线程多线程

Question

问题如下：

三个线程同时启动，如下所示：

t1.start();
t2.start();
t3.start();

第一个线程(T1)的输出应该是第二个线程(t2)的输入，第二个线程(T2)的输出应该是第三个线程(T3)的输入。

你能告诉我其中的逻辑吗？

我知道我们可以使用对象的等待和通知方法。但是，我能得到实现此输出的算法或逻辑吗？

Answer 1

这是一个为你准备的助手类。它在一个单例帮助器类中实现了两个资源锁。

让每个线程使用ResourceLock.getInstance()获取实例。让线程2调用getResource1()并等待线程1完成，并将其输出放入setResource1()中。这将释放锁，并返回线程2对getResource1()的调用。

对线程2和3重复上述步骤

在没有超时的情况下调用挂起函数并不是一个好主意。因此会有10秒的超时，可根据需要进行编辑。

package com.madinsweden.test;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;


public class ResourceLock {

    protected static final int TIMEOUT = 10000; //ms

    private CountDownLatch mLock1;
    private CountDownLatch mLock2;

    private Object mObject1;
    private Object mObject2;

    private static ResourceLock mInstance;

    private ResourceLock() {
        mLock1 =  new CountDownLatch(1);
        mLock2 =  new CountDownLatch(1);
    }

    public static ResourceLock getInstance() {
        if (null == mInstance) {
            mInstance = new ResourceLock();
        }
        return mInstance;
    }


    public void setObject1(Object o) {
        mObject1 = o;
        mLock1.countDown();
    }

    public Object getResource1() {
        try {
            mLock1.await(TIMEOUT, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            throw new RuntimeException("Timeout of resource lock 1");
        }
        return mObject1;
    }


    public void setObject2(Object o) {
        mObject2 = o;
        mLock2.countDown();
    }

    public Object getResource2() {
        try {
            mLock2.await(TIMEOUT, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            throw new RuntimeException("Timeout of resource lock 2");
        }
        return mObject2;
    }
}

Answer 2

我建议您使用ExecutorServices。这意味着更容易在线程之间传递工作。

// fields
ExecutorServices service1 = ...
ExecutorServices service2 = ...
ExecutorServices service3 = ...


// Task1 submits to service2
service1.submit(new Task1());

// service2 submits to service3

Answer 3

有几种方法可以做到这一点。正如Jon所指出的，以这种方式运行线程是没有意义的，因为您会导致它们在其他线程的输出上被阻塞，实际上无法实现并行化。

我的“首选”解决方案是使用ExecutorService，就像Peter提到的那样，尽管有点不同。这里有一种天真的方法。

    ExecutorService executor = Executors.newSingleThreadExecutor();

    final Future<String> output1 = executor.submit(new Callable<String>() {
       @Override public String call() {
           // do Something
           return "a String from Task #1";

       } 
    });



    final Future<String> output2 = executor.submit(new Callable<String>() {
        @Override public String call() throws Exception{
           // do Something
           // Wait for the output of the above task using `Future.get()`.
           return output1.get() + ", a String from Task #2";

       }

    });

    Future<String> output3 = executor.submit(new Callable<String>() {
        @Override public String call() throws Exception{
           // do Something
           return output2.get() + ", a String from Task #3";

       }

    });

    System.err.print("Output from 3rd task: " + output3.get());

使用线程的其他方法:共享阻塞数据结构(例如，在线程之间使用BlockingQueue来安全地发布结果。如果没有传递任何结果，并且只需要向其他线程发出终止信号，则可以使用CountDownLatches。