关于java多线程的问题

Question

 每收到一个信息就要创建一个线程，放到指定的存储区域内，另外还用一个线程负责从存储区域内读数据并显示出来，这个如何出来啊？大侠们指点一下。

Answer 1

不知道你想干什么。你描述是一种典型的多线程模型，你所谓的存储区域其实就是一个队列（如LinkedList），一头往队列里放数据，另一头从队列里取数据然后处理，批次间进行阻塞。

Answer 2

你这个是典型的线程同步问题，有多个线程和一个临界资源，那就肯定要实现同步，也就是说在一个线和访问这个临界资源的时候另外的线程只能等待，或者说这是一个生产者和消费者的问题（操作系统里有P-V操作来实现同步和互斥，JAVA里也有同步的机制），几个线程当生产者，一个线程当消费者，你可以用同步的方法进行互斥写，一个写完了唤醒另外一个等待写的线程。具体你可参考JAVA核心技术卷二或在网上找一下。这方面的资料很多。

Answer 3

你的问题是一个数据仓库的问题，也叫生产者、消费者问题。生产者生产产品放入仓库中，消费者从仓库中取
数据。  生产者： public void run() {
//获取生产者锁
synchronized(product.getSLock()) {
//检查队列长度是否超过最大长度，如果是，则等待
while(product.size() >= product.getMaxPNum()) {
try {
product.getSLock().wait();
} catch (InterruptedException e) {
continue;
}
}
}

//生产产品，并存入产品仓库中
productObj = trans.transactForSupplier(neObj);
if(productObj == null) {
continue;
}

product.offer(productObj);

//通知消费者对象，可以进行消费了
synchronized(product.getCLock()) {
product.getCLock().notifyAll();
}

/*
 * 通知仓库没有商品可生产了, 设置关闭状态.
 */
product.setClose(true); }
   消费者：          public void run() {
Object productObj = null;

while(isRunning) {
//获取消费者锁
synchronized(product.getCLock()) {
//检查产品列队中是否有数据，如果没有，就等待
while(product.size() <= 0) {
try {
product.getCLock().wait();
} catch (InterruptedException e) {
continue;
}
}

//从产品仓库中获取产品，并对产品做处理
productObj = product.peek();
trans.transactForConsumer(productObj);
}

//通知生产者进行生产
synchronized(product.getSLock()) {
product.getSLock().notifyAll();
}
}

if(product.getClose()) {
isRunning = false;
}
}
仓库类：
       public class ProductStorage {

/**
 * 构造函数
 */
    public ProductStorage() {
    }    /**
     * 获取消费者锁
     * @return
     */
    public byte[] getCLock() {
        return cLock;
    }    /**
     * 获取生产者锁
     * @return
     */
    public byte[] getSLock() {
        return sLock;
    }    /**
     * 获取列队的最大长度
     * @return
     */
    public int getMaxPNum() {
        return maxPNum;
    }    /**
     * 设置列队最大长度
     * @param maxPNum
     */
    public void setMaxPNum(int maxPNum) {
        this.maxPNum = maxPNum;
    }    public List getProduceList() {
        return produceList;
    }    /**
     * 获取队列的长度
     * @return
     */
public int size() {
synchronized(produceList) {
return produceList.size();
}
} /**
 * 获取队列中第一个对象，并从队列中清除该对象
 * @return
 */
public Object peek() {
     synchronized (produceList) {
         if (this.produceList.isEmpty())
         return null;
        
         return this.produceList.remove(0);
}
} /**
 * 往队列中写入一个对象
 * @param o
 * @return
 */
public boolean offer(Object o) {
     synchronized (produceList) {
         return this.produceList.add(o);
}
}

/**
 * 设置关闭标志
 * @param flag
 */
public void setClose(boolean flag) {
this.close = flag;
}

/**
 * 获取关闭标志
 * @return
 */
public boolean getClose() {
return this.close;
}

/**
 * 关闭标志, 各个生产者和消费者线程发现该标志为"true"时, 各自都将退出线程.
 */
private boolean close = false;    /**
     * cLock 消费锁，每个消费者只有获取该锁才能进入消费流程
     */
    private byte [] cLock = new byte[0];
    
    /**
     * pLock 生产锁，每个生产者只有获取该锁才能进入生产流程
     */
    private byte [] sLock = new byte[0];
    
    /**
     * produceList 产品存放的队列
     */
    private List produceList = new LinkedList();
    
    /**
     * maxPNum  产品能存放的最大数量
     */
    private int maxPNum = 50;
}