Question

我正在尝试编写多线程代码。但严重的是我无法理解我从哪里开始。我的头也在敲打。请帮帮我。

我的任务是，

有一个长度为1的队列，称为pending_tasks，其中包含需要进行处理的任务。
还有另一个长度为1的队列，称为completed_tasks，其中包含完成处理并准备交付的任务。

我的实施思路，

首先制作两个阻止队列，pending_tasks和completed_tasks。
一个线程（生产者）总是在侦听来自外部的任务，如果被放入pending_tasks。
一个线程（消费者）随时准备从pending_tasks接受任务并开始处理，之后进入completed_tasks。
然后再来pending_tasks，每当任何任务到来时，都要开始相同的处理。
基本上，它是单一的生产者 - 单一消费者问题。

我的困惑，

我知道它可以是使用ArrayBlockingQueue和Mutex的代码。但我不明白我怎么能开始这个。我对互斥体有很好的理解，我从这个link读到了互斥体，并且在我阅读了很多关于这个网站的问题的同时也对blockingQueue有了很好的理解。

您能否给我一些实施指南，以便我可以编写这个多线程代码。

我已经为此编写了一些代码，但这并没有实现我的任务的最终目标。

提前致谢。寻找你的回复。

编辑没有。 1

请参阅下面的代码。此代码工作正常，但此代码缺少一个功能。请帮我补充一下，给出一些指导。

功能是，

当生产者线程在pending_task队列中放入一些值时，它会等待一段时间。如果在那个时候消费者把结果给消费者，那就OK了。否则，它会显示超时，并且生产者在pending_task队列中获取另一个值并输出相同的进程，并开始相同的进程。

请帮助我添加上述功能。我认为我们必须在生产者线程和消费者线程之间进行通信，并且线程通信是通过使用Mutex完成的（我认为）。请帮我实现相同的

我的代码，

MultiThread类

package multithread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class MultiThread {

    public static BlockingQueue<Integer> pending_task;
    public static BlockingQueue<Integer> completed_task;

    public MultiThread(int length) {
        pending_task = new ArrayBlockingQueue<Integer>(length, true);
        completed_task = new ArrayBlockingQueue<Integer>(length, true);
    }
}

制作人类

package multithread;

import java.util.logging.Level;
import java.util.logging.Logger;

public class Producer implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("PRODUCER: Try to put value  " + i + "  in the pending queue");
                MultiThread.pending_task.put(i);
                System.out.println("PRODUCER: Successfully put value  " + i + "  in the pending queue, now its turn to consumer");
            } catch (InterruptedException ex) {
                Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

消费者类

package multithread;

import java.util.logging.Level;
import java.util.logging.Logger;

public class Consumer implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("CONSUMER: Try to take value from the pending queue");
                int val = MultiThread.pending_task.take();
                System.out.println("CONSUMER:  Successfully take value, and that is   " + val);
                System.out.println("CONSUMER: Processing starts");
                Thread.sleep(1000);
                System.out.println("CONSUMER: Processing ends");
                System.out.println("CONSUMER: Try to put that  that value in  completed queue, and the value is   " + val);
                MultiThread.completed_task.put(val);
                System.out.println("CONSUMER: Successfully put into completed queue");

                //Serve this value to the corresponding user
            } catch (InterruptedException ex) {
                Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
    }
}

DeliveryBoy类

package multithread;

import java.util.logging.Level;
import java.util.logging.Logger;

public class DeliveryBoy implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                System.out.println("DELIVERYBOY: Waiting for the value near completed queue");
                int val = MultiThread.completed_task.take();
                System.out.println("DELIVERYBOY:  Succesfully take value from completed queue and the vlue is  " + val);
                //Serve this value to the corresponding user
            } catch (InterruptedException ex) {
                Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
    }
}

测试类

package multithread;

public class Test {

    public static void main(String[] args) {
        // TODO code application logic here
        MultiThread ml = new MultiThread(1);
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
        new Thread(new DeliveryBoy()).start();
    }
}

Answer 1

来自ArrayBlockingQueue#put

public void put（E e）            抛出InterruptedException

将指定的元素插入此队列的尾部，等待   **如果队列已满，则空间可用

来自ArrayBlockingQueue#take

public E take（）          抛出InterruptedException

从界面复制的描述：BlockingQueue检索并删除   这个队列的头部，必要时等待，直到一个元素成为   可用

所以你需要做的就是从你的线程中调用这些方法试试这个（研究javadoc），当你遇到更具体的问题时，你可以再问一次。

怀疑使用ArrayBlockingQueue和mutex的多线程代码

1 个答案: