java笔记 多线程 六

可爱的静静

多线程：

自动唤醒机制：
在多线程里有一种状态是  wait(); notify();  wait();没有参数的wait() 程序会挂在那里不会自动回复执行 等待线程都放在线程池，notify唤醒线程池里的线程，如果有n多线程，首先唤醒的是第一个被等待的线程。

什么是唤醒机制

举个例子：
看图

例子就是当输入后输入的线程在等待之前唤醒了输出的那条线程
输出后 输出的线程等待之前 唤醒输入线程

1. public class ds {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Res b=new Res();
   
5.                 Output a=new Output(b);
   
6.                 Intput c=new Intput(b);
   
7.                 Thread d=new Thread(a);
   
8.                 Thread e=new Thread(c);
   
9.                 e.start();
   
10.                 d.start();
    
11.                 }
    
12. }
    
13. class Res{
    
14.         String name;
    
15.         char sex;
    
16.         boolean flag=false;
    
17.                
    
18. }
    
19. class Output implements Runnable{
    
20.          private Res r;
    
21.          Output(Res r){
    
22.                  this.r=r;
    
23.                  
    
24.          }
    
25.          public void run(){
    
26.                  int x=0;
    
27.                  while(true){
    
28.                  if(r.flag)
    
29.                         try {r.wait();} catch (Exception e) {};
    
30.                    synchronized(r){
    
31.                                 if(x==0){
    
32.                                    r.name="啦啦啦啦";
    
33.                                    r.sex='女';
    
34.                                 }
    
35.                                 else{
    
36.                                         r.name="棒棒棒";
    
37.                                         r.sex='男';
    
38.                                 }
    
39.                                 x=x+1%2;
    
40.                                 r.flag=true;
    
41.                                 r.notify();
    
42.                         }
    
43.                 }         
    
44.                  
    
45.          }
    
46.        
    
47. }
    
48. 
    
49. class Intput implements Runnable{
    
50.         private Res r;
    
51.          Intput(Res r){
    
52.                  this.r=r;
    
53.          }
    
54.          public void run(){
    
55.                  while(true){
    
56.                  if(!r.flag)
    
57.                         try {r.wait();} catch (Exception e) {};
    
58.                         synchronized(r){
    
59.                                    System.out.println(r.name+"......"+r.sex);
    
60.                                 r.flag=false;
    
61.                                 r.notify();
    
62.                         }
    
63.                 }         
    
64.                  
    
65.          }
    
66.        
    
67. }
    

复制代码

               


Wait;
Notif();
NotifyAll();

都使用在同步中，应为要对等待的监视器（锁）的线程操作
所以要使用在同步中 因为只有同步才具有锁

为什么这些操作线程的方法要定义在object 类中呢？
这些方法再操作票同步中线程是 都必须标识 他们所操作的锁
只有同一个锁上的被等待 和一被同一个锁的notify唤醒 不可以对不同锁中的线程唤醒

而锁可以是任何一个对象 可以被任意对象调用的方法在object 类里

Join方法

当A线程执行到了b线程的join方法时，a线程就被等待 ，等到b线程执行完，a线程才有执行权

1. 
   
2. public class  save
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 Demo a=new Demo();
   
7.                 Thread c=new Thread(a);
   
8.                 Thread d=new Thread(a);
   
9.                 c.start();
   
10.        c.join();
    
11.                 d.start();
    
12. 
    
13.         for (int x=0;x<70;x++)
    
14.                         System.out.println(Thread.currentThread()+"........"+x);
    
15.                 System.out.println("over");
    
16.         }
    
17. }
    
18. class Demo implements Runnable
    
19. {
    
20.         public void run(){
    
21.                 for (int x=0;x<70;x++)
    
22.                         System.out.println(Thread.currentThread()+"........"+x);
    
23.         }
    
24. }

复制代码

：

运行结果是：主线程执行到c.join(); 主线程变成等待的状态 只有c.join()相对的线程执行完，主线程才会执行