java等待服务器响应速度慢 java等待通知机制

转载

mob64ca13fb6939 2024-05-03 09:38:10

文章标签 java等待服务器响应速度慢生产者等待java 数据 ci 生产者消费者 文章分类 Java 后端开发

一、什么是等待-通知机制

如果线程要求的条件不满足，则线程阻塞自己，进入等待状态；当线程要求的条件满足后，通知等待的线程重新执行。用简单的代码来理解:

synchronized(锁对象){
while (条件不满足){
wait();
}
//条件满足时
//do sthing
notify();
}

这可以看成是多线程编程中的一种范式，需要注意这里必须使用while,因为执行wait()方法进入阻塞后会停留在这里，当被其他线程唤醒后，需要再一次判断条件是否满足，因为这时有可能资源已经别的线程先抢占了。还有一点需要注意wait()和notify()必须在同步代码块中使用(就是已经获得锁了的情况下)。这是因为线程状态转换是有规定的，比如线程只能从running状态进入waiting状态。如果不是这样的情况就会报 java.lang.IllegalMonitorStateException()错误。

二、生产者消费者模型

1.理解有缓冲区的生产者消费者模型。

image.png

生产者消费者可以说是等待通知机制的典型应用了，直接看代码，使用wait(),notify()实现一个简单的生产者消费者模型

/**
* @date 2020/3/22
*/
public class ProducerComsumer {
LinkedList list = new LinkedList<>();//缓冲区
public static void main(String[] args) throws InterruptedException {
ProducerComsumer producerComsumer = new ProducerComsumer();
Thread thread1 = new Thread(()->{
while (true) {
try {
producerComsumer.producer();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
Thread thread2 = new Thread(()->{
while (true) {
try {
producerComsumer.comsumer();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
thread1.start();
thread2.start();
}
public void producer() throws InterruptedException {
Random random = new Random();
synchronized (this) {
//当容器满时就等待消费者消费数据,容器不满时就往里面放数据
while (list.size() == 5) {
wait();
}
int i = random.nextInt(10);
list.add(i);
System.out.printf("当前线程%s生产了数据%d \n", Thread.currentThread().getName(), i);
notifyAll();
}
}
public void comsumer() throws InterruptedException {
synchronized (this) {
//当容器为空时，就等待生产者往里面放数据。容器不为空时就消费数据
while (list.size() == 0) {
wait();
}
Integer remove = list.removeFirst();
System.out.printf("当前线程%s消费了%d \n", Thread.currentThread().getName(), remove);
notifyAll();
}
}
}

如果对锁的机制还不太熟悉的话，理解这个例子需要注意的是wait(),notify()只能唤醒同一个对象锁中的等待线程。在这里这个锁对象是this。

使用Lock ,Condition实现生产者消费者模型

先看一下java.util.concurrent包中的阻塞队列是如何实现阻塞的(仅讨论take()和put()方法，这两个方法在条件不满足时会阻塞一直等待)。

几个关键的参数：

/** 这个队列中都使用这把锁 */
private ReentrantLock lock;
/** 存放元素的数组 */
private Object[] items;
/** 锁对应的数组元素为空时的条件 */
private Condition notEmpty;
/** 锁对应的数组元素为满的条件 */
private Condition notFull;
/** 数组中元素的数量 */
int count;
这几个参数会在构造方法中初始化。
public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}

在生产者方面，调用存数据的方法，当数据满了时就调用notFull.await()(相当于Object.wait())进入等待，直到消费者消费了数据以后，通过调用notFull.signal()(相当于Object.notify())来唤醒生产者继续生产。下面抽取2个主要的方法：

public void put(E e) throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
}
private void enqueue(E x) {
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
items[putIndex] = x;
if (++putIndex == items.length)
putIndex = 0;
count++;
notEmpty.signal();
}

在消费者方面，调用取数据的方法，当数据为空时就调用notEmpty.await()进入等待，直到生产者生产了数据以后，通过调用notEmpty.signal()来唤醒消费者者继续生产。下面看一下主要的两个方法：

public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
notFull.signal();
return x;
}
可以看到这是很明显的等待-通知的形式了。
接下来可以模仿ArrayBlockingQueue这种方式实现生产者消费者模型。
/**
* @author xiaobenneng@hotmail.com
* @date 2020/3/22
*/
public class ProducerComsumer {
public static void main(String[] args) {
ProducerComsumer producerComsumer = new ProducerComsumer(5);
new Thread(()->{
Random random = new Random();
while (true) {
int i = random.nextInt(10);
try {
producerComsumer.put(i);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}).start();
new Thread(()->{
while (true) {
try {
Integer take = producerComsumer.take();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}).start();
}
private ReentrantLock lock;
/** 存放元素的链表 */
private LinkedList items;
/** 锁对应的数组元素为空时的条件 */
private Condition notEmpty;
/** 锁对应的数组元素为满的条件 */
private Condition notFull;
/** 链表中最大元素的数量 */
int capacity;
public ProducerComsumer(int capacity) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new LinkedList();
this.capacity = capacity;
lock = new ReentrantLock();
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}
public void put(E e) throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (capacity == items.size()) {
notFull.await();
}
items.addLast(e);
System.out.printf("当前线程%s生产数据%d,总数%d \n",Thread.currentThread().getName(), e,items.size());
notEmpty.signal();
} finally {
lock.unlock();
}
}
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (items.size() == 0) {
notEmpty.await();
}
E e = items.removeFirst();
System.out.printf("当前线程%s消费数据%d,剩余总数%d \n",Thread.currentThread().getName(),e, items.size());
notFull.signal();
return e;
} finally {
lock.unlock();
}
}
}
测试结果
当前线程Thread-0生产数据5,总数1
当前线程Thread-0生产数据1,总数2
当前线程Thread-0生产数据0,总数3
当前线程Thread-0生产数据7,总数4
当前线程Thread-0生产数据8,总数5
当前线程Thread-1消费数据5,剩余总数4
当前线程Thread-1消费数据1,剩余总数3
当前线程Thread-1消费数据0,剩余总数2
当前线程Thread-1消费数据7,剩余总数1
当前线程Thread-1消费数据8,剩余总数0
模拟一种场景，当生产力大于消费力时，通过在消费者端sleep一段时间模拟这个场景
public static void main(String[] args) {
ProducerComsumer producerComsumer = new ProducerComsumer(5);
Random random = new Random();
new Thread(()->{
while (true) {
int i = random.nextInt(10);
try {
producerComsumer.put(i);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}).start();
new Thread(()->{
while (true) {
try {
Integer take = producerComsumer.take();
//处理数据花费时间
Thread.sleep(0,random.nextInt(500));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}).start();
new Thread(()->{
while (true) {
try {
Integer take = producerComsumer.take();
//处理数据花费时间
Thread.sleep(0,random.nextInt(400));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}).start();
}
运行结果
当前线程Thread-0生产数据6,总数4
当前线程Thread-0生产数据7,总数5
当前线程Thread-1消费数据0,剩余总数4
当前线程Thread-2消费数据6,剩余总数3
当前线程Thread-0生产数据5,总数4
当前线程Thread-0生产数据9,总数5
当前线程Thread-1消费数据5,剩余总数4
当前线程Thread-2消费数据6,剩余总数3
当前线程Thread-0生产数据7,总数4
当前线程Thread-0生产数据4,总数5

生产者生产数据的速度远远大过消费者消费数据速度，这体现了这种模式的优势，生产者不依赖消费者，生产的数据先放入缓存区，消费者再慢慢消费，处理结果使用异步返回。对于消费者来讲，因为消费者处理任务的能力是有限的，这时候也对服务器资源起到了保护的作用，比如可以避免过多的请求发送到mysql。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。