注:本文面向有一定java基础的用户
前置知识
我们都知道java的顶级父对象为超类 java.lang.Object
其中里面有3个跟线程通信的方法为
//注意,以下的方法都需要在synchronized同步块中进行使用,否则会报错,因为实际上锁是存在一个称为对象头的数据结构里面的,有兴趣的话可以自行百度,每个java对象都会有一个对象头
wait(); // 把当前的线程抢到的对象锁释放出来,并挂起自己
notify(); //唤醒一个由于调用wait()方法而被挂起的线程,随机唤醒
notifyAll(); //唤醒全部线程
当某个线程调用了wait()之后如果没有其他人调用对象的notify()或者notifyAll()方法,那么该线程就会被永远挂起直到天荒地老
//一个简单的例子
Object object = new Object();
new Thread(() -> {
System.out.println("调用对象锁的wait方法");
synchronized (object) {
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("永远不会停止了,因为线程被永远挂起,也没有人可以唤醒它");
}).start();
当然obejct提供了一些重载方法,比如
wait(long timeout)之类的,这里就不细说了,大概意思就是说只挂起线程多久
Object object = new Object();
new Thread(() -> {
System.out.println("调用对象锁的wait方法");
synchronized (object) {
try {
object.wait(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("1s后自动恢复,因为线程被指定了挂起时间");
}).start();
生成者与消费者的例子
package com.zxc.shradingjdbc.juc;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
public class ThreadTest {
private static int size = 10;
public static void main(String[] args) throws Exception{
Queue<Integer> queue = new LinkedList<>();
Object object = new Object();
Thread producer = producer(queue, object);
Thread consumer = consumer(queue, object);
//注:由于while(true)底层占用cpu的级别非常高,所以可能交替效果不是太明显,
//可以把size调大点,这个效果就会比较明显了
producer.start();
consumer.start();
}
public static Thread producer(Queue<Integer> queue, Object object) throws InterruptedException {
return new Thread(() -> {
while (true) {
synchronized (object) {
while (queue.size() >= size) {
try {
object.wait(); //如果队列满了,就挂起当前线程,等待唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//往队列里面放数据,同时通知其他线程,这里只有消费者线程,可以进行消费了
int nextInt = new Random().nextInt(1000);
queue.add(nextInt);
System.out.println("生成者--->放数据add=" + nextInt + "size=" + queue.size());
object.notifyAll();
}
}
});
}
public static Thread consumer(Queue<Integer> queue, Object object) throws InterruptedException {
return new Thread(() -> {
while (true) {
synchronized (object) {
while (queue.size() == 0) {
{
try {
object.wait(); //如果队列为空,就挂起当前线程,等待唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//获取数据,并且通知其他线程,这里只有生成者可以进行生产数据了
Integer poll = queue.poll();
System.out.println("消费者拿数据poll=" + poll + "size=" + queue.size());
object.notifyAll();
}
}
});
}
}
注:最底层的原理需要参考jvm虚拟机实现逻辑,以下的分析是个人的一种看法,并不保证一定是对的,实际上synchronized就是把并发的线程给整成串行的逻辑去处理了,那么必然需要一个数据结构来存储这些要执行的线程,同时需要有对应的唤醒机制
实现的基本原理,从对象锁本身来看待这件事可能就会比较清晰
synchronized 锁的是对象里面一个叫Monitor的对象,可以简单理解为一个属性
对象头里面的大概数据有这2个数据
Monitor 锁对象
waitSet 等待线程集合
比如有线程A,B同时要抢对象的锁
A抢到了以后,那么会进入A线程的代码块,然后执行业务逻辑
B线程此时就会被临时放到waitSet里面去,等待A线程释放锁
当A线程业务执行完毕以后,他就会通知B线程可以去拿锁了
while(加锁) {
if(成功){
跳出循环;
}
//放入waitset集合里面去
}
//业务代码数据
//释放锁,通知B线程去重新获取锁,获取成功他就也可以执行自己的业务代码块了
而上面的例子,调用对象的wait方法,实际上就类似于把当前线程放到waitset里面去
调用对象的Notify方法,实际上就是类似于通知waitset里面的线程锁已经被释放,可以去抢锁了