Java并发编程实战二

线程间的通讯方式

1.volitate(缓存一致性协议),synchronize,lock(都保证可见性)

2.wait.notify,await(),signal(前两个是Object，后两个属于lock)

3.管道输入、输出流 (示例代码：PipeInOut.java)（目前几乎没人使用）

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。
管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。

4.Thread.join() ： 隐式唤醒，没有直接调用notify。等待其他线程执行完成，其他线程会发送唤醒信号。

5.ThradLocal() —》支持子线程继承的一种形式。

6.线程中断

    /*** Tests if some Thread has been interrupted.  The interrupted state* is reset or not based on the value of ClearInterrupted that is* passed.*/private native boolean isInterrupted(boolean ClearInterrupted);

Synchronized

D:\IDEAProject\spring-framework-test\concurrency\target\classes\com\book\jdk>javap -v SyncUsingWay.class
Classfile /D:/IDEAProject/spring-framework-test/concurrency/target/classes/com/book/jdk/SyncUsingWay.classLast modified 2023-3-1; size 769 bytesMD5 checksum 550a0ffccc5c1b8084aaf83b2929b423Compiled from "SyncUsingWay.java"
public class com.book.jdk.SyncUsingWayminor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPER
Constant pool:#1 = Methodref          #8.#25         // java/lang/Object."<init>":()V#2 = Fieldref           #26.#27        // java/lang/System.out:Ljava/io/PrintStream;#3 = String             #16            // StaticSyncMethod#4 = Methodref          #28.#29        // java/io/PrintStream.println:(Ljava/lang/String;)V#5 = String             #17            // SyncMethod#6 = String             #18            // method#7 = Class              #30            // com/book/jdk/SyncUsingWay#8 = Class              #31            // java/lang/Object#9 = Utf8               <init>#10 = Utf8               ()V#11 = Utf8               Code#12 = Utf8               LineNumberTable#13 = Utf8               LocalVariableTable#14 = Utf8               this#15 = Utf8               Lcom/book/jdk/SyncUsingWay;#16 = Utf8               StaticSyncMethod#17 = Utf8               SyncMethod#18 = Utf8               method#19 = Utf8               StackMapTable#20 = Class              #30            // com/book/jdk/SyncUsingWay#21 = Class              #31            // java/lang/Object#22 = Class              #32            // java/lang/Throwable#23 = Utf8               SourceFile#24 = Utf8               SyncUsingWay.java#25 = NameAndType        #9:#10         // "<init>":()V#26 = Class              #33            // java/lang/System#27 = NameAndType        #34:#35        // out:Ljava/io/PrintStream;#28 = Class              #36            // java/io/PrintStream#29 = NameAndType        #37:#38        // println:(Ljava/lang/String;)V#30 = Utf8               com/book/jdk/SyncUsingWay#31 = Utf8               java/lang/Object#32 = Utf8               java/lang/Throwable#33 = Utf8               java/lang/System#34 = Utf8               out#35 = Utf8               Ljava/io/PrintStream;#36 = Utf8               java/io/PrintStream#37 = Utf8               println#38 = Utf8               (Ljava/lang/String;)V
{public com.book.jdk.SyncUsingWay();descriptor: ()Vflags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: invokespecial #1                  // Method java/lang/Object."<init>":()V4: returnLineNumberTable:line 3: 0LocalVariableTable:Start  Length  Slot  Name   Signature0       5     0  this   Lcom/book/jdk/SyncUsingWay;//静态同步方法public static synchronized void StaticSyncMethod();descriptor: ()Vflags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZEDCode:stack=2, locals=0, args_size=00: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;3: ldc           #3                  // String StaticSyncMethod5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V8: returnLineNumberTable:line 7: 0line 8: 8//普通同步方法public synchronized void SyncMethod();descriptor: ()Vflags: ACC_PUBLIC, ACC_SYNCHRONIZEDCode:stack=2, locals=1, args_size=10: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;3: ldc           #5                  // String SyncMethod5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V8: returnLineNumberTable:line 12: 0line 13: 8LocalVariableTable:Start  Length  Slot  Name   Signature0       9     0  this   Lcom/book/jdk/SyncUsingWay;//同步代码块public void method();descriptor: ()Vflags: ACC_PUBLICCode:stack=2, locals=3, args_size=10: aload_01: dup2: astore_1//进入同步代码块，进入临界区，锁的原子内部3: monitorenter4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;7: ldc           #6                  // String method9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V12: aload_113: monitorexit //正常退出同步代码块14: goto          2217: astore_218: aload_119: monitorexit  //防止任何异常情况下退出代码块，jvm仍然可以释放锁20: aload_221: athrow22: returnException table:  //配合异常退出monitorexitfrom    to  target type4    14    17   any17    20    17   anyLineNumberTable:line 17: 0line 18: 4line 19: 12line 20: 22LocalVariableTable:Start  Length  Slot  Name   Signature0      23     0  this   Lcom/book/jdk/SyncUsingWay;StackMapTable: number_of_entries = 2frame_type = 255 /* full_frame */offset_delta = 17locals = [ class com/book/jdk/SyncUsingWay, class java/lang/Object ]stack = [ class java/lang/Throwable ]frame_type = 250 /* chop */offset_delta = 4
}
SourceFile: "SyncUsingWay.java"

Synchronized特性

1. 有序性 （读读、读写、写读、写写 互斥）

2. 可见性 （可见性是指多个线程访问⼀个资源时，该资源的状态、值信息等对于其他线程都是可见的。 synchronized和volatile都具有可见性，其中synchronized对⼀个类或对象加锁时，⼀个线程如果要访问该类或对象必须先获得它的锁，⽽这个锁的状态对于其他任何线程都是可见的，并且在释放锁之前会将对变量的修改刷新到共享内存当中，保证资源变量的可见性。）

3. 原子性 (本质上是线程互斥保证的原子性)

4. 可重入性 （代码示例 ThreadReIn.java）
   
   无锁和偏向锁的区别在于是否是偏向锁这个标志位

被加锁的对象，没有真正、或者隐式的调用父类 Object 里边的hashcode方法。（如果一旦调用了object的hashcode方法，那么我们的对象头里边就有真正的hashcode值了，如果偏向锁来进行markword的替换，至少要提供一个保存hashcode的地方吧？可惜的是，偏向锁并没有地方进行markword的保存，只有轻量级锁才会有“displace mark word”），会直接升级为轻量级锁

偏向锁概述

为了让线程获得锁的代价更低而引入了偏向锁。当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。（偏向锁指向当前线程： 其实是cas竞争替换 线程id。）

对象头：存储线程id
和栈帧中的锁记录里： 线程有自己的栈帧，LOCK RECORD: 存储当前线程id

锁升级

偏向锁的撤销

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

偏向锁：
1.A线程获取偏向锁，并且A线程死亡退出。B线程争抢偏向锁，会直接升级当前对象的锁为轻量级锁。这只是针对我们争抢了一次。
2.A线程获取偏向锁，并且A线程没有释放偏向锁（），还在sync的代码块里边。B线程此时过来争抢偏向锁，会直接升级为重量级锁。
3.A线程获取偏向锁，并且A线程释放了锁，但是A线程并没有死亡还在活跃状态。B线程过来争抢，会直接升级为轻量级锁。
综上所述，当我们尝试第一次竞争偏向锁时，如果A线程已经死亡，升级为轻量级锁；如果A线程未死亡，并且未释放锁，直接升级为重量级锁；如果A线程未死亡，并且已经释放了锁，直接升级为轻量级锁。

4.A线程获取偏向锁，并且A线程没有释放偏向锁（），还在sync的代码块里边。B线程多次争抢锁，会在加锁过程中采用重量级锁；但是，一旦锁被释放，当前对象还是会以轻量级锁的初始状态执行。这块算是锁降级吗？不算。这个示例就是我们一些博客论坛里边的一些认为可以锁降级的示例。— 锁升级是在线程运行过程中和争抢过程中的一种升级。这句话里一定要注意 中 这个字儿，很重要。我想请问，刚才我们演示的是在竞争中的锁降级吗？（理解但不说）

5.A线程获取偏向锁，并且A线程释放了锁，但是A线程并没有死亡还在活跃状态。B线程过来争抢。部分争抢会升级为轻量级锁；部分争抢会依旧保持偏向锁。（jvm对此没有明确界定，不需要再详细了解）