精华内容
下载资源
问答
  • Java中的同步代码同步方法、同步
    万次阅读 多人点赞
    2018-08-13 01:40:01

    多线程容易出现问题的原因

    当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。即多个线程执行的不确定性引起执行结果的不稳定。

    例:

    • 多个线程账本共享,会造成操作的不完整性,会破坏数据。
    • 火车站售票,多个窗口同时售票。

    解决办法

    同步代码块

    synchronized(obj)
    {
        //需要被同步的代码块
    }

    其中,obj 称为同步监视器,也就是锁,原理是:当线程开始执行同步代码块前,必须先获得对同步代码块的锁定。并且任何时刻只能有一个线程可以获得对同步监视器的锁定,当同步代码块执行完成后,该线程会释放对该同步监视器的锁定。

    其中的锁,在非静态方法中可为this,在静态方法中为当前类本身(例如单例模式的懒汉式:Singleton.class)。

    // 单例模式 - 懒汉式
    class Singleton {
    	private Singleton() {
    	}
    
    	private static Singleton s = null;
    
    	private static Singleton getInstance() {
    		if (s == null) {
    			synchronized (Singleton.class) {
    				if (s == null) {
    					s = new Singleton();
    				}
    			}
    		}
    		return s;
    	}
    }

    同步方法

    public synchronized void testThread()
    {
        //需要被同步的代码块
    }

    对于关键字synchronized修饰的方法,不需要再指定同步监视器,这个同步方法(非static方法)无需显式地指定同步监视器,同步方法的同步监视器就是this,也就是调用该方法的对象。

    注意,synchronized可以修饰方法,修饰代码块,但是不能修饰构造器、成员变量等。

    同步锁

    class A
    {
        private final ReentrantLock lock=new ReentrantLock();
        public void method()
        {
            lock.lock();
            try{
                    //需要被同步的代码块
                }catch(Exception e){
                    e.printStackTrace();
                }finally{
                    lock.unlock();
            }
        }
    }

    这是一种功能更为强大的线程同步机制,通过显式定义同步锁对象来实现同步,这里的同步锁由Lock对象充当。使用Lock与使用同步代码块有点类似,只是使用Lock时可以显示使用Lock对象作为同步锁,而使用同步方法时系统隐式使用当前对象作为同步监视器。

    其中,为了确保能够在必要的时候释放锁,代码中使用finally来确保锁的释放,来防止死锁!

    更多相关内容
  • 主要介绍了Java同步代码和同步方法原理与应用,结合具体案例形式分析了使用java同步代码和同步方法实现买票功能的相关原理与操作技巧,需要的朋友可以参考下
  • JAVA 同步实现原理

    千次阅读 2021-03-08 09:21:19
    原标题:JAVA 同步实现原理Synchronized的基本使用Synchronized是Java中解决并发问题的一种最常用的方法,也是最简单的一种方法。Synchronized的作用主要有三个:确保线程互斥的访问同步代码保证共享变量的修改能够...

    原标题:JAVA 同步实现原理

    Synchronized的基本使用

    Synchronized是Java中解决并发问题的一种最常用的方法,也是最简单的一种方法。Synchronized的作用主要有三个:

    确保线程互斥的访问同步代码

    保证共享变量的修改能够及时可见

    有效解决重排序问题。

    从语法上讲,Synchronized总共有三种用法:

    修饰普通方法

    修饰静态方法

    修饰代码块

    接下来我就通过几个例子程序来说明一下这三种使用方式(为了便于比较,三段代码除了Synchronized的使用方式不同以外,其他基本保持一致)。

    没有同步的情况

    package com.paddx.test.concurrent;

    public class SynchronizedTest {

    public void method1(){

    System.out.println("Method 1 start");

    try {

    System.out.println("Method 1 execute");

    Thread.sleep(3000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("Method 1 end");

    }

    public void method2(){

    System.out.println("Method 2 start");

    try {

    System.out.println("Method 2 execute");

    Thread.sleep(1000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("Method 2 end");

    }

    public static void main(String[] args) {

    final SynchronizedTest test = new SynchronizedTest();

    new Thread(new Runnable() {

    @Override

    public void run() {

    test.method1();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    test.method2();

    }

    }).start();

    }

    }

    执行结果如下,线程1和线程2同时进入执行状态,线程2执行速度比线程1快,所以线程2先执行完成,这个过程中线程1和线程2是同时执行的。

    Method 1 start

    Method 1 execute

    Method 2 start

    Method 2 execute

    Method 2 end

    Method 1 end

    对普通方法同步

    package com.paddx.test.concurrent;

    public class SynchronizedTest {

    public synchronized void method1(){

    System.out.println("Method 1 start");

    try {

    System.out.println("Method 1 execute");

    Thread.sleep(3000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("Method 1 end");

    }

    public synchronized void method2(){

    System.out.println("Method 2 start");

    try {

    System.out.println("Method 2 execute");

    Thread.sleep(1000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("Method 2 end");

    }

    public static void main(String[] args) {

    final SynchronizedTest test = new SynchronizedTest();

    new Thread(new Runnable() {

    @Override

    public void run() {

    test.method1();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    test.method2();

    }

    }).start();

    }

    }

    执行结果如下,跟代码段一比较,可以很明显的看出,线程2需要等待线程1的method1执行完成才能开始执行method2方法。

    Method 1 start

    Method 1 execute

    Method 1 end

    Method 2 start

    Method 2 execute

    Method 2 end

    静态方法(类)同步

    package com.paddx.test.concurrent;

    public class SynchronizedTest {

    public static synchronized void method1(){

    System.out.println("Method 1 start");

    try {

    System.out.println("Method 1 execute");

    Thread.sleep(3000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("Method 1 end");

    }

    public static synchronized void method2(){

    System.out.println("Method 2 start");

    try {

    System.out.println("Method 2 execute");

    Thread.sleep(1000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("Method 2 end");

    }

    public static void main(String[] args) {

    final SynchronizedTest test = new SynchronizedTest();

    final SynchronizedTest test2 = new SynchronizedTest();

    new Thread(new Runnable() {

    @Override

    public void run() {

    test.method1();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    test2.method2();

    }

    }).start();

    }

    }

    执行结果如下,对静态方法的同步本质上是对类的同步(静态方法本质上是属于类的方法,而不是对象上的方法),所以即使test和test2属于不同的对象,但是它们都属于SynchronizedTest类的实例,所以也只能顺序的执行method1和method2,不能并发执行。

    Method 1 start

    Method 1 execute

    Method 1 end

    Method 2 start

    Method 2 execute

    Method 2 end

    代码块同步

    package com.paddx.test.concurrent;

    public class SynchronizedTest {

    public void method1(){

    System.out.println("Method 1 start");

    try {

    synchronized (this) {

    System.out.println("Method 1 execute");

    Thread.sleep(3000);

    }

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("Method 1 end");

    }

    public void method2(){

    System.out.println("Method 2 start");

    try {

    synchronized (this) {

    System.out.println("Method 2 execute");

    Thread.sleep(1000);

    }

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("Method 2 end");

    }

    public static void main(String[] args) {

    final SynchronizedTest test = new SynchronizedTest();

    new Thread(new Runnable() {

    @Override

    public void run() {

    test.method1();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    test.method2();

    }

    }).start();

    }

    }

    执行结果如下,虽然线程1和线程2都进入了对应的方法开始执行,但是线程2在进入同步块之前,需要等待线程1中同步块执行完成。

    Method 1 start

    Method 1 execute

    Method 2 start

    Method 1 end

    Method 2 execute

    Method 2 end

    Synchronized 原理

    先通过反编译下面的代码来看看Synchronized是如何实现对代码块进行同步的

    package com.paddx.test.concurrent;

    public class SynchronizedDemo {

    public void method() {

    synchronized (this) {

    System.out.println("Method 1 start");

    }

    }

    }

    反编译结果

    6251bf4ca09a2fb6650a644bf6e6a5c2.png

    关于这两条指令的作用,我们直接参考JVM规范中描述: ` Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows: • If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor. • If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count. • If another thread already owns the monitor associated with objectref, the thread blocks until the monitor’s entry count is zero, then tries again to gain ownership. `

    每个对象有一个监视器锁(monitor)。当monitor被占用时就会处于锁定状态,线程执行monitorenter指令时尝试获取monitor的所有权,过程如下:

    如果monitor的进入数为0,则该线程进入monitor,然后将进入数设置为1,该线程即为monitor的所有者。

    如果线程已经占有该monitor,只是重新进入,则进入monitor的进入数加1.

    如果其他线程已经占用了monitor,则该线程进入阻塞状态,直到monitor的进入数为0,再重新尝试获取monitor的所有权。

    monitorexit:  ` The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref. The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.`

    执行monitorexit的线程必须是objectref所对应的monitor的所有者。

    指令执行时,monitor的进入数减1,如果减1后进入数为0,那线程退出monitor,不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

    通过这两段描述,我们应该能很清楚的看出 Synchronized的实现原理

    Synchronized的语义底层是通过一个monitor的对象来完成,其实wait/notify等方法也依赖于monitor对象,这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法,否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

    我们再来看一下同步方法的反编译结果:

    package com.paddx.test.concurrent;

    public class SynchronizedMethod {

    public synchronized void method() {

    System.out.println("Hello World!");

    }

    }

    反编译结果

    a82ea1ba651e94b37dd06ebd5c60fb1e.png

    从反编译的结果来看,方法的同步并没有通过指令monitorenter和monitorexit来完成(理论上其实也可以通过这两条指令来实现),不过相对于普通方法,其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的:当方法调用时,调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置,如果设置了,执行线程将先获取monitor,获取成功之后才能执行方法体,方法执行完后再释放monitor。在方法执行期间,其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别,只是方法的同步是一种隐式的方式来实现,无需通过字节码来完成。

    运行结果解释

    有了对Synchronized原理的认识,再来看上面的程序就可以迎刃而解了。

    代码段2结果: 虽然method1和method2是不同的方法,但是这两个方法都进行了同步,并且是通过同一个对象去调用的,所以调用之前都需要先去竞争同一个对象上的锁(monitor),也就只能互斥的获取到锁,因此,method1和method2只能顺序的执行。

    代码段3结果: 虽然test和test2属于不同对象,但是test和test2属于同一个类的不同实例,由于method1和method2都属于静态同步方法,所以调用的时候需要获取同一个类上monitor(每个类只对应一个class对象),所以也只能顺序的执行。

    代码段4结果: 对于代码块的同步实质上需要获取Synchronized关键字后面括号中对象的monitor,由于这段代码中括号的内容都是this,而method1和method2又是通过同一的对象去调用的,所以进入同步块之前需要去竞争同一个对象上的锁,因此只能顺序执行同步块。

    总结

    Synchronized是通过对象内部的一个叫做监视器锁(monitor)来实现的。但是监视器锁本质又是依赖于底层的操作系统的Mutex Lock来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到内核态,这个成本非常高,状态之间的转换需要相对比较长的时间,这就是为什么Synchronized效率低的原因。

    因此,这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。JDK中对Synchronized做的种种优化,其核心都是为了减少这种重量级锁的使用。JDK1.6以后,为了减少获得锁和释放锁所带来的性能消耗,提高性能,引入了“偏向锁”和“轻量级锁”。无锁 --> 偏向锁 --> 轻量级 --> 重量级

    来源:winger@文哥

    awingger.com/2017/10/25/JAVA同步原理分析/返回搜狐,查看更多

    责任编辑:

    展开全文
  • Java同步关键字synchronize底层实现原理

    千次阅读 多人点赞 2019-10-20 21:20:03
    当JVM的解释器执行monitorenter时会进入到 InterpreterRuntime.cpp的 1.1 InterpreterRuntime::monitorenter // 解释器的同步代码被分解,以便方法调用和同步块共享。 JRT_ENTRY_NO_ASYNC(void, InterpreterRuntime...

    1 字节码层实现

    javap 生成的字节码中包含如下指令:

    • monitorenter
    • monitorexit

    synchronized基此实现了简单直接的锁的获取和释放。

    当JVM的解释器执行monitorenter时会进入到
    InterpreterRuntime.cpp

    1.1 InterpreterRuntime::monitorenter

    // 解释器的同步代码被分解,以便方法调用和同步块共享。
    JRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
    #ifdef ASSERT
      thread->last_frame().interpreter_frame_verify_monitor(elem);
    #endif
      if (PrintBiasedLockingStatistics) {
        Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
      }
      Handle h_obj(thread, elem->obj());
      assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
             "must be NULL or an object");
      if (UseBiasedLocking) {
        // 如果取消了偏向,请重试快速进入,以避免不必要的🔐膨胀
        ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
      } else {
        ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
      }
      assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),
             "must be NULL or an object");
    #ifdef ASSERT
      thread->last_frame().interpreter_frame_verify_monitor(elem);
    #endif
    JRT_END
    

    1.1.1 函数参数

    • JavaThread *thread
      封装 Java线程 帧状态的与机器/操作系统相关的部分的对象,这里传参代表程序中的当前线程
    • BasicObjectLock *elem

      BasicLock 类型的 _lock 对象主要用来保存 _obj 对象的对象头数据:

    1.1.2 函数体


    UseBiasedLocking 标识JVM是否开启偏向锁功能

    • 如果开启则执行fast_enter逻辑
    • 否则执行slow_enter

    2 偏向锁

    2.1 偏向锁的意义

    无多线程竞争时,尽量减少不必要的轻量级锁执行路径。

    轻量级锁的获取及释放依赖多次的CAS操作,而偏向锁只依赖一次CAS置换ThreadID

    当存在高度的锁竞争和低数据竞争时,RTM 锁最有用。
    高锁争用情况下,锁通常会膨胀,而偏向锁不适于这种情况。
    RTM 锁代码要求关闭偏向锁。

    注意:我们不能在 get_processor_features() 中关闭 UseBiasedLocking,因为它被 Thread::allocate() 使用,它在 VM_Version::initialize() 之前调用。

    if (UseRTMLocking && UseBiasedLocking) {
      if (FLAG_IS_DEFAULT(UseBiasedLocking)) {
        FLAG_SET_DEFAULT(UseBiasedLocking, false);
      } else {
        warning("Biased locking is not supported with RTM locking; ignoring UseBiasedLocking flag." );
        UseBiasedLocking = false;
      }
    }
    

    一旦出现多个线程竞争时必须撤销偏向锁,所以:

    撤销偏向锁消耗的性能必须 < 之前节省下来的CAS原子操作的性能消耗
    

    不然得不偿失!

    JDK 6中默认开启偏向锁,可以通过-XX:-UseBiasedLocking禁用偏向锁。

    • 偏向锁的入口位于synchronizer.cpp文件的ObjectSynchronizer::fast_enter函数

    2.2 偏向锁的获取

    BiasedLocking::revoke_and_rebias方法实现

    2.2.1 markOop mark = obj->mark()

    获取对象的markOop数据mark,即对象头的Mark Word

    2.2.2 判断mark是否为可偏向状态

    • mark的偏向锁标志位为 1 锁标志位为 01

    2.2.3 判断mark中JavaThread的状态

    如果为空,则进入步骤(4);如果指向当前线程,则执行同步代码块;如果指向其它线程,进入步骤(5);

    2.2.4 通过CAS原子指令

    设置mark中JavaThread为当前线程ID,如果执行CAS成功,则执行同步代码块,否则进入步骤(5);

    2.2.5 如果执行CAS失败

    表示当前存在多个线程竞争锁,当达到全局安全点(safepoint),获得偏向锁的线程被挂起,撤销偏向锁,并升级为轻量级,升级完成后被阻塞在安全点的线程继续执行同步代码块;

    2.3 偏向锁的撤销

    只有当其它线程尝试竞争偏向锁时,持有偏向锁的线程才会释放锁,偏向锁的撤销由BiasedLocking::revoke_at_safepoint方法实现:

    1、偏向锁的撤销动作必须等待全局安全点;
    2、暂停拥有偏向锁的线程,判断锁对象是否处于被锁定状态;
    3、撤销偏向锁,恢复到无锁(标志位为 01)或轻量级锁(标志位为 00)的状态;

    偏向锁在Java 1.6之后是默认启用的,但在应用程序启动几秒钟之后才激活,可以使用
    -XX:BiasedLockingStartupDelay=0
    参数关闭延迟,如果确定应用程序中所有锁通常情况下处于竞争状态,可以通过
    XX:-UseBiasedLocking=false
    参数关闭偏向锁。

    2.4 轻量级锁

    2.4.1 引入轻量级锁的目的

    在多线程交替执行同步块的情况下,尽量避免重量级锁引起的性能消耗,但是如果多个线程在同一时刻进入临界区,会导致轻量级锁膨胀升级重量级锁,所以轻量级锁的出现并非是要替代重量级锁

    2.4.2 轻量级锁的获取

    当关闭偏向锁功能,或多个线程竞争偏向锁导致偏向锁升级为轻量级锁,会尝试获取轻量级锁,其入口位于ObjectSynchronizer::slow_enter

    1、markOop mark = obj->mark()方法获取对象的markOop数据mark;
    2、mark->is_neutral()方法判断mark是否为无锁状态:mark的偏向锁标志位为 0,锁标志位为 01
    3、如果mark处于无锁状态,则进入步骤(4),否则执行步骤(6);
    4、把mark保存到BasicLock对象的_displaced_header字段;
    5、通过CAS尝试将Mark Word更新为指向BasicLock对象的指针,如果更新成功,表示竞争到锁,则执行同步代码,否则执行步骤(6);
    6、如果当前mark处于加锁状态,且mark中的ptr指针指向当前线程的栈帧,则执行同步代码,否则说明有多个线程竞争轻量级锁,轻量级锁需要膨胀升级为重量级锁;

    假设线程A和B同时执行到临界区if (mark->is_neutral())
    1、线程AB都把Mark Word复制到各自的_displaced_header字段,该数据保存在线程的栈帧上,是线程私有的;
    2、Atomic::cmpxchg_ptr原子操作保证只有一个线程可以把指向栈帧的指针复制到Mark Word,假设此时线程A执行成功,并返回继续执行同步代码块;
    3、线程B执行失败,退出临界区,通过ObjectSynchronizer::inflate方法开始膨胀锁;

    轻量级锁的释放

    轻量级锁的释放通过ObjectSynchronizer::fast_exit完成。

    1、确保处于偏向锁状态时不会执行这段逻辑;
    2、取出在获取轻量级锁时保存在BasicLock对象的mark数据dhw;
    3、通过CAS尝试把dhw替换到当前的Mark Word,如果CAS成功,说明成功的释放了锁,否则执行步骤(4);
    4、如果CAS失败,说明有其它线程在尝试获取该锁,这时需要将该锁升级为重量级锁,并释放;

    重量级锁

    重量级锁通过对象内部的监视器(monitor)实现,其中monitor的本质是依赖于底层操作系统的Mutex Lock实现,操作系统实现线程之间的切换需要从用户态到内核态的切换,切换成本非常高。

    锁膨胀过程

    锁的膨胀过程通过ObjectSynchronizer::inflate函数实现

    膨胀过程的实现比较复杂,截图中只是一小部分逻辑,完整的方法可以查看synchronized.cpp,大概实现过程如下:
    1、整个膨胀过程在自旋下完成;
    2、mark->has_monitor()方法判断当前是否为重量级锁,即Mark Word的锁标识位为 10,如果当前状态为重量级锁,执行步骤(3),否则执行步骤(4);
    3、mark->monitor()方法获取指向ObjectMonitor的指针,并返回,说明膨胀过程已经完成;
    4、如果当前锁处于膨胀中,说明该锁正在被其它线程执行膨胀操作,则当前线程就进行自旋等待锁膨胀完成,这里需要注意一点,虽然是自旋操作,但不会一直占用cpu资源,每隔一段时间会通过os::NakedYield方法放弃cpu资源,或通过park方法挂起;如果其他线程完成锁的膨胀操作,则退出自旋并返回;
    5、如果当前是轻量级锁状态,即锁标识位为 00,膨胀过程如下:

    1、通过omAlloc方法,获取一个可用的ObjectMonitor monitor,并重置monitor数据;
    2、通过CAS尝试将Mark Word设置为markOopDesc:INFLATING,标识当前锁正在膨胀中,如果CAS失败,说明同一时刻其它线程已经将Mark Word设置为markOopDesc:INFLATING,当前线程进行自旋等待膨胀完成;
    3、如果CAS成功,设置monitor的各个字段:_header、_owner和_object等,并返回;

    monitor竞争

    当锁膨胀完成并返回对应的monitor时,并不表示该线程竞争到了锁,真正的锁竞争发生在ObjectMonitor::enter方法中。

    1、通过CAS尝试把monitor的_owner字段设置为当前线程;
    2、如果设置之前的_owner指向当前线程,说明当前线程再次进入monitor,即重入锁,执行_recursions ++ ,记录重入的次数;
    3、如果之前的_owner指向的地址在当前线程中,这种描述有点拗口,换一种说法:之前_owner指向的BasicLock在当前线程栈上,说明当前线程是第一次进入该monitor,设置_recursions为1,_owner为当前线程,该线程成功获得锁并返回;
    4、如果获取锁失败,则等待锁的释放;

    monitor等待

    monitor竞争失败的线程,通过自旋执行ObjectMonitor::EnterI方法等待锁的释放,EnterI方法的部分逻辑实现如下:

    1、当前线程被封装成ObjectWaiter对象node,状态设置成ObjectWaiter::TS_CXQ;
    2、在for循环中,通过CAS把node节点push到_cxq列表中,同一时刻可能有多个线程把自己的node节点push到_cxq列表中;
    3、node节点push到_cxq列表之后,通过自旋尝试获取锁,如果还是没有获取到锁,则通过park将当前线程挂起,等待被唤醒,实现如下:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z84eXtzV-1571562703110)(https://uploadfiles.nowcoder.com/files/20191020/5088755_1571562670865_4685968-e797fdcdc32a2f8e.png)]

    4、当该线程被唤醒时,会从挂起的点继续执行,通过ObjectMonitor::TryLock尝试获取锁,TryLock方法实现如下:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sJC8vMmz-1571562703111)(https://uploadfiles.nowcoder.com/files/20191020/5088755_1571562670568_4685968-17d10b24c3369844.png)]

    其本质就是通过CAS设置monitor的_owner字段为当前线程,如果CAS成功,则表示该线程获取了锁,跳出自旋操作,执行同步代码,否则继续被挂起;

    monitor释放

    当某个持有锁的线程执行完同步代码块时,会进行锁的释放,给其它线程机会执行同步代码,在HotSpot中,通过退出monitor的方式实现锁的释放,并通知被阻塞的线程,具体实现位于ObjectMonitor::exit方法中。

    1、如果是重量级锁的释放,monitor中的_owner指向当前线程,即THREAD == _owner;
    2、根据不同的策略(由QMode指定),从cxq或EntryList中获取头节点,通过ObjectMonitor::ExitEpilog方法唤醒该节点封装的线程,唤醒操作最终由unpark完成,实现如下:

    void ObjectMonitor::ExitEpilog(Thread * Self, ObjectWaiter * Wakee) {
      assert(_owner == Self, "invariant");
    
      // Exit protocol:
      // 1. ST _succ = wakee
      // 2. membar #loadstore|#storestore;
      // 2. ST _owner = NULL
      // 3. unpark(wakee)
    
      _succ = Wakee->_thread;
      ParkEvent * Trigger = Wakee->_event;
    
      // Hygiene -- once we've set _owner = NULL we can't safely dereference Wakee again.
      // The thread associated with Wakee may have grabbed the lock and "Wakee" may be
      // out-of-scope (non-extant).
      Wakee  = NULL;
    
      // Drop the lock
      OrderAccess::release_store(&_owner, (void*)NULL);
      OrderAccess::fence();                               // ST _owner vs LD in unpark()
    
      DTRACE_MONITOR_PROBE(contended__exit, this, object(), Self);
      Trigger->unpark();
    
      // Maintain stats and report events to JVMTI
      OM_PERFDATA_OP(Parks, inc());
    }
    

    3、被唤醒的线程,继续执行monitor的竞争;

    展开全文
  • 深入理解Java并发之synchronized实现原理

    万次阅读 多人点赞 2017-06-04 17:44:44
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ... 出自【zejian的博客】...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...

    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权)
    http://blog.csdn.net/javazejian/article/details/72828483
    出自【zejian的博客】

    关联文章:

    深入理解Java类型信息(Class对象)与反射机制

    深入理解Java枚举类型(enum)

    深入理解Java注解类型(@Annotation)

    深入理解Java类加载器(ClassLoader)

    深入理解Java并发之synchronized实现原理

    Java并发编程-无锁CAS与Unsafe类及其并发包Atomic

    深入理解Java内存模型(JMM)及volatile关键字

    剖析基于并发AQS的重入锁(ReetrantLock)及其Condition实现原理

    剖析基于并发AQS的共享锁的实现(基于信号量Semaphore)

    并发之阻塞队列LinkedBlockingQueue与ArrayBlockingQueue

    本篇主要是对Java并发中synchronized关键字进行较为深入的探索,这些知识点结合博主对synchronized的个人理解以及相关的书籍的讲解(在结尾参考资料),如有误处,欢迎留言。

    线程安全是并发编程中的重要关注点,应该注意到的是,造成线程安全问题的主要诱因有两点,一是存在共享数据(也称临界资源),二是存在多条线程共同操作共享数据。因此为了解决这个问题,我们可能需要这样一个方案,当存在多个线程操作共享数据时,需要保证同一时刻有且只有一个线程在操作共享数据,其他线程必须等到该线程处理完数据后再进行,这种方式有个高尚的名称叫互斥锁,即能达到互斥访问目的的锁,也就是说当一个共享数据被当前正在访问的线程加上互斥锁后,在同一个时刻,其他线程只能处于等待的状态,直到当前线程处理完毕释放该锁。在 Java 中,关键字 synchronized可以保证在同一个时刻,只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作),同时我们还应该注意到synchronized另外一个重要的作用,synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到(保证可见性,完全可以替代Volatile功能),这点确实也是很重要的。

    synchronized的三种应用方式

    synchronized关键字最主要有以下3种应用方式,下面分别介绍

    • 修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁

    • 修饰静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁

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

    synchronized作用于实例方法

    所谓的实例对象锁就是用synchronized修饰实例对象中的实例方法,注意是实例方法不包括静态方法,如下

    public class AccountingSync implements Runnable{
        //共享资源(临界资源)
        static int i=0;
    
        /**
         * synchronized 修饰实例方法
         */
        public synchronized void increase(){
            i++;
        }
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                increase();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            AccountingSync instance=new AccountingSync();
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(i);
        }
        /**
         * 输出结果:
         * 2000000
         */
    }

    上述代码中,我们开启两个线程操作同一个共享资源即变量i,由于i++;操作并不具备原子性,该操作是先读取值,然后写回一个新值,相当于原来的值加上1,分两步完成,如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值,那么第二个线程就会与第一个线程一起看到同一个值,并执行相同值的加1操作,这也就造成了线程安全失败,因此对于increase方法必须使用synchronized修饰,以便保证线程安全。此时我们应该注意到synchronized修饰的是实例方法increase,在这样的情况下,当前线程的锁便是实例对象instance,注意Java中的线程同步锁可以是任意对象。从代码执行结果来看确实是正确的,倘若我们没有使用synchronized关键字,其最终输出结果就很可能小于2000000,这便是synchronized关键字的作用。这里我们还需要意识到,当一个线程正在访问一个对象的 synchronized 实例方法,那么其他线程不能访问该对象的其他 synchronized 方法,毕竟一个对象只有一把锁,当一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,所以无法访问该对象的其他synchronized实例方法,但是其他线程还是可以访问该实例对象的其他非synchronized方法,当然如果是一个线程 A 需要访问实例对象 obj1 的 synchronized 方法 f1(当前对象锁是obj1),另一个线程 B 需要访问实例对象 obj2 的 synchronized 方法 f2(当前对象锁是obj2),这样是允许的,因为两个实例对象锁并不同相同,此时如果两个线程操作数据并非共享的,线程安全是有保障的,遗憾的是如果两个线程操作的是共享数据,那么线程安全就有可能无法保证了,如下代码将演示出该现象

    public class AccountingSyncBad implements Runnable{
        static int i=0;
        public synchronized void increase(){
            i++;
        }
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                increase();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            //new新实例
            Thread t1=new Thread(new AccountingSyncBad());
            //new新实例
            Thread t2=new Thread(new AccountingSyncBad());
            t1.start();
            t2.start();
            //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
            t1.join();
            t2.join();
            System.out.println(i);
        }
    }

    上述代码与前面不同的是我们同时创建了两个新实例AccountingSyncBad,然后启动两个不同的线程对共享变量i进行操作,但很遗憾操作结果是1452317而不是期望结果2000000,因为上述代码犯了严重的错误,虽然我们使用synchronized修饰了increase方法,但却new了两个不同的实例对象,这也就意味着存在着两个不同的实例对象锁,因此t1和t2都会进入各自的对象锁,也就是说t1和t2线程使用的是不同的锁,因此线程安全是无法保证的。解决这种困境的的方式是将synchronized作用于静态的increase方法,这样的话,对象锁就当前类对象,由于无论创建多少个实例对象,但对于的类对象拥有只有一个,所有在这样的情况下对象锁就是唯一的。下面我们看看如何使用将synchronized作用于静态的increase方法。

    synchronized作用于静态方法

    当synchronized作用于静态方法时,其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象,是类成员,因此通过class对象锁可以控制静态 成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static synchronized方法,而线程B需要调用这个实例对象所属类的静态 synchronized方法,是允许的,不会发生互斥现象,因为访问静态 synchronized 方法占用的锁是当前类的class对象,而访问非静态 synchronized 方法占用的锁是当前实例对象锁,看如下代码

    public class AccountingSyncClass implements Runnable{
        static int i=0;
    
        /**
         * 作用于静态方法,锁是当前class对象,也就是
         * AccountingSyncClass类对应的class对象
         */
        public static synchronized void increase(){
            i++;
        }
    
        /**
         * 非静态,访问时锁不一样不会发生互斥
         */
        public synchronized void increase4Obj(){
            i++;
        }
    
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                increase();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            //new新实例
            Thread t1=new Thread(new AccountingSyncClass());
            //new心事了
            Thread t2=new Thread(new AccountingSyncClass());
            //启动线程
            t1.start();t2.start();
    
            t1.join();t2.join();
            System.out.println(i);
        }
    }

    由于synchronized关键字修饰的是静态increase方法,与修饰实例方法不同的是,其锁对象是当前类的class对象。注意代码中的increase4Obj方法是实例方法,其对象锁是当前实例对象,如果别的线程调用该方法,将不会产生互斥现象,毕竟锁对象不同,但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。

    synchronized同步代码块

    除了使用关键字修饰实例方法和静态方法外,还可以使用同步代码块,在某些情况下,我们编写的方法体可能比较大,同时存在一些比较耗时的操作,而需要同步的代码又只有一小部分,如果直接对整个方法进行同步操作,可能会得不偿失,此时我们可以使用同步代码块的方式对需要同步的代码进行包裹,这样就无需对整个方法进行同步操作了,同步代码块的使用示例如下:

    public class AccountingSync implements Runnable{
        static AccountingSync instance=new AccountingSync();
        static int i=0;
        @Override
        public void run() {
            //省略其他耗时操作....
            //使用同步代码块对变量i进行同步操作,锁对象为instance
            synchronized(instance){
                for(int j=0;j<1000000;j++){
                        i++;
                  }
            }
        }
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();t2.start();
            t1.join();t2.join();
            System.out.println(i);
        }
    }
    

    从代码看出,将synchronized作用于一个给定的实例对象instance,即当前实例对象就是锁对象,每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁,如果当前有其他线程正持有该对象锁,那么新到的线程就必须等待,这样也就保证了每次只有一个线程执行i++;操作。当然除了instance作为对象外,我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁,如下代码:

    //this,当前实例对象锁
    synchronized(this){
        for(int j=0;j<1000000;j++){
            i++;
        }
    }
    
    //class对象锁
    synchronized(AccountingSync.class){
        for(int j=0;j<1000000;j++){
            i++;
        }
    }

    了解完synchronized的基本含义及其使用方式后,下面我们将进一步深入理解synchronized的底层实现原理。

    synchronized底层语义原理

    Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现, 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步都是如此。在 Java 语言中,同步用的最多的地方可能是被 synchronized 修饰的同步方法。同步方法 并不是由 monitorenter 和 monitorexit 指令来实现同步的,而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的,关于这点,稍后详细分析。下面先来了解一个概念Java对象头,这对深入理解synchronized实现原理非常关键。

    理解Java对象头与Monitor

    在JVM中,对象在内存中的布局分为三块区域:对象头、实例数据和对齐填充。如下:

    • 实例变量:存放类的属性数据信息,包括父类的属性信息,如果是数组的实例部分还包括数组的长度,这部分内存按4字节对齐。

    • 填充数据:由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的,仅仅是为了字节对齐,这点了解即可。

    而对于顶部,则是Java头对象,它实现synchronized的锁对象的基础,这点我们重点分析它,一般而言,synchronized使用的锁对象是存储在Java对象头里的,jvm中采用2个字来存储对象头(如果对象是数组则会分配3个字,多出来的1个字记录的是数组长度),其主要结构是由Mark Word 和 Class Metadata Address 组成,其结构说明如下表:

    虚拟机位数头对象结构说明
    32/64bitMark Word存储对象的hashCode、锁信息或分代年龄或GC标志等信息
    32/64bitClass Metadata Address类型指针指向对象的类元数据,JVM通过这个指针确定该对象是哪个类的实例。

    其中Mark Word在默认情况下存储着对象的HashCode、分代年龄、锁标记位等以下是32位JVM的Mark Word默认存储结构

    锁状态25bit4bit1bit是否是偏向锁2bit 锁标志位
    无锁状态对象HashCode对象分代年龄001

    由于对象头的信息是与对象自身定义的数据没有关系的额外存储成本,因此考虑到JVM的空间效率,Mark Word 被设计成为一个非固定的数据结构,以便存储更多有效的数据,它会根据对象本身的状态复用自己的存储空间,如32位JVM下,除了上述列出的Mark Word默认存储结构外,还有如下可能变化的结构:

    其中轻量级锁和偏向锁是Java 6 对 synchronized 锁进行优化后新增加的,稍后我们会简要分析。这里我们主要分析一下重量级锁也就是通常说synchronized的对象锁,锁标识位为10,其中指针指向的是monitor对象(也称为管程或监视器锁)的起始地址。每个对象都存在着一个 monitor 与之关联,对象与其 monitor 之间的关系有存在多种实现方式,如monitor可以与对象一起创建销毁或当线程试图获取对象锁时自动生成,但当一个 monitor 被某个线程持有后,它便处于锁定状态。在Java虚拟机(HotSpot)中,monitor是由ObjectMonitor实现的,其主要数据结构如下(位于HotSpot虚拟机源码ObjectMonitor.hpp文件,C++实现的)

    ObjectMonitor() {
        _header       = NULL;
        _count        = 0; //记录个数
        _waiters      = 0,
        _recursions   = 0;
        _object       = NULL;
        _owner        = NULL;
        _WaitSet      = NULL; //处于wait状态的线程,会被加入到_WaitSet
        _WaitSetLock  = 0 ;
        _Responsible  = NULL ;
        _succ         = NULL ;
        _cxq          = NULL ;
        FreeNext      = NULL ;
        _EntryList    = NULL ; //处于等待锁block状态的线程,会被加入到该列表
        _SpinFreq     = 0 ;
        _SpinClock    = 0 ;
        OwnerIsThread = 0 ;
      }

    ObjectMonitor中有两个队列,_WaitSet 和 _EntryList,用来保存ObjectWaiter对象列表( 每个等待锁的线程都会被封装成ObjectWaiter对象),_owner指向持有ObjectMonitor对象的线程,当多个线程同时访问一段同步代码时,首先会进入 _EntryList 集合,当线程获取到对象的monitor 后进入 _Owner 区域并把monitor中的owner变量设置为当前线程同时monitor中的计数器count加1,若线程调用 wait() 方法,将释放当前持有的monitor,owner变量恢复为null,count自减1,同时该线程进入 WaitSe t集合中等待被唤醒。若当前线程执行完毕也将释放monitor(锁)并复位变量的值,以便其他线程进入获取monitor(锁)。如下图所示

    由此看来,monitor对象存在于每个Java对象的对象头中(存储的指针的指向),synchronized锁便是通过这种方式获取锁的,也是为什么Java中任意对象可以作为锁的原因,同时也是notify/notifyAll/wait等方法存在于顶级对象Object中的原因(关于这点稍后还会进行分析),ok~,有了上述知识基础后,下面我们将进一步分析synchronized在字节码层面的具体语义实现。

    synchronized代码块底层原理

    现在我们重新定义一个synchronized修饰的同步代码块,在代码块中操作共享变量i,如下

    public class SyncCodeBlock {
    
       public int i;
    
       public void syncTask(){
           //同步代码库
           synchronized (this){
               i++;
           }
       }
    }

    编译上述代码并使用javap反编译后得到字节码如下(这里我们省略一部分没有必要的信息):

    Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncCodeBlock.class
      Last modified 2017-6-2; size 426 bytes
      MD5 checksum c80bc322c87b312de760942820b4fed5
      Compiled from "SyncCodeBlock.java"
    public class com.zejian.concurrencys.SyncCodeBlock
      minor version: 0
      major version: 52
      flags: ACC_PUBLIC, ACC_SUPER
    Constant pool:
      //........省略常量池中数据
      //构造函数
      public com.zejian.concurrencys.SyncCodeBlock();
        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 7: 0
      //===========主要看看syncTask方法实现================
      public void syncTask();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=3, locals=3, args_size=1
             0: aload_0
             1: dup
             2: astore_1
             3: monitorenter  //注意此处,进入同步方法
             4: aload_0
             5: dup
             6: getfield      #2             // Field i:I
             9: iconst_1
            10: iadd
            11: putfield      #2            // Field i:I
            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:
          //省略其他字节码.......
    }
    SourceFile: "SyncCodeBlock.java"

    我们主要关注字节码中的如下代码

    3: monitorenter  //进入同步方法
    //..........省略其他  
    15: monitorexit   //退出同步方法
    16: goto          24
    //省略其他.......
    21: monitorexit //退出同步方法

    从字节码中可知同步语句块的实现使用的是monitorenter 和 monitorexit 指令,其中monitorenter指令指向同步代码块的开始位置,monitorexit指令则指明同步代码块的结束位置,当执行monitorenter指令时,当前线程将试图获取 objectref(即对象锁) 所对应的 monitor 的持有权,当 objectref 的 monitor 的进入计数器为 0,那线程可以成功取得 monitor,并将计数器值设置为 1,取锁成功。如果当前线程已经拥有 objectref 的 monitor 的持有权,那它可以重入这个 monitor (关于重入性稍后会分析),重入时计数器的值也会加 1。倘若其他线程已经拥有 objectref 的 monitor 的所有权,那当前线程将被阻塞,直到正在执行线程执行完毕,即monitorexit指令被执行,执行线程将释放 monitor(锁)并设置计数器值为0 ,其他线程将有机会持有 monitor 。值得注意的是编译器将会确保无论方法通过何种方式完成,方法中调用过的每条 monitorenter 指令都有执行其对应 monitorexit 指令,而无论这个方法是正常结束还是异常结束。为了保证在方法异常完成时 monitorenter 和 monitorexit 指令依然可以正确配对执行,编译器会自动产生一个异常处理器,这个异常处理器声明可处理所有的异常,它的目的就是用来执行 monitorexit 指令。从字节码中也可以看出多了一个monitorexit指令,它就是异常结束时被执行的释放monitor 的指令。

    synchronized方法底层原理

    方法级的同步是隐式,即无需通过字节码指令来控制的,它实现在方法调用和返回操作之中。JVM可以从方法常量池中的方法表结构(method_info Structure) 中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。当方法调用时,调用指令将会 检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置,如果设置了,执行线程将先持有monitor(虚拟机规范中用的是管程一词), 然后再执行方法,最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。在方法执行期间,执行线程持有了monitor,其他任何线程都无法再获得同一个monitor。如果一个同步方法执行期间抛 出了异常,并且在方法内部无法处理此异常,那这个同步方法所持有的monitor将在异常抛到同步方法之外时自动释放。下面我们看看字节码层面如何实现:

    public class SyncMethod {
    
       public int i;
    
       public synchronized void syncTask(){
               i++;
       }
    }

    使用javap反编译后的字节码如下:

    Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncMethod.class
      Last modified 2017-6-2; size 308 bytes
      MD5 checksum f34075a8c059ea65e4cc2fa610e0cd94
      Compiled from "SyncMethod.java"
    public class com.zejian.concurrencys.SyncMethod
      minor version: 0
      major version: 52
      flags: ACC_PUBLIC, ACC_SUPER
    Constant pool;
    
       //省略没必要的字节码
      //==================syncTask方法======================
      public synchronized void syncTask();
        descriptor: ()V
        //方法标识ACC_PUBLIC代表public修饰,ACC_SYNCHRONIZED指明该方法为同步方法
        flags: ACC_PUBLIC, ACC_SYNCHRONIZED
        Code:
          stack=3, locals=1, args_size=1
             0: aload_0
             1: dup
             2: getfield      #2                  // Field i:I
             5: iconst_1
             6: iadd
             7: putfield      #2                  // Field i:I
            10: return
          LineNumberTable:
            line 12: 0
            line 13: 10
    }
    SourceFile: "SyncMethod.java"

    从字节码中可以看出,synchronized修饰的方法并没有monitorenter指令和monitorexit指令,取得代之的确实是ACC_SYNCHRONIZED标识,该标识指明了该方法是一个同步方法,JVM通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法,从而执行相应的同步调用。这便是synchronized锁在同步代码块和同步方法上实现的基本原理。同时我们还必须注意到的是在Java早期版本中,synchronized属于重量级锁,效率低下,因为监视器锁(monitor)是依赖于底层的操作系统的Mutex Lock来实现的,而操作系统实现线程之间的切换时需要从用户态转换到核心态,这个状态之间的转换需要相对比较长的时间,时间成本相对较高,这也是为什么早期的synchronized效率低的原因。庆幸的是在Java 6之后Java官方对从JVM层面对synchronized较大优化,所以现在的synchronized锁效率也优化得很不错了,Java 6之后,为了减少获得锁和释放锁所带来的性能消耗,引入了轻量级锁和偏向锁,接下来我们将简单了解一下Java官方在JVM层面对synchronized锁的优化。

    Java虚拟机对synchronized的优化

    锁的状态总共有四种,无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争,锁可以从偏向锁升级到轻量级锁,再升级的重量级锁,但是锁的升级是单向的,也就是说只能从低到高升级,不会出现锁的降级,关于重量级锁,前面我们已详细分析过,下面我们将介绍偏向锁和轻量级锁以及JVM的其他优化手段,这里并不打算深入到每个锁的实现和转换过程更多地是阐述Java虚拟机所提供的每个锁的核心优化思想,毕竟涉及到具体过程比较繁琐,如需了解详细过程可以查阅《深入理解Java虚拟机原理》。

    偏向锁

    偏向锁是Java 6之后加入的新锁,它是一种针对加锁操作的优化手段,经过研究发现,在大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,因此为了减少同一线程获取锁(会涉及到一些CAS操作,耗时)的代价而引入偏向锁。偏向锁的核心思想是,如果一个线程获得了锁,那么锁就进入偏向模式,此时Mark Word 的结构也变为偏向锁结构,当这个线程再次请求锁时,无需再做任何同步操作,即获取锁的过程,这样就省去了大量有关锁申请的操作,从而也就提供程序的性能。所以,对于没有锁竞争的场合,偏向锁有很好的优化效果,毕竟极有可能连续多次是同一个线程申请相同的锁。但是对于锁竞争比较激烈的场合,偏向锁就失效了,因为这样场合极有可能每次申请锁的线程都是不相同的,因此这种场合下不应该使用偏向锁,否则会得不偿失,需要注意的是,偏向锁失败后,并不会立即膨胀为重量级锁,而是先升级为轻量级锁。下面我们接着了解轻量级锁。

    轻量级锁

    倘若偏向锁失败,虚拟机并不会立即升级为重量级锁,它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的),此时Mark Word 的结构也变为轻量级锁的结构。轻量级锁能够提升程序性能的依据是“对绝大部分的锁,在整个同步周期内都不存在竞争”,注意这是经验数据。需要了解的是,轻量级锁所适应的场景是线程交替执行同步块的场合,如果存在同一时间访问同一锁的场合,就会导致轻量级锁膨胀为重量级锁。

    自旋锁

    轻量级锁失败后,虚拟机为了避免线程真实地在操作系统层面挂起,还会进行一项称为自旋锁的优化手段。这是基于在大多数情况下,线程持有锁的时间都不会太长,如果直接挂起操作系统层面的线程可能会得不偿失,毕竟操作系统实现线程之间的切换时需要从用户态转换到核心态,这个状态之间的转换需要相对比较长的时间,时间成本相对较高,因此自旋锁会假设在不久将来,当前的线程可以获得锁,因此虚拟机会让当前想要获取锁的线程做几个空循环(这也是称为自旋的原因),一般不会太久,可能是50个循环或100循环,在经过若干次循环后,如果得到锁,就顺利进入临界区。如果还不能获得锁,那就会将线程在操作系统层面挂起,这就是自旋锁的优化方式,这种方式确实也是可以提升效率的。最后没办法也就只能升级为重量级锁了。

    锁消除

    消除锁是虚拟机另外一种锁的优化,这种优化更彻底,Java虚拟机在JIT编译时(可以简单理解为当某段代码即将第一次被执行时进行编译,又称即时编译),通过对运行上下文的扫描,去除不可能存在共享资源竞争的锁,通过这种方式消除没有必要的锁,可以节省毫无意义的请求锁时间,如下StringBuffer的append是一个同步方法,但是在add方法中的StringBuffer属于一个局部变量,并且不会被其他线程所使用,因此StringBuffer不可能存在共享资源竞争的情景,JVM会自动将其锁消除。

    /**
     * Created by zejian on 2017/6/4.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     * 消除StringBuffer同步锁
     */
    public class StringBufferRemoveSync {
    
        public void add(String str1, String str2) {
            //StringBuffer是线程安全,由于sb只会在append方法中使用,不可能被其他线程引用
            //因此sb属于不可能共享的资源,JVM会自动消除内部的锁
            StringBuffer sb = new StringBuffer();
            sb.append(str1).append(str2);
        }
    
        public static void main(String[] args) {
            StringBufferRemoveSync rmsync = new StringBufferRemoveSync();
            for (int i = 0; i < 10000000; i++) {
                rmsync.add("abc", "123");
            }
        }
    
    }

    关于synchronized 可能需要了解的关键点

    synchronized的可重入性

    从互斥锁的设计上来说,当一个线程试图操作一个由其他线程持有的对象锁的临界资源时,将会处于阻塞状态,但当一个线程再次请求自己持有对象锁的临界资源时,这种情况属于重入锁,请求将会成功,在java中synchronized是基于原子性的内部锁机制,是可重入的,因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法,也就是说一个线程得到一个对象锁后再次请求该对象锁,是允许的,这就是synchronized的可重入性。如下:

    public class AccountingSync implements Runnable{
        static AccountingSync instance=new AccountingSync();
        static int i=0;
        static int j=0;
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
    
                //this,当前实例对象锁
                synchronized(this){
                    i++;
                    increase();//synchronized的可重入性
                }
            }
        }
    
        public synchronized void increase(){
            j++;
        }
    
    
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();t2.start();
            t1.join();t2.join();
            System.out.println(i);
        }
    }

    正如代码所演示的,在获取当前实例对象锁后进入synchronized代码块执行同步代码,并在代码块中调用了当前实例对象的另外一个synchronized方法,再次请求当前实例锁时,将被允许,进而执行方法体代码,这就是重入锁最直接的体现,需要特别注意另外一种情况,当子类继承父类时,子类也是可以通过可重入锁调用父类的同步方法。注意由于synchronized是基于monitor实现的,因此每次重入,monitor中的计数器仍会加1。

    线程中断与synchronized

    线程中断

    正如中断二字所表达的意义,在线程运行(run方法)中间打断它,在Java中,提供了以下3个有关线程中断的方法

    //中断线程(实例方法)
    public void Thread.interrupt();
    
    //判断线程是否被中断(实例方法)
    public boolean Thread.isInterrupted();
    
    //判断是否被中断并清除当前中断状态(静态方法)
    public static boolean Thread.interrupted();

    当一个线程处于被阻塞状态或者试图执行一个阻塞操作时,使用Thread.interrupt()方式中断该线程,注意此时将会抛出一个InterruptedException的异常,同时中断状态将会被复位(由中断状态改为非中断状态),如下代码将演示该过程:

    public class InterruputSleepThread3 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread() {
                @Override
                public void run() {
                    //while在try中,通过异常中断就可以退出run循环
                    try {
                        while (true) {
                            //当前线程处于阻塞状态,异常必须捕捉处理,无法往外抛出
                            TimeUnit.SECONDS.sleep(2);
                        }
                    } catch (InterruptedException e) {
                        System.out.println("Interruted When Sleep");
                        boolean interrupt = this.isInterrupted();
                        //中断状态被复位
                        System.out.println("interrupt:"+interrupt);
                    }
                }
            };
            t1.start();
            TimeUnit.SECONDS.sleep(2);
            //中断处于阻塞状态的线程
            t1.interrupt();
    
            /**
             * 输出结果:
               Interruted When Sleep
               interrupt:false
             */
        }
    }

    如上述代码所示,我们创建一个线程,并在线程中调用了sleep方法从而使用线程进入阻塞状态,启动线程后,调用线程实例对象的interrupt方法中断阻塞异常,并抛出InterruptedException异常,此时中断状态也将被复位。这里有些人可能会诧异,为什么不用Thread.sleep(2000);而是用TimeUnit.SECONDS.sleep(2);其实原因很简单,前者使用时并没有明确的单位说明,而后者非常明确表达秒的单位,事实上后者的内部实现最终还是调用了Thread.sleep(2000);,但为了编写的代码语义更清晰,建议使用TimeUnit.SECONDS.sleep(2);的方式,注意TimeUnit是个枚举类型。ok~,除了阻塞中断的情景,我们还可能会遇到处于运行期且非阻塞的状态的线程,这种情况下,直接调用Thread.interrupt()中断线程是不会得到任响应的,如下代码,将无法中断非阻塞状态下的线程:

    public class InterruputThread {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(){
                @Override
                public void run(){
                    while(true){
                        System.out.println("未被中断");
                    }
                }
            };
            t1.start();
            TimeUnit.SECONDS.sleep(2);
            t1.interrupt();
    
            /**
             * 输出结果(无限执行):
                 未被中断
                 未被中断
                 未被中断
                 ......
             */
        }
    }

    虽然我们调用了interrupt方法,但线程t1并未被中断,因为处于非阻塞状态的线程需要我们手动进行中断检测并结束程序,改进后代码如下:

    public class InterruputThread {
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(){
                @Override
                public void run(){
                    while(true){
                        //判断当前线程是否被中断
                        if (this.isInterrupted()){
                            System.out.println("线程中断");
                            break;
                        }
                    }
    
                    System.out.println("已跳出循环,线程中断!");
                }
            };
            t1.start();
            TimeUnit.SECONDS.sleep(2);
            t1.interrupt();
    
            /**
             * 输出结果:
                线程中断
                已跳出循环,线程中断!
             */
        }
    }

    是的,我们在代码中使用了实例方法isInterrupted判断线程是否已被中断,如果被中断将跳出循环以此结束线程,注意非阻塞状态调用interrupt()并不会导致中断状态重置。综合所述,可以简单总结一下中断两种情况,一种是当线程处于阻塞状态或者试图执行一个阻塞操作时,我们可以使用实例方法interrupt()进行线程中断,执行中断操作后将会抛出interruptException异常(该异常必须捕捉无法向外抛出)并将中断状态复位,另外一种是当线程处于运行状态时,我们也可调用实例方法interrupt()进行线程中断,但同时必须手动判断中断状态,并编写中断线程的代码(其实就是结束run方法体的代码)。有时我们在编码时可能需要兼顾以上两种情况,那么就可以如下编写:

    public void run(){
        try {
        //判断当前线程是否已中断,注意interrupted方法是静态的,执行后会对中断状态进行复位
        while (!Thread.interrupted()) {
            TimeUnit.SECONDS.sleep(2);
        }
        } catch (InterruptedException e) {
    
        }
    }

    中断与synchronized

    事实上线程的中断操作对于正在等待获取的锁对象的synchronized方法或者代码块并不起作用,也就是对于synchronized来说,如果一个线程在等待锁,那么结果只有两种,要么它获得这把锁继续执行,要么它就保存等待,即使调用中断线程的方法,也不会生效。演示代码如下

    /**
     * Created by zejian on 2017/6/2.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class SynchronizedBlocked implements Runnable{
    
        public synchronized void f() {
            System.out.println("Trying to call f()");
            while(true) // Never releases lock
                Thread.yield();
        }
    
        /**
         * 在构造器中创建新线程并启动获取对象锁
         */
        public SynchronizedBlocked() {
            //该线程已持有当前实例锁
            new Thread() {
                public void run() {
                    f(); // Lock acquired by this thread
                }
            }.start();
        }
        public void run() {
            //中断判断
            while (true) {
                if (Thread.interrupted()) {
                    System.out.println("中断线程!!");
                    break;
                } else {
                    f();
                }
            }
        }
    
    
        public static void main(String[] args) throws InterruptedException {
            SynchronizedBlocked sync = new SynchronizedBlocked();
            Thread t = new Thread(sync);
            //启动后调用f()方法,无法获取当前实例锁处于等待状态
            t.start();
            TimeUnit.SECONDS.sleep(1);
            //中断线程,无法生效
            t.interrupt();
        }
    }

    我们在SynchronizedBlocked构造函数中创建一个新线程并启动获取调用f()获取到当前实例锁,由于SynchronizedBlocked自身也是线程,启动后在其run方法中也调用了f(),但由于对象锁被其他线程占用,导致t线程只能等到锁,此时我们调用了t.interrupt();但并不能中断线程。

    等待唤醒机制与synchronized

    所谓等待唤醒机制本篇主要指的是notify/notifyAll和wait方法,在使用这3个方法时,必须处于synchronized代码块或者synchronized方法中,否则就会抛出IllegalMonitorStateException异常,这是因为调用这几个方法前必须拿到当前对象的监视器monitor对象,也就是说notify/notifyAll和wait方法依赖于monitor对象,在前面的分析中,我们知道monitor 存在于对象头的Mark Word 中(存储monitor引用指针),而synchronized关键字可以获取 monitor ,这也就是为什么notify/notifyAll和wait方法必须在synchronized代码块或者synchronized方法调用的原因。

    synchronized (obj) {
           obj.wait();
           obj.notify();
           obj.notifyAll();         
     }

    需要特别理解的一点是,与sleep方法不同的是wait方法调用完成后,线程将被暂停,但wait方法将会释放当前持有的监视器锁(monitor),直到有线程调用notify/notifyAll方法后方能继续执行,而sleep方法只让线程休眠并不释放锁。同时notify/notifyAll方法调用后,并不会马上释放监视器锁,而是在相应的synchronized(){}/synchronized方法执行结束后才自动释放锁。

    ok~,篇幅已比较长了,关于synchronized,我们就暂且聊到这。如有错误,欢迎指正,谢谢~~。

    本篇的主要参考资料:
    《Java编程思想》
    《深入理解Java虚拟机》
    《实战Java高并发程序设计》

    感觉文章给你带来收获就赞一个吧!

    展开全文
  • Java同步锁synchronized的最全总结

    千次阅读 2019-10-18 11:34:35
    一、并发同步问题   线程安全是Java并发编程中的重点,而造成线程安全问题的主要原因有两点,一是存在共享数据(也称临界资源),二是存在多条线程共同操作共享数据。因此,当存在多个线程操作共享数据时,需要保证...
  • 对于synchronize同步块的实现底层使用了monitorenter (监视器进入,获取锁)和monitorexit (监视器退出,释放锁)指令 对于同步方法是使用修饰符上的ACC_SYNCHNIZED来完成的,不管使用哪一种,本质是对一个对象...
  • JAVA 同步实现原理同步实现原理

    千次阅读 2018-06-27 09:21:31
    JAVA 同步实现原理下面的文章是转载的,虽然看了半天没有看懂,但是喜欢最后的总结所说的:这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。JDK中对Synchronized做的种种优化,其核心都是为了减少...
  • Java—代码详解

    千次阅读 多人点赞 2021-09-16 20:36:40
    代码概念代码分类普通代码构造代码静态代码块同步代码 代码概念 在java中,{ } 括起来的代码被称为代码 代码分类 普通代码 类中方法的方法体 public class Main{ public static void main(String...
  • java中的同步与异步

    千次阅读 2019-11-28 19:31:09
    显然这是由于全局资源造成的,有时为了解决此问题,优先考虑使用局部变量,退而求其次使用同步代码,出于这样的安全考虑就必须牺牲系统处理性能,加在多线程并发时资源挣夺最激烈的地方,这就实现了线程的同步机制...
  • java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查),将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他线程的调用,从而保证了该...
  • java语言里,我们要进行同步块的控制,一般使用锁和synchronization关键字,用lock同步是在代码层进行资源的抢占控制, 而用synchronization进行的同步jvm层的控制,在一个方法体里,被synchronizatioin修饰的...
  • Java线程同步和锁定

    千次阅读 2022-03-23 09:08:29
    当程序运行到synchronized同步方法或代码时才该对象锁才起作用。 一个对象只有一个锁。所以,如果一个线程获得该锁,就没有其他线程可以获得锁,直到第一个线程释放(或返回)锁。这也意味着任何其他线程都不...
  • word源码java-sync:同步

    2021-06-05 23:07:59
    sync底层工作的原理synchronized sync优化 synchronized synchronized 涉及点 涉及JVM源码 涉及C++ 涉及 VB汇编 synchronized()需要传入一个对象 在非静态方法里需要传入的对象 this 在静态方法里需要传入的对象 ...
  • Java中的同步块用synchronized标记。同步块Java中是同步在某个对象上。所有同步在一个对象上的同步块在同时只能被一个线程进入并执行操作。所有其他等待进入该同步块的线程将被阻塞,直到执行该同步块中的线程退出...
  • java如何实现线程同步

    千次阅读 2020-09-14 09:30:19
    一、什么是线程的同步 线程有自己的私有数据,比如栈和寄存器,同时与其它线程共享相同的虚拟内存和全局变量等资源。 在一般情况下,创建一个线程是不能提高程序的执行效率的,所以要创建多个线程。但是当多个线程...
  • Java基础-Synchronized原理

    千次阅读 2021-02-28 09:55:25
    在多线程并发编程中Synchronized一直是元老级角色,很多人都会称呼它为重量级锁,但是随着Java SE1.6中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁,以及锁的存储结构和升级过程。CAS(Compare ...
  • Java中多线程、多线程的实现方式、同步代码的方式
  • Java线程安全原理深度解析

    千次阅读 2022-03-06 12:10:11
    对一些初学或者老的java程序员,都知道在多线程下访问一个共享变量是非线程安全,所谓的非线程安全,意思是线程a对 共享变量 的修改 对于线程b可能是不可见的(这句话听不懂没关系,看完全文,回头再来看,就会发现...
  • Java工作原理

    千次阅读 2019-01-20 02:47:28
    说起Java,人们首先想到的是Java编程语言,然而事实上,Java是一种技术,它由四方面组成:Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。它们的关系如下图所示: Java代码编译和...
  • java实现同步的几种方式(总结)

    万次阅读 2018-05-09 11:53:05
    java实现同步的几种方式(总结)为何要使用同步? java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查), 将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该...
  • 摘自:http://topmanopensource.iteye.com/blog/1738178 对代码进行同步控制我们可以选择同步方法,也可以选择同步块,这两种方式各有优缺点,至于具体选择什么方式,就见仁见智了,同步块不仅可以更加精确的控制...
  • 同步,异步,阻塞,非阻塞 同步与异步 阻塞与非阻塞 IO模型(Reference Link) ​ 阻塞I/O模型 非阻塞I/O模型 进程把一个套接口设置成非阻塞是在通知内核:当所请求的I/O操作不能满足要求时候,不把本进程...
  • Java集合底层原理理解

    千次阅读 2020-06-29 19:40:20
    Java集合 List,Set,Map三者区别 List 顺序的好帮手:存储一组不唯一的有序的对象 Set 注重独一无二的性质:不允许重复的集合 Map 用key来搜索:使用键值对存储。两个key可以引用相同的对象,但key不能重复。...
  • Java内存映射原理与实现

    千次阅读 2022-01-08 21:26:58
    Java虚拟机规范中定义了Java内存模型(Java Memory Model,JMM),用于屏蔽掉各种硬件和操作系统的内存访问差异,以实现让Java程序在各种平台下都能达到一致的并发效果,JMM规范了Java虚拟机与计算机内存是如何协同...
  • 文章目录synchronized线程安全主要诱因互斥锁特性获取对象锁同对象,异步同对象,同步代码块同对象,非静态同步方法同对象,同步代码块 对比 非...知识补充同步块-字节码分析同步方法体-字节码分析为什么会对synchro
  • 异步编程原理以及Java实现

    万次阅读 多人点赞 2019-03-30 14:16:11
    说实话多线程和异步是非常容易让人混淆的,好像产生的效果差不多,甚至有人称多线程为异步,实际上这两种技术背后的实现原理是不同的。 假设您有2个任务,不涉及任何IO(在多处理器机器上)。在这种情况下,线程...
  • java线程同步原理

    千次阅读 2012-09-12 14:43:31
    java线程同步原理 java会为每个object对象分配一个monitor,当某个对象的同步方法(synchronized methods)被多个线程调用时,该对象的monitor将负责处理这些访问的并发独占要求。 当一个线程调用一个对象的同步...
  • 对代码进行同步控制我们可以选择同步方法,也可以选择同步块,这两种方式各有优缺点。同步块不仅可以更加精确的控制对象锁,还可以控制锁的作用域,何谓锁的作用域?锁的作用域就是从锁被获取到其被释放的时间。而且...
  • java定时器之Timer使用与原理分析

    万次阅读 2018-11-07 16:10:15
    // 如果任务执行时间大于当前时间说明任务还没点,继续等,否则执行run代码 if (!taskFired) // Task hasn't yet fired; wait queue.wait(executionTime - currentTime); } if (taskFired) // Task fired; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 108,540
精华内容 43,416
关键字:

java 同步块原理

java 订阅