目录
一、Java多线程的四种创建方式
在开始介绍创建方式之前，先来看一个多线程的创建和启动图：
说明：
1、Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。下文将介绍的四种方式创建多线程，虽然各有千秋，但刨根见底，都离不开Thread类。
2、Thread类的特性
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
- 通过该Thread对象的start()方法来调用这个线程
继承Thread类
继承Thread类的操作步骤：
- 创建一个继承于Thread类的子类
- 重写Thread类的run()方法 --> 将此线程执行的操作声明在run()中
- 创建Thread类的子类的对象
- 通过此对象调用start()方法：①启动当前线程 ② 调用当前线程的run()
下面通过一个简单的例子来具体实现该方法的使用：
创建两个子线程分别打印10以内的奇数和偶数。
代码如下：
public class ThreadTest {
public static void main(String[] args) {
// 3、创建Thread的子类对象
getEvenNumber t1 = new getEvenNumber();
getOddNumber t2 = new getOddNumber();
t1.setName("线程1");
t2.setName("线程2");
// 4、通过此对象调用start()方法
t1.start();
t2.start();
}
}
// 1、创建一个继承于Thread类的子类
class getEvenNumber extends Thread {
// 2、重写Thread类的run()，将此线程的操作声明在run()中
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + "-偶数:" + i);
}
}
}
}
// 1、创建一个继承于Thread类的子类
class getOddNumber extends Thread {
// 2、重写Thread类的run()，将此线程的操作声明在run()中
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i %2 != 0){
System.out.println(getName() + "-奇数:" + i);
}
}
}
}执行结果如下：
备注：
1、如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
2、 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出“非法线程状态异常 < IllegalThreadStateException > ”。
实现Runnable接口
实现Runnable接口的方式步骤：
- 创建一个实现了Runnable接口的类
- 实现类去实现Runnable中的抽象方法：run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- 通过Thread类的对象调用start()
代码如下：
public class ThreadTest2 {
public static void main(String[] args) {
// 3. 创建实现类的对象
getEvenNumber2 even = new getEvenNumber2();
getOddNumber2 odd = new getOddNumber2();
// 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(even);
Thread t2 = new Thread(odd);
t1.setName("线程1");
t2.setName("线程2");
// 5. 通过Thread类的对象调用start()
t1.start();
t2.start();
}
}
// 1. 创建一个实现了Runnable接口的类
class getEvenNumber2 implements Runnable {
// 2. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + "-偶数:" + i);
}
}
}
}
// 1. 创建一个实现了Runnable接口的类
class getOddNumber2 implements Runnable {
// 2. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + "-奇数:" + i);
}
}
}
}执行结果如下：
实现Thread和继承Runnable的对比
联系：
Thread方法继承了Runnable接口。public class Thread implements Runnable
相同点：
1、两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。
2、目前这两种方式，要想启动线程，都是调用的Thread类中的start()。
开发中优先选择：实现Runnable接口的方式
原因：1. 实现的方式没有单继承性的局限性
2. 实现的方式更适合来处理多个线程共享数据的情况。
实现Callable接口
实现Callable接口的操作步骤：
- 创建一个实现Callable的实现类
- 实现call()方法，将此线程需要执行的操作声明在call()中
- 创建Callable接口实现类的对象
- 将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask的对象
- 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象
- 调用start()方法
- 如果需要处理返回值，则通过get()方法获取Callable中call()方法的返回值
按照惯例，通过一个小例子来演示该方法的使用：
创建一个子线程，用来打印10以内的偶数并返回其偶数之和。
主线程接收并打印子线程的偶数和。
代码如下：
public class ThreadCallable {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask<Integer> futureTask = new FutureTask<>(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println(Thread.currentThread().getName() + "-总和为：" + sum);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
//1.创建一个实现Callable的实现类
class NumThread implements Callable<Integer> {
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Integer call() {
int sum = 0;
for (int i = 1; i <= 10; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + "-偶数: " +i);
sum += i;
}
}
return sum;
}
}运行结果：
知识锦囊：
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
- call()可以有返回值。
- call()可以抛出异常，被外面的操作捕获，获取异常的信息
- Callable是支持泛型的
使用线程池
使用线程池的步骤：
- 提供指定线程数量的线程池
- 执行指定的线程的操作（需要提供实现Runnable接口或Callable接口实现类的对象）
- 关闭连接池
说明：
1、在这里，本文通过使用线程池创建线程的方式调用前文的两个方法（getOddNumber2()、NumThread()），实现打印10以内的奇数和偶数，以及偶数之和。
2、有关线程池的具体分析，本文将另起一章为读者呈现。
代码如下：
public class ThreadPoll {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(5);
// 2. 执行指定的线程的操作（需要提供实现Runnable接口或Callable接口实现类的对象）
service.execute(new getOddNumber2());
Future<Integer> res = service.submit(new NumThread());
System.out.println("偶数之和：" + res.get());
// 3. 关闭连接池
service.shutdown();
}
}运行结果：
备注：
读者可能会注意到，作者对于Runnable和Callable接口实现类的对象分别使用了不同的调用方法，查看对应的源码如下：
public interface Executor {
void execute(Runnable command);
}
public interface ExecutorService extends Executor {
...
<T> Future<T> submit(Callable<T> task);<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
...
}
以submit(Callable<T> task)展开为例，其底层调用了execute。
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
由源码，可以轻易的知道：
1、execute()方法的入参为一个Runnable
2、submit()入参可以为Callable<T>，也可以为Runnable，而且方法有返回值Future<T>；其底层调用了execute方法。
知识锦囊：
使用线程池创建线程的好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没任务时最多保持多长时间后会终止
二、解决线程安全的三种方式
在讨论解决线程安全的方式前，作者想先通过一个多线程经典案例之售票问题引出下文将要涉及的内容。
火车票售票案例：
写一个模拟三个窗口同时销售100张火车票的Java程序。
代码如下：
public class WindowBuyTicket2 {
public static void main(String[] args) {
sellTicket2 t1 = new sellTicket2();
sellTicket2 t2 = new sellTicket2();
sellTicket2 t3 = new sellTicket2();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class sellTicket2 extends Thread {
private static int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "出售票号:" + ticket);
ticket--;
}
else return;
}
}
}运行结果：
由上图的运行结果，可以总结出：
问题：卖票过程中，出现了重票、错票 --> 出现了线程的安全问题。
问题出现的原因：当某个线程操作共享数据（车票）的过程中，尚未操作完成时，其他线程参与进来，也操作共享数据（车票）。导致共享数据（车票）的错误。
如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
在Java中，我们通过同步机制，来解决线程的安全问题；共有以下三种解决方案。
同步代码块
同步代码块
synchronized(同步监视器){
// 需要被同步的代码
}
备注：
- 操作共享数据的代码，即为需要被同步的代码。
- 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
- 同步监视器，俗称：锁。
- 任何一个类的对象，都可以充当锁。所有对象都自动含有单一的锁（监视器）
- 要求：多个线程必须要共用同一把锁。
注意：同步的范围不能太大也不能太小。
范围太小：没锁住所有有安全问题的代码。
范围太大：没发挥多线程的功能。
代码中使用：
class sellTicket2 extends Thread {
private static int ticket = 100;
@Override
public void run() {
// synchronized (sellTicket2.class) { // 安全，但是范围太大，退化成单线程。在本例中，导致只有一个窗口售票
while (true) {
synchronized (sellTicket2.class) { // 安全，范围合适。
if (ticket > 0) {
// synchronized (sellTicket2.class) { // 不安全，范围小了。
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "出售票号:" + ticket);
ticket--;
} else return;
}
}
}
}为了方便理解同步原理，作者在此制作了一个简陋的动画，供读者参阅。
同步方法
如果操作共享数据的代码可以完整的声明在一个方法中，我们不妨将此方法声明为同步的，这样便得到了同步方法，
synchronized还可以放在方法声明中，表示整个方法为同步方法。
public static synchronized void sell (String name){
….
}
备注：细心的读者可能会发现在同步方法中并未看到监视器（锁）的身影，因为在同步方法中，所用的同步监视器不能指定，又因为方法分为静态和非静态，故监视器也有两种：
- 静态方法中，监控器是当前类本身
- 非静态方法中，监控器是调用该方法的对象，即this
代码如下：
public class WindowBuyTicket3 {
public static void main(String[] args) {
sellTicket3 t1 = new sellTicket3();
sellTicket3 t2 = new sellTicket3();
sellTicket3 t3 = new sellTicket3();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class sellTicket3 extends Thread {
private static int ticket = 100;
@Override
public void run() {
while (true) {
// 调用同步方法
sell();
}
}
// public static synchronized void sell(){ //监视器：当前类本身，即sellTicket3
public synchronized void sell() { // 监视器：当前对象，this
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "出售票号:" + ticket);
ticket--;
}
}
}Lock锁
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock(); // 显示加锁
try{
//保证线程安全的代码;} finally{
lock.unlock(); //显示释放锁}
} }
注意：如果同步代码有异常，要将unlock()写入finally语句块
- 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
代码如下：
public class ThreadLock {
public static void main(String[] args) {
// 创建一个线程工厂
ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("窗口%d").build();
/**
* 创建线程池的执行器，其中：
* int corePoolSize：核心池的大小为 1
* int maximumPoolSize,线程池最大线程数为 6
* keepAliveTime + TimeUnit, 存活时间为 1分钟
* BlockingQueue<Runnable> workQueue,阻塞队列大小为6
* **/
ThreadPoolExecutor service = new ThreadPoolExecutor(1, 6, 1l,
TimeUnit.MINUTES,
new LinkedBlockingQueue<>(6), threadFactory);
sellTicket_Clock se = new sellTicket_Clock();
// 创建9个任务
for (int i = 1; i < 10; i++) {
Thread t = new Thread(se);
service.execute(t);
}
// 关闭资源
service.shutdown();
}
}
class sellTicket_Clock implements Runnable {
private int ticket = 100;
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
// 加锁
lock.lock();
if (ticket > 0) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "出售票号:" + ticket);
ticket--;
} else return;
} finally {
// 解锁
lock.unlock();
}
}
}
}备注：
1、 该程序使用线程池创建了1个核心线程，5个非核心线程。9个线程任务，未被执行的线程任务放入阻塞队列中。
2、不理解线程池的读者可以提前预习第四章的线程池。
三、有关线程的知识补给站
基本概念：程序、进程、线程
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一
段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态
的过程：有它自身的产生、存在和消亡的过程。
- 程序是静态的，进程是动态的
- 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多个线程，就是支持多线程的
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间。它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
并行：多个CPU同时执行多个任务。
并发：一个CPU(采用时间片)同时执行多个任务。
线程的优先级
1、 线程的优先级等级可以分为三个：
- MAX_PRIORITY：10
- MIN _PRIORITY：1
- NORM_PRIORITY：5（默认）
2、涉及的方法
- getPriority() ：返回线程优先值
- setPriority(int newPriority) ：改变线程的优先级
3、说明
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
4、补充：Java中的线程分为两类：一种是守护线程，一种是用户线程
- 通过在start()方法前调用
- Thread.setDaemon(false)设置为用户线程
- Thread.setDaemon(true)设置为守护线程
- 守护线程是用来服务用户线程的，所以又被称为服务线程
- 它们几乎在每个方面都是相同的，唯一的区别是判断JVM何时离开。
- 主线程结束后用户线程还会继续运行，JVM存活
- 如果没有用户线程，都是守护线程，那么JVM结束（所有的线程都会结束）
线程的生命周期
JDK中用Thread.State类定义了线程的几种状态，要想实现多线程，必须在主线程中创建新的线程对象。
Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
- 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
线程的通讯
1、为什么要线程通信？
- 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当需要多个线程来共同完成一件任务，并且希望它们能有规律的执行, 那么多线程之间需要一些协调通信，以此来达到多线程共同有规律的操作同一份数据。
- 引入了线程之间的通信，使得多线程之间能够避免对同一共享变量的争夺。
2、什么是线程通信？
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。
3、等待唤醒机制：wait()、notify()、notifyAll()
- wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
- notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
- notifyAll ()：唤醒正在排队等待资源的所有线程结束等待
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报
java.lang.IllegalMonitorStateException异常。
4、生产者和消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20）。
如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品，再通知生产者继续生产；
如果店中没有产品，店员会告诉消费者等一下，如果店中有产品，再通知消费者来取走产品。
备注： 作者在此处创建了一个生产者和三个消费者。
代码实现：
public class ProducerAndCustomer {
public static void main(String[] args) {
Clerk clerk = new Clerk();
// 一个生产者
Producer producer = new Producer(clerk);
Thread producerThread = new Thread(producer);
producerThread.start();
// 三个消费者
Consumer consumer = new Consumer(clerk);
for (int i = 1; i < 4; i++) {
Thread consumerThread = new Thread(consumer);
String name = "消费者" + i;
consumerThread.setName(name);
consumerThread.start();
}
}
}
class Clerk { // 售货员
private int product = 0;
public synchronized void addProduct() {
if (product >= 20) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
product++;
System.out.println("生产者生产了第" + product + "个产品");
// 唤醒所有被阻塞的消费者
notifyAll();
}
}
public synchronized void getProduct() {
if (this.product <= 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System.out.println(Thread.currentThread().getName() + "取走了第" + product + "个产品" + "-----库存量：" + --product);
// 唤醒生产者
notify();
}
}
}
class Producer implements Runnable { // 生产者
Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
public void run() {
System.out.println("生产者开始生产产品");
while (true) {
try {
Thread.sleep((int) (Math.random() * 200));
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.addProduct();
}
}
}
class Consumer implements Runnable { // 消费者
Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
public void run() {
System.out.println("消费者开始取走产品");
while (true) {
try {
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.getProduct();
}
}
}运行结果：
四、线程池
百度百科对线程池的简介如下：
线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。 例如，线程数一般取cpu数量+2比较合适，线程数过多会导致额外的线程切换开销。
在前文使用lock解决线程安全的同步机制代码中，作者使用了 ThreadPoolExecutor创建线程池，该类的源码如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
- corePoolSize：核心池的大小。
- 在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务。
- 除非调用了预创建线程方法：prestartAllCoreThreads()或者prestartCoreThread()。即在没有任务到来之前就创建corePoolSize个线程或者一个线程。
- 当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中
- maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程；
- keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。
- 默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。
- 如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
- unit：参数keepAliveTime的时间单位
- workQueue：一个阻塞队列，用来存储等待执行的任务。
- threadFactory：线程工厂，主要用来创建线程；
补充一个参数handler参数，也是 ThreadPoolExecutor构造器中的一个入参：
- handler：线程饱和策略，当线程池和队列都满了，再加入线程会执行此策略，有以下四种取值：
由此，线程池的基础知识以全部介绍完毕，以两个小图来对线程池的流程和重要参数做总结。
线程池的流程图
线程池的重要参数图
由图可视，线程池中只有一个核心线程，但是有5个非核心线程，故线程池中可以容纳的最大线程数为6，阻塞队列长度也为6。
具体是不是作者所写的呢，为了验证猜想，在代码中加入一些打印信息：
System.out.println("线程池中核心线程数目" + service.getCorePoolSize()
+ ", 非核心线程数目" + (service.getMaximumPoolSize() - service.getCorePoolSize())
+ ", 总的任务数" + service.getTaskCount()
+ ", 队列中等待执行的任务数目："+ service.getQueue().size()
+ "\n队列信息：" + service.getQueue().toString());执行结果：
结果不言而喻。并且，由打印的信息，也刚好验证了前文所述的线程默认优先级为NORM_PRIORITY：5，子线程由主线程创建。
再看售票信息如下：
也同样说明了有非核心线程也参与了售票。
写到这，作者想起当年上课时老师对核心线程和非核心的比喻，分享给读者，作为该篇的结束语。
将线程池比做一个学校，则核心线程就是该学校的教师，假设一位教师只能教一门语言。学校共有C、C++、Java和Python共四门语言，和四位教师，此时教学任务井井有条。突然，教育局需要临时加一门多核多线程的课，而且该课程只开设一个学期，这时学校只能外聘教师完成教学任务，当课程结束并给外聘教师发工资后，外聘教师也就可以不在聘用。
该例子中，学校教师和外聘教师就是线程池中的核心线程和非核心线程，核心线程一直保留，非核心线程在没有任务后且到达了保持活跃的时间后就会被销毁。
路漫漫其修远兮，吾将上下而求索。 ---屈原
490
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
