主线程跟子线程怎么通讯 java

学到多线程，编了一个简单地电脑城进出货模拟系统。
代码有点长，主要部分如下所述：
有三方：厂家，电脑城，顾客
厂家2个，一个生产主板，一个生产显卡。
顾客有2个，他们各自不断购买主板和显卡。
电脑城有一个，卖显卡和主板。
限于篇幅问题，摘录主要代码如下：
--------------------------厂家类---------------------------------------
Java代码
public class Mainboardretailer implements Runnable// 主板厂家
{
public void run()
{
while(true)
{
电脑城.stockMainboard(deliverMB("MSI"));//不断向电脑城供货
}
}

public Mainboard deliverMB(String 主板名)
{
return 主板;
}

}
public class Videocardretailer implements Runnable// 显卡厂家
{
public void run()
{
while(true)
{
电脑城.stockVideocard(deliverVC("ATI"));//不断向电脑城供货
}
}
public videocard deliverMB(String 显卡名)
{
return 显卡;
}

}

-------------------------------------顾客类-------------------------------------------
Java代码
public class customer implements Runnable
{
public void run()
{
while(true)
{
buyVC("ATI");
//顾客不断购买显卡和主板
buyMB("MSI");
}
}

}

-----------------------------电脑城类-----------------------------------------
Java代码
public class ComputerCenter
{
int MAXVCSTORE = 100;//货仓容量
int MAXMBSTORE = 100;//货仓容量
private static LinkedList<Videocard> VideocardQty = new LinkedList<Videocard>();//显卡货仓
private static LinkedList<Mainboard> MainboardQty = new LinkedList<Mainboard>();//主板货仓

public synchronized void stockVideocard(Videocard VCname)
{
if(VideocardQty.size() >= MAXVCSTORE)
{
System.out.println("ComputerCenter: the VC storage is MAX");
try
{
wait();//---------------------当存货过多时。通知厂商等待。
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
VideocardQty.add(VCname);
notify();//----------------------------唤醒消费者消费
}

public synchronized void stockMainboard(Mainboard MBname)
{
if(MainboardQty.size() >= MAXVCSTORE)
{
System.out.println("ComputerCenter: the MB storage is MAX");
try
{
wait();//----------------------当存货过多时。通知厂商等待。
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
MainboardQty.add(MBname);
notify();//-----------------------------唤醒消费者消费
}

public synchronized Videocard sellVideocard(String VCname)
{
if(VideocardQty.size() <= 0)
{
try
{
wait();//-----------------没有存货时，通知消费者等待
}catch(Exception e)
{
e.printStackTrace();
}
}
notify();//----------------------------------唤醒厂商
return MyVideocard;
}

public synchronized Mainboard sellMainboard(String MBname)
{
if(MainboardQty.size() <= 0)
{
try
{
wait();//-----------------没有存货时，通知消费者等待
}catch(Exception e)
{
e.printStackTrace();
}
}
notify();//----------------------------------唤醒厂商
return MyMainboard;
}

public static void main(String[] args)
{
ComputerCenter MyCC = new ComputerCenter();
new customer(MyCC,"Jack").start();
new customer(MyCC,"Tom").start();
new Mainboardretailer(MyCC).start();
new Videocardretailer(MyCC).start();
}

}


现在出现了这样的一个问题：
1.如果有两个消费者同时等待，厂家生产后唤醒其中消费者A，消费者A购买完毕后会唤醒消费者B--不合逻辑。
2.如果购买显卡地消费者A在等待，电脑城从主板厂商进货了主板以后会唤醒消费者A。同样的情况也发生在购买主板的消费者B身上。
3.如果两家厂商在等待消费者购买商品，此时消费者A购买了主板，货仓主板数量-1，然后有可能唤醒显卡厂商而没有唤醒主板厂商进行生产。
4.如果两家厂商正在等待消费者购买商品，此时显卡厂商被唤醒后，可能立刻唤醒主板厂商生产主板，令到商品数量超出仓库上限。

我想，有没有什么办法，可以指定唤醒某个线程？如果可以，那问题就容易解决了。

------------------------------------------------------------------------------------------------------------------
问题补充：
xmind 写道
主要问题是 显卡 没了，等显卡送来，主板没了等主板送来。
不能人家来买显卡的，你进来一个主板也通知人家来买。
写了个例子，你看看。
Java代码
class ComputerCenter {
private static Object VIDEO = new Object();
private static Object MAINB = new Object();
private static Integer videoN = 10;
private static Integer MainbN = 10;

public void stockVd() {
synchronized(VIDEO) {
if(videoN >= 20) {
System.out.println("ComputerCenter: the VC storage is MAX");
try {VIDEO.wait();} catch (Exception e) {}
}
System.out.println("ComputerCenter: 厂商送来一块显卡。");
videoN++;
VIDEO.notify();//----------------------------唤醒消费者消费
}
}

public void stockMd() {
synchronized(MAINB) {
if(MainbN >= 20) {
System.out.println("ComputerCenter: the MB storage is MAX");
try {MAINB.wait();} catch (Exception e) {}
}
System.out.println("ComputerCenter: 厂商送来一块主板。");
MainbN++;
MAINB.notify();//-----------------------------唤醒消费者消费
}
}

public void sellVd(String name) {
synchronized(VIDEO) {
if(videoN <= 0) {
System.out.println("没有显卡了，等等，马上送来!!!!!!!!!");
try {VIDEO.wait();} catch (Exception e) {}
}
System.out.println(name + " : 买走一块显卡。");
videoN--;
VIDEO.notify();//----------------------------------唤醒厂商
}
}

public void sellMd(String name) {
synchronized(MAINB) {
if(MainbN <= 0) {
System.out.println("没有主板了，等等，马上送来!!!!!!!!!!");
try {MAINB.wait();} catch (Exception e) {}
}
System.out.println(name + " : 买走一块主板。");
MainbN--;
MAINB.notify();//----------------------------------唤醒厂商
}
}


public static void main(String[] args) {
ComputerCenter MyCC = new ComputerCenter();
new customer(MyCC,"Jack").start();
new customer(MyCC,"Tom").start();
new Md_retailer(MyCC).start();
new Vd_retailer(MyCC).start();
}
}

class customer extends Thread {
private ComputerCenter cc;
private String name;
public customer(ComputerCenter cc,String name) {
this.cc = cc;
this.name = name;
}

public void run() {
while(true) {
//try {Thread.sleep(10);} catch (Exception e) {}
//顾客不断购买显卡和主板
cc.sellVd(name); cc.sellMd(name);
}
}
}
class Md_retailer extends Thread {
private ComputerCenter cc;
public Md_retailer(ComputerCenter cc) {
this.cc = cc;
}

public void run() {
while(true) {
try {Thread.sleep(10);} catch (Exception e) {}
cc.stockMd();
}
}
}
class Vd_retailer extends Thread {
private ComputerCenter cc;
public Vd_retailer(ComputerCenter cc) {
this.cc = cc;
}

public void run() {
while(true) {
try {Thread.sleep(10);} catch (Exception e) {}
cc.stockVd();
}
}
}


注释掉不同地方的 try {Thread.sleep(10);} catch (Exception e) {} 可以模拟不同的情况。


非常感谢您，我修改了一下代码，用synchronized代码块来指定唤醒地对象。但是依然有一个问题：当有2人同时在等待买显卡地时候，厂商送来一块显卡，A买完后，却会唤醒B去买。这里有逻辑错误。该怎么样改进一下呢？
其实还有有种办法解决，就是通过在wait()那里套一个while（iswaiting）来实现唤醒指定地线程。电脑城进货后，改变某个boolean值，唤醒所有线程。那些没有被改变boolean值的线程将被套在while循环里面。这样可以解决问题，但我总觉得怪怪地不自然。

------------------------------------------------------------------------------------------------------------------
问题补充：
xmind 写道
噢，对不起，我是没有考虑这个情况。
你说的那种方法应该能够实现，我等待后再判断的方法试了试，要使，你看看
Java代码
public void sellMd(String name) {
synchronized(MAINB) {
if(MainbN <= 0) {
System.out.println("没有主板了，等等，马上送来!!!!!!!!!!");
try {MAINB.wait();} catch (Exception e) {}
}
if(MainbN >0) {
System.out.println(name + " : 买走一块主板。"+MainbN);
MainbN--;
}
MAINB.notify();//----------------------------------唤醒厂商
}
}
}

谢谢您。我觉得呢，这样子看上去是可行的，但还有一点逻辑上的错误。假如A,B都在等待买显卡，此时电脑城获得一块显卡，库存显卡数为1，通知AB其中一个。假设A买到了显卡，显卡库存变为0。此时A唤醒B。B醒来后if判断显卡数不大于0，所以并没有买走显卡，但是他却被唤醒并离开了，也就是说他这次不买显卡了（他本来是想买显卡的，只不过没货，在等待）。并且他离开时通知了电脑城再进一块显卡（如果此时达到库存上线，厂商在等待消费，那么它将被B唤醒而生产显卡，导致电脑城显卡数超出库存）。
这里是不是有点逻辑上的小漏洞呢？大家探讨探讨。

------------------------------------------------------------------------------------------------------------------
问题补充：
hareamao 写道


Java代码
import java.util.ArrayDeque;

public class StockManager {
private final Object producerLock = new Object();
private final Object consumerLock = new Object();
private final int MAX_SIZE = 10;

private final ArrayDeque<Product> queue = new ArrayDeque<Product>();

public void stock(Product p) throws InterruptedException {
synchronized (producerLock) {
if (queue.size() >= MAX_SIZE) {
producerLock.wait();
}
}
synchronized (queue) {
queue.add(p);
}
synchronized (consumerLock) {
consumerLock.notify();
}
}

public synchronized Product purchase() throws InterruptedException {
synchronized (consumerLock) {
if (queue.size() <= 0) {
consumerLock.wait();
}
}
Product product = null;
synchronized (queue) {
product = queue.remove();
}
synchronized (producerLock) {
producerLock.notify();
}
return product;
}
}

lz基本的问题就是，厂商和客户等的不是同一把锁，所以要分别对待。然后就简单了。不过我的StockManager看着也不怎么对劲儿。


阁下的方法是，将StockManager分开实例化令厂商解锁时只解在自己队列上排队的顾客，从而避免了唤醒另外一条队的顾客。这样子也可以。thanks。
另外问一句，为什么阁下的代码中这么多final的？

采纳的答案

2010-07-26 hareamao (高级程序员)
没怎么写过多线程，拿来练练手，未必正确。

Java代码
public class Product {
private String name;
private int serial;

public String getName() {
return name;
}

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

public int getSerial() {
return serial;
}

public void setSerial(int serial) {
this.serial = serial;
}
}

Java代码
import java.util.ArrayDeque;

public class StockManager {
private final Object producerLock = new Object();
private final Object consumerLock = new Object();
private final int MAX_SIZE = 10;

private final ArrayDeque<Product> queue = new ArrayDeque<Product>();

public void stock(Product p) throws InterruptedException {
synchronized (producerLock) {
if (queue.size() >= MAX_SIZE) {
producerLock.wait();
}
}
synchronized (queue) {
queue.add(p);
}
synchronized (consumerLock) {
consumerLock.notify();
}
}

public synchronized Product purchase() throws InterruptedException {
synchronized (consumerLock) {
if (queue.size() <= 0) {
consumerLock.wait();
}
}
Product product = null;
synchronized (queue) {
product = queue.remove();
}
synchronized (producerLock) {
producerLock.notify();
}
return product;
}
}

Java代码
import java.util.logging.Logger;

public class Producer implements Runnable{
private static final Logger log = Logger.getLogger(Producer.class.getName());

private String productName = null;
private int serial = 0;
private StockManager stockManager;

public void setProductName(String productName) {
this.productName = productName;
}

public void setStockManager(StockManager stockManager) {
this.stockManager = stockManager;
}

public Product produce() {
final Product p = new Product();
p.setName(productName);
p.setSerial(++serial);
return p;
}

@Override
public void run() {
try {
for( int i = 0; i < 20; i++) {
deliver();
}
Thread.sleep(30 * 1000);
while (true) {
deliver();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}

private void deliver() throws InterruptedException {
final long s = System.currentTimeMillis();
final Product product = produce();
stockManager.stock(product);
final long time = System.currentTimeMillis() - s;
if (time > 10) {
log.info(product.getName() + ", No. " +
product.getSerial() + " took " +
time + " milli seconds to finish." );
}
}
}

Java代码
import java.util.logging.Logger;

public class Consumer implements Runnable {
private static final Logger log = Logger.getLogger(Consumer.class.getName());

private String name;
private StockManager[] stockManagers;

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

public void setStockManagers(StockManager[] stockManagers) {
this.stockManagers = stockManagers;
}

@Override
public void run() {
for (int i = 0; i < 50; i++) {
final double v = Math.random() * stockManagers.length;
final int k = (int) Math.floor(v);
try {
final long s = System.currentTimeMillis();
final Product product = stockManagers[k].purchase();
final long time = System.currentTimeMillis() - s;
String l = "";
if (time > 10) {
l += "after " + time + " milli seconds of waiting, ";
}
l += (name + " bought product " + product.getName()
+ ", serial No. " + product.getSerial());
log.info(l);
} catch (InterruptedException e) {
e.printStackTrace();
break;
}

try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
}
}

Java代码
public class Mall {
public static void main(String[] args) {
final StockManager mb = new StockManager();
final Producer pmb = new Producer();
pmb.setProductName("Motherboard");
pmb.setStockManager(mb);

final StockManager vd = new StockManager();
final Producer pvd = new Producer();
pvd.setProductName("Video Card");
pvd.setStockManager(vd);

final StockManager[] stockManagers = new StockManager[2];
stockManagers[0] = mb;
stockManagers[1] = vd;

final Consumer c1 = new Consumer();
c1.setName("C1");
c1.setStockManagers(stockManagers);

final Consumer c2 = new Consumer();
c2.setName("C2");
c2.setStockManagers(stockManagers);

new Thread(c1).start();
new Thread(c2).start();

try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}

new Thread(pmb).start();
new Thread(pvd).start();
}
}


提问者对于答案的评价：
解决办法之一.
问题答案可能在这里 → 寻找更多解答

java生产者消费者经典问题
Java 关于线程同步的问题
java多线程 消费者-生产者
我有一个关于多线程编码的问题..
一段关于线程的代码 请教
其他回答

1.消费者由生产唤醒,每次唤醒队列中的一个,A买完就走,不要多管闲事
2.不同的产品在不同的队列中,不要排别人的队
3.4.同2
qinglangee (资深程序员) 2010-07-26
主要问题是 显卡 没了，等显卡送来，主板没了等主板送来。
不能人家来买显卡的，你进来一个主板也通知人家来买。
写了个例子，你看看。
Java代码
class ComputerCenter {
private static Object VIDEO = new Object();
private static Object MAINB = new Object();
private static Integer videoN = 10;
private static Integer MainbN = 10;

public void stockVd() {
synchronized(VIDEO) {
if(videoN >= 20) {
System.out.println("ComputerCenter: the VC storage is MAX");
try {VIDEO.wait();} catch (Exception e) {}
}
System.out.println("ComputerCenter: 厂商送来一块显卡。");
videoN++;
VIDEO.notify();//----------------------------唤醒消费者消费
}
}

public void stockMd() {
synchronized(MAINB) {
if(MainbN >= 20) {
System.out.println("ComputerCenter: the MB storage is MAX");
try {MAINB.wait();} catch (Exception e) {}
}
System.out.println("ComputerCenter: 厂商送来一块主板。");
MainbN++;
MAINB.notify();//-----------------------------唤醒消费者消费
}
}

public void sellVd(String name) {
synchronized(VIDEO) {
if(videoN <= 0) {
System.out.println("没有显卡了，等等，马上送来!!!!!!!!!");
try {VIDEO.wait();} catch (Exception e) {}
}
System.out.println(name + " : 买走一块显卡。");
videoN--;
VIDEO.notify();//----------------------------------唤醒厂商
}
}

public void sellMd(String name) {
synchronized(MAINB) {
if(MainbN <= 0) {
System.out.println("没有主板了，等等，马上送来!!!!!!!!!!");
try {MAINB.wait();} catch (Exception e) {}
}
System.out.println(name + " : 买走一块主板。");
MainbN--;
MAINB.notify();//----------------------------------唤醒厂商
}
}


public static void main(String[] args) {
ComputerCenter MyCC = new ComputerCenter();
new customer(MyCC,"Jack").start();
new customer(MyCC,"Tom").start();
new Md_retailer(MyCC).start();
new Vd_retailer(MyCC).start();
}
}

class customer extends Thread {
private ComputerCenter cc;
private String name;
public customer(ComputerCenter cc,String name) {
this.cc = cc;
this.name = name;
}

public void run() {
while(true) {
//try {Thread.sleep(10);} catch (Exception e) {}
//顾客不断购买显卡和主板
cc.sellVd(name); cc.sellMd(name);
}
}
}
class Md_retailer extends Thread {
private ComputerCenter cc;
public Md_retailer(ComputerCenter cc) {
this.cc = cc;
}

public void run() {
while(true) {
try {Thread.sleep(10);} catch (Exception e) {}
cc.stockMd();
}
}
}
class Vd_retailer extends Thread {
private ComputerCenter cc;
public Vd_retailer(ComputerCenter cc) {
this.cc = cc;
}

public void run() {
while(true) {
try {Thread.sleep(10);} catch (Exception e) {}
cc.stockVd();
}
}
}


注释掉不同地方的 try {Thread.sleep(10);} catch (Exception e) {} 可以模拟不同的情况。
xmind (中级程序员) 2010-07-26
噢，对不起，我是没有考虑这个情况。
你说的那种方法应该能够实现，我等待后再判断的方法试了试，要使，你看看
Java代码
class ComputerCenter {
private static Object VIDEO = new Object();
private static Object MAINB = new Object();
private static Integer videoN = 10;
private static Integer MainbN = 10;

public void stockVd() {
synchronized(VIDEO) {
if(videoN >= 20) {
System.out.println("ComputerCenter: the VC storage is MAX");
try {VIDEO.wait();} catch (Exception e) {}
}
videoN++;
System.out.println("ComputerCenter: 厂商送来一块显卡。" + videoN);
VIDEO.notify();//----------------------------唤醒消费者消费
}
}

public void stockMd() {
synchronized(MAINB) {
if(MainbN >= 20) {
System.out.println("ComputerCenter: the MB storage is MAX");
try {MAINB.wait();} catch (Exception e) {}
}
MainbN++;
System.out.println("ComputerCenter: 厂商送来一块主板。"+MainbN);
MAINB.notify();//-----------------------------唤醒消费者消费
}
}

public void sellVd(String name) {
synchronized(VIDEO) {
if(videoN <= 0) {
System.out.println("没有显卡了，等等，马上送来!!!!!!!!!");
try {VIDEO.wait();} catch (Exception e) {}
}
if(videoN >0) {
System.out.println(name + " : 买走一块显卡。"+videoN);
videoN--;
}
VIDEO.notify();//----------------------------------唤醒厂商
}
}

public void sellMd(String name) {
synchronized(MAINB) {
if(MainbN <= 0) {
System.out.println("没有主板了，等等，马上送来!!!!!!!!!!");
try {MAINB.wait();} catch (Exception e) {}
}
if(MainbN >0) {
System.out.println(name + " : 买走一块主板。"+MainbN);
MainbN--;
}
MAINB.notify();//----------------------------------唤醒厂商
}
}

public static void main(String[] args) {
ComputerCenter MyCC = new ComputerCenter();
new customer(MyCC,"Jack").start();
new customer(MyCC,"Tom").start();
new Md_retailer(MyCC).start();
new Vd_retailer(MyCC).start();
}
}

class customer extends Thread {
private ComputerCenter cc;
private String name;
public customer(ComputerCenter cc,String name) {
this.cc = cc;
this.name = name;
}

public void run() {
while(true) {
//try {Thread.sleep(10);} catch (Exception e) {}
//顾客不断购买显卡和主板
cc.sellVd(name); cc.sellMd(name);
}
}
}
class Md_retailer extends Thread {
private ComputerCenter cc;
public Md_retailer(ComputerCenter cc) {
this.cc = cc;
}

public void run() {
while(true) {
try {Thread.sleep(10);} catch (Exception e) {}
cc.stockMd();
}
}
}
class Vd_retailer extends Thread {
private ComputerCenter cc;
public Vd_retailer(ComputerCenter cc) {
this.cc = cc;
}

public void run() {
while(true) {
try {Thread.sleep(10);} catch (Exception e) {}
cc.stockVd();
}
}
}
xmind (中级程序员) 2010-07-26
恩，是有点儿，这样你看行不行，也就是顾客在买的时候，如果没有等待，买完后也不通知。电脑城在进货满之后不等待（或者sleep也行，让出cpu，现实中像是卖一段时间在进货），没进一个货就通知一声，只通知一个顾客。
Java代码
class ComputerCenter {
private static Object VIDEO = new Object();
private static Object MAINB = new Object();
private static Integer videoN = 10;
private static Integer MainbN = 10;

public void stockVd() {
synchronized(VIDEO) {
if(videoN >= 20) {
System.out.println("ComputerCenter: the VC storage is MAX");
} else {
videoN++;
System.out.println("ComputerCenter: 厂商送来一块显卡。" + videoN);
VIDEO.notify();//----------------------------唤醒消费者消费
}
}
}

public void stockMd() {
synchronized(MAINB) {
if(MainbN >= 20) {
System.out.println("ComputerCenter: the MB storage is MAX");
} else {
MainbN++;
System.out.println("ComputerCenter: 厂商送来一块主板。"+MainbN);
MAINB.notify();//-----------------------------唤醒消费者消费
}
}
}

public void sellVd(String name) {
synchronized(VIDEO) {
if(videoN <= 0) {
System.out.println("没有显卡了，等等，马上送来!!!!!!!!!");
try {VIDEO.wait();} catch (Exception e) {}
}
System.out.println(name + " : 买走一块显卡。"+videoN);
videoN--;
}
}

public void sellMd(String name) {
synchronized(MAINB) {
if(MainbN <= 0) {
System.out.println("没有主板了，等等，马上送来!!!!!!!!!!");
try {MAINB.wait();} catch (Exception e) {}
}
System.out.println(name + " : 买走一块主板。"+MainbN);
MainbN--;
}
}

public static void main(String[] args) {
ComputerCenter MyCC = new ComputerCenter();
new customer(MyCC,"Jack").start();
new customer(MyCC,"Tom").start();
new Md_retailer(MyCC).start();
new Vd_retailer(MyCC).start();
}
}

class customer extends Thread {
private ComputerCenter cc;
private String name;
public customer(ComputerCenter cc,String name) {
this.cc = cc;
this.name = name;
}

public void run() {
while(true) {
//try {Thread.sleep(10);} catch (Exception e) {}
//顾客不断购买显卡和主板
cc.sellVd(name); cc.sellMd(name);
}
}
}
class Md_retailer extends Thread {
private ComputerCenter cc;
public Md_retailer(ComputerCenter cc) {
this.cc = cc;
}

public void run() {
while(true) {
try {Thread.sleep(10);} catch (Exception e) {}
cc.stockMd();
}
}
}
class Vd_retailer extends Thread {
private ComputerCenter cc;
public Vd_retailer(ComputerCenter cc) {
this.cc = cc;
}

public void run() {
while(true) {
try {Thread.sleep(10);} catch (Exception e) {}
cc.stockVd();
}
}
}
xmind (中级程序员) 2010-07-26
lz基本的问题就是，厂商和客户等的不是同一把锁，所以要分别对待。然后就简单了。不过我的StockManager看着也不怎么对劲儿。