Java多线程-生产者于消费者 博客分类： javajust do itmore and more java多线程thread生产者和消费者经典

闲来无事，好久没有接触Java的高级东西了，害怕后期会忘记而寻找资料无门，所以写一个最简单的并且典型的多线程入门例子

/**
 * 
 * @author Administrator
 */
public class BigCup {

	/**
	 * 容器的大小
	 */
	private int size;

	/**
	 * 容器当前的数量
	 */
	private int count;

	public BigCup(int i) {
		this.size = i;
	}

	public void push(String name) {
		System.out.println(name + "放进去一个面包");
		count++;
	}

	public void pop(String name) {
		System.out.println(name + "拿出来一个面包");
		count--;
	}

	public int getSize() {
		return size;
	}

	public void setSize(int size) {
		this.size = size;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

}

public class Producer implements Runnable {

	/**
	 * 生产者的名字
	 */
	private String name;

	/**
	 * 拿着当前容器的引用
	 */
	private BigCup bc;

	public Producer(String name, BigCup bc) {
		super();
		this.name = name;
		this.bc = bc;
	}

	@Override
	public void run() {
		Thread.currentThread().setName(name);
		//Thread.currentThread().setPriority(1);
		set();
	}

	@SuppressWarnings("static-access")
	public void set() {
		for (int i = 0; i < 100; i++) {
			synchronized (bc) {
				while (bc.getCount() >= bc.getSize()) {
					try {
						System.out.println("满了，请取东西...");
						bc.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}

				try {
					Thread.currentThread().sleep(300);

				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				bc.push(name);

				bc.notify();
				Thread.yield();
			}
		}
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public BigCup getBc() {
		return bc;
	}

	public void setBc(BigCup bc) {
		this.bc = bc;
	}

}

public class Consumer implements Runnable {

	/**
	 * 消费者的名字
	 */
	private String name;

	/**
	 * 拿着当前容器的引用
	 */
	private BigCup bc;

	public Consumer(String name, BigCup bc) {
		super();
		this.name = name;
		this.bc = bc;
	}

	@Override
	public void run() {
		Thread.currentThread().setName(name);
		//Thread.currentThread().setPriority(8);
		get();
	}

	@SuppressWarnings("static-access")
	public void get() {
		for (int i = 0; i < 100; i++) {
			synchronized (bc) {
				while (bc.getCount() < 1) {
					try {
						System.out.println("空了，请放东西...");
						bc.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				try {
					Thread.currentThread().sleep(300);

				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				bc.pop(name);

				bc.notify();
				Thread.yield();
			}
		}
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public BigCup getBc() {
		return bc;
	}

	public void setBc(BigCup bc) {
		this.bc = bc;
	}

}

测试类：

public class Test {

	public static void main(String[] args) {

		BigCup bc = new BigCup(10);

		Consumer c = new Consumer("旺旺", bc);

		Producer p = new Producer("淘宝", bc);

		Thread t1 = new Thread(p);
		t1.start();
		
		Thread t2 = new Thread(c);
		t2.start();
		
		Thread t3 = new Thread(c);
		t3.start();
		Thread t4 = new Thread(c);
		t4.start();
		Thread t5 = new Thread(c);
		t5.start();

	}
}

打印的结果如下

空了，请放东西...
空了，请放东西...
淘宝放进去一个面包
旺旺拿出来一个面包
空了，请放东西...
空了，请放东西...
淘宝放进去一个面包
淘宝放进去一个面包
淘宝放进去一个面包
满了，请取东西...
旺旺拿出来一个面包
旺旺拿出来一个面包
旺旺拿出来一个面包
空了，请放东西...
空了，请放东西...
淘宝放进去一个面包
淘宝放进去一个面包
旺旺拿出来一个面包
旺旺拿出来一个面包
空了，请放东西...
空了，请放东西...

同步代码块：
    1.被synchronized包围的代码块称为同步代码块
    2.synchronized代码块需要接收一个参数，该参数是一个对象，可以称为该代码块的锁对象（又称同步锁）。
    3.若某线程一旦持有锁对象的监视器，其它线程即不能同时持有该锁对象的监视器，从而实现线程基于特定锁对象的互斥。
    4.注意：这里表示的是线程独占锁对象的监视器，而非锁对象，其它线程仍可以访问该锁对象的方法和属性。
    5.多个线程以竞争的方式争夺锁对象的监视器，线程执行完该代码块，即释放锁对象的监视器。

同步实例方法：
    就是在方法前面加上关键字synchronized，即实现了方法的同步，相当于整个方法是一个同步代码块，其锁对象是this

同步静态方法：
    就是在静态方法前面加上关键字synchronized，也是将整个方法看做一个同步代码块，其锁对象较特别，是将所属类作为锁对象

Java提供了一个精心设计的线程间通信机制即wait-notify机制，通过该机制可以实现线程协作，wait-notify机制是通过使用wait()、notify()和notifyAll()三个方法来实现的，这三个方法均定义在Object类中，是final修饰的实例方法，这三个方法必须在synchronized代码中调用，而且只有锁对象才能调用这三个方法。即持有锁对象监视器的线程才能调用锁对象的这三个方法；

wait()方法：
    调用该方法的线程退出监视器并进入等待状态，直到其他线程进入相同的监视器并调用notify( )方法。

notify()方法：
    通知等待（该方法所属对象）监视器的（多个）线程中的一个结束等待；即唤醒一个等待（当前线程所持有）监视器的线程。

notifyAll()方法：
    通知等待（该方法所属对象）监视器的所有线程结束等待；即唤醒所有等待（当前线程所持有）监视器的线程。


后记，还有几个方法没有涉及到，时间有限，后期会慢慢的同步。