线程系列 4 - synchronized 和线程间的通信
线程系列 4 - synchronized 和线程间的通信
- 1、关于内置锁 和 synchronized
-
- 1.1、三种内置锁对比
- 1.2、关于 synchronized
-
- 1.2.1、synchronized 的使用
- 1.2.1、synchronized 的执行过程
- 2、线程间的通信
-
- 2.1、对象的 wait() 方法
- 2.2、对象的 notify() 方法
- 2.3、线程通信的要点
- 2.4、线程通信示例
- 3、synchronized 八锁现象
-
- 3.1、Lock1
- 3.2、Lock2
- 3.3、Lock3
- 3.4、Lock4
- 3.5、Lock5
- 3.6、Lock6
- 3.7、Lock7
- 3.8、Lock8
1、关于内置锁 和 synchronized
1.1、三种内置锁对比
偏向锁是在没有发生锁争用的情况下使用的，一旦有了第二个线程争用锁，偏向锁就会升级为轻量级锁。如果锁争用很激烈，轻量级锁的CAS自旋到达阈值后，轻量级锁就会升级为重量级锁。
| 锁 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 偏向锁 | 加锁和解锁不需要额外的消耗，和执行非同步方法比较，仅存在纳秒级的差距。 | 如果线程间存在锁竞争，会带来额外的锁撤销的消耗。 | 适用只有一个线程访问的临界区场景。 |
| 轻量级锁 | 竞争的线程不会阻塞，提高了程序的响应速度。 | 抢不到锁竞争的线程使用CAS自旋等待，会消耗 CPU | 锁占用时间很短，吞吐量低 |
| 重量级锁 | 线程竞争不使用自旋，不会消耗 CPU | 线程阻塞，相应时间缓慢 | 锁占用时间较长，吞吐量高 |
1.2、关于 synchronized
1.2.1、synchronized 的使用
- 修饰实例方法 : 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁，即对调用该方法的对象加锁，俗称"对象锁"。
synchronized void method() {
// todo 业务代码
}
- 修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例 ，进入同步代码前要获得 当前 class 的锁。因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管 new 了多少个对象，只有一份）。
synchronized void staic method() {
//业务代码
}
- 修饰代码块 ：指定加锁对象，对给定对象/类加锁。synchronized(this|object) 表示进入同步代码库前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得 当前 class 的锁
// 线程安全的懒汉模式 - 单例
public class Singleton {
//保证有序性，防止指令重排
private volatile static Singleton uniqueInstance;
private Singleton() {}
public static Singleton getInstance() {
//先判断对象是否已经实例过，没有实例化过才进入加锁代码
if (uniqueInstance == null) {
//类对象加锁
synchronized (Singleton.class) {
if (uniqueInstance == null) uniqueInstance = new Singleton();
}
}
return uniqueInstance;
}
}
1.2.1、synchronized 的执行过程
-
① 线程抢锁时，JVM首先检测内置锁对象Mark Word中的 biased_lock（偏向锁标识）是否设置成1，lock（锁标志位）是否为 01，如果都满足，确认内置锁对象为可偏向状态。
-
② 在内置锁对象确认为可偏向状态之后，JVM检查Mark Word中 的线程ID是否为抢锁线程ID，如果是，就表示抢锁线程处于偏向锁状态，抢锁线程快速获得锁，开始执行临界区代码。
-
③ 如果Mark Word中的线程ID并未指向抢锁线程，就通过CAS操作竞争锁。如果竞争成功，就将Mark Word中的线程ID设置为抢锁线程，偏向标志位设置为1，锁标志位设置为01，然后执行临界区代码，此时内置锁对象处于偏向锁状态。
-
④ 如果CAS操作竞争失败，就说明发生了竞争，撤销偏向锁，进而升级为轻量级锁。
-
⑤ JVM使用CAS将锁对象的Mark Word替换为抢锁线程的锁记录指针，如果成功，抢锁线程就获得锁。如果替换失败，就表示其他线程竞争锁，JVM尝试使用CAS自旋替换抢锁线程的锁记录指针，如果自旋成功（抢锁成功），那么锁对象依然处于轻量级锁状态。
-
⑥如果JVM的CAS替换锁记录指针自旋失败，轻量级锁就膨胀为重量级锁，后面等待锁的线程也要进入阻塞状态。
2、线程间的通信
线程间的通信：当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。
线程间通信的方式可以有很多种：等待-通知、共享内存、管道流。而且"等待-通知"通信方式是Java中使用普遍的线程间通信方式。该方式的线程间通信使用对象的wait()、notify()两类方法来实现。每个Java对象都有wait()、notify()两类实例方法，并且wait()、notify()方法和对象的监视器是紧密相关的。
在调用同步对象的wait()和notify()系列方法时，“当前线程”必须拥有该对象的同步锁，也就是说，wait()和notify()系列方法需要在同步块中使用，否则JVM会抛出 IllegalMonitorStateException 异常。
2.1、对象的 wait() 方法
对象的wait()方法的主要作用是让当前线程阻塞并等待被唤醒。wait()方法与对象监视器紧密相关，在当前线程执行 wait() 方法前，必须通过 synchronized() 方法成为对象锁的监视器的Owner。使用wait()方法时一定要放在同步块中。
Object类中 wait() 方法的三个版本：
// 当前线程调用了同步对象的 wait()实例方法后，将导致当前的线程等待，
// 当前线程进入同步对象的监视器WaitSet，等待被其他线程唤醒。
public final void wait() throws InterruptedException {
wait(0L);
}
// 当前的线程等待，等待被其他线程唤醒，或者指定的时间timeout用完，线程不再等待。
public final native void wait(long timeoutMillis) throws InterruptedException;
// 高精度限时等待版本,参数nanos是一个附加的纳秒级别的等待时间，而实现更加高精度的等待时间控制
// 1秒=1000毫秒=1000,000微秒=1000,000,000纳秒。
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {……}
为方便表达，设某个同步锁对象为：locko.
对象的 wait() 方法的核心原理 大致如下：
- ① 当线程调用了 locko（某个同步锁对象）的 wait() 方法后，JVM会将当前线程加入 locko 监视器的 WaitSet（等待集），等待被其他线程唤醒。
- ② 当前线程会释放 locko 对象监视器的 Owner 权利，让其他线程可以抢夺 locko 对象的监视器。
- ③ 让当前线程等待，其状态变成 WAITING。
2.2、对象的 notify() 方法
对象的 notify() 方法的主要作用是唤醒在等待的线程。notify() 方法与对象监视器紧密相关，在执行notify()方法前，当前线程也必须通过 synchronized() 方法成为对象锁的监视器的Owner。所以调用notify()方法时也需要放在同步块中。
Object类中 notify() 方法的两个版本：
// locko.notify()调用后，唤醒locko 监视器等待集中的第一条等待线程；
// 被唤醒的线程进入EntryList，其状态从 WAITING 变成 BLOCKED。
@HotSpotIntrinsicCandidate
public final native void notify();
// locko.notifyAll()被调用后，唤醒locko监视器等待集中的全部等待线程，
// 所有被唤醒的线程进入EntryList，线程状态从 WAITING 变成 BLOCKED。
@HotSpotIntrinsicCandidate
public final native void notifyAll();
为方便表达，设某个同步锁对象为：locko.
对象的 notify() 或者 notifyAll() 方法的核心原理：
-
① 当线程调用了locko（某个同步锁对象）的notify()方法后，JVM会唤醒locko监视器WaitSet中的第一条等待线程。
-
② 当线程调用了locko的notifyAll()方法后，JVM会唤醒locko监视器WaitSet中的所有等待线程。
-
③ 等待线程被唤醒后，会从监视器的WaitSet移动到EntryList，线程具备了排队抢夺监视器Owner权利的资格，其状态从WAITING变成BLOCKED。
-
④ EntryList中的线程抢夺到监视器的Owner权利之后，线程的状态从BLOCKED变成Runnable，具备重新执行的资格。
2.3、线程通信的要点
调用 wait() 和 notify() 系列方法进行线程通信的要点如下：
-
① 调用某个同步对象locko的wait()和notify()类型方法前，必须要取得这个锁对象的监视锁，所以 wait() 和 notify() 类型方法必须放在 synchronized(locko) 同步块中，如果没有获得监视锁，JVM就会报 IllegalMonitorStateException 异常。
-
② 调用wait()方法时使用while进行条件判断，如果是在某种条件下进行等待，对条件的判断就不能使用if语句做一次性判断，而是使用while循环进行反复判断。只有这样才能在线程被唤醒后继续检查 wait 的条件，并在条件没有满足的情况下继续等待。
2.4、线程通信示例
- 数据缓存区 DataBuffer
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.List;
/**
* 数据缓存区
*/
@Slf4j
public class DataBuffer<T> {
/**
* 数据缓冲区队列的最大长度
*/
public static final int MAX_AMOUNT = 10;
/**
* 数据缓冲区队列当前长度
*/
private Integer amount = 0;
/**
* 缓存区队列
*/
private List<T> dataList = new LinkedList<>();
// 同步锁对象：lockObject 用来锁队列 dataList,保证dataList线程安全
private final Object lockObject = new Object();
// 同步锁对象：notFull
private final Object notFull = new Object();
// 同步锁对象：notEmpty
private final Object notEmpty = new Object();
/**
* 向数据区增加一个元素
*/
public void add(T element) throws Exception {
// 当缓存区队列达到最大的长度时，锁住notFull，锁住notFull对象锁等待
while (amount >= MAX_AMOUNT) {
synchronized (notFull) {
log.info("缓存区队列已满！！！");
// 等待未满通知，调用notFull对象锁的wait()方法，让当前线程进入 WAITING 状态，
// 等待被其他线程唤醒
notFull.wait();
}
}
// 这个地方需要注意，当生产速度*生产者线程数 > 消费者速度*消费者线程数时，
// 会出现 队列长度大于最大队列长度的情况。
// 且 dataList 的长度最大为 11
// add() -> dataList 缓存区队列的长度 -> 11
synchronized (lockObject) {
dataList.add(element);
amount++;
log.info("add() -> dataList 缓存区队列的长度 -> {}", dataList.size());
}
// 上一步 往对列中添加了元素，能走到这一步，队列中肯定不为空，
// 所以去唤醒消费者中的 notEmpty对象锁 锁住的线程
synchronized (notEmpty) {
//发送未空通知
notEmpty.notify();
}
}
/**
* 从数据区取出一条元素
*/
public T fetch() throws Exception {
while (amount <= 0) {
synchronized (notEmpty) {
log.info("缓存区队列已空！！！");
//等待未空通知
notEmpty.wait();
}
}
T element = null;
synchronized (lockObject) {
// 这里需要添加校验，否则当 多线程情况下，消费速度快于生产速度时，会有异常
if (!CollectionUtils.isEmpty(dataList)) {
element = dataList.remove(BigInteger.ZERO.intValue());
amount--;
log.info("fetch() -> dataList 缓存区队列的长度 -> {}", dataList.size());
} else {
log.info("fetch() -> dataList 缓存区队列的长度为 0 不消费");
}
}
synchronized (notFull) {
//发送未满通知
notFull.notify();
}
return element;
}
}
- 生产者 Producer
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @description: 生产者
*/
@Slf4j
public class Producer implements Runnable {
// 生产次数计数器
static final AtomicInteger TURN = new AtomicInteger(1);
// 生产的动作
Callable action = null;
// 生产者生产，默认耗时2s
private int gap = 2;
public Producer(Callable action, int gap) {
this.action = action;
this.gap = gap;
}
@Override
public void run() {
// 这里一直生产
while (true) {
try {
//执行生产动作
Object out = action.call();
// 模拟生产者生产耗时
TimeUnit.SECONDS.sleep(gap);
//增加生产轮次
TURN.incrementAndGet();
//输出生产的结果
if (null != out) {
log.info("线程{}->第{}次生产:{}", Thread.currentThread().getName(),
TURN.get(), out);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
- 消费者Consumer
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
@Slf4j
public class Consumer extends Thread {
//消费总次数计数器
static final AtomicInteger TURN = new AtomicInteger(0);
//消费的动作
Callable action = null;
//消费默认消费耗时3s
int gap = 3;
public Consumer(Callable action, int gap) {
this.action = action;
this.gap = gap;
}
@Override
public void run() {
while (true) {
//增加消费次数
TURN.incrementAndGet();
try {
//执行消费动作
Object out = action.call();
if (null != out) {
log.info("线程{}->第{}次消费：{}", Thread.currentThread().getName(),
TURN.get(), out);
}
// 模拟消费者消费耗时
TimeUnit.SECONDS.sleep(gap);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
- 生产的产品 Good
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @description: 生产的产品
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Good implements Cloneable {
private String name;
@Override
public Good clone() {
Good good = null;
try {
good = (Good) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return good;
}
}
- 执行类 ThreadCommunicationDemo
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 执行类
*/
@Slf4j
public class ThreadCommunicationDemo {
public static void main(String[] args) {
Good goodBase = new Good("香蕉");
final AtomicInteger goodCount = new AtomicInteger(0);
//共享数据区，实例对象
DataBuffer<Good> dataBuffer = new DataBuffer<>();
//生产者执行的动作
Callable<Good> produceAction = () -> {
//首先生成一个随机的商品
Good good = goodBase.clone();
int aa = goodCount.incrementAndGet();
log.info("生产总次数 -> {}", aa);
good.setName(good.getName() + aa);
//将商品加上共享数据区
dataBuffer.add(good);
return good;
};
//消费者执行的动作
Callable<Good> consumerAction = () -> {
// 从缓存区获取商品
Good goods = null;
goods = dataBuffer.fetch();
return goods;
};
//线程池，用于多线程模拟测试
ExecutorService threadPool = Executors.newFixedThreadPool(10);
//假定共6个线程，其中有1个消费者，但是有5个生产者
final int consumerTotal = 1;
final int produceTotal = 5;
for (int i = 0; i < produceTotal; i++) {
//生产者线程每生产一个商品，需要1秒
threadPool.submit(new Producer(produceAction, 2));
}
for (int i = 0; i < consumerTotal; i++) {
//消费者线程每消费一个商品，需要两秒
threadPool.submit(new Consumer(consumerAction, 1));
}
threadPool.shutdown();
}
}
- 执行结果：
Connected to the target VM, address: '127.0.0.1:51914', transport: 'socket'
21:52:10.320 [pool-1-thread-6] INFO com.DataBuffer - 缓存区队列已空！！！
21:52:10.320 [pool-1-thread-2] INFO com.ThreadCommunicationDemo - 生产总次数 -> 2
21:52:10.320 [pool-1-thread-3] INFO com.ThreadCommunicationDemo - 生产总次数 -> 4
21:52:10.320 [pool-1-thread-5] INFO com.ThreadCommunicationDemo - 生产总次数 -> 5
21:52:10.326 [pool-1-thread-2] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 1
21:52:10.320 [pool-1-thread-4] INFO com.ThreadCommunicationDemo - 生产总次数 -> 1
21:52:10.320 [pool-1-thread-1] INFO com.ThreadCommunicationDemo - 生产总次数 -> 3
21:52:10.327 [pool-1-thread-4] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 2
21:52:10.327 [pool-1-thread-5] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 3
21:52:10.327 [pool-1-thread-3] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 4
21:52:10.327 [pool-1-thread-1] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 5
21:52:10.330 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 4
21:52:10.331 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第1次消费：Good(name=香蕉2)
21:52:11.352 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 3
21:52:11.352 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第2次消费：Good(name=香蕉1)
21:52:12.330 [pool-1-thread-3] INFO com.Producer - 线程pool-1-thread-3->第6次生产:Good(name=香蕉4)
21:52:12.330 [pool-1-thread-1] INFO com.Producer - 线程pool-1-thread-1->第6次生产:Good(name=香蕉3)
21:52:12.330 [pool-1-thread-5] INFO com.Producer - 线程pool-1-thread-5->第6次生产:Good(name=香蕉5)
21:52:12.330 [pool-1-thread-2] INFO com.Producer - 线程pool-1-thread-2->第6次生产:Good(name=香蕉2)
21:52:12.330 [pool-1-thread-1] INFO com.ThreadCommunicationDemo - 生产总次数 -> 7
21:52:12.330 [pool-1-thread-4] INFO com.Producer - 线程pool-1-thread-4->第6次生产:Good(name=香蕉1)
21:52:12.330 [pool-1-thread-5] INFO com.ThreadCommunicationDemo - 生产总次数 -> 8
21:52:12.330 [pool-1-thread-3] INFO com.ThreadCommunicationDemo - 生产总次数 -> 6
21:52:12.330 [pool-1-thread-2] INFO com.ThreadCommunicationDemo - 生产总次数 -> 9
21:52:12.330 [pool-1-thread-1] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 4
21:52:12.330 [pool-1-thread-4] INFO com.ThreadCommunicationDemo - 生产总次数 -> 10
21:52:12.331 [pool-1-thread-5] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 5
21:52:12.331 [pool-1-thread-4] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 6
21:52:12.331 [pool-1-thread-3] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 7
21:52:12.332 [pool-1-thread-2] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 8
21:52:12.369 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 7
21:52:12.369 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第3次消费：Good(name=香蕉5)
21:52:13.389 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 6
21:52:13.389 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第4次消费：Good(name=香蕉4)
21:52:14.336 [pool-1-thread-3] INFO com.Producer - 线程pool-1-thread-3->第8次生产:Good(name=香蕉6)
21:52:14.336 [pool-1-thread-2] INFO com.Producer - 线程pool-1-thread-2->第8次生产:Good(name=香蕉9)
21:52:14.336 [pool-1-thread-4] INFO com.Producer - 线程pool-1-thread-4->第11次生产:Good(name=香蕉10)
21:52:14.336 [pool-1-thread-5] INFO com.Producer - 线程pool-1-thread-5->第11次生产:Good(name=香蕉8)
21:52:14.336 [pool-1-thread-1] INFO com.Producer - 线程pool-1-thread-1->第11次生产:Good(name=香蕉7)
21:52:14.336 [pool-1-thread-2] INFO com.ThreadCommunicationDemo - 生产总次数 -> 12
21:52:14.336 [pool-1-thread-3] INFO com.ThreadCommunicationDemo - 生产总次数 -> 11
21:52:14.336 [pool-1-thread-5] INFO com.ThreadCommunicationDemo - 生产总次数 -> 14
21:52:14.336 [pool-1-thread-4] INFO com.ThreadCommunicationDemo - 生产总次数 -> 13
21:52:14.336 [pool-1-thread-2] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 7
21:52:14.336 [pool-1-thread-1] INFO com.ThreadCommunicationDemo - 生产总次数 -> 15
21:52:14.336 [pool-1-thread-3] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 8
21:52:14.337 [pool-1-thread-1] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 9
21:52:14.337 [pool-1-thread-4] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 10
21:52:14.337 [pool-1-thread-5] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 11
21:52:14.403 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 10
21:52:14.403 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第5次消费：Good(name=香蕉3)
21:52:15.419 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 9
21:52:15.419 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第6次消费：Good(name=香蕉7)
21:52:16.342 [pool-1-thread-5] INFO com.Producer - 线程pool-1-thread-5->第16次生产:Good(name=香蕉14)
21:52:16.342 [pool-1-thread-3] INFO com.Producer - 线程pool-1-thread-3->第16次生产:Good(name=香蕉11)
21:52:16.342 [pool-1-thread-1] INFO com.Producer - 线程pool-1-thread-1->第16次生产:Good(name=香蕉15)
21:52:16.342 [pool-1-thread-5] INFO com.ThreadCommunicationDemo - 生产总次数 -> 16
21:52:16.342 [pool-1-thread-3] INFO com.ThreadCommunicationDemo - 生产总次数 -> 17
21:52:16.342 [pool-1-thread-2] INFO com.Producer - 线程pool-1-thread-2->第16次生产:Good(name=香蕉12)
21:52:16.342 [pool-1-thread-4] INFO com.Producer - 线程pool-1-thread-4->第16次生产:Good(name=香蕉13)
21:52:16.343 [pool-1-thread-5] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 10
21:52:16.343 [pool-1-thread-2] INFO com.ThreadCommunicationDemo - 生产总次数 -> 19
21:52:16.343 [pool-1-thread-1] INFO com.ThreadCommunicationDemo - 生产总次数 -> 18
21:52:16.343 [pool-1-thread-4] INFO com.ThreadCommunicationDemo - 生产总次数 -> 20
21:52:16.343 [pool-1-thread-3] INFO com.DataBuffer - 缓存区队列已满！！！
21:52:16.343 [pool-1-thread-4] INFO com.DataBuffer - 缓存区队列已满！！！
21:52:16.343 [pool-1-thread-2] INFO com.DataBuffer - 缓存区队列已满！！！
21:52:16.343 [pool-1-thread-1] INFO com.DataBuffer - 缓存区队列已满！！！
21:52:16.443 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 9
21:52:16.443 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第7次消费：Good(name=香蕉8)
21:52:16.443 [pool-1-thread-3] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 10
21:52:17.459 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 9
21:52:17.460 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第8次消费：Good(name=香蕉10)
21:52:17.460 [pool-1-thread-4] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 10
21:52:18.357 [pool-1-thread-5] INFO com.Producer - 线程pool-1-thread-5->第17次生产:Good(name=香蕉16)
21:52:18.358 [pool-1-thread-5] INFO com.ThreadCommunicationDemo - 生产总次数 -> 21
21:52:18.358 [pool-1-thread-5] INFO com.DataBuffer - 缓存区队列已满！！！
21:52:18.453 [pool-1-thread-3] INFO com.Producer - 线程pool-1-thread-3->第18次生产:Good(name=香蕉17)
21:52:18.453 [pool-1-thread-3] INFO com.ThreadCommunicationDemo - 生产总次数 -> 22
21:52:18.453 [pool-1-thread-3] INFO com.DataBuffer - 缓存区队列已满！！！
21:52:18.468 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 9
21:52:18.468 [pool-1-thread-2] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 10
21:52:18.468 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第9次消费：Good(name=香蕉6)
21:52:19.462 [pool-1-thread-4] INFO com.Producer - 线程pool-1-thread-4->第19次生产:Good(name=香蕉20)
21:52:19.462 [pool-1-thread-4] INFO com.ThreadCommunicationDemo - 生产总次数 -> 23
21:52:19.462 [pool-1-thread-4] INFO com.DataBuffer - 缓存区队列已满！！！
21:52:19.477 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 9
21:52:19.477 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第10次消费：Good(name=香蕉9)
21:52:19.477 [pool-1-thread-1] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 10
21:52:20.484 [pool-1-thread-6] INFO com.DataBuffer - fetch() -> dataList 缓存区队列的长度 -> 9
21:52:20.484 [pool-1-thread-2] INFO com.Producer - 线程pool-1-thread-2->第20次生产:Good(name=香蕉19)
21:52:20.484 [pool-1-thread-5] INFO com.DataBuffer - add() -> dataList 缓存区队列的长度 -> 10
21:52:20.484 [pool-1-thread-2] INFO com.ThreadCommunicationDemo - 生产总次数 -> 24
21:52:20.484 [pool-1-thread-6] INFO com.Consumer - 线程pool-1-thread-6->第11次消费：Good(name=香蕉12)
21:52:20.484 [pool-1-thread-2] INFO com.DataBuffer - 缓存区队列已满！！！
…………
…………
…………
3、synchronized 八锁现象
3.1、Lock1
import java.util.concurrent.TimeUnit;
/**
* 该例子 call() 和 sendMes() 共用一个锁，谁先拿到谁先执行
*/
public class Lock1 {
public static void main(String[] args) {
Phone1 phone = new Phone1();
new Thread(() -> phone.sendMes(), "A").start();
// sleep 一秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> phone.call(), "B").start();
}
}
class Phone1 {
// synchronized 修饰非静态方法，是对调用该方法的对象加锁，俗称"对象锁"
public synchronized void sendMes() {
System.out.println(Thread.currentThread().getName() + " -> 发送消息");
}
public synchronized void call() {
System.out.println(Thread.currentThread().getName() + " -> 打电话");
}
}
/************************* 执行结果： *****************************/
A -> 发送消息
B -> 打电话
3.2、Lock2
import java.util.concurrent.TimeUnit;
/**
* 该例子 call() 和 sendMes() 共用一个锁，谁先拿到谁先执行
*/
public class Lock2 {
public static void main(String[] args) {
Phone2 phone2 = new Phone2();
new Thread(() -> phone2.sendMes(), "A").start();
// sleep 一秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> phone2.call(), "B").start();
}
}
class Phone2 {
// synchronized 修饰非静态方法，是对调用该方法的对象加锁，俗称"对象锁"
public synchronized void sendMes() {
try {
TimeUnit.SECONDS.sleep(4); // sleep 4秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " -> 发送消息");
}
public synchronized void call() {
System.out.println(Thread.currentThread().getName() + " -> 打电话");
}
}
/************************* 执行结果： *****************************/
A -> 发送消息
B -> 打电话
3.3、Lock3
import java.util.concurrent.TimeUnit;
/**
* call() 方法没有 synchronized 不受锁影响
*/
public class Lock3 {
public static void main(String[] args) {
Phone3 phone3 = new Phone3();
new Thread(() -> phone3.sendMes(), "A").start();
// sleep 一秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> phone3.call(), "B").start();
}
}
class Phone3 {
// synchronized 修饰非静态方法，是对调用该方法的对象加锁，俗称"对象锁"
public synchronized void sendMes() {
// sleep 4秒
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " -> 发送消息");
}
// 该方法没有 synchronized 不受锁影响
public void call() {
System.out.println(Thread.currentThread().getName() + " -> 打电话");
}
}
/************************* 执行结果： *****************************/
B -> 打电话
A -> 发送消息
3.4、Lock4
import java.util.concurrent.TimeUnit;
/**
* 两个对象，两个非静态同步方法，该例子实际上是两把锁。
*/
public class Lock4 {
public static void main(String[] args) {
Phone4 phone41 = new Phone4();
Phone4 phone42 = new Phone4();
new Thread(() -> phone41.sendMes(), "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> phone42.call(), "B").start();
}
}
class Phone4 {
// synchronized 修饰非静态方法，是对调用该方法的对象加锁，俗称"对象锁"
public synchronized void sendMes() {
// sleep 4秒
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " -> 发送消息");
}
public synchronized void call() {
System.out.println(Thread.currentThread().getName() + " -> 打电话");
}
}
/************************* 执行结果： *****************************/
B -> 打电话
A -> 发送消息
3.5、Lock5
import java.util.concurrent.TimeUnit;
/**
* 一个对象，两个静态同步方法，该例子实际上是共用一个锁（Phone5.class），谁先拿到谁先执行。
*/
public class Lock5 {
public static void main(String[] args) {
Phone5 phone5 = new Phone5();
new Thread(() -> phone5.sendMes(), "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> phone5.call(), "B").start();
}
}
class Phone5 {
// synchronized 修饰静态方法，是对调用该方法的class 模板加锁，俗称"类锁"。
public static synchronized void sendMes() {
// sleep 4秒
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " -> 发送消息");
}
public static synchronized void call() {
System.out.println(Thread.currentThread().getName() + " -> 打电话");
}
}
/************************* 执行结果： *****************************/
A -> 发送消息
B -> 打电话
3.6、Lock6
import java.util.concurrent.TimeUnit;
/**
* 两个对象，两个静态同步方法，该例子实际上是共用一个锁（Phone6.class），谁先拿到谁先执行。
*/
public class Lock6 {
public static void main(String[] args) {
Phone6 phone61 = new Phone6();
Phone6 phone62 = new Phone6();
new Thread(() -> phone61.sendMes(), "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> phone62.call(), "B").start();
}
}
class Phone6 {
// synchronized 修饰静态方法，是对调用该方法的class 模板加锁，俗称"类锁"。
public static synchronized void sendMes() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " -> 发送消息");
}
public static synchronized void call() {
System.out.println(Thread.currentThread().getName() + " -> 打电话");
}
}
/************************* 执行结果： *****************************/
A -> 发送消息
B -> 打电话
3.7、Lock7
import java.util.concurrent.TimeUnit;
/**
* 一个对象，一个静态同步方法，一个非静态同步方法
* 该例子实际上是两个锁（Phone7.class 和 phone7对象）。
* 说明：如果一个线程 A 调用一个实例对象的非静态 synchronized 方法，
* 而线程 B 需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，
* 因为访问静态 synchronized 方法占用的锁是当前类的锁，
* 而访问非静态 synchronized 方法占用的锁是当前实例对象锁。
*/
public class Lock7 {
public static void main(String[] args) {
Phone7 phone7 = new Phone7();
new Thread(() -> phone7.sendMes(), "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> phone7.call(), "B").start();
}
}
class Phone7 {
// synchronized 修饰静态方法，是对调用该方法的class 模板加锁，俗称"类锁"。
public static synchronized void sendMes() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " -> 发送消息");
}
// synchronized 修饰非静态方法，是对调用该方法的对象加锁，俗称"对象锁"
public synchronized void call() {
System.out.println(Thread.currentThread().getName() + " -> 打电话");
}
}
/************************* 执行结果： *****************************/
B -> 打电话
A -> 发送消息
3.8、Lock8
import java.util.concurrent.TimeUnit;
/**
* 两个对象，一个静态同步方法，一个非静态同步方法
* 该例子实际上是两个锁（Phone8.class 和 phone82对象）。
*/
public class Lock8 {
public static void main(String[] args) {
Phone8 phone81 = new Phone8();
Phone8 phone82 = new Phone8();
new Thread(() -> phone81.sendMes(), "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> phone82.call(), "B").start();
}
}
class Phone8 {
// synchronized 修饰静态方法，是对调用该方法的class 模板加锁，俗称"类锁"。
public static synchronized void sendMes() {
// sleep 4秒
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " -> 发送消息");
}
// synchronized 修饰非静态方法，是对调用该方法的对象加锁，俗称"对象锁"
public synchronized void call() {
System.out.println(Thread.currentThread().getName() + " -> 打电话");
}
}
/************************* 执行结果： *****************************/
B -> 打电话
A -> 发送消息
线程系列博文：
线程系列 1 - 线程基础
线程系列 2 - 并发编程之线程池 ThreadPool 的那些事
线程系列 3 - 关于 CompletableFuture
线程系列 5 - CAS 和 JUC原子类
线程系列 6 - JUC相关的显示锁
线程系列 7 - JUC高并发容器类
.