多线程经典消费者实例

需求

我们的程序想要实现这样的一个功能，两个线程，一个不断往一个容器加数据，一个不断从这个容器取数据。

设计的问题

我们的第一个问题是，如果容器满了怎么办，空了又怎么。解决的办法是使用wait()和notify()。思路是当容器满或空时，对应的线程就应该停下了，等到不空或者不满的时候再继续。显然wait()和notify()可以很好的实现。当空时，暂停取，使用wait()，添加线程添加了后就不空了，就可以使用notify()唤醒取的线程了。满的时候也是一样的。

sleep()和wait()的区别

暂停也可用sleep()，为什么不用sleep()呢？首先是我们不知道停多久，有notify()配合使用才方便。sleep()和wait()有一个重要的区别是，sleep()不会让出对象锁。我们写个例子来证明下：

class Lock{
    public synchronized void printlnTest(){
        for(int i=0;i<100;i++)
        System.out.println(Thread.currentThread().getName());
    }
    public synchronized void sleepTest(){

        System.out.println("sleeped 2 second");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class Print implements Runnable{
    private Lock lock;
    public  Print(Lock lock){
        this.lock = lock;
    }
    @Override
    public void run(){
        lock.printlnTest();
    }
}

class SleepTest implements Runnable{
    private Lock lock;
    public  SleepTest(Lock lock){
        this.lock = lock;
    }
    @Override
    public void run(){
        lock.sleepTest();
    }
}
public class SleepAndWait {

    public static void main(String[] args) {
        Lock lock = new Lock();
        Print print = new Print(lock);
        SleepTest sleep = new SleepTest(lock);

        new Thread(sleep).start();
        new Thread(print).start();  
    }
}

输出的结果是，输出了sleeped 2 second，等待两秒后，才可以看到输出的100个Thread-1。如果把synchronized去掉，也就是不加锁，Thread-1会立即输出不会等两秒。这里证明sleep是不会让出对象锁的。

非常有用的线程图

消费者实例

这是容器，使用一个类似栈的容器

public class Stack {
    private char[] container  = new char[6];
    private int top;//指向栈顶元素的上一个

    public synchronized void push(char a){

        if(top==container.length){//if 改为while更合适，思考下为什么
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
            this.notify();
            container[top]=a;
            top++;
            System.out.println(Thread.currentThread().getName()+"入栈的元素"+a);

    }

    public synchronized char pop(){

        if(top==0){//if 改为while更合适，思考下为什么
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
            this.notify();
            top--;
            System.out.println(Thread.currentThread().getName()+"出栈的元素:"+container[top]);
            return container[top];

    }

}

生产者

public class Producer implements Runnable{
    private Stack stack;

    public Producer(Stack stack){
        this.stack = stack;
    }

    @Override
    public void run(){

        for(int i=0;i<10;i++){

            stack.push((char)('a'+i));
        }

    }
}

消费者

public class Consumer implements Runnable{

    private Stack stack;
    public Consumer(Stack stack){
        this.stack = stack;
    }

    @Override
    public void run(){

        try {
            for(int i=0;i<10;i++)
            stack.pop();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }       
    }
}

主线程

public class ThreadTest {

    public static void main(String[] args) {

        Stack stack = new Stack();
        Producer p = new Producer(stack);
        Consumer c = new Consumer(stack);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

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

同步的问题

当添加线程的push方法和取线程的pop方法，不是原子操作时意思就是push方法执行一半，cpu切换给pop方法的线程执行，就会出现问题。比如说，当执行了container[top]=a;但是还没执行top++；切换到取线程时，把原来栈顶的元素取出来了并且指针向下减，如果再返回添加线程，继续执行top++；结果就是新添加的元素丢失了，原来栈顶的元素取了一次还在。所以pop方法和push方法要加锁，作为原子操作。