生产者消费者问题，为什么t1和t2线程执行不完啊？？？到这晕菜了，线程是怎么循环啊？？什么时候线程执行完毕啊？？？

//描述资源
class ZiYuan
{
        private String name;
        private int count;
        
        //定义标记
        private boolean flag;

        //提供给商品赋值的方法
        public synchronized void set(String name)
        {
                if(flag)//判断标记为true，执行wait等待，为false，就生产
                        
                {
                        try
                        {
                                wait();
                        }
                        catch (InterruptedException e)
                        {
                        }
                }
               
                this.name=name+"--"+count;
                count++;

                System.out.println(Thread.currentThread().getName()+"生产"+this.name);

                //生产完毕，将标记改为true
                flag=true;
                //唤醒消费者
                notify();
        }

   //提供获取商品的方法
        public synchronized void get()
        {
                if(!flag)
                {
                        try
                        {
                                wait();
                        }
                        catch (InterruptedException e)
                        {
                        }
                }
               
                System.out.println(Thread.currentThread().getName()+"消费"+this.name);

                //消费完毕，将标记改为false
                flag=false;
                //唤醒生产者
                notify();
        }
}


class ShengChanZhe implements Runnable
{
        private ZiYuan z;
        public ShengChanZhe(ZiYuan z)
        {
                this.z=z;
        }

        public void run()
        {
                z.set("面包");
        }
}


class XiaoFeiZhe implements Runnable
{
        private ZiYuan z;
        public XiaoFeiZhe(ZiYuan z)
        {
                this.z=z;
        }

        public void run()
        {
                z.get();
        }
}


class ShengChanXiaoFei
{
        public static void main(String[] args)
        {
                //创建资源
                ZiYuan z=new ZiYuan();
               
                //创建两个任务
                ShengChanZhe s=new ShengChanZhe(z);
                XiaoFeiZhe x=new XiaoFeiZhe(z);
               
                //创建线程
                Thread t1=new Thread(s);
                Thread t2=new Thread(x);

                t1.start();
                t2.start();

        }
}

这个问题说起来有点复杂
建议多看几遍毕老师关于线程的讲解，很详细，如果跟着毕老师的思路听下云，一定能理解
剩下的就是自己模拟了

你在资源中没有设定资源的多少啊,那样肯定会一直运行下去,比如毕老师买票的例子,卖一百张票,卖掉一张就少一张,最后全部卖完!
我将代码改动一下,定义 count为100;
然后资源被占用时count就减减
class ZiYuan
{
         private String name;
         private int count=100;
         
         //定义标记
         private boolean flag;

        //提供给商品赋值的方法
         public synchronized void set(String name)
         {
                 if(flag)//判断标记为true，执行wait等待，为false，就生产
                        
                 {
                         try
                         {
                                 wait();
                         }
                         catch (InterruptedException e)
                         {
                         }
                 }
                 
                this.name=name+"--"+count;
                 count--;

                System.out.println(Thread.currentThread().getName()+"生产"+this.name);

                //生产完毕，将标记改为true
                 flag=true;
                 //唤醒消费者
                 notify();
         }

   //提供获取商品的方法
         public synchronized void get()
         {
                 if(!flag)
                 {
                         try
                         {
                                 wait();
                         }
                         catch (InterruptedException e)
                         {
                         }
                 }
                 
                System.out.println(Thread.currentThread().getName()+"消费"+this.name);

                //消费完毕，将标记改为false
                 flag=false;
                 //唤醒生产者
                 notify();
         }
}

class ShengChanZhe implements Runnable
{
         private ZiYuan z;
         public ShengChanZhe(ZiYuan z)
         {
                 this.z=z;
         }

        public void run()
         {
                 z.set("面包");
         }
}

class XiaoFeiZhe implements Runnable
{
         private ZiYuan z;
         public XiaoFeiZhe(ZiYuan z)
         {
                 this.z=z;
         }

        public void run()
         {
                 z.get();
         }
}

class MyTest3
{
         public static void main(String[] args)
        {
                 //创建资源
                 ZiYuan z=new ZiYuan();
                 
                //创建两个任务
                 ShengChanZhe s=new ShengChanZhe(z);
                 XiaoFeiZhe x=new XiaoFeiZhe(z);
                 
                //创建线程
                 Thread t1=new Thread(s);
                 Thread t2=new Thread(x);

                t1.start();
                 t2.start();

}
}

顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶

你的两个线程 (不包括主线程) 已近执行完了,但是每个线程只执行了一次,因为线程没有循环结构,代码执行完,程序也就结束了,

对楼主的代码稍加改动,加入了while循环,则每个线程执行100次结束,代码如下

1. //package day21;
   
2. class ZiYuan
   
3. {
   
4.          private String name;
   
5.          private int count=100;
   
6.          
   
7.          //定义标记
   
8.          private boolean flag;
   
9. 
   
10.         //提供给商品赋值的方法
    
11.          public synchronized void set(String name)
    
12.          {
    
13.                  while(count>0){
    
14.                  if(flag)//判断标记为true，执行wait等待，为false，就生产
    
15.                         
    
16.                  {
    
17.                          try
    
18.                          {
    
19.                                  wait();
    
20.                          }
    
21.                          catch (InterruptedException e)
    
22.                          {
    
23.                          }
    
24.                  }
    
25.                  
    
26.                 this.name=name+"--"+count;
    
27.                  count--;
    
28. 
    
29.                 System.out.println(Thread.currentThread().getName()+"生产"+this.name);
    
30. 
    
31.                 //生产完毕，将标记改为true
    
32.                  flag=true;
    
33.                  //唤醒消费者
    
34.                  notify();
    
35.                  }
    
36.          }
    
37. 
    
38.    //提供获取商品的方法
    
39.          public synchronized void get()
    
40.          {
    
41.                  while(count>0){
    
42.                  if(!flag)
    
43.                  {
    
44.                          try
    
45.                          {
    
46.                                  wait();
    
47.                          }
    
48.                          catch (InterruptedException e)
    
49.                          {
    
50.                          }
    
51.                  }
    
52.                  
    
53.                 System.out.println(Thread.currentThread().getName()+"消费"+this.name);
    
54. 
    
55.                 //消费完毕，将标记改为false
    
56.                  flag=false;
    
57.                  //唤醒生产者
    
58.                  notify();
    
59.                  }
    
60.          }
    
61. }
    
62. 
    
63. class ShengChanZhe implements Runnable
    
64. {
    
65.          private ZiYuan z;
    
66.          public ShengChanZhe(ZiYuan z)
    
67.          {
    
68.                  this.z=z;
    
69.          }
    
70. 
    
71.         public void run()
    
72.          {
    
73.                  z.set("面包");
    
74.          }
    
75. }
    
76. 
    
77. class XiaoFeiZhe implements Runnable
    
78. {
    
79.          private ZiYuan z;
    
80.          public XiaoFeiZhe(ZiYuan z)
    
81.          {
    
82.                  this.z=z;
    
83.          }
    
84. 
    
85.         public void run()
    
86.          {
    
87.                  z.get();
    
88.          }
    
89. }
    
90. 
    
91. class MyTest3
    
92. {
    
93.          public static void main(String[] args)
    
94.         {
    
95.                  //创建资源
    
96.                  ZiYuan z=new ZiYuan();
    
97.                  
    
98.                 //创建两个任务
    
99.                  ShengChanZhe s=new ShengChanZhe(z);
    
100.                  XiaoFeiZhe x=new XiaoFeiZhe(z);
     
101.                  
     
102.                 //创建线程
     
103.                  Thread t1=new Thread(s);
     
104.                  Thread t2=new Thread(x);
     
105. 
     
106.                 t1.start();
     
107.                  t2.start();
     
108. 
     
109. }
     
110. }

复制代码