首页 > 编程语言 >深入研究synchronized:解锁高效多线程编程的秘诀

深入研究synchronized:解锁高效多线程编程的秘诀

时间:2023-11-04 21:34:38浏览次数:36  
标签:NULL synchronized 解锁 线程 owner 多线程 Self 偏向

大家好,我是老七,点个关注吧,将持续更新更多精彩内容!

深入研究synchronized:解锁高效多线程编程的秘诀_java


在Java的多线程编程里,让多个线程能够安全、高效地协同工作是非常重要的。

而synchronized这个关键字,就是一个很重要的工具,可以帮助我们实现多线程同步。

本文会深入讨论synchronized的作用、使用方法、工作原理,以及它和其他锁机制的比较。

还会分享一些使用synchronized的最佳实践和注意事项,以及在不同版本的JVM中,synchronized的优化内容和实现细节。

这样,我们就可以更好地满足高级开发者的需求了。

介绍synchronized关键字

synchronized是Java中的一个关键字,它特别重要,就像一个交通警察,指挥多线程这个路口的交通。

在多线程一起工作时,它们可能会同时想要使用同一个资源,就像几辆车同时想进入一个狭窄的车道。

这时,synchronized就出场了,它的作用是确保在任何时候都只有一个线程能够使用这个资源,这样就能避免因为同时使用同一个资源而引起的数据冲突和不一致的问题。

synchronized的使用方式和示例

synchronized关键字可以应用在不同的地方,包括方法级别、代码块级别以及静态方法级别。下面我们将介绍不同用法并提供示例。

方法级别的synchronized

当一个方法被声明为synchronized时,只有一个线程可以同时访问该方法。它锁住的是当前对象,其他线程必须等待直到当前线程退出该方法。下面是一个简单的示例:

public synchronized void test() { 
  // 同步方法的代码 
}

代码块级别的synchronized

除了方法级别的同步,我们还可以使用synchronized关键字创建同步代码块。这使得我们可以更灵活地控制哪部分代码需要同步。下面是一个示例:

public void test() { 
      // 一些非同步代码 
      synchronized (this) { 
      // 需要同步的代码块
      } 
      // 更多非同步代码
}

静态方法级别的synchronized

静态方法级别的synchronized是应用在静态方法上的,它锁住的是类级别的资源,而不是实例级别的资源。示例:

public static synchronized void test() { 
  // 静态同步方法的代码 
}

synchronized的优化

在JDK1.5的时候推出了ReentrantLock,性能远高于synchronized,所以JDK团队就在JDK1.6中,对synchronized做了大量的优化,从而衍生出了一些新的概念。

锁消除:在synchronized修饰的代码中,如果不存在操作临界资源的情况,会触发锁消除,你即便写了synchronized,他也不会触发。

public synchronized void test(){
    // 没有操作临界资源
    // 此时这个方法的synchronized你可以认为无效
}

锁膨胀:如果在一个循环中,频繁的获取和释放做资源,这样带来的消耗很大,锁膨胀就是将锁的范围扩大,避免频繁的竞争和获取锁资源带来不必要的消耗。

public void test(){
    for(int i = 0;i < 999999;i++){
        synchronized(对象){

        }
    }
    // 这是上面的代码会触发锁膨胀
    synchronized(对象){
        for(int i = 0;i < 999999;i++){

        }
    }
}

锁升级:ReentrantLock的实现,是先基于乐观锁的CAS尝试获取锁资源,如果拿不到锁资源,才会挂起线程。synchronized在JDK1.6之前,完全就是获取不到锁,立即挂起当前线程,所以synchronized性能比较差。

synchronized就在JDK1.6做了锁升级的优化

  • 无锁、匿名偏向:当前对象没有作为锁存在。
  • 偏向锁:如果当前锁资源,只有一个线程在频繁的获取和释放,那么这个线程过来,只需要判断,当前指向的线程是否是当前线程 。
  • 如果是,直接拿着锁资源走。
  • 如果当前线程不是我,基于CAS的方式,尝试将偏向锁指向当前线程。如果获取不到,触发锁升级,升级为轻量级锁。(偏向锁状态出现了锁竞争的情况)
  • 轻量级锁:会采用自旋锁的方式去频繁的以CAS的形式获取锁资源(采用的是自适应自旋锁
  • 如果成功获取到,拿着锁资源走
  • 如果自旋了一定次数,没拿到锁资源,锁升级。
  • 重量级锁:就是最传统的synchronized方式,拿不到锁资源,就挂起当前线程。(用户态&内核态)

synchronized实现原理

synchronized是基于对象实现的。

先要对Java中对象在堆内存的存储有一个了解。


深入研究synchronized:解锁高效多线程编程的秘诀_锁_02

展开MarkWord

深入研究synchronized:解锁高效多线程编程的秘诀_多线程_03

MarkWord中标记着四种锁的信息:无锁、偏向锁、轻量级锁、重量级锁。

synchronized的锁升级

锁默认情况下,开启了偏向锁延迟。

偏向锁在升级为轻量级锁时,会涉及到偏向锁撤销,需要等到一个安全点(STW),才可以做偏向锁撤销,在明知道有并发情况,就可以选择不开启偏向锁,或者是设置偏向锁延迟开启

因为JVM在启动时,需要加载大量的.class文件到内存中,这个操作会涉及到synchronized的使用,为了避免出现偏向锁撤销操作,JVM启动初期,有一个延迟4s开启偏向锁的操作

如果正常开启偏向锁了,那么不会出现无锁状态,对象会直接变为匿名偏向

public static void main(String[] args) throws InterruptedException {
    Thread.sleep(5000);
    Object o = new Object();
    System.out.println(ClassLayout.parseInstance(o).toPrintable());

    new Thread(() -> {

        synchronized (o){
            //t1  - 偏向锁
            System.out.println("t1:" + ClassLayout.parseInstance(o).toPrintable());
        }
    }).start();
    //main - 偏向锁 - 轻量级锁CAS - 重量级锁
    synchronized (o){
        System.out.println("main:" + ClassLayout.parseInstance(o).toPrintable());
    }
}

整个锁升级状态的转变:


深入研究synchronized:解锁高效多线程编程的秘诀_锁_04

Lock Record以及ObjectMonitor存储的内容

深入研究synchronized:解锁高效多线程编程的秘诀_多线程_05

重量锁底层ObjectMonitor

需要去找到openjdk,在百度中直接搜索openjdk,第一个链接就是

找到ObjectMonitor的两个文件,hpp,cpp

ObjectMonitor() {
    _header       = NULL;   // header存储着MarkWord
    _count        = 0;      // 竞争锁的线程个数
    _waiters      = 0,      // wait的线程个数
    _recursions   = 0;      // 标识当前synchronized锁重入的次数
    _object       = NULL;
    _owner        = NULL;   // 持有锁的线程
    _WaitSet      = NULL;   // 保存wait的线程信息,双向链表
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;  // 获取锁资源失败后,线程要放到当前的单向链表中
    FreeNext      = NULL ;
    _EntryList    = NULL ;  // _cxq以及被唤醒的WaitSet中的线程,在一定机制下,会放到EntryList中
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
    _previous_owner_tid = 0;
  }

C++中实现的加锁流程

TryLock

int ObjectMonitor::TryLock (Thread * Self) {
   for (;;) {
      // 拿到持有锁的线程
      void * own = _owner ;
      // 如果有线程持有锁,告辞
      if (own != NULL) return 0 ;
      // 说明没有线程持有锁,own是null,cmpxchg指令就是底层的CAS实现。
      if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
         // 成功获取锁资源
         return 1 ;
      }
      // 这里其实重试操作没什么意义,直接返回-1
      if (true) return -1 ;
   }
}

try_entry

bool ObjectMonitor::try_enter(Thread* THREAD) {
  // 在判断_owner是不是当前线程
  if (THREAD != _owner) {
    // 判断当前持有锁的线程是否是当前线程,说明轻量级锁刚刚升级过来的情况
    if (THREAD->is_lock_owned ((address)_owner)) {
       _owner = THREAD ;
       _recursions = 1 ;
       OwnerIsThread = 1 ;
       return true;
    }
    // CAS操作,尝试获取锁资源
    if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
      // 没拿到锁资源,告辞
      return false;
    }
    // 拿到锁资源
    return true;
  } else {
    // 将_recursions + 1,代表锁重入操作。
    _recursions++;
    return true;
  }
}

enter(想方设法拿到锁资源,如果没拿到,挂起扔到_cxq单向链表中)

void ATTR ObjectMonitor::enter(TRAPS) {
  // 拿到当前线程
  Thread * const Self = THREAD ;
  void * cur ;
  // CAS走你,
  cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
  if (cur == NULL) {
     // 拿锁成功
     return ;
  }
  // 锁重入操作
  if (cur == Self) {
     // TODO-FIXME: check for integer overflow!  BUGID 6557169.
     _recursions ++ ;
     return ;
  }
  //轻量级锁过来的。
  if (Self->is_lock_owned ((address)cur)) {
    _recursions = 1 ;
    _owner = Self ;
    OwnerIsThread = 1 ;
    return ;
  }


  // 走到这了,没拿到锁资源,count++
  Atomic::inc_ptr(&_count);

  
    for (;;) {
      jt->set_suspend_equivalent();
      // 入队操作,进到cxq中
      EnterI (THREAD) ; //看下面的代码
      if (!ExitSuspendEquivalent(jt)) break ;
      _recursions = 0 ;
      _succ = NULL ;
      exit (false, Self) ;
      jt->java_suspend_self();
    }
  }
  // count--
  Atomic::dec_ptr(&_count);
  
}

EnterI

for (;;) {
    // 入队
    node._next = nxt = _cxq ;
    // CAS的方式入队。
    if (Atomic::cmpxchg_ptr (&node, &_cxq, nxt) == nxt) break ;

    // 重新尝试获取锁资源
    if (TryLock (Self) > 0) {
        assert (_succ != Self         , "invariant") ;
        assert (_owner == Self        , "invariant") ;
        assert (_Responsible != Self  , "invariant") ;
        return ;
    }
}

如果各位觉得老七的文章还不错的话,麻烦大家动动小手,

点赞、关注、转发走一波!!

有任何问题可以评论区留言或者私信我,我必将知无不言言无不尽!

标签:NULL,synchronized,解锁,线程,owner,多线程,Self,偏向
From: https://blog.51cto.com/u_16277888/8185181

相关文章

  • Java多线程
    构造方法//参数最全的构造方法publicThreadPoolExecutor(intcorePoolSize,//核心线程数intmaximumPoolSize,//最大线程数longkeepAliveTime,//非核心线程最长等待新任务的时间TimeUnituni......
  • 01-02异步多线程基础概念
    任何异步多线程都离不开委托delegate--lambda-action/Func委托的异步调用异步多线程:发起调用,不等待结束就直接进入下一行(主线程)动作会有新的线程执行.线程特点特点一:多线程和界面使用(说白了,多线程就是为了给大量计算创建子线程,然后先执行完后面代码)场......
  • C++使用多线程将数据写入文件
    #include<iostream>#include<vector>#include<thread>#include<fstream>//使用多线程将数据写入文件voidwriteToFile(conststd::vector<std::string>&data,conststd::string&filename){//创建一个文件输出流std::ofstreamfile......
  • Task异步多线程
    不废话,直接贴上代码...【1】直接实现多线程:`usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;namespaceTask异步多线程{classProgram{staticvoidMain(string[]args){......
  • java网络编程与多线程
      一、Java 网络编程网络编程是指编写运行在多个设备(计算机)的程序,这些设备都通过网络连接起来。java.net包中J2SE的API包含有类和接口,它们提供低层次的通信细节。你可以直接使用这些类和接口,来专注于解决问题,而不用关注通信细节。java.net包中提供了两种常见的网络......
  • JAVA多线程之线程间的通信方式
    一,介绍本总结我对于JAVA多线程中线程之间的通信方式的理解,主要以代码结合文字的方式来讨论线程间的通信,故摘抄了书中的一些示例代码。 二,线程间的通信方式①同步这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信。参考示例:publicclassMyObj......
  • 定时任务@Scheduled之单线程多线程问题
    现象在一个类内,写了两个定时任务,发现它们竟然是串行执行的。于是想到,@Scheduled该不会是单线程执行折吧?于是找了一下,发现还真的是。。。可参考:https://blog.csdn.net/Mr_EvanChen/article/details/103408290解决方案1、ScheduledTaskRegistrar有一个setScheduler()方......
  • C 语言多线程基础
    ......
  • C#多线程异常捕获
    C#线程可分为前台线程和后台线程。Thread可以使用IsBackground来设置前后台属性,Task已经取消这种设置方式。 可以简单的认为,全局线程是前台线程,局部线程是后台线程。类似变量的生命周期,全局线程执行完还可以获取状态,局部线程执行完直接释放。后台(局部)线程不会抛出异常。需......
  • Spring Boot - @Transactional 标注的方法如何使用 synchronized?
    这篇文章中有说到@Transactional标注的方法也有锁的情况下会出现一些问题,具体请看SpringBoot锁。而且Idea也会标一个黄色波浪线提示你。我是这样做的,仅供参考。file:[DiscussionService.java]@ServicepublicclassDiscussionServiceimplementsIDiscussionService{......