由浅入深了解synchronized关键字

最新推荐文章于 2023-04-08 07:45:00 发布
最新推荐文章于 2023-04-08 07:45:00 发布
阅读量227 收藏
点赞数
分类专栏： # Java虚拟机 文章标签： synchronized 偏向锁 重偏向 轻量级锁 重量级锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiaMen_BuYu/article/details/107595051
版权

简介

本文主要介绍synchronized的用法，功能，原理，以及最后通过实验数据验证。

用法

使用synchronized关键字对方法或者代码块进行修饰，来实现多线程下加锁的目的，具体用法如下：

介绍代码功能
修饰静态方法public synchronized static void add() {}对类对象进行加锁
修饰实例方法public synchronized void add() {}对类实例进行加锁
修饰代码块-类对象synchronized (Obj.class){}对类对象进行加锁
修饰代码块-类实例Obj obj = new Obj(); synchronized (obj){}对类实例进行加锁

原理

基础介绍

上章节提到synchronized可以修饰实例对象或者类对象，不管类对象还是实例对象，都是继承自java.lang.Object，每个Object对象都有一个Monitor属性，Monitor属性是用于控制对象的访问权限（也就是加锁）。synchronized关键字会操作Monitor，通过汇编指令可以看出。如果有synchronized关键字都会有monitorenter和monitorexit指令。

 monitorenter
 ......
 monitorexit

Monitor是通过C++实现，信息保存在对象头部中的MarkWord，后面会详细介绍。如果对这部分源码感兴趣的朋友可以下载OpenJDK的源码进行阅读。

锁膨胀流程介绍

synchronized锁的升级分为四个过程：无锁->偏向锁->轻量级锁->重量级锁，具体如下图所示（该图来自https://wiki.openjdk.java.net/display/HotSpot/Synchronization）
在这里插入图片描述
按上图的描述，可以看出有区分是否支持偏向锁。下面只说明支持偏向锁的情况：

  1. 分配对象时，默认为匿名向锁；
  2. 当对象第一次被线程获取时，获取线程信息记录到对象的MarkWord中；
  3. 当另一个线程要获取锁时，偏向模式就会结束，会根据对象状态进行重偏向（rebias）,未锁定，轻量锁；
  4. 多线程同时尝试获取锁，各个线程通过自旋（也就是递归加锁recursive lock）方式都可以获取锁，膨胀为轻量级锁；
  5. 当存在线程通过自旋锁获取失败时，膨胀为重量级锁。

Mark Word内容介绍

java中对象头由Mard Word、Klass Pointer（类型指针，对象指向它的类元数据的指针，虚拟机通过这个指针确定这个对象是哪个类的实例）。接下来重点介绍Mark Word的内容：

Mark Word (64bit，其中的数字指长度)锁状态
unused:25 + hashcode:31 + unused:1 + age:4 + biased_lock:1 + lock:2正常无锁（01）
thread:54 + epoch:2 + unused:1 + age:4 + biased_lock:1 + lock:2偏向锁（01）
ptr_to_lock_record:62 + lock:2轻量级锁（00）
ptr_to_heavyweight_monitor:62 + lock:2重量级锁（10）

验证

需要使用jol-core.jar包，添加依赖：

 <dependency>
   <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.10</version>
</dependency>

加锁对象如下：

public class Obj {

    public int sum = 0;

    public synchronized void add(final long time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sum++;
    }

}

偏向锁

synchronizedi修饰类对象时，不支持偏向锁。

偏向锁VM参数查看命令

  • Window：java -XX:+PrintFlagsFinal -version | findstr BiasedLocking
  • Linux：java -XX:+PrintFlagsFinal -version | grep BiasedLocking
C:\Users\guoyu.huang>java -XX:+PrintFlagsFinal -version | findstr BiasedLocking
     intx BiasedLockingBulkRebiasThreshold          = 20                                  {product}
     intx BiasedLockingBulkRevokeThreshold          = 40                                  {product}
     intx BiasedLockingDecayTime                    = 25000                               {product}
     intx BiasedLockingStartupDelay                 = 4000                                {product}
     bool TraceBiasedLocking                        = false                               {product}
     bool UseBiasedLocking                          = true                                {product}
  • BiasedLockingBulkRebiasThreshold：批量重新偏向临界值，默认值20
  • BiasedLockingBulkRevokeThreshold：批量撤销偏向临界值，默认值40
  • BiasedLockingDecayTime：重置计数的时间，默认值为25000毫秒
  • BiasedLockingStartupDelay：偏向锁延迟时间，默认值4000毫秒
  • TraceBiasedLocking：是否追踪偏向锁，默认值false
  • UseBiasedLocking：是否使用偏向锁，默认值true

BiasedLockingStartupDelay单位是毫秒

偏向锁实现方式

  1. 根据对象的Mark Word确定为偏向模式
  2. 通过CAS操作，将获取对象锁的线程信息记录在对象的Mark Word中
  3. 偏向锁没有释放锁的操作，一直记录着持有偏向锁的线程信息，这样可以减少同步操作（例如：Locking、UnLocking以及修改Mark Word操作）。

偏向锁终止条件

当存在另一个线程去尝试获取这个对象锁，偏向模式才结束。

测试代码

/**
 * 验证偏向锁
 * <pre>
 *      默认偏向锁有延迟，为了测试方便，直接设置0延迟
 *      VM参数：-XX:BiasedLockingStartupDelay=0
 * </pre>
 *
 * @throws InterruptedException
 */
public static void testBiasedLocking() throws InterruptedException {
	// 该类无任何属性和函数
    Obj obj = new Obj();

    System.out.println("初始内容----------------------");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());

    synchronized (obj) {
        System.out.println("偏向内容----------------------");
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}

日志说明

初始内容----------------------
java.lang.Object object internals:
 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)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

偏向内容----------------------
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 38 ca 02 (00000101 00111000 11001010 00000010) (46807045)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

根据以上日志可以看出，刚开始时为101，偏向线程为空，表示匿名偏向锁，当第一个线程获取到锁之后，将锁的偏向线程改成当前线程。

重偏向

A similar mechanism, called bulk rebiasing, optimizes situations in which objects of a class are locked and unlocked by different threads but never concurrently. It invalidates the bias of all instances of a class without disabling biased locking. An epoch value in the class acts as a timestamp that indicates the validity of the bias. This value is copied into the header word upon object allocation. Bulk rebiasing can then efficiently be implemented as an increment of the epoch in the appropriate class. The next time an instance of this class is going to be locked, the code detects a different value in the header word and rebiases the object towards the current thread.
一个类似的机制称为批量重偏，它优化了由不同线程锁定和解锁类对象但从不并发的情况。它使类的所有实例的偏向失效，而不禁用偏向锁。类中的epoch值充当时间戳，指示偏差的有效性。此值在对象分配时复制到头字中。批量再偏可以有效地实现为适当类中的历元的增量。下一次锁定这个类的实例时，代码在头字中检测到一个不同的值，并将对象重新定位到当前线程。来自：OpenJDK

触发条件

在没有并发情况下，一个类对象下类实例获取锁的线程发生变化，当达到BiasedLockingBulkRebiasThreshold值时，会发生重偏向。

测试代码

/**
 * 测试重偏向
 * <pre>
 *      默认偏向锁有延迟，为了测试方便，直接设置0延迟： -XX:BiasedLockingStartupDelay=0
 *      跟踪偏向锁：-XX:+TraceBiasedLocking
 * </pre>
 *
 * @throws InterruptedException
 */
public static void testRebias() throws InterruptedException {

    List<Obj> objList = new ArrayList<>();

    new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            Obj obj = new Obj();
            synchronized (obj) {
                objList.add(obj);
            }
        }
        try {
            //为了防止JVM线程复用，在创建完对象后，保持线程存活状态
            Thread.sleep(100000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();

    Thread.sleep(3000);
    System.out.println("objList中第20个对象的偏向内容----------------------");
    System.out.println((ClassLayout.parseInstance(objList.get(19)).toPrintable()));

    //创建另一个线程去竞争之前线程中已经退出同步块的锁
    new Thread(() -> {
        for (int i = 0; i < 20; i++) {
            Obj obj = objList.get(i);
            synchronized (obj) {
                if (i == 18 || i == 19) {
                    System.out.println("第" + (i + 1) + "次偏向结果");
                    System.out.println((ClassLayout.parseInstance(obj).toPrintable()));
                }
            }
        }
        try {
            Thread.sleep(10000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();
}

日志分析

objList中第20个对象的偏向内容----------------------
cn.hgy.jol.Obj object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 88 e8 1f (00000101 10001000 11101000 00011111) (535332869)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

第19次偏向结果
cn.hgy.jol.Obj object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           30 f3 7c 20 (00110000 11110011 01111100 00100000) (545059632)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

第20次偏向结果
cn.hgy.jol.Obj object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 69 dc 1e (00000101 01101001 11011100 00011110) (517761285)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

根据日志可以看出同一个实例，在第一次打印时持有偏向锁的线程和第二次发生偏向的线程不是同一个线程。

撤销偏向

当偏向发生了撤销偏向之后，就会禁用偏向。

// TODO 未研究透彻

static HeuristicsResult update_heuristics(oop o, bool allow_rebias) {
  markOop mark = o->mark();
  if (!mark->has_bias_pattern()) {
    return HR_NOT_BIASED;
  }

  Klass* k = o->klass();
  jlong cur_time = os::javaTimeMillis();
  jlong last_bulk_revocation_time = k->last_biased_lock_bulk_revocation_time();
  int revocation_count = k->biased_lock_revocation_count();
  if ((revocation_count >= BiasedLockingBulkRebiasThreshold) &&
      (revocation_count <  BiasedLockingBulkRevokeThreshold) &&
      (last_bulk_revocation_time != 0) &&
      (cur_time - last_bulk_revocation_time >= BiasedLockingDecayTime)) {
    k->set_biased_lock_revocation_count(0);
    revocation_count = 0;
  }

  // Make revocation count saturate just beyond BiasedLockingBulkRevokeThreshold
  if (revocation_count <= BiasedLockingBulkRevokeThreshold) {
    revocation_count = k->atomic_incr_biased_lock_revocation_count();
  }

  if (revocation_count == BiasedLockingBulkRevokeThreshold) {
    return HR_BULK_REVOKE;
  }

  if (revocation_count == BiasedLockingBulkRebiasThreshold) {
    return HR_BULK_REBIAS;
  }

  return HR_SINGLE_REVOKE;
}

轻量级锁

触发条件

当存在多个线程竞争同一把锁时，每个线程等待的时间都不长（通过自旋都可以获得锁）。

测试代码

/**
 * 轻量锁
 * <pre>
 *      默认偏向锁有延迟，为了测试方便，直接设置0延迟
 *      VM参数：-XX:BiasedLockingStartupDelay=0
 * </pre>
 *
 * @throws InterruptedException
 */
public static void testLightweight() throws InterruptedException {
    
    Obj obj = new Obj();

    new Thread(() -> {
        synchronized (obj) {
            try {
                Thread.sleep(400);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();

    Thread.sleep(200);

    System.out.println("----------------------");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    
    new Thread(() -> {
        synchronized (obj) {
            System.out.println("T2----------------------");
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        }

    }).start();

    Thread.sleep(200);

    System.out.println("----------------------");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());

}

日志分析

----------------------
cn.hgy.jol.Obj object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 30 a0 1e (00000101 00110000 10100000 00011110) (513814533)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

T2----------------------
cn.hgy.jol.Obj object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           40 f3 0a 20 (01000000 11110011 00001010 00100000) (537588544)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

----------------------
cn.hgy.jol.Obj 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)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

第一个线程通过CAS成功修改对象的MarkWord，获取偏向锁，持有锁的时间为400毫秒；第二个线程在200毫秒后启动，通过CAS修改对象的MarkWord失败，JVM将该对象的锁升级为轻量级锁；此时第二个线程进行自旋，也就不断的执行CAS操作，最终在允许自旋的最大时间内获取锁。

重量级锁

触发条件

当存在多个线程竞争同一把锁时，存在线程通过自旋无法获得锁。

测试代码

同轻量锁的测试代码相似，修改第一个线程的持锁时间。

/**
 * 重量锁
 * <pre>
 *      默认偏向锁有延迟，为了测试方便，直接设置0延迟
 *      VM参数：-XX:BiasedLockingStartupDelay=0
 * </pre>
 *
 * @throws InterruptedException
 */
public static void testHeavyweight() throws InterruptedException {
    Obj obj = new Obj();

    new Thread(() -> {
        synchronized (obj) {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();

    Thread.sleep(200);

    System.out.println("----------------------");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());

    new Thread(() -> {
        synchronized (obj) {
            System.out.println("T2----------------------");
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        }

    }).start();

    Thread.sleep(5000);

    System.out.println("----------------------");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
}

日志分析

----------------------
cn.hgy.jol.Obj object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 38 b1 1f (00000101 00111000 10110001 00011111) (531707909)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

T2----------------------
cn.hgy.jol.Obj object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           3a 0a b3 1c (00111010 00001010 10110011 00011100) (481495610)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

----------------------
cn.hgy.jol.Obj 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)                           92 c3 00 f8 (10010010 11000011 00000000 11111000) (-134167662)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

第一个线程通过CAS成功修改对象的MarkWord，获取偏向锁，持有锁的时间为5000毫秒；第二个线程在200毫秒后启动，通过CAS修改对象的MarkWord失败，JVM将该对象的锁升级为轻量锁；此时第二个线程进行自旋，在允许自旋的最大时间内无法获取锁，则将该对象的锁膨胀为重量级锁。

参考资料

  1. OpenJDK-Synchronization
  2. 周志明-深入理解Java虚拟机 第2版
  3. 简书-白龙6-JOL工具分析java对象大小
  4. 简书-biudefu-并发编程-（5）
瑾析编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java并发编程实战范例（由浅入深代码范例和详细说明）.docx
06-15
Java 提供了多种同步机制，如 synchronized 关键字、Lock 接口等。在这个例子中，我们使用了 Lock 接口的实现类 ReentrantLock。 2. **ReentrantLock（可重入锁）**：ReentrantLock 是一个可重入、互斥的锁，它提供...
java并发编程实战范例（由浅入深代码范例和详细说明）（合集）.docx
06-28
Java提供了丰富的并发工具和API，包括线程（Thread）、线程池（ExecutorService）、锁（synchronized关键字和Lock接口）、并发容器（如ConcurrentHashMap、ConcurrentLinkedQueue等）以及原子变量（Atomic*类）等。...
Java并发编程(5) —— synchronized关键字详解
m0_56602092的博客
04-07 359
在上一篇中我们提到了volatile关键字可通过插入内存屏障的方式来保证变量的可见性（每次使用都到主存中进行读取）和有序性（不允许指令重排序），但是volatile关键字不保证对变量复合操作的原子性，例如i++操作在jvm层面实际上是通过多条指令操作完成，而若用synchronized 关键字将操作代码块包起来，则同一时刻只有一个线程能进入进行操作，这就保证了原子性。 在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。这是因为监视器锁（monitor）是依赖于底层的操作系统的
synchronized关键字全解
全栈行动派的博客
04-08 249
能用无锁数据结构，就不要用锁;能锁区块，就 不要锁整个方法体;能用对象锁，就不要用类锁。无锁最好，有锁也要控制锁的范围。锁的范围大小：方法内区块锁
synchronized关键字用法总结
weixin_30363509的博客
09-13 64
转载原文：http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html 关于synchronized关键字的详细解析，这篇博文讲的十分通透，在此先赞美一下这位大牛由浅入深的讲解。 好记性不如烂笔头，在此记录下自己的所知所得。 synchronized可以修饰方法，也可以修饰代码块，以实现同步的目的。 1、synchroniz...
大厂之路一由浅入深、并行基础、源码分析一synchronized关键字,以及相应优化
置身于量子事业的软件开发爱好者
05-28 707
文章部分引用于：点击如下！！！！ synchronized原理 在java中，每一个对象 （ 注意：对象的重要性。) 有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。 当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。例如，synchronized(obj)就获取了 “obj这个对象” 的同步锁。 不同线程对同步锁的访问是互斥的。也就是说，同一个时间点，只有一个线程能得到对象锁。 synchronized基本规则（3条） 当一个线程访问“某对象”的 ..
由浅入深逐步了解 Synchronized
十指波课堂的博客
12-02 227
使用synchronized关键字是Java并发编程中线程同步的常用手段之一，其作用有三个:1、互斥性：确保线程互斥的访问同步代，锁自动释放，多个线程操作同个代码块或函数必须排队获得锁，2、可见性：保证共享变量的修改能够及时可见，获得锁的线程操作完毕后会将所数据刷新到共享内存区[1]3、有序性：有效解决重排序问题synchronized用法有三个:1、修饰实例方法2、修饰静态方法3、修饰代码块1....
java 线程由浅入深_Java多线程：由浅入深看synchronized的底层实现原理
weixin_30696613的博客
02-27 55
Java多线程：由浅入深看synchronized的底层实现原理-1.jpg (91.72 KB, 下载次数: 0)2018-9-21 03:55 上传前言前俩篇文章，我们聊了聊线程/进程的概念，接着简单串了一下同步的体例体例。今天我们就单拎出来synchronized，好好捋一捋它的前世今生。正文小A：咱们前几天铺垫了这么多内容，今天是不是要好好的深挖一下原理的内容了？MDove：没错，接下来。...
java多线程synchronized_Java多线程：由浅入深看synchronized的底层实现原理
weixin_32626635的博客
02-12 68
前言前两篇文章，我们聊了聊线程/进程的概念，接着简单串了一下同步的方式方法。今天我们就单拎出来synchronized，好好捋一捋它的前世今生。正文小A：咱们前几天铺垫了这么多内容，今天是不是要好好的深挖一下原理的内容了？MDove：没错，接下来。我会从常见的synchronized加锁方式入手；引出Java对象在内存的布局，以及锁的存放位置；然后看一看锁在C++中的简单实现思路；最后咱们从字节码...
Synchronized的由浅入深
u012933335的博客
03-12 185
Synchronized的由浅入深 一. 使用 synchronized可用来修饰实例方法，静态方法和代码块，其作用是为了保证被修饰的方法或代码块在同一时间内，只有一个线程可以执行。那么我们先看看如何使用，因重点不是介绍使用，会快速而简单的介绍下。 public class TestSynchronized { private static int count = 0; public synchronized void increase() { for (int i =
synchronized锁由浅入深解析
狐言
04-03 293
一：几种锁的概念 1.1 自旋锁 自旋锁，当一个线程去获取锁时，如果发现锁已经被其他线程获取，就一直循环等待，然后不断的判断是否能够获取到锁，一直到获取到锁后才会退出循环。 1.2 乐观锁 乐观锁，是假设不会发生冲突，当去修改值的时候才判断是否和自己获得的值是一样的（CAS的实现，值也可以是版本号），如果一样就更新值，否则就再次去读取值，然后比较再更新。就是说每...
由浅入深——Java 2自学教程 配书光盘.rar
05-24
同步机制（如synchronized关键字、wait()和notify()方法）确保了多线程环境下的数据安全。 6. **输入输出流**：Java 2的I/O流系统允许程序进行文件读写、网络通信等。InputStream和OutputStream是字节流的基础，而...
java并发编程实战范例合集new（由浅入深代码范例和详细说明）.docx
06-16
3. **同步机制**：Java 提供了多种同步机制，包括 synchronized 关键字、`wait()`, `notify()`, `notifyAll()` 方法、`Lock` 接口及其实现类（如 `ReentrantLock`）等，用于控制多个线程对共享资源的访问。...
java由浅到深必了解的题
04-09
- 学习使用synchronized、volatile、ThreadLocal等关键字解决并发问题。 - 掌握线程池的使用，如ExecutorService和Future。 8. **网络编程**： - 网络编程涉及Socket、ServerSocket等类，理解TCP/IP协议，实现...
基于Springboot和Vue的数码论坛系统设计与实现-源码 数码论坛系统设计与实现代码（高分毕设）
最新发布
07-24
数码论坛系统设计与实现-源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
java程序设计—JAVA局域网飞鸽传书软件设计与实现(源代码+论文)43.rar
07-24
java程序设计，可供正在学习的同学研究参考。
年终总结汇报PPT模板(20)三套材料.pptx
07-24
年终总结汇报PPT模板(20)三套材料.pptx
ListView侧边A-Z快速定位导航.zip
07-24
ListView侧边A-Z快速定位导航
synchronized 关键字的了解
04-09
synchronized是Java中的一个关键字，用于实现线程的同步。它可以用于修饰方法或代码块，确保在同一时间只有一个线程可以访问被synchronized修饰的代码段。 当一个线程进入synchronized修饰的方法或代码块时，它会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

瑾析编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值