【Java并发001】使用级别：线程相关知识

一、前言

本文介绍Java线程相关知识（不包括线程同步+线程通信，这个内容在笔者的另一篇博客中介绍过了），包括：线程生命周期、线程优先级、线程礼让、后台线程、联合线程。

二、线程生命周期

2.1 引子：线程生命周期

本节阐述线程生命周期相关知识，Java支持多线程技术，除了Main函数主导一个main线程以外，可以用代码创建一系列的前台线程、后台线程（本文后面会讲），每一个线程都有自己的生命周期，线程生命周期的不同状态有不同的说法：

（1）有的说Java线程5种状态，这是因为将“等待状态Waiting+限时等待状态Timed_Waiting”作为一种状态，5种状态为：
新建状态New、可运行状态Runnable(Running+Ready)、等待状态Waiting+Timed_Waiting、阻塞状态Blocked、结束状态Terminated

（2）有的说Java线程6种状态，这是因为将将Running和Ready两种状态拆分开了，6种状态为：
新建状态New、准备状态Ready、运行状态Running、等待状态Waiting+Timed_Waiting、阻塞状态Blocked、结束状态Terminated

或者将等待状态Waiting和限时等待状态Timed_Waiting两种状态拆开，6种状态为：
新建状态New、可运行状态Runnable(Running+Ready)、等待状态Waiting、计时等待状态Timed_Waiting、阻塞状态Blocked、结束状态Terminated

（3）有的说Java线程7种状态，这是因为将将Running和Ready两种状态拆分开、等待状态Waiting和限时等待状态Timed_Waiting两种状态拆开，7种状态为：
新建状态New、准备状态Ready、运行状态Running、 等待状态Waiting、计时等待状态Timed_Waiting、阻塞状态Blocked、结束状态Terminated

不管采用哪种说法，Java线程状态以下几种，新建状态New、可运行状态Runnable(Running+Ready)、等待状态(等待状态Waiting+限时等待状态Timed_Waiting)、阻塞状态Blocked、结束状态Terminated

本文采用6种状态的说法，下面2.3 会具体阐述。

2.2 用一段代码来演示一个完整的生命周期

代码1：

package mypackage;
//  线程的生命周期，演示线程的六种状态： NEW 新建状态   RUNNABLE 可运行状态（ready就绪状态+running运行状态） TIMED_WAITING 计时等待状态
//   WAITING 等待状态  BLOCKED 阻塞状态  TERMINATED  终止状态（进入终止状态后只能结束，无法再返回回来）
class Block {   //共享资源类
	public boolean waitStatus = true;
	public void waitOp() throws InterruptedException {
		synchronized (this) {
			System.out.println(Thread.currentThread().getName() + "  进入wait");
			wait();
			// waitThread被notifyThread唤醒
			System.out.println(Thread.currentThread().getName() + "  next to Block.wait(), in the loop");
		}
	}
	public void notifyOp() {
		synchronized (this) {
			this.waitStatus = false; // 修改标志位 等待状态waitStatus=false
			notifyAll(); // 唤醒WaitRunnable
			System.out.println(Thread.currentThread().getName() + "  向正在wait当前对象的线程发出notify");
		}
	}
}
class WaitThread implements Runnable {
	private Block block;
	public WaitThread(Block block) {
		super();
		this.block = block;
	}
	@Override
	public void run() {
		//该方法中测试了 sleep(毫秒数)进入计时等待状态和wait()进入等待状态
		// 前者只能等待2秒后自动唤醒   后者由notifyThread使用notify()/notifyAll()唤醒
		try {
			System.out.println(Thread.currentThread().getName() + "  被启动，开始执行...");
			// Thread.sleep(毫秒数) 进入计时等待状态 线程计时等待状态中，线程依然存活，线程isAlive() 仍然为true
			System.out.println(Thread.currentThread().getName() + "  开始sleep 2s");
			Thread.sleep(2000);
			System.out.println(Thread.currentThread().getName() + "  从sleep中醒来");
			// 从sleep中醒来后，进入wait状态
			while (block.waitStatus) {
				block.waitOp(); // 进入等待状态，线程在等待状态中，线程依然存活，线程isAlive()
								// 仍然为true，等待状态只有一个出口，notify()/notifyAll()
				// waitThread被notifyThread唤醒
				System.out.println(Thread.currentThread().getName() + "  next to WaitRunnable.waitOp(), in the loop");
			}
			System.out.println(Thread.currentThread().getName() + "  out of wait loop");
			System.out.println(Thread.currentThread().getName() + "  任务执行结束，即将终止...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class NotifyThread implements Runnable {
	private Block block;
	public NotifyThread(Block block) {
		super();
		this.block = block;
	}
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "  被启动，开始执行...");
		block.notifyOp();
		synchronized (block) {
			try {
				System.out.println(Thread.currentThread().getName() + "  开始sleep 6s，并且不会释放当前对象的锁");
				// 进入计时等待状态有两种方式 wait(毫秒数) sleep(毫秒数) 两者不同在于
				// wait(毫秒数)释放锁 ,其他线程(本程序中另一个线程)获得锁并运行
				// sleep(毫秒数)不释放锁,其他线程(本程序中另一个线程)不可以获得锁并运行
				// 现在notifyThread sleep(6000) 不释放锁，所以waitThread也不能运行
				// ,只能等到6秒后notifyThread醒来
				Thread.sleep(6000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// notifyThread醒来了，打印一下
		System.out.println(Thread.currentThread().getName() + "  从sleep中醒来");
	}
}
public class Test {
	private static final String IN_THE_STATE = "当前的状态为：";
	private static final String ISALIVE_RETRUN = "isAlive()返回为：";
	public static void printStatus(Thread thread) {
		System.out.println(thread.getName() + "  " + IN_THE_STATE + thread.getState().toString() + "  " + ISALIVE_RETRUN
				+ thread.isAlive());
	}
	public static void main(String[] args) throws InterruptedException {
		// 该对象将作为后面加锁的对象
		Block block = new Block();
		// new Thread() 进入新建状态
		Thread waitThread = new Thread(new WaitThread(block));
		Thread notifyThread = new Thread(new NotifyThread(block));
		printStatus(waitThread); // 打印当前状态，当前状态为新建状态 线程尚未启动，isAlive()为false
		printStatus(notifyThread);// 打印当前状态，当前状态为新建状态 线程尚未启动，isAlive()为false
		// .start() 进入可运行状态 （包括就绪状态和运行状态）
		// 就绪状态进入运行状态是CPU调度，程序员无法控制，所本程序中对这两种状态不做区分，统一为可运行状态
		waitThread.start();
		printStatus(waitThread); // 打印当前状态，当前状态为可运行状态 线程启动，isAlive()为true
		Thread.sleep(1000);
		// TIMED_WAITING
		printStatus(waitThread); // 打印当前状态，当前状态为计时等待状态
		Thread.sleep(2000);
		// WAITING
		printStatus(waitThread); // 打印当前状态，当前状态为wait()等待状态,等待被notifyThread()唤醒才能继续下去
		Thread.sleep(1000); // 主线程main线程等待1s
		notifyThread.start(); // 启动notify线程，去唤醒处于等待状态的waitThread
		printStatus(notifyThread); // 打印notifyThread当前状态，当前状态为可运行状态
									// 线程启动，isAlive()为true
		Thread.sleep(1000); // 主线程main线程等待1s
		// BLOCKED or TERMINATED
		// TERMINATED：运行到此处时，如果notifyThread执行完notify操作后，调度器立马切换至thread的情况下，thread会先行终止，调度器再调度notifyThread
		printStatus(waitThread); // 现在处于notifyThread sleep(6000) 睡眠6秒过程中  我们打印一下被notifyThread唤醒的waitThread处于什么状态
									// waitThread为Block状态,islive为true
		//这是因为waitThread虽然被notifyThread唤醒，从等待状态中出来，但是因为notifyThread现在一直占用同步锁，waitThread无法获得同步锁，所以处于阻塞状态
		//等待状态和阻塞状态区别：Java中，每个对象都有两个池，锁池和等待池，
		//阻塞状态两种：I/O阻塞（本程序不涉及，略）和获取同步锁失败而阻塞（本程序当前情况），线程对象处于锁池，锁池的中线程对象获取到同步锁之后就可以进入可运行状态运行，即阻塞状态的线程获取同步锁成功后就可以运行
		//等待和计时等待状态：sleep(毫秒数)只能等待自动唤醒，wait(毫秒数)可以等待自动唤醒或notify()/notifyAll()唤醒，wait()只能notify()/notifyAll()唤醒，三种等待都是处于等待池中
		//wait()和wait(毫秒数)释放同步锁，其间不占用同步锁，sleep(毫秒数)占用同步锁，其间不释放同步锁
		printStatus(notifyThread); // 现在处于notifyThread sleep(6000) 睡眠6秒过程中
									// notifyThread 为计时等待状态,islive为true
		Thread.sleep(6000); // 主线程睡眠6s 让两个子程序有足够的时间进入终止状态
		// 终止状态 主线程给了6s 足够进入终止状态了
		printStatus(waitThread); // waitThread 进入终止状态，isAlive()为false
		printStatus(notifyThread); // notifyThread 进入终止状态，isAlive()为false
		// 注意：线程一旦进入终止状态，只能结束，无法再返回来
	}
}

输出1：

Thread-0  当前的状态为：NEW  isAlive()返回为：false
Thread-1  当前的状态为：NEW  isAlive()返回为：false
Thread-0  当前的状态为：RUNNABLE  isAlive()返回为：true
Thread-0  被启动，开始执行...
Thread-0  开始sleep 2s
Thread-0  当前的状态为：TIMED_WAITING  isAlive()返回为：true
Thread-0  从sleep中醒来
Thread-0  进入wait
Thread-0  当前的状态为：WAITING  isAlive()返回为：true
Thread-1  当前的状态为：RUNNABLE  isAlive()返回为：true
Thread-1  被启动，开始执行...
Thread-1  向正在wait当前对象的线程发出notify
Thread-1  开始sleep 6s，并且不会释放当前对象的锁
Thread-0  当前的状态为：BLOCKED  isAlive()返回为：true
Thread-1  当前的状态为：TIMED_WAITING  isAlive()返回为：true
Thread-1  从sleep中醒来
Thread-0  next to Block.wait(), in the loop
Thread-0  next to WaitRunnable.waitOp(), in the loop
Thread-0  out of wait loop
Thread-0  任务执行结束，即将终止...
Thread-0  当前的状态为：TERMINATED  isAlive()返回为：false
Thread-1  当前的状态为：TERMINATED  isAlive()返回为：false

小结：本程序（已经注释的比较清楚了，这里不再赘余）使用synchronized+标志位waitStatus+wait()+notify()/notifyAll()，程序中的两个线程waitThread和notifyThread，既使用到了线程同步+线程通信，又监听了六个状态，帮助读者很好的理解Java线程生命周期六个状态。

2.3 线程生命周期的相关问题

问题（1）：线程有几种状态？状态之间如何转换？

回答（1）：没有绝对的答案，本文采用Java官方的解释，6种状态，分别是 ：NEW 新建状态 RUNNABLE 可运行状态（包括ready就绪状态+running运行状态） TIMED_WAITING 计时等待状态
WAITING 等待状态 BLOCKED 阻塞状态 TERMINATED 终止状态（进入终止状态后只能结束，无法再返回回来）

关于状态之间的转换图，我认为这张图最能符合标准：

补充：因为可运行状态Runnable包括Ready就绪状态和Running运行状态，但是就绪状态进入运行状态是CPU调度，程序员无法控制，所本文中对这两种状态不做区分，统一为可运行状态，两者中转换如图：

问题（2）：六种状态isAlive()返回值？

回答（2）：新建状态和终止状态isAlive()为false,表示线程此时不存活；其他四种状态isAlive()为true，表示线程此时为存活。

问题（3）：进入终止状态terminate还可以再回到可运行状态吗？

回答（3）：不可以，进入终止状态线程只能死亡，不可以再回到可运行状态。

问题（4）：等待状态（包括计时等待）和阻塞状态的区别？wait()、wait(毫秒数)和sleep(毫秒数)区别？

回答（4）：等待状态和阻塞状态区别：Java中，每个对象都有两个池，锁池和等待池，
阻塞状态两种：
I/O阻塞（本程序不涉及，略）和获取同步锁失败而阻塞（本程序当前情况），线程对象处于锁池，锁池的中线程对象获取到同步锁之后就可以进入可运行状态运行，即阻塞状态的线程获取同步锁成功后就可以运行；
等待和计时等待状态：
进入等待状态（包括计时等待）方式有三种（sleep(毫秒数)、wait()、wait(毫秒数)）
sleep(毫秒数)只能等待自动唤醒，wait(毫秒数)可以等待自动唤醒或notify()/notifyAll()唤醒，wait()只能notify()/notifyAll()唤醒，三种等待都是处于等待池中。
另外，wait()和wait(毫秒数)释放同步锁，其间不占用同步锁，sleep(毫秒数)占用同步锁，其间不释放同步锁

方法名	线程状态	唤醒	状态期间
wait()	进入等待状态	只能notify()/notifyAll()唤醒	释放同步锁，其间不占用同步锁
wait(毫秒数)	进入计时等待状态	可以等待自动唤醒或notify()/notifyAll()唤醒	释放同步锁，其间不占用同步锁
sleep(毫秒数)	进入计时等待状态	只能等待自动唤醒	占用同步锁，其间不释放同步锁

三、线程优先级

Java中提供了操作线程优先级的方法setter-getter， int getPriority() :返回线程的优先级。 void setPriority(int newPriority) : 更改线程的优先级。 另外，提供了三个表现线程优先级的常量，

MAX_PRIORITY=10,最高优先级

MIN_PRIORITY=1,最低优先级

NORM_PRIORITY=5,默认优先级，

线程优先级有1~ 10,10种，程序员也可以直接使用数字1~10设置线程优先级。线程优先级代码实现且见代码1：

代码——线程优先级：

package mypackage;

public class SimplePriorities implements Runnable {
	private int countDown = 5;

	public SimplePriorities(int priority) {
		Thread.currentThread().setPriority(priority);
	}

	public String toString() {
		return Thread.currentThread() + ": " + countDown;
	}

	@Override
	public void run() {

		while (true) {
			System.out.println(this);
			if (--countDown == 0) {
				return;
			}
		}
	}

	public static void main(String[] args) {
		new Thread(new SimplePriorities(Thread.MIN_PRIORITY)).start();
		new Thread(new SimplePriorities(Thread.MAX_PRIORITY)).start();

	}

}

输出：

Thread[Thread-1,10,main]: 5
Thread[Thread-1,10,main]: 4
Thread[Thread-1,10,main]: 3
Thread[Thread-0,1,main]: 5
Thread[Thread-1,10,main]: 2
Thread[Thread-0,1,main]: 4
Thread[Thread-1,10,main]: 1
Thread[Thread-0,1,main]: 3
Thread[Thread-0,1,main]: 2
Thread[Thread-0,1,main]: 1

小结：我们看到，程序开始的时候，即使在客户端低优先级的线程Thread-0先创建和执行，但是输出结果中，高优先级的线程Thread-1可以获得更多执行机会（前面5个，Thread-1打印了4个，Thread-0打印1个，后面5个没有意义，因为Thread-1已经快打印完了，每个线程countDown总数只有5）（注意：打印结果不同且当前线程数和countDown数字较小，特例没有意义）

注意1：值得注意的是，线程优先级并不是指线程执行的先后顺序，而是线程被执行的概率权重。事实上，除非程序员使用标志位做线程通信，否则Java并没有提供任何线程执行先后顺序的机制，哪个线程先执行只取决于CPU调度。
注意2：此外，不同的操作系统支持的线程优先级不同的,建议使用上述三个优先级MAX_PRIORITY、MIN_PRIORITY、NORM_PRIORITY,不要自定义。

四、线程礼让

线程礼让是以线程优先级为基础的（本文先介绍线程优先级，再介绍线程礼让），线程礼让yield方法只会给相同优先级或者更高优先级的线程运行的机会. 且看如下代码：

代码——线程礼让（在线程优先级代码的基础上添加）：

package mypackage_线程礼让;
public class SimplePriorities implements Runnable {
	private int countDown = 5;
	public SimplePriorities(int priority) {
		Thread.currentThread().setPriority(priority);
	}
	public String toString() {
		return Thread.currentThread() + ": " + countDown;
	}
	@Override
	public void run() {
		while (true) {
			Thread.yield();
			System.out.println(this);
			if (--countDown == 0) {
				return;
			}
		}
	}
	public static void main(String[] args) {
		new Thread(new SimplePriorities(Thread.MIN_PRIORITY)).start();
		new Thread(new SimplePriorities(Thread.MAX_PRIORITY)).start();
	}
}

输出：

Thread[Thread-1,10,main]: 5
Thread[Thread-0,1,main]: 5
Thread[Thread-1,10,main]: 4
Thread[Thread-0,1,main]: 4
Thread[Thread-1,10,main]: 3
Thread[Thread-1,10,main]: 2
Thread[Thread-1,10,main]: 1
Thread[Thread-0,1,main]: 3
Thread[Thread-0,1,main]: 2
Thread[Thread-0,1,main]: 1

小结：在run()方法中加上Thread.yield()之后，可以更大程度上保证高优先级的线程打败低优先级的线程，因为yield()只能将线程礼让给同等优先级和更高优先级的线程，本程序中Thread-0会礼让给Thread-1,但是Thread-1不会礼让给Thread-0,所以Thread.yield()本身更大程度上保证高优先级的线程打败低优先级的线程（注意：不绝对，况且的这里的countDown计数器和客户端线程数都很少）。

附：线程礼让yield()和线程休眠sleep()的相同点和不同点
sleep方法和yield方法的区别:
1):相同点：都能使当前处于运行状态的线程放弃CPU,把运行的机会给其他线程.
2):不同点——转让运行机会的条件不同：sleep方法会给其他线程运行机会,但是不考虑其他线程的优先级,yield方法只会给相同优先级或者更高优先级的线程运行的机会.
3):不同点——转让后进入的状态不同：调用sleep方法后,线程进入计时等待状态,调用yield方法后,线程进入就绪状态.
4):不同点——两方法开发中用途不同：sleep()方法开发中更多的用于模拟延迟,让多线程并发访问同一个资源的错误效果更明显.；yield()方法开发中很少会使用到该方法，该方法主要用于调试或测试，它可能有助于因多线程竞争条件下的错误重现现象。

五、后台线程

5.1 引子：后台线程

Java中，前台线程创建的线程默认是前台线程（可以通过setDaenon(true)方法设置为后台线程），后台线程创建的线程默认是后台线程。由于main线程是一个前台线程，所以我们新建的线程默认都是前台线程，本节阐述Java线程另一种线程——后台线程。

注意1：设置后台线程：thread.setDaemon(true),该方法必须在start方法调用前，否则出现IllegalThreadStateException异常。
注意2：前台线程停止，后台线程也停止，即使是finally块的内容也不执行了，且见本节代码演示。
注意3：main线程是前台线程

5.2 前台线程与后台线程

代码1——前台线程停止，后台线程也停止：

package mypackage;
public class Test {
	public static void main(String[] args) {
		Thread daemonThread = new Thread(new DaemonThread());
		daemonThread.setDaemon(true); // thread.setDaemon(true),该方法必须在start方法调用前，否则出现IllegalThreadStateException异常。
		daemonThread.start();
		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(500);
				// mainThread中每次休眠比后台线程少，这个mainThread就比后台线程先结束，从而证明前台线程结束后后台线程也会结束
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("This is mainThread");
		}
	}
}
class DaemonThread implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("This is DaemonThread");
		}
	}
}

输出1：

This is mainThread
This is DaemonThread
This is mainThread
This is mainThread
This is DaemonThread
This is mainThread
This is mainThread

小结1：该程序（即代码1）充分说明了，前台线程停止，那么它创建的后台线程也停止，但是如果是后台线程中finally块里面的内容，会任何时候都得到执行吗？且看代码2。

代码2——前台线程停止，后台线程也停止，即使是finally块的内容也不执行了：

package mypackage2;
public class Test {
	public static void main(String[] args) {
		Thread daemonThread = new Thread(new DaemonThread());
		daemonThread.setDaemon(true); // thread.setDaemon(true),该方法必须在start方法调用前，否则出现IllegalThreadStateException异常。
		daemonThread.start();
	}
}
class DaemonThread implements Runnable {
	@Override
	public void run() {
		try {
			System.out.println("This is DaemonThread");
		} finally {
			System.out.println("This is finally Blocks");
		}
	}
}

输出2：

This is DaemonThread

小结2：该程序（代码2）有三种输出情况：

第一，为空，什么都不输出，这是问题在后台线程尚未打印This is DaemonThread，主线程就结束了；

第二，输出为This is DaemonThread\n This is finally Blocks ,这是因为后台线程完全打印完后，主线程才结束；

第三，输出为This is DaemonThread，这是因为后台线程尚未执行完，finally中的代码未执行完，主线程结束。

我们重点谈论第三种输出，这一个输出可以充分说明，后台线程中即使是finally块中的语句，也不一定会得到执行。这与我们的认知的是矛盾的，通常来说，finally块的语句一定会得到执行，所以开发的时候一般将jdbc连接的close或io的close放在finally块里面。

原因简单阐述，这是因为main()退出时，JVM就会立即关闭所有的后台进场，并不会有任何你希望出现的确认形式。

解决方法，只能让程序员自己来解决这个问题，写程序的时候，要慎用后台线程，如代码2，若将main()中setDaemon()注释掉，就永远可以看到finally子句的执行，所有要慎用后台线程，否则finally子句将不再安全。

5.3 后台线程：小结

后台线程最重要的点就是生命周期跟随创建它的前台线程，前台线程死亡，后台线程立刻死亡，即使是finally中的子句也不一定会执行。

六、联合线程

6.1 引子：联合线程

定义：Java中，联合线程使用join()方法实现，线程的join方法表示一个线程等待另一个线程完成后才执行。join方法被调用之后，线程对象处于阻塞状态。 有人也把这种方式称为联合线程，就是说把当前线程和当前线程所在的线程联合成一个线程，且见本节代码。

6.2 联合线程代码演示

代码1：

package mypackage;
public class Test {
	public static void main(String[] args) throws InterruptedException {
		Thread joinThread = new Thread(new JoinThread());
		for (int i = 0; i < 5; i++) {
			System.out.println("main :" + i);
			if (i == 1) {
				joinThread.start();
			}
			if (i == 3) {
				joinThread.join(); // 强制运行joinThread,main线程被设置为阻塞状态
			}
		}
	}
}
class JoinThread implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println("JoinThread: " + i);
		}
	}
}

输出1：

main :0
main :1
main :2
main :3
JoinThread: 0
JoinThread: 1
JoinThread: 2
JoinThread: 3
JoinThread: 4
main :4

小结：join()方法就用阻塞当前正在运行的线程（代码1中为main线程），运行新建加入的线程（代码1中的JoinThread）,等到JoinThread运行完之后再运行mian线程。可以更加简单的理解，就是在main线程中嵌入一个JoinThread线程。

6.3 联合线程：小结

联合线程就是在某线程（代码1中main线程）中嵌入一个新线程（代码1中JoinThread），然后运行的时候当然是按照嵌入的运行。

七、小结

本文介绍Java线程相关知识，包括：线程生命周期、线程优先级、线程礼让、后台线程、联合线程，基本涵盖Java多线程部分的各个常用知识点，希望对初学者学习者提供帮助。
天天打码，天天进步！