精华内容
下载资源
问答
  • delphi线程异常处理

    2015-06-16 20:40:52
    delphi线程异常处理
  • 线程异常处理 重启

    千次阅读 2016-03-24 14:35:24
    线程异常处理不能像普通程序一样出现异常后抛出然后由创建并启用该线程的主线程try catch后进行异常处理,而是只能由该子线程自己try catch自己的异常,比如该子线程中连接数据库或者操作文件,会有可能出现...

    线程的异常处理不能像普通程序一样出现异常后抛出然后由创建并启用该线程的主线程try catch后进行异常处理,而是只能由该子线程自己try catch自己的异常,比如该子线程中连接数据库或者操作文件,会有可能出现IOException或者SQLException等异常,而且这些异常一旦发生,线程就会中止,中止的线程并不会对其他线程或者主线程造成影响,不过有时当我们用子线程去连接数据库时,假如连接不上,会抛出异常,而我们希望自动断线间隔重连,即子线程出现异常停止后,通知主线程在适当的时间后再次重启子线程,此时可以使用两种方法(有可能还有方法,只是目前我所知道的有两种),第一种使用java1.5以上自带的Observable和Observer,即观察者模式,第二种是使用原始内存模式(第一种有可能是封装好的也是基于内存实现,没去看源码)。

    一、观察者模式

    1.介绍

    在Java中通过Observable类和Observer接口实现了观察者模式。一个Observer对象监视着一个Observable对象的变化,当Observable对象发生变化时,Observer得到通知,就可以进行相应的工作。

    2.实现方法

    观察者:

    /**
     * Created by Administrator on 2016-03-24.
     *
     * 观察者 线程 类
     *
     */
    class SimpleObserver implements Observer {
    
        @Override
        public void update(Observable observable ,Object data){
            //重启线程
            System.out.println("5秒后重启线程");
            Thread.sleep(5000);
            SimpleObservable simpleObservable = new SimpleObservable();
            SimpleObserver simpleObserver = new SimpleObserver();
            //需要将观察者类加入到被观察者的观察者列表中
            simpleObservable.addObserver(simpleObserver);
            simpleObservable.run();
        }
    }

    被观察者

    import java.sql.SQLException
    
    /**
     * Created by Administrator on 2016-03-24.
     *
     * 被观察者 线程 类
     */
    class SimpleObservable extends Observable implements Runnable{
    
    
        public void run(){
    
            try {
                //System.out.println("下面进行JDBC连接");
                /**
                 * Do jdbc
                 */
                //测试
                int a  = 100 / 0 ;
            } catch (SQLException e) {
                //处理连接异常,自动重启该线程
                setChanged();
                //只有在setChange()被调用后,notifyObservers()才会去调用update(),否则什么都不干。
                notifyObservers();
            } catch (Exception et){
                System.out.println("出现异常");
                setChanged();
                notifyObservers();
            }
        }
    }

    主线程

    /**
     * Created by Administrator on 2016-03-24.
     */
    class MainThread {
    
        public static void main(String[] args) {
    
            //创建观察者对象
            SimpleObserver simpleObserver = new SimpleObserver();
            //创建被观察者对象
            SimpleObservable simpleObservable = new SimpleObservable();
    
            //需要将观察者类加入到被观察者的观察者列表中
    
            simpleObservable.addObserver(simpleObserver);
    
            //启动被观察者,观察者线程也会同时被启动
            simpleObservable.run();
        }
    }
    

    二、内存模式

    具体原理为在内存中建立一个唯一的子线程标示,一旦子线程异常后,删除标示,子线程启动后,创建标示,然后监控线程时刻监视标示,一旦标示不存在了,就启动一个新的子线程,以此来实现线程异常后的重启。

    内存线程类

    public class ThreadUtil
    {
        private static Thread thread;
    
        private ThreadUtil( ) {
        }
        //添加线程标示
        public static addThread(Thread value){
            if(thread == null){
                thread = value;
            }
        }
        //获取线程标示
        public static Thread getLocalThread(){
            if(thread){
                return thread;
            }
            else return null;
        }
        //删除线程标示
        public static deleteThread(Thread value){
            if(thread != null){
                thread = null;
            }
        }
    }

    子线程

    class childThread implements Runnable{
    
        public void run(){
            try{
                //do something
            }
            catch(Exception outEx){
                //log
            }
            finally{
                //删除childThread标示
                Thread thread = ThreadUtil.getLocalThread();
                ThreadUtil.deleteThread(thread);
            }
        }
    }

    监控线程

    /**
     * Created by Administrator on 2016年3月23日16:36:06
     *
     * 监控线程 的 线程
     */
    class MonitorThread implements Runnable{
    
        public void run() {
            while(true){
                Thread.sleep(10000);
                Thread thread = ThreadUtil.getLocalThread();
                //存在线程,休眠10秒
                if(thread){
                    LogUtil.logInfo("历史数据上传线程正常运行");
                }
                //不存在线程,重启线程
                else{
                    Thread newThread = new Thread(new childThread());
                    ThreadUtil.addThread(newThread);;
                    thread.start();
                }
            }
        }
    }
    展开全文
  • Java 线程异常处理

    千次阅读 2019-03-25 16:58:39
    当多线程应用程序运行出现空指针异常,可以使用UncaughtExceptionHandler类进行捕捉,进而处理。 下面通过官方文档对UncaughtExceptionHandler进一步了解: 此类是Thread接口中的。 描述: 当线程由于未捕获...

    当多线程应用程序运行出现空指针异常,可以使用UncaughtExceptionHandler类进行捕捉,进而处理。

    下面通过官方文档对UncaughtExceptionHandler进一步了解:
    在这里插入图片描述
    此类是Thread接口中的。
    在这里插入图片描述
    描述:
    当线程由于未捕获的异常而即将终止时,Java虚拟机将查询线程的 UncaughtExceptionHandler使用情况 Thread.getUncaughtExceptionHandler(),并将调用处理程序的 uncaughtException方法,将线程和异常作为参数传递。如果一个线程没有UncaughtExceptionHandler 明确设置,那么它的ThreadGroup对象就像它一样 UncaughtExceptionHandler。
    如果ThreadGroup对象没有处理异常的特殊要求,它可以将调用转发给默认的未捕获异常处理程序。

    该类的方法:
    在这里插入图片描述
    可以使用如下方法对线程设置默认的异常处理器:

    Thread.setDefaultUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler)——>public static void setDefaultUncaughtExceptionHandler​(Thread.UncaughtExceptionHandler eh)
    eh - 用作默认未捕获异常处理程序的对象。如果null那时没有默认处理程序。

    设置当线程由于未捕获的异常而突然终止时调用的默认处理程序,并且没有为该线程定义其他处理程序。未捕获的异常处理首先由线程控制,然后由线程的ThreadGroup对象控制,最后由默认的未捕获异常处理程序控制。如果线程没有明确的未捕获异常处理程序集,并且线程的线程组(包括父线程组)不专门化其 uncaughtException方法,则将uncaughtException调用默认处理程序的 方法。

    通过设置默认的未捕获异常处理程序,应用程序可以更改已经接受系统提供的任何“默认”行为的线程处理未捕获异常的方式(例如,记录到特定设备或文件)。

    请注意,默认的未捕获异常处理程序通常不应该遵循线程的ThreadGroup对象,因为这可能导致无限递归。

    Thread.setUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler)——>public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
    eh - 用作此线程的未捕获异常处理程序的对象。如果null那么这个线程没有显式处理程序。

    设置当此线程由于未捕获的异常而突然终止时调用的处理程序。
    线程可以通过显式设置未捕获的异常处理程序来完全控制它如何响应未捕获的异常。如果没有设置这样的处理程序,则线程的ThreadGroup 对象充当其处理程序。

    ThreadGroup.uncaughtException(java.lang.Thread, java.lang.Throwable)——>public void uncaughtException(Thread t, Throwable e)
    t - 即将退出的线程。
    e - 未被捕获的例外。

    当此线程组中的线程因未捕获的异常而停止并且该线程未Thread.UncaughtExceptionHandler 安装特定时,由Java虚拟机调用。
    该uncaughtException方法 ThreadGroup执行以下操作:

    如果此线程组具有父线程组,uncaughtException则使用相同的两个参数调用该父线程的 方法。
    否则,此方法将检查是否安装了 默认的未捕获异常处理程序,如果是,uncaughtException则使用相同的两个参数调用其 方法。
    否则,此方法确定Throwable 参数是否是实例ThreadDeath。如果是这样,没有什么特别的。否则,包含该线程的名称的消息,如从线程的返回getName的方法,以及在堆栈中,使用Throwable的printStackTrace方法中,被打印到标准错误流。
    应用程序可以在子类中覆盖此方法, ThreadGroup以提供对未捕获异常的替代处理。

    下面通过代码来 操练 此类异常:

    在这里插入图片描述
    在这里插入图片描述
    如果想操练其他的方法,改下方法就行了,这里不做操练演示。
    线程组也是同样道理,不过需要注意:
    使用自定义java.lang.ThreadGroup线程组,并重写uncaughtException方法处理组内线程中断行为时,每个线程对象中的run()方法内部不要出现有异常catch语块。如果出现,uncaughtException方法会不执行。
    对于多个线程,如果要处理多个异常,也可以放在一起进行运行处理。

    线程异常处理的传递:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    输出结果:
    在这里插入图片描述
    修改如下代码:
    在这里插入图片描述
    在这里插入图片描述
    还是对象的异常处理,如果把处理对象异常处理的线程注释掉,则输出的是静态的异常处理和线程组异常,如果注释掉两个线程异常处理,则抛出线程组异常处理的信息。

    展开全文
  • python多线程异常处理

    千次阅读 2016-08-06 18:31:44
    python 多线程异常

    最近在根据项目需求。统计10万个query,召回的xml中提取某标签信息。共启动10个线程,不过在统计过程线程出现UrlError的异常,但是在线程中未捕获异常,导致线程提前终止。导致统计信息异常。</span><pre>

            出现问题后,通过查询得知,线程中有自己独有的栈,当线程抛出异常后,假如未捕获的话,线程会直接结束,但是不影响其它线程的运行,通过捕获异常,对异常进行处理,此线程不会终止,执行完异常处理代码后,可继续执行execp后的代码。

             如果服务器网络状况不好,爬取网页数据时需要设置socket超时,设置超时后,当read()超时时,程序会抛出socket.timeout的异常。设置超时有以下两种方法:

           1、为urlopen设置可选参数 timeout

    f = urllib2.urlopen(r, data=None, timeout=3)

       2设置全局的socket超时:

    import socket
    socket.setdefaulttimeout(10.0)


    展开全文
  • C# 多线程异常处理

    千次阅读 2013-11-25 11:08:41
    问题1:子线程中的未处理异常会影响...问题2:如何捕获子线程和主线程中所有的未处理异常? 示例代码: class Program { static void Main(string[] args) { //AppDomain.CurrentDomain.UnhandledException +

    问题1:子线程中的未处理异常会影响主线程的运行吗?

    问题2:如何捕获子线程和主线程中所有的未处理异常?


    示例代码:


     class Program
        {
            static void Main(string[] args)
            {
                //AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
                
                new Thread(new ThreadStart(threadFun)).Start();
    
                Thread.Sleep(500); //让子线程执行完毕
    
                Console.WriteLine("主线程正常运行!!!");
    
                Console.ReadLine();
            }
    
            static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
            {
    
                Console.WriteLine( e.ExceptionObject.ToString());
                Console.ReadLine();
            }
    
            public static void threadFun()
            {
    
                    throw new Exception("子线程异常!!!");
    
            }
        }


    代码中注释掉的部分为全局的异常处理代码;

    运行上述代码可以看到子线程抛出未处理的异常后,主线程是无法正常运行的。

    打开异常处理代码,加入全局异常处理后,在CurrentDomain_UnhandledException中对子线程的异常进行了处理,

    此时主线程可正常运行。


    展开全文
  • 多线程核心(2):线程异常处理

    千次阅读 2020-01-12 19:28:07
    线程的未捕获异常UncaughtException应该如何处理
  • 作为一名应用开发,大家是否有遇到以下现象,为什么一套非常优秀的兜底机制还是会出现页面空窗现象?本文将会通过实例和大家分享,作者在线程池使用过程中遇到的问题:异常处理,以及下线程池的参数设置...
  • UI线程异常处理方法

    千次阅读 2015-07-12 21:15:00
    当应用程序启动,创建了一个叫“main”的线程,用于管理UI相关,又叫UI线程。其他线程叫工作线程(Work Thread)。 Single Thread Model 一个组件的创建并不会新建一个线程,他们的创建都在UI线程中进行,包括...
  • 【java并发编程】多线程异常处理

    千次阅读 2020-01-09 20:50:05
    ​ 多线程充分发挥了系统的性能,但是调用Thread.start()方法之后,如果线程异常造成线程终止,主线程无法及时获取。 public static void main(String[] args) { Thread thread = new Thread(() -> { //todo...
  • 处理未捕获的异常是每个应用程序起码有的功能,C#在AppDomain提供了UnhandledException 事件来接收未捕获到的异常的通知。常见的应用如下:  static void Main(string[] args) { AppDom
  • 前面的博客中主要描述的关于线程的概念,通过源码分析了解线程的基本操作方式,但是如何在线程运行期间获取异常信息呢?这就要使用到一个Hook线程线程运行时的异常   在Thread类中,关于线程运行时异常的...
  • c#中的多线程异常处理

    万次阅读 2012-08-29 15:33:52
    1.对于Thread操作的异常处理 public static void Main() {  try  {  new Thread (Go).Start();  }  catch (Exception ex)  {  // We'll never get here!  Console.WriteLine ("Exception!");  }...
  • 《Java并发》:第五节 线程异常处理

    千次阅读 2013-12-29 18:19:01
    1、异常不能跨线程传播 class ExceptionThread implements Runnable { @Override public void run() { //这里只能抛运行时异常,Runnable.run不允许抛出未处理的非运行时异常 throw new RuntimeException(...
  • 关于线程异常处理

    千次阅读 2018-07-03 14:56:27
    其中一个面试题如标题,说实话以前真没有注意过这个,所以根本不知道,下来就翻看各种资料了解到在线程的Thread中有一个内部接口类UncaughtExceptionHandler,可以去处理线程抛出来的异常。例子:基于Thread:public...
  • 易语言源码易语言线程结构异常处理.rar 易语言源码易语言线程结构异常处理.rar 易语言源码易语言线程结构异常处理.rar 易语言源码易语言线程结构异常处理.rar 易语言源码易语言线程结构异常处理.rar 易语言源码...
  • C# 中多线程异常处理

    千次阅读 2015-01-09 16:38:05
    在创建多线程的时候,启动多线程时候...需要在主程序的地方加上异常处理方法。 //处理未捕获的异常 Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException); //处理UI线程异常 Appli
  • JAVA线程及线程池异常处理

    千次阅读 2018-08-10 23:45:51
    JAVA线程异常处理 在run方法上增加异常处理 new Thread(() -&gt; { try { System.err.println(3 / 2); System.err.println(3 / 0); } catch (Exception e) { System.err.println("Catch exception===&...
  • 在java多线程程序中,所有线程都不允许抛出未捕获的checked exception,也就是说各个线程需要自己把自己的checked exception处理掉,通过此篇文章给大家分享Java多线程之多线程异常捕捉,需要的朋友可以参考下
  • Java线程未捕获异常处理

    千次阅读 2016-01-16 13:14:26
    Java线程未捕获异常处理  线程执行完run方法即可正常退出,如果发生了没有捕获的异常则会异常退出。...下面介绍线程异常的处理办法。  JVM为我们提供了线程的未捕获异常处理机制,通过Thread的setU
  • 线程异常处理.ppt

    2020-03-02 00:10:46
    第七章 多线程异常处理 武汉大学计算机学院计算机应用系 本章学习要点 深入理解多线程的基本概念 熟练掌握创建线程的两种基本方法 熟练处理线程的同步问题和死锁问题 深入理解异常的基本概念 熟悉和掌握Java平台...
  • 线程异常重启

    千次阅读 2017-08-16 14:33:25
    线程异常处理不能像普通程序一样出现异常后抛出然后由创建并启用该线程的主线程try catch后进行异常处理,而是只能由该子线程自己try catch自己的异常,比如该子线程中连接数据库或者操作文件,会有可能出现...
  • 捕获异步线程异常的常用方式

    千次阅读 2020-05-01 14:42:38
    声明: 捕获异步线程异常的方式有很多,本文只介绍(并示例)几种相对常用的方式。 捕获异步线程异常的常用方式(结论): 开启线程的方式 使用线程池的情况 捕获异步线程异常的常用方式 Thread 不使用线程池 1...
  • Java捕获线程异常的几种方式

    万次阅读 多人点赞 2018-08-27 16:47:49
    Java捕获线程异常的几种方式,Java中在处理异常的时候,通常的做法是使用try-catch-finally来包含代码块,但是Java自身还有一种方式可以处理——使用UncaughtExceptionHandler。它能检测出某个线程由于未捕获的异常...
  • 08. 线程异常捕获

    2019-09-01 18:50:44
    从java5 开始, Java 加强了对线程异常处理. 如果线程执行过程中抛出了一个未处理的异常, JVM在结束该线程之前, 会自动查找该线程是否拥有对应的线程异常处理器对象, 若找到之后, 则调用异常处理器的方法处理异常. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 519,228
精华内容 207,691
关键字:

线程异常如何处理