多线程编程(六)-Executor与ThreadPoolExecutor的使用

• 使用Executors工厂类创建线程池

　　　　1、使用newCachedThreadPool()方法创建无界线程池

　　　　　　newCachedThreadPool()方法创建的是无界线程池，可以进行线程自动回收，此类线程池中存放线程个数理论值为Integer.MAX_VALUE最大值。

package com.wjg.unit4_2_2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        Run run = new Run();
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            executorService.execute(run.new MyRunnable(" "+(i+1)));
        }
        Thread.sleep(3000);
        System.out.println();
        System.out.println();
        for (int i = 0; i < 5; i++) {
            executorService.execute(run.new MyRunnable(" "+(i+1)));
        }
    }
    
    
    public class MyRunnable implements Runnable{
        private String username;
        
        public MyRunnable(String username) {
            this.username = username;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" username="+username+" begin "+System.currentTimeMillis());
            System.out.println(Thread.currentThread().getName()+" username="+username+" end   "+System.currentTimeMillis());
        }
        
    }
}

执行结果：

pool-1-thread-1 username= 1 begin 1488268086641

pool-1-thread-3 username= 3 begin 1488268086641

pool-1-thread-2 username= 2 begin 1488268086641

pool-1-thread-2 username= 2 end   1488268086641

pool-1-thread-4 username= 4 begin 1488268086642

pool-1-thread-4 username= 4 end   1488268086642

pool-1-thread-3 username= 3 end   1488268086641

pool-1-thread-1 username= 1 end   1488268086641

pool-1-thread-5 username= 5 begin 1488268086642

pool-1-thread-5 username= 5 end   1488268086642

 

 

pool-1-thread-5 username= 1 begin 1488268089647

pool-1-thread-3 username= 3 begin 1488268089648

pool-1-thread-4 username= 4 begin 1488268089648

pool-1-thread-1 username= 2 begin 1488268089647

pool-1-thread-1 username= 2 end   1488268089648

pool-1-thread-4 username= 4 end   1488268089648

pool-1-thread-3 username= 3 end   1488268089648

pool-1-thread-2 username= 5 begin 1488268089648

pool-1-thread-2 username= 5 end   1488268089648

pool-1-thread-5 username= 1 end   1488268089648

 

通过线程的名字，可以看出来线程是从池中取出来的，是可以复用的。

　　　　2、使用newCachedThreadPool(ThreadFactory)定制线程工厂

　　　　　　构造函数ThreadFactory是实现定制Thread的作用，具体可以看下面的例子。

package com.wjg.unit4_2_3;

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class Run {
    public static void main(String[] args) {
        Run run = new Run();
        MyThreadFactory factory = run.new MyThreadFactory();
        ExecutorService executorService = Executors.newCachedThreadPool(factory);
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                System.out.println("当前线程的自定义名称为："+ Thread.currentThread().getName());
            }
        });
    }
    
    
    public class MyThreadFactory implements ThreadFactory{

        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("自定义名称："+new Date());
            return thread;
        }
        
    }
}

执行结果：

当前线程的自定义名称为：自定义名称：Tue Feb 28 15:58:13 CST 2017

　　　　3、使用newFixedThreadPool(int) 方法创建有界线程池

　　　　　　此方法创建的是有界线程池，也就是池中的线程的个数可以指定最大值。

package com.wjg.unit4_2_4;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Run {
    public static void main(String[] args) {
        Run run = new Run();
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.execute(run.new MyRunnable(" "+(i+1)));
        }
    }
    
    public class MyRunnable implements Runnable{
        private String username;
        
        public MyRunnable(String username) {
            this.username = username;
        }


        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" username="+username+" begin "+System.currentTimeMillis());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" username="+username+" end   "+System.currentTimeMillis());
        }
        
    }
}

执行结果：

pool-1-thread-1 username= 1 begin 1488269132995

pool-1-thread-3 username= 3 begin 1488269132995

pool-1-thread-2 username= 2 begin 1488269132995

pool-1-thread-2 username= 2 end   1488269136000

pool-1-thread-3 username= 3 end   1488269136000

pool-1-thread-2 username= 4 begin 1488269136000

pool-1-thread-3 username= 5 begin 1488269136000

pool-1-thread-1 username= 1 end   1488269136000

pool-1-thread-2 username= 4 end   1488269139002

pool-1-thread-3 username= 5 end   1488269139002

通过执行结果可以看出，线程池中的线程最大数量为3。

　　　　4、使用newSingleThreadExecutor()方法创建单一线程池

　　　　　　此方法可以创建单一线程池，线程池里只有一个线程，单一线程池可以实现以队列的方式来执行任务。

package com.wjg.unit4_2_5;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Run {
    public static void main(String[] args) {
        Run run = new Run();
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            executorService.execute(run.new MyRunnable(" "+(i+1)));
        }
    }
    
    
    public class MyRunnable implements Runnable{
        private String username;
        
        public MyRunnable(String username) {
            this.username = username;
        }


        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" username="+username+" begin "+System.currentTimeMillis());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" username="+username+" end   "+System.currentTimeMillis());
        }
        
    }
}

执行结果：

pool-1-thread-1 username= 1 begin 1488269392403

pool-1-thread-1 username= 1 end   1488269395409

pool-1-thread-1 username= 2 begin 1488269395409

pool-1-thread-1 username= 2 end   1488269398412

pool-1-thread-1 username= 3 begin 1488269398413

pool-1-thread-1 username= 3 end   1488269401418

pool-1-thread-1 username= 4 begin 1488269401418

pool-1-thread-1 username= 4 end   1488269404422

pool-1-thread-1 username= 5 begin 1488269404422

pool-1-thread-1 username= 5 end   1488269407423

 

由执行结果的线程名字可以看出，线程池中只有一个线程。

• ThreadPoolExecutor的使用

　　　　类ThreadPoolExecutor可以非常方便的创建线程池对象。

　　　　常用的构造方法有ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue)

　　　　参数解释如下：

　　　　corePoolSize:池中所保存的线程数，包括空闲线程数，也就是核心池的大小。

　　　　maximumPoolSize:池中允许的最大线程数

　　　　keepAliveTime:当线程数量大于corePoolSize值时，在没有超过指定的时间内是不从线程池中将空闲线程删除的，如果超过此时间，则删除。

　　　　unit:keepAliveTime参数的时间单位。

　　　　workQueue：执行前用于保持任务的队列。此队列仅保存由execute方法提交的Runnable任务。

　　　　为了更好地理解这些参数在使用上的一些关系，可以将它们进行详细化的注释：

　　　　（1）A代表execute（runnable）欲执行的runnable的数量；

　　　　（2）B代表corePoolSize；

　　　　（3）C代表maximumPoolSize；

　　　　（4）D代表A-B(假设A>=B)；

　　　　（5）E代表newLinkedBlockingDeque<Runnable>()队列，无构造函数。

　　　　（6）F代表SynchronousQueue队列；

　　　　（7）G代表keepAliveTime；

　　　　在使用线程池的过程下，会出现以下的集中情况：

　　　　（1）如果A<=B,那么马上创建线程运行这个任务，并不放入扩展队列Queue中，其他参数功能忽略；

　　　　（2）如果A>B&&A<=C&&E,则C和G参数忽略，并把D放入E中等待被执行；

　　　　（3）如果A>B&&A<=C&&F,则C和G参数有效，并且马上创建线程运行这些任务，而不把D放入F中，D执行完任务后在指定时间后发生超时时将D进行清除。

　　　　（4）如果A>B&&A>C&&E,则C和G参数忽略，并把D放入E中等待被执行；

　　　　（5）如果A>B&&A>C&&F,则处理C的任务，其他任务则不再处理抛出异常；

　　　　方法getActiveCount()的作用是取得有多少个线程正在执行任务。

　　　　方法getPoolSize()的作用是获得当前线程池里面有多少个线程，这些线程数包括正在执行任务的线程，也包括正在休眠的线程。

　　　　方法getCompletedTaskCount()的作用是取得有多少个线程已经执行完任务了。

　　　　方法getCorePoolSize()的作用是取得构造方法传入的corePoolSize参数值。

　　　　方法getMaximumPoolSize()的作用是取得构造方法传入的maximumPoolSize的值。

　　　　方法getTaskCount()的作用是取得有多少个任务发送给了线程池。

　　　　方法shutdown()的作用是使当前未执行完的线程继续执行，而不再添加新的任务task，该方法不会阻塞，调用之后，主线程main马上结束，而线程池会继续运行直到所有任务执行完才会停止。

　　　　方法shutdownNow()的作用是中断所有的任务task，并且抛出InterruptedException异常，前提是在Runnable中使用if（Thread.currentThread().isInterrupted()==true）语句来判断当前线程的中断状态，而未执行的线程不再执行，也就是从执行队列中清除。如果不手工加if语句及抛出异常，则池中正在运行的线程知道执行完毕，而未执行的线程不再执行，也从执行队列中清除。

　　　　方法isShutDown()的作用是判断线程池是否已经关闭。　　

　　　　方法isTerminating()的作用是判断线程池是否正在关闭中。

　　　　方法isTerminated()的作用是判断线程池是否已经关闭。

　　　　方法awaitTermination(long timeout,TimeUnit unit)的作用是查看在指定的时间之内，线程池是否已经终止工作，也就是最多等待多少时间后去判断线程池是否已经终止工作。

　　　　方法allowsCoreThreadTimeOut(boolean) 的作用是配置核心线程是否有超时的效果。

　　　　方法prestartCoreThread()的作用是每调用一次就创建一个核心线程，返回值为boolean。

　　　　方法prestartAllCoreThreads()的作用是启动全部核心线程，返回值是启动核心线程的数量。

• 线程池ThreadPoolExecutor的拒绝策略

　　　　线程池中的资源全部被占用的时候，对新添加的Task任务有不同的处理策略，在默认的情况ThreadPoolExecutor类中有4个不同的处理方式：

　　　　（1）AbortPolicy:当任务添加到线程池中被拒绝时，它将抛出RejectedExecutionException异常。

　　　　（2）CallerRunsPolicy:当任务添加到线程池被拒绝时，会使用调用线程池的Thread线程对象处理被拒绝的任务。

　　　　（3）DiscardOldestPolicy：当任务添加到线程池被拒绝时，线程池会放弃等待队列中最旧的未处理任务，然后将拒绝的任务添加到等待队列中。

　　　　（4）DiscardPolicy:当任务添加到线程池中被拒绝时，线程池将丢弃被拒绝的任务。