叮铃铃~

谁啊，大早上的扰人清梦，不知道好不容易有个周末吗？接电话知道是朋友约我出去钓鱼，顺便跟我聊一下前段时间让他帮忙内推一下我小侄子去实习的事情

见面之后，他直接开门见山，小侄子在面试的时候表现不错，最后一面是他来面的，问的相当深入，侄子表现也不错，但是在多线程这个地方，他稍微问的深入了一些，小朋友明显的慌张起来，很多知识点回答的相当不好（我说这小子怎么面试回来之后都不敢找我问问题了），朋友说问题不大，这里他不会卡他，过几天应该就能收到offer了

虽然朋友这样说，但是心里却记下了，多线程这一块该给这小子补习一下了

其实多线程应该是现在很多朋友的难点吧，没什么时间看源码，工作的时候又很少能应用得到，但是在面试的时候，这一块又是面试的重点，那应该怎么办呢？其实不需要慌张，因为面试也算是考试，考试就会划重点，我总共总结出以下几点，大家可以先看一下能详细的回想起来多少

线程sleep

线程yield

设置线程的优先级获取线程ID

获取当前线程

设置线程上下文类加载器

线程interrupt

线程join

如何关闭—个线程

如果你能回答出来80%以上，那基本就没什么问题了，不然，你可能要仔细的往下看，有的朋友会说我还年轻，不需要这个，那我要告诉你，这些知识点确实可能不会阻挡你拿offer，但是，会影响你后期的发展速度以及在公司享受的资源，不信就去问你老大

好了，话不多说，我们来看一下从源码角度，这些问题你都该回答那些东西

线程 sleep

sleep是一个静态方法，其有两个重载方法，其中一个需要传入毫秒数，另外一个既需要毫秒数也需要纳秒数。

sleep方法介绍

 public static void sleep(long millis) throws InterruptedException
 public static void sleep(long millis, int nanos) throws InterruptedException

sleep方法会使当前线程进入指定毫秒数的休眠，暂停执行，虽然给定了一个休眠的时间，但是最终要以系统的定时器和调度器的精度为准，休眠有一个非常重要的特性, 那就是其不会放弃monitor锁的所有权(在后文中讲解线程同步和锁的时候会重点介绍 monitor),下面我们来看一个简单的例子：

package com.wangwenjun,concurrent,chapter03;
public class Threadsleep
public static void main(String[] args)
new Thread(()->

long startTime = System.currentTimeMillis();
sleep(2_000L);
long endTime = System.currentTimeMillis();
System.out.printin(String.format("Total spend %d ms", (endTime - startTime)));
}).start()；
long startTime = System.currentTimeMillis();
sleep(3_000L);
long endTime = System.currentTimeMillis();
System.out.printin(String.format("Main thread total spend %d ms", (endTime - startTime)));
}
private static void sleep(long ms)
{
try
{
Thread.sleep(ms);
} catch (InterruptedException e)
{
}
}
}

在上面的例子中，我们分别在自定义的线程和主线程中进行了休眠，每个线程的休眠互不影响，Thread.sleep只会导致当前线程进入指定时间的休眠。

使用 TimeUnit 替代 Thread.sleep

在JDK1.5以后，JDK引入了一个枚举TimeUnit,其对sleep方法提供了很好的封装, 使用它可以省去时间单位的换算步骤，比如线程想休眠3小时24分17秒88毫秒，使用 TimeUnit来实现就非常的简便优雅了：

Thread.sleep(12257088L);
TimeUnit.HOURS.sleep(3);
TimeUnit・ MINUTES.sleep(24);
TimeUnit, SECONDS・ sleep(17);
TimeUnit.MILLISECONDS.sleep(88);

同样的时间表达，TimeUnit显然清晰很多，笔者强烈建议，在使用Thread.sleep的地方，完全使用TimeUnit来代替，因为sleep能做的事，TimeUnit全部都能完成，并且功能更加的强大，在本书后面的内容中，我将全部采用TimeUnit替代sleep。

线程 yield

yield方法介绍

yield方法属于一种启发式的方法，其会提醒调度器我愿意放弃当前的CPU资源，如果 CPU的资源不紧张，则会忽略这种提醒。

调用yield方法会使当前线程从RUNNING状态切换到RUNNABLE状态，一般这个方法不太常用：

package com.wangwenjun.concurrent,chapter03;
import java.util.stream.IntStream;
public class ThreadYield
{
public static void main(String[] args)
{
IntStream.range(0, 2).mapToObj(ThreadYield::create)
.forEach(Thread::start);
}
private static Thread create(int index)
{
return new Thread(() ->
{
//①注释部分
//if (index == 0)
// Thread, yield();
System.out.printin(index);
})；
}
}

上面的程序运行很多次，你会发现输出的结果不一致，有时候是0最先打印出来，有

时候是1最先打印出来，但是当你打开代码的注释部分，你会发现，顺序始终是0, 10 因为第一个线程如果最先获得了 CPU资源，它会比较谦虚，主动告诉CPU调度器是放了原本属于自己的资源，但是yield R是一个提示(hint), CPU调度器并不会担保每次都能满足yield提示。

yield sleep

看过前面的内容之后，会发现yield和sleep有一些混淆的地方，在JDK1.5以前的版本中yield的方法事实上是调用了 sleep(O),但是它们之间存在着本质的区别，具体如下。

□ sleep会导致当前线程暂停指定的时间，没有CPU时间片的消耗。

□ yield只是对CPU调度器的一个提示，如果CPU调度器没有忽略这个提示，它会导

致线程上下文的切换。

□ sleep会使线程短暂block,会在给定的时间内释放CPU资源。

□ yield会使RUNNING状态的Thread进入RUNNABLE状态(如果CPU调度器没有忽略这个提示的话)。

□ sleep几乎百分之百地完成了给定时间的休眠，而yield的提示并不能一定担保。

□ 一个线程sleep另一个线程调用interrupt会捕获到中断信号，而yield则不会。

设置线程的优先级

□ public final void setPriority(int newPriority)为线程设定优先级。

□ public final int getPriority()获取线程的优先级。

线程优先级介绍

进程有进程的优先级，线程同样也有优先级，理论上是优先级比较高的线程会获取优先被CPU调度的机会，但是事实上往往并不会如你所愿，设置线程的优先级同样也是一个 hint操作，具体如下。

□对于root用户，它会hint操作系统你想要设置的优先级别，否则它会被忽略。

□如果CPU比较忙，设置优先级可能会获得更多的CPU时间片，但是闲时优先级的高低几乎不会有任何作用。

所以，不要在程序设计当中企图使用线程优先级绑定某些特定的业务，或者让业务严重依赖于线程优先级，这可能会让你大失所望。举个简单的例子，可能不同情况下的运行效果不会完全一样，但是我们只是想让优先级比较高的线程获得更多的信息输出机会，示例代码如下：

package com.wangwenjun.concurrent.chapter03;
public class Threadpriority
{
public static void main(String[] args)
{
Thread tl = new Thread(()->
{
while (true)
{
System.out.printin("tl");
}
})；
tl・ setPriority(3);

Thread t2 = new Thread(()->
{
while (true)
{
System. out. printin (,lt2");
}
})；
t2.setPriority(10);
tl.start();
t2.start();
}
}

运行上面的程序，会发现t2出现的频率很明显要高一些，当然这也和笔者当前CPU的资源情况有关系，不同情况下的运行会有不一样的结果。

线程优先级源码分析

设置线程的优先级，只需要调用setPriority方法即可，下面我们打开Thread的源码, 一起来分析一下：

public final void setPriority(int newPriority) {
ThreadGroup g; checkAccess(); if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) { throw new IllegalArgumentException();
}
if((g = getThreadGroup()) 1= null) {
if (newPriority > g.getMaxPriority()) { newPriority = g.getMaxPriority();
}
setPriorityO(priority = newPriority);
}
}

通过上面源码的分析，我们可以看出，线程的优先级不能小于1也不能大于10,如果指定的线程优先级大于线程所在group的优先级，那么指定的优先级将会失效，取而代之的是group的最大优先级，下面我们通过一个例子来证明一下：

package com.wangwenjun.concurrent.chapter03;
public class Threadpriority
{
public static void main(String[] args)
{
//定义一个线程组
ThreadGroup group = new ThreadGroup("test");
//将线程组的优先级指定为7
group.setMaxPriority(7);
//定义一个线程，将该线程加入到group中
Thread thread = new Thread(group, "test-thread");
//企图将线程的优先级设定为10
thread.setPriority(10);
/ /企图未遂
System.out.printin(thread.getPriority());
}
}

上面的结果输出为7,而不是10,因为它超过了所在线程组的优先级别

关于优先级的一些总结

一般情况下，不会对线程设定优先级别，更不会让某些业务严重地依赖线程的优先级别，比如权重，借助优先级设定某个任务的权重，这种方式是不可取的，一般定义线程的时候使用默认的优先级就好了，那么线程默认的优先级是多少呢？

线程默认的优先级和它的父类保持一致，一般情况下都是5,因为main线程的优先级就是5,所以它派生出来的线程都是5,示例代码如下：

package com.wangwenjun.concurrent.chapter03;
public class Threadpriority
{
public static void main(String[] args)
{
Thread tl = new Thread();
System.out,println("tl priority " + tl.getPriority());
Thread t2 = new Thread(()->
{
Thread t3 = new Thread();
System.out.printIn("t3 priority " + t3.getPriority());
})；
t2 ・ setPriority(6);
t2 ・ start();
System.out.printin("t2 priority " + t2.getPriority());

上面程序的输出结果是tl的优先级为5,因为main线程的优先级是5 ; t2的优先级是6,因为显式地将其指定为6； t3的优先级为6,没有显式地指定，因此其与父线程保持一致。

获取线程ID

public long getld()获取线程的唯一 ID,线程的ID在整个JVM进程中都会是唯一的,

并且是从0开始逐次递增。如果你在main线程(main函数)中创建了一个唯一的线程，并且调用getld()后发现其并不等于0,也许你会纳闷，不应该是从0开始的吗？之前已经说过了在一个JVM进程启动的时候，实际上是开辟了很多个线程，自增序列已经有了一定的消耗，因此我们自己创建的线程绝非第0号线程。

获取当前线程

public static Thread currentThread()用于返回当前执行线程的引用，这个方法虽然很简单，但是使用非常广泛，我们在后面的内容中会大量的使用该方法，来看一段示例代码：

 package com.wangwenjun.concurrent.chapter03;
public class CurrentThread
{
public static void main(String[] args)
{
Thread thread = new Thread()
{
@Override
public void run()
{
//always true System.out.printin(Thread.CurrentThread() == this);
}
}；
thread, start();
String name = Thread.CurrentThread().getName(); System.out.printIn("main".equals(name));
}
}

上面程序运行输出的两个结果都是true。

设置线程上下文类加载器

□ public ClassLoader getContextClassLoader()获取线程上下文的类加载器，简单来说就是这个线程是由哪个类加器加载的，如果是在没有修改线程上下文类加载器的情况下，则保持与父线程同样的类加载器。

□ public void setContextClassLoader(ClassLoader cl)设置该线程的类加载器，这个方法可以打破JAVA类加载器的父委托机制，有时候该方法也被称为JAVA类加载器的后门。

关于线程上下文类加载器的内容我们将在本书的第11章重点介绍，并且结合jdbc驱动包的源码分析JDK的开发者为什么要留有这样的后门。

线程 interrupt

线程interrupt,是一个非常重要的API,也是经常使用的方法，与线程中断相关的API 有如下几个，在本节中我们也将Thread深入源码对其进行详细的剖析。

□ public void interrupt()
□ public static boolean interrupted()
□ public boolean islnterrupted()

interrupt

如下方法的调用会使得当前线程进入阻塞状态，而调用当前线程的interrupt方法，就可以打断阻塞。

□ Object 的 wait 方法。
□ Object 的 wait(long)方法。
□ Object 的 wait(long,int)方法。
□ Thread 的 sleep(long)方法。
□ Thread 的 sleep(long,int)方法。
□ Thread 的 join 方法。
□ Thread 的 join(long)方法。
□ Thread 的 join(long,int)方法。
□ InterruptibleChannel 的 io 操作。
□ Selector 的 wakeup 方法。

□其他方法。

上述若干方法都会使得当前线程进入阻塞状态，若另外的一个线程调用被阻塞线程的 interrupt方法，则会打断这种阻塞，因此这种方法有时会被称为可中断方法，.记住，打断一个线程并不等于该线程的生命周期结束，仅仅是打断了当前线程的阻塞状态。

一旦线程在阻塞的情况下被打断，都会抛出一个称为InterruptedException的异常，这个异常就像一个signal (信号)一样通知当前线程被打断了，下面我们来看一个例子：

package com.wangwenjun,concurrent,chapter03;
import java.util.concurrent .TimeUnit;
public class Threadinterrupt
public static void main(String[] args) throws InterruptedException
{
Thread thread = new Thread(()->
{
try
{
TimeUnit•MINUTES.sleep(1);
} catch (InterruptedException e)
{
System.out.printIn("Oh, i am be interrupted.");
} 、
})；
thread.start();
//short block and make sure thread is started.
TimeUnit, MILLISECONDS.sleep(2);
thread, interrupt();
}
}

上面的代码创建了一个线程，并且企图休眠1分钟的时长，不过很可惜，大约在2毫秒之后就被主线程调用interrupt方法打断，程序的执行结果就是“Oh, i am be interrupted.”

interrupt这个方法到底做了什么样的事情呢？在一个线程内部存在着名为interrupt flag 的标识，如果一个线程被interrupt,那么它的flag将被设置，但是如果当前线程正在执行可中断方法被阻塞时，调用interrupt方法将其中断，反而会导致flag被清除，关于这点我们在后面还会做详细的介绍。另外有一点需要注意的是，如果一个线程已经是死亡状态, 那么尝试对其的interrupt会直接被忽略。

islnterrupted

islnterrupted是Thread的一个成员方法，它主要判断当前线程是否被中断，该方法仅仅是对interrupt标识的一个判断，并不会影响标识发生任何改变，这个与我们即将学习到的interrupted是存在差别的，下面我们看一个简单的程序：

package com.wangwenjun,concurrent•chapter03;
import java.util.concurrent.TimeUnit;
public class ThreadisInterrupted
{
public static void main(String[] args) throws InterruptedException
Thread thread = new Thread()
{
@Override
public void run()
{
while (true)
{
//do nothing, just empty loop.
}
}
}；
thread.start();
TimeUnit.MILLISEC0NDS.sleep(2);
System.out.printf("Thread is interrupted ? %s\n", thread.isInterrupted()); thread.interrupt();
System.out.printf("Thread is interrupted ? %s\n", thread.islnterrupted());
}
}

上面的代码中定义了一个线程，并且在线程的执行单元中(run方法)写了一个空的死循环，为什么不写sleep呢？因为sleep是可中断方法，会捕获到中断信号，从而干扰我们程序的结果。下面是程序运行的结果，记得手动结束上面的程序运行，或者你也可以将上面定义的线程指定为守护线程，这样就会随着主线程的结束导致JVM中没有非守护线程而自动退出。

Thread is interrupted ? false
Thread is interrupted ? true

可中断方法捕获到了中断信号(signal)之后，也就是捕获了 InterruptedException异常之后会擦除掉interrupt的标识，对上面的程序稍作修改，你会发现程序的结果又会出现很大的不同，示例代码如下：

package com.wangwenjun.concurrent.chapter03;
import java.util.concurrent.TimeUnit;
public class ThreadisInterrupted
{
public static void main(String[] args) throws InterruptedException
{
Thread thread = new Thread()
{
@Override
public void run()
while (true)

try
{
TimeUnit.MINUTES.sleep(1);
} catch (InterruptedException e)
{
//ignore the exception
//here the interrupt flag will be clear.
System.out.printf("I am be interrupted ? %s\n", islnterrupted());
}
}
}
}；
thread.setDaemon(true);
thread.start();
TimeUnit.MILLISECONDS.sleep(2);
System.out.printf("Thread is interrupted ? %s\n", thread.isInterrupted()); thread.interrupt();
TimeUnit, MILLISECONDS・ sleep(2); System.out.printf("Thread is interrupted ? %s\n", thread.isInterrupted());
}
}

由于在run方法中使用了 sleep这个可中断方法，它会捕获到中断信号，并且会擦除 interrupt标识，因此程序的执行结果都会是false,程序输岀如下：

Thread is interrupted ? false
I am be interrupted ? false
Thread is interrupted ? false

其实这也不难理解，可中断方法捕获到了中断信号之后，为了不影响线程中其他方法的执行，将线程的interrupt标识复位是一种很合理的设计。

interrupted

interrupted是一个静态方法，虽然其也用于判断当前线程是否被中断，但是它和成员方法islnterrupted还是有很大的区别的，调用该方法会直接擦除掉线程的interrupt标识，需要注意的是，如果当前线程被打断了，那么第一次调用interrupted方法会返回true,并且立即擦除了 interrupt标识；第二次包括以后的调用永远都会返回false,除非在此期间线程又一次地被打断，下面设计了一个简单的例子，来验证我们的说法：

package com.wangwenjun.concurrent.chapter03;
import java.util.concurrent.TimeUnit;
public class Threadinterrupted
public static void main(String[] args) throws InterruptedException
{
Thread thread = new Thread()
{
@Override
public void run()
{
while (true)
{
System.out.printIn(Thread.interrupted());
}
}
}；
thread.setDaemon(true);
thread.start();
//shortly block make sure the thread is started.
TimeUnit, MILLISECONDS.sleep(2); thread.interrupt();
}
}

同样由于不想要受到可中断方法如sleep的影响，在Thread的run方法中没有进行任何短暂的休眠，所以运行上面的程序会出现非常多的输出，但是我们通过对输出的检查会发现如下所示的内容，其足以作为对该方法的解释。

false
false
true
false
false

在很多的false包围中发现了一个true,也就是interrupted方法判断到了其被中断，立即擦除了中断标识，并且只有这一次返回true,后面的都将会是false。

interrupt 注意事项

打开Thread的源码，不难发现，islnterrupted方法和interrupted方法都调用了同一个本地方法：

private native boolean islnterrupted(boolean Clearlnterrupted);

其中参数Clearlnterrupted主要用来控制是否擦除线程interrupt的标识。

islnterrupted方法的源码中该参数为false,表示不想擦除：

public boolean islnterrupted() { return islnterrupted(false);
}

而interrupted静态方法中该参数则为true,表示想要擦除：

public static boolean interrupted() {
return currentThread().islnterrupted(true);
}

在比较详细地学习了 interrupt方法之后，大家思考一个问题，如果一个线程在没有执行可中断方法之前就被打断，那么其接下来将执行可中断方法，比如sleep会发生什么样的情况呢？下面我们通过一个简单的实验来回答这个疑问：

public static void main(String!] args)
{
//① 判断当前线程是否被中断
System.out.printin("Main thread is interrupted? " + Thread.interrupted());
//②中断当前线程
Thread.currentThread().interrupt();
//③判断当前线程是否已经被中断
System.out.printin("Main thread is interrupted? " + Thread.currentThread(). islnterrupted());
try
{
//④ 当前线程执行可中断方法 TimeUnit.MINUTES.sleep(1);
} catch (InterruptedException e)
{
//⑤捕获中断信号
System.out.printin("I will be interrupted still.");
}
}

通过运行上面的程序，你会发现，如果一个线程设置了 interrupt标识，那么接下来的可中断方法会立即中断，因此注释⑤的信号捕获部分代码会被执行，请大家注意注释①和注释③中判断线程中断方法的不同，也希望读者结合本节的内容思考为什么要这么做？

线程 join

Thread的join方法同样是一个非常重要的方法，使用它的特性可以实现很多比较强大的功能，与sleep -样它也是一个可中断的方法，也就是说，如果有其他线程执行了对当前线程的interrupt操作，它也会捕获到中断信号，并且擦除线程的interrupt标识，Thread的 API为我们提供了三个不同的join方法，具体如下。

□ public final void join() throws InterruptedException
□ public final synchronized void join(long millis, int nanos)
throws InterruptedException
□ public final synchronized void join(long millis)
throws InterruptedException

在本节中，笔者将会详细介绍join方法以及如何在实际应用中使用join方法。

线程join方法详解

join某个线程A,会使当前线程B进入等待，直到线程A结束生命周期，或者到达给定的时间，那么在此期间B线程是处于BLOCKED的，而不是A线程，下面就来通过一个简单的实例解释一下join方法的基本用法：

package com.wangwenjun.concurrent.chapter03;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
import static java.util.stream.Collectors.toList;
public class Threadjoin
{
public static void main(String[] args) throws InterruptedException
{
//①定义两个线程，并保存在threads中
List threads = IntStream.range(1, 3)
.mapToObj(Threadjoin::create).collect(toList());
//②启动这两个线程
threads•forEach(Thread::start);
//③ 执行这两个线程的join方法
for (Thread thread : threads)
{
thread.join();
}
//④main线程循环输出
for (int i = 0; i < 10; i++)
System.out.printin(Thread.currentThread().getName() + "+ i); shortSleep();

//构造一个简单的线程，每个线程只是简单的循环输出
private static Thread create(int seq)
{
return new Thread(() ->
{
for (int i = 0; i < 10; i++)
{
System・ out・ printin(Thread.currentThread()・ getName() + "#" + i); shortSleep();
}
}, String.valueOf(seq));
}
private static void shortSleep()
{
try
{
TimeUnit, SECONDS.sleep(1);
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
}

上面的代码结合Java 8的语法，创建了两个线程，分别启动，并且调用了每个线程的 join方法(注意：join方法是被主线程调用的，因此在第一个线程还没有结束生命周期的时后，第二个线程的join不会得到执行，但是此时，第二个线程也已经启动了)，运行上面的程序，你会发现线程一和线程二会交替地输出直到它们结束生命周期，main线程的循环才会开始运行，程序输岀如下：

2#8
1#8
2#9
1#9
main#0
main#l
main#2
main#3

如果你将注释③下面的join全部注释掉，那么三个线程将会交替地输出，程序输出如下：

main#2
2#2
1#2
main#3
1#3
2#3 main#4

join方法会使当前线程永远地等待下去，直到期间被另外的线程中断，或者join的线程执行结束，当然你也可以使用join的另外两个重载方法，指定毫秒数，在指定的时间到达之后，当前线程也会退出阻塞。同样思考一个问题，如果一个线程已经结束了生命周期，那么调用它的join方法的当前线程会被阻塞吗？

join方法结合实战

本节我们将结合一个实际的案例,来看一下join方法的应用场景，假设你有一个APP, 主要用于查询航班信息，你的APP是没有这些实时数据的，当用户发起查询请求时，你需要到各大航空公司的接口获取信息，最后统一整理加工返回到APP客户端，如图3-1所示, 当然JDK自带了很多高级工具，比如CountDownLatch和CyclicBarrier等都可以完成类似的功能，但是仅就我们目前所学的知识，使用join方法即可完成下面的功能。

多线程源码明白了吗？不明白的话来看腾讯大牛给你画的面试重点

该例子是典型的串行任务局部并行化处理，用户在APP客户端输入出发地“北京”和目的地“上海”，服务器接收到这个请求之后，先来验证用户的信息，然后到各大航空公司的接口查询信息，最后经过整理加工返回给客户端，每一个航空公司的接口不会都一样, 获取的数据格式也不一样，查询的速度也存在着差异，如果再跟航空公司进行串行化交互（逐个地查询），很明显客户端需要等待很长的时间，这样的话，用户体验就会非常差。如果我们将每一个航空公司的查询都交给一个线程去工作，然后在它们结束工作之后统一对数据进行整理，这样就可以极大地节约时间，从而提高用户体验效果。

代码清单3-1 查询接口 FightQuery

package com.wangwenjun.concurrent.chapter03;
import j ava.util.List;
public interface FightQuery
{
List get();
}

在代码清单3-1中，FightQuery提供了一个返回方法，写到这里大家应该注意到了，不管是Thread的run方法，还是Runnable接口，都是void返回类型，如果你想通过某个线程的运行得到结果，就需要自己定义一个返回的接口。

查询Fight的task,其实就是一个线程的子类，主要用于到各大航空公司获取数据，示例代码如下：

package com.wangwenjun,concurrent.chapter03;
import java.util.ArrayList;
import j ava.util.List;
import j ava.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
public class FightQueryTask extends Thread implements FightQuery

public FightQueryTask(String airline, String origin, String destination)
super("[" + airline + "]"); this.origin = origin;
this.destination = destination; }
@Override public void run()
{
System.out.printf("%s-query from %s to %s \n", getName(), origin, destination);
int randomVal = ThreadLocalRandom.current().nextlnt(10);
try
{
TimeUnit.SECONDS.sleep(randomVal);
this.flightList.add(getName() + + randomVal);
System.out.printf("The Fight:%s list query successful\n", getName());
} catch (InterruptedException e)
{
}
}
@Override
public List get()
{
return this.flightList;
}
}

接口定义好了，查询航班数据的线程也有了，下面就来实现一下从SH (上海)到北京 (BJ)的航班查询吧！示例代码如下：

package com.wangwenjun.concurrent.chapter0 3;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static java.util.stream.Collectors.toList;
public class FightQueryExample
{
//①合作的各大航空公司
private static List fightCompany = Arrays.asList(
"CSA", "CEA", "HNA"
)；
public static void main(String[] args)
{
List results = search("SH", "BJ");
System.out.printin("===========result===========");
results , forEach(System•out::printin);
}
private static List search(String original, String dest)
{
final List result = new ArrayList<>();
//②创建查询航班信息的线程列表
List tasks = fightCompany.stream()
.map(f -> createSearchTask(f, original, dest))
.collect(toList());
//③分别启动这几个线程
tasks , forEach(Thread::start);

〃④分别调用每一个线程的join方法，阻塞当前线程 tasks.forEach（t ->
try
t.join();
} catch (InterruptedException e)
{
}
})；
//⑤在此之前，当前线程会阻塞住，获取每一个查询线程的结果，并且加入到result中
tasks.stream().map(FightQuery::get).forEach(result::addAll);
return result;
}
FightQueryTask createSearchTask( fight,
original, String dest)
return new FightQueryTask(fight, original, dest);
}

上面的代码，关键的地方已通过注释解释得非常清楚，主线程收到了 search请求之后, 交给了若干个查询线程分别进行工作，最后将每一个线程获取的航班数据进行统一的汇总。由于每个航空公司的查询时间可能不一样，所以用了一个随机值来反应不同的查询速度, 返回给客户端（打印到控制台），程序的执行结果输出如下：

[CSA]-query from SH to BJ [CEA]-query from SH to BJ [HNA]-query from SH to BJ The Fight:[HNA] list query The Fights[CSA] list query The Fight:[CEA] list query ===========result=========： [CSA]-4
[CEA]-7
[HNA]-2

如何关闭一•个线程

JDK有一个Deprecated方法stop,但是该方法存在一个问题，JDK官方早已经不推荐使用，其在后面的版本中有可能会被移除，根据官网的描述，该方法在关闭线程时可能不

会释放掉monitor的锁，所以强烈建议不要使用该方法结束线程，本节将主要介绍几种关闭线程的方法。

正常关闭

1. 线程结束生命周期正常结束

线程运行结束，完成了自己的使命之后，就会正常退出，如果线程中的任务耗时比较短，或者时间可控，那么放任它正常结束就好了。

2. 捕获中断信号关闭线程

我们通过new Thread的方式创建线程，这种方式看似很简单，其实它的派生成本是比较高的，因此在一个线程中往往会循环地执行某个任务，比如心跳检查，不断地接收网络消息报文等，系统决定退出的时候，可以借助中断线程的方式使其退出，示例代码如下：

package com.wangwenjun.concurrent.chapter0 3;
import java.util.concurrent. TimeUnit;
public class InterruptThreadExit
{
public static void main(String[] args) throws InterruptedException
{
Thread t = new Thread()
{
@Override
public void run()
{
System.out.printin("I will start work");
while (!islnterrupted())
{
//working.
}
System.out.printin("I will be exiting.");
}
}；
t.start();
TimeUnit.MINUTES・ sleep(1); System.out.printin("System will be shutdown."); t.interrupt();
}
}

上面的代码是通过检查线程interrupt的标识来决定是否退出的，如果在线程中执行某个可中断方法，则可以通过捕获中断信号来决定是否退出。

@Override
public void run()
System.out.printin("I will start work"); for (;;)
//working, try
TimeUnit.MILLISECONDS.sleep(l); catch (InterruptedException e)
break;
}
}
System.out.printin("I will be exiting.");
}

上面的代码执行结果都会导致线程正常的结束，程序输出如下:

I will start work
System will be shutdown.
I will be exiting.

3. 使用volatile开关控制

由于线程的interrupt标识很有可能被擦除，或者逻辑单元中不会调用任何可中断方法, 所以使用volatile修饰的开关flag关闭线程也是一种常用的做法，具体如下：

package com.wangwenjun.concurrent.chapter03;
import java.util•concurrent.TimeUnit;
public class FlagThreadExit
static class MyTask extends Thread
private volatile boolean closed = false;
@Override public void run()
System.out.printIn("I will start work"); while (Iclosed && !islnterrupted())
//正在运行
}
System.out.printin("I will be exiting.");
public void close()
{
this.closed = true;
this , interrupt();
}
?
public static void main(String[] args) throws InterruptedException
{
MyTask t = new MyTask();
t.start();
TimeUnit・ MINUTES.sleep(1);
System.out.printIn("System will be shutdown.");
t.close();
}
}

上面的例子中定义了一个closed开关变量，并且是使用volatile修饰(关于volatile关键字会在本书的第3部分中进行非常细致地讲解，volatile关键字在Java中是一个革命性的关键字，非常重要，它是Java原子变量以及并发包的基础)运行上面的程序同样也可以关闭线程。

异常退出

在一个线程的执行单元中，是不允许抛出checked异常的，不论Thread中的run方法，还是Runnable中的run方法，如果线程在运行过程中需要捕获checked异常并且判断是否还有运行下去的必要，那么此时可以将checked异常封装成unchecked异常 (RuntimeException)抛出进而结束线程的生命周期。