java架构《并发线程高级篇一》

　　本章主要记录讲解并发线程的线程池。java.util.concurrent工具包里面的工具类。

一：Executor框架：

　　　　Executors创建线程池的方法：

　　　　　　

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

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

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

newFixedThreadPool使用心得：因为该方法创建的是一个固定的线程池，底层运用的队列是linkBlockingQueue队列，该队列是阻塞无序队列，所以切记，当首次任务列队完成调度后，后面的顺序就会被打乱，排序则需要根据指定的规则排序。

newCachedThreadExecutor使用心得：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newSingleThreadExecutor使用心得：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

newScheduledThreadPool使用心得：创建一个定长线程池，支持定时及周期性任务执行。

 

　　　　　

　　　　代码解析：

　　　　　　　

　//Task内部类：　　

　　　　　　　　class Task extends Thread{

　　　　　　　　private int TaskId; 

　　　　　　　　public Task(Integer TaskId){
　　　　　　　　this.TaskId=TaskId;
　　　　　　　　}
　　　　　　　　　　@Override
　　　　　　　　　　public void run() {
　　　　　　　　　　　　long start = System.currentTimeMillis();
　　　　　　　　　　　　try {
　　　　　　　　　　　　　　System.out.println("Run-----" +"TaskId:"+TaskId);
　　　　　　　　　　　　　　//模仿处理数据需要5s
　　　　　　　　　　　　　　Thread.sleep(5000);
　　　　　　　　　　　　　　long end = System.currentTimeMillis() - start;
　　　　　　　　　　　　　　System.out.println(" 执行时间：" + end);
　　　　　　　　　　　　　　} catch (InterruptedException e) {
　　　　　　　　　　　　　　　　// TODO Auto-generated catch block
　　　　　　　　　　　　　　　　e.printStackTrace();
　　　　　　　　　　　　　　} 

　　　　　　　　　　　　　　}
　　　　　　　　　　}

 

 

　　　　　　

//　newFixedThreadPool方法测试：

　　　　　　　　　　　　

　　　　　　　　　　/**
　　　　　　　　　　* newFixedThreadPool线程池测试 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。队列无序
　　　　　　　　　　* @throws InterruptedException
　　　　　　　　　　*/
　　　　　　　　　　private static void FixedThredPoolTest() throws InterruptedException {
　　　　　　　　　　　　System.out.println("newFixedThreadPool线程池测试-------------------");
　　　　　　　　　　　　//创建固定的10个线程的线程池 队列阻塞无序
　　　　　　　　　　　　ExecutorService    pool=Executors.newFixedThreadPool(10);
　　　　　　　　　　　　/**
　　　　　　　　　　　　* 这里产生15个任务 看是否一次性处理10个任务，
　　　　　　　　　　　　* 然后5个任务阻塞放在LinkBlockingQueue队列里面，
　　　　　　　　　　　　* 然后等10个任务处理完在执行
　　　　　　　　　　　　*/
　　　　　　　　　　　　　　for (int i = 1; i <= 15; i++) {
　　　　　　　　　　　　　　　　// 执行给定的命令 执行任务
　　　　　　　　　　　　　　　　pool.execute(new Task(i)); 
　　　　　　　　　　　　　　　　}

　　　　　　　　　　　　　　　　//关闭启动线程
　　　　　　　　　　　　　　　　pool.shutdown();
　　　　　　　　　　　　　　　　// 等待子线程结束，再继续执行下面的代码
　　　　　　　　　　　　　　　　pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
　　　　　　　　　　　　　　　　System.out.println("all thread complete");
　　　　　　　　　　　　　　}

　　　　　　　　

 

　　　　　　

　//　newCachedThreadPool方法测试：

　　　　　　　　　　　　

　　　　　　　　　　　/**
　　　　　　　　　　　* newCachedThreadPool线程池测试 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
　　　　　　　　　　　* @throws InterruptedException
　　　　　　　　　　　*/
　　　　　　　　　　　private static void CachedThreadPoolTest() throws InterruptedException {
　　　　　　　　　　　　　　System.out.println("newCachedThreadPool线程池测试-------------------");
　　　　　　　　　　　　　　ExecutorService pool=Executors.newCachedThreadPool();

　　　　　　　　　　　　　　　　for (int i =1; i <= 10; i++) {
　　　　　　　　　　　　　　　　　　// 执行给定的命令 
　　　　　　　　　　　　　　　　　　pool.execute(new Task(i));
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　//关闭启动线程
　　　　　　　　　　　　　　　　pool.shutdown();
　　　　　　　　　　　　　　　　// 等待子线程结束，再继续执行下面的代码
　　　　　　　　　　　　　　　　pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
　　　　　　　　　　　　　　　　System.out.println("all thread complete");
　　　　　　　　　　　　　　}

 

 

　　　　　　　

//　newSingleThreadExecutor方法测试：

　　　　　　　　

　　　　　　　　　　　　/**

　　　　　　　　　　　　* newSingleThreadExecutor测试：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
　　　　　　　　　　　　* @throws InterruptedException
　　　　　　　　　　　　*/
　　　　　　　　　　　　private static void SingleThreadPoolTest() throws InterruptedException {
　　　　　　　　　　　　　　System.out.println("newSingleThreadExecutor线程池测试-------------------");
　　　　　　　　　　　　　　ExecutorService pool=Executors.newSingleThreadExecutor();
　　　　　　　　　　　　　　　　for (int i = 1; i <= 5; i++) {
　　　　　　　　　　　　　　　　　　// 执行给定的命令 
　　　　　　　　　　　　　　　　　　pool.execute(new Task(i));
　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　//关闭启动线程
　　　　　　　　　　　　　　　　pool.shutdown();
　　　　　　　　　　　　　　　　// 等待子线程结束，再继续执行下面的代码
　　　　　　　　　　　　　　　　pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
　　　　　　　　　　　　　　　　System.out.println("all thread complete");
　　　　　　　　　　　　　　}

 

 

　　　　　　

　//　newScheduledThreadPool方法测试：

　　　　　　　　　　

　　　　　　　　　　/**
　　　　　　　　　　* newScheduledThreadPool测试 创建一个定长线程池，支持定时及周期性任务执行。
　　　　　　　　　　*/
　　　　　　　　　　private static void ScheduledThreadPoolTest() {
　　　　　　　　　　　　System.out.println("newScheduledThreadPool线程池测试-------------------");
　　　　　　　　　　　　ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
　　　　　　　　　　　　/* 参数：
　　　　　　　　　　　　command - 要执行的任务
　　　　　　　　　　　　initialdelay - 首次执行的延迟时间
　　　　　　　　　　　　delay - 一次执行终止和下一次执行开始之间的延迟
　　　　　　　　　　　　unit - initialdelay 和 delay 参数的时间单位*/
　　　　　　　　　　　　ScheduledFuture<?> scheduleTask = scheduler.scheduleWithFixedDelay(new Task(1), 5, 1, TimeUnit.SECONDS);
　　　　　　　　　　}