基于内置锁的生产者消费者模型

这里有三个概念，生产者，消费者，仓库

public class Repository {
private int capability;//仓库容量
private boolean stoped=false;//生产者线程是否退出的标志，如果生产者线程退出，则消费者线程消费完所以商品后也退出，而不是等待
private List<String> list=new ArrayList<>();
public Repository(int capability){
this.capability=capability;
}
public synchronized void add(String product) throws InterruptedException {
list.add(product);
}
public synchronized String remove() throws InterruptedException {
return list.remove(0);
}
public boolean isFull(){
return list.size()==capability;
}
public boolean isEmpty(){
return list.size()==0;
}
public void stop(){
stoped=true;
}
public boolean isStoped(){
return stoped;
}
}

public class Productor extends Thread {
private Repository repository;
private int i=1;
public Productor(Repository repository){
this.repository=repository;
}
@Override
public void run(){
while (i<1000){
synchronized (repository){
try {
if(!repository.isFull()){
Thread.sleep(100);
String product=Thread.currentThread().getName()+(i++);
System.out.println("生产商品："+product);
repository.add(product);
repository.notifyAll();
}else {
System.out.println("仓库已满，暂停生产");
//                        repository.notifyAll();如果notifyAll放在此次，则只有仓库满的时候会通知消费者
repository.wait();
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
repository.stop();
}
}

public class Consumer extends Thread {
private Repository repository;
public Consumer(Repository repository){
this.repository=repository;
}
@Override
public void run(){
boolean stoped=false;
while (!stoped){
synchronized (repository){
try {
if(!repository.isEmpty()){
System.out.println("消费商品："+repository.remove());
repository.notifyAll();
}else {
System.out.println("仓库已空，暂停消费");
if(repository.isStoped()){
stoped=true;
}else{
//                            repository.notifyAll();如果notifyAll放在此次，则只有仓库空的时候会通知生产者者
repository.wait();
}
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

public class Main {
public static void main(String[] args) throws InterruptedException {
Repository repository=new Repository(100);
new Productor(repository).start();
Thread.sleep(10000);
new Consumer(repository).start();
}
}