【多线程】浅说Synchronized

news/2024/5/17 19:34:17 标签: Synchronized

一、前言

synchronized关键字用来保证在同一时刻只有一个线程可以执行被它修饰的变量或者代码块。

这一篇中，只涉及synchronized的底层实现原理，不涉及对synchronized效率以及如何优化的讨论。

二、使用方式

（1）给静态方法加锁

public class Main {
   
    public static synchronized void staticSynPrint(String str) {
        System.out.println(str);
    }

}

静态方法不属于任何一个实例，而是属于该类。不管该类被实例化多少次，静态成员只有一份。在同一时刻，不管是使用实例.staticSynPrint方式还是直接类名.staticSynPrint的方式，都会进行同步处理。

（2）给静态变量加锁

同（1），他们都是该类的静态成员。

（3）synchronized(xxx.class)

public class Main {

    public void classSynPrint(String str) {
        synchronized (Main.class) {
            System.out.println(str);
        }
    }

}

给当前类加锁（注意是当前类，不是实例对象），会作用于该类的所有实例对象，多个线程访问Main类中的所有同步方法，都需要先进行同步处理。

（4）synchronized(this)

public class Main {

    public void thisSynPrint(String str) {
        synchronized (this) {
            System.out.println(str);
        }
    }

}

this代表实例对象，因此现在锁住的是当前实例对象，因此多个线程访问不同实例的同步方法不需要进行同步。

（5）给实例方法加锁

public class Main {

    public synchronized void synPrint(String str) {
        System.out.println(str);
    }

}

不同线程访问同一个实例底下的该方法，才会需要进行同步。

三、实际使用方式之一：单例模式中的双重检验锁

更多单例模式的种类可以参考我的另外一篇博文【设计模式】单例模式

public class SingletonDCL {
    private volatile static SingletonDCL instance;

    private SingletonDCL() {
    }

    public static SingletonDCL getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }

}

有几个疑问：

（1）这里为什么要检验两次null?

最初的想法，是直接利用synchronized将整个getInstance方法锁起来，但这样效率太低，考虑到实际代码更为复杂，我们应当缩小锁的范围。

在单例模式下，要的就是一个单例，new SingletonDCL()只能被执行一次。因此，现在初步考虑成以下的这种方式：

    public static SingletonDCL getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                    //一些耗时的操作
                    instance = new SingletonDCL();
            }
        }
        return instance;
    }

但这样，存在一个问题。线程1判断instance为null，然后拿到锁，执行到了耗时的操作，阻塞了一会儿，还没有对instance进行实例化，instance还是为null。线程2判断instance为null，尝试去获取锁。线程1实例化instance之后，释放了锁。而线程2获取锁之后，同样进行了实例化操作。线程1和线程2拿到了两个不同的对象，违背了单例的原则。

因此，在获取锁之后，又进行了一次null检验。

（2）为什么使用volatile 修饰单例变量？

关于volatie和synchronized的区别，可以先参考我的另外一篇文章【JAVA】volatile和synchronized的区别

这段代码，instance = new SingletonDCL()，在虚拟机层面，其实分为了3个指令：

  1. 为instance分配内存空间，相当于堆中开辟出来一段空间
  2. 实例化instance，相当于在上一步开辟出来的空间上，放置实例化好的SingletonDCL对象
  3. 将instance变量引用指向第一步开辟出来的空间的首地址

但由于虚拟机做出的某些优化，可能会导致指令重排序，由1->2->3变成1->3->2。这种重新排序在单线程下不会有任何问题，但出于多线程的情况下，可能会出现以下的问题：

线程1获取锁之后，执行到了instance = new SingletonDCL()阶段，此时，刚好由于虚拟机进行了指令重排序，先进行了第1步开辟内存空间，然后执行了第3步，instance指向空间首地址，第2步还没来得及执行，此时恰好有线程2执行getInstance方法，最外层判断instance不为null（instance已经指向了某一段地址，因此不为null），直接返回了单例对象，接着线程2在获取单例对象属性的时候，出现了空指针错误！

因此使用volatile 修饰单例变量，可以避免由于虚拟机的指令重排序机制可能导致的空指针异常。

四、实现原理

这里可以分两种情况讨论：

（1）同步语句块

public class Main {

    public static final Object object = new Object();

    public void print() {
        synchronized (object) {
            System.out.println("123");
        }
    }

}

使用java Main.java，之后使用javap -c Main.class（-c代表反汇编）得到：

public class com.yang.testSyn.Main {
  public static final java.lang.Object object;

  public com.yang.testSyn.Main();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void print();
    Code:
       0: getstatic     #2                  // Field object:Ljava/lang/Object;
       3: dup
       4: astore_1
       5: monitorenter
       6: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: ldc           #4                  // String 123
      11: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      14: aload_1
      15: monitorexit
      16: goto          24
      19: astore_2
      20: aload_1
      21: monitorexit
      22: aload_2
      23: athrow
      24: return
    Exception table:
       from    to  target type
           6    16    19   any
          19    22    19   any

  static {};
    Code:
       0: new           #6                  // class java/lang/Object
       3: dup
       4: invokespecial #1                  // Method java/lang/Object."<init>":()V
       7: putstatic     #2                  // Field object:Ljava/lang/Object;
      10: return
}

其中print方法中的第5行、15行出现了monitorenter和monitorexit，而这两行其中的字节码代表的正是同步语句块里的内容。

当线程执行到monitorenter时，代表即将进入到同步语句块中，线程首先需要去获得Object的对象锁，而对象锁处于每个java对象的对象头中，对象头中会有一个锁的计数器，当线程查询对象头中计数器，发现内容为0时，则代表该对象没有被任何线程所占有，此时该线程可以占有此对象，计数器于是加1。

线程占有该对象后，也就是拿到该对象的锁，可以执行同步语句块里面的方法。此时，如果有其他线程进来，查询对象头发现计数器不为0，于是进入该对象的锁等待队列中，一直阻塞到计数器为0时，方可继续执行。

第一个线程执行到enterexit后，释放了Object的对象锁，此时第二个线程可以继续执行。

这边依然有几个问题：

[1]为什么有一个monitorenter指令，却有两个monitorexit指令？

因为编译器必须保证，无论同步代码块中的代码以何种方式结束（正常 return 或者异常退出），代码中每次调用 monitorenter 必须执行对应的 monitorexit 指令。为了保证这一点，编译器会自动生成一个异常处理器，这个异常处理器的目的就是为了同步代码块抛出异常时能执行 monitorexit。这也是字节码中，只有一个 monitorenter 却有两个 monitorexit 的原因。

当然这一点，也可以从Exception table(异常表)中看出来，字节码中第6(from)到16(to)的偏移量中如果出现任何类型(type)的异常，都会跳转到第19(target)行。

（2）同步方法

public class Main {

    public synchronized void print(String str) {
        System.out.println(str);
    }

}

使用javap -v Main.class查看

-v 选项可以显示更加详细的内容，比如版本号、类访问权限、常量池相关的信息，是一个非常有用的参数。

public class com.yang.testSyn.Main
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#14         // java/lang/Object."<init>":()V
   #2 = Fieldref           #15.#16        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Methodref          #17.#18        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #4 = Class              #19            // com/yang/testSyn/Main
   #5 = Class              #20            // java/lang/Object
   #6 = Utf8               <init>
   #7 = Utf8               ()V
   #8 = Utf8               Code
   #9 = Utf8               LineNumberTable
  #10 = Utf8               print
  #11 = Utf8               (Ljava/lang/String;)V
  #12 = Utf8               SourceFile
  #13 = Utf8               Main.java
  #14 = NameAndType        #6:#7          // "<init>":()V
  #15 = Class              #21            // java/lang/System
  #16 = NameAndType        #22:#23        // out:Ljava/io/PrintStream;
  #17 = Class              #24            // java/io/PrintStream
  #18 = NameAndType        #25:#11        // println:(Ljava/lang/String;)V
  #19 = Utf8               com/yang/testSyn/Main
  #20 = Utf8               java/lang/Object
  #21 = Utf8               java/lang/System
  #22 = Utf8               out
  #23 = Utf8               Ljava/io/PrintStream;
  #24 = Utf8               java/io/PrintStream
  #25 = Utf8               println
{
  public com.yang.testSyn.Main();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0

  public synchronized void print(java.lang.String);
    descriptor: (Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=2, args_size=2
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: aload_1
         4: invokevirtual #3                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         7: return
      LineNumberTable:
        line 32: 0
        line 33: 7
}

只看最后两个方法，第一个方法是编译后自动生成的默认构造方法，第二个方法则是我们的同步方法，可以看到同步方法比默认的构造方法多了一个ACC_SYNCHRONIZED的标志位。

与同步语句块不同，虚拟机不会在字节码层面实现锁同步，而是会先观察该方法是否含有ACC_SYNCHRONIZED标志。如果含有，则线程会首先尝试获取锁。如果是实例方法，则会尝试获取实例锁；如果是静态方法(类方法)，则会尝试获取类锁。最后不管方法执行是否出现异常，都会释放锁。


http://www.niftyadmin.cn/n/1705256.html

相关文章

java传参省略号的含义

java传参省略号的含义

这是java可变参数的写法&#xff0c;下面详细说明&#xff1a; Java1.5增加了新特性&#xff1a;可变参数&#xff1a;适用于参数个数不确定&#xff0c;类型确定的情况&#xff0c;java把可变参数当做数组处理。注意&#xff1a;可变参数必须位于最后一项。当可变参数个数多余…
阅读更多...
正式版XP SP3 硬盘版下载 含 深度Ghost Xp sp3 雨林木风Ghost xp sp3

正式版XP SP3 硬盘版下载 含 深度Ghost Xp sp3 雨林木风Ghost xp sp3

正式版的XP SP3 简体中文 已经发布。GHOST 版本也接踵而来&#xff0c;深度 还有 雨林木风 已经发布了自己的封装版本的XP SP3 喜欢的 可以去载了。具体就不 介绍了 2个版本都免安装驱动&#xff08;都集成了所有驱动&#xff09;1&#xff1a;雨林木风XP SP3&#xff08;这个…
阅读更多...
VS2008安装失败

VS2008安装失败

本文摘自&#xff1a;http://www.cnblogs.com/yank/archive/2009/03/07/1405487.html 之前在2003系统中安装了Visual Studio Team System 2008 Team Suite&#xff0c;很顺利就能完成。但是这次在XP SP2安装Professional版本时出现了如下错误&#xff1a; 在安装VS Web创作组件…
阅读更多...
【多线程】Synchronized的优化

【多线程】Synchronized的优化

对synchronized不太了解的同学&#xff0c;可以先参考我的另外一篇文章【多线程】浅说Synchronized 早期版本synchronized性能较低的原因 在早期版本中&#xff0c;synchronized是一种重量级锁&#xff0c;其底层由Monitor实现&#xff0c;而Monitor又依赖于操作系统的Mutex …
阅读更多...
SYSTEM_INFO

SYSTEM_INFO

SYSTEM_INFOSYSTEM_INFO&#xff0c;Win32 API函数GetSystemInfo所使用的结构体。说明&#xff1a;SYSTEM_INFO结构体包含了当前计算机的信息。这个信息包括计算机的体系结构、中央处理器的类型、系统中中央处理器的数量、页面的大小以及其他信息。结构原型&#xff1a; typede…
阅读更多...
【JVM】说说java中的堆区

【JVM】说说java中的堆区

堆&#xff08;Heap&#xff09;是被虚拟机所管理的最大的一块内存区域&#xff0c;在堆中&#xff0c;会有以下一些对象&#xff1a; 朝生夕死的小对象&#xff0c;蜉蝣一般大对象&#xff0c;例如长数组&#xff0c;需要大量连续的内存空间长周期对象&#xff0c;存活很久&a…
阅读更多...
驾驭系统 做一个Windows XP的“***”(图)5

驾驭系统 做一个Windows XP的“***”(图)5

先睹Vista 先睹Vista只是一个开始&#xff0c;安全性和性能的提升才是下一代Windows的真正亮点。未来10年内&#xff0c;Vista将会是最安全、最快和最可靠的一个Windows版本。在经过4年的开发期后&#xff0c;它会于2006年晚些时候发布&#xff0c;Windows XP的这个后继者将会提…
阅读更多...
GetSystemInfo

GetSystemInfo

GetSystemInfo GetSystemInfo&#xff0c;Win32 API 函数。 　　函数说明&#xff1a; 　　GetSystemInfo返回关于当前系统的信息。 　　函数原型&#xff1a; 　　VOID GetSystemInfo 　　( 　　LPSYSTEM_INFO lpSystemInfo 　　); 　　参数表&#xff1a; 　　lpSystemInfo …
阅读更多...
最新文章

Copyright @ 2022~2023