1

我有一个应用程序并行执行两个线程，每个线程都执行一些操作，最终生成一个整数。在我的主线程中，我想对每个线程 A 和线程 B 产生的 int 执行一些操作（分别称为 int a 和 int b），然后按照每个线程吐出它们的顺序输出它们。所以本质上，我定期运行每个线程（比如每 2 秒），每个线程都吐出一个整数，我按照它们的创建顺序操作和打印出来。

为了做到这一点，我如何将需要由 gui 线程打印的每个线程的整数聚合在一起？我可以为主线程观察到的每个线程使用一个队列，当它更新时，主 gui 操作并输出它们？我怎么能写这样一个队列？

我的线程的代码如下：

Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {
    @Override
    public void run() {
        new Thread(new t1()).start(//TODO: pass in some parameter that this
                                   //thread will write to); 
        new Thread(new t2()).start();
    }
}, 0, period);
4

3 回答 3

1

考虑这个解决方案，您可能会发现它很有用。它ConcurrentLinkedQueue用于队列上的线程安全操作。

final Queue<Integer> queue1 = new ConcurrentLinkedQueue<Integer>();
final Queue<Integer> queue2 = new ConcurrentLinkedQueue<Integer>();

final Random r = new Random();

Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {             
    @Override
    public void run() {
        //Thread 1
        new Thread(new Runnable() {
            @Override
            public void run() {
                //even numbers
                queue1.add(r.nextInt(50)*2);
            }
        }).start();

        //Thread 2
        new Thread(new Runnable() {
            @Override
            public void run() {
                //odd numbers
                queue2.add(r.nextInt(50)*2 + 1);
            }
        }).start();
    }
}, 0, 2000);

//Main thread (maybe GUI)
while (true){
    while (!queue1.isEmpty()){
        System.out.println("Thread-1: " + queue1.poll());
    }
    while (!queue2.isEmpty()){
        System.out.println("Thread-2: " + queue2.poll());
    }
}

编辑

您真正需要的是生产者-消费者（参见http://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem）。为了解决这个问题，我们将使用另一个队列ArrayBlockingQueue，因为这种数据结构让我们阻塞直到产生（或消费）某些东西。

final BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<Integer>(1024);
final BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<Integer>(1024);

final Random r = new Random();          

Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {
    @Override
    public void run() {
        try {
            //don't create threads here, this is already a thread, just produce the numbers
            //If the queue is full `BlockingQueue.put()` will block until the consumer consume numbers.

            //Producer even number
            queue1.put(r.nextInt(50)*2);

            //Producer odd number
            queue2.put(r.nextInt(50)*2 + 1);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}, 0, 2000);

//Now we create the threads that will take numbers from the producer. Don't worry about the `while (true)`, it is not wasting resources because `BlockingQueue.take()` will block the thread until something is produced.

//Consumer 1
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            while (true){
                System.out.println("Thread-1: " + queue1.take());

                //Or update some UI component
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();

//Consumer 2
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            while (true){
                System.out.println("Thread-2: " + queue2.take());

                //Or update some UI component
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();
于 2013-10-02T05:19:17.367 回答
1

尝试使用使用Callables而不是 Runnables 的Executor框架。使用 Callable 的一个优点是它提供了一种类似于 Runnable方法的方法，但方法可以是一个值。因此，在您的情况下，您可以从两个线程返回整数值，然后可以在主线程中使用它们。callruncallreturn

于 2013-10-02T04:52:54.547 回答
0

将队列传递给两个线程的构造函数。

覆盖你传递的队列的offer/add方法，并在此处添加你调用gui主线程的逻辑，基本上在调用基类调用后调用监听器。

于 2013-10-02T04:58:36.653 回答