1.一生产与一消费：操作值
public class P {
private String lock;
public P(String lock){
super();
this.lock = lock;
}
public void setValue(){
try {
synchronized (lock){
if(!ValueObject.value.equals("")){
lock.wait();
}
String value = System.currentTimeMillis() + "_" +
System.nanoTime();
System.out.println("set的值是" + value);
ValueObject.value = value;
lock.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
class C {
private String lock;
public C(String lock) {
super();
this.lock = lock;
}
public void getValue() {
try {
synchronized (lock) {
if (ValueObject.value.equals("")) {
lock.wait();
}
System.out.println("get的值是" + ValueObject.value);
ValueObject.value = "";
lock.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class ThreadP extends Thread {
private P p;
public ThreadP(P p){
super();
this.p = p;
}
@Override
public void run(){
while (true){
p.setValue();
}
}
}
class ThreadC extends Thread {
private C c;
public ThreadC(C c){
super();
this.c = c;
}
@Override
public void run(){
while (true){
c.setValue();
}
}
}
}
public class Run{
public static void main(String[] args){
String lock = new String("");
P p = new P(lock);
C c = new C(lock);
ThreadP pThread = new ThreadP(p);
ThreadC cThread = new ThreadC(r);
pThread.start();
cThread.start();
}
}
上述代码是一生产一消费进行数据的交互在控制台中打印的日志get和set是交替运行的。
但是如果是多生产者和多消费者，那在运行中就极有可能出现假死状态（即所有线程均处于WAITING状态）
2.多生产与多消费：操作值－假死
假死的现象其实就是线程进入WAITING状态，则程序就不再执行任何业务功能了，整个项目呈停止状态。这在使用生产者与消费者模式时经常遇到。
public class P｛
private String lock；
public P（String lock）｛
super（）；
this.lock ＝ lock；
｝
public void setValue（）｛
synchronized （lock）｛
while（！ValueObject.Value.equals（""））｛
System.out.println（“生产者”＋
Thread.currentThread（）.getName()+"WAITING了"）；
lock.wait();
｝
System.out.println("生产者"＋
Thread.currentThread().getName()+"RUNNABLE了")；
String value ＝
System.currentTimeMillis()+"_"+System.nanoTime();
ValueObject.value=value;
lock.notify();
｝
｝
｝
public class C｛
private String lock；
public C（String lock）｛
super（）；
this.lock ＝ lock；
｝
public void setValue（）｛
synchronized （lock）｛
while（ValueObject.Value.equals（""））｛
System.out.println（“消费者”＋
Thread.currentThread（）.getName()+"WAITING了"）；
lock.wait();
｝
System.out.println("消费者"＋
Thread.currentThread().getName()+"RUNNABLE了");
ValueObject.value="";
lock.notify();
｝
｝
｝
class ThreadP extends Thread {
private P p;
public ThreadP(P p){
super();
this.p = p;
}
@Override
public void run(){
while (true){
p.setValue();
}
}
}
class ThreadC extends Thread {
private C c;
public ThreadC(C c){
super();
this.c = c;
}
@Override
public void run(){
while (true){
c.setValue();
}
}
}
}
public class Run{
public static void main（String［］ args）｛
String lock = new String("")；
P p = new P(lock);
C r = new C(lock);
ThreadP[] pThread = new ThreadP[2];
ThreadC[] rThread = new ThreadC[2];
for(int i=0;i<2;i++){
pThread[i] = new ThreadP(p);
pThread[i].setName("生产者"＋（i＋1）)；
rThread[i] = new ThreadC(r);
rThread[i].setName("消费者" ＋ (i+1));
pThread[i].start();
rThread[i].start();
}
Thread.sleep(5000);
Thread[] threadArray = new
Thread[Thread.currentThread().getThreadGroup().activeCount()];
Thread.currentThread().getThreadGroup()
.enumerate(threadArray);
for(int i = 0;i<threadArray.length;i++){
System.out.println(ThreadArray[i].getName()+" "+threadArray[i].getState());
}
｝
}
在代码中确实已经通过wait／notify进行通信了，但不保证notify唤醒的是异类，也许是同类，比如“生产者”唤醒“生产者”或“消费者”唤醒“消费者”这样的情况。如果按这样的情况运行的比率积少成多，就会导致所有的线程都不能继续运行下去，大家都在等待，都呈WAITING状态，程序最后也就呈假死状态。
如何解决唤醒同类的问题？
将notify（）改成notifyAll（），也就是不光唤醒同类，将异类也一同唤醒就解决了。
