Java线程池的设计与分析

最新推荐文章于 2021-02-24 10:13:54 发布

weixin_34174105

最新推荐文章于 2021-02-24 10:13:54 发布

阅读量50

点赞数

文章标签： java python

原文链接：https://my.oschina.net/chenxiaobian/blog/632882

版权

2019独角兽企业重金招聘Python工程师标准>>>

1.线程池的好处

合理利用线程池能够带来三个好处:

降低资源消耗
提高响应速度
提高线程的可管理性

2.线程池的使用

我们可以通过ThreadPoolExecutor来创建一个线程池:

new  ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, milliseconds,runnableTaskQueue, handler);

创建一个线程池需要输入几个参数:

corePoolSize - 线程池的基本大小
maximumPoolSize -线程池最大大小
keepAliveTime - 线程活动保持时间
runableTaskQueue - 任务队列

3.线程池工作原理

通过线程池的处理流程如下:

1.首先线程池判断基本线程池是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程

2.其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程

3.最后线程池判断整个线程池是否已满? 没满, 则创建一个新的工作线程来执行任务, 满了则交给饱和策略来处理任务

4.线程池的四种实现

Java通过Executors提供了四种线程池:

newCachedThreadPool 创建一个可缓存的线程池, 如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程

newCacheThreadPool源代码分析如下:

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

实现的是SynchronousQueue

newFixThreadPool: 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待

newFixThreadPool源代码:

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

newScheduledTheadPool:创建一个定长线程池, 支持定时及周期任务执行

newScheduledThreadPool源代码分析:

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

newSingleThreadPool:创建一个单线程化的线程池

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

项目中使用

public class ThreadPoolTest {

    static class ExecutePrint implements Task {

        @Override
        public String getName() {
            return "threadpool";
        }

        @Override
        public void shutdown() {

        }

        @Override
        public void run() {
            System.out.println("hello world");

        }
    }

    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(5000), new ThreadPoolExecutor.CallerRunsPolicy());
        threadPoolExecutor.submit(new ExecutePrint());
    }
}

public class ThreadPoolTest2 {

    public static void main(String[] args) {
       // ExecutorService executorService = Executors.newCachedThreadPool();
        //ExecutorService executorService = Executors.newFixedThreadPool(10);
        //ExecutorService executorService = Executors.newScheduledThreadPool(10);
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        for(int i =0; i <10;i++){
            final int index = i;
            try {
                Thread.sleep(index*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(index);
                }
            });
        }
    }
}

转载于:https://my.oschina.net/chenxiaobian/blog/632882