多线程之四

wait、notify、notifyAll
每一个对象除了有一个锁之外，还有一个等待队列（wait set），当一个对象刚创建的时候，它的对待队列是空的。
我们应该在当前线程锁住对象的锁后，去调用该对象的wait方法。
当调用对象的notify方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。
当调用对象的notifyAll方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将成为可运行的线程。
wait和notify主要用于producer-consumer这种关系中。

class Test
...{
    public static void main(String[] args)
    ...{
        Queue q=new Queue();
        Producer p=new Producer(q);
        Consumer c=new Consumer(q);
        p.start();
        c.start();
    }
}

class Producer extends Thread
...{
    Queue q;
    Producer(Queue q)
    ...{
        this.q=q;
    }
    public void run()
    ...{
        for(int i=0;i<10;i++)
        ...{
            q.put(i);
            System.out.println("Producer put "+i);
        }
    }
}
class Consumer extends Thread
...{
    Queue q;
    Consumer(Queue q)
    ...{
        this.q=q;
    }
    public void run()
    ...{
        while(true)
        ...{
            System.out.println("Consumer get "+q.get());
        }
    }
}
class Queue
...{
    int value;
    boolean bFull=false;
    public synchronized void put(int i)
    ...{
        if(!bFull)
        ...{
            value=i;
            bFull=true;
            notify();
        }
        try
        ...{
            wait();
        }
        catch(Exception e)
        ...{
            e.printStackTrace();
        }
            
    }
    public synchronized int get()
    ...{
        if(!bFull)
        ...{
            try
            ...{
                wait();
            }
            catch(Exception e)
            ...{
                e.printStackTrace();
            }
        }
        bFull=false;
        notify();
        return value;
    }
}

 线程的终止
设置一个flag变量。
结合interrupt()方法。

 

class TestThread
...{
    public static void main(String[] args)
    ...{
        Thread1 t1=new Thread1();
        t1.start();
        int index=0;
        while(true)
        ...{
            if(index++==500)
            ...{
                t1.stopThread();
                t1.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName());
        }
        System.out.println("main() exit");
    }
}

class Thread1 extends Thread
...{
    private boolean bStop=false;
    public synchronized void run()
    ...{
        while(!bStop)
        ...{
            try
            ...{
                wait();
            }
            catch(InterruptedException e)
            ...{
                //e.printStackTrace();
                if(bStop)
                    return;
            }
            System.out.println(getName());
        }
    }
    public void stopThread()
    ...{
        bStop=true;
    }
}