总结线程池

目录

一、线程池是什么？

二、线程池参数

三、线程池的拒绝策略

四、Executors 创建线程池的几种方式

4.1 newFixedThreadPool：固定线程数的线程池 

4.2 newCachedThreadPool：可缓存的线程池 

 4.3 newSingleThreadExecutor：单线程的线程池

 4.4 newScheduledThreadPool：定时线程池

 五、线程池的实现

一、线程池是什么？

线程池是一种线程管理的机制，它维护着多个可重用的线程，在需要时分配线程去处理任务。线程池包含了一个任务队列，用来存放需要执行的任务，以及一个线程集合，用来执行任务。

通过使用线程池，可以避免频繁地创建和销毁线程，从而减少了系统资源的消耗，提高了系统的性能和效率。线程池还可以控制任务的执行速度，避免因为任务量过大而导致系统崩溃的情况发生。同时，线程池也可以管理线程的数量，避免线程数量过多，导致系统资源的浪费和线程调度的效率降低。

二、线程池参数

• corePoolSize：核心线程数。

• maximumPoolSize：最大线程数。

• keepAliveTime：空闲线程存活时间。

• TimeUnit：时间单位。

• workQueue：线程池任务队列。

• ThreadFactory：创建线程的工厂。

• RejectedExecutionHandler：拒绝策略。

三、线程池的拒绝策略

• AbortPolicy(): 超过负荷, 直接抛出异常.
• CallerRunsPolicy(): 调用者负责处理
• DiscardOldestPolicy(): 丢弃队列中最老的任务.
• DiscardPolicy(): 丢弃新来的任务. 

四、Executors 创建线程池的几种方式

• newFixedThreadPool: 创建固定线程数的线程池

• newCachedThreadPool: 创建线程数目动态增长的线程池.

• newSingleThreadExecutor: 创建只包含单个线程的线程池.

• newScheduledThreadPool: 设定 延迟时间后执行命令

4.1 newFixedThreadPool：固定线程数的线程池 

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            fixedThreadPool.execute(() -> {
                System.out.println("任务：" + taskId + "，线程：" + Thread.currentThread().getName());
            });
        }
        fixedThreadPool.shutdown();
    }
}

4.2 newCachedThreadPool：可缓存的线程池 

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            cachedThreadPool.execute(() -> {
                System.out.println("任务：" + taskId + "，线程：" + Thread.currentThread().getName());
            });
        }
        cachedThreadPool.shutdown();
    }
}

 4.3 newSingleThreadExecutor：单线程的线程池

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            singleThreadExecutor.execute(() -> {
                System.out.println("任务：" + taskId + "，线程：" + Thread.currentThread().getName());
            });
        }
        singleThreadExecutor.shutdown();
    }
}

 4.4 newScheduledThreadPool：定时线程池

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);      
        scheduledThreadPool.schedule(() -> {
            System.out.println("延迟任务，线程：" + Thread.currentThread().getName());
        }, 3, TimeUnit.SECONDS);
     
        scheduledThreadPool.scheduleAtFixedRate(() -> {
            System.out.println("周期任务，线程：" + Thread.currentThread().getName());
        }, 0, 2, TimeUnit.SECONDS);
        
       scheduledThreadPool.shutdown();
    }
}

 五、线程池的实现

class MyThreadPool {
    // 阻塞队列用来存放任务.
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();

    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }

    // 此处实现一个固定线程数的线程池.
    public MyThreadPool(int n) {
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                try {
                    while (true) {
                        // 此处需要让线程内部有个 while 循环, 不停的取任务.
                        Runnable runnable = queue.take();
                        runnable.run();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }
    }
}