应网友要求，现分享一个关于java线程学习的DEMO

一个关于线程的学习DMEO，本DEMO是很久以前以前写的，欢迎您与我讨论学习

DEMO的场景是

仓库中有一种物品B，供消费者消费

但是消费者是线程方式的，也就是说消费者是随机来取物品B的

如果仓库中没有物品B，就锁定消费者，不让其来取物品，同时线程交给生产者来生产，当生产者生产物品B后，就就可以解锁消费者，让消费者来消费了

下面我们先写我们的仓库类

package com.thread;

public class Cangku {
	private char ck; // 仓库中的产品
	private boolean b = false; // 标记仓库中是否有产品

	public char getCk() {
		return ck;
	}

	public void setCk(char ck) {
		this.ck = ck;
	}

	public boolean isB() {
		return b;
	}

	public void setB(boolean b) {
		this.b = b;
	}

	// 消费者
	synchronized public void xiaofei() {
		if (isB()) {
			notify();
			System.out.println("取出了b");
			setB(false);
		} else {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			System.out.println("仓库中没有商品，等待生产");
		}
	}

	// 生产者
	synchronized public void shengchan() {
		if (!isB()) {
			notify();
			setCk('b');
			System.out.println("生产了B");
			setB(true);
		} else {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			System.out.println("仓库中有商品，等待取出");
		}
	}
}

上面的代码，如果有两个消费者线程去访问，就会出现第二次仓库中没有物品B，就会提示您等待生产

此时消费者线程被锁定，就等待生产者来生产

下面是消费者类

package com.thread;

/*
 * 消费者类线程
 */
public class ConsumptionThread extends Thread {
	private Cangku ck;

	public ConsumptionThread(Cangku ck, String name) {
		super(name);
		this.ck = ck;
	}

	public void run() {
		for (int i = 0; i < 10; i++) {
			ck.xiaofei();
			System.out.println(Thread.currentThread().getName() + " 第" + (i+1)
					+ "次 取出B");
			try {
				sleep(1500);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
	}
}

最后是生产者类：

package com.thread;

/*
 * 生产者类线程
 */
public class ProductionThread extends Thread {
	private Cangku ck;

	public ProductionThread(Cangku ck, String name) {
		super(name);
		this.ck = ck;
	}

	public void run() {
		for (int i = 0; i < 10; i++) {
			ck.shengchan();
			System.out.println(Thread.currentThread().getName() + " 第" + (i+1)
					+ "次 生产出B");
			try {
				sleep(1500);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
	}

}

消费者类和生产者类模拟十次去仓库存取的情况

最后就是我们的测试类：

package com.thread;

public class Cangkudemo {

	public static void main(String[] args) {
		Cangku C = new Cangku();
		new ProductionThread(C, "生产者").start();
		new ConsumptionThread(C, "消费者").start();

	}

}

运行结果如下：

生产了B
生产者 第1次 生产出B
取出了b
消费者 第1次 取出B
生产了B
生产者 第2次 生产出B
仓库中没有商品，等待生产
消费者 第2次 取出B
取出了b
消费者 第3次 取出B
生产了B
生产者 第3次 生产出B
取出了b
仓库中有商品，等待取出
生产者 第4次 生产出B
消费者 第4次 取出B
生产了B
生产者 第5次 生产出B
仓库中没有商品，等待生产
消费者 第5次 取出B
取出了b
生产了B
生产者 第6次 生产出B
消费者 第6次 取出B
取出了b
消费者 第7次 取出B
生产了B
生产者 第7次 生产出B
取出了b
消费者 第8次 取出B
仓库中有商品，等待取出
生产者 第8次 生产出B
生产了B
仓库中没有商品，等待生产
消费者 第9次 取出B
生产者 第9次 生产出B
取出了b
消费者 第10次 取出B
生产了B
生产者 第10次 生产出B

注意加粗的黑体字，每次运行，上面的结果应该都是不一样的。