Java并发机制----同步synchronized以及原子操作

最新推荐文章于 2023-10-30 10:37:54 发布

huaishu

最新推荐文章于 2023-10-30 10:37:54 发布

阅读量369

点赞数

分类专栏： Java JVM 线程并发库

本文链接：https://blog.csdn.net/huaishu/article/details/103140435

版权

Java 同时被 3 个专栏收录

40 篇文章 1 订阅

订阅专栏

JVM

33 篇文章 1 订阅

订阅专栏

线程并发库

23 篇文章 0 订阅

订阅专栏

Java并发编程过程中必须接触synchronized和volatile，以及后来的读写锁ReadWriteLock、重入锁ReentrantLock等，JVM在编译synchronized时会生成2个指令集monitorenter和monitorexit，volatile则实现

1）将当前处理器缓存行的数据写回到系统内存。
2）这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效。

synchronized可以使用在普通同步方法（当前实例）、静态方法（当前Class对象）、同步方法块（括号配置对象），JVM基于进入和退出Monitor对象来实现方法同步和代码块同步。

Monitor对象有什么不一样，或者说对象和对象到底有什么不一样，JVM通过定义对象头来标识不同对象，对象头这个元元素需要好好理解才能了解JVM是怎么实现锁的。

对象头是占用空间的，很多开源项目会重写数据结构，不使用JVM这样重的对象结构。

32位JVM为例

对象头形式

普通对象

|--------------------------------------------------------------|
|                     Object Header (64 bits)                  |
|------------------------------------|-------------------------|
|        Mark Word (32 bits)         |    Class Word (32 bits) |
|------------------------------------|-------------------------|

数组对象

|---------------------------------------------------------------------------------|
|                                 Object Header (96 bits)                         |
|--------------------------------|-----------------------|------------------------|
|        Mark Word(32bits)       |    Class Word(32bits) |  Array length(32bits)  |
|--------------------------------|-----------------------|------------------------|

对象头的组成

Mark Word

|-------------------------------------------------------|--------------------|
|                  Mark Word (32 bits)                  |       State        |
|-------------------------------------------------------|--------------------|
| identity_hashcode:25 | age:4 | biased_lock:1 | lock:2 |       Normal       |
|-------------------------------------------------------|--------------------|
|  thread:23 | epoch:2 | age:4 | biased_lock:1 | lock:2 |       Biased       |
|-------------------------------------------------------|--------------------|
|               ptr_to_lock_record:30          | lock:2 | Lightweight Locked |
|-------------------------------------------------------|--------------------|
|               ptr_to_heavyweight_monitor:30  | lock:2 | Heavyweight Locked |
|-------------------------------------------------------|--------------------|
|                                              | lock:2 |    Marked for GC   |
|-------------------------------------------------------|--------------------|

各部分的含义如下：
lock:2位的锁状态标记位，由于希望用尽可能少的二进制位表示尽可能多的信息，所以设置了lock标记。该标记的值不同，整个mark word表示的含义不同。

biased_lock	lock	状态
0	01	无锁（Normal）
1	01	偏向锁（Biased）
0	00	轻量级锁（Lightweight Locked）
0	10	重量级锁（Heavyweight Locked）
0	11	GC标记（Marked for GC）

biased_lock：对象是否启用偏向锁标记，只占1个二进制位。为1时表示对象启用偏向锁，为0时表示对象没有偏向锁。
age：4位的Java对象年龄。在GC中，如果对象在Survivor区复制一次，年龄增加1。当对象达到设定的阈值时，将会晋升到老年代。默认情况下，并行GC的年龄阈值为15，并发GC的年龄阈值为6。由于age只有4位，所以最大值为15，这就是
-XX:MaxTenuringThreshold选项最大值为15的原因。
identity_hashcode：25位的对象标识Hash码，采用延迟加载技术。调用方法System.identityHashCode()计算，并会将结果写到该对象头中。当对象被锁定时，该值会移动到管程Monitor中。
thread：持有偏向锁的线程ID。
epoch：偏向时间戳。
ptr_to_lock_record：指向栈中锁记录的指针。
ptr_to_heavyweight_monitor：指向管程Monitor的指针。

64位下的标记

|------------------------------------------------------------------------------|--------------------|
|                                  Mark Word (64 bits)                         |       State        |
|------------------------------------------------------------------------------|--------------------|
| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |       Normal       |
|------------------------------------------------------------------------------|--------------------|
| thread:54 |       epoch:2        | unused:1 | age:4 | biased_lock:1 | lock:2 |       Biased       |
|------------------------------------------------------------------------------|--------------------|
|                       ptr_to_lock_record:62                         | lock:2 | Lightweight Locked |
|------------------------------------------------------------------------------|--------------------|
|                     ptr_to_heavyweight_monitor:62                   | lock:2 | Heavyweight Locked |
|------------------------------------------------------------------------------|--------------------|
|                                                                     | lock:2 |    Marked for GC   |
|------------------------------------------------------------------------------|--------------------|

Class Point（对象指针）

用于存储对象的类型指针，该指针指向它的类元数据，JVM通过这个指针确定对象是哪个类的实例。该指针的位长度为JVM的一个字大小，即32位的JVM为32位，64位的JVM为64位。
如果应用的对象过多，使用64位的指针将浪费大量内存，统计而言，64位的JVM将会比32位的JVM多耗费50%的内存。为了节约内存可以使用选项+UseCompressedOops开启指针压缩，其中，Oop即ordinary object pointer普通对象指针。开启该选项后，下列指针将压缩至32位：

每个Class的属性指针（即静态变量）
每个对象的属性指针（即对象变量）
普通对象数组的每个元素指针

当然，也不是所有的指针都会压缩，一些特殊类型的指针JVM不会优化，比如指向PermGen的Class对象指针(JDK8中指向元空间的Class对象指针)、本地变量、堆栈元素、入参、返回值和NULL指针等。

Array length

如果对象是一个数组，那么对象头还需要有额外的空间用于存储数组的长度，这部分数据的长度也随着JVM架构的不同而不同：32位的JVM上，长度为32位；64位JVM则为64位。64位JVM如果开启+UseCompressedOops选项，该区域长度也将由64位压缩至32位。

锁状态类型

锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。

偏向锁

当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。

如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

偏向锁的撤销

偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有正在执行的字节码）。它会首先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果线程不处于活动状态，则将对象头设置成无锁状态；如果线程仍然活着，拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向于其他线程，要么恢复到无锁或者标记对象不适合作为偏向锁，最后唤醒暂停的线程。

关闭偏向锁

偏向锁在Java 6和Java 7里是默认启用的，但是它在应用程序启动几秒钟之后才激活，如有必要可以使用JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0。如果你确定应用程序里所有的锁通常情况下处于竞争状态，可以通过JVM参数关闭偏向锁：-XX:-UseBiasedLocking=false，那么程序默认会进入轻量级锁状态。

轻量级锁

加锁

线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。

解锁

轻量级解锁时，会使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。下图两个线程同时争夺锁，导致锁膨胀的流程图。

锁的优缺点

锁	优点	缺点	适用场景
偏向锁	加锁和解锁不需要额外的消耗，和执行非同步方法相比仅存在纳秒级的差距	如果线程间存在锁竞争，会带来额外的锁撤销的消耗	适用于只有一个线程访问同步块场景
轻量级锁	竞争的线程不会阻塞，提高了程序的响应速度	如果始终得不到锁竞争的线程，适用自旋会消耗CPU	追求响应时间同步块执行速度非常快
重量级锁	线程竞争不使用自旋，不会消耗CPU	线程阻塞，响应时间缓慢	追求吞吐量同步块执行速度较长

处理器提供总线锁定和缓存锁定两个机制来保证复杂内存操作的原子性。

使用总线锁保证原子性
使用缓存锁保证原子性

Java如何实现原子操作

使用循环CAS实现原子操作
CAS实现原子操作的三大问题：ABA问题、循环时间长开销大、只能保证一个共享变量的原子操作
使用锁机制实现原子操作

问题

当适用一个订单号作为方法参数，同步块Monitor对象为该String 订单号，如何保证相同订单号锁，不同订单号不锁？

String hashCode代码

public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;

for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}

这就是为什么hashCode相同，对象不一定相等的原因了，不同的字符串是可以通过计算逻辑累加一个相同的hash值的。

public class Test {
	 
    public static void main(String[] args) {
        new Thread(){
            public void run(){
                send("zhangsan");
            }
        }.start();
        new Thread(){
            public void run(){
                send("zhangsan");
            }
        }.start();
        new Thread(){
            public void run(){
                send("lisi");
            }
        }.start();
    }
     
    public static void send(String name){
        synchronized (name) {
            System.out.println(Thread.currentThread().getName() + "," + name);
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
     
}

代码中“zhangsan”字符串其实是同一个对象，同一对象多线程访问必定阻塞。

如果是StringBuilder构建出来的对象都是new出来的对象，则sb.toString()后再加上intern()。

JVM内存区域里面有一块常量池，关于常量池的分配：

JDK6的版本，常量池在持久代PermGen中分配
JDK7的版本，常量池在堆Heap中分配

字符串是存储在常量池中的，有两种类型的字符串数据会存储在常量池中：

编译期就可以确定的字符串，即使用""引起来的字符串，比如String a = "123"、String b = "1" + B.getStringDataFromDB() + "2" + C.getStringDataFromDB()、这里的"123"、"1"、"2"都是编译期间就可以确定的字符串，因此会放入常量池，而B.getStringDataFromDB()、C.getStringDataFromDB()这两个数据由于编译期间无法确定，因此它们是在堆上进行分配的
使用String的intern()方法操作的字符串，比如String b = B.getStringDataFromDB().intern()，尽管B.getStringDataFromDB()方法拿到的字符串是在堆上分配的，但是由于后面加入了intern()，因此B.getStringDataFromDB()方法的结果，会写入常量池中

常量池中的String数据有一个特点：每次取数据的时候，如果常量池中有，直接拿常量池中的数据；如果常量池中没有，将数据写入常量池中并返回常量池中的数据。

后记：

《Java并发编程的艺术》《深入理解Java虚拟机》这2本书之前看过，只是粗粗的看过并没有做什么笔记，结合问题总结一下，带着问题总结知识就是不一样，飞一般的感觉，相信对Java并发实现有不一般的认识。

参考：

《Java并发编程的艺术》

《深入理解Java虚拟机》

huaishu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java并发机制----同步synchronized以及原子操作

Java并发编程过程中必须接触synchronized和volatile，以及后来的读写锁ReadWriteLock、重入锁ReentrantLock等，JVM在编译synchronized时会生成2个指令集monitorenter和monitorexit，volatile则实现1）将当前处理器缓存行的数据写回到系统内存。2）这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效。...
复制链接

扫一扫