java - 将打开的资源传递给线程是好习惯吗？

Question

我有一个类 MesssageReader，它在一个单独的线程中从流中读取消息。现在，当我第一次创建解决方案时，我在线程类之外创建了流对象，然后将其作为对 MessageReader 类的引用传递。我通过我的自定义界面传递它，因为在某些时候我想更改流阅读器类。如果读取器线程收到指示消息流结束的特殊消息，则它会正常结束。创建流的主线程关闭它。现在，我担心的是这是一个糟糕的设计？因为，如果我在阅读器线程之外创建一个流，其他人可能会关闭它，这可能会导致问题。但是，另一方面，我也在读者线程之外创建了套接字，这有意义吗？因为，您可以创建更多线程来读取来自同一连接的消息。在读取器线程外部或内部创建所需的流，并让线程处理流的打开和关闭是否更好(但仍然具有创建不同流选项/对象的灵 active )？这是我的示例类:

public class MessageReader implements Runnable {
    private MessageInputReader reader;
    /* Custom interface for reading messages */
    public MessageReader(MessageInputReader reader) {
        this.reader = reader;
    }

    public void run() {
        String line = null;
        try {
            while ((line = reader.readMessage()) != null) {
                if ("BYE".equals(line)) {
                    break;
                }
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}
public class ReaderExample {

    public static void main(String[] args) {
        Socket clientSocket = null;
        MessageBufferStream bufferedStream = null;
        MessageReader reader;
        try {
            clientSocket = new Socket("hostname", 4060);
            bufferedStream = new MessageBufferStream(clientSocket);
            reader = new MessageReader(bufferedStream);
            (new Thread(reader)).start();
            someBlockingMethodWhichDoesOtherWork();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedStream != null)
                    bufferedStream.closeStream();
                if (clientSocket != null)
                    clientSocket.close();
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

这是第二个选项:

public class MessageReader implements Runnable {
    private MessageBufferStream reader;

    public MessageReader(Socket clientSocket) throws IOException {
    /* I could probably create a factory method here which would
     * return different stream objects and achieve the same flexibility as in the first example? */
        this.reader = new MessageBufferStream(clientSocket);
    }

    public void run() {
        String line = null;
        try {
            while ((line = reader.readMessage()) != null) {
                if ("BYE".equals(line)) {
                    break;
                }
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        } finally {
            try {
                if (reader != null)
                    reader.closeStream();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

下面是剩余的代码:

public interface MessageInputStream {
    public String readMessage() throws IOException;
    public void closeStream() throws IOException;
}

public class MessageBufferStream implements MessageInputStream {
    private BufferedReader reader;

    public MessageBufferStream(Socket clientSocket) throws IOException {
        this.reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
    }

    @Override
    public String readMessage() throws IOException {
        return reader.readLine();
    }

    @Override
    public void closeStream() throws IOException {
        reader.close();
    }
}

Answer 1

这没有好坏之分。这与其说是实践问题，不如说是生命周期管理。如果您注意控制传递给线程的资源的管理，并确保它在使用前处于打开状态，并且在仍然需要时从不关闭，那么您就可以了。

文档 是这里的最佳实践。明确预期的内容和必须发生的内容，这样当您或其他人稍后查看时，您就不会遇到麻烦。在打开和关闭资源的位置进行解释。在您的线程代码或任何地方，记录前后条件以及对资源生命周期所做的任何假设。等等

现在这当然假设了关于所述资源的一些事情。特别是，它要么是线程安全的，要么你注意不要通过其他方式(实际同步或简单的设计不变量)同时从多个线程访问它，并且所述资源可以用于不同的thread 而不是构建它的线程(为此你必须查阅它的文档或源代码。例如，如果资源在构造时分配和初始化线程本地存储，你可能别无选择，只能在线程本身上打开它。