【Java并发编程】Java多线程（一）：线程基础

1.线程基础知识

1.1 线程状态

• NEW（创建）：线程刚被创建，但未启动，还未调用start
• RUNNABLE（可运行）：调用了 strat 方法；可能在 CPU 执行，也有可能没有
• TIMED_WAITING（计时等待）：让出 CPU，计时休眠；sleep（持锁）
• WAITINIT（等待）：让出 CPU，休眠；无锁 park->unpark，有锁 wait->notify（会释放锁）
• BLOCKED（阻塞）：等待获得 monitor lock 锁，是对于 synchronized 而言
• TERMINATED（终止）：运行结束；子线程运行完成、被打断、被中止

PS：操作系统的线程状态为：创建、运行、就绪、阻塞、终止。

这里需要注意以下两点：

1. 阻塞之后是进入就绪状态，重新等待调度，而不能直接获得CPU进入运行态
2. 当线程的时间片用完之后是进入就绪状态，重新等待调度

1.2 优先级

优先级代表线程执行的机会的大小，优先级高的可能先执行，低的可能后执行，在 Java 源码中，优先级从低到高分别是 1 到 10，线程默认 new 出来的优先级都是 5，源码如下：

// 最低优先级
public final static int MIN_PRIORITY = 1; 

// 普通优先级，也是默认的
public final static int NORM_PRIORITY = 5;

// 最大优先级
public final static int MAX_PRIORITY = 10;

1.3 守护线程

我们默认创建的线程都是非守护线程。创建守护线程时，需要将 Thread 的 daemon 属性设置成 true，守护线程的优先级很低，当 JVM 退出时，是不关心有无守护线程的，即使还有很多守护线程，JVM 仍然会退出。

我们在工作中，可能会写一些工具做一些监控的工作，这时我们都是用守护子线程去做，这样即使监控抛出异常，但因为是子线程，所以也不会影响到业务主线程，因为是守护线程，所以 JVM 也无需关注监控是否正在运行，该退出就退出，所以对业务不会产生任何影响。

1.4 几点注意

• 线程是交替运行的（任务>时间片），现在 CPU 往往多核
• main 是主线程，可能提前执行完成一般不要阻塞
• 线程间相互独立，当有异常抛出时，只会影响当前线程
• Thread.currentThread() 获取当前线程

2.线程创建方式

JVM 中创建线程有2种方式：

1. new java.lang.Thread().start()
2. 使用 JNI 将一个 native thread attach 到JVM中

2.1 Thread#start()

针对 new java.lang.Thread().start()这种方式，只有调用 start() 方法的时候，才会真正的在 JVM中去创建线程，主要的生命周期步骤有：

1. 创建对应的 JavaThread 的 instance
2. 创建对应的 OSThread 的 instance
3. 创建实际的底层操作系统的 native thread
4. 准备相应的 JVM 状态，比如 ThreadLocal 存储空间分配等
5. 底层的 native thread 开始运行，调用 java.lang.Thread 生成的 Object的run() 方法
6. 当 java.lang.Thread 生成的 Object 的 run() 方法执行完毕返回后，或者抛出异常终止后，终止native thread
7. 释放 JVM 相关的 thread 的资源，清除对应的 JavaThread 和 OSThread

start 方法可以创建一个新的线程出来，内部就是调用 Runnable 的 run 方法

public synchronized void start() {
    // 如果没有初始化，抛异常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    // started 是个标识符，我们在做一些事情的时候，经常这么写
    // 动作发生之前标识符是 false，发生完成之后变成 true
    boolean started = false;
    try {
        // 这里会创建一个新的线程，执行完成之后，新的线程已经在运行了，既 target 的内容已经在运行了
        start0();
        // 这里执行的还是主线程
        started = true;
    } finally {
        try {
            // 如果失败，把线程从线程组中删除
            if (!started) {
                group.threadStartFailed(this);
            }
         // Throwable 可以捕捉一些 Exception 捕捉不到的异常，比如说子线程抛出的异常
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}
// 开启新线程使用的是 native 方法
private native void start0();

所以说，线程相当于载体，要 start 必须要有任务(Callable/Runnable)。

1）Thread

为了方便，Thread 已经实现了 Runnable，因此可以直接继承 Thread，并重写 run 方法

class MyThread extends Thread{
  	public void run() {...}
}

2）Runnable

// 内部类
Thread thread = new Thread(new Runnable() {
  public void run() {...}
});

// lamada
new Thread(()->{
    public void run() {...}
}).start()

3）Callable

// Callable不能直接使用，而是包装成FutureTask 
FutureTask futureTask = new FutureTask(new Callable<T> () {
    public String call() throws Exception {...}
  });
// FutureTask也是Runnable，所以可以传入Thread然后运行
new Thread(futureTask).start();
// 获取执行结果，无参会一直阻塞等待执行结果
futureTask.get()

2.2 JNI native thread attach

针对 JNI 将一个 native thread attach 到 JVM 中，主要的步骤有：

1. 通过 JNI call AttachCurrentThread 申请连接到执行的 JVM 实例
2. JVM 创建相应的 JavaThread 和 OSThread 对象
3. 创建相应的 java.lang.Thread 的对象
4. 一旦 java.lang.Thread 的 Object 创建之后，JNI 就可以调用Java代码了
5. 当通过JNI call DetachCurrentThread 之后，JNI 就从 JVM 实例中断开连接
6. JVM 清除相应的 JavaThread, OSThread, java.lang.Thread 对象

3.线程状态控制

3.1 Thread.sleep()

• 线程进入 Timed_Waiting，当前线程休眠，释放 CPU，持锁等待
• 作用
  • 模拟任务；防止多线程下任务<时间片，线程串行执行
  • 暂停线程；在线程运行期间将其暂停，让其余线程运行
• TimeUnit.SECONDS.sleep(2)

3.2 Thread.yeild()

• 当前线程让出CPU，进入NEW状态，再次去竞争CPU
• 作用：防止当前线程一直占用CPU
• 与 sleep 的区别
  • sleep 可以指定等待时间
  • sleep 这段时间各个级别的线程都可运行，yeild一般只能让优先级高的线程运行

3.3 Thread.interrput()

• 设置线程中断不影响线程的继续执行
• 但是线程设置休眠后（wait、jion、sleep）， 抛出 InterruptedException，且中断标志被清除，重新设置为false
• Thread.currentThread().isInterrupted()

3.4 obj.wait()

• 线程进入WAITING，释放当前对象的锁，等待被唤醒
• 必须在synchronized代码块内使用，要先持有锁
  • 本质：Java的线程通信实质上是共享内存，而不是直接通信
  • 表象：wait,notify 需要调用 monitor 对象
• 一般配合while使用
  • 被唤醒后会重新竞争锁，之后从上次wait位置重新运行
  • while 多次判断，防止在wait这段时间内对象被修改

3.5 obj.notify(All)()

• 随机唤醒wait的线程
• 必须在synchronized代码块中使用
• 等当前线程运行完释放锁后，唤醒的线程再重新竞争锁
• 在生产者消费者模型中，推荐使用notifyAll，因为notify唤醒的线程不确定是生产者或消费者

3.6 obj.join()

• 当前线程会等待调用 join 的线程结束后，再继续运行
• 本质：其实就是当前线程功能 wait，调用线程运行完后 notify
• 作用
  • 当线程任务量大时，保证 main 线程在这些线程运行结束后再结束、
  • 可控制子线程间执行顺序

3.7 LockSupport.park()

• 使指定线程在没获得锁的情况下进入WAITING，休眠释放CPU
• 需要 unpark 指定唤醒线程
• 区别对比：
  • wait：unpark(th)可以唤醒指定线程，而notify是随机唤醒
  • yeild：park进入休眠状态不再抢占CPU，而yeild只是让出并参与下一次CPU竞争
  • interrput：interrput在线程休眠前不会影响线程执行
• park是定义UNSAFE中的，一般通过LockSupport调用