//创建一个有10个线程的线程池,任务多于10个会一直等待,直到10个线程中有空闲线程为止
//ExecutorService pool = Executors.newFixedThreadPool(10);
//开启线程
pool.execute(new Thread(()->{System.out.println(Thread.currentThread().getName()+"执行中.....");}));
pool.execute(new Thread(()->{System.out.println(Thread.currentThread().getName()+"执行中.....");}));
pool.execute(new Thread(()->{System.out.println(Thread.currentThread().getName()+"执行中.....");}));

		ExecutorService poolSingle = Executors.newSingleThreadExecutor();
		poolSingle.execute(new Thread(()->{
			System.out.println("run1");
			while(true){
			}
		}));				
		//下面永不会执行
		poolSingle.execute(new Thread(()->{System.out.println("run2");}));

		不指定数量.如果任务多,且没有空闲线程则会一直创建线程,并且空闲线程会在60秒后回收
		ExecutorService cachePool = Executors.newCachedThreadPool();
		cachePool.execute(new Thread(()->{
			System.out.println("run1");
			while(true){
			}
		}));
		cachePool.execute(new Thread(()->{
			System.out.println("run2");
			while(true){
			}
		}));

class RunTest implements Runnable{
	@Override
	public void run() {
		System.out.println("run");
	}
}
public class ScheculedTest {
	public static void main(String[] args) {
		ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);
		//可实现任务定时,但实际业务中一般都用spring的定时器,这个技术比较老了
		//pool.schedule(new RunTest(), 2, TimeUnit.SECONDS);//2秒后执行此任务
		//可实现任务的轮询,指定时间间隔循环执行此任务     任务    延迟时间(即2秒后开始执行)   间隔多少秒之后再执行(一直循环)
		pool.scheduleAtFixedRate(new RunTest(), 2, 2, TimeUnit.SECONDS);
		pool.scheduleWithFixedDelay(new RunTest(), 2, 2, TimeUnit.SECONDS);
	}
}

public class MyCustom01 {

	public static void main(String[] args) {
		//有界队列自定义线程池
		/**在使用有界队列时，如果有任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
		 * 若大于corePoolSize，则会将任务加入队列，
		 * 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
		 * 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
		 */
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				1,   //核心线程数
				2,   //最大线程数
				60,   //空闲时回收时间
				TimeUnit.SECONDS, 
				new ArrayBlockingQueue<Runnable>(3),//指定队列//指定队列
				//DiscardOldestPolicy :丢弃最老的请求,即当6进来时,将队列中最早的2丢弃,执行6
				//new ThreadPoolExecutor.DiscardOldestPolicy()//指定拒绝策略.不指定默认抛异常
				//自定义拒绝策略
				new RejectedExecutionHandler(){
					@Override        //r:被拒绝任务     executor 当前线程池
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						//实例工作中默认策略都不可取,一般是把拒绝的任务记录日志,然后空闲时间解析再重新执行
						//或者直接返回客户端,让他稍后再提交此任务
						System.out.println("自定义处理..");
						System.out.println("当前被拒绝任务为：" + r.toString());
						System.out.println(executor.getPoolSize());
					}}
		); 
		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");
		pool.execute(mt1);
		pool.execute(mt2);//如果有两个任务,则会将第二个任务入队,等待核心线程线程空闲
		pool.execute(mt3);//同上
		pool.execute(mt4);//同上,知道队列满 为止
		pool.execute(mt5);//当有5个任务时,队列已满,则会创建第二个线程
		pool.execute(mt6); //有6个时,此时队列已满,且当前线程达到最大线程数,所以无法执行,执行拒绝策略
		//关闭,等到所有线程空闲时才会关闭
		pool.shutdown();
	}
}

public class MyCustom02 implements Runnable{
	//并发数字运算
	private static AtomicInteger count = new AtomicInteger(0);
	@Override
	public void run() {
		try {
			int temp = count.incrementAndGet();//count累加,区分任务
			System.out.println("任务" + temp);
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}	
	}
	public static void main(String[] args) throws Exception{
		//无界队列
		BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
		ExecutorService executor  = new ThreadPoolExecutor(
					5, 		
					10,//无界时,任务多会一直添加到队列中,不会创建新的线程,线程数会一直是核心数量
					120L, 	
					TimeUnit.SECONDS,
					queue //指定无界队列
		);
		for(int i = 0 ; i < 20; i++){
			executor.execute(new MyCustom02()); //会5个一起执行
		}
		Thread.sleep(1000);
		System.out.println("queue size:" + queue.size());
		Thread.sleep(2000);
	}
}