day23线程池

1、 线程池
先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交 通工具。
好处：
a) 提高响应速度（减少了创建新线程的时间）
b) 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
c) 便于线程管理
i. corePoolSize：核心池的大小
ii. maximumPoolSize：最大线程数
iii. keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程池API
 JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
 ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
 void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
 Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
 void shutdown() ：关闭连接池
 Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
 Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
 Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
 Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
 Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

package com.zrz.pool;

/**
 * 线程池的作用：

 线程池作用就是限制系统中执行线程的数量。
 根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；

 少了浪费了系统资源，多了造成系统拥挤效率不高。

 用线程池控制线程数量，其他线程排 队等候。

 一个任务执行完毕，再从队列的中取最前面的任务开始执行。

 若队列中没有等待进程，线程池的这一资源处于等待。

 当一个新任务需要运行时，如果线程池 中有等待的工作线程，就可以开始运行了；

 否则进入等待队列。

 为什么要用线程池:

 1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

 2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)
 */
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，
//则新建线程。线程池的规模不存在限制。（数量不固定的线程池）

public class _01_NewCachedThreadPoolTest {

	public static void main(String[] args) {
		// 创建池子
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		for (int i = 0; i < 10; i++) {
			final int index = i;
			try {
				Thread.sleep(index * 1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			cachedThreadPool.execute(new Runnable() {

				@Override
				public void run() {
					while (true) {
						try {
							Thread.sleep((long) ((Math.random() * 3 + 1) * 1000));
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName());

						System.out.println(index);
					}
				}
			});
		}
	}
}

package com.zrz.pool;

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

//创建一个固定长度线程池，可控制线程最大并发数，
//超出的线程会在队列中等待。（固定数量的线程池）
public class _02_NewFixedThreadPoolTest {
	public static void main(String[] args) {
		// 创建池子 指定并发数为3 , 最多3个
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
			final int ii = i;
			fixedThreadPool.execute(new Runnable() {

				@Override
				public void run() {
					System.out.println("线程名称：" + Thread.currentThread().getName() + "，执行" + ii);
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
	}
}

package com.zrz.pool;

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

//创建一个固定长度线程池，支持定时及周期性任务执行。（定时线程池）
public class _03_NewScheduledThreadPoolTest {
	public static void main(String[] args) {
		// work1();
		work2();
	}

	public static void work1() {
		// 创建池子 并指定长度5
		ScheduledExecutorService scheduledThreadPool = Executors
				.newScheduledThreadPool(5);
		// 1 线程对象 , 2 延迟初始化(延迟执行) , 3 计时单位SECONDS(秒)
		scheduledThreadPool.schedule(new Runnable() {

			@Override
			public void run() {
				System.out.println("delay 3 seconds");
			}
		}, 3, TimeUnit.SECONDS);
		// 如果不关闭池子,就算执行完,也会一直等待
		scheduledThreadPool.shutdown();
	}

	public static void work2() {
		ScheduledExecutorService scheduledThreadPool = Executors
				.newScheduledThreadPool(5);
		// 1 线程对象 , 2 初始化延迟(延迟执行), 3 间隔时间 , 4 计时单位SECONDS(秒)
		scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

			@Override
			public void run() {
				System.out
						.println("delay 1 seconds, and excute every 3 seconds");
			}
		}, 1, 3, TimeUnit.SECONDS);
	}
}

package com.zrz.pool;

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

/**
 * 单线程化线程池(newSingleThreadExecutor)的优点，串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。
 * 此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
 * 
 * @author 天亮教育-帅气多汁你泽哥
 * @Date 2021年1月28日
 */
public class _04_NewSingleThreadExecutor {
	// 通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；
	// 当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)
	// 适用：一个任务一个任务执行的场景
	public static void main(String[] args) {
		// 创建池子
		ExecutorService singleThreadExecutor = Executors
				.newSingleThreadExecutor();
		// 一次性创建10个请求
		for (int i = 0; i < 10; i++) {
			final int index = i;
			System.out.println("创建" + index + "次");
			// 只能依次执行
			singleThreadExecutor.execute(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println(Thread.currentThread().getName()
								+ "  " + index);

						Thread.sleep(2000);
						System.out.println("我是线程睡醒后的代码" + index);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
	}
}