ThreadPool笔记

四种线程池示例:

单线程化线程池newSingleThreadExecutor:

• 单线程化线程池(newSingleThreadExecutor)的优点，串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
• 示例代码:

public static void main(String[] args) {
   	ExecutorService service = Executors.newSingleThreadExecutor();
   	for(int i=0; i<5; i++) {
   		final int j = i;
   		service.execute(()->{	
   			System.out.println(j + " " + Thread.currentThread().getName());
   		});
   	}
   }
运行结果:
0 pool-1-thread-1
1 pool-1-thread-1
2 pool-1-thread-1
3 pool-1-thread-1
4 pool-1-thread-1

可控最大并发数线程池(newFixedThreadPool)

• 创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程（只有要请求的过来，就会在一个队列里等待执行）。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务。
• 示例代码:

public static void main(String[] args) throws Exception{
   	long start = System.currentTimeMillis();
   	getPrime(1, 200000); 
   	long end = System.currentTimeMillis();
   	System.out.println(end - start);
   	
   	final int cpuCoreNum = 4;
   	
   	ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);
   	
   	MyTask t1 = new MyTask(1, 80000); //1-5 5-10 10-15 15-20
   	MyTask t2 = new MyTask(80001, 130000);
   	MyTask t3 = new MyTask(130001, 170000);
   	MyTask t4 = new MyTask(170001, 200000);
   	
   	Future<List<Integer>> f1 = service.submit(t1);
   	Future<List<Integer>> f2 = service.submit(t2);
   	Future<List<Integer>> f3 = service.submit(t3);
   	Future<List<Integer>> f4 = service.submit(t4);
   	
   	start = System.currentTimeMillis();
   	f1.get();
   	f2.get();
   	f3.get();
   	f4.get();
   	end = System.currentTimeMillis();
   	System.out.println(end - start);
   }
   
   static class MyTask implements Callable<List<Integer>> {
   	int startPos, endPos;
   	
   	MyTask(int s, int e) {
   		this.startPos = s;
   		this.endPos = e;
   	}
   	
   	@Override
   	public List<Integer> call() throws Exception {
   		List<Integer> r = getPrime(startPos, endPos);
   		return r;
   	}
   	
   }
   
   static boolean isPrime(int num) {
   	for(int i=2; i<=num/2; i++) {
   		if(num % i == 0) return false;
   	}
   	return true;
   }
   
   static List<Integer> getPrime(int start, int end) {
   	List<Integer> results = new ArrayList<>();
   	for(int i=start; i<=end; i++) {
   		if(isPrime(i)) results.add(i);
   	}
   	
   	return results;
   }
运行结果:
2563
841

可回收缓存线程池(newCachedThreadPool)

• 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
• 示例代码:

public static void main(String[] args) throws InterruptedException {
   	ExecutorService service = Executors.newCachedThreadPool();
   	System.out.println(service);
   	for (int i = 0; i < 2; i++) {
   		service.execute(() -> {
   			try {
   				TimeUnit.MILLISECONDS.sleep(500);
   			} catch (InterruptedException e) {
   				e.printStackTrace();
   			}
   			System.out.println(Thread.currentThread().getName());
   		});
   	}
   	System.out.println(service);
   	TimeUnit.SECONDS.sleep(80);
   	System.out.println(service);
   }
运行结果:
java.util.concurrent.ThreadPoolExecutor@5e481248[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
java.util.concurrent.ThreadPoolExecutor@5e481248[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
pool-1-thread-2
pool-1-thread-1

支持定时与周期性任务的线程池(newScheduledThreadPool)

• 创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
• 示例代码:

   public static void main(String[] args) {
   	ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
   	service.scheduleAtFixedRate(()->{
   		try {
   			TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));
   		} catch (InterruptedException e) {
   			e.printStackTrace();
   		}
   		System.out.println(Thread.currentThread().getName());
   	}, 0, 500, TimeUnit.MILLISECONDS);
   }
运行结果:
pool-1-thread-1
pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1

笔记:

• 但是真实开发的时候 按照阿里开发规范都是要手动初始化线程池的.
  • 1.创建线程池,手动指定属性. 单例构造方法
  • 2.初始化所需要的bean. 多线程的时候是没有spring容器支持的.
    • 通过spring容器获取使用的bean,需要spring容器支持.
    • 将需要调用的类,当成参数参入传入到线程中去.
    • 采用内部类方案
  • 3.多线程的时候要注意 数据的引用方式.
  • 4.不要抛异常,因为没有人解决. 记录错误数据id和错误原因.打印日志.方便查阅
  • 5.数量大于50w条的时候list 就直接蹦掉了
  • 6.创建自己要执行的任务task.需要实现Callable