多线程（四）

1、Executor

线程池顶级接口。定义方法，void execute(Runnable)。方法是用于处理任务的一个服务 方法。调用者提供 Runnable 接口的实现，线程池通过线程执行这个 Runnable。服务方法无 返回值的。是 Runnable 接口中的 run 方法无返回值。 常用方法 - void execute(Runnable) 作用是： 启动线程任务的。

2、ExecutorService

Executor 接口的子接口。提供了一个新的服务方法，submit。有返回值（Future 类型）。 submit 方法提供了 overload 方法。其中有参数类型为 Runnable 的，不需要提供返回值的； 有参数类型为 Callable，可以提供线程执行后的返回值。 Future，是 submit 方法的返回值。代表未来，也就是线程执行结束后的一种结果。如返 回值。 常见方法 - void execute(Runnable)， Future submit(Callable)， Future submit(Runnable) 线程池状态： Running， ShuttingDown， Termitnaed Running - 线程池正在执行中。活动状态。 ShuttingDown - 线程池正在关闭过程中。优雅关闭。一旦进入这个状态，线程池不再接 收新的任务，处理所有已接收的任务，处理完毕后，关闭线程池。 Terminated - 线程池已经关闭。

3、Callable

可执行接口。 类似 Runnable 接口。也是可以启动一个线程的接口。其中定义的方法是 call。call 方法的作用和 Runnable 中的 run 方法完全一致。call 方法有返回值。 接口方法 ： Object call();相当于 Runnable 接口中的 run 方法。区别为此方法有返回值。 不能抛出已检查异常。 和 Runnable 接口的选择 - 需要返回值或需要抛出异常时，使用 Callable，其他情况可 任意选择。

4、Executors

工具类型。为 Executor 线程池提供工具方法。可以快速的提供若干种线程池。如：固定 容量的，无限容量的，容量为 1 等各种线程池。 线程池是一个进程级的重量级资源。默认的生命周期和 JVM 一致。当开启线程池后， 直到 JVM 关闭为止，是线程池的默认生命周期。如果手工调用 shutdown 方法，那么线程池 执行所有的任务后，自动关闭。 开始 - 创建线程池。 结束 - JVM 关闭或调用 shutdown 并处理完所有的任务。 类似 Arrays，Collections 等工具类型的功用。

5、newFixedThreadPool

固定容量的线程池

容量固定的线程池。活动状态和线程池容量是有上限的线程池。所有的线程池中，都有 一个任务队列。使用的是 BlockingQueue作为任务的载体。当任务数量大于线程 池容量的时候，没有运行的任务保存在任务队列中，当线程有空闲的，自动从队列中取出任 务执行。 使用场景： 大多数情况下，使用的线程池，首选推荐 FixedThreadPool。OS 系统和硬件 是有线程支持上限。不能随意的无限制提供线程池。 线程池默认的容量上限是 Integer.MAX_VALUE。 常见的线程池容量： PC - 200。 服务器 - 1000~10000 queued tasks - 任务队列 completed tasks - 结束任务队列

/**
 * 线程池
 * 固定容量线程池
 * FixedThreadPool - 固定容量线程池。创建线程池的时候，容量固定。
 *  构造的时候，提供线程池最大容量
 * new xxxxx -> 
 * ExecutorService - 线程池服务类型。所有的线程池类型都实现这个接口。
 *  实现这个接口，代表可以提供线程池能力。
 *  shutdown - 优雅关闭。 不是强行关闭线程池，回收线程池中的资源。而是不再处理新的任务，将已接收的任务处理完毕后
 *      再关闭。
 * Executors - Executor的工具类。类似Collection和Collections的关系。
 *  可以更简单的创建若干种线程池。
 */
package concurrent.t08;

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

public class Test_02_FixedThreadPool {
 
 public static void main(String[] args) {
  ExecutorService service = 
    Executors.newFixedThreadPool(5);
  for(int i = 0; i < 6; i++){
   service.execute(new Runnable() {
    @Override
    public void run() {
     try {
      TimeUnit.MILLISECONDS.sleep(500);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println(Thread.currentThread().getName() + " - test executor");
    }
   });
  }
  
  System.out.println(service);
  
  service.shutdown();
  // 是否已经结束， 相当于回收了资源。
  System.out.println(service.isTerminated());
  // 是否已经关闭， 是否调用过shutdown方法
  System.out.println(service.isShutdown());
  System.out.println(service);
  
  try {
   TimeUnit.SECONDS.sleep(2);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  
  // service.shutdown();
  System.out.println(service.isTerminated());
  System.out.println(service.isShutdown());
  System.out.println(service);
 }

}
复制代码

结果：

java.util.concurrent.ThreadPoolExecutor@42a57993[Running, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]
false
true
java.util.concurrent.ThreadPoolExecutor@42a57993[Shutting down, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]
pool-1-thread-2 - test executor
pool-1-thread-1 - test executor
pool-1-thread-5 - test executor
pool-1-thread-4 - test executor
pool-1-thread-3 - test executor
pool-1-thread-2 - test executor
true
true
java.util.concurrent.ThreadPoolExecutor@42a57993[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 6]
复制代码

6、future

未来结果，代表线程任务执行结束后的结果。获取线程执行结果的方式是通过 get 方法 获取的。get 无参，阻塞等待线程执行结束，并得到结果。get 有参，阻塞固定时长，等待 线程执行结束后的结果，如果在阻塞时长范围内，线程未执行结束，抛出异常。 常用方法： T get() T get(long, TimeUnit)

/**
 * 线程池
 * 固定容量线程池
 */
package concurrent.t08;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class Test_03_Future {
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		/*FutureTask<String> task = new FutureTask<>(new Callable<String>() {
			@Override
			public String call() throws Exception {
				return "first future task";
			}
		});
		
		new Thread(task).start();
		
		System.out.println(task.get());*/
		
		ExecutorService service = Executors.newFixedThreadPool(1);
		
		Future<String> future = service.submit(new Callable<String>() {
			@Override
			public String call() {
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("aaa");
				return Thread.currentThread().getName() + " - test executor";
			}
		});
		System.out.println(future);
		System.out.println(future.isDone()); // 查看线程是否结束， 任务是否完成。 call方法是否执行结束
		
		System.out.println(future.get()); // 获取call方法的返回值。
		System.out.println(future.isDone());
	}

}
复制代码

结果：

java.util.concurrent.FutureTask@6d6f6e28
false
aaa
pool-1-thread-1 - test executor
true
复制代码

7、CachedThreadPool

缓存的线程池。容量不限（Integer.MAX_VALUE）。自动扩容。容量管理策略：如果线程 池中的线程数量不满足任务执行，创建新的线程。每次有新任务无法即时处理的时候，都会 创建新的线程。当线程池中的线程空闲时长达到一定的临界值（默认 60 秒），自动释放线程。 默认线程空闲 60 秒，自动销毁。 应用场景： 内部应用或测试应用。 内部应用，有条件的内部数据瞬间处理时应用，如： 电信平台夜间执行数据整理（有把握在短时间内处理完所有工作，且对硬件和软件有足够的 信心）。 测试应用，在测试的时候，尝试得到硬件或软件的最高负载量，用于提供 FixedThreadPool 容量的指导。

/**
 * 线程池
 * 无容量限制的线程池（最大容量默认为Integer.MAX_VALUE）
 */
package concurrent.t08;

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

public class Test_05_CachedThreadPool {
	
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		System.out.println(service);
		
		for(int i = 0; i < 5; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
		System.out.println(service);
		
		try {
			TimeUnit.SECONDS.sleep(65);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println(service);
	}

}
复制代码

结果：

java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 5, active threads = 5, queued tasks = 0, completed tasks = 0]
pool-1-thread-5 - test executor
pool-1-thread-2 - test executor
pool-1-thread-4 - test executor
pool-1-thread-1 - test executor
pool-1-thread-3 - test executor
java.util.concurrent.ThreadPoolExecutor@7f31245a[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 5]

Process finished with exit code 0
复制代码

8、ScheduledThreadPool

计划任务线程池。可以根据计划自动执行任务的线程池。 scheduleAtFixedRate(Runnable, start_limit, limit, timeunit) runnable - 要执行的任务。 start_limit - 第一次任务执行的间隔。 limit - 多次任务执行的间隔。 timeunit - 多次任务执行间隔的时间单位。 使用场景： 计划任务时选用（DelaydQueue），如：电信行业中的数据整理，没分钟整 理，没小时整理，每天整理等。

/**
 * 线程池
 * 计划任务线程池。
 */
package concurrent.t08;

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

public class Test_07_ScheduledThreadPool {
	
	public static void main(String[] args) {
		ScheduledExecutorService service = Executors.newScheduledThreadPool(3);
		System.out.println(service);
		
		// 定时完成任务。 scheduleAtFixedRate(Runnable, start_limit, limit, timeunit)
		// runnable - 要执行的任务。
		service.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				try {
					TimeUnit.MILLISECONDS.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());
			}
		}, 0, 300, TimeUnit.MILLISECONDS);
		
	}

}
复制代码

结果：

java.util.concurrent.ScheduledThreadPoolExecutor@14ae5a5[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
pool-1-thread-1
pool-1-thread-1
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
复制代码

9、SingleThreadExceutor

单一容量的线程池。

使用场景： 保证任务顺序时使用。如： 游戏大厅中的公共频道聊天。秒杀。

/**
 * 线程池
 * 容量为1的线程池。 顺序执行。
 */
package concurrent.t08;

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

public class Test_06_SingleThreadExecutor {
	
	public static void main(String[] args) {
		ExecutorService service = Executors.newSingleThreadExecutor();
		System.out.println(service);
		
		for(int i = 0; i < 5; i++){
			service.execute(new Runnable() {
				@Override
				public void run() {
					try {
						TimeUnit.MILLISECONDS.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " - test executor");
				}
			});
		}
		
	}

}
复制代码

结果：

java.util.concurrent.Executors$FinalizableDelegatedExecutorService@14ae5a5
pool-1-thread-1 - test executor
pool-1-thread-1 - test executor
pool-1-thread-1 - test executor
pool-1-thread-1 - test executor
pool-1-thread-1 - test executor
复制代码

10、ForkJoinPool

分支合并线程池（mapduce 类似的设计思想）。适合用于处理复杂任务。 初始化线程容量与 CPU 核心数相关。 线程池中运行的内容必须是 ForkJoinTask 的子类型（RecursiveTask,RecursiveAction）。

ForkJoinPool - 分支合并线程池。 可以递归完成复杂任务。要求可分支合并的任务必须是 ForkJoinTask 类型的子类型。其中提供了分支和合并的能力。ForkJoinTask 类型提供了两个抽象子类型，RecursiveTask 有返回结果的分支合并任务,RecursiveAction 无返回结果的分支合并任务。（Callable/Runnable）compute 方法：就是任务的执行逻辑。

ForkJoinPool 没有所谓的容量。默认都是 1 个线程。根据任务自动的分支新的子线程。当子线程任务结束后，自动合并。所谓自动是根据 fork 和 join 两个方法实现的。应用： 主要是做科学计算或天文计算的。数据分析的

/**
 * 线程池
 * 分支合并线程池。
 */
package concurrent.t08;

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class Test_08_ForkJoinPool {
	
	final static int[] numbers = new int[1000000];
	final static int MAX_SIZE = 50000;
	final static Random r = new Random();
	
	
	static{
		for(int i = 0; i < numbers.length; i++){
			numbers[i] = r.nextInt(1000);
		}
	}
	
	static class AddTask extends RecursiveTask<Long>{ // RecursiveAction
		int begin, end;
		public AddTask(int begin, int end){
			this.begin = begin;
			this.end = end;
		}
		
		// 
		protected Long compute(){
			if((end - begin) < MAX_SIZE){
				long sum = 0L;
				for(int i = begin; i < end; i++){
					sum += numbers[i];
				}
				// System.out.println("form " + begin + " to " + end + " sum is : " + sum);
				return sum;
			}else{
				int middle = begin + (end - begin)/2;
				AddTask task1 = new AddTask(begin, middle);
				AddTask task2 = new AddTask(middle, end);
				task1.fork();// 就是用于开启新的任务的。 就是分支工作的。 就是开启一个新的线程任务。
				task2.fork();
				// join - 合并。将任务的结果获取。 这是一个阻塞方法。一定会得到结果数据。
				return task1.join() + task2.join();
			}
		}
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException, IOException {
		long result = 0L;
		for(int i = 0; i < numbers.length; i++){
			result += numbers[i];
		}
		System.out.println(result);
		
		ForkJoinPool pool = new ForkJoinPool();
		AddTask task = new AddTask(0, numbers.length);
		
		Future<Long> future = pool.submit(task);
		System.out.println(future.get());
		
	}

}
复制代码

结果：

499664397
499664397
复制代码