Question

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

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

这不是好事或坏事。这不是一个实践问题，而是生命周期管理。如果你注意控制传递给一个线程的资源的管理，并确保它在使用之前是打开的，并且在它仍然需要时从不关闭，那么你没事。

文档是最佳实践。明确预期会发生什么以及发生什么事情，以便当您或其他人稍后再看时，您不会遇到麻烦。在打开和关闭资源的地方，请解释一下。在您的线程代码或任何地方，记录前后条件以及有关资源生命周期的任何假设。等等。

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

Answer 2

现在，当我第一次创建解决方案时，我已经在线程类之外创建了流对象，然后将其作为对MessageReader类的引用传递。 ......我担心这是一个糟糕的设计？

可能。你当然需要在线程之外创建Socket，但我认为在该套接字上启动流可能在线程内部做得更好。主线程可以保留对Socket的引用（见下文），但是分叉线程处理套接字上的流的打开，并且还负责在消息完成时关闭流。

因为，如果我在读者线程之外创建一个流，其他人可能会关闭它，这可能会导致问题。

您当然可以编写主线程代码，以便在出现问题时忘记流对象。主线程可能想要了解Socket周围有时候是个好主意的知识。如果你想停止对套接字的处理，因为某些超时已经过期或者应用程序正在关闭，那么主线程可以关闭套接字，这会导致IO方法抛出IOException，让你的线程有机会干净地关闭。这是一个很好用的模式。

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

2 个答案: