synchronized 我理解的到底有多深

我就是我 2022-11-13 15:28 183阅读 0赞

## synchronize 作用 ##

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。人话解释就是解决多线程并发访问冲突问题。保证原子性，可见性，有序性（单线程执行依然会有指令重排序，但是由于是单线程执行，所以还是能保证有序性）

## synchronized锁的谁 ##

首先需要说明的是Java 中任何一个对象都可以作为synchronized 锁。具体锁分如下几种情况

1.  普通同步方法锁是当前实例对象
2.  静态同步方法，锁是当前类的class对象
3.  同步方法块，锁是括号里面的对象

public class SynchronizedTest { 
    
        public static final Object lock = new Object();
    
        // 锁的是SynchronizedTest.class对象
        public static synchronized void sync1() { 
    
        }
    
        public static void sync2() { 
            // 锁的是SynchronizedTest.class对象
            synchronized (SynchronizedTest.class) { 
    
            }
        }
    
        // 锁的是当前实例this
        public synchronized void sync3() { 
    
        }
    
        public void sync4() { 
            // 锁的是当前实例this
            synchronized (this) { 
    
            }
        }
    
        public void sync5() { 
            // 锁的是指定对象lock
            synchronized (lock) { 
    
            }
        }
    }

如果想要验证也很简单比如这样

public class SynchronizedTest { 
    
    
        public static void main(String[] args) { 
            SynchronizedTest synchronizedTest = new SynchronizedTest();
            ExecutorService threadPool = Executors.newFixedThreadPool(3);
    // AtomicInteger i = new AtomicInteger();
            for (int i = 0; i < 5; i++) { 
                int finalI = i;
                threadPool.execute(() -> { 
    // SynchronizedTest synchronizedTest = new SynchronizedTest();
                    synchronizedTest.testSynchronized(finalI);
                });
            }
    
            threadPool.shutdown();
        }
    
    
        public synchronized void testSynchronized(int i) { 
            if (i == 0) { 
                try { 
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            System.out.println("方法执行完成时间：" + System.currentTimeMillis());
        }
    
    
    
    }

这里如果我们使用同一个SynchronizedTest 对象去运行就会发现其他方法运行需要等待线程0休眠完释放锁后才能继续运行，如果使用不同的SynchronizedTest 去运行会发现前四个线程可以很快运行，不用等待线程0的锁释放，因为使用的不是同一把把锁。

## synchronized是公平锁吗 ##

synchronized实际上是非公平的，新来的线程有可能立即获得监视器，而在等待区中等候已久的线程可能再次等待，不过这种抢占的方式可以预防饥饿。

## 实现原理 ##

这里我们使用idea获取上面的代码看看字节码文件是啥，做一个简单的分析

> 如何获取字节码文件[参考这里][Link 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]  
这里我们看到 synchronized修饰的方法并没有monitorenter指令和monitorexit指令，取得代之的是ACC\_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法(在Class文件的方法表中将该方法的access\_flags字段中的synchronized标志位置1，表示该方法是同步方法并使用调用该方法的对象或该方法所属的Class在JVM的内部对象表示Klass做为锁对象)，JVM通过ACC\_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。这才是synchronized锁在同步代码块和同步方法上实现的基本原理

如果 synchronized 作用于代码块呢？

public  void doSynchronizedMethod(){ 
            synchronized (SynchronizedTest.class){ 
                System.out.println("test Synchronized" );
            }
        }

我们获取这一个方法的字节码看看  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 1]  
这里可以看到修饰同步代码块的时候才是使用monitorenter和monitorexit两个指令实现同步

而monitorenter只用的使用原理是什么呢。我们使用的每个对象，都会与一个monitor 相关联。当且仅当它有一个所有者时，monitor才会被锁定。执行到monitorenter指令的线程，会尝试去获得对应的monitor  
如下例子：每个对象维护着一个记录着被锁次数的计数器, 对象未被锁定时，该计数器为0。线程进入monitor（执行monitorenter指令）时，会把计数器设置为1.  
当同一个线程再次获得该对象的锁的时候，计数器再次自增(可重入).  
当其他线程想获得该monitor的时候，就会阻塞，直到计数器为0才能成功。

流程大概如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70_pic_center]  
当遇到 ACC\_SYNCHRONIZED流程也是如上

[官网给出的说明][Link 2]

总结：

*  synchronized 底层实现不都是基于monitorenter和monitorexit实现的
 *  同步代码块才是使用monitorenter和monitorexit实现的
 *  而同步方法是基于ACC\_SYNCHRONIZED标识来实现的
 *  synchronized是可重入锁
 *  synchronized是非公平锁
 *  synchronized可以同时保证原子性、可见性、有序性

## 锁的优化 ##

jdk1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。 锁主要存在四中状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

这里对这些优化锁做一些大致说明

*  锁消除：在有些情况下，JVM检测到不可能存在共享数据竞争，这是JVM会对这些同步锁进行锁消除。锁消除的依据是逃逸分析的数据支持
 *  偏向锁：同步代码一直被一个线程访问，那么这个线程会自动获取锁，降低获取锁的代价
 *  轻量级锁：当锁是偏向锁时，被另一个线程所访问，偏向锁会升级为轻量级锁，这个线程会通过自旋的方式尝试获取锁，不会阻塞，提高性能
 *  重量级锁：当锁是轻量级锁时，当自旋的线程自旋了一定的次数后，还没有获取到锁，就会进入阻塞状态，该锁升级为重量级锁，重量级锁会使其他线程阻塞。重量级锁通过对象内部的监视器（monitor）实现，其中monitor的本质是依赖于底层操作系统的Mutex Lock实现，操作系统实现线程之间的切换需要从用户态到内核态的切换，切换成本非常高

[Link 1]: https://weihubeats.blog.csdn.net/article/details/115268744
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]: /images/20221022/74fa6900441e4789870885165960ff8b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 1]: /images/20221022/48378a579fb245b1a3b11a4dc91f9104.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20210327211923457.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0,size_16,color_FFFFFF,t_70#pic_center
[Link 2]: https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html