/*
多线程练习
需求：在t1调用join()下，且t1的run方法里调用wait()无限等待，调用interrupt()方法唤醒主函数继续运行，并且与t2交替争夺资源

思路：我想通过flag的值的判断来唤醒主函数，从而达到t1继续等待，t2和主函数继续交替运行。
*/

class Res //判断值
{
        boolean flag=true;
}




class Dem implements Runnable
{
        private Res r;

        Dem(Res r)
        {
                this.r=r;
        }


        public synchronized  void run()//t1线程执行的方法
        {
                        
                        try
                        {
                                while(r.flag)
                                wait();                                
                                                
                        }
                        catch(InterruptedException e)
                        {
                                System.out.println(Thread.currentThread().getName()+"---t0--Exception---");
                                r.flag=false;
                        }

                        System.out.println(Thread.currentThread().getName()+"---t0---RUN----");
        }
}




class Cem implements Runnable  
{
        public synchronized void run()//t2线程执行的方法
        {
                for(int x=0;x<40;x++)
                {        
                        System.out.println(Thread.currentThread().getName()+"---t1-----"+x);
                }        
        
        }
}


class QDemo7
{
        public static void main(String[] args) throws Exception
        {
                Res r=new Res();

                Dem d=new Dem(r);

                Cem c=new Cem();
               
                Thread t1=new Thread(d);
                Thread t2=new Thread(c);


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

                for(int x=0;x<40;x++)
                {

                        System.out.println(Thread.currentThread().getName()+"---main-----"+x);        

                        t1.join();
                        Thread.currentThread().interrupt();
                }

                System.out.println("over");
        }
}


运行结果如图，执行到t1就无限等待了，求解

Thread.currentThread().interrupt();这句根本没执行到。这句在主线程里，而主线程在执行到ti.join()时就已经处于冻结状态了，只有t1执行完终止后，主线程才会被唤醒。要想手动清除主线程的冻结状态，必须在一个处于活跃状态的线程中执行interrupt()方法，这里可以使用t2线程。主线程被唤醒以后，再使用t1.interrupt()方法，清除t1线程的冻结状态，使程序结束。修改后代码如下：

1. /*
   
2. 多线程练习
   
3. 需求：在t1调用join()下，且t1的run方法里调用wait()无限等待，调用interrupt()方法唤醒主函数继续运行，并且与t2交替争夺资源
   
4. 
   
5. 思路：我想通过flag的值的判断来唤醒主函数，从而达到t1继续等待，t2和主函数继续交替运行。
   
6. */
   
7. 
   
8. class Res //判断值
   
9. {
   
10.         boolean flag=true;
    
11. }
    
12. 
    
13. 
    
14. 
    
15. 
    
16. class Dem implements Runnable
    
17. {
    
18.         private Res r;
    
19. 
    
20.         Dem(Res r)
    
21.         {
    
22.                 this.r=r;
    
23.         }
    
24. 
    
25. 
    
26.         public synchronized  void run()//t1线程执行的方法
    
27.         {
    
28.                         
    
29.                         try
    
30.                         {
    
31.                                 while(r.flag)
    
32.                                 wait();                                
    
33.                                                 
    
34.                         }
    
35.                         catch(InterruptedException e)
    
36.                         {
    
37.                                 System.out.println(Thread.currentThread().getName()+"---t1--Exception---");
    
38.                                 r.flag=false;
    
39.                         }
    
40. 
    
41.                         System.out.println(Thread.currentThread().getName()+"---t1---RUN----");
    
42.         }
    
43. }
    
44. 
    
45. 
    
46. 
    
47. 
    
48. class Cem implements Runnable  
    
49. {
    
50. 
    
51.                 private Thread main;
    
52.                 public Cem(Thread main)
    
53.                 {
    
54.                         this.main = main;
    
55.                 }
    
56.         public synchronized void run()//t2线程执行的方法
    
57.         {
    
58.                 for(int x=0;x<40;x++)
    
59.                 {        
    
60. 
    
61.                         System.out.println(Thread.currentThread().getName()+"---t2-----"+x);
    
62.                                                 main.interrupt();
    
63.                 }        
    
64.         
    
65.         }
    
66. }
    
67. 
    
68. 
    
69. class QDemo7
    
70. {
    
71.         public static void main(String[] args) throws Exception
    
72.         {
    
73. 
    
74.                                 Thread main = Thread.currentThread();//获得主线程的引用。
    
75.                 Res r=new Res();
    
76. 
    
77.                 Dem d=new Dem(r);
    
78. 
    
79.                 Cem c=new Cem(main);//将主线程传递给t2线程。
    
80.                
    
81.                 Thread t1=new Thread(d);
    
82.                 Thread t2=new Thread(c);
    
83. 
    
84. 
    
85.                 t1.start();
    
86.                 t2.start();
    
87.                                  try
    
88.                  {
    
89.                                         t1.join();
    
90.                  }
    
91.                  catch (InterruptedException e)
    
92.                  {
    
93.                                          System.out.println(Thread.currentThread().getName()+"---main--Exception---");
    
94.                  }
    
95.                 for(int x=0;x<40;x++)
    
96.                 {
    
97. 
    
98.                         System.out.println(Thread.currentThread().getName()+"---main-----"+x);        
    
99. 
    
100.                     
     
101.                                                
     
102.                         //Thread.currentThread().interrupt();
     
103.                 }
     
104. 
     
105.                 System.out.println("over");
     
106.                                 t1.interrupt();
     
107.         }
     
108. }

复制代码

李天富 发表于 2014-12-3 21:37
Thread.currentThread().interrupt();这句根本没执行到。这句在主线程里，而主线程在执行到ti.join()时就已 ...

非常感谢，终于成功实现了。:lol

在需求：在t1调用join()下，且t1的run方法里调用wait()无限等待，调用interrupt()方法唤醒主函数继续运行，并且与t2交替争夺资源中。
main与t2交替争夺资源是指main线程运行一次，t2线程运行一次那样交替吗？

Smart_lll 发表于 2014-12-6 09:31
在需求：在t1调用join()下，且t1的run方法里调用wait()无限等待，调用interrupt()方法唤醒主函数继续运行， ...

因为t2和 t1调用的方法不一样，所以t2的输出可以和主函数的输出同时进行

kane 发表于 2014-12-6 09:58
因为t2和 t1调用的方法不一样，所以t2的输出可以和主函数的输出同时进行

这个我知道， 我想知道是交替执行吗？交替执行的意思是：
main线程
t2线程
main线程
t2线程
main线程
t2线程
...
这样交替？！？！

Smart_lll 发表于 2014-12-6 17:08
这个我知道， 我想知道是交替执行吗？交替执行的意思是：
main线程
t2线程

理想情况是这样的，不过内存CPU抢占资源的结果可能没有那么理想

kane 发表于 2014-12-6 18:14
理想情况是这样的，不过内存CPU抢占资源的结果可能没有那么理想

恩恩，可以用一个lock两个condition搞定吧？！

Smart_lll 发表于 2014-12-6 19:35
恩恩，可以用一个lock两个condition搞定吧？！

对，说的没错:lol

kane 发表于 2014-12-6 19:37
对，说的没错

:lol:lol:lol

我还是不明白啊

Dark_Knight 发表于 2014-12-7 00:36
我还是不明白啊

还不懂吗?
这里有源代码，你可以看看哈，希望对你有帮助
http://bbs.itheima.com/thread-155539-1-1.html