java笔记 多线程 六

可爱的静静

多线程：

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

什么是唤醒机制

举个例子：
看图

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

public class ds {

        public static void main(String[] args) {
                Res b=new Res();
                Output a=new Output(b);
                Intput c=new Intput(b);
                Thread d=new Thread(a);
                Thread e=new Thread(c);
                e.start();
                d.start();
                }
}
class Res{
        String name;
        char sex;
        boolean flag=false;
                
}
 class Output implements Runnable{
         private Res r;
         Output(Res r){
                 this.r=r;
                 
         }
         public void run(){
                 int x=0;
                 while(true){
                 if(r.flag)
                        try {r.wait();} catch (Exception e) {};
                   synchronized(r){
                                if(x==0){
                                   r.name="啦啦啦啦";
                                   r.sex='女';
                                }
                                else{
                                        r.name="棒棒棒";
                                        r.sex='男';
                                }
                                x=x+1%2;
                                r.flag=true;
                                r.notify();
                        }
                }         
                 
         }
        
}
 
class Intput implements Runnable{
        private Res r;
         Intput(Res r){
                 this.r=r;
         }
         public void run(){
                 while(true){
                 if(!r.flag)
                        try {r.wait();} catch (Exception e) {};
                        synchronized(r){
                                   System.out.println(r.name+"......"+r.sex);
                                r.flag=false;
                                r.notify();
                        }
                }         
                 
         }
        
}

               


Wait;
Notif();
NotifyAll();

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

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

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

Join方法

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

public class  save
{
        public static void main(String[] args) 
        {
                Demo a=new Demo();
                Thread c=new Thread(a);
                Thread d=new Thread(a);
                c.start();
       c.join();
                d.start();

        for (int x=0;x<70;x++) 
                        System.out.println(Thread.currentThread()+"........"+x);
                System.out.println("over");
        }
}
class Demo implements Runnable
{
        public void run(){
                for (int x=0;x<70;x++) 
                        System.out.println(Thread.currentThread()+"........"+x);
        }
}

：

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