java多线程之线程池

package Thread;

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

public class ThreadPoolTest {

	public static void main(String[] args) {
		f4();

	}
	
	/**
	 * 创建定长线程池，每当提交一个任务时就创建一个线程，直到线程池的最大数量。超出的线程会在队列中等待。
	 * 该方法内部使用了阻塞队列LinkedBlockingQueue<Runnable>，超过池子容量的线程会在队列中等待
	 * 
	 */
	static void f1(){
		ExecutorService executorService = Executors.newFixedThreadPool(5);
		executorService.execute(new MyRunable1());
		executorService.execute(new MyRunable2());
		executorService.execute(new MyRunable3());
		//在静态方法中可以不用shutdown。非静态方法中，如果不调用shutdown，那么线程池将会一直开启
		executorService.shutdown();
		
		/**
		 * 如果线程池的大小设置为2，而实际中添加了3个线程。那么前两个线程是在队列中的，几乎一起执行。执行结束后
		 * 才执行第三个线程。
		 * ExecutorService executorService = Executors.newFixedThreadPool(2);
		 * executorService.execute(new MyRunable1());
		 * executorService.execute(new MyRunable2());
		 * executorService.execute(new MyRunable3());
		 * 
		 */
		
	} 
	
	/**
	 * 可缓存线程池,如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程(和数据库连接池类似)。
	 * 线程池的大小不受限，允许的最的线程数为：Integer.MAX_VALUE。
	 * 该方法内部使用使用了同步队列SynchronousQueue<Runnable>
	 */
	static void f2(){
		ExecutorService executorService = Executors.newCachedThreadPool();
		executorService.execute(new MyRunable1());
		executorService.execute(new MyRunable2());
		executorService.execute(new MyRunable3());
		executorService.shutdown();
	}
	/**
	 * 单线程的线程池,该线程池内部只维护一个线程。如果有多个任务，则按照指定顺序执行。
	 * 实际上，newSingleThreadExecutor()和newFixedThreadPool(1)是完全等价的。
	 * 该方法内部使用了阻塞队列LinkedBlockingQueue<Runnable>，超过池子容量的线程会在队列中等待
	 */
	static void f3(){
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		executorService.execute(new MyRunable1());
		executorService.execute(new MyRunable2());
		executorService.execute(new MyRunable3());
		executorService.shutdown();
	}
	
	
	/**
	 * 定长，可定时的线程池，
	 * 定时或周期性任务不要shutdown，否则线程池会销毁。
	 * 和quartz框架的作用一样，可以实现任务调度。
	 * 该方法内部使用了延迟队列DelayedWorkQueue。
	 */
	static void f4(){
		//ExecutorService executorService = Executors.newScheduledThreadPool(3);
		//ScheduledExecutorService继承自ExecutorService
		ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
		/**
		 * 任务1延迟4秒后执行
		 */
		executorService.schedule(new MyRunable1(),4,TimeUnit.SECONDS);
		
		/**
		 * 任务2， 1秒后开始启动，每隔3秒钟，就会周期执行
		 * 
		 * 第二个参数表示第一次延迟执行的时间，第三个参数表示周期性执行时的周期，即两次执行的时间间隔，第四个参数是时间单位。
		 * 该方法是固定频率，无论上一个任务是否结束，到时间就会执行新任务
		 */
		executorService.scheduleAtFixedRate(new MyRunable2(),1,3,TimeUnit.SECONDS);
		
		/**
		 * 任务3，1秒后开始启动，上一次执行结束后的，间隔3秒钟，周期执行期
		 * 第二个参数表示第一次延迟执行的时间，第三个参数表示周期性执行时的周期，但该方法会在上一次的任务执行结束后开始计时。该方法可以用来做任务调度。
		 */
		
		executorService.scheduleWithFixedDelay(new MyRunable3(),1,3,TimeUnit.SECONDS);
		//executorService.shutdown();
	}

}



class MyRunable1 implements Runnable{

	@Override
	public void run() {
		try {
			Thread.sleep(200);
			System.err.println(" 线程1     执行结束");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

class MyRunable2 implements Runnable{

	@Override
	public void run() {
		try {
			Thread.sleep(200);
			System.err.println(" 线程2     执行结束");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

class MyRunable3 implements Runnable{

	@Override
	public void run() {
		try {
			Thread.sleep(200);
			System.err.println(" 线程3     执行结束");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

参考连接：https://www.cnblogs.com/qlqwjy/p/9470414.html，感谢作者分享！