synchronized的个人理解

一时失言乱红尘 2022-12-07 11:57 204阅读 0赞

## 一 概述 ##

在Java中最基本的互斥同步手段就是synchronized关键字，这是一种块结构（Block Structured）的同步语法。synchronized关键字在经过Javac编译后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令。这两个指令都需要一个类型为reference的参数来指明要锁定和解锁的对象。如果Java源码中的synchronized明确指定了对象参数，那就以这个对象的引用作为类型为reference的参数。如果没有明确指定，那就根据synchronized修饰的方法类型（如实例方法或类方法）来决定是取代码所在的对象实例还是取类型对应的Class对象来作为线程要持有的锁。

根据《Java虚拟机规范》的要求，在执行monitorenter指令时，首先要尝试获取对象的锁。如果这个对象没有被锁定，或者当前线程已经持有了某个对象的锁，就把锁的计数器的值增加一，而在执行moniterexit指令时会将锁计数器的值减一。一旦计数器的值为零，锁随即被释放。如果获取对象锁失败，那当前线程就应当被阻塞等待，直到请求锁定的对象被持有它的线程释放为止。

## 二 synchronized有关的重要推论 ##

1. 被synchronized修饰的同步块对同一条线程来说是可重入的。这就意味着同一线程反复进入同步块也不会出现自己把自己锁死的状态。从互斥锁的设计来说，当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次请求自己持有的对象锁的临界资源时，这种情况就属于重入，是被允许的操作。

//synchronized的重入
    synchronized(this) {
        System.out.println("Hello");
        synchronized(this){
            System.out.println("world");
        }
    }

2. 被synchronized修饰的同步块在持有锁的线程持有执行完毕并释放锁之前，会无条件地阻塞后面其他线程的进入。这意味着无法像处理某些数据库中的锁那样，强制已获取锁的线程释放锁；也无法强制正在等待锁的线程中断等待或超时退出。

从执行成本的角度看，持有锁是一个重量级的操作。在主流的java虚拟机实现中，Java的线程是映射到操作系统的原生内核线程上的，如果要阻塞或唤醒一条线程，则需要操作系统来帮助完成，这就不可避免地陷入从操作系统的用户态到内核态的转换中，进行这种状态转换需要消耗很多的处理器的时间。尤其是对于代码特别简单的同步块（如被synchronized修饰的getter()或者setter()方法），状态转换消耗的时间甚至会比用户代码本身执行的时间还要长。因此才说sychronized是Java语言中的重量级的操作，有经验的程序员都只会在确实必要的情况下才使用这种操作。而虚拟机本身会进行一些优化，如通知操作系统阻塞线程之前加入一段自旋等待过程，以避免频繁地切入核心态之中。

## 三 synchronized相关的原子性，可见性和有序性 ##

**原子性（Atomicity）：**

Java内存模型提供了lock和unlock操作来满足大范围的原子性，虚拟机未把lock和unlock操作直接开放给用户使用，但是却提供了更高层次的字节码指令monitorenter和moniterexit来隐式地使用两个操作。这两个字节码指令反映到Java代码中就是同步块即synchronized关键字，因此在synchronized块之间的操作也具有原子性。

**可见性（Visibility）:**

synchronized关键字修饰的同步代码块的可见性是由规则"**对一个变量执行unlock操作之前，必须先把此变量同步回主存中（执行store，write操作）**"所获得。

**有序性（Ordering）：**

synchronized关键字是由规则“一个变量在同一个时刻只允许一条线程对其进行lock操作”所获得，这个规则决定了持有同一个锁的两个同步块只能串行地进入。

## 四 synchronized获取对象锁和类锁 ##

**synchronized获取对象锁的两种用法：**

public class SyncBlockAndMethod {
    
        //方式一之方法一
        public void syncsTaskThis() {
            //同步代码块
            synchronized (this) {
                System.out.println("Hello");
                synchronized (this){ //可重入锁
                    System.out.println("World");
                }
            }
        }
    
        //方式一之方法二
        SyncBlockAndMethod sbam = new SyncBlockAndMethod();
        public void syncsTaskObject() {
            //同步代码块
            synchronized (sbam) {
                System.out.println("Hello");
                synchronized (sbam){ //可重入锁
                    System.out.println("World");
                }
            }
        }
    
        //方式二之同步非静态方法，锁为当前对象的实例对象
        public synchronized void syncTask() {
            System.out.println("Hello Again");
        }

**synchronized获取类锁的两种方法：**

public class SyncThread implements Runnable {
    
        private void syncClassBlock1() {
            //synchronized(类的Class对象)，每个类都只有一个Class对象，类锁就是获取某个类对象的Class对象。
            synchronized (SyncThread.class) {
                try {
                  //logic
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
       
        //synchronized 修饰静态方法
        private synchronized static void syncClassMethod1() {
         
            try {
               //logic
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

## 五 synchronized对象锁和类锁的总结 ##

1.  有线程访问对象的同步代码块时，另外的线程可以访问该对象的非同步代码块。
2.  若锁住的是同一个对象，一个线程在访问对象的同步代码块时，另一个访问对象的同步代码块的线程会被阻塞。
3.  若锁住的是同一个对象，一个线程在访问对象的同步方法时，另一个访问同步方法的线程会被阻塞。
4.  若锁住的是同一个对象，一个线程在访问对象的同步代码块时，另一个访问对象同步方法的线程会被阻塞，反之亦然。
5.  同一个类的不同对象的对象锁互不影响。
6.  类锁由于也是一种特殊的对象锁，因此表现和上述1，2，3，4一致，而由于一个类只有一把对象锁，所以同一个类的不同对象使用类锁将会是同步的。
7.  类锁和对象锁互不影响。

**注：**互斥锁是在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程的协调机制，这样在同一时间允许一个线程对同步的代码块进行访问，互斥性也称为操作的原子性。

偏向锁：当同一时刻只有一个线程访问被锁定的某个资源的时候，synchronized使用的锁为偏向锁。

轻量级锁：当同一时刻多个线程访问被锁定的某个资源的时候，会存在某些线程处于忙等待状态，synchronized变成了轻量级锁。

重量级锁：在轻量级锁的基础上，某些线程被完全阻塞的情况下，轻量级锁会变成重量级锁。

总结：三种锁机制的切换是根据竞争激烈程度进行的， 在几乎无竞争的条件下， 会使用偏向锁， 在轻度竞争的条件下， 会由偏向锁升级为轻量级锁， 在重度竞争的情况下， 会升级到重量级锁。