前言
本文将对 Java 线程 Thread 进行学习和总结，以下是概览：
一、Thread 创建
线程的创建主要依靠实现 Runnable 接口。调用 start() 方法使线程进入就绪状态，等待 CPU 调度，然后 run () 方法由 JVM 调用。
1.1 实现 Runnable
public interface Runnable {
public abstract void run();
}
例子
public class TestThread implements Runnable{
@Override
public void run() {
System.out.println("TestThread Running");
}
}
使用
public static void main(String[] args) {
// 创建线程
TestThread testThread = new TestThread();
// 将 Runnable 对象作为参数传递给 Thread
Thread thread = new Thread(testThread);
thread.start();
}
为什么不能直接创建 TestThread 对象并调用 run() 方法呢，因为这样只是普通地调用了对象的方法，并没有经历创建线程的过程。
所以还是需要利用 Java 为我们写好的 Thread 类对线程对象（实现了 Runnable 的对象）进行一次包装，然后由 Thread 类替我们完成创建并执行线程的过程。
1.2 继承 Thread
Thread 类本身实现了 Runnable 接口，内部又包装了一个 Thread 对象 target，执行 run 方法的时候实际调用 target 的 run 方法。
public class Thread implements Runnable {
private Runnable target;
...
public void run() {
if (target != null) {
target.run();
}
}
}
所以本质上还是实现了 Runnable 接口实现线程的创建。
二、部分属性
Thread 类的部分属性：
// 对象锁，用于使当前线程占有 CPU
private final Object lock = new Object();
// 该值不等于0，说明线程存活，尚不知原理
private volatile long nativePeer;
// 线程名称
private volatile String name;
// 线程优先级
private int priority;
// 是否守护线程
private boolean daemon = false;
接下来将逐个分析。
2.1 lock 锁对象
lock 对象用于加锁和使调用者线程进入阻塞状态。
阻塞
调用 join 方法会使当前线程获取 lock 对象的锁，然后 lock 对象执行 wait 方法进入阻塞状态，实现阻塞当前线程的效果。
public final void join() throws InterruptedException {
// 传入 0 表示无限阻塞
join(0);
}
public final void join(long millis) throws InterruptedException {
synchronized(lock) { // 同步锁
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) { // 等于 0 无限阻塞
while (isAlive()) {
lock.wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
lock.wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
}
比如现在有个线程 Thread1，在运行过程中需要执行 Thread2 的相关逻辑。Thread2 在 Thread1 的 run() 方法中调用了 join() 方法，这样 Thread1 就获取到了 Thread2 中 lock 对象的锁。
lock 对象循环调用 wait() 方法进行阻塞。因为这时是处于 Thread1 的运行环境下，并且由 synchronized 获取了 monitor（相当于同步锁），所以 Thread1 进入了阻塞状态。
注意：
当前线程必须是此对象的监视器所有者，否则还是会发生 IllegalMonitorStateException 异常。
如果当前线程在等待之前或在等待时被任何线程中断，则会抛出 InterruptedException 异常。
解除阻塞
解除阻塞有两种方式，但不限于这两种。一种是 超时 自动释放，另一种是由 JVM 释放。
-
join()方法传入millis (毫秒数)，在时间达到之后跳出循环，lock对象不再加锁。这样Thread1持有的lock对象不再阻塞，由此该线程回到就绪状态。 - 加入线程执行完毕，JVM 释放锁。线程死亡时 JVM 会调用
lock对象的notify_all()方法来释放所有锁。
以下代码摘自 Thread.join的作用和原理 中的 hotspot 虚拟机源码：
void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
assert(this == JavaThread::current(), "thread consistency check");
...
// Notify waiters on thread object. This has to be done after exit() is called
// on the thread (if the thread is the last thread in a daemon ThreadGroup the
// group should have the destroyed bit set before waiters are notified).
ensure_join(this);
assert(!this->has_pending_exception(), "ensure_join should have cleared");
...
可以看到线程退出方法 exit() 调用了 ensure_join(this) 释放锁：
static void ensure_join(JavaThread* thread) {
// We do not need to grap the Threads_lock, since we are operating on ourself.
Handle threadObj(thread, thread->threadObj());
assert(threadObj.not_null(), "java thread object must exist");
ObjectLocker lock(threadObj, thread);
// Ignore pending exception (ThreadDeath), since we are exiting anyway
thread->clear_pending_exception();
// Thread is exiting. So set thread_status field in java.lang.Thread class to TERMINATED.
java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
// Clear the native thread instance - this makes isAlive return false and allows the join()
// to complete once we've done the notify_all below
//这里是清除native线程，这个操作会导致isAlive()方法返回false
java_lang_Thread::set_thread(threadObj(), NULL);
lock.notify_all(thread);//注意这里
// Ignore pending exception (ThreadDeath), since we are exiting anyway
thread->clear_pending_exception();
}
这里的 lock 对象大概就是 Thread 中的同步锁对象了，调用 Java Object notifyAll() 方法 用来唤醒所有持有该对象锁的线程。
2.2 其它参数
- nativePeer： 判断线程是否存活依靠此字段，可能在线程销毁的时候把该值置为 0。
public final boolean isAlive() {
return nativePeer != 0;
}
-
priority： 优先级，默认
NORM_PRIORITY=5。最小MIN_PRIORITY = 1，最大MAX_PRIORITY = 10。
设置该参数的作用在于希望较高优先级的线程可以先行执行，但实际可能并非总是如此。
优先级和操作系统及虚拟机版本相关。
优先级只是代表告知了 「线程调度器」该线程的重要度有多大。如果有大量线程都被堵塞，都在等候运
行，调试程序会首先运行具有最高优先级的那个线程。然而，这并不表示优先级较低的线程不会运行（换言之，不会因为存在优先级而导致死锁）。若线程的优先级较低，只不过表示它被准许运行的机会小一些而已。
- daemon： 是否为守护线程。守护线程就像一个卫士，追随用户线程。当用户线程销毁时，守护线程也就没有了意义，可能会被随时回收。
参考：什么是守护线程？
三、Thread 状态
3.1 线程的几种状态
有关线程状态，大概有两种说法。
- 一种是概括性的五种状态：
- 创建状态 已经创建出对象，并未调用 start；
- 就绪状态 调用 start 方法之后，并未开始运行；
- 运行状态 被 cpu 执行，run 方法被调用；
- 阻塞状态 在运行过程中被暂停，调用 wait() 或被别的线程 join() 等；
- 死亡状态 run 方法执行结束，或者调用 stop() 结束运行。
- 另一种是根据源码的六种状态：
- NEW 刚 new 出来；
- RUNNABLE 运行中；
- BLOCKED 等待同步锁；
- WAITING 阻塞状态，wait() 或被 join()；
- TIMED_WAITING 阻塞状态，限时；
- TERMINATED 被终止。
个人感觉没有必要纠结孰对孰错，这是两个层面上的理解。前者更倾向于总览，后者更为细化。
3.2 线程状态控制
线程调度
简单地说就是设置优先级，使 JVM 进行协调。避免多个线程抢夺有限资源造成的死机或者崩溃。上文已经提到过，最低优先级 MIN_PRIORITY =1、最高优先级 MAX_PRIORITY = 10，默认优先级 NORM_PRIORITY=5。
为了控制线程的运行策略，Java定义了线程调度器来监控系统中处于就绪状态的所有线程。线程调度器按照线程的优先级决定那个线程投入处理器运行。在多个线程处于就绪状态的条件下，具有高优先级的线程会在低优先级线程之前得到执行。
守护线程
特殊的低优先级守护(Daemon)线程，它是为系统中的其它对象或线程服务。
典型的守护线程例子是JVM中的系统资源自动回收线程，它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。
当所有用户线程销毁后，也不会产生垃圾了。守护线程会随着 JVM 销毁。
线程分组
Java定义了在多线程运行系统中的线程组（ThreadGroup）对象，用于实现按照特定功能对线程进行集中式分组管理。
用户创建的每个线程均属于某线程组，这个线程组可以在线程创建时指定，也可以不指定线程组以使该线程处于默认的线程组之中。但是，一旦线程加入某线程组，该线程就一直存在于该线程组中直至线程死亡，不能在中途改变线程所属的线程组。
与线程类似，可以针对线程组对象进行线程组的调度、状态管理以及优先级设置等。在对线程组进行管理过程中，加入到某线程组中的所有线程均被看作统一的对象。
四、Thread 其它
4.1 线程同步
- synchronized： 依赖 JVM 实现，通过锁住 对象、方法、类 等实现线程同步；
- volatile： 特殊域变量，使用该关键字修饰对象，保证其 可见性。使其无论在哪个线程读取时都从内存重新读取，而不是在 CPU 缓存中读取；
- 重入锁： ReentrantLock 可重入，内含 CAS+AQS 机制。CAS 保证数据准确性，AQS 保证顺序。
- ThreadLocal： 为每一条线程创建数据副本，这样各个线程间处理的数据互不影响。因为处理的不是同一数据，要注意数据的一致性。
4.2 终止线程
终止线程三种方法：
- 设置 flag 标记：为 false 时结束代码运行，JVM 会回收掉线程；
- stop 方法（不推荐）：强行结束线程，但是可能会因马上释放锁造成数据产生误差；
- interrupt 方法：使线程进入中断状态，代码逻辑中 catch InterruptedException 用来结束逻辑执行。
总结
线程使用时要特别注意同步、锁的使用。由于多个线程不易管理，实际使用时一般用 线程池 进行处理。后面讲对线程池原理进行记录。
参考资料
