Java-线程池实现

线程池参数概念：

1.线程池可立即运行的最大线程数 即maximumPoolSize 参数。

2.线程池能包含的最大线程数 = 可立即运行的最大线程数 + 线程队列大小
 (一部分立即运行，一部分装队列里等待)

3.核心线程数可理解为建议值，即建议使用的线程数，或者依据CPU核数

4.add，offer，put三种添加线程到队列的方法只在队列满的时候有区别，
  add为抛异常，offer返回boolean值，put直到添加成功为止。

5.remove，poll， take三种移除队列中线程的方法只在队列为空的时候有区别，
  remove为抛异常，poll为返回boolean值， take等待直到有线程可以被移除。

线程池排除策略：

1.  如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，
    而不进行排队。而不进行排队。

2.  如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，
    而不添加新的线程。而不添加新的线程。

3.  如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，
    在这种情况下，任务将被拒绝。在这种情况下，任务将被拒绝。

最基础的ThreadPoolExecutor实现：

import org.junit.Test;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool {

    @Test
    public void Test(){
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                5,//核心池线程数
                10,//线程池最大线程数
                200,//超过核心池线程数的线程的空闲最大等待时间，过了就销毁
                TimeUnit.SECONDS,//等待时间的单位
                new ArrayBlockingQueue<Runnable>(5)//excute提交的Runnable任务队列
        );

        for(int i = 0; i < 15; i++){
            MyTask task = new MyTask(i);
            pool.execute(task);
            System.out.println("线程池中线程数目："+pool.getPoolSize());
            System.out.println("缓冲队列中任务数目："+pool.getQueue().size());
//            System.out.println("已完成任务数目："+pool.getCompletedTaskCount());

        }
        System.out.println("已完成任务数目："+pool.getCompletedTaskCount());
        pool.shutdown();
    }

    class MyTask implements Runnable{

        private int i;

        public MyTask(int i){
            this.i = i;
        }

        @Override
        public void run() {
            try {
                System.out.println("task: "+i);
                Thread.currentThread().sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

封装好的各类线程池实现：
  1.newCachedThreadPool
  2.newFixedThreadPool
  3.newSingleThreadExecutor
  4.newScheduledThreadPool

  5.实现：
    //建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，
    // 若无可回收，则新建线程。
    public ExecutorService getCachedThreadPool(){
        ExecutorService executor = Executors.newCachedThreadPool();
        return executor;
    }

    //创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
    public ExecutorService getFixedThreadPool(int nThreads){
        return Executors.newFixedThreadPool(nThreads);
    }


    //创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
    // 保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
    public ExecutorService getSingleThreadPool(){
        return Executors.newSingleThreadExecutor();
    }


    //创建一个定长线程池，支持定时及周期性任务执行。
    public ExecutorService getSchelduledThreadPool(int corePoolSize){
        return Executors.newScheduledThreadPool(corePoolSize);
    }

参考：https://www.cnblogs.com/dolphin0520/p/3932921.html
参考：https://blog.csdn.net/shixing_11/article/details/7109471

猜你喜欢