java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java 线程池

Java线程池由浅入深掌握到精通

作者：白杨学编程

什么是线程池？很简单，简单看名字就知道是装有线程的池子，我们可以把要执行的多线程交给线程池来处理，和连接池的概念一样，通过维护一定数量的线程池来达到多个线程的复用

1.为什么使用线程池？

反复创建线程开销大，可以复用线程池
过多的线程会占用太多的内存

解决以上问题的方法：

2.线程池的好处：

加快响应速度，提高用户体验
合理利用CPU内存
统一管理

3.线程池使用的场合

服务器接受大量请求时，使用线程池技术是非常合适的，它可以大大减少线程的创建和销毁次数，提高服务器的工作效率。在实际开发中，如果创建5个以上 的线程，那么就可以使用线程池来管理线程。

4.创建和停止线程

线程池构造方法的参数？
线程池应该手动创建和自动创建那个更好？
线程池里的线程数量设置未多少合适？
停止线程的正确方法？

线程池构造函数的参数：

线程池构造函数的参数

corePoolSize： 核心线程数
线程池在完成初始化后，默认情况下，线程池中并没有任何线程，会等到有任务到来时再去创建新的线程去执行任务。
maxPoolSize：在核心线程的基础上，额外增加的线程数的上限。

在这里插入图片描述

根据图可知添加线程的规则：

1.如果线程数小于corePoolSize，即使其他工作线程处于空闲状态，也会创建一个新线程来运行任务。
2.如果线程数等于或大于corePoolSize但少于maximumPoolSize，则将任务放入队列。
3.如果线程池已满，并且线程数小于maxPoolSize，则创建一个新线程来运行任务。
4.如果队列已满，并且线程数大于或等于maxPoolSzie，则参数拒绝该任务。

添加线程规则

添加线程判断顺序：corePoolSize——workQueue——maxPoolSize

比如线程池的核心线程是5个，最大线程池大小为10个，队列为50个。
则线程池的请求最多会创建5个，然后任务将被添加到队列中，直到达到50。队列已满时，将创建最新的线程maxPoolSize，最多达到10个，如果再来任务就直接拒绝。

keepAliveTime：如果线程池当前的线程数多于corePoolSize，那么如果多余的线程空闲时间超过keepAliveTime，那么就会终止。

ThreadFactory:
默认使用Executors.defaultThreadFactory()
创建出来的线程都在同一个线程组。
如果自己指定ThreadFactory，那么就可以改变线程名、线程组、优先级、是否是守护线程等等。

常见的3中队列类型：
直接交接：SynchronousQueue
无界队列：LinkedBlockingQueue
有界队列：ArrayBlockingQueue

线程池应该手动创建和自动创建那个更好？

手动创建好，因为这样可以明确线程池的运行规则和避开资源浪费的风险。

常见的线程池：

FixedThreadPool

在这里插入图片描述

CachedThreadPool：可缓存线程池，具有自动回收多余线程的功能

在这里插入图片描述

ScheduledThreadPool：支持定时及周期性任务执行的线程池
SingleThreadExecutor：单线程的线程池只会用唯一的工作线程来执行任务
原理和FixedThreadPool一样，但是线程数量被设为1

四种线程池的构造方法的参数：

在这里插入图片描述

阻塞队列分析：

在这里插入图片描述

5.停止线程池的方法

//演示关闭线程池
public class ShutDown {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 500; i++) {
            executorService.execute(new ShutDownTask());
        }
        Thread.sleep(1500);
//        executorService.shutdown();
//        System.out.println(executorService.isShutdown());
        executorService.awaitTermination(3L, TimeUnit.SECONDS);
    }
}
class ShutDownTask implements Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6.暂停和恢复线程池

//暂停线程池
 pauseAbleThreadPool.pause();
 //恢复线程池
 pauseAbleThreadPool.resume();

代码实现：

//演示每个任务执行前后放钩子函数
public class PauseAbleThreadPool extends ThreadPoolExecutor {
    private final ReentrantLock lock = new ReentrantLock();
    private Condition unpaused = lock.newCondition();
    private boolean isPaused;

    public PauseAbleThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public PauseAbleThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }

    public PauseAbleThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    public PauseAbleThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        lock.lock();
        try {
            while (isPaused) {
                unpaused.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    private void pause() {
        lock.lock();
        try {
            isPaused = true;
        } finally {
            lock.unlock();
        }
    }

    public void resume() {
        lock.lock();
        try {
            isPaused = false;
            unpaused.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        PauseAbleThreadPool pauseAbleThreadPool = new PauseAbleThreadPool(10, 20, 10l, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我被执行");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 10000; i++) {
            pauseAbleThreadPool.execute(runnable);
        }
        Thread.sleep(1500);
        pauseAbleThreadPool.pause();
        System.out.println("线程池被暂停了");
        Thread.sleep(1500);
        pauseAbleThreadPool.resume();
        System.out.println("线程池被恢复了");

    }
}

实现原理及源码分析：
线程池的组成部分：

在这里插入图片描述

到此这篇关于Java线程池由浅入深掌握到精通的文章就介绍到这了,更多相关Java 线程池内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文