Java并发编程系列 - 互斥锁：解决原子性问题

Java并发编程系列 - 互斥锁：解决原子性问题

原子的意思代表着“不可分”，那么如果我们要保证原子性就必须满足“同一时刻只有一个线程执行”，称之为互斥。如果我们能够保证对 共享变量的修改是互斥的，那么，无论是单核 CPU 还是多核 CPU，就都能保证原子性了。

如上图所示，线程A和B同时访问共享资源，只有获取到锁的线程才能得到访问同步资源的权限并且同一时刻只有一个线程访问，其他线程等待，当重新获取到锁时才能访问同步资源。

Java 语言提供的锁技术:synchronized

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 

• 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
• 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
• 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

它的使用示例如下：

public class Test {

    //修饰非静态方法
    synchronized void add(){
        //临界区
    }

    //修饰静态方法
    synchronized static void delete(){
        //临界区
    }
    
    //修饰代码块
    Object obj = new Object();
    void update(){
        synchronized (obj){
            //临界区 
        }
    }

}

上面的代码我们 看到只有修饰代码块的时候，锁定了一个 obj 对象，那修饰方法的时候锁定的是什么呢?

• 当修饰静态方法的时候，锁定的是当前类的 Class 对象，在上面的例子中就 是 Class Test，Class对象是在是 Java 虚拟机在加载 Test 类的时候创建的，因此是全局唯一的

• 当修饰非静态方法的时候，锁定的是当前实例对象 this

对于上面的例子，synchronized修饰静态方法等价于

public class Test {

    //修饰静态方法
    synchronized(Test.class) static void delete(){
        //临界区
    }
    
}

修饰非静态方法等价于

public class Test {

    //修饰非静态方法
    synchronized(this) void add(){
        //临界区
    }

}

利用synchronized解决i++问题：

public class Test {

    /**
     * 共享资源
     */
    static int i =0;
    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
        System.out.println("current i : "+i);
    }

    public static void main(String[] args) {
        Test test = new Test();
        Thread t1 = new Thread(() -> {
            for(int j=0; j<10000; j++){
                test.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for(int j=0; j<10000; j++){
                test.increase();
            }
        });
        t1.start();
        t2.start();
    }

}

我们先来看看 increase() 方法，被 synchronized 修饰后，无论是单核 CPU 还是多核 CPU，只有一个线程能够执行 increase() 方法，所以上面i最终的输出结果肯定会是20000，当一个线程执行i++操作时，另一个线程必须等待当前执行的线程执行完才可以获得执行的机会。

synchronized实现锁的原理

在介绍synchronized实现原理之前先给大家介绍下两个重要的概念：对象头、管程(monitor)。

在JVM中，对象在内存中的布局分为三块区域：对象头、实例数据和对齐填充，如下所示：

                                                                        

Java头对象，它实现synchronized的锁对象的基础，一般而言，synchronized使用的锁对象是存储在Java对象头里的，jvm中采用2个字来存储对象头(如果对象是数组则会分配3个字，多出来的1个字记录的是数组长度)

Mark Word：存储对象的hashCode、锁信息或分代年龄或GC标志等信息
指向类的指针(Class Metadata Address)：类型指针指向对象的类元数据，JVM通过这个指针确定该对象是哪个类的实例。
数组长度（只有数组对象才有）

Mark Word

Mark Word记录了对象和锁有关的信息，当这个对象被synchronized关键字当成同步锁时，围绕这个锁的一系列操作都和Mark Word有关。

Mark Word在32位JVM中的长度是32bit，在64位JVM中长度是64bit。

Mark Word在不同的锁状态下存储的内容不同，在32位JVM中是这么存的：

                           

其中轻量级锁和偏向锁是Java 6 对 synchronized 锁进行优化后新增加的。这里我们主要分析一下重量级锁也就是通常说synchronized的对象锁，锁标识位为10，其中指针指向的是monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个 monitor 与之关联，对象与其 monitor 之间的关系有存在多种实现方式，如monitor可以与对象一起创建销毁或当线程试图获取对象锁时自动生成，但当一个 monitor 被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp文件，C++实现的），如果对源码感兴趣可以在http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/file/f9f19940bf72/src/share/vm/runtime查看：

// initialize the monitor, exception the semaphore, all other fields
// are simple integers or pointers
ObjectMonitor() {
  _header       = NULL;
  _count        = 0; 
  _waiters      = 0,        //等待线程数
  _recursions   = 0;        //重入次数
  _object       = NULL;
  _owner        = NULL;     //指向获得ObjectMonitor对象的线程
  _WaitSet      = NULL;     //处于wait状态的线程，会被加入到_WaitSet
  _WaitSetLock  = 0 ;
  _Responsible  = NULL ;
  _succ         = NULL ;
  _cxq          = NULL ;    //与_EntryList类似，不过针对的是代码段加锁
  FreeNext      = NULL ;
  _EntryList    = NULL ;    //处于等待锁block状态的线程，会被加入到该双向链表中
  _SpinFreq     = 0 ;
  _SpinClock    = 0 ;
  OwnerIsThread = 0 ;
  _previous_owner_tid = 0;  //前一个拥有者的线程ID
}

ObjectMonitor中有两个双向链表，分别是_WaitSet 和 _EntryList，用来保存ObjectWaiter对象列表( 每个等待锁的线程都会被封装成ObjectWaiter对象)，_owner指向持有ObjectMonitor对象的线程，当多个线程同时访问加锁的代码段或者方法时，首先会尝试获取ObjectMonitor对象，若此时ObjectMonitor已被其他线程占有则进入 _EntryList 集合，当_EntryList 集合中线程获取到对象的monitor 后进入 _Owner 区域并把monitor中的owner变量设置为当前线程同时monitor中的计数器count加1，若线程调用 wait() 方法，将释放当前持有的monitor，owner变量恢复为null，count自减1，同时该线程进入 WaitSet集合中等待被唤醒。若当前线程执行完毕也将释放monitor(锁)并复位变量的值，以便其他线程进入获取monitor(锁)。如下图所示：

由此看来，monitor对象存在于每个Java对象的对象头中(存储的指针的指向)，synchronized锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因，因为没一个Java对象都会与一个monitor相关联。

公平锁与非公平锁：

公平锁：获取不到锁的时候，会自动加入队列，等待线程释放后，队列的第一个线程获取锁

非公平锁：获取不到锁的时候，会自动加入队列，等待线程释放锁后所有等待的线程同时去竞争

上面我们介绍了线程如何尝试获取ObjectMonitor对象的过程，那么synchronized是公平的还是非公平的呢？

synchronized实际上是非公平锁，从上面的双向链表看起来像是公平锁。但当一个线程想获取锁时，先试图插队，如果占用锁的线程释放了锁，下一个线程还没来得及拿锁，那么当前线程就可以直接获得锁；如果锁正在被其它线程占用，则排队进入_EntryList，排队的时候就不能再试图获得锁了，只能等到前面所有线程都执行完才能获得锁。