2.1　线程安全问题
- 2.1.1　自增运算不是线程安全的
- 2.1.2　临界区资源与临界区代码段
2.2　synchronized关键字
2.3　生产者-消费者问题
- 2.3.1　生产者-消费者模式
- 2.3.2　一个线程不安全的实现版本
2.4　Java对象结构与内置锁
2.5　偏向锁的原理与实战
2.8　偏向锁、轻量级锁与重量级锁的对比

2.1　线程安全问题

2.1.1　自增运算不是线程安全的

2.1.2　临界区资源与临界区代码段

2.2　synchronized关键字

2.2.1　synchronized同步方法

synchronized关键字是Java的保留字，当使用synchronized关键字修饰一个方法的时候，该方法被声明为同步方法

//同步方法
         public synchronized  void selfPlus()
         {
             amount++; 
         }

2.2.2　synchronized同步块

对于小的临界区，我们直接在方法声明中设置synchronized同步关键字，可以避免竞态条件的问题。但是对于较大的临界区代码段，为了执行效率，最好将同步方法分为小的临界区代码段

public class TwoPlus {
         private int sum1 = 0;
         private int sum2 = 0;
         //同步方法
         public synchronized void plus(int val1, int val2){
              //临界区代码段
              this.sum1 += val1;
              this.sum2 += val2;
        }
     }

一旦线程进入，当线程在操作sum1而没有操作sum2时，也将sum2的操作权白白占用，其他的线程由于没有进入临界区，只能看着sum2被闲置而不能去执行操作。<br />synchronized同步块的写法是：

synchronized(syncObject) //同步块而不是方法
     {
          //临界区代码段的代码块
     }

public class TwoPlus{
         private int sum1 = 0;
         private int sum2 = 0;
         private Integer sum1Lock = new Integer(1); // 同步锁一
         private Integer sum2Lock = new Integer(2); // 同步锁二
         public void plus(int val1, int val2){
            //同步块1
             synchronized(this.sum1Lock){
                 this.sum1 += val1;
             }
            //同步块2
            synchronized(this.sum2Lock){
                 this.sum2 += val2;
             }
         }
     }

例如，下面两种实现多线程同步的plus方法版本编译成JVM内部字节码后结果是一样的。
版本一，使用synchronized代码块对方法内部全部代码进行保护，具体代码如下：

public void plus() {
           synchronized(this){  //对方法内部全部代码进行保护
               amount++; 
           }
     }

版本二，使用synchronized方法对方法内部全部代码进行保护，具体代码如下：

public  synchronized  void plus() {
           amount++; 
     }

2.2.3　静态的同步方法

下面展示一个使用synchronized关键字修饰static方法的例子，具体如下：

package com.crazymakercircle.plus;
     // 省略import
     public class SafeStaticMethodPlus
     {   //静态的临界区资源
         private static Integer amount = 0;
         //使用synchronized关键字修饰 static方法
         public static synchronizedvoid selfPlus()
         {
             amount++;
          }
     }

2.3　生产者-消费者问题

2.3.1　生产者-消费者模式

2.3.2　一个线程不安全的实现版本

不是线程安全的数据缓冲区类 ```java package com.crazymakercircle.producerandcomsumer.store; // 省略import //数据缓冲区，不安全版本的类定义 class NotSafeDataBuffer {

  public static final int MAX_AMOUNT = 10;
  private List<T> dataList = new LinkedList<>();
  //保存数量
  private AtomicInteger amount = new AtomicInteger(0);
  //向数据区增加一个元素
  public void add(T element) throws Exception
  {
      if (amount.get() > MAX_AMOUNT)
      {
          Print.tcfo("队列已经满了！");
          return;
      }
      dataList.add(element);
      Print.tcfo(element + "");
      amount.incrementAndGet();
      //如果数据不一致，就抛出异常
      if (amount.get() != dataList.size())
      {
          throw new Exception(amount + "!=" + dataList.size());
      }
  }
  //从数据区取出一个元素
  public T fetch() throws Exception
  {
      if (amount.get() <= 0)
      {
          Print.tcfo("队列已经空了！");
          return null;
      }
       T element = dataList.remove(0);
      Print.tcfo(element + "");
      amount.decrementAndGet();
      //如果数据不一致，就抛出异常
      if (amount.get() != dataList.size())
      {
          throw new Exception(amount + "!=" + dataList.size());
      }


2. 生产者、消费者的逻辑与动作解耦
生产者、消费者逻辑与对应动作解耦后的类结构图<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/27178439/1650164864965-4fd04b69-0399-4859-b6d0-7b0a8d4388e8.png#clientId=u0d67bc05-45ec-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=178&id=u918ca972&margin=%5Bobject%20Object%5D&name=image.png&originHeight=222&originWidth=662&originalType=binary&ratio=1&rotation=0&showTitle=false&size=42980&status=done&style=none&taskId=u61a6bb23-d98f-4c0c-bcaa-e3a38fe270a&title=&width=529.6)
3. 通用的Producer类实现
```java
package com.crazymakercircle.petstore.actor;
     // 省略import
     /**
      * 通用的生产者
      */
     public class Producer implements Runnable
     {
         //生产的时间间隔，生产一次等待的时间默认为200毫秒
         public static final int PRODUCE_GAP = 200;
         //总次数
         static final AtomicInteger TURN = new AtomicInteger(0);
         //生产者对象编号
         static final AtomicInteger PRODUCER_NO = new AtomicInteger(1);
         //生产者名称
         String name = null;
         //生产的动作
         Callable action = null;
         int gap = PRODUCE_GAP;
         public Producer(Callable action, int gap)
         {
             this.action = action;
             this.gap = gap;
             name = "生产者-" + PRODUCER_NO.incrementAndGet();
         }
         @Override
         public void run()
         {
             while (true)
             {
                 try
                 {
                     //执行生产动作
                     Object    out = action.call();
                     //输出生产的结果
                     if (null != out)
                     {
                         Print.tcfo("第" + TURN.get() + "轮生产：" + out);
                     }
                     //每一轮生产之后，稍微等待一下
                     sleepMilliSeconds(gap);
                     //增加生产轮次
                     TURN.incrementAndGet();
                 } catch (Exception e)
                 {
                     e.printStackTrace();
                 }
             }
         }
     }

通用的Consumer类实现 ```java package com.crazymakercircle.petstore.actor; // 省略import /**
- 通用的消费者的定义 */ public class Consumer implements Runnable {
  
  //消费的时间间隔，默认等待100毫秒 public static final int CONSUME_GAP = 100; //消费总次数 static final AtomicInteger TURN = new AtomicInteger(0); //消费者对象编号 static final AtomicInteger CONSUMER_NO = new AtomicInteger(1); //消费者名称 String name; //消费的动作 Callable action = null;
  
  //消费一次等待的时间，默认为100毫秒 int gap = CONSUME_GAP;
  
  public Consumer(Callable action, int gap) {
```
 this.action = action;
 this.gap = gap;
 name = "消费者-" + CONSUMER_NO.incrementAndGet();
```
  }
  
  @Override public void run() {
```
 while (true)
 {
     //增加消费次数
     TURN.incrementAndGet();
     try
     {
         //执行消费动作
         Object out = action.call();
         if (null != out)
         {
             Print.tcfo("第" + TURN.get() + "轮消费：" + out);
         }
         //每一轮消费之后，稍微等待一下
         sleepMilliSeconds(gap);
     } catch (Exception e)
     {
         e.printStackTrace();
     }
 }
```
  } }


5. 数据区缓冲区实例、生产动作、消费动作的定义
```java
package com.crazymakercircle.producerandcomsumer.store;
     // 省略import
     public class NotSafePetStore
     {
         //数据缓冲区静态实例
         private static NotSafeDataBuffer<IGoods> notSafeDataBuffer =
                                                                new NotSafeDataBuffer();
         //生产者执行的动作
         static Callable<IGoods> produceAction = () ->
         {
             //首先生成一个随机的商品
             IGoods goods = Goods.produceOne();
             //将商品加上共享数据区
             try
             {
                 notSafeDataBuffer.add(goods);
             } catch (Exception e)
             {
                 e.printStackTrace();
             }
             return goods;

组装出一个生产者和消费者模式的简单实现版本 ```java package com.crazymakercircle.producerandcomsumer.store; // 省略import public class NotSafePetStore {

  public static void main(String[] args) throws InterruptedException
  {
      System.setErr(System.out);
      // 同时并发执行的线程数
      final int THREAD_TOTAL = 20;
      //线程池，用于多线程模拟测试
      ExecutorService threadPool = 
                      Executors.newFixedThreadPool(THREAD_TOTAL);
      for (int i = 0; i < 5; i++)
      {
          //生产者实例每生产一个商品，间隔500毫秒
          threadPool.submit(new Producer(produceAction, 500));
          //消费者实例每消费一个商品，间隔1500毫秒
          threadPool.submit(new Consumer(consumerAction, 1500));
      }
  }
  // 省略其他

}

<a name="yiglP"></a>
## 2.3.3　一个线程安全的实现版本
创建一个安全的数据缓存区类SafeDataBuffer，在其add(…)和fetch()两个实例方法的public声明后面加上synchronized关键字即可。其他的代码一行不动，与NotSafeDataBuffer的代码相同。SafeDataBuffer类的代码如下：
```java
package com.crazymakercircle.producerandcomsumer.store;
     // 省略import
     //共享数据区，类定义
     class SafeDataBuffer<T>
     {
         public static final int MAX_AMOUNT = 10;
         private BlockingQueue<T> dataList = new LinkedBlockingQueue<>();
         //保存数量
         private AtomicInteger amount = new AtomicInteger(0);
         /**
          * 向数据区增加一个元素
          */
         public synchronized void add(T element) throws Exception
         {
             // 省略其他相同的代码
             dataList.add(element);
             Print.tcfo(element + "");w
             amount.incrementAndGet();
         }
         /**
          * 从数据区取出一个元素
          */
         public synchronized T fetch() throws Exception
         T element = dataList.remove(0);
             // 省略其他相同的代码
             return element;
         }

2.4　Java对象结构与内置锁

2.4.1　Java对象结构

Java对象（Object实例）结构包括三部分：对象头、对象体和对齐字节

Java对象（Object实例）的三部分
1. 对象头
2. 对象体
3. 对齐字节
对象结构中核心字段的作用
1. Mark Word（标记字）字段主要用来表示对象的线程锁状态，另外还可以用来配合GC存放该对象的hashCode。
2. Class Pointer（类对象指针）字段是一个指向方法区中Class信息的指针，意味着该对象可随时知道自己是哪个Class的实例。
3. Array Length（数组长度）字段占用32位（在32位JVM中）字节，这是可选的，只有当本对象是一个数组对象时才会有这个部分。
4. 对象体用于保存对象属性值，是对象的主体部分，占用的内存空间大小取决于对象的属性数量和类型。
5. 对齐字节并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。当对象实例数据部分没有对齐（8字节的整数倍）时，就需要通过对齐填充来补全。
对象结构中的字段长度

2.4.2　Mark Word的结构信息
不同锁状态下的Mark Word字段结构

不同锁状态下32位Mark Word的结构信息

不同锁状态下64位Mark Work的结构信息

64位Mark Word的构成
1. lock：锁状态标记位，占两个二进制位，由于希望用尽可能少的二进制位表示尽可能多的信息，因此设置了lock标记。该标记的值不同，整个Mark Word表示的含义就不同。
2. biased_lock：对象是否启用偏向锁标记，只占1个二进制位。为1时表示对象启用偏向锁，为0时表示对象没有偏向锁。
3. age：4位的Java对象分代年龄。在GC中，对象在Survivor区复制一次，年龄就增加1。当对象达到设定的阈值时，将会晋升到老年代。默认情况下，并行GC的年龄阈值为15，并发GC的年龄阈值为6。由于age只有4位，因此最大值为15，这就是-XX:MaxTenuringThreshold选项最大值为15的原因。
4. identity_hashcode：31位的对象标识HashCode（哈希码）采用延迟加载技术，当调用Object.hashCode()方法或者System.identityHashCode()方法计算对象的HashCode后，其结果将被写到该对象头中。当对象被锁定时，该值会移动到Monitor（监视器）中。
5. thread：54位的线程ID值为持有偏向锁的线程ID。
6. epoch：偏向时间戳。
7. ptr_to_lock_record：占62位，在轻量级锁的状态下指向栈帧中锁记录的指针。
8. ptr_to_heavyweight_monitor：占62位，在重量级锁的状态下指向对象监视器的指针。32位的Mark Word与64位的Mark Word结构相似，这里不再赘述。

2.4.3　使用JOL工具查看对象的布局

要使用JOL工具，先引入Maven的依赖坐标：

<!--Java Object Layout -->
         <dependency>
             <groupId>org.openjdk.jol</groupId>
             <artifactId>jol-core</artifactId>
             <version>0.11</version>
         </dependency>

准备进行对象布局分析的ObjectLock类 ```java package com.crazymakercircle.innerlock; // 省略import public class ObjectLock {

  private Integer amount = 0; //整型字段占用4字节
  public void increase()
  {
      synchronized (this)
      {
          amount++;
      }
  }
  /**
   * 输出十六进制、小端模式的hashCode
   */
  public String hexHash()
  {
      //对象的原始 hashCode，Java默认为大端模式
      int hashCode = this.hashCode();
      //转成小端模式的字节数组
      byte[] hashCode_LE = ByteUtil.int2Bytes_LE(hashCode);
      //转成十六进制形式的字符串
      return ByteUtil.byteToHex(hashCode_LE);
  }


2. 编写对象布局分析的用例代码
```java
package com.crazymakercircle.innerlock;
     // 省略import
     public class InnerLockTest
     {
        @org.junit.Test
         public void showNoLockObject() throws InterruptedException
         {
             //输出JVM的信息
             Print.fo(VM.current().details());
             //创建一个对象
             ObjectLock objectLock = new ObjectLock();
             Print.fo("object status: ");
             //输出对象的布局信息
             objectLock.printSelf();
         }
         // 省略其他用例
     }
[InnerLockTest.showNoLockObject]：# Running 64-bit HotSpot VM.
# Using compressed oop with 0-bit shift.
# Using compressed klass with 3-bit shift.
# Objects are 8 bytes aligned.
# Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]
# Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]
[InnerLockTest.showNoLockObject]：object status: 
[ObjectLock.printSelf]：lock hexHash= 04 c0 97 0b 
[ObjectLock.printSelf]：lock binaryHash= 00000100 11000000 10010111 00001011 
[ObjectLock.printSelf]：lock = com.crazymakercircle.innerlock.ObjectLock object internals:
 OFFSET  SIZE                TYPE DESCRIPTION                               VALUE
      0     4                     (object header)                           01 04 c0 97 (00000001 00000100 11000000 10010111) (-1749023743)
      4     4                     (object header)                           0b 00 00 00 (00001011 00000000 00000000 00000000) (11)
      8     4                     (object header)                           5d 0f 01 20 (01011101 00001111 00000001 00100000) (536940381)
     12     4   java.lang.Integer ObjectLock.amount                         0
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

JOL对象布局输出结果解读
2.4.4　大小端问题

2.4.5　无锁、偏向锁、轻量级锁和重量级锁

无锁状态
偏向锁状态
轻量级锁状态
重量级锁状态
2.5　偏向锁的原理与实战
2.5.1　偏向锁的核心原理
偏向锁的核心原理是：如果不存在线程竞争的一个线程获得了锁，那么锁就进入偏向状态，此时Mark Word的结构变为偏向锁结构，锁对象的锁标志位（lock）被改为01，偏向标志位（biased_lock）被改为1，然后线程的ID记录在锁对象的Mark Word中（使用CAS操作完成）。以后该线程获取锁时判断一下线程ID和标志位，就可以直接进入同步块，连CAS操作都不需要，这样就省去了大量有关锁申请的操作，从而也就提升了程序的性能。

2.5.2　偏向锁的演示案例

偏向锁演示案例的代码 ```java package com.crazymakercircle.innerlock; // 省略import public class InnerLockTest {

  //偏向锁的案例演示
  @org.junit.Test
  public void showBiasedLock() throws InterruptedException
  {
      Print.tcfo(VM.current().details());
      //JVM延迟偏向锁
      sleepMilliSeconds(5000);
      ObjectLock counter = new ObjectLock();
      Print.tcfo("抢占锁前, lock的状态: ");
      lock.printObjectStruct();
      sleepMilliSeconds(5000);
      CountDownLatch latch = new CountDownLatch(1);
      Runnable runnable = () ->
      {
          for (int i = 0; i < MAX_TURN; i++)
          {
              synchronized (lock)
              {
                  lock.increase();
                  if (i == MAX_TURN / 2)
                  {
                      Print.tcfo("占有锁, lock的状态: ");
                      lock.printObjectStruct();
                  }
              }
              //每一次循环等待10毫秒
              sleepMilliSeconds(10);
          }
          latch.countDown();
      };
      new Thread(runnable, "biased-demo-thread").start();
      //等待加锁线程执行完成
      latch.await();
      sleepMilliSeconds(5000);
      Print.tcfo("释放锁后, lock的状态: ");
      lock.printObjectStruct();
  }
// 省略不相干代码

}

<a name="sQQw3"></a>
## 2.5.3　偏向锁的膨胀和撤销
1. 偏向锁的撤销
1. 偏向锁的膨胀
1. 偏向锁的好处
<a name="FCSI1"></a>
## 2.6　轻量级锁的原理与实战
<a name="K36vB"></a>
## 2.6.1　轻量级锁的核心原理
轻量锁存在的目的是尽可能不动用操作系统层面的互斥锁，因为其性能比较差。线程的阻塞和唤醒需要CPU从用户态转为核心态，频繁地阻塞和唤醒对CPU来说是一件负担很重的工作
<a name="PRvjb"></a>
## 2.6.2　轻量级锁的演示案例
```java
package com.crazymakercircle.innerlock;
     // 省略import
     public class InnerLockTest
     {
　　//偏向锁的案例演示
          @org.junit.Test
         public void showLightweightLock() throws InterruptedException
         {
             Print.tcfo(VM.current().details());
             //JVM延迟偏向锁
             sleepMilliSeconds(5000);
             ObjectLock lock = new ObjectLock();
             Print.tcfo("抢占锁前, lock的状态: ");
             lock.printObjectStruct();
             sleepMilliSeconds(5000);
             CountDownLatch latch = new CountDownLatch(2);
             Runnable runnable = () ->
             {
                 for (int i = 0; i < MAX_TURN; i++)
                 {
                     synchronized (lock)
                     {
                         lock.increase();
                         if (i == 1)
                         {
                             Print.tcfo("第一个线程占有锁, lock的状态: ");
                             lock.printObjectStruct();
                         }
                     }
                 }
                 //循环完毕
                 latch.countDown();
                 //线程虽然释放锁，但是一直存在死循环
                 for (int j = 0; ; j++)
                 {
                     //每一次循环等待1毫秒
                     sleepMilliSeconds(1);
                 }
             };
             new Thread(runnable).start();
             sleepMilliSeconds(1000); //等待1秒
             Runnable lightweightRunnable = () ->
             {
                 for (int i = 0; i < MAX_TURN; i++)
                 {
                     synchronized (lock)
                     {
                         lock.increase();
                         if (i == MAX_TURN / 2)
   [main|InnerLockTest.showLightweightLock]：抢占锁前, lock的状态: 
     [ObjectLock.printObjectStruct]：lock = com.crazymakercircle.innerlock.ObjectLock 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)          a4 00 01 f8 (10100100 00000000 00000001 11111000) (-134152028)
          12     4   java.lang.Integer ObjectLock.amount         0
     Instance size: 16 bytes
     Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
[Thread-1|InnerLockTest.lambda$showLightweightLock$2]：第二个线程占有锁, lock的状态: 
     [ObjectLock.printObjectStruct]：lock = com.crazymakercircle.innerlock.ObjectLock object internals:
      OFFSET  SIZE     TYPE DESCRIPTION       VALUE
           0     4       (object header)        88 ef d9 21 (10001000 11101111 11011001 00100001) (567930760)
           4     4       (object header)        00 00 00 00 (00000000 00000000 00000000 00000000) (0)
           8     4       (object header)        a4 00 01 f8 (10100100 00000000 00000001 11111000) (-134152028)
          12     4   java.lang.Integer ObjectLock.amount           1501
     Instance size: 16 bytes
     Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
         [ObjectLock.printObjectStruct]：lock = com.crazymakercircle.innerlock.ObjectLock 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)             a4 00 01 f8 (10100100 00000000 00000001 11111000) (-134152028)
          12     4   java.lang.Integer ObjectLock.amount      2000
     Instance size: 16 bytes

2.6.3　轻量级锁的分类

普通自旋锁

所谓普通自旋锁，就是指当有线程来竞争锁时，抢锁线程会在原地循环等待，而不是被阻塞，直到那个占有锁的线程释放锁之后，这个抢锁线程才可以获得锁。

自适应自旋锁

所谓自适应自旋锁，就是等待线程空循环的自旋次数并非是固定的，而是会动态地根据实际情况来改变自旋等待的次数，自旋次数由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。自适应自旋锁的大概原理是：
a. 如果抢锁线程在同一个锁对象上之前成功获得过锁，JVM就会认为这次自旋很有可能再次成功，因此允许自旋等待持续相对更长的时间。
b. 如果对于某个锁，抢锁线程很少成功获得过，那么JVM将可能减少自旋时间甚至省略自旋过程，以避免浪费处理器资源。

轻量级锁也被称为非阻塞同步、乐观锁，因为这个过程并没有把线程阻塞挂起，而是让线程空循环等待。

2.6.4　轻量级锁的膨胀

轻量级锁的问题在哪里呢？虽然大部分临界区代码的执行时间都是很短的，但是也会存在执行得很慢的临界区代码。临界区代码执行耗时较长，在其执行期间，其他线程都在原地自旋等待，会空消耗CPU。因此，如果竞争这个同步锁的线程很多，就会有多个线程在原地等待继续空循环消耗CPU（空自旋），这会带来很大的性能损耗。

2.7　重量级锁的原理与实战

2.7.1　重量级锁的核心原理

2.7.2　重量级锁的开销

2.7.3　重量级锁的演示案例

package com.crazymakercircle.innerlock;
     // 省略import
     public class InnerLockTest
     {
         @org.junit.Test
         public void showHeavyweightLock() throws InterruptedException
         {
             Print.tcfo(VM.current().details());
             //JVM延迟偏向锁
             sleepMilliSeconds(5000);
             ObjectLock counter = new ObjectLock();
             Print.tcfo("抢占锁前, lock的状态: ");
             lock.printObjectStruct();
             sleepMilliSeconds(5000);
             CountDownLatch latch = new CountDownLatch(3);
             Runnable runnable = () ->
             {
                 for (int i = 0; i < MAX_TURN; i++)
                 {
                     synchronized (lock)
                     {
                         lock.increase();
                         if (i == 0)
                         {
                             Print.tcfo("第一个线程占有锁, lock的状态: ");
                             lock.printObjectStruct();
                         }
                     }
                 }
                 //循环完毕
                 latch.countDown();
                 //线程虽然释放锁，但是一直存在
                 for (int j = 0; ; j++)
                 {
                     //每一次循环等待1毫秒
                     sleepMilliSeconds(1);
                 }
             };
             new Thread(runnable).start();
             sleepMilliSeconds(1000); //等待1秒
             Runnable lightweightRunnable = () ->
             {
                 for (int i = 0; i < MAX_TURN; i++)
                 {
                     synchronized (lock)
                     {
                         lock.increase();
                         if (i == 0)
                         {
                             Print.tcfo("占有锁, lock的状态: ");
                             lock.printObjectStruct();
                         }
                         //每一次循环等待1毫秒
                         sleepMilliSeconds(1);
                     }
                 }
                 //循环完毕
                 latch.countDown();
             };
            //启动两个线程，开始激烈地抢锁
             new Thread(lightweightRunnable,"抢锁线程1").start();
             sleepMilliSeconds(100);  //等待100毫秒
             new Thread(lightweightRunnable,"抢锁线程2").start();
             //等待加锁线程执行完成
             latch.await();
             sleepMilliSeconds(2000);  //等待2秒
             Print.tcfo("释放锁后, lock的状态: ");
             lock.printObjectStruct();
         }

2.8　偏向锁、轻量级锁与重量级锁的对比

2.9　线程间通信

2.9.1　线程间通信的定义

线程的通信可以被定义为：当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。
线程间通信的方式可以有很多种：等待-通知、共享内存、管道流。每种方式用不同的方法来实现，这里首先介绍等待-通知的通信方式。

2.9.2　低效的线程轮询

每个Java对象都有wait()、notify()两类实例方法，并且wait()、notify()方法和对象的监视器是紧密相关的。

2.9.3　wait方法和notify方法的原理

对象的wait()方法 ```java synchronized(locko) {　

   //同步保护的代码块
   locko.wait();
   ...

}


2. wait()方法的核心原理
![image.png](https://cdn.nlark.com/yuque/0/2022/png/27178439/1650176753950-fe92f9a0-c68f-44a5-a849-4125cc2070b4.png#clientId=u0d67bc05-45ec-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=250&id=uec06cd0d&margin=%5Bobject%20Object%5D&name=image.png&originHeight=312&originWidth=623&originalType=binary&ratio=1&rotation=0&showTitle=false&size=51135&status=done&style=none&taskId=u3affacc8-08ca-4004-ab26-48e391f1f88&title=&width=498.4)
3. 对象的notify()方法
```java
synchronized(locko)
     {　     
          //同步保护的代码块
          locko.notify();
          ...
     }

notify()方法的核心原理

2.9.4　“等待-通知”通信模式演示案例

package com.crazymakercircle.multithread.basic.use;
     // 省略import
     public class WaitNotifyDemo
     {
         static Object locko = new Object();
         //等待线程的异步目标任务
         static class WaitTarget implements Runnable
         {
             public void run()
             {
                 //加锁
                 synchronized (locko)
                 {
                     try
                     {
                         //启动等待
                         Print.tco("启动等待");
                         //等待被通知，同时释放locko监视器的Owner权利
                         locko.wait();
                         //收到通知后，线程会进入locko监视器的EntryList
                     } catch (InterruptedException e)
                     {
                         e.printStackTrace();
                     }
                     //获取到监视器的Owner权利
                     Print.tco("收到通知，当前线程继续执行");
                 }
             }
         }
         //通知线程的异步目标任务
         static class NotifyTarget implements Runnable
         {
             public void run()
             {
                 //加锁
                 synchronized (locko)
                 {
                     //从屏幕读取输入，目的是阻塞通知线程，方便使用jstack查看线程状态
                     Print.consoleInput();
                     //获取lock锁，然后进行发送
                     // 此时不会立即释放locko的Monitor的Owner，需要执行完毕
                     locko.notifyAll();
                     Print.tco("发出通知了，但是线程还没有立马释放锁");
                 }
             }
         }
         public static void main(String[] args) throws InterruptedException
         {
             //创建等待线程
             Thread waitThread = new Thread(new WaitTarget(), "WaitThread");
             //启动等待线程
             waitThread.start();
             sleepSeconds(1);
             //创建通知线程
             Thread notifyThread = new Thread(new NotifyTarget(), "NotifyThread");
             //启动通知线程
             notifyThread.start();
         }
     }

2.9.5　生产者-消费者之间的线程间通信

package com.crazymakercircle.producerandcomsumer.store;
     // 省略import
     public class CommunicatePetStore
     {
         public static final int MAX_AMOUNT = 10; //数据缓冲区最大长度
         //数据缓冲区，类定义
         static class DataBuffer<T>
         {
             //保存数据
             private List<T> dataList = new LinkedList<>();
             //数据缓冲区长度
             private Integer amount = 0;
             private final Object LOCK_OBJECT = new Object();
             private final Object NOT_FULL = new Object();
             private final Object NOT_EMPTY = new Object();
             // 向数据区增加一个元素
             public void add(T element) throws Exception
             {
                 while (amount > MAX_AMOUNT)
                 {
                     synchronized (NOT_FULL)
                     {
                         Print.tcfo("队列已经满了！");
                         //等待未满通知
                         NOT_FULL.wait();
                     }
                 }
                 synchronized (LOCK_OBJECT)
                 {
                     dataList.add(element);
                     amount++;
                 }
                 synchronized (NOT_EMPTY)
                 {
                     //发送未空通知
                     NOT_EMPTY.notify();
                 }
             }
             /**
              * 从数据区取出一个商品
              */
             public T fetch() throws Exception
             {
                 while (amount <= 0)
                 {
                     synchronized (NOT_EMPTY)
                     {
                         Print.tcfo("队列已经空了！");
                         //等待未空通知
                         NOT_EMPTY.wait();
                     }
                 }

Java 从入门到进阶

第2章　Java内置锁的核心原理

2.1　线程安全问题

2.1.1　自增运算不是线程安全的

2.1.2　临界区资源与临界区代码段

2.2　synchronized关键字

2.2.1　synchronized同步方法

2.2.2　synchronized同步块

2.2.3　静态的同步方法

2.3　生产者-消费者问题

2.3.1　生产者-消费者模式

2.3.2　一个线程不安全的实现版本

2.4　Java对象结构与内置锁

2.4.1　Java对象结构

2.4.2　Mark Word的结构信息

2.4.3　使用JOL工具查看对象的布局

2.4.4　大小端问题

2.4.5　无锁、偏向锁、轻量级锁和重量级锁

2.5　偏向锁的原理与实战

2.5.1　偏向锁的核心原理

2.5.2　偏向锁的演示案例

2.6.3　轻量级锁的分类

2.6.4　轻量级锁的膨胀

2.7　重量级锁的原理与实战

2.7.1　重量级锁的核心原理

2.7.2　重量级锁的开销

2.7.3　重量级锁的演示案例

2.8　偏向锁、轻量级锁与重量级锁的对比

2.9　线程间通信

2.9.1　线程间通信的定义

2.9.2　低效的线程轮询

2.9.3　wait方法和notify方法的原理

2.9.4　“等待-通知”通信模式演示案例

2.9.5　生产者-消费者之间的线程间通信

2.9.6　需要在synchronized同步块的内部使用wait和notify

第2章 Java内置锁的核心原理

2.1 线程安全问题

2.1.1 自增运算不是线程安全的

2.1.2 临界区资源与临界区代码段

2.2 synchronized关键字

2.2.1 synchronized同步方法

2.2.2 synchronized同步块

2.2.3 静态的同步方法

2.3 生产者-消费者问题

2.3.1 生产者-消费者模式

2.3.2 一个线程不安全的实现版本

2.4 Java对象结构与内置锁

2.4.1 Java对象结构

2.4.2 Mark Word的结构信息

2.4.3 使用JOL工具查看对象的布局

2.4.4 大小端问题

2.4.5 无锁、偏向锁、轻量级锁和重量级锁

2.5 偏向锁的原理与实战

2.5.1 偏向锁的核心原理

2.5.2 偏向锁的演示案例

2.6.3 轻量级锁的分类

2.6.4 轻量级锁的膨胀

2.7 重量级锁的原理与实战

2.7.1 重量级锁的核心原理

2.7.2 重量级锁的开销

2.7.3 重量级锁的演示案例

2.8 偏向锁、轻量级锁与重量级锁的对比

2.9 线程间通信

2.9.1 线程间通信的定义

2.9.2 低效的线程轮询

2.9.3 wait方法和notify方法的原理

2.9.4 “等待-通知”通信模式演示案例

2.9.5 生产者-消费者之间的线程间通信

2.9.6 需要在synchronized同步块的内部使用wait和notify

第2章　Java内置锁的核心原理

2.1　线程安全问题

2.1.1　自增运算不是线程安全的

2.1.2　临界区资源与临界区代码段

2.2　synchronized关键字

2.2.1　synchronized同步方法

2.2.2　synchronized同步块

2.2.3　静态的同步方法

2.3　生产者-消费者问题

2.3.1　生产者-消费者模式

2.3.2　一个线程不安全的实现版本

2.4　Java对象结构与内置锁

2.4.1　Java对象结构

2.4.2　Mark Word的结构信息

2.4.3　使用JOL工具查看对象的布局

2.4.4　大小端问题

2.4.5　无锁、偏向锁、轻量级锁和重量级锁

2.5　偏向锁的原理与实战

2.5.1　偏向锁的核心原理

2.5.2　偏向锁的演示案例

2.6.3　轻量级锁的分类

2.6.4　轻量级锁的膨胀

2.7　重量级锁的原理与实战

2.7.1　重量级锁的核心原理

2.7.2　重量级锁的开销

2.7.3　重量级锁的演示案例

2.8　偏向锁、轻量级锁与重量级锁的对比

2.9　线程间通信

2.9.1　线程间通信的定义

2.9.2　低效的线程轮询

2.9.3　wait方法和notify方法的原理

2.9.4　“等待-通知”通信模式演示案例

2.9.5　生产者-消费者之间的线程间通信

2.9.6　需要在synchronized同步块的内部使用wait和notify