Java线程池基础

 1 public ThreadPoolExecutor(int corePoolSize,
 2                               int maximumPoolSize,
 3                               long keepAliveTime,
 4                               TimeUnit unit,
 5                               BlockingQueue<Runnable> workQueue,
 6                               ThreadFactory threadFactory,
 7                               RejectedExecutionHandler handler) {
 8         if (corePoolSize < 0 ||
 9             maximumPoolSize <= 0 ||
10             maximumPoolSize < corePoolSize ||
11             keepAliveTime < 0)
12             throw new IllegalArgumentException();
13         if (workQueue == null || threadFactory == null || handler == null)
14             throw new NullPointerException();
15         this.acc = System.getSecurityManager() == null ?
16                 null :
17                 AccessController.getContext();
18         this.corePoolSize = corePoolSize;
19         this.maximumPoolSize = maximumPoolSize;
20         this.workQueue = workQueue;
21         this.keepAliveTime = unit.toNanos(keepAliveTime);
22         this.threadFactory = threadFactory;
23         this.handler = handler;
24     }

 1 //第一个构造函数，参数只有线程数量，核心线程数与最大线程数一致
 2 public static ExecutorService newFixedThreadPool(int nThreads) {
 3         return new ThreadPoolExecutor(nThreads, nThreads,
 4                                       0L, TimeUnit.MILLISECONDS,
 5                                       new LinkedBlockingQueue<Runnable>());
 6 }
 7 
 8 //第二个构造函数，参数包含核心线程数和线程工厂，核心线程数与最大线程数一致
 9 public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
10         return new ThreadPoolExecutor(nThreads, nThreads,
11                                       0L, TimeUnit.MILLISECONDS,
12                                       new LinkedBlockingQueue<Runnable>(),
13                                       threadFactory);
14 }

1 //构造函数，默认核心线程数和最大线程数都是1
2 public static ExecutorService newSingleThreadExecutor() {
3         return new FinalizableDelegatedExecutorService
4             (new ThreadPoolExecutor(1, 1,
5                                     0L, TimeUnit.MILLISECONDS,
6                                     new LinkedBlockingQueue<Runnable>()));
7 }

1 //构造函数，核心线程数为0，最大线程数为Integer.MAX_VALUE，空闲线程超时时间为60秒
2 public static ExecutorService newCachedThreadPool() {
3         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
4                                       60L, TimeUnit.SECONDS,
5                                       new SynchronousQueue<Runnable>());
6 }

 1 //第一个构造函数，指定核心线程数大小
 2 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
 3         return new ScheduledThreadPoolExecutor(corePoolSize);
 4 }
 5 
 6 //第二个构造函数，指定核心线程数大小及线程工厂
 7 public static ScheduledExecutorService newScheduledThreadPool(
 8             int corePoolSize, ThreadFactory threadFactory) {
 9         return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
10 }

 1 public class ExecuteTest {
 2 
 3     public static void main(String[] args) {
 4 
 5         BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
 6         ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 3, 60, TimeUnit.SECONDS, workQueue);
 7         poolExecutor.execute(new TaskOne());
 8         poolExecutor.execute(new TaskTwo());
 9         poolExecutor.shutdown();
10     }
11 }
12 
13 class TaskOne implements Runnable{
14 
15     @Override
16     public void run() {
17         System.out.println("正在执行任务1...");
18     }
19 }
20 
21 class TaskTwo implements Runnable{
22 
23     @Override
24     public void run() {
25         System.out.println("正在执行任务2...");
26     }
27 }

 1 public class SubmitTest {
 2 
 3     public static void main(String[] args) throws ExecutionException, InterruptedException {
 4 
 5         ExecutorService executorService = Executors.newCachedThreadPool();
 6         List<Future<String>> resultList = new ArrayList<Future<String>>();
 7         //创建10个任务并执行
 8         for(int i = 0;i < 10;i++){
 9             //使用ExecutorService执行Callable类型的任务,并将结果保存在future变量中
10             Future<String> future = executorService.submit(new TaskWithResult(i));
11             resultList.add(future);
12         }
13         //遍历结果集
14         for(Future<String> future : resultList){
15             //Future返回如果没有完成,则一直循环等待,直到Future返回完成
16             while(!future.isDone());{
17                 //打印各个线程(任务)执行的结果
18                 System.out.println(future.get());
19             }
20         }
21         executorService.shutdown();
22     }
23 }
24 
25 class TaskWithResult implements Callable<String>{
26 
27     private int id;
28     public TaskWithResult(int id){
29         this.id = id;
30     }
31     
32     @Override
33     public String call() throws Exception {
34         return "执行结果" + id;
35     }
36 }

 1 public class TimerTest {
 2     
 3     static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 4 
 5     public static void main(String[] args) {
 6 
 7         TimerTask timerTaskOne = new TimerTask() {
 8             @Override
 9             public void run() {
10                 System.out.println("任务1执行时间:" + sdf.format(new Date()));
11                 try{
12                     //模拟任务1执行时间3秒
13                     Thread.sleep(3000);
14                 }catch(InterruptedException ex){
15                     ex.printStackTrace();
16                 }
17             }
18         };
19         
20         System.out.println(String.format("当前时间:" + sdf.format(new Date())));
21         Timer timer = new Timer();
22         //间隔4秒钟周期性执行任务1
23         timer.schedule(timerTaskOne, new Date(), 4000);
24     }
25 }

 1 public class TimerDefectTestOne {
 2     
 3     static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 4 
 5     public static void main(String[] args) {
 6 
 7         TimerTask timerTaskOne = new TimerTask() {
 8             @Override
 9             public void run() {
10                 System.out.println(String.format("任务1执行时间:" + sdf.format(new Date())));
11                 try{
12                     Thread.sleep(10000);
13                 }catch(InterruptedException ex){
14                     ex.printStackTrace();
15                 }
16             }
17         };
18         
19         TimerTask timerTaskTwo = new TimerTask() {
20             @Override
21             public void run() {
22                 System.out.println(String.format("任务2执行时间:" + sdf.format(new Date())));
23             }
24         };
25         
26         System.out.println("当前时间:" + sdf.format(new Date()));
27         Timer timer = new Timer();
28         //间隔1秒周期性执行任务1
29         timer.schedule(timerTaskOne, new Date(), 1000);
30         //间隔4秒周期性执行任务2
31         timer.schedule(timerTaskTwo, new Date(), 4000);
32     }
33 }

 1 public class TimerDefectTestTwo {
 2     
 3     static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 4 
 5     public static void main(String[] args) {
 6 
 7         TimerTask timerTaskOne = new TimerTask() {
 8             @Override
 9             public void run() {
10                 System.out.println(String.format("任务1执行时间:" + sdf.format(new Date())));
11                 throw new RuntimeException();
12             }
13         };
14         
15         TimerTask timerTaskTwo = new TimerTask() {
16             @Override
17             public void run() {
18                 System.out.println(String.format("任务2执行时间:" + sdf.format(new Date())));
19             }
20         };
21         
22         System.out.println("当前时间:" + sdf.format(new Date()));
23         Timer timer = new Timer();
24         //间隔1秒周期性执行任务1
25         timer.schedule(timerTaskOne, new Date(), 1000);
26         //间隔4秒周期性执行任务2
27         timer.schedule(timerTaskTwo, new Date(), 4000);
28     }
29 }

 1 public class ScheduledThreadPoolExecutorTestOne {
 2     
 3     static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 4 
 5     public static void main(String[] args) {
 6 
 7         TimerTask timerTaskOne = new TimerTask() {
 8             @Override
 9             public void run() {
10                 System.out.println(String.format("任务1执行时间:" + sdf.format(new Date())));
11                 try{
12                     Thread.sleep(10000);
13                 }catch(InterruptedException ex){
14                     ex.printStackTrace();
15                 }
16             }
17         };
18 
19         TimerTask timerTaskTwo = new TimerTask() {
20             @Override
21             public void run() {
22                 System.out.println(String.format("任务2执行时间:" + sdf.format(new Date())));
23             }
24         };
25 
26         System.out.println("当前时间:" + sdf.format(new Date()));
27         ScheduledThreadPoolExecutor poolExecutor = new ScheduledThreadPoolExecutor(2);
28         poolExecutor.scheduleAtFixedRate(timerTaskOne, 0, 1000, TimeUnit.MILLISECONDS);
29         poolExecutor.scheduleAtFixedRate(timerTaskTwo, 0, 4000, TimeUnit.MILLISECONDS);
30     }
31 }

 1 public class ScheduledThreadPoolExecutorTestTwo {
 2     
 3     static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 4 
 5     public static void main(String[] args) {
 6 
 7         TimerTask timerTaskOne = new TimerTask() {
 8             @Override
 9             public void run() {
10                 System.out.println(String.format("任务1执行时间:" + sdf.format(new Date())));
11                 throw new RuntimeException();
12             }
13         };
14 
15         TimerTask timerTaskTwo = new TimerTask() {
16             @Override
17             public void run() {
18                 System.out.println(String.format("任务2执行时间:" + sdf.format(new Date())));
19             }
20         };
21 
22         System.out.println("当前时间:" + sdf.format(new Date()));
23         ScheduledThreadPoolExecutor poolExecutor = new ScheduledThreadPoolExecutor(2);
24         poolExecutor.scheduleAtFixedRate(timerTaskOne, 0, 1000, TimeUnit.MILLISECONDS);
25         poolExecutor.scheduleAtFixedRate(timerTaskTwo, 0, 4000, TimeUnit.MILLISECONDS);
26     }
27 }

 1 public void shutdown(){
 2     final ReentrantLock mainLock = this.mainLock;
 3     mainLock.lock();
 4     try {
 5         //检查权限
 6         checkShutdownAccess();
 7         //设置线程池状态
 8         advanceRunState(SHUTDOWN);
 9         //中断空闲线程
10         interruptIdleWorkers();
11         //钩子函数,主要用于清理一些资源
12         onShutdown();
13     } finally {
14         mainLock.unlock();
15     }
16     tryTerminate();
17 }    

 1 public List<Runnable> shutdownNow(){
 2     List<Runnable> tasks;
 3     final ReentrantLock mainLock = this.mainLock;
 4     mainLock.lock();
 5     try {
 6         //检查状态
 7         checkShutdownAccess();
 8         //将线程池状态转变为STOP
 9         advanceRunState(STOP);
10         //中断所有线程,包括工作线程以及空闲线程
11         interruptWorkers();
12         //丢弃工作队列中的存量任务
13         tasks = drainQueue();
14     } finally {
15         mainLock.unlock();
16     }
17     tryTerminate();
18     return tasks;
19 }

1 poolExecutor.shutdown();
2     try{
3         while(!poolExecutor.awaitTermination(60, TimeUnit.SECONDS)){
4             System.out.println("线程池任务还未执行结束");
5         }
6     }catch(InterruptedException ex){
7         ex.printStackTrace();
8 }

 1 //调用shutdown()方法关闭线程池        
 2 poolExecutor.shutdown();
 3 try{
 4     //等待60秒
 5     if (!poolExecutor.awaitTermination(60, TimeUnit.SECONDS)){
 6         //调用shutdownNow取消正在执行的任务
 7         poolExecutor.shutdownNow();
 8         //再次等待60秒，如果还未结束，可以再次尝试，或者直接放弃
 9         if(!poolExecutor.awaitTermination(60, TimeUnit.SECONDS)){
10             System.err.println("线程池任务未正常执行结束");
11         }
12     }
13 }catch(InterruptedException ex){
14     //重新调用shutdownNow
15     poolExecutor.shutdownNow();
16 }