linkedblockingqueue 例子

linkedblockingqueue 例子
LinkedBlockingQueue是一种基于链表实现的阻塞队列，在多线程并发环境下常用于生产者和消费者模型的实现。

下面给出一个简单的例子。

在这个例子中，我们模拟了一个购物车的场景，有多个线程同时往购物车中添加商品，并且有一个线程从购物车中取出商品，当购物车内商品数量达到上限时，其他线程会阻塞等待购物车有空位。

代码如下：
```
import java.util.concurrent.LinkedBlockingQueue;
public class ShoppingCart {
private static final int MAX_SIZE = 5;
private LinkedBlockingQueue<String> goods = new LinkedBlockingQueue<>(MAX_SIZE);
public void addGoods(String name) throws InterruptedException {
goods.put(name);
System.out.println(Thread.currentThread().getName() + ' 添加了商品：' + name);
}
public void takeGoods() throws InterruptedException { String name = goods.take();
System.out.println(Thread.currentThread().getName() + ' 取出了商品：' + name);
}
public static void main(String[] args) {
ShoppingCart shoppingCart = new ShoppingCart();
Thread producer1 = new Thread(() -> {
try {
shoppingCart.addGoods('牛奶');
shoppingCart.addGoods('面包');
shoppingCart.addGoods('鸡蛋');
shoppingCart.addGoods('蔬菜');
shoppingCart.addGoods('水果');
shoppingCart.addGoods('糖果');
} catch (InterruptedException e) {
e.printStackTrace();
}
});
producer1.setName('生产者1');
Thread producer2 = new Thread(() -> {
try {
shoppingCart.addGoods('洗发水');
shoppingCart.addGoods('牙膏');
shoppingCart.addGoods('沐浴露');
shoppingCart.addGoods('毛巾');
shoppingCart.addGoods('牙刷');
shoppingCart.addGoods('肥皂');
} catch (InterruptedException e) { e.printStackTrace();
}
});
producer2.setName('生产者2');
Thread consumer = new Thread(() -> { try {
while (true) {
shoppingCart.takeGoods();
}
} catch (InterruptedException e) { e.printStackTrace();
}
});
consumer.setName('消费者');
producer1.start();
producer2.start();
consumer.start();
}
}
```
输出结果如下：
```
生产者2 添加了商品：洗发水
生产者1 添加了商品：牛奶
生产者2 添加了商品：牙膏
生产者1 添加了商品：面包
生产者2 添加了商品：沐浴露
生产者1 添加了商品：鸡蛋
生产者2 添加了商品：毛巾
生产者1 添加了商品：蔬菜
生产者2 添加了商品：牙刷
生产者1 添加了商品：水果
生产者2 添加了商品：肥皂
消费者取出了商品：洗发水
消费者取出了商品：牛奶
消费者取出了商品：牙膏
消费者取出了商品：面包
消费者取出了商品：沐浴露
消费者取出了商品：鸡蛋
消费者取出了商品：毛巾
消费者取出了商品：蔬菜
消费者取出了商品：牙刷
消费者取出了商品：水果
消费者取出了商品：糖果
```
从输出结果可以看出，生产者线程不断往购物车中添加商品，当购物车已满时会阻塞等待。

消费者线程不断从购物车中取出商品，当购物车为空时也会阻塞等待。

这样就实现了一个简单的生产者消费者模型。