1. /*
   
2. 当多个线程操作生产,多个线程操作销售时
   
3. */
   
4. //商品资源库;
   
5. import java.util.concurrent.locks.*;
   
6. <FONT color=red>//locks.*;为什么locks后面还要加上*号啊??
   
7. </FONT>class Resource
   
8. {
   
9. private boolean flag=false;
   
10. //标记是否有商品,如果为false,则无,如果为true,则有;
    
11. private String name;
    
12. //商品名称;
    
13. private int id;
    
14. //商品编号;
    
15. public void setFlag(boolean flag)
    
16. {
    
17. this.flag=flag;
    
18. }
    
19. public boolean getFlag()
    
20. {
    
21. return flag;
    
22. }
    
23. public void setGoods(String name)
    
24. {
    
25. this.name=name;
    
26. id++;
    
27. System.out.println(Thread.currentThread().getName()+"生产商品:"+this.name+"....商品编号:"+id);
    
28. }
    
29. public void getGoods()
    
30. {
    
31. System.out.println(Thread.currentThread().getName()+"销售商品:"+this.name+"........商品编号:"+id);
    
32. }
    
33. private Lock lock=new ReentrantLock();
    
34. private Condition conditionInputs=lock.newCondition();
    
35. private Condition conditionOutputs=lock.newCondition();
    
36. public void inputs()
    
37. {
    
38. while(getFlag())
    
39. {
    
40. lock.lock();
    
41. try
    
42. {
    
43. conditionInputs.await();
    
44. setGoods("牙刷");
    
45. setFlag(true);
    
46. conditionOutputs.signal();
    
47. }
    
48. catch (InterruptedException ie)
    
49. {
    
50. 
    
51. }
    
52. finally
    
53. {
    
54. lock.unlock();
    
55. }
    
56. }
    
57. }
    
58. public void outputs()
    
59. {
    
60. while(!getFlag())
    
61. //使用while,可以保证线程wait()时,被唤醒后,可以重新再判断flag标记,以防止出现连续两次生产或者连续两次销售的现象发生
    
62. {
    
63. lock.lock();
    
64. try
    
65. {
    
66. conditionOutputs.await();
    
67. getGoods();
    
68. setFlag(false);
    
69. conditionInputs.signal();
    
70. }
    
71. catch (InterruptedException ie)
    
72. {
    
73. 
    
74. }
    
75. finally
    
76. {
    
77. lock.unlock();
    
78. }
    
79. }
    
80. }
    
81. //生产商品;
    
82. class Inputs implements Runnable
    
83. {
    
84. private Resource res;
    
85. //声明一个商品对象;
    
86. Inputs(Resource res)
    
87. //把商品对象通过构造函数传入到本类对象中;
    
88. {
    
89. this.res=res;
    
90. }
    
91. 
    
92. public void run()
    
93. //复写Runnable接口总run()方法;
    
94. {
    
95. while(true)
    
96. {
    
97. res.inputs();
    
98. }
    
99. }
    
100. }
     
101. 
     
102. //销售商品;
     
103. class Outputs implements Runnable
     
104. {
     
105. private Resource res;
     
106. //声明一个商品对象;
     
107. Outputs(Resource res)
     
108. //把商品对象通过构造函数传入到本类对象中;
     
109. {
     
110. this.res=res;
     
111. }
     
112. public void run()
     
113. //复写Runnable接口总run()方法;
     
114. {
     
115. while(true)
     
116. {
     
117. res.outputs();
     
118. }
     
119. }
     
120. }
     
121. 
     
122. 
     
123. class InputsOutputsNewDemo
     
124. {
     
125. public static void main(String[] args)
     
126. {
     
127. Resource res=new Resource();
     
128. Inputs inputs=new Inputs(res);
     
129. Outputs outputs=new Outputs(res);
     
130. Thread t1=new Thread(inputs);
     
131. Thread t2=new Thread(inputs);
     
132. Thread t3=new Thread(outputs);
     
133. Thread t4=new Thread(outputs);
     
134. t1.start();
     
135. t2.start();
     
136. t3.start();
     
137. t4.start();
     
138. }
     
139. }
     

复制代码

问题一:问题在第一行代码的红色字体部分;
问题二:为什么最后运行会出错啊??
           DOS命令行显示:

         F:\JAVAWORK\day12>javac InputsOutputsNewDemo.java
         InputsOutputsNewDemo.java:138: 进行语法解析时已到达文件结尾
         }
        ^
        1 错误

* 是一个通配符，表示所有，locks.*；表示导入locks包中的所有类。

至于你编译错误...只需要记住：这个提示一般都是在提示你大括号搭配有问题，检查下是不是大括号有多的或者少的。你括号太多，我看头晕了，这个错误提示你记住能解决很多问题了

* 表示导入locks包中的所有类。
代码花了点时间。整理了下。}{的问题。可以编译了。运行线程太多。无输出。太占资源了。

这DISCUS排版有点问题。

/*
当多个线程操作生产,多个线程操作销售时
*/
//商品资源库;
import java.util.concurrent.locks.*;
//locks.*;为什么locks后面还要加上*号啊??
class Resource
{
private boolean flag=false;
//标记是否有商品,如果为false,则无,如果为true,则有;
private String name;
//商品名称;
private int id;
//商品编号;
public void setFlag(boolean flag)
{
this.flag=flag;
}
  public boolean getFlag()
  {
  return flag;
  }
   public void setGoods(String name)
   {
   this.name=name;
   id++;
   System.out.println(Thread.currentThread().getName()+"生产商品:"+this.name+"....商品编号:"+id);
   }
    public void getGoods()
    {
    System.out.println(Thread.currentThread().getName()+"销售商品:"+this.name+"........商品编号:"+id);
    }
private Lock lock=new ReentrantLock();
private Condition conditionInputs=lock.newCondition();
private Condition conditionOutputs=lock.newCondition();
public void inputs()
{
while(getFlag())
{
  lock.lock();
   try
   {
   conditionInputs.await();
   setGoods("牙刷");
   setFlag(true);
   conditionOutputs.signal();
   }
    catch (InterruptedException ie)
    {
    }
   finally
   {
   lock.unlock();
   }
}
}
public void outputs()
{
  while(!getFlag())
  //使用while,可以保证线程wait()时,被唤醒后,可以重新再判断flag标记,以防止出现连续两次生产或者连续两次销售的现象发生
  {
   lock.lock();
    try
    {
    conditionOutputs.await();
    getGoods();
    setFlag(false);
    conditionInputs.signal();
    }
   catch (InterruptedException ie)
   {
   }
    finally
    {
    lock.unlock();
    }
  }
}
}
//生产商品;
class Inputs implements Runnable
{
private Resource res;
//声明一个商品对象;
Inputs(Resource res)
//把商品对象通过构造函数传入到本类对象中;
{
this.res=res;
}
public void run()
//复写Runnable接口总run()方法;
{
  while(true)
  {
  res.inputs();
  
  }
}
}
//销售商品;
class Outputs implements Runnable
{
private Resource res;
//声明一个商品对象;
Outputs(Resource res)
//把商品对象通过构造函数传入到本类对象中;
{
  this.res=res;
}
public void run()
//复写Runnable接口总run()方法;
{
  while(true)
   {
    res.outputs();
   }
}
}

class InputsOutputsNewDemo
{
public static void main(String[] args)
  {
  Resource res=new Resource();
  Inputs inputs=new Inputs(res);
  Outputs outputs=new Outputs(res);
  Thread t1=new Thread(inputs);
  Thread t2=new Thread(inputs);
  Thread t3=new Thread(outputs);
  Thread t4=new Thread(outputs);
  t1.start();
  t2.start();
  t3.start();
  t4.start();
  }
}

1，导入locks包得类
2，第8行没有对应的括号，记得编写的时候把括号高亮就行了。