黑马程序员技术交流社区

标题: 关于Lock接口使用过程中的疑问?? [打印本页]
作者: 孙国军    时间: 2012-4-12 20:44
标题: 关于Lock接口使用过程中的疑问??
  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. {

  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. {

  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. }

  92. public void run()
  93. //复写Runnable接口总run()方法;
  94. {
  95. while(true)
  96. {
  97. res.inputs();
  98. }
  99. }
  100. }

  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. }


  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 错误

作者: 石好强    时间: 2012-4-12 21:13
* 是一个通配符，表示所有，locks.*；表示导入locks包中的所有类。

至于你编译错误...只需要记住：这个提示一般都是在提示你大括号搭配有问题，检查下是不是大括号有多的或者少的。你括号太多，我看头晕了，这个错误提示你记住能解决很多问题了
作者: 邓斌    时间: 2012-4-12 21:45
本帖最后由 邓斌 于 2012-4-12 21:48 编辑

* 表示导入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();
  }
}

作者: 马强    时间: 2012-4-12 21:45
1，导入locks包得类
2，第8行没有对应的括号，记得编写的时候把括号高亮就行了。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2