package thread;
public class ProducerConsumer {
public static void main(String args[]){
SyncStack ss = new SyncStack();//
Producer p = new Producer(ss) ; //new生产者对象
Consumer c = new Consumer(ss) ;//new消费者对象
new Thread (p).start();
new Thread (p).start();
new Thread (p).start();
new Thread (c).start();
}
}
class WoTou {//建立对象WoTou
int id ;
WoTou(int id){
this.id = id;
}
public String toString(){
return "WoTou: " +id;//返回 WoTou的id ；
}
}
class SyncStack{
int index = 0 ;
WoTou arrWT[] = new WoTou[6];//定义数组arrWT[]的类型为 WoTou ；长度为 6 ；
public synchronized void push(WoTou wt){
while(index == arrWT.length){//判定语句 index = arrWT.length ; 即篮子装满了窝头；
try{
this.wait();//线程进入等待状态
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.notifyAll();//当篮子的窝头被消耗掉后唤醒所有锁定的等待的线程 ，
arrWT[index] = wt;//继续往数组填充窝头 ，即篮子
index++;
}
public synchronized WoTou pop(){
while(index == 0) {
try {
this.wait();//满足while条件则 线程进入 等待执行状态，直到被唤醒；
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.notifyAll();//唤醒等待的线程
index--;
return arrWT[index] ;//返回窝头 及 index 的值；
}
}
class Producer implements Runnable{//生产者接口实现
SyncStack ss = null ;//定义篮子初始值为空
Producer(SyncStack ss){
this.ss = ss ;
}
public void run(){
for(int i = 0 ; i < 20;i++){//进行20次循环
WoTou wt = new WoTou(i);//定义生产 20 个窝头
ss.push(wt);//调用push（WoTou wt）方法
System.out.println("生产了："+wt);//输出生产的馒头数量
try {
Thread.sleep((int)(Math.random()*200));//每生产一个窝头 休眠 （0.0 ， 1.0 ）*200 中的随机一个时间 ，给其他线程运行的时间；
}catch(InterruptedException e){//捕获异常；
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable{//消费者接口实现
SyncStack ss = null ;
Consumer(SyncStack ss){
this.ss = ss;
}
public void run(){
for (int i = 0 ;i< 20 ; i++){
WoTou wt = ss.pop();//调用 WoTou pop（）方法
System.out.println("消费了："+ wt);//输出消耗的馒头数量
try {
Thread.sleep((int)(Math.random()*200));//每生产一个窝头 休眠 （0.0 ， 1.0 ）*200 中的随机一个时间 ，给其他线程运行的时间；
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
这个 sychpackage thread;
public class ProducerConsumer {
public static void main(String args[]){
SyncStack ss = new SyncStack();//
Producer p = new Producer(ss) ; //new生产者对象
Consumer c = new Consumer(ss) ;//new消费者对象
new Thread (p).start();
new Thread (p).start();
new Thread (p).start();
new Thread (c).start();
}
}
class WoTou {//建立对象WoTou
int id ;
WoTou(int id){
this.id = id;
}
public String toString(){
return "WoTou: " +id;//返回 WoTou的id ；
}
}
class SyncStack{
int index = 0 ;
WoTou arrWT[] = new WoTou[6];//定义数组arrWT[]的类型为 WoTou ；长度为 6 ；
public synchronized void push(WoTou wt){
while(index == arrWT.length){//判定语句 index = arrWT.length ; 即篮子装满了窝头；
try{
this.wait();//线程进入等待状态
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.notifyAll();//当篮子的窝头被消耗掉后唤醒所有锁定的等待的线程 ，
arrWT[index] = wt;//继续往数组填充窝头 ，即篮子
index++;
}
public synchronized WoTou pop(){
while(index == 0) {
try {
this.wait();//满足while条件则 线程进入 等待执行状态，直到被唤醒；
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.notifyAll();//唤醒等待的线程
index--;
return arrWT[index] ;//返回窝头 及 index 的值；
}
}
class Producer implements Runnable{//生产者接口实现
SyncStack ss = null ;//定义篮子初始值为空
Producer(SyncStack ss){
this.ss = ss ;
}
public void run(){
for(int i = 0 ; i < 20;i++){//进行20次循环
WoTou wt = new WoTou(i);//定义生产 20 个窝头
ss.push(wt);//调用push（WoTou wt）方法
System.out.println("生产了："+wt);//输出生产的窝头数量
try {
Thread.sleep((int)(Math.random()*200));//每生产一个窝头 休眠 （0.0 ， 1.0 ）*200 中的随机一个时间 ，给其他线程运行的时间；
}catch(InterruptedException e){//捕获异常；
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable{//消费者接口实现
SyncStack ss = null ;
Consumer(SyncStack ss){
this.ss = ss;
}
public void run(){
for (int i = 0 ;i< 20 ; i++){
WoTou wt = ss.pop();//调用 WoTou pop（）方法
System.out.println("消费了："+ wt);//输出消耗的馒头数量
try {
Thread.sleep((int)(Math.random()*200));//每生产一个窝头 休眠 （0.0 ， 1.0 ）*200 中的随机一个时间 ，给其他线程运行的时间；
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
这个 synchronized 不是锁定只允许一个线程访问 里面的内容吗？ 但是this.notifyAll 是唤醒 所有的线程 ，这中间是不是有什么矛盾 呢？还有 ，麻烦 各位哥哥姐姐 看看我的注释是否有错误，有的话麻烦帮修改一下，谢谢！！！ |
|
收藏
淘帖
踩
