java - 即使在 java 中出现异常后，线程仍会继续执行

Question

下面的代码中有我的线程的框架。我使用了一个简单的倒计时锁存器。我陷入了线程 1 依赖于线程 2 来完成的情况。如果没有异常，则代码运行正常。但异常(exception)的可能性更大。如果线程 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

你有没有想过使用线程池？如果您可以修改使用线程池的要求，那么在出现异常时您可以强制关闭池，从而停止所有线程。