中断线程中的BlockingQueue

Question

I'm writing a program that has 3 threads. One reads a text file and inputs the words into a ArraylistBlockingQueue of size 2. The next one takes that list and reverses every other word inside of it. The last thread takes the words and writes them to a new text file.

I have everything working except I cannot figure out how to interrupt and stop my threads. The program writes the text file but never ends.

Main method

 JFileChooser chooser = new JFileChooser();
    File selectedFile = null;
    File outFile = new File("output.txt");

    int returnValue = chooser.showOpenDialog(null);
    if (returnValue == JFileChooser.APPROVE_OPTION) {
        selectedFile = chooser.getSelectedFile();

    }




    BlockingQueue text = new ArrayBlockingQueue(2);
    BlockingQueue out = new ArrayBlockingQueue(2);

    Thread input = new Thread(new inputClass(selectedFile, text));
    Thread reverse = new Thread(new reverseClass(text, out));
    Thread output = new Thread(new outputClass(out, outFile));


    chooser.setSelectedFile(outFile);
    if (chooser.showSaveDialog(chooser) == JFileChooser.APPROVE_OPTION) {

        input.start();
        reverse.start();
        output.start();


    }

Input

@Override
public void run() {

    try {
        Scanner s = new Scanner(f);

        while (isRunning) {

            try {
                if(s.hasNext()){
                text.put(s.next());
                } else {
               text.put(END);
            }
            } catch (InterruptedException ex) {

                Logger.getLogger(inputClass.class.getName()).log(Level.SEVERE, null, ex);
            } 

        }

    } catch (FileNotFoundException ex) {
        Logger.getLogger(inputClass.class.getName()).log(Level.SEVERE, null, ex);
    }

Reverse Class @Override public void run() {

    String original;
    String temp = "";
    String character = "";
    int count = 1; // keeps track of whether or not a word should be reversed

    while (isRunning) {

        try {

            original = text.take();
            if(original.equalsIgnoreCase(END)){
                Thread.currentThread().interrupt();
            }
            int length = original.length() - 1;
            //if count is even then the word should be reversed.
            if ((count % 2) == 0) {
                // reverses the original string if a ? or . appears
                if (original.contains("?") || original.contains(".")) {
                    character = original.charAt(length) + "";
                    for (int i = (length - 1); i >= 0; i--) {
                        temp = temp + original.charAt(i);

                    }
                    out.put(temp + character);
                    temp = "";
                    character = "";
                    // reverses the orgininal string if no ? or . appears
                } else {

                    for (int i = length; i >= 0; i--) {
                        temp = temp + original.charAt(i);

                    }
                    out.put(temp);
                    temp = "";
                }
                count++;
            } else {
                out.put(original);
                count++;
            }


        } catch (InterruptedException ex) {

            Logger.getLogger(reverseClass.class.getName()).log(Level.SEVERE, null, ex);

        }
    }
    try {
        out.put(END);
    } catch (InterruptedException ex) {
        Logger.getLogger(reverseClass.class.getName()).log(Level.SEVERE, null, ex);
    }

}

Output Code @Override public void run() {

    while (isRunning) {

        String s = null;
        try {
            s = out.take();
        } catch (InterruptedException ex) {
            Logger.getLogger(outputClass.class.getName()).log(Level.SEVERE, null, ex);
        }

        try {

            BufferedWriter writer = new BufferedWriter(new FileWriter(file, true));

            try {
                if (s.equalsIgnoreCase(END)) {
                    Thread.currentThread().interrupt();
                }
                writer.write(s + " ");


            }  finally {
                writer.flush();
            }

        } catch (IOException ex) {
            Logger.getLogger(outputClass.class.getName()).log(Level.SEVERE, null, ex);

        }
    }

Answer 1

From the Javadoc:

A BlockingQueue does not intrinsically support any kind of "close" or "shutdown" operation to indicate that no more items will be added. The needs and usage of such features tend to be implementation-dependent. For example, a common tactic is for producers to insert special end-of-stream or poison objects, that are interpreted accordingly when taken by consumers.

I suggest queuing the value null to indicate that the stream is over; the reader will need to check whether the value read is null and terminate if it is.

Answer 2

Since you are reading one word at a time, you can send a flag through the blocking queue. Sending the string literal "This queue is terminated" would be sufficient. Since you are reading only one word at a time, there is no way this string can be tested in your word reverse program.

Once this is received you can interrupt the word reverser. Then send the same literal to the writer. Once the writer receives the flag you can shut down the writer as well.

AKA "Poison Pill" as stated from Sotirios.

Example from reverser class:

/**
 * Called when being executed. Reverses a word by taking from intake and
 * places the reversed word into store
 */
@Override
public void run() {
    boolean isInterrupted = false;
    while (!isInterrupted) {
        try {
            StringBuilder str = new StringBuilder(intake.take());

            //Exit condition
            if (str.toString().equalsIgnoreCase(END_FLAG)) {
                Thread.currentThread().interrupt();
            }

            //If it is a word to be reversed, then reverse it
            if (oddWord % 2 == 1) {
                str = reverseWord(str);
            }

            //Put word in queue and increment counter
            store.put(str);
            ++oddWord;
        } catch (InterruptedException ex) {
            isInterrupted = true;
        }
    }

    //Puts pill into queue when main body is done
    try {
        store.put(END_FLAG);
    } catch (InterruptedException ex) {
        System.err.printf("Error setting flag in store.%nWordReverser%n%s%n", ex);
    }
}

My run() method from the Writer Class:

    /**
     * Executes when being called in a thread
     */
    @Override
    public void run() {
        boolean isInterrupted = false;

        try (BufferedWriter writer = new BufferedWriter(new FileWriter(output))) {

            //Continue writing until the thread is interrupted
            while (!isInterrupted) {
                CharSequence word = in.take();

                if (word.toString().equalsIgnoreCase(END_FLAG)) {
                    isInterrupted = true;
                } else {
                    writer.write(word + " ");
                }
            }
        } catch (InterruptedException | IOException ex) {
            System.err.printf("Error writing to output file!%n%s%n", ex);
        }
    }
}

Answer 3

You're code is already halfway there ...

For the threads that block in the take() method, you need to:

1. Set the isRunning flag to false .
2. Call Thread.interrupt() on the thread object.

And you could avoid exposing the isRunning flag by setting it to false in the handlers for the InterruptedException .

For the thread that is blocking while reading from the Scanner , a Thread.interrupt() should result in a InterruptedIOException . If not, then calling close() on the stream that the Scanner is using should be sufficient. It requires a little bit of reorganization; ie constructing the Scanner with a Reader or InputStream instead of a File object.