Java并发编程- Synchronized原理

旧城等待， 2021-11-29 16:46 316阅读 0赞

**Java并发编程- Synchronized原理**

**在jdk.1.6之前是重量级锁，jdk1.6之后对synchronzied的关键字的优化之后，引入了偏向锁，轻量级锁。**

**1.先来看****synchronzied使用的****基础：**

static  A a = new A();
    
    //普通同步方法
    public synchronized void test(){
        System.out.println("锁的是当前对象实例");
    }
    //静态同步方法
    public static synchronized void test1(){
        System.out.println("锁的是当前类的Class对象");
    }
    //同步方法块
    public   void test2(){
        synchronized (a){
            System.out.println("锁的是括号里配置的对象");
        }
    }

**2. synchronzied使用的锁在哪呢？存在对象头里，**

**整个对象存储情况,运行代码查看结果分析:**

public class A {
    
        private boolean b;
    }

public class Test {
        static  A a = new A();
        public static void main(String[] args) {
            System.out.println(VM.current().details());
            System.out.println(ClassLayout.parseInstance(a).toPrintable());
        }
    }

运行结果分析：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmbG92ZWphdmE_size_16_color_FFFFFF_t_70][]

分析：对象一共16B，其中12B是对象头，1B是对象实例数据，3B是字节对齐

**对象的长度**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>长度</td> 
   <td>内容</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>12B</td> 
   <td>对象头</td> 
   <td>存储信息，hashcode，年代信息等。</td> 
  </tr> 
  <tr> 
   <td>1B</td> 
   <td>对象实例数据</td> 
   <td>存储对象的实例数据</td> 
  </tr> 
  <tr> 
   <td>3B</td> 
   <td>字节对齐</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

对象头12B存储哪些内容呢？64位的VM

可以从openjdk.java.net/groups/hotspot/docs/HotSpotGlossary.html 官网上看到,存储的内容是mark word 和klass word

**java对象头的长度**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>长度</td> 
   <td>内容</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>8B</td> 
   <td>mark word</td> 
   <td>存储着锁的信息，hashcode，gc信息等等</td> 
  </tr> 
  <tr> 
   <td>4B</td> 
   <td>klass word&nbsp;</td> 
   <td>指向对象的元数据</td> 
  </tr> 
 </tbody> 
</table>

**java对象头的结构**

**无锁的对象头如下：**

第一个字节的前8位存储着，分代年龄4个bit，锁的标识2个bit，是否偏向1个bit，和没有使用的1个bit。

其他的7个字节存储着hashcode信息。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>锁状态</td> 
   <td>56bit</td> 
   <td>4bit</td> 
   <td>1bit是否偏向锁</td> 
   <td>2bit锁的标识</td> 
  </tr> 
  <tr> 
   <td>无锁</td> 
   <td>对象hashcode</td> 
   <td>对象分代年龄</td> 
   <td>0</td> 
   <td>01</td> 
  </tr> 
 </tbody> 
</table>

![20190724163246593.png][]

我们知道对象的状态一共五种状态：无锁，偏向锁，轻量级锁，重量级锁，gc标记的锁。

**3. 偏向锁**

**概念：同一个线程多次获取同一把锁。（只有一个线程调用同步块）**

代码：

public class Test {
        static  A a ;
        public static void main(String[] args) {
            Thread.sleep(5000);//jvm 延时启动偏向锁，是默认4s之后开启，可以设置关闭延时。因为启动的时候就使用偏向锁，比较消耗性能，升级锁比较费时间。
    
            System.out.println(VM.current().details());
            a = new A();
            System.out.println(ClassLayout.parseInstance(a).toPrintable());
            syn();
                System.out.println(ClassLayout.parseInstance(a).toPrintable());
        }
        public static  synchronized  void syn(){
            System.out.println("演示偏向锁-----------");
        }
    }

输出结果：

演示偏向锁-----------  
  
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE  
      0     4           (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)  
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)  
      8     4           (object header)                           80 22 01 f8 (10000000 00100010 00000001 11111000) (-134143360)  
     12     1   boolean A.b                                       false  
     13     3           (loss due to the next object alignment)  
Instance size: 16 bytes  
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

分析结果：程序只有一个线程main调用syn方法，因此是偏向锁，也可以使用-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0禁用延时。-XX:+TraceClassLoading （跟踪加载）

**4. 轻量级锁：线程交替运行，无竞争。**

public class Test {
        static  A a ;
        public static void main(String[] args) throws InterruptedException {
          //  System.out.println(VM.current().details());
            a = new A();
            System.out.println(ClassLayout.parseInstance(a).toPrintable());
            syn();
            System.out.println(ClassLayout.parseInstance(a).toPrintable());
    
        }
        public static    void syn(){
            synchronized (a){
                out.println("lock ing");
                System.out.println(ClassLayout.parseInstance(a).toPrintable());
            }
        }
    }

运行结果：  
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE  
      0     4           (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)  
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)  
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)  
     12     1   boolean A.b                                       false  
     13     3           (loss due to the next object alignment)  
Instance size: 16 bytes  
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

lock ing  
com.luban.wf.A object internals:  
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE  
      0     4           (object header)                           a0 f5 e7 02 (10100000 11110101 11100111 00000010) (48756128)  
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)  
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)  
     12     1   boolean A.b                                       false  
     13     3           (loss due to the next object alignment)  
Instance size: 16 bytes  
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

com.luban.wf.A object internals:  
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE  
      0     4           (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)  
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)  
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)  
     12     1   boolean A.b                                       false  
     13     3           (loss due to the next object alignment)  
Instance size: 16 bytes  
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

Process finished with exit code 0

分析结果：lock ing 输出的10100000 轻量级锁。

**5. 重量级锁：**

public class Test2 {
        static  A a ;
    
        public static void main(String[] args) throws InterruptedException {
            a = new A();
            System.out.println("before lock");
            out.println(ClassLayout.parseInstance(a).toPrintable());//轻量锁
    
            Thread t1 = new Thread(new Runnable() {
                public void run() {
                    synchronized (a){
    
                        synchronized (a){
                            System.out.println("before wait");
                            out.println(ClassLayout.parseInstance(a).toPrintable());//轻量锁
                            try {
                                a.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            System.out.println("after wait");
                            out.println(ClassLayout.parseInstance(a).toPrintable());//重量级锁
                        }
                    }
                }
            });
    
            t1.start();
    
            Thread.sleep(5000);
            synchronized (a){
                a.notifyAll();//唤醒线程t1
            }
    
        }
    
    
    }

运行结果：

before lock  
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE  
      0     4           (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)  
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)  
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)  
     12     1   boolean A.b                                       false  
     13     3           (loss due to the next object alignment)  
Instance size: 16 bytes  
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

before wait  
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE  
      0     4           (object header)                           a0 f2 7b 1c (10100000 11110010 01111011 00011100) (477885088)  
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)  
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)  
     12     1   boolean A.b                                       false  
     13     3           (loss due to the next object alignment)  
Instance size: 16 bytes  
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

after wait  
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE  
      0     4           (object header)                           da d7 e2 19 (11011010 11010111 11100010 00011001) (434296794)  
      4     4           (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)  
      8     4           (object header)                           43 c1 00 f8 (01000011 11000001 00000000 11111000) (-134168253)  
     12     1   boolean A.b                                       false  
     13     3           (loss due to the next object alignment)  
Instance size: 16 bytes  
Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

Process finished with exit code 0

运行结果分析：after wait  的为11011010 重量级锁

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmbG92ZWphdmE_size_16_color_FFFFFF_t_70 1][]

**6. 偏向锁的批量撤销:**

**7. 轻量级锁的膨胀过程：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmbG92ZWphdmE_size_16_color_FFFFFF_t_70 2][]

**8.总结：**

锁有哪几种：公平锁和非公平锁（线程获取锁的机会不是均匀的）

工作当中怎样选择锁：

Synchronized 是有sun公司实现的 jvm内部调用操作系统实现的

1.是个非公平锁，

2.使用简单，

3.经过优化了，偏向锁，轻量级锁，重量级锁

lock jdk实现的：

1.是个公平锁，

2.需要手动释放锁

3.如果要实现高级功能，可以使用

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmbG92ZWphdmE_size_16_color_FFFFFF_t_70]: /images/20211129/6bc82b33e55c4128b5d0edf8edf89ae8.png
[20190724163246593.png]: /images/20211129/26e3627a922e4cf89eb3eded3f5ba4cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmbG92ZWphdmE_size_16_color_FFFFFF_t_70 1]: /images/20211129/5f968a535ef7441a82b33bd466703655.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dmbG92ZWphdmE_size_16_color_FFFFFF_t_70 2]: /images/20211129/77afd45b557e4b128a5b9e2a5089ce32.png