我应该将 Thread and.join 还是 Callable 与 Future and.get 一起使用？

Question

I am writing a simple thread that simply run a process and reads the InputStream . While reading the input, if it finds a certain string it sets a boolean to true. Then when I need to check that boolean I usually do this:

thread.start();
//some other code
thread.join();
thread.getBoolean();

Or should I instead use Callable along with Future ? If so, the correct use would be like this?

Callable<Boolean> myTask = new Task();

ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<Boolean> future = executorService.submit(myTask);
//some other code
Boolean output = future.get();
System.out.println(output);

executorService.awaitTermination(3, TimeUnit.SECONDS);
executorService.shutdownNow();

Answer 1

In my opinion, it is much better to use interfaces for asynchronous events like this. It is clean, faster and reliable.
Instead of a bare thread class, we would implement a string processor class that has a listener interface, and a process method that would take the stream and as well as the string to look for within the stream. So the approximate implementatin would be as following:

StringProcessor.java

class StringProcessor {

    public interface StringProcessorListener {
        void onStringProcessingFinish(boolean found);
    }

    private ExecutorService executorService = Executors.newSingleThreadExecutor();
    private StringProcessorListener listener;

    public StringProcessor(StringProcessorListener listener) {
        this.listener = listener;
    }

    public void process(InputStream inputStream, String strToFind) {
        executorService.execute(()-> {
            // Do the processing here...
            while(inputStream.availlable() > 0) {
                // Processing... maybe some string building or something else...
                // Processing code goes here...
                // A string built check it out
                if(str.equals(strToFind)) {
                    // The string what we look for is found, notify the listener with true
                    listener.onStringProcessingFinish(true);
                    return;
                }
                // If reached here then the string not found, notify with false
                listener.onStringProcessingFinish(false);
            }
        });
    }
}

We would make use of this class from a superior class like following:

YourMainOrSuperiorClass.java

class YourMainOrSuperiorClass {

    public static void main(String[] args) {

        // Insantiate or get an input stream from where you wish...
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);

        // Search a string using the processor class
        new StringProcessor(new StringProcessorListener {
            @Override
            public void onStringProcessingFinish(boolean found) {
                if(found) {
                    // The string has been found, handle it
                }
                else {
                    // The String has not been found, handle it
                }
            }
        })
        .process(bufferedInputStream, "String to find");

        // Maybe some more stuff to process from here...
    }

}

As you can see, no need to block any thread using async interface patterns. When you invoke the StringProcessor.process() method, it will process the string within its internal thread without blocking the main thread, and you don't have to wait it to finish, on the contrary you can process more code meanwhile.
In the meantime, the StringProcessor will call the listener's onStringProcessingFinish() method as soon as the result is available and it will handled asynchronously from main thread while the main thread is taking care of something else.

Note that main thread should not return until the result is delivered in case of you need to update some UI elements or something else in the main thread. If this is the case you can manage it using a boolean flag, when main thread has been executed all of its stuff then enters to a busy waiting using that flag until the result is delivered. Once the result has delivered you can set that boolean flag accordingly then. It is like some kind of using the thread blocking method stuff.