生产者消费者模式

作为一个初学者，对于多线程编程，完全没有概念，这时候你需要从最简单的多线程开始，通过一些简单的实例，去加深对于多线程的理解。对于多线程的概念什么的，我就不说了，反正我是说不清楚的，度娘上一大堆，不过在看那些定义之前，我觉得你最好能理解最简单的生产者-消费者模式，理解过后再去看那些枯燥的定义，或许能加深你对多线程的印象，废话不多说，直接上代码。

sychronized锁对象，在本例中锁的是馒头对象，注意在用到sychronized关键字的代码中，本段代码会被一直执行到末尾，才会释放出锁住的对象，以供线程争抢这个资源（这个线程可能会和上一个线程一样，意思就是说生产者生产一次，下一次可能生产者还会获得这个资源继续生产）。

需要注意的地方：对于馒头中的生产和消费方法，必须是原子性操作，什么意思呢，就是说里面写的是最基本的操作。举个例子一个循环需要循环n次，那么它的每次循环就是最原子的操作。这个操作一旦被加上sychronized关键字，那么每次循环都会执行到末尾才结束，而不受wait()方法影响。wait()和notify()方法只会配合sychronized使用。

wait()和notifiy()方法会阻断当前线程的进行，wait()方法释放对象锁，线程会处于等待状态，再等待notify()的唤醒，再次进入到可运行状态，下面附上线程各个状态间的转换关系图。

public class Mantou {
int list;

public Mantou(int list){
this.list = list;
}

public void produce(){
synchronized (this) {
if(list>=500){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
list++;
System.out.println("prodeucer馒头数量为"+list);
this.notifyAll();
}


}
}

public void consume(){
synchronized (this) {
if(list<=0){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else{

list--;
this.notifyAll();
System.out.println("consumer馒头数量为"+list+"-------------");
}
}
}
}

public class Producer extends Thread{

Mantou m ;

public Producer(Mantou m){
this.m = m;
}


@Override
public void run() {
for(int i =0;i<500;i++){
m.produce();
// try {
// this.sleep(500);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
}
}
}

public class Consumer extends Thread{

public Mantou m;

public Consumer(Mantou m){
this.m = m;
}

@Override
public void run() {
for(int i =0;i<500;i++){
m.consume();
// try {
// this.sleep(500);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
}
}
}

public class Test {

public static void main(String[] args) {
int list =0;
Mantou m = new Mantou(list);

Producer p = new Producer(m);
Consumer c = new Consumer(m);

p.start();
c.start();
}
}