Java并发编程实战二

最新推荐文章于 2024-05-25 12:01:51 发布

TheFeasterfromAfar

最新推荐文章于 2024-05-25 12:01:51 发布

阅读量575

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_40662424/article/details/129314851

版权

线程间的通讯方式

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.class
  Last modified 2023-3-1; size 769 bytes
  MD5 checksum 550a0ffccc5c1b8084aaf83b2929b423
  Compiled from "SyncUsingWay.java"
public class com.book.jdk.SyncUsingWay
  minor version: 0
  major version: 52
  flags: 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: ()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 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/book/jdk/SyncUsingWay;

//静态同步方法
  public static synchronized void StaticSyncMethod();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String StaticSyncMethod
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 7: 0
        line 8: 8

//普通同步方法
  public synchronized void SyncMethod();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #5                  // String SyncMethod
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 12: 0
        line 13: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Lcom/book/jdk/SyncUsingWay;

//同步代码块
  public void method();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         //进入同步代码块，进入临界区，锁的原子内部
         3: monitorenter
         4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: ldc           #6                  // String method
         9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        12: aload_1
        13: monitorexit //正常退出同步代码块
        14: goto          22
        17: astore_2
        18: aload_1
        19: monitorexit  //防止任何异常情况下退出代码块，jvm仍然可以释放锁
        20: aload_2
        21: athrow
        22: return
      Exception table:  //配合异常退出monitorexit
         from    to  target type
             4    14    17   any
            17    20    17   any
      LineNumberTable:
        line 17: 0
        line 18: 4
        line 19: 12
        line 20: 22
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      23     0  this   Lcom/book/jdk/SyncUsingWay;
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 17
          locals = [ 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特性

有序性（读读、读写、写读、写写互斥）
可见性（可见性是指多个线程访问⼀个资源时，该资源的状态、值信息等对于其他线程都是可见的。 synchronized和volatile都具有可见性，其中synchronized对⼀个类或对象加锁时，⼀个线程如果要访问该类或对象必须先获得它的锁，⽽这个锁的状态对于其他任何线程都是可见的，并且在释放锁之前会将对变量的修改刷新到共享内存当中，保证资源变量的可见性。）
原子性 (本质上是线程互斥保证的原子性)
可重入性（代码示例 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对此没有明确界定，不需要再详细了解）
在这里插入图片描述

TheFeasterfromAfar

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java并发编程实战二

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

扫一扫