05.并发编程之线程常见方法

Leefs 2022-10-07 PM 535℃ 0条

[TOC]

### 一、常用方法

| 方法名             | static | 功能说明                                                     | 注意                                                         |
| ------------------ | ------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| start()            |        | 启动一个新线程，在新的线程运行run方法中的代码                | start方法只是让线程进入就绪，里面的代码不一定立刻运行（CUP的时间片还没有分给他）。每个线程对象的start方法只能调用一次，如果调用多次会出现`IllegalThreadStateException` |
| run()              |        | 新线程启用后会调用的方法                                     | 如果在构造Thread对象时传递了Runnable参数，则线程启动后调用Runnable中的run方法，否则默认不执行任何操作。但可以穿件Thread的子类对象，来覆盖默认行为 |
| join()             |        | 等待线程运行结束                                             |                                                              |
| join(long n)       |        | 等待线程运行结束，最多等待n毫秒                              |                                                              |
| `getId()`          |        | 获取线程长整型的id                                           | id唯一                                                       |
| `getName()`        |        | 获取线程名                                                   |                                                              |
| `setName(String)`  |        | 修改线程名                                                   |                                                              |
| `getPriority()`    |        | 获取线程优先级                                               |                                                              |
| `setPriority(int)` |        | 修改线程优先级                                               | java中规定优先级是1~10的整数，比较大优先级能提高该线程被CPU调用的几率 |
| `getState()`       |        | 获取线程状态                                                 | Java 中线程状态是用 6 个 enum 表示，分别为： NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED |
| `isInterrupted()`  |        | 判断是否被打断                                               | 不会清除 "打断标记"                                          |
| `isAlive()`        |        | 线程是否存活 （还没有运行完 毕）                             |                                                              |
| interrupt()        |        | 打断线程                                                     | 如果被打断线程正在 sleep，wait，join 会导致被打断 的线程抛出 `InterruptedException`，并清除打断标记 ；如果打断的正在运行的线程，则会设置打断标记 ；park 的线程被打断，也会设置打断标记 |
| interrupted()      | static | 判断当前线程是 否被打断                                      | 会清除打断标记                                               |
| `currentThread()`  | static | 获取当前正在执 行的线程                                      |                                                              |
| sleep(long n)      | static | 让当前执行的线 程休眠n毫秒， 休眠时让出 cpu 的时间片给其它 线程 |                                                              |
| yield()            | static | 提示线程调度器 让出当前线程对 CPU的使用                      | 主要是为了测试和调试                                         |

### 二、start与run方法

#### 调用run

```java
import com.lilinchao.concurrent.utils.FileReader;
import lombok.extern.slf4j.Slf4j;

/**
 * Created by lilinchao
 * Date 2022/10/7
 * Description 1.0
 */
@Slf4j(topic = "c.Test05")
public class Test05 {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug(Thread.currentThread().getName());
                FileReader.read(Constants.MP4_FULL_PATH);
            }
        };
        t1.run();
        //t1.start();
        log.debug("do other things ...");
    }
}
```

**运行结果**

```
18:15:54.365 c.Test05 [main] - main
18:15:54.368 c.FileReader [main] - read [1.mp4] start ...
18:15:59.173 c.FileReader [main] - read [1.mp4] end ... cost: 4805 ms
18:15:59.173 c.Test05 [main] - do other things ...
```

程序仍在 main 线程运行， FileReader.read() 方法调用还是同步的。

#### 调用start

将上述代码的 `t1.run()` 切换为`t1.start();`

**运行结果**

```
18:25:01.364 c.Test05 [main] - do other things ...
18:25:01.364 c.Test05 [t1] - t1
18:25:01.366 c.FileReader [t1] - read [1.mp4] start ...
18:25:02.715 c.FileReader [t1] - read [1.mp4] end ... cost: 1349 ms
```

程序在 t1 线程运行， FileReader.read() 方法调用是异步的。

#### 小结

+ 直接调用 run 是在主线程中执行了 run，没有启动新的线程；

+ 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码。

```java
  public static void main(String[] args) {
      Thread t1 = new Thread("t1") {
          @Override
          public void run() {
              log.debug("t1 running...");
          }
      };
      //获取线程状态
      System.out.println(t1.getState());
      t1.start();
      System.out.println(t1.getState());
  }
  ```

**运行结果**

```
  NEW
  RUNNABLE
  18:37:20.527 c.Test06 [t1] - t1 running...
  ```

可以看见，start方法创建了一个新线程，将线程从就绪状态切换为Runnable

### 三、sleep与yield

#### sleep

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）

2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

```java
   public static void main(String[] args) throws InterruptedException {
       Thread t1 = new Thread("t1"){
           @Override
           public void run() {
               log.debug("enter sleep...");
               try {
                   Thread.sleep(2000);
               } catch (InterruptedException e) {
                   log.debug("wake up...");
                   e.printStackTrace();
               }
           }
       };
       t1.start();
   
       Thread.sleep(1000);
       log.debug("interrupt...");
       t1.interrupt();
   }
   ```

**运行结果**

```
   18:51:01.954 c.Test07 [t1] - enter sleep...
   18:51:02.950 c.Test07 [main] - interrupt...
   18:51:02.950 c.Test07 [t1] - wake up...
   java.lang.InterruptedException: sleep interrupted
   	at java.lang.Thread.sleep(Native Method)
   	at com.lilinchao.concurrent.demo_01.Test07$1.run(Test07.java:18)
   ```

3. 睡眠结束后的线程未必会立刻得到执行

4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性 。其底层还是sleep方法。

```java
   public static void main(String[] args) throws InterruptedException {
       log.debug("enter");
       TimeUnit.SECONDS.sleep(1);
       log.debug("end");
       //Thread.sleep(1000);
   }
   ```

**运行结果**

```
   18:58:00.815 c.Test08 [main] - enter
   18:58:01.818 c.Test08 [main] - end
   ```

5. 在循环访问锁的过程中，可以加入sleep让线程阻塞时间，防止大量占用cpu资源。

#### yield

1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程 
1. 具体的实现依赖于操作系统的任务调度器
1. 它是一个静态方法而且只保证当前线程放弃 CPU 占用而不能保证使其它线程一定能占用 CPU，执行yield()的线程有可能在进入到暂停状态后马上又被执行

#### 线程优先级

- 线程优先级会提示（hint）调度器优先调度该线程，**但它仅仅是一个提示**，调度器可以忽略它

- 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

```java
  /**
   * 线程可以拥有的最低优先级。
   */
  public static final int MIN_PRIORITY = 1;
  
  /**
   * 分配给线程的默认优先级。
   */
  public static final int NORM_PRIORITY = 5;
  
  /**
   * 线程可以拥有的最大优先级。
   */
  public static final int MAX_PRIORITY = 10;
  
  /**
   * 更改此线程的优先级。
   * <p>
   * 首先调用该线程的{@code checkAccess}方法，不带任何参数。这可能会导致抛出{@code SecurityException} 。
   * <p>
   * 否则，此线程的优先级设置为指定的{@code newPriority}和线程的线程组的最大允许优先级中的较小者。
   *
   * @param newPriority 将此线程设置为的优先级
   * @throws     IllegalArgumentException  If the priority is not in the
   *               range {@code MIN_PRIORITY} to
   *               {@code MAX_PRIORITY}.
   * @throws     SecurityException  if the current thread cannot modify
   *               this thread.
   * @see        #getPriority
   * @see        #checkAccess()
   * @see        #getThreadGroup()
   * @see        #MAX_PRIORITY
   * @see        #MIN_PRIORITY
   * @see        ThreadGroup#getMaxPriority()
   */
  public final void setPriority(int newPriority) {
      ThreadGroup g;
      checkAccess();
      if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
          throw new IllegalArgumentException();
      }
      if((g = getThreadGroup()) != null) {
          if (newPriority > g.getMaxPriority()) {
              newPriority = g.getMaxPriority();
          }
          setPriority0(priority = newPriority);
      }
  }
  ```

**测试优先级和yield**

```java
@Slf4j(topic = "c.TestYield")
public class TestYield {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
//                Thread.yield();
                System.out.println("              ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}
```

**运行结果**

```
......
#优先级
---->1 283500
              ---->2 374389
#yield
---->1 119199
              ---->2 101074
......
```

> 结论：可以看出，线程优先级和yield会对线程获取cpu时间片产生一定影响，但不会影响太大。

**面试题**

**Thread 类中的 yield 方法有什么作用？**

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

> 结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

**Thread.sleep(0)的作用是什么？**

由于 `Java 采用抢占式的线程调度算法`，因此可能会出现某条线程常常获取到 CPU 控制权的情况，`为了让某些优先级比较低的线程也能获取到 CPU 控制权`，可以使用 `Thread.sleep(0)手动触发一次操作系统分配时间片的操作`，这也是`平衡 CPU 控制权的一种操作`。

#### 应用之限制

##### sleep 实现

在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu，这时可以使用 yield 或 sleep 来让出 cpu 的使用权给其他程序

```java
while(true) {
    try {
        Thread.sleep(50);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
```

- 可以用 wait 或 条件变量达到类似的效果 
- 不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景 
- sleep 适用于无需锁同步的场景

##### wait 实现

```java
synchronized(锁对象) {
    while(条件不满足) { 
        try {
            锁对象.wait();
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
    // do sth...
}
```

##### 条件变量实现

```java
lock.lock();
try {
    while(条件不满足) {
        try {
            条件变量.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // do sth...
} finally {
    lock.unlock();
}
```

### 四、join 方法详解

#### join使用示例

```java
@Slf4j(topic = "c.Test09")
public class Test09 {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        log.debug("start");
        Thread t1 = new Thread(() -> {
            log.debug("start");
            sleep(1);
            log.debug("end");
            r = 10;
        });
        t1.start();
        //t1.join();
        log.debug("result:{}", r);
        log.debug("end");
    }

}
```

**运行结果**

```
20:00:31.686 c.Test09 [main] - start
20:00:31.735 c.Test09 [Thread-0] - start
20:00:31.735 c.Test09 [main] - result:0
20:00:31.736 c.Test09 [main] - end
20:00:32.737 c.Test09 [Thread-0] - end
```

**结果分析**

- 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
- 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

**解决方法**

在`t1.start()`之后增加如下代码

```
t1.join();
```

**运行结果**

```
20:03:11.014 c.Test09 [main] - start
20:03:11.061 c.Test09 [Thread-0] - start
20:03:12.062 c.Test09 [Thread-0] - end
20:03:12.062 c.Test09 [main] - result:10
20:03:12.063 c.Test09 [main] - end
```

#### 应用之同步

以调用方角度来讲，如果

- 需要等待结果返回，才能继续运行就是同步
- 不需要等待结果返回，就能继续运行就是异步

![05.并发编程之线程常见方法01.png](https://lilinchao.com/usr/uploads/2022/10/333451017.png)

##### 等待多个结果

**示例**

```java
import lombok.extern.slf4j.Slf4j;

import static com.lilinchao.concurrent.utils.Sleeper.sleep;

/**
 * Created by lilinchao
 * Date 2022/10/7
 * Description 1.0
 */
@Slf4j(topic = "c.Test10")
public class Test10 {
    static int r1 = 0;
    static int r2 = 0;
    public static void main(String[] args) throws InterruptedException {
        test2();
    }
    private static void test2() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(1);
            r1 = 10;
        });
        Thread t2 = new Thread(() -> {
            sleep(2);
            r2 = 20;
        });
        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}
```

**运行结果**

```
20:11:48.166 c.Test10 [main] - r1: 10 r2: 20 cost: 2002
```

**说明**

- 第一个 join：等待 t1 时, t2 并没有停止, 而在运行
- 第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s

**如果t1.join()和t2.join()颠倒顺序呢？**

运行结果

```
20:15:08.682 c.Test10 [main] - r1: 10 r2: 20 cost: 2003
```

![05.并发编程之线程常见方法02.png](https://lilinchao.com/usr/uploads/2022/10/4223181870.png)

#### 有时效的join

当线程执行时间没有超过join设定时间

```java
@Slf4j(topic = "c.Test11")
public class Test11 {
    static int r1 = 0;
    static int r2 = 0;
    public static void main(String[] args) throws InterruptedException {
        test3();
    }
    public static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(1);
            r1 = 10;
        });
        long start = System.currentTimeMillis();
        t1.start();
        // 线程执行结束会导致 join 结束
        t1.join(1500);
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}
```

**运行结果**

```
20:19:02.310 c.Test11 [main] - r1: 10 r2: 0 cost: 1002
```

当执行时间超时

```java
@Slf4j(topic = "c.Test11")
public class Test11 {
    static int r1 = 0;
    static int r2 = 0;
    public static void main(String[] args) throws InterruptedException {
        test3();
    }
    public static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(2);
            r1 = 10;
        });
        long start = System.currentTimeMillis();
        t1.start();
        // 线程执行结束会导致 join 结束
        t1.join(1500);
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}
```

**运行结果**

```
20:20:39.378 c.Test11 [main] - r1: 0 r2: 0 cost: 1502
```

*附参考原文链接*

*https://blog.csdn.net/u013494827/article/details/125998256*

标签: 并发编程

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/2461.html

上一篇 04.并发编程之线程运行原理

下一篇 06.并发编程之interrupt方法详解

05.并发编程之线程常见方法

评论啦~

栏目分类

标签云

友情链接申请

05.并发编程之线程常见方法

 评论啦~

 栏目分类

标签云

友情链接申请

评论啦~

栏目分类

标签云

友情链接申请