Java并发编程系列文章
《一》多线程基础——Java线程与进程的基本概念
《二》多线程基础——Java线程入门类和接口
《三》多线程基础——Java线程组和线程优先级
《四》多线程基础——Java线程生命周期及转换
《五》多线程基础——Java线程间的通信（互斥与协作）
《六》实际应用——如何优雅的关闭线程
《七》实际应用——生产者与消费者模型

  并发编程（多线程）一直以来都是程序员头疼的难题。曾经听别人总结过并发编程的第一原则，那就是不要写并发程序，哈哈哈。后来发现，这样能够显著提高程序响应和吞吐量的利器，哪还能忍得住不会用呢？
  整理出《Java并发编程系列文章》，共计7篇，与君共勉。

---

---

1、Java线程生命周期

1.1、Java线程的6个状态

// Thread.State 源码
public enum State {
 NEW,
 RUNNABLE,
 BLOCKED,
 WAITING,
 TIMED_WAITING,
 TERMINATED;
}

（1）NEW（初始化）

private void testStateNew() {
 Thread thread = new Thread(() -> {});
 System.out.println(thread.getState()); // 输出 NEW 
}

  只创建了线程⽽并没有调⽤start()⽅法，此时线程处于NEW状态。

关于start()的两个引申问题

1. 反复调⽤同⼀个线程的start()⽅法是否可⾏？
   start()源码中有⼀个threadStatus的变量的判断，如果不等于0，就会直接抛出异常的。因为调用一次start()后，threadStatus值会改变，所以不能。
2. 假如⼀个线程执⾏完毕（此时处于TERMINATED状态），再次调⽤这个线程的start()⽅法是否可行？
   因为处于TERMINATED状态的线程，threadStatus不等于0，所以不能。
   RUNNABLE,

（2）RUNNABLE（可运行或运行中）

  Java线程的RUNNABLE状态其实是包括了传统操作系统线程的ready和running两个状态的。

（3）BLOCKED（阻塞）

  阻塞状态。处于BLOCKED状态的线程正等待锁的释放以进⼊同步区。

（4）WAITING（等待）

  等待状态。处于等待状态的线程变成RUNNABLE状态需要其他线程唤醒。

调⽤如下3个⽅法会使线程进⼊等待状态：
Object.wait()：使当前线程处于等待状态直到另⼀个线程唤醒它；
Thread.join()：等待线程执⾏完毕，底层调⽤的是Object实例的wait⽅法；
LockSupport.park()：除⾮获得调⽤许可，否则禁⽤当前线程进⾏线程调度。

（5）TIMED_WAITING（超时等待）

  超时等待状态。线程等待⼀个具体的时间，时间到后会被⾃动唤醒。

调⽤如下⽅法会使线程进⼊超时等待状态：
Thread.sleep(long millis)：使当前线程睡眠指定时间；
Object.wait(long timeout)：线程休眠指定时间；
Thread.join(long millis)：等待当前线程最多执⾏millis毫秒，如果millis为0，则会⼀直执⾏；
LockSupport.parkNanos(long nanos)： 除⾮获得调⽤许可，否则禁⽤当前线程进⾏线程调度指定时间；
LockSupport.parkUntil(long deadline)：同上，也是禁⽌线程进⾏调度指定时间；

（6）TERMINATED（终止）

  终⽌状态。此时线程已执⾏完毕。

1.2、Java线程状态的转换

（1）BLOCKED与RUNNABLE状态的转换

  处于BLOCKED状态的线程是因为在等待锁的释放。假如这⾥有两个线程a和b，a线程提前获得了锁并且暂未释放锁，此时b就处于BLOCKED状态。我们先来看⼀个例⼦：

public void blockedTest() {
    Thread a = new Thread(new Runnable() {
        @Override
        public void run() {
            testMethod();
        }
    }, "a");
    Thread b = new Thread(new Runnable() {
        @Override
        public void run() {
            testMethod();
        }
    }, "b");
    a.start();
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出？
    System.out.println(b.getName() + ":" + b.getState()); // 输出？
}
// 同步⽅法争夺锁
private synchronized void testMethod() {
    try {
        Thread.sleep(2000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

  除了a、b线程，还有⼀个main线程。线程启动后执⾏run⽅法还是需要消耗⼀定时间的。不打断点的情况下，上⾯代码中都应该输出RUNNABLE。
  具体来说，main线程只保证了a，b两个线程调⽤start()⽅法（转化为RUNNABLE状态），还没等两个线程真正开始争夺锁，就已经打印此时两个线程的状态（RUNNABLE）了。
  我们把上⾯的改动⼀下：

     ······
    a.start();
    Thread.sleep(1000L); // 需要注意这⾥main线程休眠了1000毫秒，⽽testMethod()⾥休眠了
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出？
    System.out.println(b.getName() + ":" + b.getState()); // 输出？

  由于main线程休眠，所以线程a的run()⽅法跟着执⾏，线程b再接着执⾏。在线程a执⾏run()调⽤testMethod()之后，线程a休眠了2000ms（注意这⾥是没有释放锁的），main线程休眠完毕，接着b线程执⾏的时候是争夺不到锁的，所以这⾥输出：

a:TIMED_WAITING
b:BLOCKED

（2）WAITING状态与RUNNABLE状态的转换

  转换图我们知道有3个⽅法可以使线程从RUNNABLE状态转为WAITING状态。我们主要说一下Object.wait()和Thread.join()。

Object.wait()
调⽤wait()⽅法前线程必须持有对象的锁。
调⽤wait()⽅法时，会释放当前的锁，直到有其他线程调⽤notify()/notifyAll()⽅法唤醒等待锁的线程。
需要注意的是，其他线程调⽤notify()⽅法只会随机唤醒单个等待锁的线程。调⽤notifyAll()⽅法唤醒所有等待锁的线程之后，也不⼀定会⻢上把时间⽚分给刚才放弃锁的那个线程，具体要看系统的调度。

Object.wait()
调⽤join()⽅法不会释放锁，会⼀直等待当前线程执⾏完毕（转换为
TERMINATED状态）。

我们把上面的例子改动一下：

    ······
    a.start();
    a.join();
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出 TERMINATED
    System.out.println(b.getName() + ":" + b.getState());

  要是没有调⽤join⽅法，main线程不管a线程是否执⾏完毕都会继续往下⾛。a线程启动之后⻢上调⽤了join⽅法，这⾥main线程就会等到a线程执⾏完毕，所以这⾥a线程打印的状态固定是TERMIATED。
⾄于b线程的状态，有可能打印RUNNABLE（尚未进⼊同步⽅法），也有可能打印TIMED_WAITING（进⼊了同步⽅法）。

（3）TIMED_WAITING与RUNNABLE状态转换

  TIMED_WAITING与WAITING状态类似，只是TIMED_WAITING状态等待的时间是指定的。

Thread.sleep(long)
使当前线程睡眠指定时间，并不会释放锁。时间到后，线程会重新进⼊RUNNABLE状态。

Object.wait(long)
wait(long)⽅法使线程进⼊TIMED_WAITING状态。这⾥的wait(long)⽅法与
⽆参⽅法wait()相同的地⽅是，都可以通过其他线程调⽤notify()或notifyAll() ⽅法来唤醒。
不同的地⽅是，经过指定时间 long之后它会⾃动唤醒，线程会重新进⼊RUNNABLE状态。

Thread.join(long)
join(long)使当前线程执⾏指定时间，并且使线程进⼊TIMED_WAITING状
态。

（4）线程中断

  在某些情况下，我们在线程启动后发现并不需要它继续执⾏下去时，需要中断线程。⽬前在Java⾥还没有安全直接的⽅法来停⽌线程。需要注意，通过中断操作并不能直接终⽌⼀个线程，⽽是通知需要被中断的线程⾃⾏处理。

简单介绍下Thread类⾥提供的关于线程中断的⼏个⽅法：
Thread.interrupt()：中断线程。这⾥的中断线程并不会⽴即停⽌线程，⽽是设 置线程的中断状态为true（默认是flase）；
Thread.interrupted()：测试当前线程是否被中断。线程的中断状态受这个⽅法的影响，意思是调⽤⼀次使线程中断状态设置为true，连续调⽤两次会使得这 个线程的中断状态重新转为false；
Thread.isInterrupted()：测试当前线程是否被中断。与上⾯⽅法不同的是调⽤ 这个⽅法并不会影响线程的中断状态。

  在线程中断机制⾥，当其他线程通知需要被中断的线程后，线程中断的状态被设置为true，但是具体被要求中断的线程要怎么处理，完全由被中断线程⾃⼰⽽定，可以在合适的实际处理中断请求，也可以完全不处理继续执⾏下去。