第一章--------java线程原理

1、原理之线程运行

1、栈与栈帧       Java Virtual Machine Stacks （Java 虚拟机栈）

      我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。
      每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
      每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法。

2、线程上下文切换（Thread Context Switch）

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码：

1. 线程的 cpu 时间片用完
2. 垃圾回收
3. 有更高优先级的线程需要运行
4. 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法
5. 当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等。Context Switch 频繁发生会影响性能

3、 sleep 与 yield、join

sleep
1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
3. 睡眠结束后的线程未必会立刻得到执行
4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield
1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
2. 具体的实现依赖于操作系统的任务调度器。

join 

能实现同步，当前线程调用时，能让主线程等待。

4、不推荐使用的方法

这些方法已过时，容易破坏同步代码块，造成线程死锁

5、 主线程与守护线程

      默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守
护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

注意：

垃圾回收器线程就是一种守护线程
Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

6、java中线程的6中状态

• NEW 线程刚被创建，但是还没有调用 start() 方法
• RUNNABLE 当调用了 start() 方法之后。注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行。
• BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节详述。
• TERMINATED 当线程代码运行结束

 

• 情况 1 NEW --> RUNNABLE：当调用 t.start() 方法时，由 NEW --> RUNNABLE
• 情况 2 RUNNABLE <--> WAITING：

t 线程用 synchronized(obj) 获取了对象锁后，调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING。
调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时：
竞争锁成功，t 线程从 WAITING --> RUNNABLE
竞争锁失败，t 线程从 WAITING --> BLOCKED

• 情况 3 RUNNABLE <--> WAITING

当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING
注意是当前线程在t 线程对象的监视器上等待
t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE

• 情况 4 RUNNABLE <--> WAITING

当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING
调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING -->RUNNABLE

• 情况 5 RUNNABLE <--> TIMED_WAITING

t 线程用 synchronized(obj) 获取了对象锁后，调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING
t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时：
竞争锁成功，t 线程从 TIMED_WAITING --> RUNNABLE
竞争锁失败，t 线程从 TIMED_WAITING --> BLOCKED

• 情况 6 RUNNABLE <--> TIMED_WAITING

当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING。
注意是当前线程在t 线程对象的监视器上等待。当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从TIMED_WAITING --> RUNNABLE

• 情况 7 RUNNABLE <--> TIMED_WAITING

当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED_WAITING
当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE

• 情况 8 RUNNABLE <--> TIMED_WAITING

当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时。
调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，或是等待超时，会让目标线程从
TIMED_WAITING--> RUNNABLE

• 情况 9 RUNNABLE <--> BLOCKED

t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED
持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED

• 情况 10 RUNNABLE <--> TERMINATED

当前线程所有代码运行完毕，进入TERMINATED

 

Thread t1 = new Thread("t1") {
    @Override
    public void run() {
        log.debug("running...");
    }
};

Thread t2 = new Thread("t2") {
    @Override
    public void run() {
        while(true) { // runnable

        }
    }
};
t2.start();

Thread t3 = new Thread("t3") {
    @Override
    public void run() {
        log.debug("running...");
    }
};
t3.start();

Thread t4 = new Thread("t4") {
    @Override
    public void run() {
        synchronized (TestState.class) {
            try {
                Thread.sleep(1000000); // timed_waiting
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
};
t4.start();

Thread t5 = new Thread("t5") {
    @Override
    public void run() {
        try {
            t2.join(); // waiting
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};
t5.start();

Thread t6 = new Thread("t6") {
    @Override
    public void run() {
        synchronized (TestState.class) { // blocked
            try {
                Thread.sleep(1000000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
};
t6.start();

try {
    Thread.sleep(500);
} catch (InterruptedException e) {
    e.printStackTrace();
}
log.debug("t1 state {}", t1.getState());
log.debug("t2 state {}", t2.getState());
log.debug("t3 state {}", t3.getState());
log.debug("t4 state {}", t4.getState());
log.debug("t5 state {}", t5.getState());
log.debug("t6 state {}", t6.getState());
System.in.read();

最后输出：

17:34:44.569 c.TestState [t3] - running...
17:34:45.067 c.TestState [main] - t1 state NEW
17:34:45.070 c.TestState [main] - t2 state RUNNABLE
17:34:45.070 c.TestState [main] - t3 state TERMINATED
17:34:45.070 c.TestState [main] - t4 state TIMED_WAITING
17:34:45.070 c.TestState [main] - t5 state WAITING
17:34:45.070 c.TestState [main] - t6 state BLOCKED