对于单个生产者和单个消费者模式,可以使用wiat与notify来进行解决。
使用一个变量isproduce来标记当前是否生产了产品,如果isproduce为true,那么说明当前已经有一个产品生产好了,此时生产产品的线程应该wait,消费的线程应该被重新启动,反之,如果isproduce为false,那么此时说明没有产品生产,生产的线程应该启动,消费的线程应该wait。
代码如下:
package Thread;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import org.omg.CORBA.PUBLIC_MEMBER;
@SuppressWarnings("all")
class Test {
public static Object LOCK = new Object();
public volatile boolean isproduce = false; //用来标记当前是否有产品产生
public static int i = 0;
public void produce() {
synchronized (LOCK) {
if (isproduce) {
try {
LOCK.wait(); //如果还有产品没有被消费,生产的线程应该wait
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
i++;
System.out.println("P->" + i);
isproduce = true;
LOCK.notify(); //主要是唤醒消费的线程。
}
}
}
public void consume() {
synchronized (LOCK) {
if (isproduce) {
System.out.println("C->" + i); //有产品就消费
isproduce = false;
LOCK.notify(); //消费完之后唤醒生产的线程
} else {
try {
LOCK.wait(); //没有产品可以消费,那就等待产品产生。
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public class Main {
public static void main(String[] args) {
Test x1 = new Test();
new Thread() {
@Override
public void run() {
while (true)
x1.produce();
};
}.start();
new Thread() {
@Override
public void run() {
while(true) {
while(true)
x1.consume();
}
};
}.start();
}
}
那么这是单个消费者与单个生产者,在现实生活中消费者是多个的,生产者是多个的,那么用上面的那种模式还以可以吗?
答案是否定的,假设有两个生产者和两个消费者,代码如下:
package Thread;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import org.omg.CORBA.PUBLIC_MEMBER;
@SuppressWarnings("all")
class Test {
public static Object LOCK = new Object();
public volatile boolean isproduce = false;
public static int i = 0;
public void produce() {
synchronized (LOCK) {
if (isproduce) {
try {
LOCK.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
i++;
System.out.println("P->" + i);
isproduce = true;
LOCK.notify();
}
}
}
public void consume() {
synchronized (LOCK) {
if (isproduce) {
System.out.println("C->" + i);
isproduce = false;
LOCK.notify();
} else {
try {
LOCK.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public class Main {
public static void main(String[] args) {
Test x1 = new Test();
for (int i = 1; i <= 2; i++) { //两个生产者
new Thread() {
@Override
public void run() {
while (true)
x1.produce();
};
}.start();
}
for (int i = 1; i <= 2; i++) { //两个消费者
new Thread() {
@Override
public void run() {
while (true) {
while (true)
x1.consume();
}
};
}.start();
}
}
}
那么上述代码运行的结果是:
这种情况并不是死锁,而是出现了假死的现象,那么为什么会出现这种情况呢?
分析原因如下:
我们把上述代码输出结果加上线程的名称就好理解了:
P0:第一个生产者。
P1:第二个生产者。
C0:第一个消费者。
C1:第二个消费者。
对于第一个产品来说,由P0生产,接着由C0消费,此时等待的队列有{P1,C1},接着有P0生产第二件产品,由C1来消费,此时等待的队列中有:{P1,C0},接着有P1生产第三件产品,然后此时等待队列中就含有{P0,C0,C1},接着在P1生产完第三件产品之后,如果唤醒的是P0的话,就会出现假死的状况,我们接着来分析为啥,唤醒P0之后,接着由于isproduce是true,P0就会进入wait状态,而之前的P1由于isproduce的状态也为true(也就是由于没有消费的线程被唤醒,所有的生产的线程最终都会进入到wait状态),同样会进入wait状态,到现在为止,所有的线程都进入到了wait状态下,都不会去占用CPU,程序就卡在了这(当然我认为还有另一种情况,就是最后一步是消费线程,当消费者线程滑行的时候,唤醒的是另一个消费者线程,那么最终也会出现假死的现象),
那怎么解决这个问题呢?
既然是由于生产的线程或者消费的线程没有被及时的唤醒,那么可以采用notifyAll来唤醒LOCK对象锁池中等待的线程,就不会出现上述的情况了。
代码如下:
package Thread;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import org.omg.CORBA.PUBLIC_MEMBER;
@SuppressWarnings("all")
class Test {
public static Object LOCK = new Object();
public volatile boolean isproduce = false;
public static int i = 0;
public void produce() {
synchronized (LOCK) {
if (isproduce) {
try {
LOCK.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
i++;
System.out.println("P *" + Thread.currentThread().getName() + " " + i);
isproduce = true;
LOCK.notifyAll();
}
}
}
public void consume() {
synchronized (LOCK) {
if (isproduce) {
System.out.println("C *" + Thread.currentThread().getName() + " " + i);
isproduce = false;
LOCK.notifyAll();
} else {
try {
LOCK.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public class Main {
public static void main(String[] args) {
Test x1 = new Test();
for (int i = 1; i <= 2; i++) {
new Thread() {
@Override
public void run() {
while (true)
x1.produce();
};
}.start();
}
for (int i = 1; i <= 2; i++) {
new Thread() {
@Override
public void run() {
while (true) {
while (true)
x1.consume();
}
};
}.start();
}
}
}
如果写的有问题,还请博主们指出。