Java--Synchronized与Lock的区别及底层实现

妖狐艹你老母 2023-10-03 09:39 2阅读 0赞

起初 Java 中只有 synchronized 这一种对程序加锁的方式，因此在JDK1.5之前，我们在编写并发程序的时候无一例外都是使用synchronized来实现线程同步的，而synchronized在JDK1.5之前同步的开销较大效率较低，因此在JDK1.5之后，推出了代码层面的Lock接口（synchronized为jvm层面）来实现与synchronized同样功能的同步锁，并且针对不同的并发场景也加入了许多个性锁功能

## 一、synchronized ##

synchronized是Java中的一个关键字，他的实现时基于jvm指令去实现的

Object syn = new Object();
            System.out.println("同步开始！");
            synchronized (syn) {//加锁
                //synchronized代码块
                System.out.println("synchronized");
            }//解锁
            System.out.println("同步结束！");

我们运行得到.class文件，然后找到.class文件下，通过终端如下命令javap -v XXXX.class查看

javap -v XXXX.class

如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu_size_16_color_FFFFFF_t_70][]

#### 1、synchronized同步方法时： ####

如果修饰同步方法是通过的flag ACC\_SYNCHRONIZED来完成的，也就是说一旦执行到这个方法，就会先判断是否有标志位，然后ACC\_SYNCHRONIZED会去隐式调用刚才的两个指令：monitorenter和monitorexit。

#### 2、synchronized修饰同步代码块时： ####

首先如果被synchronized修饰在方法块的话，是通过 monitorenter 和 monitorexit 这两个字节码指令获取线程的执行权的。当方法执行完毕退出以后或者出现异常的情况下会自动释放锁。

以上不管修饰哪一种：不管哪一种本质是对一个对象监视器(monitor)进行获取

monitor它就是个监视器，底层源码是C++编写的。在hotspot虚拟机中，它是采用ObjectMonitor类来实现monitor的源码如下：

bool has_monitor() const {
        return ((value() & monitor_value) != 0);
      }
      ObjectMonitor* monitor() const {
        assert(has_monitor(), "check");
        // Use xor instead of &~ to provide one extra tag-bit check.
        return (ObjectMonitor*) (value() ^ monitor_value);
      }

#### **3、synchronized原理** ####

在Java虚拟机执行到monitorenter指令时，1⃣️首先它会尝试获取对象的锁，如果该对象没有锁，或者当前线程已经拥有了这个对象的锁时，它会把计数器+1；然后当执行到monitorexit 指令时就会将计数器-1；然后当计数器为0时，锁就释放了。2⃣️如果获取锁 失败，那么当前线程就要阻塞等待，直到对象锁被另一个线程释放为止。

但是我们发现图上有2个monitorexit，那是因为synchronized锁释放有两种机制，一种就是执行完释放；另外一种就是发送异常，虚拟机释放。图中第二个monitorexit就是发生异常时执行的流程，这就是我开头说的“会有2个流程存在“。而且，从图中我们也可以看到在第30行，有一个goto指令，也就是说如果正常运行结束会跳转到38行执行。

## 二、Lock ##

Lock是java.util.concurrent.Locks 包下的一个接口，定义如下:

public interface Lock {
        void lock();
    
        void lockInterruptibly() throws InterruptedException;
    
        boolean tryLock();
    
        boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    
        void unlock();
    
        Condition newCondition();
    }

在java.util.concurrent.locks包中有很多Lock的实现类，常用的有ReentrantLock、ReadWriteLock（实现类ReentrantReadWriteLock），其实现都依赖java.util.concurrent.**AbstractQueuedSynchronizer**类简称AQS，他是实现Lock接口所有锁的核心。

public class LockClass {
        private ArrayList<Integer> arrayList = new ArrayList<Integer>();
        private Lock lock = new ReentrantLock();
    
        public static void main(String args[]){
            final LockClass obj = new LockClass();
            new Thread(() -> obj.insert(Thread.currentThread())).start();
            new Thread(() -> obj.insert(Thread.currentThread())).start();
        }
    
        private void insert(Thread thread) {
            lock.lock();//加锁
            try {
                System.out.println(thread.getName() + "得到锁");
                for (int i = 0;i < 5;i++){
                    arrayList.add(i);
                }
            } catch (Exception e){
                e.printStackTrace();
            } finally {
                System.out.println(thread.getName() + "释放锁");
                lock.unlock();//解锁
            }
        }
    }

lock 锁住的是 Lock 对象，当调用它的 lock 方法时，会将 Lock 类中的一个标志位 state 加 1（state 其实是 AbstractQueuedSynchronizer 这个类中的一个变量，它是 Lock 中一个内部类的父类），释放锁时是将 state 减 1（加 1 减 1 这样的操作是为了实现可重入）

## 三、Synchronized与Lock的区别 ##

<table> 
 <tbody> 
  <tr> 
   <th>类别</th> 
   <th>synchronized</th> 
   <th>Lock</th> 
  </tr> 
 </tbody> 
 <tbody> 
  <tr> 
   <td>存在层次</td> 
   <td>Java的关键字，在jvm层面上</td> 
   <td>是一个类</td> 
  </tr> 
  <tr> 
   <td>锁的释放</td> 
   <td> <p>1、以获取锁的线程执行完同步代码，释放锁</p> <p>2、线程执行发生异常，jvm会让线程释放锁</p> </td> 
   <td>在finally中必须释放锁，不然容易造成线程死锁</td> 
  </tr> 
  <tr> 
   <td>锁的获取</td> 
   <td>假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待</td> 
   <td>分情况而定，Lock有多个锁获取的方式，具体下面会说道，大致就是可以尝试获得锁，线程可以不用一直等待</td> 
  </tr> 
  <tr> 
   <td>锁状态</td> 
   <td>无法判断</td> 
   <td>可以判断</td> 
  </tr> 
  <tr> 
   <td>锁类型</td> 
   <td>可重入 不可中断 非公平</td> 
   <td>可重入 可中断 可公平/非公平（两者皆可）</td> 
  </tr> 
  <tr> 
   <td>性能</td> 
   <td>少量同步</td> 
   <td>大量同步</td> 
  </tr> 
 </tbody> 
</table>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210630103458662.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbmdnZVFpbmdjaHVu,size_16,color_FFFFFF,t_70