Java线程池

1.   线程池

1.1.  为什么使用线程池

多线程的缺点：

处理任务的线程创建和销毁都非常耗时并消耗资源。

多线程之间的切换也会非常耗时并消耗资源。

解决方法：采用线程池

使用时线程已存在，消除了线程创建的时耗

通过设置线程数目，防止资源不足

1.1.  ThreadPoolExecutor的全参构造函数参数介绍

在Java中创建线程池常用的类是ThreadPoolExecutor，该类的全参构造函数如下：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
      

　　

参数介绍：

l  corePoolSize：线程池中核心线程数的最大值

l  maximumPoolSize：线程池中能拥有最多线程数

l  workQueue：用于缓存任务的阻塞队列，对于不同的应用场景我们可能会采取不同的排队策略，这就需要不同类型的阻塞队列，在线程池中常用的阻塞队列有以下2种：

• SynchronousQueue<Runnable>：此队列中不缓存任何一个任务。向线程池提交任务时，如果没有空闲线程来运行任务，则入列操作会阻塞。当有线程来获取任务时，出列操作会唤醒执行入列操作的线程。从这个特性来看，SynchronousQueue是一个无界队列，因此当使用SynchronousQueue作为线程池的阻塞队列时，参数maximumPoolSizes没有任何作用。

LinkedBlockingQueue<Runnable>：顾名思义是用链表实现的队列，可以是有界的，也可以是无界的，但在Executors中默认使用无界的。

以上三个参数之间的关系如下：

1)         如果没有空闲的线程执行该任务且当前运行的线程数少于corePoolSize，则添加新的线程执行该任务。

2)         如果没有空闲的线程执行该任务且当前的线程数等于corePoolSize同时阻塞队列未满，则将任务入队列，而不添加新的线程。

3)         如果没有空闲的线程执行该任务且阻塞队列已满同时池中的线程数小于maximumPoolSize，则创建新的线程执行任务。

4)         如果没有空闲的线程执行该任务且阻塞队列已满同时池中的线程数等于maximumPoolSize，则根据构造函数中的handler指定的策略来拒绝新的任务。

l  keepAliveTime：表示空闲线程的存活时间。

unit：表示keepAliveTime的单位

l  handler：表示当workQueue已满，且池中的线程数达到maximumPoolSize时，线程池拒绝添加新任务时采取的策略。一般可以采取以下四种取值。　　

ThreadPoolExecutor.AbortPolicy()	抛出RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()	由向线程池提交任务的线程来执行该任务
ThreadPoolExecutor.DiscardOldestPolicy()	抛弃最旧的任务（最先提交而没有得到执行的任务）
ThreadPoolExecutor.DiscardPolicy()	抛弃当前的任务

l  threadFactory：指定创建线程的工厂

1.1.  四种常用线程池

ThreadPoolExecutor构造函数的参数很多，使用起来很麻烦，JavaSE中又定义了Executors类，Eexcutors类提供了四个创建线程池的方法，分别如下

l  newCachedThreadPool

l  newFixedThreadPool

l  newSingleThreadExecutor

l  newScheduleThreadPool

1.1.1.    newCachedThreadPool

该方法创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

此类型线程池特点是：

工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger.

1)         MAX_VALUE)

2)         空闲的工作线程会自动销毁，有新任务会重新创建

在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪

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

public class ExecutorServiceDemo {
	public static void main(String[] args) {
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		for (int i = 0; i < 10; i++) {
			final int index = i;
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			cachedThreadPool.execute(new Runnable() {

				@Override
				public void run() {
					System.out.println(index);
				}
			});
		}
	}
}
      

1.1.1.    newFixedThreadPool

该方法创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

优点：具有线程池提高程序效率和节省创建线程时所耗的开销。

缺点：在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源

public static void main(String[] args) {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
			final int index = i;
			fixedThreadPool.execute(new Runnable() {

				@Override
				public void run() {
					try {
						System.out.println(index);
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
}
      

  newSingleThreadExecutor

该方法创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行

单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的

public static void main(String[] args) {
		ExecutorService singleThreadExecutor =Executors.newSingleThreadExecutor();
		for(int i=0;i<10;i++){
			
			final int index=i;
			singleThreadExecutor.execute(new Runnable() {
				
				@Override
				public void run() {
					try {
						 System.out.println(index);  
	                        Thread.sleep(2000);  

					} catch (InterruptedException e) {
						e.printStackTrace(); 
					}
					
				}
			});
		}
	}
      

 newScheduleThreadPool

public class ScheduledExecutorServiceDemo {
	public static void main(String[] args) {
		ScheduledExecutorService scheduledThreadPool =Executors.newScheduledThreadPool(5);
		for(int i=0;i<10;i++){
			scheduledThreadPool.schedule(new Runnable() {
				
				@Override
				public void run() {
					System.out.println("delay 3 seconds");  
					
				}
			},3,TimeUnit.SECONDS);
		}
	}
}