即使在java中出现异常之后，线程的执行也会继续。

Question

我在下面的代码中有我的线程的骨架。我使用了一个简单的倒计时锁存器。我陷入了线程1依赖于线程2才能完成的情况。如果没有异常，代码将正常运行。但例外的可能性更大。如果在线程2或任何线程中发生异常，我希望所有线程都停止执行。我的独立线程即使在异常之后也会继续执行。我还在线程1中使用了一个标志来检查线程2中是否发生了异常。我特意将除以零异常作为测试异常的示例。我无法找到解决这个问题的方法。请帮帮我！

import java.util.concurrent.CountDownLatch;

    public class MainThread extends Thread{
        static boolean flag=false;
        final static CountDownLatch latch1= new CountDownLatch(1);
        final static CountDownLatch latch2= new CountDownLatch(1);
        final static CountDownLatch latch3= new CountDownLatch(3);
        static MainThread t1;
        static MainThread t2;
        static MainThread t3;
        static MainThread t4;
        static MainThread t5;

        public static void main(String args[]){


             t1 = new MainThread(){
                public void run(){


                    System.out.println("Waiting for Thread 2");
                    try {
                        System.out.println("THis iss before the thread 2 starts its for loop.");
                        latch2.countDown();
                        t3.start();
                        t4.start();
                        t5.start();
                        System.out.println("waiting for thread 2 to countdown");
                        latch1.await();
                        if(flag==true){
                            System.out.println("successful.");
                        }
                        else{
                            System.out.println("error.");

                        }
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("All the dependencies resolved.");
                    System.out.println("Waiting for the remaining threads to complete their work.");
                    try {
                        latch3.await();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("All the threads have finished doing their work. Exiting now...");
                }
            };
            Thread t2 = new MainThread(){
                public void run(){
                    System.out.println("Before Starting for loop");
                    try {

                        System.out.println("waiting for thread 1 to countdown latch2");
                        latch2.await();
                        System.out.println("Starting for loop");
                        for(int i=0;i<5;i++){
                            System.out.println("iteration: "+i);
                            try {
                                Thread.sleep(5);
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                        int x=1/0;
                        latch1.countDown();
                        System.out.println("countdown by thread2 for latch 1 done.");

                        flag=true;
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();

                    }
                    finally{
                        latch1.countDown();

                    }
                }
            };
            t3 = new MainThread(){
                public void run(){
                    System.out.println("Running Thread 3");
                    for(int i=0;i<10;i++){
                        System.out.println("iteration: "+i+ " "+t3.getName());
                        try {
                            Thread.sleep(5);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    latch3.countDown();

                }
            };

            t4 = new MainThread(){
                public void run(){
                    System.out.println("Running Thread 4");
                    for(int i=0;i<10;i++){
                        System.out.println("iteration: "+i+ " "+t4.getName());
                        try {
                            Thread.sleep(5);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }

                    latch3.countDown();
                }
            };

            t5 = new MainThread(){
                public void run(){
                    System.out.println("Running Thread 5");
                    for(int i=0;i<10;i++){
                        System.out.println("iteration: "+i+ " "+t5.getName());
                        try {
                            Thread.sleep(5);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }

                    latch3.countDown();
                }
            };
            t1.start();
            t2.start();


        }





    }

我的输出是：

Before Starting for loop
waiting for thread 1 to countdown latch2
Waiting for Thread 2
THis iss before the thread 2 starts its for loop.
Starting for loop
iteration: 0
waiting for thread 2 to countdown
Running Thread 3
iteration: 0 Thread-2
Running Thread 5
iteration: 0 Thread-4
Running Thread 4
iteration: 0 Thread-3
iteration: 1
iteration: 1 Thread-3
iteration: 1 Thread-2
iteration: 1 Thread-4
iteration: 2
iteration: 2 Thread-3
iteration: 2 Thread-2
iteration: 2 Thread-4
iteration: 3
iteration: 3 Thread-3
iteration: 3 Thread-2
iteration: 3 Thread-4
iteration: 4
iteration: 4 Thread-3
iteration: 4 Thread-4
iteration: 4 Thread-2
iteration: 5 Thread-3
error.
All the dependencies resolved.
Waiting for the remaining threads to complete their work.
Exception in thread "Thread-1" java.lang.ArithmeticException: / by zero
    at ThreadProjectStructure.MainThread$2.run(MainThread.java:72)
iteration: 5 Thread-4
iteration: 5 Thread-2
iteration: 6 Thread-3
iteration: 6 Thread-4
iteration: 6 Thread-2
iteration: 7 Thread-3
iteration: 7 Thread-2
iteration: 7 Thread-4
iteration: 8 Thread-3
iteration: 8 Thread-2
iteration: 8 Thread-4
iteration: 9 Thread-3
iteration: 9 Thread-4
iteration: 9 Thread-2
All the threads have finished doing their work. Exiting now...

Answer 1

你有没有想过使用线程池？如果您可以修改您的要求以使用线程池，在出现异常的情况下，您可以强制关闭线程池，因此所有线程都将停止。

Answer 2

那么，使用当前的代码，您需要获得正确的视角。请定义闩锁变量，不言自明，否则会让你陷入混乱。假设以下是您的要求:仅当Thread 2成功执行时才继续执行其他线程。

以下是更新后的代码：

import java.util.concurrent.CountDownLatch;

public class MainThread extends Thread{
    static boolean flag=false;
    final static CountDownLatch waitForThread2ToFinish= new CountDownLatch(1);
    final static CountDownLatch waitForStartSignalFromThread1= new CountDownLatch(1);
    final static CountDownLatch latchForAllOtherThreads= new CountDownLatch(3);
    static MainThread t1;
    static MainThread t2;
    static MainThread t3;
    static MainThread t4;
    static MainThread t5;

    public static void main(String args[]){
        t1 = new MainThread(){
            public void run(){
                try {
                    System.out.println("Waiting for Thread 2 to finish");
                    waitForStartSignalFromThread1.countDown();
                    waitForThread2ToFinish.await();
                    if(flag==true){
                        System.out.println("Successful.");
                        t3.start();
                        t4.start();
                        t5.start();

                        System.out.println("All the dependencies resolved.");
                        System.out.println("Waiting for the remaining threads to complete their work.");
                        try {
                            latchForAllOtherThreads.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("All the threads have finished doing their work. Exiting now...");
                    }
                    else{
                        System.out.println("Error.");

                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        Thread t2 = new MainThread(){
            public void run(){
                System.out.println("Before Starting for loop");
                try {

                    System.out.println("waiting for thread 1 to countdown latch2");
                    waitForStartSignalFromThread1.await();
                    System.out.println("Starting for loop");
                    for(int i=0;i<5;i++){
                        System.out.println("iteration: "+i);
                        try {
                            Thread.sleep(5);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int x=1/0;

                    System.out.println("countdown by thread2 for latch 1 done.");

                    flag=true;
                } catch (Exception e) {
                    e.printStackTrace();

                }
                finally{
                    waitForThread2ToFinish.countDown();
                }
            }
        };
        t3 = new MainThread(){
            public void run(){
                System.out.println("Running Thread 3");
                for(int i=0;i<10;i++){
                    System.out.println("iteration: "+i+ " "+t3.getName());
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                latchForAllOtherThreads.countDown();

            }
        };

        t4 = new MainThread(){
            public void run(){
                System.out.println("Running Thread 4");
                for(int i=0;i<10;i++){
                    System.out.println("iteration: "+i+ " "+t4.getName());
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                latchForAllOtherThreads.countDown();
            }
        };

        t5 = new MainThread(){
            public void run(){
                System.out.println("Running Thread 5");
                for(int i=0;i<10;i++){
                    System.out.println("iteration: "+i+ " "+t5.getName());
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                latchForAllOtherThreads.countDown();
            }
        };
        t1.start();
        t2.start();
    }
}

Answer 3

Java没有提供任何直接的方法来停止正在运行的线程的执行，但它提供了中断线程的方法。仍然不能保证停止线程的执行，它只是将该线程的中断标志设置为真，它依赖于线程来检查标志并抛出中断异常。这是停止线程执行的唯一优雅的方式。您可以通过调用handle.interrupt()来中断另一个线程