一文带你彻底了解synchronized 和 Lock

淩亂°似流年 2023-10-11 18:09 4阅读 0赞

#### 文章目录 ####

*  1.synchronized实现原理
 *  2.synchronized锁表现三种形势
 *   *  2.1 普通同步方法：锁是当前实例对象
     *  2.2 静态同步方法：锁是当前类的class对象
     *  2.3 同步方法块：锁是括号里面的对象
 *  3.为什么说Synchronized是一个重量级锁
 *  4.Synchronized锁存储位置
 *  5.Synchronized锁的升级过程
 *  6.synchronized和lock的区别
 *   *  6.1 synchronized和lock的用法区别
     *  6.2 synchronized和lock性能区别
     *  6.3 具体区别：

## 1.synchronized实现原理 ##

Java中**每一个对象都可以作为锁**，这是synchronized实现同步的基础

当一个线程访问同步代码块时，它首先是**需要得到锁**，当退出或者抛出异常时**必须要释放锁**，那么它是如何来实现这个机制的呢？

同步方法通过**ACC\_SYNCHRONIZED 关键字隐式**的对方法进行加锁。当线程要执行的方法被标注上ACC\_SYNCHRONIZED时，需要先获得锁才能执行该方法。

同步代码块通过**monitorenter和monitorexit**执行来进行加锁。当线程执行到**monitorenter**的时候要**先获得锁**，才能执行后面的方法。当线程执行到**monitorexit**的时候则**要释放锁**。每个对象**自身维护着一个被加锁次数的计数器**，当计数器不为0时，只有获得锁的线程才能再次获得锁。

## 2.synchronized锁表现三种形势 ##

上面我们提到：Java中每一个对象都可以作为锁，这是synchronized实现同步的基础，且它有三种表现形式，下面我们具体来探讨一下这三种形式。

*  **普通同步方法**：锁是当前实例对象
 *  **静态同步方法**：锁是当前类的class对象
 *  **同步方法块**：锁是括号里面的对象

### 2.1 普通同步方法：锁是当前实例对象 ###

public class SynchronizedTest {
        
        public synchronized void test(String name){
        
            System.out.println(name+"开始执行");
            try {
        
                Thread.sleep(2000);
            }catch (Exception e){
        
            }
            System.out.println(name+"执行完毕");
        }
        public static void main(String[] args) throws  Exception {
        
            SynchronizedTest t=new SynchronizedTest();
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    t.test("线程1");
                }
            }).start();
            SynchronizedTest t1=new SynchronizedTest();
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    t1.test("线程2");
                }
            }).start();
        }
    }

![在这里插入图片描述][f32f7bbd7111416bbd1f12dd51db73cc.png_pic_center]

从运行结果，我们可以看出线程2并没有等待线程1结束才开始运行，这说明什么？

> **说明对于普通方法，如果是不同的对象实例锁是不起作用的**

我们把上面的代码修改一下，改为同一个实例

public class SynchronizedTest {
        
        public synchronized void test(String name){
        
            System.out.println(name+"开始执行");
            try {
        
                Thread.sleep(2000);
            }catch (Exception e){
        
            }
            System.out.println(name+"执行完毕");
        }
    
        public static void main(String[] args) throws  Exception {
        
            SynchronizedTest t=new SynchronizedTest();
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    t.test("线程1");
                }
            }).start();
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    t.test("线程2");
                }
            }).start();
        }
    }

![在这里插入图片描述][6f3ae76c2fee4b2db2a28b74c53e2b9f.png_pic_center]

可以看出来，同一个实例下，synchronized生效了。

### 2.2 静态同步方法：锁是当前类的class对象 ###

public class SynchronizedTest {
        
        public synchronized static void test(String name){
        
            System.out.println(name+"开始执行");
            try {
        
                Thread.sleep(2000);
            }catch (Exception e){
        
            }
            System.out.println(name+"执行完毕");
        }
        public static void main(String[] args) throws  Exception {
        
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    SynchronizedTest.test("线程1");
                }
            }).start();
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    SynchronizedTest.test("线程2");
                }
            }).start();
        }
    }

![在这里插入图片描述][722b438e02b94bf981d765aebd975ce6.png_pic_center]

### 2.3 同步方法块：锁是括号里面的对象 ###

public class SynchronizedTest {
        
        public  void test(String name){
        
           Object o=new Object();
            synchronized(o.getClass()){
        
                System.out.println(name+"开始执行");
                try {
        
                    Thread.sleep(2000);
                }catch (InterruptedException e){
        
                    e.printStackTrace();
                }
    
                System.out.println(name+"执行完毕");
            }
    
        }
        public static void main(String[] args) throws  Exception {
        
            SynchronizedTest t=new SynchronizedTest();
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    t.test("线程1");
                }
            }).start();
            SynchronizedTest t1=new SynchronizedTest();
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    t1.test("线程2");
                }
            }).start();
        }
    }

![在这里插入图片描述][14bc6bfe743c4376bc78e5ecb583059e.png_pic_center]

上面代码都很简单，可能在文章里感觉很长，大家不妨自己去运行一下，切身感受一下。

## 3.为什么说Synchronized是一个重量级锁 ##

Synchronized 是通过对象内部的一个叫做**监视器锁（monitor）**来实现的，监视器锁本质又是**依赖于底层的操作系统的 Mutex Lock（互斥锁）**来实现的。

而操作系统实现线程之间的**切换需要从用户态转换到核心态**，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么 Synchronized 效率低的原因。因此，这种依赖于操作系统 **Mutex Lock** 所实现的锁我们称之为 **“重量级锁”**。

## 4.Synchronized锁存储位置 ##

Synchronized用的锁是存在**java的对象头**里面的。一个对象在new出来之后再内存中主要分为**4个部分**：  
![在这里插入图片描述][f132643e38174742b02359346cd5fd15.png_pic_center]

*  **Mark Word**：存储了对象的**hashCode、GC信息、锁信息**三部分。这部分占**8字节**。
 *  **Class Pointer**：存储了指向**类对象信息的指针**。在64位JVM上有一个压缩指针选项-ClassPointer指针：-XX:+UseCompressedClassPointers 为4字节 不开启为8字节。**默认是开启的**。
 *  **实例数据(instance data)**：记录了对象里面的**变量数据**。引用类型：-XX:+UseCompressedOops 为4字节，不开启为8字节 Oops Ordinary Object Pointers
 *  **Padding**：作为**对齐使用**，对象在64位服务版本中，规定对象内存**必须要能被8字节整除**，如果不能整除，那么就靠**对齐来补**。
    
     *  举个例子：new出了一个对象，内存只占用18字节，但是规定要能被8整除，所以padding=6

## 5.Synchronized锁的升级过程 ##

Java SE 1.6 为了**减少获得锁和释放锁**带来的性能消耗，引入了 **“偏向锁”** 和**“轻量级锁”** ：锁一共有 4 种状态，级别从低到高依次是：**无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态**。

值得我们注意的是**锁可以升级但不能降级**。

1.**偏向锁**：大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了**让线程获得锁的代价更低**而引入了偏向锁。

当一个线程访问同步块并获取锁时，会在**对象头**和**栈**中记录存储锁偏向的**线程ID**，以后该线程在进入同步块时**先判断**对象头的Mark Word里是否存储着指向当前线程的偏向锁，如果存在就直接获取锁。

2.**轻量级锁**：当**其他线程尝试竞争偏向锁**时，锁升级为轻量级锁。线程在执行同步块之前，JVM会先在当前线程的栈帧中创建用于**存储锁记录**的空间，并将对象头中的MarkWord替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，标识其他线程竞争锁，当前线程便尝试使用**自旋**来获取锁。

3.**重量级锁**：锁在**原地循环等待**的时候，是会消耗CPU资源的。所以自旋必须要有一定的条件控制，否则如果一个线程执行同步代码块的时间很长，那么等待锁的线程会不断的循环反而会消耗CPU资源。默认情况下锁自旋的次数是**10**次，可以使用**-XX:PreBlockSpin**参数来设置自旋锁等待的次数。10次后如果还没获取锁，则升级为重量级锁。

## 6.synchronized和lock的区别 ##

![在这里插入图片描述][7fd7b51555414429b3e73cbea83121b6.jpeg_pic_center]

Synchronized**编码**更简单，锁机制由**JVM**维护，在竞争**不激烈**的情况下性能更好。Lock功能更强大更灵活，**竞争激烈**时性能较好。

区别如下：

**1.来源**：lock是一个**接口**，而synchronized是java的一个**关键字**，synchronized是内置的语言实现；

**2.异常是否释放锁**：synchronized在发生异常时候会**自动释放**占有的锁，因此**不会出现死锁**；

而lock发生异常时候，**不会主动释放**占有的锁，必须手动unlock来释放锁，**可能引起死锁**的发生。（所以最好将同步代码块用try catch包起来，finally中写入unlock，避免死锁的发生。）

**3.是否响应中断**：lock等待锁过程中可以用**interrupt**来中断等待，而synchronized只能等待锁的释放，**不能响应中断**；

**4.是否知道获取锁**：Lock可以通过**trylock**来知道有没有获取锁，而synchronized不能；

Lock可以提高**多个线程进行读操作的效率**。（可以通过**readwritelock**实现读写分离）

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要**远远优于**synchronized。所以说，在具体使用时要根据适当情况选择。

synchronized使用Object对象本身的**wait 、notify、notifyAll**调度机制，而Lock可以使用**Condition**进行线程之间的调度。

Lock lock=new ReentrantLock();
    Condition condition=lock.newCondition();
    ...
    condition.await();
    ...
    condition.signal();
    condition.signalAll();

### 6.1 synchronized和lock的用法区别 ###

**synchronized：** 在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。

**lock：** 一般使用**ReentrantLock**类做为锁。在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。

### 6.2 synchronized和lock性能区别 ###

synchronized是托管给JVM执行的，而lock是java写的控制锁的代码。

在Java1.5中，synchronize是性能低效的。因为这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用Java提供的Lock对象，性能更高一些。

但是到了Java1.6，发生了变化。synchronize在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。导致在Java1.6上synchronize的性能并不比Lock差。官方也表示，他们也更支持synchronize，在未来的版本中还有优化余地。

### 6.3 具体区别： ###

synchronized原始采用的是**CPU悲观锁机制**，即线程获得的是**独占锁**。、

独占锁意味着其他线程只能依靠**阻塞**来等待线程释放锁。而在CPU转换线程阻塞时会引起线程**上下文切换**，当有很多线程竞争锁的时候，会引起**CPU频繁的上下文切换导致效率很低**。

而Lock用的是**乐观锁方式**。**所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止**。

乐观锁实现的机制就是**CAS操作（Compare and Swap）**。我们可以进一步研究ReentrantLock的源代码，会发现其中比较重要的获得锁的一个方法是**compareAndSetState**。这里其实就是调用的CPU提供的特殊指令。

现代的CPU提供了指令，可以**自动更新共享数据**，而且能够检测到其他线程的干扰，而compareAndSet() 就用这些代替了锁定。这个算法称作非阻塞算法，意思是一个线程的失败或者挂起**不应该影响**其他线程的失败或挂起的算法。

[f32f7bbd7111416bbd1f12dd51db73cc.png_pic_center]: https://img-blog.csdnimg.cn/f32f7bbd7111416bbd1f12dd51db73cc.png#pic_center
[6f3ae76c2fee4b2db2a28b74c53e2b9f.png_pic_center]: https://img-blog.csdnimg.cn/6f3ae76c2fee4b2db2a28b74c53e2b9f.png#pic_center
[722b438e02b94bf981d765aebd975ce6.png_pic_center]: https://img-blog.csdnimg.cn/722b438e02b94bf981d765aebd975ce6.png#pic_center
[14bc6bfe743c4376bc78e5ecb583059e.png_pic_center]: https://img-blog.csdnimg.cn/14bc6bfe743c4376bc78e5ecb583059e.png#pic_center
[f132643e38174742b02359346cd5fd15.png_pic_center]: https://img-blog.csdnimg.cn/f132643e38174742b02359346cd5fd15.png#pic_center
[7fd7b51555414429b3e73cbea83121b6.jpeg_pic_center]: https://img-blog.csdnimg.cn/7fd7b51555414429b3e73cbea83121b6.jpeg#pic_center