JDK多任务执行框架--------Executor框架

为了更好的控制多线程，进jdk提供了一套线程框架Executor ，它在Java.util.concurrent包中，是jdk并发报的核心，其中有一个重要的类：

Executors，它扮演这个线程工厂的角色，我们通过Executors可以创建特定的功能线程池。

1. newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2. newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3. newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
4. newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)

 
 
ExecutorService executorService = Executors.newSingleThreadExecutor();  
  
executorService.execute(new Runnable() {  
    public void run() {  
        System.out.println("Asynchronous task");  
    }  
});  
      
executorService.shutdown(); 

package com.dt.thread;


import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


class Temp extends Thread {
@Override
public void run() {
System.out.println("run");
}
}


public class ScheduleJob {


public static void main(String[] args) {
Temp temp = new Temp();
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
//1表示初始化1秒钟后执行，3表示每隔3秒执行1次
scheduledExecutorService.scheduleWithFixedDelay(temp, 1, 3, TimeUnit.SECONDS);


}


}

------------------------------------------------------------------------------------------------------------------------------

1.Exexctor简介

Executor的UML图：（常用的几个接口和子类）

Executor：一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnable command),

 

ExecutorService： 是一个比Executor使用更广泛的子类接口，其提供了生命周期管理的方法，以及可跟踪一个或多个异步任务执行状况返回Future的方法

 

AbstractExecutorService：ExecutorService执行方法的默认实现

 

ScheduledExecutorService：一个可定时调度任务的接口

 

ScheduledThreadPoolExecutor：ScheduledExecutorService的实现，一个可定时调度任务的线程池

 

ThreadPoolExecutor：线程池，可以通过调用Executors以下静态工厂方法来创建线程池 并返回一个ExecutorService对象：

 

2.ThreadPoolExecutor构造函数的各个参数说明

ThreadPoolExecutor方法签名：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) //后两个参数为可选参数

参数说明：

corePoolSize：核心线程数，如果运行的线程少于corePoolSize，则创建新线程来执行新任务，即使线程池中的其他线程是空闲的

 

maximumPoolSize:最大线程数，可允许创建的线程数，corePoolSize和maximumPoolSize设置的边界自动调整池大小：

corePoolSize <运行的线程数< maximumPoolSize:仅当队列满时才创建新线程

corePoolSize=运行的线程数= maximumPoolSize：创建固定大小的线程池

 

keepAliveTime:如果线程数多于corePoolSize,则这些多余的线程的空闲时间超过keepAliveTime时将被终止

 

unit:keepAliveTime参数的时间单位

 

workQueue:保存任务的阻塞队列，与线程池的大小有关：

  当运行的线程数少于corePoolSize时，在有新任务时直接创建新线程来执行任务而无需再进队列

  当运行的线程数等于或多于corePoolSize，在有新任务添加时则选加入队列，不直接创建线程

  当队列满时，在有新任务时就创建新线程

 

threadFactory:使用ThreadFactory创建新线程，默认使用defaultThreadFactory创建线程

 

handle:定义处理被拒绝任务的策略，默认使用ThreadPoolExecutor.AbortPolicy,任务被拒绝时将抛出RejectExecutorException

 

3.Executors：提供了一系列静态工厂方法用于创建各种线程池

   newFixedThreadPool:创建可重用且固定线程数的线程池，如果线程池中的所有线程都处于活动状态，此时再提交任务就在队列中等待，直到有可用线程；如果线程池中的某个线程由于异常而结束时，线程池就会再补充一条新线程。

方法签名：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  //使用一个基于FIFO排序的阻塞队列，在所有corePoolSize线程都忙时新任务将在队列中等待
                                  new LinkedBlockingQueue<Runnable>());
}

   newSingleThreadExecutor:创建一个单线程的Executor，如果该线程因为异常而结束就新建一条线程来继续执行后续的任务

方法签名：

public static ExecutorService newSingleThreadExecutor() {
   return new FinalizableDelegatedExecutorService
                     //corePoolSize和maximumPoolSize都等于，表示固定线程池大小为1
                        (new ThreadPoolExecutor(1, 1,
                                                0L, TimeUnit.MILLISECONDS,
                                                new LinkedBlockingQueue<Runnable>()));
}

   newScheduledThreadPool:创建一个可延迟执行或定期执行的线程池

------------------------------------------------------------------------------------------------------------------------------

public  class  CallableAndFuture {

     public  static  void  main(String[] args)  throws  ExecutionException, InterruptedException {

         ExecutorService executor = Executors.newSingleThreadExecutor();

         Future<String> future = executor.submit( new  Callable<String>() {    //接受一上callable实例

             public  String call()  throws  Exception {

                 return  "MOBIN" ;

             }

         });

         System.out.println( "任务的执行结果：" +future.get());

     }

}




--------------------

ExecutorCompletionService:实现了CompletionService，将执行完成的任务放到阻塞队列中，通过take或poll方法来获得执行结果

例4：（启动10条线程，谁先执行完成就返回谁）

public  class  CompletionServiceTest {

     public  static  void  main(String[] args)  throws  InterruptedException, ExecutionException {

         ExecutorService executor = Executors.newFixedThreadPool( 10 );         //创建含10.条线程的线程池

         CompletionService completionService =  new  ExecutorCompletionService(executor);

         for  ( int  i = 1 ; i <= 10 ; i ++) {

             final   int  result = i;

             completionService.submit( new  Callable() {

                 public  Object call()  throws  Exception {

                     Thread.sleep( new  Random().nextInt( 5000 ));    //让当前线程随机休眠一段时间

                     return  result;

                 }

             });

         }

         System.out.println(completionService.take().get());    //获取执行结果

     }

}

-------------------------------------------------------------------------------------------------

public  class  ThreadPoolTest {

     public  static  void  main(String[] args)  throws  InterruptedException {

      ExecutorService threadPool = Executors.newCachedThreadPool(); //线程池里面的线程数会动态变化，并可在线程线被移除前重用

         for  ( int  i =  1 ; i <=  3 ; i ++) {

             final   int  task = i;    //10个任务

             //TimeUnit.SECONDS.sleep(1);

             threadPool.execute( new  Runnable() {     //接受一个Runnable实例

                 public  void  run() {

                         System.out.println( "线程名字： "  + Thread.currentThread().getName() +   "  任务名为： " +task);

                 }

             });

         }

     }

}