• Java多线程编程

    目录

    1、一个线程的生命周期

    2、创建一个进程

    2.1 Thread 方法

    2.2 通过Runnable接口

    2.3 通过继承Thread类本身

    2.4 通过Callable和 Future创建进程

    2.5 创建线程的三种方式的对比

    3、线程的状态

    4、线程同步

    4.1 同步代码块

    4.2 同步方法

    5、使用wait和notify

    6、线程死锁

    7、ThreadLocal

    7.1 使用场景

    7.2 使用说明

    Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以包含一个或多个线程，每条线程并行执行不同的任务。

    1、一个线程的生命周期

    线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

    下图显示了一个线程完整的生命周期。

    • 新建状态:使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
    • 就绪状态:当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
    • 运行状态:如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
    • 阻塞状态:如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
      • 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
      • 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
      • 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
    • 死亡状态:一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

    2、创建一个进程

    Java提供了三种创建线程的方法

    2.1 Thread 方法

    下表列出了Thread类的一些重要方法：

    序号

    方法描述

    1

    public void start()
    使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

    2

    public void run()
    如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。

    3

    public final void setName(String name)
    改变线程名称，使之与参数 name 相同。

    4

    public final void setPriority(int priority)
    更改线程的优先级。

    5

    public final void setDaemon(boolean on)
    将该线程标记为守护线程或用户线程。

    6

    public final void join(long millisec)
    等待该线程终止的时间最长为 millis 毫秒。

    7

    public void interrupt()
    中断线程。

    8

    public final boolean isAlive()
    测试线程是否处于活动状态。

    上述方法是被 Thread 对象调用的，下面表格的方法是 Thread 类的静态方法。

    序号

    方法描述

    1

    public static void yield()
    暂停当前正在执行的线程对象，并执行其他线程。

    2

    public static void sleep(long millisec)
    在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

    3

    public static boolean holdsLock(Object x)
    当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。

    4

    public static Thread currentThread()
    返回对当前正在执行的线程对象的引用。

    5

    public static void dumpStack()
    将当前线程的堆栈跟踪打印至标准错误流。

    2.2 通过Runnable接口

    创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。

    为了实现 Runnable，一个类只需要执行一个方法调用 run()，声明如下：

    1. class RunnableDemo implements Runnable {
    2.    private Thread t;
    3.    private String threadName;
    4.    
    5.    RunnableDemo( String name) {
    6.       threadName = name;
    7.       System.out.println("Creating " +  threadName );
    8.    }
    9.    
    10.    public void run() {
    11.       System.out.println("Running " +  threadName );
    12.       try {
    13.          for(int i = 4; i > 0; i--) {
    14.             System.out.println("Thread: " + threadName + ", " + i);
    15.             // 让线程睡眠一会
    16.             Thread.sleep(50);
    17.          }
    18.       }catch (InterruptedException e) {
    19.          System.out.println("Thread " +  threadName + " interrupted.");
    20.       }
    21.       System.out.println("Thread " +  threadName + " exiting.");
    22.    }
    23.    
    24.    public void start () {
    25.       System.out.println("Starting " +  threadName );
    26.       if (t == null) {
    27.          t = new Thread (this, threadName);
    28.          t.start ();
    29.       }
    30.    }
    31. }
    32.  
    33. public class TestThread {
    34.  
    35.    public static void main(String args[]) {
    36.       RunnableDemo R1 = new RunnableDemo( "Thread-1");
    37.       R1.start();
    38.       
    39.       RunnableDemo R2 = new RunnableDemo( "Thread-2");
    40.       R2.start();
    41.    }   
    42. }

    程序运行结果：

    1. Creating Thread-1
    2. Starting Thread-1
    3. Creating Thread-2
    4. Starting Thread-2
    5. Running Thread-1
    6. Thread: Thread-1, 4
    7. Running Thread-2
    8. Thread: Thread-2, 4
    9. Thread: Thread-1, 3
    10. Thread: Thread-2, 3
    11. Thread: Thread-1, 2
    12. Thread: Thread-2, 2
    13. Thread: Thread-1, 1
    14. Thread: Thread-2, 1
    15. Thread Thread-1 exiting.
    16. Thread Thread-2 exiting.

    2.3 通过继承Thread类本身

    创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。

    继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

    该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

    1. class ThreadDemo extends Thread {
    2.    private Thread t;
    3.    private String threadName;
    4.    
    5.    ThreadDemo( String name) {
    6.       threadName = name;
    7.       System.out.println("Creating " +  threadName );
    8.    }
    9.    
    10.    public void run() {
    11.       System.out.println("Running " +  threadName );
    12.       try {
    13.          for(int i = 4; i > 0; i--) {
    14.             System.out.println("Thread: " + threadName + ", " + i);
    15.             // 让线程睡眠一会
    16.             Thread.sleep(50);
    17.          }
    18.       }catch (InterruptedException e) {
    19.          System.out.println("Thread " +  threadName + " interrupted.");
    20.       }
    21.       System.out.println("Thread " +  threadName + " exiting.");
    22.    }
    23.    
    24.    public void start () {
    25.       System.out.println("Starting " +  threadName );
    26.       if (t == null) {
    27.          t = new Thread (this, threadName);
    28.          t.start ();
    29.       }
    30.    }
    31. }
    32.  
    33. public class TestThread {
    34.  
    35.    public static void main(String args[]) {
    36.       ThreadDemo T1 = new ThreadDemo( "Thread-1");
    37.       T1.start();
    38.       
    39.       ThreadDemo T2 = new ThreadDemo( "Thread-2");
    40.       T2.start();
    41.    }   
    42. }

    编译以上程序运行结果如下：

    1. Creating Thread-1
    2. Starting Thread-1
    3. Creating Thread-2
    4. Starting Thread-2
    5. Running Thread-1
    6. Thread: Thread-1, 4
    7. Running Thread-2
    8. Thread: Thread-2, 4
    9. Thread: Thread-1, 3
    10. Thread: Thread-2, 3
    11. Thread: Thread-1, 2
    12. Thread: Thread-2, 2
    13. Thread: Thread-1, 1
    14. Thread: Thread-2, 1
    15. Thread Thread-1 exiting.
    16. Thread Thread-2 exiting.

    2.4 通过Callable和 Future创建进程

    • 1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
    • 2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
    • 3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
    • 4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
    1. public class CallableThreadTest implements Callable<Integer> {
    2.     public static void main(String[] args)  
    3.     {  
    4.         CallableThreadTest ctt = new CallableThreadTest();  
    5.         FutureTask<Integer> ft = new FutureTask<>(ctt);  
    6.         for(int i = 0;i < 100;i++)  
    7.         {  
    8.             System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
    9.             if(i==20)  
    10.             {  
    11.                 new Thread(ft,"有返回值的线程").start();  
    12.             }  
    13.         }  
    14.         try  
    15.         {  
    16.             System.out.println("子线程的返回值："+ft.get());  
    17.         } catch (InterruptedException e)  
    18.         {  
    19.             e.printStackTrace();  
    20.         } catch (ExecutionException e)  
    21.         {  
    22.             e.printStackTrace();  
    23.         }  
    24.   
    25.     }
    26.     @Override  
    27.     public Integer call() throws Exception  
    28.     {  
    29.         int i = 0;  
    30.         for(;i<100;i++)  
    31.         {  
    32.             System.out.println(Thread.currentThread().getName()+" "+i);  
    33.         }  
    34.         return i;  
    35.     }  
    36. }

    2.5 创建线程的三种方式的对比

    • 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
    • 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

    3、线程的状态

    在Java程序中，一个线程对象只能调用一次start()方法启动新线程，并在新线程中执行run()方法。一旦run()方法执行完毕，线程就结束了。因此，Java线程的状态有以下几种：

    • New：新创建的线程，尚未执行；
    • Runnable：运行中的线程，正在执行run()方法的Java代码；
    • Blocked：运行中的线程，因为某些操作被阻塞而挂起；
    • Waiting：运行中的线程，因为某些操作在等待中；
    • Timed Waiting：运行中的线程，因为执行sleep()方法正在计时等待；
    • Terminated：线程已终止，因为run()方法执行完毕。

    用一个状态转移图表示如下：

    1.       	 ┌─────────────┐
    2.          │     New     │
    3.          └─────────────┘
    4.                 │
    5.                 ▼
    6. ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
    7.  ┌─────────────┐ ┌─────────────┐
    8. ││  Runnable   │ │   Blocked   ││
    9.  └─────────────┘ └─────────────┘
    10. │┌─────────────┐ ┌─────────────┐│
    11.  │   Waiting   │ │Timed Waiting│
    12. │└─────────────┘ └─────────────┘│
    13.  ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
    14.                 │
    15.                 ▼
    16.          ┌─────────────┐
    17.          │ Terminated  │
    18.          └─────────────┘

    当线程启动后，它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换，直到最后变成Terminated状态，线程终止。

    线程终止的原因有：

    • 线程正常终止：run()方法执行到return语句返回；
    • 线程意外终止：run()方法因为未捕获的异常导致线程终止；
    • 对某个线程的Thread实例调用stop()方法强制终止（强烈不推荐使用）。

    一个线程还可以等待另一个线程直到其运行结束。例如，main线程在启动t线程后，可以通过t.join()等待t线程结束后再继续运行：

    1. public class Main {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         Thread t = new Thread(() -> {
    4.             System.out.println("hello");
    5.         });
    6.         System.out.println("start");
    7.         t.start();
    8.         t.join();
    9.         System.out.println("end");
    10.     }
    11. }

    当main线程对线程对象t调用join()方法时，主线程将等待变量t表示的线程运行结束，即join就是指等待该线程结束，然后才继续往下执行自身线程。所以，上述代码打印顺序可以肯定是main线程先打印start，t线程再打印hello，main线程最后再打印end。

    如果t线程已经结束，对实例t调用join()会立刻返回。此外，join(long)的重载方法也可以指定一个等待时间，超过等待时间后就不再继续等待。

    4、线程同步

    如果多个线程同时读写共享变量，会出现数据不一致的问题。

    一个例子：

    1. public class Main {
    2.     public static void main(String[] args) throws Exception {
    3.         var add = new AddThread();
    4.         var dec = new DecThread();
    5.         add.start();
    6.         dec.start();
    7.         add.join();
    8.         dec.join();
    9.         System.out.println(Counter.count);
    10.     }
    11. }
    12.  
    13. class Counter {
    14.     public static int count = 0;
    15. }
    16.  
    17. class AddThread extends Thread {
    18.     public void run() {
    19.         for (int i=0; i<10000; i++) { Counter.count += 1; }
    20.     }
    21. }
    22.  
    23. class DecThread extends Thread {
    24.     public void run() {
    25.         for (int i=0; i<10000; i++) { Counter.count -= 1; }
    26.     }
    27. }

    上面的代码很简单，两个线程同时对一个int变量进行操作，一个加10000次，一个减10000次，最后结果应该是0，但是，每次运行，结果实际上都是不一样的。

    这是因为对变量进行读取和写入时，结果要正确，必须保证是原子操作。原子操作是指不能被中断的一个或一系列操作。

    例如，对于语句：

    n = n + 1;

    看上去是一行语句，实际上对应了3条指令：

    1. ILOAD
    2. IADD
    3. ISTORE

    我们假设n的值是100，如果两个线程同时执行n = n + 1，得到的结果很可能不是102，而是101，原因在于：

    1. ┌───────┐    ┌───────┐
    2. │Thread1│    │Thread2│
    3. └───┬───┘    └───┬───┘
    4.     │            │
    5.     │ILOAD (100) │
    6.     │            │ILOAD (100)
    7.     │            │IADD
    8.     │            │ISTORE (101)
    9.     │IADD        │
    10.     │ISTORE (101)│
    11.     ▼            ▼

    如果线程1在执行ILOAD后被操作系统中断，此刻如果线程2被调度执行，它执行ILOAD后获取的值仍然是100，最终结果被两个线程的ISTORE写入后变成了101，而不是期待的102。

    这说明多线程模型下，要保证逻辑正确，对共享变量进行读写时，必须保证一组指令以原子方式执行：即某一个线程执行时，其他线程必须等待：

    1. ┌───────┐     ┌───────┐
    2. │Thread1│     │Thread2│
    3. └───┬───┘     └───┬───┘
    4.     │             │
    5.     │-- lock --   │
    6.     │ILOAD (100)  │
    7.     │IADD         │
    8.     │ISTORE (101) │
    9.     │-- unlock -- │
    10.     │             │-- lock --
    11.     │             │ILOAD (101)
    12.     │             │IADD
    13.     │             │ISTORE (102)
    14.     │             │-- unlock --
    15.     ▼             ▼

    4.1 同步代码块
     

    保证一段代码的原子性就是通过加锁和解锁实现的。Java程序使用synchronized关键字对一个对象进行加锁：

    1. synchronized(lock) {
    2.     n = n + 1;
    3. }

    synchronized保证了代码块在任意时刻最多只有一个线程能执行。我们把上面的代码用synchronized改写如下：

    1. public class Main {
    2.     public static void main(String[] args) throws Exception {
    3.         var add = new AddThread();
    4.         var dec = new DecThread();
    5.         add.start();
    6.         dec.start();
    7.         add.join();
    8.         dec.join();
    9.         System.out.println(Counter.count);
    10.     }
    11. }
    12.  
    13. class Counter {
    14.     public static final Object lock = new Object();
    15.     public static int count = 0;
    16. }
    17.  
    18. class AddThread extends Thread {
    19.     public void run() {
    20.         for (int i=0; i<10000; i++) {
    21.             synchronized(Counter.lock) {
    22.                 Counter.count += 1;
    23.             }
    24.         }
    25.     }
    26. }
    27.  
    28. class DecThread extends Thread {
    29.     public void run() {
    30.         for (int i=0; i<10000; i++) {
    31.             synchronized(Counter.lock) {
    32.                 Counter.count -= 1;
    33.             }
    34.         }
    35.     }
    36. }

    使用synchronized解决了多线程同步访问共享变量的正确性问题。但是，它的缺点是带来了性能下降。因为synchronized代码块无法并发执行。此外，加锁和解锁需要消耗一定的时间，所以，synchronized会降低程序的执行效率。

    我们来概括一下如何使用synchronized：

    1. 找出修改共享变量的线程代码块；
    2. 选择一个共享实例作为锁；
    3. 使用synchronized(lockObject) { ... }。

    在使用synchronized的时候，不必担心抛出异常。因为无论是否有异常，都会在synchronized结束处正确释放锁

    4.2 同步方法

    我们知道Java程序依靠synchronized对线程进行同步，使用synchronized的时候，锁住的是哪个对象非常重要。

    让线程自己选择锁对象往往会使得代码逻辑混乱，也不利于封装。更好的方法是把synchronized逻辑封装起来。例如，我们编写一个计数器如下：

    1. public class Counter {
    2.     private int count = 0;
    3.  
    4.     public void add(int n) {
    5.         synchronized(this) {
    6.             count += n;
    7.         }
    8.     }
    9.  
    10.     public void dec(int n) {
    11.         synchronized(this) {
    12.             count -= n;
    13.         }
    14.     }
    15.  
    16.     public int get() {
    17.         return count;
    18.     }
    19. }

    这样一来，线程调用add()、dec()方法时，它不必关心同步逻辑，因为synchronized代码块在add()、dec()方法内部。并且，我们注意到，synchronized锁住的对象是this，即当前实例，这又使得创建多个Counter实例的时候，它们之间互不影响，可以并发执行：

    1. var c1 = Counter();
    2. var c2 = Counter();
    3.  
    4. // 对c1进行操作的线程:
    5. new Thread(() -> {
    6.     c1.add();
    7. }).start();
    8. new Thread(() -> {
    9.     c1.dec();
    10. }).start();
    11.  
    12. // 对c2进行操作的线程:
    13. new Thread(() -> {
    14.     c2.add();
    15. }).start();
    16. new Thread(() -> {
    17.     c2.dec();
    18. }).start();

    现在，对于Counter类，多线程可以正确调用。

    当我们锁住的是this实例时，实际上可以用synchronized修饰这个方法。下面两种写法是等价的：

    1. public void add(int n) {
    2. synchronized(this) { // 锁住this
    3.     count += n;
    4. } // 解锁
    5. }
    1. public synchronized void add(int n) { // 锁住this
    2.     count += n;
    3. } // 解锁

    因此，用synchronized修饰的方法就是同步方法，它表示整个方法都必须用this实例加锁。

    5、使用wait和notify

    在Java程序中，synchronized解决了多线程竞争的问题。例如，对于一个任务管理器，多个线程同时往队列中添加任务，可以用synchronized加锁：

    1. class TaskQueue {
    2.     Queue<String> queue = new LinkedList<>();
    3.  
    4.     public synchronized void addTask(String s) {
    5.         this.queue.add(s);
    6.     }
    7. }

    但是synchronized并没有解决多线程协调的问题。

    仍然以上面的TaskQueue为例，我们再编写一个getTask()方法取出队列的第一个任务：

    1. class TaskQueue {
    2.     Queue queue = new LinkedList<>();
    3.  
    4.     public synchronized void addTask(String s) {
    5.         this.queue.add(s);
    6.     }
    7.  
    8.     public synchronized String getTask() {
    9.         while (queue.isEmpty()) {
    10.         }
    11.         return queue.remove();
    12.     }
    13. }

    上述代码看上去没有问题：getTask()内部先判断队列是否为空，如果为空，就循环等待，直到另一个线程往队列中放入了一个任务，while()循环退出，就可以返回队列的元素了。

    但实际上while()循环永远不会退出。因为线程在执行while()循环时，已经在getTask()入口获取了this锁，其他线程根本无法调用addTask()，因为addTask()执行条件也是获取this锁。

    因此，执行上述代码，线程会在getTask()中因为死循环而100%占用CPU资源。

    如果深入思考一下，我们想要的执行效果是：

    • 线程1可以调用addTask()不断往队列中添加任务；
    • 线程2可以调用getTask()从队列中获取任务。如果队列为空，则getTask()应该等待，直到队列中至少有一个任务时再返回。

    因此，多线程协调运行的原则就是：当条件不满足时，线程进入等待状态；当条件满足时，线程被唤醒，继续执行任务。

    对于上述TaskQueue，我们先改造getTask()方法，在条件不满足时，线程进入等待状态：

    1. public synchronized String getTask() {
    2.     while (queue.isEmpty()) {
    3.         this.wait();
    4.     }
    5.     return queue.remove();
    6. }

    当一个线程执行到getTask()方法内部的while循环时，它必定已经获取到了this锁，此时，线程执行while条件判断，如果条件成立（队列为空），线程将执行this.wait()，进入等待状态。

    这里的关键是：wait()方法必须在当前获取的锁对象上调用，这里获取的是this锁，因此调用this.wait()。

    调用wait()方法后，线程进入等待状态，wait()方法不会返回，直到将来某个时刻，线程从等待状态被其他线程唤醒后，wait()方法才会返回，然后，继续执行下一条语句。

    有些仔细的童鞋会指出：即使线程在getTask()内部等待，其他线程如果拿不到this锁，照样无法执行addTask()，肿么办？

    这个问题的关键就在于wait()方法的执行机制非常复杂。首先，它不是一个普通的Java方法，而是定义在Object类的一个native方法，也就是由JVM的C代码实现的。其次，必须在synchronized块中才能调用wait()方法，因为wait()方法调用时，会释放线程获得的锁，wait()方法返回后，线程又会重新试图获得锁。

    因此，只能在锁对象上调用wait()方法。因为在getTask()中，我们获得了this锁，因此，只能在this对象上调用wait()方法：

    1. public synchronized String getTask() {
    2.     while (queue.isEmpty()) {
    3.         // 释放this锁:
    4.         this.wait();
    5.         // 重新获取this锁
    6.     }
    7.     return queue.remove();
    8. }

    当一个线程在this.wait()等待时，它就会释放this锁，从而使得其他线程能够在addTask()方法获得this锁。

    现在我们面临第二个问题：如何让等待的线程被重新唤醒，然后从wait()方法返回？答案是在相同的锁对象上调用notify()方法。我们修改addTask()如下：

    1. public synchronized void addTask(String s) {
    2.     this.queue.add(s);
    3.     this.notify(); // 唤醒在this锁等待的线程
    4. }

    注意到在往队列中添加了任务后，线程立刻对this锁对象调用notify()方法，这个方法会唤醒一个正在this锁等待的线程（就是在getTask()中位于this.wait()的线程），从而使得等待线程从this.wait()方法返回。

    我们来看一个完整的例子：

    1. public class Main {
    2.     public static void main(String[] args) throws InterruptedException {
    3.         var q = new TaskQueue();
    4.         var ts = new ArrayList<Thread>();
    5.         for (int i=0; i<5; i++) {
    6.             var t = new Thread() {
    7.                 public void run() {
    8.                     // 执行task:
    9.                     while (true) {
    10.                         try {
    11.                             String s = q.getTask();
    12.                             System.out.println("execute task: " + s);
    13.                         } catch (InterruptedException e) {
    14.                             return;
    15.                         }
    16.                     }
    17.                 }
    18.             };
    19.             t.start();
    20.             ts.add(t);
    21.         }
    22.         var add = new Thread(() -> {
    23.             for (int i=0; i<10; i++) {
    24.                 // 放入task:
    25.                 String s = "t-" + Math.random();
    26.                 System.out.println("add task: " + s);
    27.                 q.addTask(s);
    28.                 try { Thread.sleep(100); } catch(InterruptedException e) {}
    29.             }
    30.         });
    31.         add.start();
    32.         add.join();
    33.         Thread.sleep(100);
    34.         for (var t : ts) {
    35.             t.interrupt();
    36.         }
    37.     }
    38. }
    39.  
    40. class TaskQueue {
    41.     Queue<String> queue = new LinkedList<>();
    42.  
    43.     public synchronized void addTask(String s) {
    44.         this.queue.add(s);
    45.         this.notifyAll();
    46.     }
    47.  
    48.     public synchronized String getTask() throws InterruptedException {
    49.         while (queue.isEmpty()) {
    50.             this.wait();
    51.         }
    52.         return queue.remove();
    53.     }
    54. }

    这个例子中，我们重点关注addTask()方法，内部调用了this.notifyAll()而不是this.notify()，使用notifyAll()将唤醒所有当前正在this锁等待的线程，而notify()只会唤醒其中一个（具体哪个依赖操作系统，有一定的随机性）。这是因为可能有多个线程正在getTask()方法内部的wait()中等待，使用notifyAll()将一次性全部唤醒。通常来说，notifyAll()更安全。有些时候，如果我们的代码逻辑考虑不周，用notify()会导致只唤醒了一个线程，而其他线程可能永远等待下去醒不过来了。

    但是，注意到wait()方法返回时需要重新获得this锁。假设当前有3个线程被唤醒，唤醒后，首先要等待执行addTask()的线程结束此方法后，才能释放this锁，随后，这3个线程中只能有一个获取到this锁，剩下两个将继续等待。

    再注意到我们在while()循环中调用wait()，而不是if语句：

    1. public synchronized String getTask() throws InterruptedException {
    2.     if (queue.isEmpty()) {
    3.         this.wait();
    4.     }
    5.     return queue.remove();
    6. }

    这种写法实际上是错误的，因为线程被唤醒时，需要再次获取this锁。多个线程被唤醒后，只有一个线程能获取this锁，此刻，该线程执行queue.remove()可以获取到队列的元素，然而，剩下的线程如果获取this锁后执行queue.remove()，此刻队列可能已经没有任何元素了，所以，要始终在while循环中wait()，并且每次被唤醒后拿到this锁就必须再次判断：

    1. while (queue.isEmpty()) {
    2.     this.wait();
    3. }

    所以，正确编写多线程代码是非常困难的，需要仔细考虑的条件非常多，任何一个地方考虑不周，都会导致多线程运行时不正常。

    6、线程死锁

    Java的线程锁是可重入的锁。

    什么是可重入的锁？我们还是来看例子：

    1. public class Counter {
    2.     private int count = 0;
    3.  
    4.     public synchronized void add(int n) {
    5.         if (n < 0) {
    6.             dec(-n);
    7.         } else {
    8.             count += n;
    9.         }
    10.     }
    11.  
    12.     public synchronized void dec(int n) {
    13.         count += n;
    14.     }
    15. }

    观察synchronized修饰的add()方法，一旦线程执行到add()方法内部，说明它已经获取了当前实例的this锁。如果传入的n < 0，将在add()方法内部调用dec()方法。由于dec()方法也需要获取this锁，现在问题来了：

    对同一个线程，能否在获取到锁以后继续获取同一个锁？

    答案是肯定的。JVM允许同一个线程重复获取同一个锁，这种能被同一个线程反复获取的锁，就叫做可重入锁。

    由于Java的线程锁是可重入锁，所以，获取锁的时候，不但要判断是否是第一次获取，还要记录这是第几次获取。每获取一次锁，记录+1，每退出synchronized块，记录-1，减到0的时候，才会真正释放锁。

    死锁

    一个线程可以获取一个锁后，再继续获取另一个锁。例如：

    1. public void add(int m) {
    2. synchronized(lockA) { // 获得lockA的锁
    3.     this.value += m;
    4.     synchronized(lockB) { // 获得lockB的锁
    5.         this.another += m;
    6.     } // 释放lockB的锁
    7. } // 释放lockA的锁
    8. }
    9.  
    10. public void dec(int m) {
    11.     synchronized(lockB) { // 获得lockB的锁
    12.         this.another -= m;
    13.         synchronized(lockA) { // 获得lockA的锁
    14.             this.value -= m;
    15.         } // 释放lockA的锁
    16.     } // 释放lockB的锁
    17. }

    在获取多个锁的时候，不同线程获取多个不同对象的锁可能导致死锁。对于上述代码，线程1和线程2如果分别执行add()和dec()方法时：

    • 线程1：进入add()，获得lockA；
    • 线程2：进入dec()，获得lockB。

    随后：

    • 线程1：准备获得lockB，失败，等待中；
    • 线程2：准备获得lockA，失败，等待中。

    此时，两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

    死锁发生后，没有任何机制能解除死锁，只能强制结束JVM进程。

    因此，在编写多线程应用时，要特别注意防止死锁。因为死锁一旦形成，就只能强制结束进程。

    那么我们应该如何避免死锁呢？答案是：线程获取锁的顺序要一致。即严格按照先获取lockA，再获取lockB的顺序，改写dec()方法如下：

    1. public void dec(int m) {
    2. synchronized(lockA) { // 获得lockA的锁
    3.     this.value -= m;
    4.     synchronized(lockB) { // 获得lockB的锁
    5.         this.another -= m;
    6.     } // 释放lockB的锁
    7. } // 释放lockA的锁
    8. }

    7、ThreadLocal

    ThreadLocal 中填充的的是当前线程的变量，该变量对其他线程而言是封闭且隔离的，ThreadLocal 为变量在每个线程中创建了一个副本，这样每个线程都可以访问自己内部的副本变量。

    7.1 使用场景

    • 在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。
    • 线程间数据隔离
    • 进行事务操作，用于存储线程事务信息。
    • 数据库连接，Session会话管理。

    7.2 使用说明

    我们可以在代码中调用Thread.currentThread()获取当前线程。例如，打印日志时，可以同时打印出当前线程的名字：
     

    1. public class Main {
    2.     public static void main(String[] args) throws Exception {
    3.         log("start main...");
    4.         new Thread(() -> {
    5.             log("run task...");
    6.         }).start();
    7.         new Thread(() -> {
    8.             log("print...");
    9.         }).start();
    10.         log("end main.");
    11.     }
    12.  
    13.     static void log(String s) {
    14.         System.out.println(Thread.currentThread().getName() + ": " + s);
    15.     }
    16. }

    对于多任务，Java标准库提供的线程池可以方便地执行这些任务，同时复用线程。Web应用程序就是典型的多任务应用，每个用户请求页面时，我们都会创建一个任务，类似：

    1. public void process(User user) {
    2.     checkPermission();
    3.     doWork();
    4.     saveStatus();
    5.     sendResponse();
    6. }

    然后，通过线程池去执行这些任务。

    观察process()方法，它内部需要调用若干其他方法，同时，我们遇到一个问题：如何在一个线程内传递状态？

    这种在一个线程中，横跨若干方法调用，需要传递的对象，我们通常称之为上下文（Context），它是一种状态，可以是用户身份、任务信息等。

    给每个方法增加一个context参数非常麻烦，而且有些时候，如果调用链有无法修改源码的第三方库，User对象就传不进去了。

    Java标准库提供了一个特殊的ThreadLocal，它可以在一个线程中传递同一个对象。

    ThreadLocal实例通常总是以静态字段初始化如下：

    static ThreadLocal<User> threadLocalUser = new ThreadLocal<>();

    它的典型使用方式如下：

    1. void processUser(user) {
    2.     try {
    3.         threadLocalUser.set(user);
    4.         step1();
    5.         step2();
    6.     } finally {
    7.         threadLocalUser.remove();
    8.     }
    9. }

    通过设置一个User实例关联到ThreadLocal中，在移除之前，所有方法都可以随时获取到该User实例：

    1. void step1() {
    2.     User u = threadLocalUser.get();
    3.     log();
    4.     printUser();
    5. }
    6.  
    7. void log() {
    8.     User u = threadLocalUser.get();
    9.     println(u.name);
    10. }
    11.  
    12. void step2() {
    13.     User u = threadLocalUser.get();
    14.     checkUser(u.id);
    15. }

    注意到普通的方法调用一定是同一个线程执行的，所以，step1()、step2()以及log()方法内，threadLocalUser.get()获取的User对象是同一个实例。

    实际上，可以把ThreadLocal看成一个全局Map：每个线程获取ThreadLocal变量时，总是使用Thread自身作为key：

    Object threadLocalValue = threadLocalMap.get(Thread.currentThread());

    因此，ThreadLocal相当于给每个线程都开辟了一个独立的存储空间，各个线程的ThreadLocal关联的实例互不干扰。

    最后，特别注意ThreadLocal一定要在finally中清除：

    1. try {
    2.     threadLocalUser.set(user);
    3.     ...
    4. } finally {
    5.     threadLocalUser.remove();
    6. }

    这是因为当前线程执行完相关代码后，很可能会被重新放入线程池中，如果ThreadLocal没有被清除，该线程执行其他代码时，会把上一次的状态带进去。

    为了保证能释放ThreadLocal关联的实例，我们可以通过AutoCloseable接口配合try (resource) {...}结构，让编译器自动为我们关闭。例如，一个保存了当前用户名的ThreadLocal可以封装为一个UserContext对象：

    1. public class UserContext implements AutoCloseable {
    2.  
    3.     static final ThreadLocal<String> ctx = new ThreadLocal<>();
    4.  
    5.     public UserContext(String user) {
    6.         ctx.set(user);
    7.     }
    8.  
    9.     public static String currentUser() {
    10.         return ctx.get();
    11.     }
    12.  
    13.     @Override
    14.     public void close() {
    15.         ctx.remove();
    16.     }
    17. }

    使用的时候，我们借助try (resource) {...}结构，可以这么写：

    1. try (var ctx = new UserContext("Bob")) {
    2.     // 可任意调用UserContext.currentUser():
    3.     String currentUser = UserContext.currentUser();
    4. } // 在此自动调用UserContext.close()方法释放ThreadLocal关联对象

    这样就在UserContext中完全封装了ThreadLocal，外部代码在try (resource) {...}内部可以随时调用UserContext.currentUser()获取当前线程绑定的用户名。

  • 相关阅读:
    【MogDB/openGauss的三种函数稳定性关键字】
    用爬虫玩转石墨文档
    Java基础入门1-2
    ELK创建仪表盘
    测试网线的仪器叫什么？
    RHCE——实施高级存储功能(CSA)
    【华为OD机试真题 python】 绘图机器【2022 Q4 | 100分】
    Vue3.0+typescript+Vite+Pinia+Element-plus搭建vue3框架！
    代理IP和Socks5代理：跨界电商与爬虫的智能引擎
    风控数据(模型)不扎心，只因好这道流水工序上的处理技巧
  • 原文地址：https://blog.csdn.net/qq_62254095/article/details/132792610