多线程案例：生产者和消费者

以继承Thread实现:
           

package example;

/**
* 所有synchronized方法持有同一把this锁,
* synchronized方法执行到wait(）时放锁，
* 让其他线程可以进入相应的synchronized方法
* @author 姚丽辉
*/
public class Producter_Consumer {
private int     size = 5;      //容器大小
private int     remain = size;      //剩余空间
private int[] common = new int[size];//容器，该信号量用于同步生产者和消费者

private synchronized void product(int i) throws InterruptedException {
     if (remain > 0) {
      notify();//通知生产者继续
     }
     common[i % size] = i;
     remain--;
     System.out.println("product:" + i);
     if (remain == 0) {
      System.out.println("product wait");
      wait();//让生产者等待
     }
}

private synchronized void consume(int i) throws InterruptedException {
     if ((size - remain) > 0) {
      notify();//通知消费者继续
     }
     System.out.println("consume:" + common[i % size]);
     remain++;
     if (remain == size) {
      System.out.println("consume wait");
      wait();//让消费者等待
     }
}

class Producter extends Thread {
     public void run() {
      for (int i = 1; true; i++) {
       try {
        product(i);
        sleep((int) (Math.random() * 5000));
       } catch (InterruptedException e) {
        e.printStackTrace();
       }
      }
     }
}

class Consumer extends Thread {
     public void run() {
      for (int i = 1; true; i++) {
       try {
        consume(i);
        sleep((int) (Math.random() * 5000));
       } catch (InterruptedException e) {
        e.printStackTrace();
       }
      }
     }
}

private void start() {
     Producter p = new Producter();
     Consumer c = new Consumer();
     p.start();
     c.start();
}

public static void main(String[] args) {
     Producter_Consumer m = new Producter_Consumer();
     m.start();
}

}











实现Runnable接口


1。生产和消费的产品抽象类

//预留

public abstract class Product {
    
    public String name;
    public abstract String toString();

}

2。一个具体的产品类

public class AProduct extends Product {

    public AProduct(String pname) {
        super();
        name = pname;
        // TODO Auto-generated constructor stub
    }

    public String toString() {
        // TODO Auto-generated method stub
        return name;
    }

}

3。容器类（仓库）

import java.util.ArrayList;

/*
 * 存放生产者和消费者的产品队列
 * */
public class Container {

    private ArrayList arrList = new ArrayList();

    private int LENGTH = 10;

    public boolean isFull() {
        return arrList.size() == LENGTH;
    }

    public boolean isEmpty() {
        return arrList.isEmpty();
    }

    /* 如果此处不加synchronized锁，那么也可以再调用push的地方加锁
    * 既然此处加了锁，那么再别的地方可以不加锁
    */
    public synchronized void push(Object o) {
        arrList.add(o);
    }

    // 如果此处不加synchronized锁，那么也可以再调用push的地方加锁

    public synchronized Object pop() {
        Object lastOne = arrList.get(arrList.size() - 1);
        arrList.remove(arrList.size() - 1);

        return lastOne;
    }
}


4。休息一会，生产者和消费者都要休息，因此作为抽象基类

public abstract class Sleep {

    public void haveASleep() throws InterruptedException {

        Thread.sleep((long) (Math.random() * 3000));
    }

}

// sleep让出cpu时间给其他线程执行.也许你会问，既然我已经wait了，为什么还要sleep?

 // wait()的作用就是阻塞当前线程并且释放对象的锁给别人（一般是等待队列中的第一个线程）

 // Thead.sleep()也是阻塞当前线程，但不释放锁。

 // sleep()方法是使线程停止一段时间的方法。

 // 在sleep 时间间隔期满后，线程不一定立即恢复执行。

 // 这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非 (a)“醒来”的线程具有更高的优先级。

 // (b)正在运行的线程因为其它原因而阻塞。 wait()是线程交互时，如果线程对一个同步对象x

 // 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

 // 当调用wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用。

 // waite()和notify()因为会对对象的“锁标志”进行操作，所以它们必须在synchronized函数或synchronized

 

/*
 * 消费者线程
 * */
public class Consumer extends Sleep implements Runnable {
    private Container contain = null;

    public Consumer(Container contain) {
        super();
        this.contain = contain;
    }

    public void run() {
        // TODO Auto-generated method stub

        while (true) {
            synchronized (contain) {
                while (contain.isEmpty()) {
                    try {
                        contain.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block

                        e.printStackTrace();
                    }
                }
            }
            consume();//消费

            try {
                haveASleep();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block

                e.printStackTrace();
            }
            synchronized (contain) {
                contain.notify();
            }
        }
    }

    private void consume() {
        Product a = (AProduct) contain.pop();
        System.out.println("消费了一个产品" + a.toString());
    }
}


/*
 * 生产者线程
 * */
public class Producator extends Sleep implements Runnable {
    private Container contain = null;

    public Producator(Container contain) {
        super();
        this.contain = contain;
    }

    public void run() {
        // TODO Auto-generated method stub

        while (true) {
            synchronized (contain) {
                while (contain.isFull()) {
                    try {
                        contain.wait();// 阻塞当前线程,当前线程进入等待队列。这个时候只有等待别的线程来唤醒自己了。

                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block

                        e.printStackTrace();
                    }
                }
            }
            producer();// 生产一个产品

            try {
                haveASleep();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block

                e.printStackTrace();
            }
            synchronized (contain) {
                contain.notify();// 唤醒等待队列中正在等待的第一个线程，让其执行。

            }
        }
    }

    public void producer() {
        Product aProduct = new AProduct("pp:" + String.valueOf(Math.random()));
        System.out.println("生产了一个产品：" + aProduct.toString());
        contain.push(aProduct);
    }

}


5 写一个测试吧：

public class TestMain {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Container contain = new Container();
        Producator p = new Producator(contain);
        Consumer c = new Consumer(contain);
        Thread pt = new Thread(p);
        Thread ct = new Thread(c);
        pt.start();
        ct.start();
    }

}

 

 

1.生产和消费的产品抽象类：
public abstract class Product {
    public String name;
    public abstract String toString();
}

2.一个具体的产品类：

public class AProduct extends Product {
    public AProduct(String name) {
        this.name = name;
        // TODO Auto-generated constructor stub
    }
    public String toString() {
        // TODO Auto-generated method stub
        return this.name;
    }
}

3.容器类（仓库）：


import java.util.ArrayList;

/*
 * 存放生产者和消费者的产品队列
 * */
public class Container {
    private ArrayList arrList = new ArrayList();
    private int LENGTH = 10;
    public boolean isFull() {
        return arrList.size()==LENGTH;
    }
    public boolean isEmpty() {
        return arrList.isEmpty();
    }

    /* 如果此处不加synchronized锁，那么也可以再调用push的地方加锁
    * 既然此处加了锁，那么再别的地方可以不加锁
    */
    public synchronized void push(Object o) {
        arrList.add(o);
    }
    // 如果此处不加synchronized锁，那么也可以再调用push的地方加锁
    public synchronized Object pop() {
        Object lastOne = arrList.get(arrList.size()- 1);
        arrList.remove(arrList.size()- 1);
        return lastOne;
    }
}

4.休息一会，生产者和消费者都要休息，因此作为抽象基类：


public abstract class Sleep {
    public void haveASleep() throws InterruptedException {
        Thread.sleep((long)(Math.random()* 3000));
    }
}


/*
 * 消费者线程
 * */
public class Consumer extends Sleep implements Runnable {
    private Container contain =null;
    public Consumer(Container contain) {
        this.contain = contain;
    }
    public void run() {
        // TODO Auto-generated method stub
        while(true) {
            synchronized(contain) {
                while(contain.isEmpty()) {
                    try{
                        contain.wait();
                    }catch(InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            consume();//消费
            try {
                haveASleep();
            }catch(InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized(contain) {
                contain.notify();
            }
        }
    }
    private void consume() {
        Product a = (AProduct)contain.pop();
        System.out.println("消费了一个产品"+ a.toString());
    }
}


/*
 * 生产者线程
 * */
public class Producator extends Sleep implements Runnable {
    private Container contain = null;
    public Producator(Container contain) {
        super();
        this.contain = contain;
    }
    public void run() {
        // TODO Auto-generated method stub
        while(true) {
            synchronized(contain) {
                while(contain.isFull()) {
                    try{
                        contain.wait();// 阻塞当前线程,当前线程进入等待队列。这个时候只有等待别的线程来唤醒自己了。
                    }catch(InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            producer();// 生产一个产品
            try {
                haveASleep();
            }catch(InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized(contain) {
                contain.notify();// 唤醒等待队列中正在等待的第一个线程，让其执行。
            }
        }
    }
    public void producer() {
        Product aProduct = new AProduct("pp:"+String.valueOf((int)(10*Math.random())));
        System.out.println("生产了一个产品："+ aProduct.toString());
        contain.push(aProduct);
    }
}

5. 写一个测试：


public class TestMain {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Container contain = new Container();
        Producator p = new Producator(contain);
        Consumer c = new Consumer(contain);
        Thread pt =new Thread(p);
        Thread ct =new Thread(c);
        pt.start();
        ct.start();
    }
}

 

 

好了，看看执行结果吧：

生产了一个产品：pp:0.5010546528255287
生产了一个产品：pp:0.08173509855014827
消费了一个产品pp:0.5010546528255287
生产了一个产品：pp:0.7022996270428004
生产了一个产品：pp:0.6245814751574797
生产了一个产品：pp:0.2839979336434959
生产了一个产品：pp:0.49694821923381394
消费了一个产品pp:0.49694821923381394
生产了一个产品：pp:0.7830305503500449
消费了一个产品pp:0.7830305503500449
消费了一个产品pp:0.2839979336434959
生产了一个产品：pp:0.8563793401031702
消费了一个产品pp:0.8563793401031702
生产了一个产品：pp:0.32584165485489935
生产了一个产品：pp:0.28527005336129474
消费了一个产品pp:0.28527005336129474
生产了一个产品：pp:0.9941746668279293
消费了一个产品pp:0.9941746668279293
消费了一个产品pp:0.32584165485489935
生产了一个产品：pp:0.7338057107242784
生产了一个产品：pp:0.7582181553056575
消费了一个产品pp:0.7582181553056575
生产了一个产品：pp:0.7563821078081756
生产了一个产品：pp:0.5659487332730776
消费了一个产品pp:0.5659487332730776
生产了一个产品：pp:0.8737523015090108
消费了一个产品pp:0.8737523015090108
消费了一个产品pp:0.7563821078081756
消费了一个产品pp:0.7338057107242784
生产了一个产品：pp:0.37558043387512685
消费了一个产品pp:0.37558043387512685
生产了一个产品：pp:0.5152849555101155
消费了一个产品pp:0.5152849555101155
消费了一个产品pp:0.6245814751574797
生产了一个产品：pp:0.2839737014600726
生产了一个产品：pp:0.14867665839711486
消费了一个产品pp:0.14867665839711486
消费了一个产品pp:0.2839737014600726
生产了一个产品：pp:0.7526721181825591
消费了一个产品pp:0.7526721181825591
生产了一个产品：pp:0.7413376261101124
生产了一个产品：pp:0.6122237252752002
消费了一个产品pp:0.6122237252752002
生产了一个产品：pp:0.5506019686616669
消费了一个产品pp:0.5506019686616669
消费了一个产品pp:0.7413376261101124
消费了一个产品pp:0.7022996270428004
消费了一个产品pp:0.08173509855014827
生产了一个产品：pp:0.4210845970052677
生产了一个产品：pp:0.38826328968056667
消费了一个产品pp:0.38826328968056667
生产了一个产品：pp:0.8431303537483879
消费了一个产品pp:0.8431303537483879
消费了一个产品pp:0.4210845970052677
生产了一个产品：pp:0.34155093374925427
消费了一个产品pp:0.34155093374925427
生产了一个产品：pp:0.6344976720730141
消费了一个产品pp:0.6344976720730141
生产了一个产品：pp:0.8363082839823789
生产了一个产品：pp:0.2811236642618875
消费了一个产品pp:0.2811236642618875
生产了一个产品：pp:0.5203709922238451
消费了一个产品pp:0.5203709922238451
生产了一个产品：pp:0.33594716801656854
消费了一个产品pp:0.33594716801656854
生产了一个产品：pp:0.6769814698429393
消费了一个产品pp:0.6769814698429393
生产了一个产品：pp:0.9745584834485369
消费了一个产品pp:0.9745584834485369
生产了一个产品：pp:0.8499765864829567
消费了一个产品pp:0.8499765864829567
生产了一个产品：pp:0.6281666437831501
生产了一个产品：pp:0.7009942032367253
生产了一个产品：pp:0.6354980777267613
消费了一个产品pp:0.6354980777267613
生产了一个产品：pp:0.5343260452244308
生产了一个产品：pp:0.7760536310129287
消费了一个产品pp:0.7760536310129287
生产了一个产品：pp:0.1571400849830824
消费了一个产品pp:0.1571400849830824
生产了一个产品：pp:0.7219309859537877
消费了一个产品pp:0.7219309859537877
消费了一个产品pp:0.5343260452244308
生产了一个产品：pp:0.27212965262811006
生产了一个产品：pp:0.6767042422791443
消费了一个产品pp:0.6767042422791443
生产了一个产品：pp:0.5569267542654116
消费了一个产品pp:0.5569267542654116
生产了一个产品：pp:0.2711661616389571
消费了一个产品pp:0.2711661616389571
消费了一个产品pp:0.27212965262811006
消费了一个产品pp:0.7009942032367253
消费了一个产品pp:0.6281666437831501
生产了一个产品：pp:0.2002128062138283
生产了一个产品：pp:0.1922231902417787
消费了一个产品pp:0.1922231902417787
消费了一个产品pp:0.2002128062138283
生产了一个产品：pp:0.17966888984989626
生产了一个产品：pp:0.3671850675304076
消费了一个产品pp:0.3671850675304076
生产了一个产品：pp:0.939554979545969
消费了一个产品pp:0.939554979545969
生产了一个产品：pp:0.40458123731585616
生产了一个产品：pp:0.5295806686705823
消费了一个产品pp:0.5295806686705823
生产了一个产品：pp:0.20237224414120825
生产了一个产品：pp:0.3318491844902224
生产了一个产品：pp:0.6154098900759897
消费了一个产品pp:0.6154098900759897

……