Java Multithread立即停止所有其他线程

Question

I have this code:

public class BruteForceThread implements Callable<String> {

private static volatile boolean stopped = false;        

public String call() {

    String password = this.getNextPassword();

    while (!stopped) {

        System.out.println(numberOfThreat + ": " + password);

        synchronized(this) {
            try {
                if (this.testPassword(password)) {
                    stopped = true;
                    return password;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        password = this.getNextPassword();

    }
    return "";

}
}

Main class:

public static void main(String[] args) throws IOException {

int numberOfThreads = 2;
ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);
CompletionService<String> pool = new ExecutorCompletionService<String>(executor);
for (int i = 1; i < numberOfThreads + 1; i++) {
  Callable<String> bruteForce = new BruteForceThread(...);
  pool.submit(bruteForce);
}

executor.shutdown();

    for(int i = 0; i < numberOfThreads; i++){
        try {
            String result = pool.take().get();
            if (result != "") {
                System.out.println("Your password: " + result);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

executor = null;
}

Output: ...

1: aa <- here first thread found a password
2: Fa <- second thread is continue
2: Fb
2: Fc
... many more ...
2: IZ
Your password: aa

If one thread find a password and sets stopped to true, another threads does not stop immediately. Why?

Answer 1

There will be threads waiting to write to the console. This means some or all the threads could be between when you check for stopped and when you output to the screen.

BTW Unless you are hacking a web site with a high latency you might find that cracking a password is done with only as many threads as you have CPUs. More threads could add overhead and slow it down.