synchronized与异常表

最新推荐文章于 2023-09-09 10:27:35 发布

hhkun0120

最新推荐文章于 2023-09-09 10:27:35 发布

阅读量169

点赞数

分类专栏： spring 文章标签： java 多线程

本文链接：https://blog.csdn.net/hhkun0120/article/details/118739031

版权

spring 专栏收录该内容

16 篇文章 2 订阅

订阅专栏

synchronized简介

在Java的并发编程中，保证线程同步最为程序员所熟悉的就是synchronized关键字，synchronized关键字最为方便的地方是他不需要显示的管理锁的释放，极大减少了编程出错的概率。

在Java1.5及以前的版本中，synchronized并不是同步最好的选择，由于并发时频繁的阻塞和唤醒线程，会浪费许多资源在线程状态的切换上，导致了synchronized的并发效率在某些情况下不如ReentrantLock。在Java1.6的版本中，对synchronized进行了许多优化，极大的提高了synchronized的性能。只要synchronized能满足使用环境，建议使用synchronized而不使用ReentrantLock。

synchronized的三种使用方式

修饰实例方法，为当前实例加锁，进入同步方法前要获得当前实例的锁。
修饰静态方法，为当前类对象加锁，进入同步方法前要获得当前类对象的锁。

修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁。

package com.lock.keywords;

import java.util.concurrent.TimeUnit;

/**
 * @description: 通过编译底层class文件分析synchronized与CAS的原理以及使用方法
 * OracleJDK 1.6之后对sync进行了优化
 * @author: H.K
 * @create: 2021-07-14 14:46
 */
public class SyncTester {
    /**
     * 对静态方法的修饰可以和实例方法的修饰同时使用，不会阻塞，因为一个是修饰的Class类，一个是修饰的实例对象
     */
    public static synchronized void StaticSyncTest() {

        for (int i = 0; i < 3; i++) {
            System.out.println("StaticSyncTest");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    public synchronized void NonStaticSyncTest() {

        for (int i = 0; i < 3; i++) {
            System.out.println("NonStaticSyncTest");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws Exception {
        final SyncTester synchronizedTest = new SyncTester();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedTest.StaticSyncTest();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronizedTest.NonStaticSyncTest();
            }
        }).start();
    }
}

com.lock.keywords.SyncTester
StaticSyncTest
NonStaticSyncTest
NonStaticSyncTest
StaticSyncTest
StaticSyncTest
NonStaticSyncTest

以上打印信息表示修饰静态方法和实例方法在sync修饰的情况下，一个锁的是类，
另外一个锁定的是对象

synchronized的底层原理

package com.lock.keywords;

/**
 * @description: 看看编译出来class文件
 * @author: H.K
 * @create: 2021-07-14 14:53
 */
public class SyncByteCode {
    public static SyncByteCode instance;
    public static void main(String[] args) {

        if (null == instance) {
            synchronized (SyncByteCode.class) {
                if (null == instance) {
                    instance = new SyncByteCode();
                }else{

                }
            }
        }else {

        }
    }
}

javap -verbose /xx/src/main/java/com/lock/keywords/SyncByteCode.class 

Last modified 2021-7-14; size 496 bytes
  MD5 checksum a520192ad8adcaef6deb1579e8d65037
  Compiled from "SyncByteCode.java"
public class com.lock.keywords.SyncByteCode
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#19         // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#20         // com/lock/keywords/SyncByteCode.instance:Lcom/lock/keywords/SyncByteCode;
   #3 = Class              #21            // com/lock/keywords/SyncByteCode
   #4 = Methodref          #3.#19         // com/lock/keywords/SyncByteCode."<init>":()V
   #5 = Class              #22            // java/lang/Object
   #6 = Utf8               instance
   #7 = Utf8               Lcom/lock/keywords/SyncByteCode;
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               main
  #13 = Utf8               ([Ljava/lang/String;)V
  #14 = Utf8               StackMapTable
  #15 = Class              #22            // java/lang/Object
  #16 = Class              #23            // java/lang/Throwable
  #17 = Utf8               SourceFile
  #18 = Utf8               SyncByteCode.java
  #19 = NameAndType        #8:#9          // "<init>":()V
  #20 = NameAndType        #6:#7          // instance:Lcom/lock/keywords/SyncByteCode;
  #21 = Utf8               com/lock/keywords/SyncByteCode
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/Throwable
{
  public static com.lock.keywords.SyncByteCode instance;
    descriptor: Lcom/lock/keywords/SyncByteCode;
    flags: ACC_PUBLIC, ACC_STATIC

  public com.lock.keywords.SyncByteCode();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0                           // 从局部变量表下标为0的位置，加载锁到栈
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 8: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=1
         0: aconst_null
         1: getstatic     #2                  // Field instance:Lcom/lock/keywords/SyncByteCode;
         4: if_acmpne     39
         7: ldc           #3                  // class com/lock/keywords/SyncByteCode
         9: dup                               // 在栈顶复制该对象 
        10: astore_1                          // 将栈顶对象（锁对象）保存到局部变量表1的位置
        11: monitorenter                      // 获取锁
        12: aconst_null                       // 
        13: getstatic     #2                  // Field instance:Lcom/lock/keywords/SyncByteCode;
        16: if_acmpne     29
        19: new           #3                  // class com/lock/keywords/SyncByteCode
        22: dup
        23: invokespecial #4                  // Method "<init>":()V
        26: putstatic     #2                  // Field instance:Lcom/lock/keywords/SyncByteCode;
        29: aload_1                           // 将锁对象取到栈顶
        30: monitorexit                       // 释放锁 
        31: goto          39                  // 跳到return语句，代码执行完返回
        34: astore_2                          // 执行语句34表示，上面代码执行异常，将异常对象保存到局部变量位置2处
        35: aload_1                           // 同29
        36: monitorexit                        // 同30
        37: aload_2                            // 将位置2处的异常对象拉到栈顶
        38: athrow                            // 抛出异常
        39: return                            // 代码执行结束。返回。
      Exception table:
         from    to  target type
            12    31    34   any
            34    37    34   any
      LineNumberTable:
        line 12: 0
        line 13: 7
        line 14: 12
        line 15: 19
        line 19: 29
        line 23: 39
      StackMapTable: number_of_entries = 3
        frame_type = 252 /* append */
          offset_delta = 29
          locals = [ class java/lang/Object ]
        frame_type = 68 /* same_locals_1_stack_item */
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4
}
SourceFile: "SyncByteCode.java"

另外我们分析为什么出现两个monitorexit，而只有一个monitorenter。看异常表

异常表的每一条记录结构如下：它包含4个字段，这些字段的含义为：如果当字节码在第start_pc行到第end_pc行之间（不包含end_pc行）出现了类型为catch_type或者其子类的异常（catch_type为指向一个CONSTANT_Class_info型常量的索引），则转到第handler_pc行继续处理。当catch_type的值为0时，代表任意异常情况都需要转向到handler_pc处进行处理。

exception_table {
u2 start_pc;
u2 end_pc;
u2 handler_pc;
u2 catch_type;
}

Exception table:
         from    to  target type
            12    31    34   any
            34    37    34   any

从字节码第12到31行出现异常，则转到第34行（把异常信息存储到位置2处）运行，34行到37行中有monitorexit（第36行）会释放锁。这个就是为了让锁在异常情况下也会被释放的一种保护机制。

hhkun0120

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
synchronized与异常表

synchronized简介在Java的并发编程中，保证线程同步最为程序员所熟悉的就是synchronized关键字，synchronized关键字最为方便的地方是他不需要显示的管理锁的释放，极大减少了编程出错的概率。在Java1.5及以前的版本中，synchronized并不是同步最好的选择，由于并发时频繁的阻塞和唤醒线程，会浪费许多资源在线程状态的切换上，导致了synchronized的并发效率在某些情况下不如ReentrantLock。在Java1.6的版本中，对synchronized进行了
复制链接

扫一扫