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

谁借莪１个温暖的怀抱￠ 2022-12-07 12:18 283阅读 0赞

## 1.线程基础知识 ##

### 1.1 线程状态 ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]

> 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调用

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/8abf2adc3d134af7ad74a6ef890edb57.png