多线程学习十一：多线程对共享资源的访问

首先介绍两个概念：

1. 临界区 Critical Section：一个程序运行多个线程本身是没有问题的，但是问题出在多个线程访问共享资源。多个线程读共享资源其实也没有问题，但是在多个线程对共享资源读写操作时发生指令交错，就会出现问题，一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区
2. 竞态条件 Race Condition：多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

下面代码的执行结果是多少呢？

    static int counter = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter++;
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter--;
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
    }

运行结果：以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析。

例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i

i- -

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

如果以上代码是单线程执行是不会有问题的
但多线程下这 8 行代码可能交错运行：会有出现正数的情况，有出现负数的情况
出现负数：

出现正数：

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

• 阻塞式的解决方案：synchronized，Lock
• 非阻塞式的解决方案：原子变量
  我们先来看看使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换
  语法

 synchronized(对象) // 线程1， 线程2(blocked)
 {
  临界区
 }

• 总结：synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。

我们来用一段代码测试一下synchronized对象锁：

 static int counter = 0;
    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        //线程t1,t2要执行临界区的代码就必须拥有对象o的锁
        Thread t1 = new Thread(() -> { 
           synchronized (o){
               for (int i = 0; i < 5000; i++) {
                   counter++;
               }
           }
        }, "t1");
        Thread t2 = new Thread(() -> {
            synchronized (o){
                for (int i = 0; i < 5000; i++) {
                    counter--;
                }
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
      运行结果：
      16:15:43.727 c.test1: [main] - 0
    }

接下来我们将synchronized 面向对象改进

    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.increment();
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.decrement();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",room.get());
    }

}
class Room {
    int value = 0;

    public void increment() {
        synchronized (this) {
            value++;
        }
    }
    public void decrement() {
        synchronized (this) {
            value--;
        }
    }

    public int get() {
        synchronized (this) {
            return value;
        }
    }
    运行结果：
    16:17:03.245 c.test2: [main] - 0