多线程 - 为什么要用线程池

谁践踏了优雅 2023-09-26 19:21 71阅读 0赞

线程池是一种管理和重用线程的机制，它可以减少应用程序中创建和销毁线程的开销，并提高线程的利用率。以下是一些使用线程池的好处：

## 降低系统负载： ##

线程池可以限制同时执行的线程数量，避免系统因创建大量线程而导致的负载过高。

## 提高系统性能： ##

线程池可以重用已经创建的线程，避免重复创建线程和线程销毁的开销，从而提高系统的性能和响应速度。

## 更好的资源管理： ##

线程池可以统一管理线程的创建、销毁和调度，从而更好地利用系统资源。

## 更好的任务处理： ##

线程池可以提供更好的任务处理方式，例如任务队列、优先级设置等。

## 更好的稳定性： ##

线程池可以提供更好的稳定性和可靠性，例如在线程异常退出时，线程池可以自动重启线程，避免程序崩溃。

总之，线程池可以提高系统的性能、可靠性和稳定性，减少系统资源的浪费，是一种非常有效的线程管理机制。

## 在Java项目中，线程池可以通过Java标准库中的Executor框架来实现 ##

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ThreadPoolExample {
        
        public static void main(String[] args) {
        
            // 创建一个线程池，包含5个线程
            ExecutorService executor = Executors.newFixedThreadPool(5);
    
            // 提交10个任务给线程池处理
            for (int i = 0; i < 10; i++) {
        
                Runnable worker = new WorkerThread("" + i);
                executor.execute(worker);
            }
    
            // 关闭线程池
            executor.shutdown();
            while (!executor.isTerminated()) {
        
            }
    
            System.out.println("所有任务执行完毕");
        }
    }
    
    class WorkerThread implements Runnable {
        
        private String message;
    
        public WorkerThread(String s) {
        
            this.message = s;
        }
        
    	@Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName() + " 开始处理 " + message);
            processMessage();
            System.out.println(Thread.currentThread().getName() + " 处理完成 " + message);
        }
    
        private void processMessage() {
        
            try {
        
                Thread.sleep(2000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

上面的示例中，我们首先创建了一个包含5个线程的线程池，然后提交10个任务给线程池处理。每个任务是一个实现了Runnable接口的WorkerThread对象，它包含一个需要处理的消息，以及在处理过程中需要执行的一些操作。在任务提交完毕后，我们关闭了线程池，并等待所有任务执行完毕。最后，我们输出一个提示信息，表示所有任务已经执行完毕。

## 除了使用Executors工具类提供的线程池方法外，还可以使用Java并发包（java.util.concurrent）中的ThreadPoolExecutor类来自定义线程池的行为 ##

import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class ThreadPoolExample2 {
        
        public static void main(String[] args) {
        
            // 创建一个阻塞队列
            BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(10);
    
            // 创建一个自定义线程池
            ThreadPoolExecutor executor = new ThreadPoolExecutor(
                    5,   // 核心线程数
                    10,  // 最大线程数
                    1,   // 线程空闲时间
                    TimeUnit.SECONDS,  // 空闲时间单位
                    queue  // 任务队列
            );
    
            // 提交20个任务给线程池处理
            for (int i = 0; i < 20; i++) {
        
                Runnable worker = new WorkerThread2("" + i);
                executor.execute(worker);
            }
    
            // 关闭线程池
            executor.shutdown();
            while (!executor.isTerminated()) {
        
            }
    
            System.out.println("所有任务执行完毕");
        }
    }
    
    class WorkerThread2 implements Runnable {
        
        private String message;
    
        public WorkerThread2(String s) {
        
            this.message = s;
        }
    
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName() + " 开始处理 " + message);
            processMessage();
            System.out.println(Thread.currentThread().getName() + " 处理完成 " + message);
        }
    
        private void processMessage() {
        
            try {
        
                Thread.sleep(2000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

上面的示例中，我们使用ThreadPoolExecutor类来创建一个自定义的线程池。我们指定了线程池的核心线程数为5，最大线程数为10，空闲时间为1秒，任务队列为一个容量为10的阻塞队列。然后我们提交20个任务给线程池处理，最后关闭线程池。该示例与前面使用Executors创建线程池的示例效果相同，但更灵活，因为它允许我们更好地控制线程池的行为。