思想：
1、生产者在while循环里不停地生产“产品”，每生产一个，就交给店员，店员就得到一个产品
2、消费者在while循环里不停地消费产品，每消费一个，店员就移走一个产品
3、店员手里的产品少于20个，就从生产者那里拿走产品。等于20个，就停止从生产者那里拿走产品
4、店员手里的产品多于0个，就让消费者消费产品。等于0个，就停止让消费者消费产品
?
生产者：
生产者在while循环里不停地生产“产品”，每生产一个，就交给店员，店员就得到一个产品
//生产者
class Producter implements Runnable{
Clerk clerk;
Producter(Clerk clerk){
this.clerk=clerk;
}
@Override
public void run() {
while (true){
//此处可加sleep，让生产者生产的慢一点
clerk.getProduce();//生产者不停地生产产品，生产一个，就交给店员，店员就get一个
}
}
}
消费者：
消费者在while循环里不停地消费产品，每消费一个，店员就移走一个产品
//消费者
class Consummer implements Runnable{
Clerk clerk;
Consummer(Clerk clerk){
this.clerk=clerk;
}
@Override
public void run() {
while (true){
//此处可加sleep，让消费者消费的慢一些
clerk.removeProduce();//消费者不停地消费产品，消费一个，店员处就remove一个
}
}
}
店员：
店员手里的产品少于20个，就从生产者那里拿走产品。等于20个，就停止从生产者那里拿走产品
店员手里的产品多于0个，就让消费者消费产品。等于0个，就停止让消费者消费产品
//店员
class Clerk{
public int producenumber;//店员手里产品的数量
public synchronized void getProduce() {//锁是clerk，反复执行的实际上是该方法和removeProduce方法
if(producenumber<20){//店员手里产品数量少于20个，就从生产者那里拿过来一个
producenumber++;
System.out.println(Thread.currentThread().getName()+"生产了第"+producenumber+"个产品");
notify();//已经从生产者那里拿过来一个产品了，说明手里肯定是有产品的，店员可以让消费者拿走产品了
}else{
try {
wait();//店员手里产品数量多于20个，停止从生产者那里拿走产品
} catch (InterruptedException e) {
System.out.println(e.getMessage());
}
}
}
public synchronized void removeProduce(){//锁是clerk，相当于四个线程一个一个的执行
if(producenumber>0){//店员手里产品数量多余0个，就让消费者拿走产品
System.out.println(Thread.currentThread().getName()+"消费了第"+producenumber+"个产品");
producenumber--;
notify();//已经让消费者拿走了一个产品，说明柜台肯定有位置放产品，店员可以从生产者那里取产品了
}else{
try {
wait();//店员手里产品数量少于0个，停止让消费者拿走产品
} catch (InterruptedException e) {
System.out.println(e.getMessage());
}
}
}
}
测试类：
public class ThreadCommunicationTest {
public static void main(String[] args) {
Clerk clerk=new Clerk();
Producter p=new Producter(clerk);
Thread tp1=new Thread(p);
tp1.setName("生产者1");
tp1.start();
Thread tp2=new Thread(p);
tp2.setName("生产者2");
tp2.start();
Consummer c=new Consummer(clerk);
Thread tc1=new Thread(c);
tc1.setName("消费者1");
tc1.start();
Thread tc2=new Thread(c);
tc2.setName("消费者2");
tc2.start();
}
}Attention：
一共有四个线程：生产者1、生产者2、消费者1、消费者2
生产者1和生产者2线程开启后，调用Producter类里的run方法，又在run方法里调用Clerk类里的getProduce方法
相当于生产者1和生产者2反复执行的是getProduce方法
生产者1和生产者2线程开启后，调用PConsummer类里的run方法，又在run方法里调用Clerk类里的removeProduce方法
相当于消费者1和消费者2反复执行的是removeProduce方法
而getProduce方法和removeProduce方法都是同步方法，它们都在Clerk类中定义，而Clerk类从始至终只有一个对象，所以两个同步方法的锁是同一把，即Clerk类的实例对象clerk
意味着在两个方法中，四个线程只能一个一个的执行，因此线程安全
执行截图：
?