Java 互斥锁：解决原子性问题

浅浅的花香味﹌ 2022-01-10 08:53 214阅读 0赞

# Java 互斥锁：解决原子性问题 #

一个或多个操作在CPU执行的过程中不被中断的特性，称为“原子性”。

## 原子性的问题怎么解决? ##

原子性问题的源头就是线程切换。

如果能够禁用线程切换那不就能解决这个问题吗？而操作系统做线程切换是依赖CPU中断的，所以禁止CPU发生中断就能够禁止线程切换。

单核CPU时代，这个方案是可行的，但是并不适合多核场景。

如:32位CPU上执行long型变量的写操作为例，long类型是64位的，那么在32位的CPU上执行写操作会被拆分成两次写操作（写高32位，写低32位）。

在多核场景下，同一时刻，有可能有两个线程同时在执行，一个线程执行在CPU1上，一个线程执行在CPU2上，此时禁止CPU中断，只能保证同一CPU上的线程连续执行，并不能保证同一时刻只有一个线程执行，如果这两个线程同时写long类型的高32位的话，那就有可能出现奇怪的bug了。

同一时刻只有一个线程执行。这个条件就非常重要，我们称之为互斥。

如果我们能够保证对共享变量的修改是互斥的，那么，无论是单核CPU还是多核CPU,就都能保证原子性了。

## 简易锁模型 ##

谈到互斥，一定会想到杀手级解决方案：锁。

加锁操作：lock()
    临界区：一段代码
    解锁操作：unlock()

我们把一段需要互斥执行的代码称为临界区。

像上厕所，进去锁门，上完厕所开门。

注意两个问题点：

1.  锁是什么？
2.  保护的是什么？

## 改进后的锁模型 ##

锁和锁要保护的资源是有对应关系的，你家的锁保护你家，我家的锁保护我家。

创建保护资源R的锁：LR
    加锁操作：lock(LR)
    临界区：一段代码（受保护的资源:R）
    解锁操作：unlock(LR)

## Java语言提供的锁技术：synchronized ##

锁是一种通用的技术方案, Java 语言提供的 synchronized 关键字，就是锁的一种实现。

synchronized 关键字可以用来修饰方法，也可以用来修饰代码块。

class X { 
      // 修饰非静态方法
      synchronized void foo() { 
        // 临界区
      }
      // 修饰静态方法
      synchronized static void bar() { 
        // 临界区
      }
      // 修饰代码块
      Object obj = new Object()；
      void baz() { 
        synchronized(obj) { 
          // 临界区
        }
      }
    }

Java 编译器会在 synchronized 修饰的方法或代码块前后自动加锁lock()和解锁unlock()。

## 用 synchronized 解决 count += 1问题 ##

count += 1 存在并发问题。可以使用 synchronized 来解决。

class SafeCalc { 
      long value = 0L;
      long get() { 
        return value;
      }
      synchronized void addOne() { 
        value += 1;
      }
    }

可能会忽视get()方法，要保证get()方法可见性，那么也需要加上synchronized。

class SafeCalc { 
      long value = 0L;
      synchronized long get() { 
        return value;
      }
      synchronized void addOne() { 
        value += 1;
      }
    }

get()方法和addOne()方法都需要访问 value 这个受保护的资源，这个资源用this这把锁来保护。

这个模型列像现实世界里面的球赛门票的管理，一个座位只允许一个人使用，这个座位就是受保护的资源，门票就是用来保护资源的“锁”，Java里的检票工作是由 synchronized 解决的。

## 锁和受保护资源的关系 ##

受保护资源和锁之间的关联关系是 N:1的关系。可以用一把锁保护多个资源，现实世界“包场”就是这样的。

上面的例子修改一下：

class SafeCalc { 
      static long value = 0L;
      synchronized long get() { 
        return value;
      }
      synchronized static void addOne() { 
        value += 1;
      }
    }

仔细观察，发现改动后的代码是用两个锁保护一个资源，这个受保护的资源就是静态变量 value,两个锁分别是 this 和 SafeCalc.class。

由于临界区get() 和 addOne() 是用两个锁保护的，因此这两个临界区没有互斥关系，临界区addOne() 对value 的修改对临界区 get() 也没有可见性保证，这就导致并发问题了。

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

## 总结 ##

互斥锁，只要有了并发问题，大家首先想到的就是锁。

但要用好锁，要分析锁定的对象和受保护资源之间的关系，综合考虑受保护资源的访问路径，才能用好互斥锁。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2plaWtlcnhpYW8_size_16_color_FFFFFF_t_70]: /images/20220110/c91bfa5a7890453b80ebdebfedfdb119.png