A股上市公司传智教育（股票代码 003032）旗下技术交流社区北京昌平校区

传智教育官网黑马程序员官网

 找回密码
 加入黑马

QQ登录

只需一步，快速开始

论坛首页 › 隐藏归类 › 黑马那些年 › 第40,41,42,43届Android交流区 › 正文

多线程求教

© 柳超 中级黑马   /  2014-7-15 17:34  /  1961 人查看  /  10 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

  1. class Student
  2. {
  3.         boolean flag=true;
  4.         String name;
  5.         private String sex;
  6.         public void set(String name,String sex)
  7.         {
  8.                 this.name=name;
  9.                 this.sex=sex;
  10.         }
  11.         public void show()
  12.         {
  13.                 System.out.println("------"+this.name+"-----------"+this.sex);
  14.         }
  15.        
  16. }
  17. class In implements Runnable
  18. {
  19.         Student stu;
  20.         boolean bool1=true;
  21.         In(Student stu)
  22.         {
  23.                 this.stu=stu;
  24.         }
  25.         public void run()
  26.         {
  27.                 while(true)
  28.                 {
  29.                         synchronized(stu)
  30.                         {
  31.                                 if(stu.flag)
  32.                                 {
  33.                                         try {
  34.                                                 stu.wait();
  35.                                         } catch (InterruptedException e) {
  36.                                                 // TODO Auto-generated catch block
  37.                                                 e.printStackTrace();
  38.                                         }
  39.                                         }
  40.                                         if(bool1)
  41.                                         {
  42.                                                 stu.set("lucy", "girl");
  43.                                                 bool1=false;
  44.                                         }
  45.                                         else
  46.                                         {
  47.                                                 stu.set("李四","男");
  48.                                         }
  49.                                
  50.                                 stu.flag=false;
  51.                                 stu.notify();
  52.                         }
  53.                 }
  54.         }
  55. }
  56. class Out implements Runnable
  57. {
  58.         Student stu;
  59.         private String sex;
  60.         Out(Student stu)
  61.         {
  62.                 this.stu=stu;
  63.         }
  64.         public void run()
  65.         {
  66.                         synchronized(stu)
  67.                         {
  68.                                 if(!stu.flag)
  69.                                 {
  70.                                         try {
  71.                                                 stu.wait();
  72.                                         } catch (InterruptedException e)
  73.                                         {
  74.                                                 // TODO Auto-generated catch block
  75.                                                 e.printStackTrace();
  76.                                         }
  77.                                         }
  78.                                                 while(true)
  79.                                                 {
  80.                                                        
  81.                                                         {
  82.                                                                 stu.show();
  83.                                                                 stu.flag=true;
  84.                                                                 stu.notify();
  85.                                                         }
  86.                                                 }
  87.                                
  88.                                
  89.                 }
  90.                        
  91.                
  92.         }
  93.        
  94. }
  95. class Study
  96. {
  97.         public static void main(String[] args)
  98.         {
  99.                
  100.                 System.out.println("start");
  101.                 Student stu= new Student();
  102.                 In in =new In(stu);
  103.                 Out out =new Out(stu);
  104.                 new Thread(in).start();
  105.                 new Thread(out).start();
  106.         }
  107. }
复制代码

求教  那里要改，  输出给果是   无限的    ------null-----------null

10 个回复

倒序浏览
柳超 中级黑马 2014-7-15 19:34:01
| 只看该作者
沙发
自顶！没有人来看看吗
回复 使用道具 举报
fantacyleo 金牌黑马 2014-7-15 19:59:29
| 只看该作者
藤椅
柳超 发表于 2014-7-15 19:34
自顶！没有人来看看吗

额，这么长的代码，你最好先讲一下你要实现什么功能
回复 使用道具 举报
黄宝宝 高级黑马 2014-7-15 20:15:02
| 只看该作者
板凳
  1. <div class="blockcode"><blockquote>package cn.main;

  3. class Student
  4. {
  5.         boolean flag=false;//这里应该是false，如果是true的话，一开始生产者就等待了，当然输出null.
  6.         String name;
  7.         private String sex;
  8.         public void set(String name,String sex)
  9.         {
  10.                 this.name=name;
  11.                 this.sex=sex;
  12.         }
  13.         public void show()
  14.         {         try {
  15.                         Thread.sleep(10);//让子弹停一会。
  16.                 } catch (InterruptedException e) {
  17.                        
  18.                         e.printStackTrace();
  19.                 }
  20.                 //得到当前运行的线程名称
  21.                 System.out.println(Thread.currentThread().getName()+"------"+this.name+"-----------"+this.sex);
  22.         }
  23.         
  24. }
  25. class In implements Runnable
  26. {
  27.         Student stu;
  28.         boolean bool1=true;
  29.         In(Student stu)
  30.         {
  31.                 this.stu=stu;
  32.         }
  33.         public void run()
  34.         {
  35.                 while(true)
  36.                 {
  37.                         synchronized(stu)
  38.                         {
  39.                                 if(stu.flag)
  40.                                 {
  41.                                         try {
  42.                                                 stu.wait();
  43.                                         } catch (InterruptedException e) {
  44.                                                 // TODO Auto-generated catch block
  45.                                                 e.printStackTrace();
  46.                                         }
  47.                                  }
  48.                                 
  49.                                                 if(bool1)
  50.                                                 {
  51.                                                         stu.set("lucy", "girl");
  52.                                                         bool1=false;
  53.                                                         stu.show();
  54.                                                 }
  55.                                                 else
  56.                                                 {
  57.                                                         stu.set("李四","男");
  58.                                                         bool1=true;
  59.                                                         stu.show();
  60.                                                 }
  61.                                      
  62.                                 stu.flag=true;
  63.                                 stu.notify();
  64.                         
  65.                                   }
  66.                                 
  67.                 }
  68.         }
  69. }
  70. class Out implements Runnable
  71. {
  72.         Student stu;
  73.         private String sex;
  74.         Out(Student stu)
  75.         {
  76.                 this.stu=stu;
  77.         }
  78.         public void run()
  79.         {
  80.                         synchronized(stu)
  81.                         {
  82.                                 while(true)//while应该放在这儿
  83.                         {
  84.                                 if(!stu.flag)
  85.                                 {
  86.                                         try {
  87.                                                 stu.wait();
  88.                                         } catch (InterruptedException e)
  89.                                         {
  90.                                                 // TODO Auto-generated catch block
  91.                                                 e.printStackTrace();
  92.                                         }
  93.                                 }
  94.                               
  95. //                                while(true){
  96.                                                         
  97.                                                         {
  98.                                                                 stu.show();
  99.                                                                 stu.flag=false;
  100.                                                                 stu.notify();
  101.                                                         }
  102.                                                 }
  103.                                 
  104.                                 
  105.                 }
  106.                         
  107.                
  108.         }
  109.         
  110. }
  111. class Study
  112. {
  113.         public static void main(String[] args)
  114.         {
  115.                
  116.                 System.out.println("start");
  117.                 Student stu= new Student();
  118.                 In in =new In(stu);
  119.                 Out out =new Out(stu);
  120.                 new Thread(in).start();
  121.                 new Thread(out).start();
  122.         }
  123. }
复制代码



回复 使用道具 举报
柳超 中级黑马 2014-7-15 20:42:47
| 只看该作者
报纸

  2. class Student
  3. {
  4.         boolean flag=false;
  5.         String name;
  6.         private String sex;
  7.         public void set(String name,String sex)
  8.         {
  9.                 this.name=name;
  10.                 this.sex=sex;
  11.         }
  12.         public void show() throws InterruptedException
  13.         {
  14.                 Thread.sleep(10);
  15.                 System.out.println("------"+this.name+"-----------"+this.sex);
  16.         }
  17.        
  18. }
  19. class In implements Runnable
  20. {
  21.         private Student stu;
  22.         boolean bool1=true;
  23.         In(Student stu)
  24.         {
  25.                 this.stu=stu;
  26.         }
  27.         public void run()
  28.         {
  29.                 while(true)
  30.                 {
  31.                         synchronized(stu)
  32.                         {
  33.                                 if(stu.flag)
  34.                                 {
  35.                        
  36.                                         try {stu.wait();} catch (InterruptedException e)
  37.                                         {
  38.                                                 // TODO Auto-generated catch block
  39.                                                 e.printStackTrace();}
  40.                                         }
  41.                                 }
  42.                                 while(true)
  43.                                 {
  44.                                         int x=0;
  45.                                        
  46.                                                 if(x%2==0)
  47.                                                 {
  48.                                                 stu.set("lucy", "girl");
  49.                                                 bool1=false;
  50.                                                 }
  51.                                                 else
  52.                                                 {
  53.                                                         bool1=true;
  54.                                                         stu.set("李四","男");
  55.                                                        
  56.                                                 }
  57.                                                 stu.flag=true;
  58.                                                
  59.                                                 x=x+1;
  60.                                                 stu.notify();
  61.                                 }
  62.                        
  63.                 }
  64.         }
  65. }
  66. class Out implements Runnable
  67. {
  68.         private Student stu;
  69.         private String sex;
  70.         Out(Student stu)
  71.         {
  72.                 this.stu=stu;
  73.         }
  74.         public void run()
  75.         {
  76.                         synchronized(stu)
  77.                         {
  78.                                 while(true)
  79.                                 {
  80.                                 if(!stu.flag)      
  81.                                 {
  82.                                         try {stu.wait();} catch (InterruptedException e)
  83.                                         {
  84.                                                 // TODO Auto-generated catch block
  85.                                                
  86.                                         }
  87.                                 }
  88.                                                
  89.                                                        
  90.                                                         {
  91.                                                                 try {
  92.                                                                         stu.show();
  93.                                                                 } catch (InterruptedException e) {
  94.                                                                         // TODO Auto-generated catch block
  95.                                                                         e.printStackTrace();
  96.                                                                 }
  97.                                                                 stu.flag=false;
  98.                                                                 stu.notify();
  99.                                                         }
  100.                                                
  101.                                
  102.                                                 }
  103.                 }
  104.                        
  105.                
  106.         }
  107.        
  108. }
  109. class Study
  110. {
  111.         public static void main(String[] args)
  112.         {
  113.                
  114.                 System.out.println("start");
  115.                 Student stu= new Student();
  116.                 new Thread(new In(stu)).start();
  117.                 new Thread(new Out(stu)).start();
  118.         }
  119. }
复制代码

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
        at java.lang.Object.notify(Native Method)
        at In.run(Test.java:60)
        at java.lang.Thread.run(Unknown Source)


这个是多线程的练习       一个线程输入  一个线程输出     用  flag  控制   输入一次  就 输出一次两组名字交替输入  输出
回复 使用道具 举报
柳超 中级黑马 2014-7-15 20:43:53
| 只看该作者
地板
fantacyleo 发表于 2014-7-15 19:59
额，这么长的代码，你最好先讲一下你要实现什么功能

这个是多线程的练习       一个线程输入  一个线程输出     用  flag  控制   输入一次  就 输出一次两组名字交替输入  输出
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
         at java.lang.Object.notify(Native Method)
         at In.run(Test.java:60)
         at java.lang.Thread.run(Unknown Source)这个是报错
回复 使用道具 举报
柳超 中级黑马 2014-7-15 20:46:40
| 只看该作者
7#
黄宝宝 发表于 2014-7-15 20:15

这样写就 不是一个线程控制输入 一个线程控制输出 了！ 我这个是想 两个线程 一个控制输入一个控制输出
然后通过 flag 控制 wait 和notify执行
回复 使用道具 举报
tianleboy 高级黑马 2014-7-15 22:08:30
| 只看该作者
8#
你这个代码有同步的对象不一样，而且你在show方法中直接打印System.out.println(name +"...."+sex); 不用加this。如果你加this的话，调用对象是stu的值传不到。      第二个问题就是在set方法中没有加同步。set方法中有共享数据，应该加同步。 最后一个就是Out方法不用加同步代码，因为在Out中只有一条共享数据。也就是show方法，既然在show（）加上了同步函数，就不用造Out写同步代码块。
  1. class Student{
  2.     private String name;
  3.         private String sex;
  4.         private boolean flag = false;
  5.         public synchronized void set(String name,String sex){
  6.                 if(flag){
  7.                         try {
  8.                                 wait();
  9.                         } catch (InterruptedException e) {
  10.                                 // TODO Auto-generated catch block
  11.                                 e.printStackTrace();
  12.                         }
  13.                 }
  14.                 this.name = name;
  15.                 this.sex = sex;
  16.                 flag =true;
  17.                 this.notify();
  18.         }
  19.         public synchronized void show(){
  20.                 if(!flag){
  21.                         try {
  22.                                 wait();
  23.                         } catch (InterruptedException e) {
  24.                                 // TODO Auto-generated catch block
  25.                                 e.printStackTrace();
  26.                         }
  27.                 }
  28.                 System.out.println(name +"...."+sex);
  29.                 flag = false;
  30.                 notify();
  31.         }
  32. }
  33. class In implements Runnable{
  34.         private Student stu;
  35.         In(Student stu){
  36.                 this.stu = stu;
  37.         }
  38.         public void run(){
  39.                 int x =0;
  40.                 while(true){
  41.                         synchronized(stu){
  42.                                
  43.                                 if(x==0){
  44.                                         stu.set("lucy", "girl");
  45.                                 }else{
  46.                                         stu.set("李四", "男");
  47.                                 }
  48.                                 x = (x+1)%2;
  49.                         }
  50.                 }
  51.         }
  52.        
  53. }
  54. class Out implements Runnable{
  55.         private Student stu;
  56.         Out(Student stu ) {
  57.                 this.stu = stu;
  58.         }
  59.         public void run(){
  60.                 while(true){
  61.                      stu.show();
  62.                         }
  63.                 }
  64.        
  65. }
  66. public class Study {
  67.         public static void main(String[] args){
  68.                 Student stu = new Student();
  69.                 new Thread(new In(stu)).start();
  70.                 new Thread(new Out(stu)).start();
  71.         }

  73. }
复制代码
回复 使用道具 举报
黄宝宝 高级黑马 2014-7-15 22:11:29
| 只看该作者
9#
柳超 发表于 2014-7-15 20:46
这样写就 不是一个线程控制输入 一个线程控制输出 了！ 我这个是想 两个线程 一个控制输入一个控制输出
...

Thread-0:是输入的线程任务。Thread-1：是输出的线程任务。

注意上面我发的代码，有些修改了没有注释给你看，你看看。

A)R58E~RI87{N{BZGL(0G@I.jpg (128.74 KB, 下载次数: 59)

A)R58E~RI87{N{BZGL(0G@I.jpg
回复 使用道具 举报
柳超 中级黑马 2014-7-16 17:00:11
| 只看该作者
10#
黄宝宝 发表于 2014-7-15 22:11
Thread-0:是输入的线程任务。Thread-1：是输出的线程任务。

注意上面我发的代码，有些修改了没有注释给 ...

线程1只输入  线程2 只输出  我的意思
回复 使用道具 举报
fantacyleo 金牌黑马 2014-7-16 17:16:37
| 只看该作者
11#
你的代码不符合你的思考逻辑。你的flag初始化为true，此时学生的姓名和性别都为空。按理说应该让in在flag＝true时调用set方法，让out在flag＝true时等待。但代码中却在flag＝true时让in等待，导致set方法调用不了。同时flag＝true时out又判定为不等待，所以打印出null。然后就是无限循环问题。out的run方法中：
  1. while(true)
  2. {
  3.     {
  4.         stu.show();
  5.         stu.flag=true;
  6.         stu.notify();
  7.     }
  8. }
复制代码

这里虽然notify了另一个线程，但notify本身不会放弃同步锁，而你的out线程又在这里死循环，始终拿着锁不放，导致无限循环null，null
回复 使用道具 举报
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 加入黑马