java线程安全之Executor框架及自定义线程池(十五)

Executor框架及自定义线程池

Executor框架

概念理解

       为了更好的控制多线程,JDK提供了一套线程框架Executor,帮助开发人员有效地进行线程控制。它们都在Java.util.concurrent包中,是JDK并发包的核心。其中有一个比较重要的类:Executors,他扮演这线程工厂的角色,我们通过Executors可以创建特定功能的线程池。Executors创建线程池方法:

newFixedThreadPool()方法,该方法返回一个固定数量的线程池,该方法的线程数始终不变,当有一个任务提交时,若线程池中空闲,则立即执行,若没有,则会被暫缓在一个任务队列中等待有空闲的线程去执行·

具体源码如下:

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,   //初始化多少个线程  /  最大线程
             0L, TimeUnit.MILLISECONDS,   //这两个参数一起用的等待的时间 这里为 0
             new LinkedBlockingQueue());  //无界队列  如果这个任务没有空闲线程就会 缓存到这个线程中
}

newSingleThreadExecutor()方法,创建一个线程的程池,若空闲则执行,若没有空闲线程则暂缓在任务列队中。

具体源码如下:

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

newCachedThreadPool()方法,返回一个可以根据实际情况调整线程个数的线程池,不限制最大线程数量,若用空闲的线程则执行任务,若无任务则不创建线程。并且每一个空闲线程会在60秒后自动回收。

具体源码如下:

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,  //如果有一个线程 来60s了 还是没有另一个线程进来 则这个现场将会被回收 ,60s之内有线程进来,则不被回收
                                      new SynchronousQueue()); //来一个任务就直接提交给 SynchronousQueue()
    }

newScheduledThreadPool()方法,该方法返回一个SchededExecutorSrevice对象,但该线程池可以指定线程的数量。

具体源码如下:

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

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
}

自定义线程池

若Executors工厂类无法满足我们的需求,可以自己去创建自定义的线程池,其实 ecuto工厂类里面的创建线程方法其内部实现均是用了ThreadPoolExecutor这个类,这个类可以自定义线程。构造方法如下:

public ThreadPooIExecutor(
    int corePoolSize, 
    int maximumPoolSize, 
    long keepAIiveTime ,
    TimeUnit unit,
    BlockingQueue workQueue,
    ThreadFactory threadFactory, 
    RejectedExecutionHandler handler) {……}

参数说明:

corePoolSize:核心线程池的大小,在线程池被创建之后,其实里面是没有线程的。(当然,调用prestartAllCoreThreads()或者prestartCoreThread()方法会预创建线程,而不用等着任务的到来)。当有任务进来的时候,才会创建线程。当线程池中的线程数量达到corePoolSize之后,就把任务放到 缓存队列当中。(就是 workQueue)。

maximumPoolSize:最大线程数量是多少。它标志着这个线程池的最大线程数量。如果没有最大数量,当创建的线程数量达到了 某个极限值,到最后内存肯定就爆掉了。

keepAliveTime:当线程没有任务时,最多保持的时间,超过这个时间就被终止了。默认情况下,只有 线程池中线程数量 大于 corePoolSize时,keepAliveTime值才会起作用。也就说说,只有在线程池线程数量超出corePoolSize了。我们才会把超时的空闲线程给停止掉。否则就保持线程池中有 corePoolSize 个线程就可以了。

workQueue:用来存储待执行任务的队列,不同的线程池它的队列实现方式不同(因为这关系到排队策略的问题)比如有以下几种

   ArrayBlockingQueue:基于数组的队列,创建时需要指定大小。
   LinkedBlockingQueue:基于链表的队列,如果没有指定大小,则默认值是 Integer.MAX_VALUE。(newFixedThreadPool和newSingleThreadExecutor使用的就是这种队列)。
   SynchronousQueue:这种队列比较特殊,因为不排队就直接创建新线程把任务提交了。(newCachedThreadPool使用的就是这种队列)。

Unit:参数keepAliveTime的时间单位。

threadFactory:线程工厂,用来创建线程。

Handler:拒绝执行任务时的策略,一般来讲有以下四种策略,

(1) ThreadPoolExecutor.AbortPolicy 丢弃任务,并抛出 RejectedExecutionException 异常。
(2) ThreadPoolExecutor.CallerRunsPolicy:该任务被线程池拒绝,由调用 execute方法的线程执行该任务。
(3) ThreadPoolExecutor.DiscardOldestPolicy : 抛弃队列最前面的任务,然后重新尝试执行任务。
(4) ThreadPoolExecutor.DiscardPolicy,丢弃任务,不过也不抛出异常。

自定义线程池使用详细

这个构造方法对于队列是什么类型的比较关键:

在使用有界队列时,若有新的任务需要执行,如果线程池实际线程数小于corePooISize,则优先创建线程,若大于corePooISize,则会将任务入队列,若队列已满,则在总线程数不大于
MaximunPoolSize的前提下,创建新的线程,若线程数大于MaximunPoolSize,则执行拒绝策略,或其他自定义方式。

无界的任务队列时,LinkedBIockinaQueue。与有界队列相比,除非系统资源耗尽,否则无界的任务队列不存在任务入队失败的情况。当有新任务到来,系统的线程数小于corePooISize时,则新建线程执行任务。当达到corePooISize后,就不会继续增加。若后续仍有新的任务加入,而没有空闲的线程资源,则任务接进入队列等待。若任务创建和处理的速度差异很大,无界队列会保持快速增长,直到耗尽系统内存。

JDK拒绝策略:
AbortPolicy:直接出异常组织系统正常工作

CallerRunPolicy:只要线程池未关团,该策略直接在调用者线程中,运行当前被丢弃的任务

DiscardOldestPolicy:丢弃最老的一个请隶,尝试再次提交当前任务

DiscardPolicy:丢弃无法处理的任务,不给予任何处理,如果需要自定义拒绝簽略可以实现RejectdExceutionHandler接口。

有界队列案例1:

public class UseThreadPoolExecutor2 implements Runnable{
    private static AtomicInteger count = new AtomicInteger(0);

    @Override
    public void run() {
        try {
            int temp = count.incrementAndGet();
            System.out.println("任务" + temp);
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception{
        //System.out.println(Runtime.getRuntime().availableProcessors());
        BlockingQueue queue = 
                //new LinkedBlockingQueue();  //这个是无界的
                new ArrayBlockingQueue(10);
        ExecutorService executor  = new ThreadPoolExecutor(
                    5,      //core
                    10,     //max
                    120L,   //2fenzhong
                    TimeUnit.SECONDS,
                    queue);

        for(int i = 0 ; i < 20; i++){
            executor.execute(new UseThreadPoolExecutor2());
        }
        Thread.sleep(1000);
        System.out.println("queue size:" + queue.size());       //10
        Thread.sleep(2000);
    }

}

打印结果:

任务2
任务1
任务3
任务4
任务5
queue size:5
任务6
任务10
任务9
任务8
任务7

有界队列案例2:

MyTask.java

public class MyTask implements Runnable {

    private int taskId;
    private String taskName;

    public MyTask(int taskId, String taskName){
        this.taskId = taskId;
        this.taskName = taskName;
    }

    public int getTaskId() {
        return taskId;
    }

    public void setTaskId(int taskId) {
        this.taskId = taskId;
    }

    public String getTaskName() {
        return taskName;
    }

    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        try {
            System.out.println("run taskId =" + this.taskId);
            Thread.sleep(3*1000);
            //System.out.println("end taskId =" + this.taskId);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }       
    }

    public String toString(){
        return Integer.toString(this.taskId);
    }

}

UseThreadPoolExecutor1.java

public class UseThreadPoolExecutor1 {


    public static void main(String[] args) {
        /**
         * 在使用有界队列时,若有新的任务需要执行,如果线程池实际线程数小于corePoolSize,则优先创建线程,
         * 若大于corePoolSize,则会将任务加入队列,
         * 若队列已满,则在总线程数不大于maximumPoolSize的前提下,创建新的线程,
         * 若线程数大于maximumPoolSize,则执行拒绝策略。或其他自定义方式。
         * 
         */ 
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,              //coreSize
                2,              //MaxSize
                60,             //60
                TimeUnit.SECONDS, 
                new ArrayBlockingQueue(3)  //指定一种队列 (有界队列 先进先出)
                );

        MyTask mt1 = new MyTask(1, "任务1");
        MyTask mt2 = new MyTask(2, "任务2");
        MyTask mt3 = new MyTask(3, "任务3");
        MyTask mt4 = new MyTask(4, "任务4");
        MyTask mt5 = new MyTask(5, "任务5");
        MyTask mt6 = new MyTask(6, "任务6");

        pool.execute(mt1);
        pool.execute(mt2);
        pool.execute(mt3);
        pool.execute(mt4);
        pool.execute(mt5);
        pool.execute(mt6);

        //关闭
        pool.shutdown();

    }
}

打印结果:

run taskId =1
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task 6 rejected from java.util.concurrent.ThreadPoolExecutor@6d6f6e28[Running, pool size = 2, active threads = 2, queued tasks = 3, completed tasks = 0]
run taskId =5
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at com.bjsxt.height.concurrent018.UseThreadPoolExecutor1.main(UseThreadPoolExecutor1.java:48)
run taskId =2
run taskId =3
run taskId =4

从打印结果可以看出线程6并没有执行,是因为配置连接池最大链接数为2,所以才报错了,如果你把2改成3这时候就不会出现错了。

既然出现错了那就说一下JDK拒绝策略(详细说明在前面有,在这说一下自定义的拒绝方式):

上面这个错属于jdk中的AbortPolicy这种策略,抛出异常系统还会继续工作(出错时jdk默认的拒绝策略)。

下面说一下自定义的拒绝方式需要,实现RejectdExceutionHandler接口

MyRejected.java


public class MyRejected implements RejectedExecutionHandler{


    public MyRejected(){
    }

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("自定义处理..");
        System.out.println("当前被拒绝任务为:" + r.toString());


    }

}

UseThreadPoolExecutor1.java

public class UseThreadPoolExecutor1 {


    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,              //coreSize
                2,              //MaxSize
                60,             //60
                TimeUnit.SECONDS, 
                new ArrayBlockingQueue(3)  //指定一种队列 (有界队列 先进先出)
                , new MyRejected()  //自定义拒绝方式
                //, new DiscardOldestPolicy()  //丢弃最老的一个任务,执行新的任务
                );

        MyTask mt1 = new MyTask(1, "任务1");
        MyTask mt2 = new MyTask(2, "任务2");
        MyTask mt3 = new MyTask(3, "任务3");
        MyTask mt4 = new MyTask(4, "任务4");
        MyTask mt5 = new MyTask(5, "任务5");
        MyTask mt6 = new MyTask(6, "任务6");

        pool.execute(mt1);
        pool.execute(mt2);
        pool.execute(mt3);
        pool.execute(mt4);
        pool.execute(mt5);
        pool.execute(mt6);

        pool.shutdown();

    }
}

打印结果:

自定义处理..
run taskId =1
run taskId =5
当前被拒绝任务为:6
run taskId =2
run taskId =3
run taskId =4

源代码:https://github.com/hfbin/Thread_Socket/tree/master/Thread/concurrent018

你可能感兴趣的:(java,线程,线程安全)