Java并发编程 ----- Executors框架（二）

一、自定义线程 池使用详细

在构造方法中队列中使用是什么类型比较关键：

1、在使用有界队列时

     若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，     则优先创建线程，
      若大于corePoolSize，则会将任务加入队列，
      若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
      若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。

2、在使用无界队列时:LinkedBlockingQueue，与有界队列相比，

    除非资源耗尽，否则无界的任务队列不存在入队列失败的情况。当有新任务到来，系统的线程数小于corePoolSize时，则新建线程执行情况。当达到corePoolSize时，就不会继续增加，若后续有新的任务进来，而且没有空闲的线程资源，则任务加入到队列中进行等待，若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到资源耗尽系统内存。

在有界队列中需要存在拒绝策略：

  其中JDk中自带了几种拒绝策略：

    1、AbortPolicy:直接抛出异常组织，但是系统可以正常运行 。

  例如：在有界队列中new ArrayBlockingQueue<Runnable>(3)，coreSize为1，maxSize为2，则现在有六个任务到来，这这时候对于第六个任务要进行拒绝，则jdk中自带的处理，抛出异常，但是系统正常运行，在队列中的任务还是会一直执行。

2、CallRunsPolicy ：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务、

3、DiscardOldestPolicy : 丢弃最老的一个请求，尝试再次提交当前任务。

4、如果自定义拒绝策略可以实现RejectedExecutionHandle接口。

（可以在这几方面进行编写拒绝策略：

1、将拒绝的任务使用http将拒绝的任务发送给客户端，让用户重新进行处理（但是该种方式比较耗费资源，因为本来使用有界队列已经是资源有限，当运行时再将一部分内存分出去干另一件事情就使得系统运行更缓慢，还不如加大有界队列的maxPoolSize）

2、将拒绝的任务写入到日志中，然后等任务执行完之后，解析日志中的数据，使用写一个定时器去执行日志中被拒绝的任务）

代码：

自定义有界队列线程池：UseThreadPoolExecutor1.class

package com.bjsxt.height.concurrent018;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;



public class UseThreadPoolExecutor1 {


	public static void main(String[] args) {
		/**
		 * 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
		 * 若大于corePoolSize，则会将任务加入队列，
		 * 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
		 * 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
		 * 
		 */	
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				1, 				//coreSize
				2, 				//MaxSize
				60, 			//60
				TimeUnit.SECONDS, 
				new ArrayBlockingQueue<Runnable>(3)			//指定一种队列 （有界队列）
				//new LinkedBlockingQueue<Runnable>()
				//, new MyRejected()      //自定义的拒绝策略，将拒绝的任务写入到日志中
				, new DiscardOldestPolicy()
				//, new CallerRunsPolicy()
				);
		//创建任务
		MyTask mt1 = new MyTask(1, "任务1");
		MyTask mt2 = new MyTask(2, "任务2");
		MyTask mt3 = new MyTask(3, "任务3");
		MyTask mt4 = new MyTask(4, "任务4");
		MyTask mt5 = new MyTask(5, "任务5");
		MyTask mt6 = new MyTask(6, "任务6");
		MyTask mt7 = new MyTask(7, "任务7");
        //将任务加入到线程中
		pool.execute(mt1);
		pool.execute(mt2);
		pool.execute(mt3);
		pool.execute(mt4);
		pool.execute(mt5);
		pool.execute(mt6);
		pool.execute(mt7);
		pool.shutdown(); //关闭线程池
		
	}
}

执行结果：

 

2、自定义无界队列线程池：

package com.bjsxt.height.concurrent018;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class UseThreadPoolExecutor2 implements Runnable{
    
	//jdk中自带的自增器，保持数据的原子性
	private static AtomicInteger count = new AtomicInteger(0);
	
	@Override
	public void run() {
		try {
			int temp = count.incrementAndGet();
			System.out.println("任务" + temp);
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) throws Exception{
		//获取cpu核心数（返回可用处理器的Java虚拟机的数量） 线程池的大小最优的是CPU核数的1.5--2倍
		System.out.println(Runtime.getRuntime().availableProcessors());
		BlockingQueue<Runnable> queue = 
				new LinkedBlockingQueue<Runnable>();
				//new ArrayBlockingQueue<Runnable>(10);
		ExecutorService executor  = new ThreadPoolExecutor(
					5, 		//core
					10, 	//max
					120L, 	//2fenzhong
					TimeUnit.SECONDS,
					queue);
		//定义20个线程任务
		for(int i = 0 ; i < 20; i++){
			executor.execute(new UseThreadPoolExecutor2());
		}
		Thread.sleep(1000);
		//输出任务缓存队列的大小
		System.out.println("queue size:" + queue.size());		//10
		Thread.sleep(2000);
	}
}

执行结果：

3、线程任务类:MyTask.class

package com.bjsxt.height.concurrent018;

public class MyTask implements Runnable {

	private int taskId;
	private String taskName;
	
	public MyTask(int taskId, String taskName){
		this.taskId = taskId;
		this.taskName = taskName;
	}
	
	public int getTaskId() {
		return taskId;
	}

	public void setTaskId(int taskId) {
		this.taskId = taskId;
	}

	public String getTaskName() {
		return taskName;
	}

	public void setTaskName(String taskName) {
		this.taskName = taskName;
	}

	@Override
	public void run() {
		try {
			System.out.println("run taskId =" + this.taskId);
			Thread.sleep(5*1000);
			//System.out.println("end taskId =" + this.taskId);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}		
	}
	
	public String toString(){
		return Integer.toString(this.taskId);
	}

}

4、自定义简单的拒绝策略：MyReject()类

package com.bjsxt.height.concurrent018;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

   //其中自定义的拒绝策略要实现RejectedExecutionHandler的接口
public class MyRejected implements RejectedExecutionHandler{

	
	public MyRejected(){
	}
	
	/**
	 * 重写rejectedExecution方法
	 */
	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
		System.out.println("自定义处理..");
		//输出拒绝的线程任务，将其信息输入到日志中
		System.out.println("当前被拒绝任务为：" + r.toString());
	}

}