Java多线程

最新推荐文章于 2025-03-14 20:22:19 发布
最新推荐文章于 2025-03-14 20:22:19 发布
阅读量720 收藏 20
点赞数 24
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_46335449/article/details/145325179
版权

Java多线程

现在多线程有比较多的方法实现。目前在实习期间这边主要是采用线程池的方法来实现。

多线程是 Java 中非常重要的一个特性，它允许程序同时执行多个任务，从而提高程序的效率和响应能力。在本文中，我们将详细介绍多线程的概念、优势、实现方式以及相关的高级并发工具和应用场景。

1. 什么是多线程

多线程是指在一个程序中同时运行多个线程，每个线程可以看作是一个独立的执行路径。线程是操作系统调度的最小单位，而一个进程可以包含多个线程。

在 Java 中，线程由 Thread 类或实现 Runnable 接口来表示。多线程的核心思想是并发执行任务，从而提高程序的性能。

2. 多线程的优势

  1. 提高资源利用率：多线程可以充分利用多核 CPU 的计算能力，提升程序的执行效率。
  2. 提高程序响应性：在 GUI 应用中，主线程可以处理用户交互，后台线程可以执行耗时任务，避免界面卡顿。
  3. 简化程序设计：将复杂的任务分解为多个线程独立执行，逻辑更清晰。
  4. 支持异步操作：多线程可以实现异步任务处理，避免阻塞主线程。

3. 创建和管理线程

在 Java 中，创建线程有以下几种方式：

3.1 继承 Thread 类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running...");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

3.2 实现 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running...");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

3.3 使用线程池

线程池是管理线程的高级方式，推荐在实际开发中使用。线程池（Thread Pool）是一种多线程管理机制，它通过提前创建一组线程来处理任务，避免了频繁创建和销毁线程的开销。线程池可以复用线程，提升程序性能，并提供更好的资源管理。

在 Java 中，线程池由 java.util.concurrent 包中的 Executor 框架提供，主要通过 ExecutorService 接口和其实现类来使用。

为什么使用线程池？

  1. 减少资源消耗：线程池通过复用线程，避免了频繁创建和销毁线程的开销。
  2. 提高响应速度：任务到达时可以直接复用已有线程，无需等待新线程创建。
  3. 提高线程管理能力：线程池可以限制线程的数量，避免系统资源耗尽。
  4. 简化并发编程：线程池提供了方便的 API，简化了多线程任务的管理。

线程池的常见类型

Java 提供了几个常见的线程池实现，可以通过 Executors 工厂类创建：

  1. newFixedThreadPool(int nThreads)

    • 创建一个固定大小的线程池。

    • 适用于需要限制线程数量的场景。

    • 示例：

      ExecutorService executor = Executors.newFixedThreadPool(3);

  2. newCachedThreadPool()

    • 创建一个可缓存的线程池，线程数量不固定，空闲线程会被回收。

    • 适用于短时间内需要大量线程的场景。

    • 示例：

      ExecutorService executor = Executors.newCachedThreadPool();

  3. newSingleThreadExecutor()

    • 创建一个单线程的线程池，所有任务按顺序执行。

    • 适用于需要顺序执行任务的场景。

    • 示例：

      ExecutorService executor = Executors.newSingleThreadExecutor();

  4. newScheduledThreadPool(int corePoolSize)

    • 创建一个支持定时和周期性任务的线程池。

    • 适用于需要定时任务的场景。

    • 示例：

      ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);

线程池的使用方法

以下是线程池的常见使用步骤：

  1. 创建线程池：通过 Executors 工厂类创建线程池。
  2. 提交任务：使用 execute() 或 submit() 方法提交任务。
  3. 关闭线程池：使用 shutdown() 或 shutdownNow() 方法关闭线程池。
示例：固定大小线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为3的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 提交5个任务到线程池
        for (int i = 1; i <= 5; i++) {
            int taskId = i;
            executor.execute(() -> {
                System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 关闭线程池
        executor.shutdown();
        System.out.println("All tasks submitted.");
    }
}

输出示例：

Task 1 is running on thread: pool-1-thread-1
Task 2 is running on thread: pool-1-thread-2
Task 3 is running on thread: pool-1-thread-3
Task 4 is running on thread: pool-1-thread-1
Task 5 is running on thread: pool-1-thread-2
All tasks submitted.

使用 submit() 和 Future 获取任务结果

线程池的 submit() 方法可以返回一个 Future 对象，用于获取任务的执行结果或捕获异常。

示例：使用 submit() 和 Future
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交任务并获取 Future 对象
        Future<Integer> future = executor.submit(() -> {
            System.out.println("Task is running on thread: " + Thread.currentThread().getName());
            Thread.sleep(2000); // 模拟任务执行时间
            return 42; // 返回结果
        });

        try {
            // 获取任务结果
            Integer result = future.get();
            System.out.println("Task result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

定时任务线程池

ScheduledExecutorService 提供了定时和周期性任务的支持。

示例：定时任务
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

        // 定时任务：延迟2秒后执行
        scheduler.schedule(() -> {
            System.out.println("Task executed after 2 seconds.");
        }, 2, TimeUnit.SECONDS);

        // 周期性任务：延迟1秒后每3秒执行一次
        scheduler.scheduleAtFixedRate(() -> {
            System.out.println("Periodic task executed at: " + System.currentTimeMillis());
        }, 1, 3, TimeUnit.SECONDS);

        // 运行10秒后关闭线程池
        scheduler.schedule(() -> {
            scheduler.shutdown();
            System.out.println("Scheduler shutdown.");
        }, 10, TimeUnit.SECONDS);
    }
}

线程池的注意事项

  1. 线程池大小的选择：
    • 线程池大小应根据任务的性质和系统资源来选择。
    • CPU 密集型任务：线程池大小应接近 CPU 核心数。
    • I/O 密集型任务：线程池大小可以大于 CPU 核心数。
  2. 避免线程泄漏：
    • 使用完线程池后，必须调用 shutdown() 方法关闭线程池。
    • 如果不关闭线程池，程序可能无法正常退出。
  3. 任务队列的使用：
    • 线程池内部使用任务队列存储待执行任务。
    • 如果任务过多，可能导致队列溢出。
  4. 异常处理：
    • 在线程池中，未捕获的异常可能导致线程终止。
    • 推荐在任务中使用 try-catch 捕获异常。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executor.execute(() -> System.out.println("Thread is running..."));
        }
        executor.shutdown();
    }
}

4. 线程的生命周期

线程的生命周期包括以下几个状态：

  1. 新建（New）：线程对象被创建，但未调用 start() 方法。
  2. 就绪（Runnable）：调用 start() 方法后，线程进入就绪状态，等待 CPU 调度。
  3. 运行（Running）：线程被 CPU 调度后开始执行。
  4. 阻塞（Blocked）：线程因等待资源或锁而暂停执行。
  5. 终止（Terminated）：线程执行完毕或被强制终止。

5. 线程同步和互斥

在多线程环境中，多个线程可能会同时访问共享资源，导致数据不一致的问题。为了解决这个问题，可以使用线程同步和互斥机制。

5.1 使用 synchronized 关键字

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

5.2 使用 ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

6. 线程调度和控制

线程调度是指操作系统根据一定的算法分配 CPU 时间片给线程。Java 提供了一些方法来控制线程的执行：

  • sleep(long millis)：让线程休眠指定时间。
  • join()：等待线程执行完毕。
  • yield()：让出当前线程的 CPU 时间片。
  • setPriority(int priority)：设置线程优先级。

示例：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread is running...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        thread.join(); // 等待线程执行完毕
        System.out.println("Main thread finished.");
    }
}

7. 线程安全和共享资源

线程安全是指多个线程访问共享资源时，程序的行为是可预测的。常见的线程安全问题包括：

  1. 数据竞争：多个线程同时修改共享变量。
  2. 死锁：多个线程相互等待对方释放资源。

解决方法：

  • 使用 synchronized 或 Lock 保护共享资源。
  • 避免嵌套锁，减少死锁风险。
  • 使用线程安全的集合类，如 ConcurrentHashMap。

8. 并发编程实践

在实际开发中，以下是一些常见的并发编程实践：

  1. 生产者-消费者模型
    使用阻塞队列实现生产者和消费者之间的通信。

    import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumer {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int value = queue.take();
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}

  2. 线程池的使用
    使用线程池管理线程，避免频繁创建和销毁线程。

9. Java 高级并发工具

Java 提供了一些高级并发工具，简化了多线程编程：

  1. CountDownLatch：用于等待多个线程完成任务。
  2. CyclicBarrier：用于让多个线程在某个点上同步。
  3. Semaphore：用于控制同时访问资源的线程数量。
  4. ExecutorService：线程池管理工具。
  5. ForkJoinPool：用于分治任务的线程池。

示例：CountDownLatch

import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " finished.");
                latch.countDown();
            }).start();
        }

        latch.await(); // 等待所有线程完成
        System.out.println("All threads finished.");
    }
}

10. 多线程应用场景

  1. Web 服务器：处理多个用户请求。
  2. 文件处理：同时读取和写入多个文件。
  3. 游戏开发：处理玩家输入、渲染画面和后台逻辑。
  4. 数据处理：并行处理大数据任务。
  5. 爬虫程序：同时抓取多个网页。
Phil_jida
关注
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 9万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
多线程
zm13319249591的博客
02-26 284
一.进程说到多线程，线程是依赖于进程存在的，所以我们首先应该想到是进程。A：什么是进程？答：进程就是正在运行的应用程序，进程与线程的区别就是，进程是系统进行资源分配和调用的最小单位。而线程是程序运行的最小单位，即使用cpu的最小单位。一旦进程被创建，就会有自己的内存空间和系统资源。B：多进程的意义？答：如果一个计算机是单进程计算机，那么这个计算机只能处理一个进程，但是实际生活中我们通常需要计算同时...
13.1 多线程的概念13.2 多线程实现13.3 线程的生命周期
09-05 533
13.1 多线程的概念 一、程序与进程 1、程序：一段静态的代码。 2、进程：程序的一次动态执行过程，它对应从代码加载、执行到执行完毕的一个完整过程。 3、进程也称任务，支持多个进程同时执行的OS就被称为多进程OS或多任务OS。 二、进程与线程 在一个程序内部也可以实
多线程(超详细) (ε≡٩(๑＞₃＜)۶ 一心向学)
最新发布
2303_80388948的博客
03-14 1872
总结： 进程与线程的区别 • 进程是包含线程的，每个进程至少有一个线程存在，即为主线程； • 进程是系统进行资源分配和调度的一个独立单位，线程是程序执行的最小单位； • 进程有自己的内存地址空间，线程值独享指令流执行的必要资源，如寄存器和栈； 线程安全问题 产生原因 1、「根本」操作系统对于线程的调度是随机的，抢占式执行 2、多个线程同时修改同一个变量 3、修改操作，不是原子的 4、内存可见性问题，引起的线程不安全问题 5、指令重排序，引起的线程不安全问题
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
线程状态，线程礼让，线程方法，线程休眠，线程停止，线程优先级
weixin_44823472的博客
07-12 331
线程的状态 1、新建状态 用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态（runnable）。 注意：不能对已经启动的线程再次调用start()方法，否则会出现Java.lang.IllegalThreadStateException异常。 2、就绪状态 处于就绪状态的线程已经具备了运行条...
Java多线程编程详解
Java多线程机制提供了强大的并发能力，允许开发者编写高效的并发程序。理解和掌握这些知识点对于Java开发人员来说至关重要，有助于在实际项目中处理复杂的并发问题，提升程序的性能和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值