精华内容
下载资源
问答
  • 多线程中一个线程抛出异常(不捕获);主线程及其他子线程如何表现 结论: 语言 主线程 子线程 C++ 挂死 挂死 Java 继续运行 继续运行 C++ code #include <iostream> #...

    进程与多线程

    多线程中一个线程抛出异常(不捕获);主线程及其他子线程如何表现

    • 结论
    语言 主线程 子线程
    C++ 挂死 挂死
    Java 继续运行 继续运行
    • 原因
      java:存在用户线程(User Thread)和守护线程(Daemon Thread),当所有用户线程都退出了,守护线程退出,进而应用程序退出;这就是为什么"main线程"退出后,其他线程还正在运行。也是其他"子线程"被异常终止了或者退出了,其他线程正常运行。

      c++:main属于主进程,当子线程抛出异常时,最后抛到主线程中,导致主进程crash,进而结束应用程序,相应的Thread被销毁(thread对象被销毁)。

    C++ code

    #include <iostream>
    #include <thread>
    #include <chrono>
    
    void thread1_func() {
        int i = 0;
        while(true) {
            std::this_thread::sleep_for (std::chrono::seconds(1));
            std::cout << "thread1 i: " << i++ << "\n";
            if (i == 3) {
                throw 1;
            }
        }
    }
    
    void thread2_func() {
        int i = 0;
        while(true) {
            std::this_thread::sleep_for (std::chrono::seconds(1));
            std::cout << "thread2 i: " << i++ << "\n";
        }
    }
    
    
    int main() {
        std::cout << "Main thread start:spawning 2 threads... \n";
        std::thread t1 (thread1_func);
        std::thread t2 (thread2_func);
    
        t1.join();
        t2.join();
    
        std::cout << "Main thread end\n";
        return 0;
    }
    
    

    运行结果:

    Main thread start:spawning 2 threads…
    thread1 i: thread2 i: 00
    thread1 i: 1
    thread2 i: 1
    thread1 i: 2
    thread2 i: 2
    terminate called after throwing an instance of ‘int’
    Aborted (core dumped)

    java代码:

    public class ThreadDemo {
    
    	public static void main(String[] args) {
    
    		System.out.println("Main Thread start");
    
    		// TODO Auto-generated method stub
    		Thread t1 = new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				int i = 0;
    				while(true) {
    					System.out.println("Thread1 i: "+(i++));
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    
    					if (i == 3) {
    						throw new RuntimeException();
    					}
    				}
    			}
    		});
    
    		Thread t2 = new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				int i = 0;
    				while(true) {
    					System.out.println("Thread2 i: "+(i++));
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    			}
    		});
    
    		t2.start();
    		t1.start();
    
    		try {
    			Thread.sleep(1000);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    		System.out.println("Main Thread end");
    
    	}
    
    }
    

    运行结果:

    Thread2 i: 1
    Main Thread end
    Thread1 i: 1
    Thread2 i: 2
    Thread1 i: 2
    Thread2 i: 3
    Exception in thread “Thread-0” java.lang.RuntimeException
    at ThreadDemo$1.run(ThreadDemo.java:26)
    at java.lang.Thread.run(Unknown Source)
    Thread2 i: 4
    Thread2 i: 5
    Thread2 i: 6
    Thread2 i: 7
    Thread2 i: 8
    Thread2 i: 9
    … …

    展开全文
  • 线程抛出异常后,synchronized锁会不会主动释放 —笔记 思路: 创建两个线程分别访问同一对象的不同方法,在第一个方法主动抛出异常,如果第二个方法正常执行,则会主动释放,反之亦然。 代码: public class ...

    线程抛出异常后,synchronized锁会不会主动释放 —笔记

    思路: 创建两个线程分别访问同一对象的不同方法,在第一个方法主动抛出异常,如果第二个方法正常执行,则会主动释放,反之亦然。

    代码:

    public class SynchronizedTest implements Runnable{
    
        static SynchronizedTest instance = new SynchronizedTest();
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread1 = new Thread(instance);
            Thread thread2 = new Thread(instance);
            thread1.start();
            thread2.start();
            thread1.join();
            thread2.join();
            System.out.println("finished");
        }
    
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("Thread-0")) {
                method1();
            } else {
                method2();
            }
        }
    
        public synchronized void method1(){
            System.out.println("我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            throw new RuntimeException();
            //System.out.println(Thread.currentThread().getName()+"运行完毕");
        }
    
        public synchronized void method2(){
            System.out.println("我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"运行完毕");
        }
    }
    

    运行结果:

    我叫Thread-0
    我叫Thread-1
    Exception in thread "Thread-0" java.lang.RuntimeException
    	at wl.test.SynchronizedTest.method1(SynchronizedTest.java:33)
    	at wl.test.SynchronizedTest.run(SynchronizedTest.java:20)
    	at java.lang.Thread.run(Thread.java:745)
    Thread-1运行完毕
    finished
    

    说明抛出异常后会释放锁0.0

    展开全文
  • Java中如何捕获其他线程抛出异常

    千次阅读 2018-12-28 13:40:49
    如Java中另一个线程抛出异常 可以使用公共静态接口Thread.UncaughtExceptionHandler完成。 Thread.UncaughtExceptionHandler是当线程因未捕获的异常而突然终止时调用的处理程序接口。 当一个线程由于未捕获的...

    如Java中另一个线程抛出的异常

    可以使用公共静态接口Thread.UncaughtExceptionHandler完成。

    Thread.UncaughtExceptionHandler是当线程因未捕获的异常而突然终止时调用的处理程序接口。

    当一个线程由于未捕获的异常而即将终止时,Java虚拟机将使用它来 查询线程的 UncaughtExceptionHandler  Thread.getUncaughtExceptionHandler(),并将调用该处理程序的 uncaughtException方法,并将该线程和异常作为参数传递。如果某个线程没有 显式设置其UncaughtExceptionHandler,则其ThreadGroup对象将充当其 UncaughtExceptionHandler。如果ThreadGroup对象没有处理异常的特殊要求,它可以将调用转发到默认的未捕获异常处理程序

    一个简单的例子:

    package com.vista;
    
    /**
     * Created by VISTA on 2018/12/28.
     * Java中如何捕获另一个线程抛出的异常?
     * 如下是示例
     */
    public class CatchAnExecptionThrownByAnotherThread {
    
        public static void main(String[] args) {
            // create our uncaught exception handler
            Thread.UncaughtExceptionHandler handler = new Thread.UncaughtExceptionHandler() {
                public void uncaughtException(Thread th, Throwable ex) {
                    System.out.println("Uncaught exception: " + ex);
                }
            };
    
    // create another thread
            Thread otherThread = new Thread() {
                public void run() {
                    System.out.println("Sleeping ...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println("Interrupted.");
                    }
                    System.out.println("Throwing exception ...");
                    throw new RuntimeException();//主动抛出异常
                }
            };
    
    // set our uncaught exception handler as the one to be used when the new thread
    // throws an uncaught exception
            otherThread.setUncaughtExceptionHandler(handler);
    
    // start the other thread - our uncaught exception handler will be invoked when
    // the other thread throws an uncaught exception
            otherThread.start();
        }
    }
    

     

    展开全文
  • Exception in thread “pool-1-thread-5” java.lang.ClassCastException: [B...原因:线程同时调用了同一个jedis对象,导致内存数据被线程竞争,产生数据混乱 解决方案:每个线程都new一个自己的jedis对象

    Exception in thread “pool-1-thread-5” java.lang.ClassCastException: [B cannot be cast to java.lang.Long
    at redis.clients.jedis.Connection.getIntegerReply(Connection.java:222)
    at redis.clients.jedis.Jedis.zrank(Jedis.java:1404)
    at com.redistool.redenvelope.RedisTool.fetchRedEnvelop(RedisTool.java:42)
    at com.redistool.redenvelope.People.fetchRedEnvelop(People.java:35)
    at com.redistool.redenvelope.FetchHbTask.run(FetchHbTask.java:14)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:744)

    原因:多个线程同时调用了同一个jedis对象,导致内存数据被多个线程竞争,产生数据混乱
    解决方案:每个线程都new出一个自己的jedis对象

    展开全文
  • 昨天开始看《Java多线程编程核心技术》一书。记录一些所学:1.通过查看“Windows资源管理器”中的列表,完全可以将运行在内存中的.exe文件理解成一个线程,线程是受操作系统管理的基本运行单元。2.非线程安全:指多...
  • 这个问题坑了很Java程序员,若你能想到锁...无论你的同步块是正常还是异常退出的,里面的线程都会释放锁,所以对比锁接口我更喜欢同步块,因为它不用我花费精力去释放锁,该功能可以在finally block里释放锁实现。
  • 特别重要,因为如果程序中使用了多线程,那么这个异常处理不好的话,无法捕捉异常,可能会导致系统奔溃
  • 首先明确线程代码的边界。其实很简单,Runnable接口的run... 而所有的具体线程都实现这个方法,所以这里就明确了一点,线程代码不能抛出任何checked异常。所有的线程中的checked异常都只能被线程本身消化掉。:) 这样本
  • 通过抛出异常的方式停止线程

    千次阅读 2018-06-23 15:58:46
    /** * @ClassName: StopThreadByException * @Description:通过throw异常的方式停止线程(真正的停止了线程) * @author freeflying * @date 2018年6月23日 */ public class StopThreadByExcepti...
  • java 多线程中的异常处理

    千次阅读 2015-08-17 15:04:06
    1、java多线程中,最近线程会抛异常,但是所以自然的想着通过try catche来捕获异常:try { thread1.start(); } catch (Exception e) { System.out.println("thread1 异常被捕获"); }抛异常代码段为:public void ...
  • c++异常 连续抛出异常

    千次阅读 2013-10-12 17:33:19
    连续两次抛出异常,但是只有一个catch,会导致core这个时候会导致core,单线程编程中可能很少遇到这样的问题,但是多线程中是很容易遇到的,举个例子:catch代码在主线程M中,子线程C1抛出异常,如果引起子线程C2的...
  • 当你跑起了一个异步线程,并用 await 异步等待时,有没有好奇为什么能够在主线程 catch ...本文介绍 ExceptionDispatchInfo,专门用于重新抛出异常。它在 .NET Framework 4.5 中首次引入,并原生在 .NET Core 和 .NET S
  • java多线程中的异常处理

    万次阅读 多人点赞 2012-11-23 15:16:26
    在java多线程程序中,所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己把自己的checked exception处理掉。这一点是通过java.lang.Runnable.run()方法声明(因为此方法声明上没有throw ...
  • 关于抛出线程操作UI线程异常的处理
  • 建议66:正确捕获多线程中的异常

    千次阅读 2016-09-07 10:50:19
    建议66:正确捕获多线程中的异常 多线程异常处理需要采用特殊的方式。一下这种方式会存在问题: try { Thread t = new Thread((ThreadStart)delegate { throw new Except
  • 原因: 当大量抛出运行时异常时,系统肯定存在问题,会影响系统吞吐量
  • Java多线程(七)-多线程异常捕捉

    千次阅读 2019-08-08 18:50:07
     为什么要单独讲多线程的异常捕捉呢?先看个例子: public class ThreadException implements Runnable{ @Override public void run() { throw new RuntimeException(); } //现象:控制台打印出异常信息,...
  • Java多线程之捕获子线程中的异常

    千次阅读 2017-06-10 15:28:54
    在某些场景下,我们经常需要使用多线程来执行任务提高性能,但是我们知道正常的线程是无法处理异常的,一旦出现异常就会传播到控制台。这个时候我们需要在线程里面处理异常怎么办呢,我们可以使用Executor来处理。 ...
  • 在java多线程程序中,所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己把自己的checked exception处理掉。这一点是通过java.lang.Runnable.run()方法声明(因为此方法声明上没有throw ...
  • C# 多线程之捕获异常(try...catch)

    千次阅读 2019-03-27 14:43:16
    当主程序启动时,定义了两个将会抛出异常线程。其中一个在方法内部对异常进行了处理,另一个则没有。可以看到第二个异常没有被包裹启动线程的try/catch代码块捕获到。所以如果直接使用线程,一般来说不要在线程中...
  • 多线程情况下如何捕获线程中的异常?摘要: 本文主要介绍当使用ExecutorService来执行任务(Runnable)时,该如何正确的捕捉线程中的异常。 Thread类最佳实践: 写的时候最好要设置线程名称 Thread.name,并设置线程...
  • Thread的run方法是不抛出任何检查型异常(checked exception)的,但是它自身却可能因为一个异常而被终止,导致这个线程的终结。最麻烦的是,在线程中抛出的异常...主线程之所以不处理子线程抛出的RuntimeException,是因
  • 【0】README0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——异常分类+声明已检查异常+如何抛出异常+自定义异常类 的相关知识; 0.2)异常处理的任务: 就是将控制权从错误产生的地方转移...
  • Java多线程探究-线程异常逃逸

    千次阅读 2017-04-12 14:45:24
    在Thread的run方法中,Java是不允许抛出受检异常的,所以必须由自己捕获,但是对于一些运行时的异常,难免有时候完全捕获到,继而传递到上一层,导致不可预料的程序终止,所以需要在上一层捕获 来看看我们到底不能...
  • 多线程中的异常处理

    千次阅读 2019-07-28 19:51:40
    Thread类run方法不会将异常抛出 如: 主线程: public static void main(String[] args) { try{ Thread t=new Thread(new Task()); t.start(); }catch (Exception e){ System.o...
  • Java 多线程异常捕获Runnable实现

    千次阅读 2017-04-13 17:10:29
    1、背景:  Java 多线程异常不向主线程抛,自己处理,外部捕获不了异常。所以要实现主线程对子线程异常的捕获。... 向LayerInitTask中传入Vector,记录异常情况,外部遍历,判断,抛出异常。 4
  • 线程异常的处理 1. 非运行时异常(Unchecked Exception)  必须捕获并处理,因为run()方法并不支持throws语句 2.运行时异常(Runtime Exception)  2.1默认在控制台输出异常信息  2.2设置UncaughtException异常...
  • 什么时候处理与抛出异常

    千次阅读 2018-03-05 16:50:34
    什么时候处理与抛出异常采用伪代码的形式模拟JAVA代码,不能编译通过,重在思想.什么时候处理异常给客户端(第三方)提供服务时,在服务器的最顶层进行异常处理try{ // 这里抛出异常 return { status : 1 , data...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 295,770
精华内容 118,308
关键字:

多线程抛出异常