Java高并发编程学习（二）线程同步

冷不防 2023-07-07 05:52 18阅读 0赞

### 简介 ###

当多个线程同时运行时，线程的调度由操作系统决定，程序本身是无法决定的。因此，任何一个线程都有可能在任何指令处被操作系统暂停，然后在某个时间段后继续执行。这个时候，有个单线程模型下不存在的问题就来了：如果多个线程同时读写共享变量，会出现数据不一致的问题，接下来研究一下线程同步与线程安全问题。

### 线程锁 ###

多线程模型下，要对变量进行读取和写入，结果要正确，必须保证是原子操作。原子操作是指不能被中断的一个或一系列操作，即某一个线程执行时，其他线程必须等待！  
**通过加锁和解锁的操作，即能实现原子操作，其他线程会因为无法获得锁导致无法进入此指令区间**。只有执行线程将锁释放后，其他线程才有机会获得锁并执行。这种加锁和解锁之间的代码块我们称之为临界区（Critical Section），任何时候临界区最多只有一个线程能执行。Java程序使用synchronized关键字对一个对象进行加锁：

synchronized(lock) {
        n = n + 1;
    }

synchronized保证了代码块在任意时刻最多只有一个线程能执行。示例如下：

public class Main {
        public static void main(String[] args) throws Exception {
            var add = new AddThread();
            var dec = new DecThread();
            add.start();
            dec.start();
            add.join();
            dec.join();
            System.out.println(Counter.count);
        }
    }
    
    class Counter {
        public static final Object lock = new Object();
        public static int count = 0;
    }
    
    class AddThread extends Thread {
        public void run() {
            for (int i=0; i<10000; i++) {
                synchronized(Counter.lock) {
                    Counter.count += 1;
                }
            }
        }
    }
    
    class DecThread extends Thread {
        public void run() {
            for (int i=0; i<10000; i++) {
                synchronized(Counter.lock) {
                    Counter.count -= 1;
                }
            }
        }
    }

其中这段代码：

synchronized(Counter.lock) { // 获取锁
        ...
    } // 释放锁

它表示用Counter.lock实例作为锁，两个线程在执行各自的synchronized(Counter.lock) \{ … \}代码块时，必须先获得锁，才能进入代码块进行。执行结束后，在synchronized语句块结束会自动释放锁。使用synchronized解决了多线程同步访问共享变量的正确性问题。但是，它的缺点是带来了性能下降。因为synchronized代码块无法并发执行。此外，加锁和解锁需要消耗一定的时间，所以，synchronized会降低程序的执行效率。不必担心抛出异常。因为无论是否有异常，都会在synchronized结束处正确释放锁。  
总结如何使用synchronized：

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

需要注意的是：**多个线程锁住的一定要是同一个对象，才能有锁的效果**，因为JVM只保证同一个锁在任意时刻只能被一个线程获取，但两个不同的锁在同一时刻可以被两个线程分别获取。

#### 不需要synchronized的操作 ####

JVM规范定义了几种原子操作：

*  基本类型（long和double除外）赋值，例如：int n = m；
 *  引用类型赋值，例如：List list = anotherList。

long和double是64位数据，JVM没有明确规定64位赋值操作是不是一个原子操作，不过在x64平台的JVM是把long和double的赋值作为原子操作实现的。

### 同步方法 ###

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

public class Counter {
        private int count = 0;
    
        public void add(int n) {
            synchronized(this) {
                count += n;
            }
        }
    
        public void dec(int n) {
            synchronized(this) {
                count += n;
            }
        }
    
        public int get() {
            return count;
        }
    }

**如果一个类被设计为允许多线程正确访问，我们就说这个类就是“线程安全”的（thread-safe）**，上面的Counter类就是线程安全的。Java标准库的java.lang.StringBuffer也是线程安全的。还有一些不变类，例如String，Integer，LocalDate，它们的所有成员变量都是final，多线程同时访问时只能读不能写，这些不变类也是线程安全的。最后，类似Math这些只提供静态方法，没有成员变量的类，也是线程安全的。  
除了上述几种少数情况，大部分类，例如ArrayList，都是非线程安全的类，我们不能在多线程中修改它们。但是，如果所有线程都只读取，不写入，那么ArrayList是可以安全地在线程间共享的。所以**多线程能否安全访问某个非线程安全的实例，需要具体问题具体分析**。注：没有特殊说明时，一个类默认是非线程安全的。  
当我们锁住的是this实例时，实际上可以用synchronized修饰这个方法。下面两种写法是等价的：

public void add(int n) {
        synchronized(this) { // 锁住this
            count += n;
        } // 解锁
    }

等价于

public synchronized void add(int n) { // 锁住this
        count += n;
    } // 解锁

如果对一个静态方法添加synchronized修饰符，它锁住的是哪个对象？

public synchronized static void test(int n) {
        ...
    }

对于static方法，是没有this实例的，因为static方法是针对类而不是实例。但是我们注意到任何一个类都有一个由JVM自动创建的Class实例，因此，对static方法添加synchronized，锁住的是该类的class实例。上述synchronized static方法实际上相当于：

public class Counter {
        public static void test(int n) {
            synchronized(Counter.class) {
                ...
            }
        }
    }

### 死锁 ###

Java的线程锁是可重入的锁。也即是说能在获取到锁以后，继续获取同一个锁，JVM允许同一个线程重复获取同一个锁，这种能被同一个线程反复获取的锁，就叫做可重入锁。  
由于Java的线程锁是可重入锁，所以，获取锁的时候，不但要判断是否是第一次获取，还要记录这是第几次获取。每获取一次锁，记录+1，每退出synchronized块，记录-1，减到0的时候，才会真正释放锁。  
当两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。死锁发生后，没有任何机制能解除死锁，只能强制结束JVM进程。因此，在编写多线程应用时，要特别注意防止死锁。如何避免死锁：线程获取锁的顺序要一致。即严格按照先获取lockA，再获取lockB的顺序。例如：

public void dec(int m) {
        synchronized(lockA) { // 先获得lockA的锁
            this.value -= m;
            synchronized(lockB) { // 再获得lockB的锁
                this.another -= m;
            } // 释放lockB的锁
        } // 释放lockA的锁
    }

### wait和notify ###

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

class TaskQueue {
        Queue<String> queue = new LinkedList<>();
    
        public synchronized void addTask(String s) {
            this.queue.add(s);
        }
    
        public synchronized String getTask() {
            while (queue.isEmpty()) {
            }
            return queue.remove();
        }
    }

上述代码看上去没有问题：getTask()内部先判断队列是否为空，如果为空，就循环等待，直到另一个线程往队列中放入了一个任务，while()循环退出，就可以返回队列的元素了。但实际上while()循环永远不会退出。因为线程在执行while()循环时，已经在getTask()入口获取了this锁，其他线程根本无法调用addTask()，因为addTask()执行条件也是获取this锁。因此，执行上述代码，线程会在getTask()中因为死循环而100%占用CPU资源。  
我们要执行的效果是：

*  线程1可以调用addTask()不断往队列中添加任务；
 *  线程2可以调用getTask()从队列中获取任务。如果队列为空，则getTask()应该等待，直到队列中至少有一个任务时再返回。因此，多线程协调运行的原则就是：当条件不满足时，线程进入等待状态；当条件满足时，线程被唤醒，继续执行任务。

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

public synchronized String getTask() {
        while (queue.isEmpty()) {
            this.wait();
        }
        return queue.remove();
    }

当一个线程执行到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()方法：

public synchronized String getTask() {
        while (queue.isEmpty()) {
            // 释放this锁:
            this.wait();
            // 重新获取this锁
        }
        return queue.remove();
    }

当一个线程在this.wait()等待时，它就会释放this锁，从而使得其他线程能够在addTask()方法获得this锁。  
现在我们面临第二个问题：如何让等待的线程被重新唤醒，然后从wait()方法返回？答案是在相同的锁对象上调用notify()方法，修改addTask()如下：

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

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

public class Main {
        public static void main(String[] args) throws InterruptedException {
            var q = new TaskQueue();
            var ts = new ArrayList<Thread>();
            for (int i=0; i<5; i++) {
                var t = new Thread() {
                    public void run() {
                        // 执行task:
                        while (true) {
                            try {
                                String s = q.getTask();
                                System.out.println("execute task: " + s);
                            } catch (InterruptedException e) {
                                return;
                            }
                        }
                    }
                };
                t.start();
                ts.add(t);
            }
            var add = new Thread(() -> {
                for (int i=0; i<10; i++) {
                    // 放入task:
                    String s = "t-" + Math.random();
                    System.out.println("add task: " + s);
                    q.addTask(s);
                    try { Thread.sleep(100); } catch(InterruptedException e) {}
                }
            });
            add.start();
            add.join();
            Thread.sleep(100);
            for (var t : ts) {
                t.interrupt();
            }
        }
    }
    
    class TaskQueue {
        Queue<String> queue = new LinkedList<>();
    
        public synchronized void addTask(String s) {
            this.queue.add(s);
            this.notifyAll();
        }
    
        public synchronized String getTask() throws InterruptedException {
            while (queue.isEmpty()) {
                this.wait();
            }
            return queue.remove();
        }
    }

这里内部调用了this.notifyAll()而不是this.notify()，**使用notifyAll()将唤醒所有当前正在this锁等待的线程，而notify()只会唤醒其中一个（具体哪个依赖操作系统，有一定的随机性）。这是因为可能有多个线程正在getTask()方法内部的wait()中等待，使用notifyAll()将一次性全部唤醒。通常来说，notifyAll()更安全。有些时候，如果我们的代码逻辑考虑不周，用notify()会导致只唤醒了一个线程，而其他线程可能永远等待下去醒不过来了**。  
注意到wait()方法返回时需要重新获得this锁。假设当前有3个线程被唤醒，唤醒后，首先要等待执行addTask()的线程结束此方法后，才能释放this锁，随后，这3个线程中只能有一个获取到this锁，剩下两个将继续等待。  
再注意到我们在while()循环中调用wait()，而不是if语句：

public synchronized String getTask() throws InterruptedException {
        if (queue.isEmpty()) {
            this.wait();
        }
        return queue.remove();
    }

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

while (queue.isEmpty()) {
        this.wait();
    }

### 参考资料 ###

**Java核心技术 卷1 基础知识**  
**[https://www.liaoxuefeng.com/wiki/1252599548343744][https_www.liaoxuefeng.com_wiki_1252599548343744]**

### 接下来 ###

#### [Java高并发编程学习（一）多线程基础][Java] ####

#### [Java高并发编程学习（二）线程同步][Java 1] ####

#### [Java高并发编程学习（三）java.util.concurrent包][Java_java.util.concurrent] ####

[https_www.liaoxuefeng.com_wiki_1252599548343744]: https://www.liaoxuefeng.com/wiki/1252599548343744
[Java]: https://blog.csdn.net/qq_22136439/article/details/104427003
[Java 1]: https://blog.csdn.net/qq_22136439/article/details/104427259
[Java_java.util.concurrent]: https://blog.csdn.net/qq_22136439/article/details/104444867