上篇文章讲到并发问题的由来，并发世界中的几个容易混淆的概念，并发级别以及衡量并发性能的两个定律。这篇博文将解决三个问题：
1. 线程和进程的区别？为什么调度线程而不调度进程？
2. 调度的线程在代码中是如何创建的？如何终止的？如何阻塞的？
3. 线程的类别和优先级？
我们经常说的“高并发”是我们要达到的目的，即系统的高可用、高响应、高吞吐量等。而实现“高并发”最底层的途径就是并发编程，并发编程简单理解就是通过编码使得多个线程正确运行。
用过电脑的人都打开过Windows的任务管理器，管理器界面上的Tab页会出现“应用程序”、“进程”、“服务”、“性能”等；“应用程序”是我们打开的一个程序，比如打开QQ，打开word文档，打开chrome等，每一个应用都是一个程序，这些都是我们看得见的程序，电脑运行还有很多我们开不见的程序，比如系统的运行、杀毒软件的运行、代理的运行等，这些都显示在“进程”中。
那么进程和线程之间有什么联系？
我们知道，“进程”是暴露给用户的，让用户知道这个程序的运行情况，比如进程的名称，状态，作用（描述），端口等，是指整个程序的运行状况；而程序（系统）是由线程来执行的，即程序的功能实现则由线程来操作；高并发也就是程序的各个功能能够快速且稳定的响应用户的操作，每个功能通过独立的线程来完成，进而造就高并发系统。举个例子理解进程和线程：一个公司的运作可以比作为一个进程的执行，公司内各个部门，如财务部门，人事部门，业务部门等组成进程，他们的运作才支撑起公司的运作，各个部门则可以理解为各个线程，每个线程用于完成不同的工作，进而使得进程能正确的运转；即线程组成进程，进程囊括线程，是一个组成和被组成的关系。
用术语来讲就是，进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。线程就是轻量级进程，是程序执行的最小单位。
使用多线程而不是用多进程去进行并发程序的设计，是因为线程间的切换和调度的成本远远小于进程。
进程的状态有两种：已停止和正在运行；由于线程的粒度较细，因此线程的状态有多种：创建，运行，阻塞，等待和结束。（生命周期）
线程的各种状态
2.1 创建并启动
java是面向对象的语言，所以它把任何操作的实体抽象成一个对象，所执行的动作抽象成一个方法；java语言中用Thread类来表示线程，创建线程就是new一个对象：
Thread thread = new Thread(); // 不带参数默认名字为Thread-n
Thread thread = new Thread(“t1”); // t1 表示线程的名字
java语言中通过.来调用对象及其方法，线程类创建完毕需要通过start()方法来启动线程；即
thread.start();
才能表示启动了一个线程；完整实例如下：
public static void main(String[] args) {
Thread thread = new Thread();
thread.start();
System.out.println(thread.getName());
Thread thread2 = new Thread("t2");
thread2.start();
System.out.println(thread2.getName()); // 打印线程名字
System.out.println(Thread.currentThread().getName()); // 主线程
}
结果：
Thread-0
t2
main
这里表示创建并启动了一个线程。
new Thread()过程，实际调用init()方法
private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
init(g, target, name, stackSize, null, true);
}
通过上面的方法可知；
->init方法为私有方法，只能在Thread类内部调用，保证Thread类构造的安全性；
-> Thread类暴露给程序员的构造方法有很多种，以便满足不同场景下的需要；但实际调用的方法则是同一个方法；
->构造线程要给线程赋予名字name，组别threadGroup，运行内容target，栈堆大小stackSize，其中第五、六个参数分别表示保证线程安全的对象、是否为本地线程赋值来自构造函数的初始值(涉及到ThreadLocal，默认为true)；
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
// ①首先确定线程的名字，要么构造传进来，要么使用默认的名字
if (name == null) {
throw new NullPointerException("name cannot be null");
}
this.name = name;
// ② 确认线程的组别 要么构造传进来 要么归属于安全框架设置的线程组 要么归属于当前线程的线程组；因为线程分级别，所以需要确定线程组；
Thread parent = currentThread();
SecurityManager security = System.getSecurityManager();
if (g == null) {
if (security != null) {
g = security.getThreadGroup();
}
if (g == null) {
g = parent.getThreadGroup();
}
}
// 确保正在运行的线程(主线程)是否具有修改该线程组的权限
g.checkAccess();
// ③ 如果存在安全对象，则还需要判断线程的相关运行时权限
if (security != null) {
if (isCCLOverridden(getClass())) {
security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
}
}
// ④ 线程组中未启动线程数加1
g.addUnstarted();
// ⑤ 判断是否是守护线程，得到线程的优先级
this.group = g;
this.daemon = parent.isDaemon();
this.priority = parent.getPriority();
// ⑥ 确定对象上下文加载器(来自运行线程的加载器)
if (security == null || isCCLOverridden(parent.getClass()))
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
// ⑦ 获取当前调用上下文的快照，并将其至于AccessControllerContext对象中
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext();
// ⑧ 运行内容和设置优先级
this.target = target;
setPriority(priority);
// ⑨ 设置当前线程的私有局部变量ThreadLocal
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
// ⑩设置线程的堆栈大小，初始构造默认为0； 设置线程id
this.stackSize = stackSize;
tid = nextThreadID();
}
.start()启动线程如下：
public synchronized void start() {
/**
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
start方法实则调用本地方法start0():
// 实则为本地方法，用c或者c++实现；
private native void start0();
经过断点调试，start0()方法实则调用Thread类的run()方法，而run()方法调用target对象的run()方法。若在初始化过程中没有指定target对象，则为空不执行run()，会立即执行exit()方法结束线程；
private void exit() {
if (group != null) {
group.threadTerminated(this);
group = null;
}
/* Aggressively null out all reference fields: see bug 4006245 */
target = null;
/* Speed the release of some of these resources */
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
exist()方法意在清除掉该线程的所有变量或者引用。
到这里创建并启动了一个线程，但是线程的运行还没有开始。运行run()方法是调用Runnable类的run方法，Runnable类是一个接口，提供一个抽象run方法供实体类重写。其实Thread类本身也继承Runnable接口，Thread类本身也可以实现run方法，如下：
Thread thread = new Thread(){
@Override
public void run(){
System.out.println(" I am thread");
}
};
但是项目中都会定制线程，可以通过继承Thread类来自定义线程，重载run()方法执行想要执行的内容；但考虑到java语言是单继承的，继承特性比较宝贵，因此一般通过实现Runnable接口和Callable接口来定制化线程；实例如下：
public class CreateThread {
public static void main(String[] args) {
ThreadCallable thread = new ThreadCallable();
try {
thread.call();
} catch (Exception e) {
e.printStackTrace();
}
Thread thread2 = new Thread(new ThreadRunnable(), "t2");
thread2.start();
System.out.println(Thread.currentThread().getName());
}
}
class ThreadRunnable implements Runnable{
@Override
public void run() {
System.out.println("I am ThreadRunnable");
}
}
class ThreadCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println("I am ThreadCallable");
return null;
}
}
观察上面代码可能会有以下几个问题：
1. Callable接口的call()和Runnable接口的run()有什么区别？
2. 实现call()方法的类对象为何不需要调用start()就能直接运行线程？
首先Callable和Runnable接口都是实现线程功能的接口，唯一区别就是Callable接口的call()可以返回线程执行的结果且能抛出异常，而Runnable接口的run()则不返回任何内容；可以说两者在功能上互补。
然后，Callable类型的对象，直接调用call()就可运行线程；而Runnable类型的对象，则需要调用start()启动线程；通过call()的源码注释可知，call是放在Executor中执行，由执行器来调用，run()则依赖start()方法。（为什么要这样设计呢？）
2.2 停止线程
stop()是Thread类中定义的停止线程的方法，但stop方法太过暴力，在调用时直接停掉线程，可能会造成数据不一致性问题，因此已经被废弃掉。在实际开发中，不会单个的创建线程，而是由线程池来创建并管理线程；上面的例子中显示，线程执行完毕后会自定执行exist方法停止线程。
private void exit() {
if (group != null) {
group.threadTerminated(this);
group = null;
}
/* Aggressively null out all reference fields: see bug 4006245 */
target = null;
/* Speed the release of some of these resources */
threadLocals = null;
inheritableThreadLocals = null;
inheritedAccessControlContext = null;
blocker = null;
uncaughtExceptionHandler = null;
}
如果由线程池来管理线程，则是另外一种情况。
2.3 线程阻塞
线程阻塞是暂停线程的一种方法，关于线程中断有以下三个方法：
public void interrupt(); // 中断线程
public static boolean interrupted(); // 判断当前线程是否被中断，并清除中断状态
public boolean isInterrupted(); // 判断当前线程是否被中断
实例：
public class InterruptTest {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("my name is " + Thread.currentThread().getName());
if (Thread.currentThread().isInterrupted()) {
System.out.println("i have interrupted");
break;
}
}
}
});
thread.start();
thread.interrupt();
}
}
大意：启动一个线程，循环打印当前线程的名字；在主线程中启动thread线程然后调用interrupt()方法中断线程thread，当thread线程检测到自身被中断了则退出循环。
interrupt()
public void interrupt() {
// ① 调用该方法是否是线程本身，如果不是则进行安全检查；checkAccess()可能会抛出一个异常
if (this != Thread.currentThread())
checkAccess();
// ②blockerLock是一个object类型的对象，利用内置锁来保证中断的同步性
synchronized (blockerLock) {
Interruptible b = blocker; // IO操作过程的中断标志
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
// ③通过native方法实现线程中断
interrupt0();
}
isInterrupted()方法也是native方法；
interrupted()方法调用native方法；
在中断线程后，一般要在线程内部对中断后的线程进行响应。
2.4 线程等待
为了支持线程之间的协作，JDK在对象上设置了wait()和notify()；在线程A中调用对象的wait()可使得该线程在该对象上等待，当线程B调用同一对象的notify()，则线程A等待结束，继续执行。
wait和notify为什么是对象的两个方法，而不是线程？这是因为对象有内置锁，通过内置锁使得线程等待。
public class WaitTest {
private static Object object = new Object();
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (object) {
System.out.println(System.currentTimeMillis() + ": t1 start!");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("notify...");
System.out.println(System.currentTimeMillis() + ": t1 end!");
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (object) {
System.out.println(System.currentTimeMillis() + ": t2 start!");
System.out.println("wait...");
object.notify();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(System.currentTimeMillis() + ": t2 end!");
}
}
});
t1.start();
t2.start();
}
}
结果：
1538915095285: t1 start!
1538915095285: t2 start!
wait...
1538915097285: t2 end!
notify...
1538915097285: t1 end!
从代码中可以看出，要想调用object对象的wait和notify方法，需要首先获得object对象的锁；因此线程在object对象上等待时，会释放object对象的内置锁。这点和Thread类的sleep方法不一样，sleep方法让线程睡眠一定时间，睡眠期间不能做任何事情。
wait和notify方法都属于native方法。
2.5 线程的加入和谦让
在线程执行过程中，有些线程依赖其他线程的结果，因此需要等待其他线程执行完成才执行本线程。JDK提供的join方法就可以实现这样的功能；
public class JoinTest {
private static volatile int i = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (i = 0; i < 1000000; i++) ;
}
});
t1.start();
t1.join();
System.out.println(i);
}
}
join方法有很多个：
join(); // 无限等待
join(long); // 等待一定时长
join(long, int); // 等待一定时长，int参数为纳秒
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
源码中的核心代码是wait(0)，可知join方法本质是让调用线程wait在当前线程对象实例上；当被等待线程全部执行完毕，会notify等待线程继续执行。
yield()方法是一种谦让的方法，意思是尽量不会参与CPU的竞争，是native本地方法。
参考文献
《实战java高并发程序设计》