java多线程:线程体往外抛出异常的处理机制实践

1当线程的线程体内部无捕获异常,将异常抛出线程体外,不同情况下,程序处理机制

测试类

 1 package com.ehking.bankchannel.domesticremit.facade.impl;
 2
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.concurrent.Executor;
 6 import java.util.concurrent.Executors;
 7
 8
 9 public class ThreadTest {
10
11     private static Executor executor=Executors.newCachedThreadPool();
12
13
14     public static void main(String[] args) {
15         test01();
16         //test02();
17     }
18
19     /**
20      * 线程池,主线程往线程池提交任务(子线程)
21      * 如果任务中有往外抛出异常,主线程并不会捕获异常。
22      * 是线程池捕获了任务的异常
23      */
24     public static void test02(){
25
26         ThreadTask aTask=new ThreadTask(1);
27         ThreadTask aTask2=new ThreadTask(2);
28         ThreadTask aTask3=new ThreadTask(6);
29         List<ThreadTask> aList=new ArrayList<ThreadTask>();
30         aList.add(aTask);
31         aList.add(aTask2);
32         aList.add(aTask3);
33         try {
34             for(ThreadTask a:aList){
35                 executor.execute(a);
36             }
37             System.out.println("ThreadTest.test02(没有执行)");
38         } catch (Exception e) {
39             System.out.println("ThreadTest.test02()"+e);
40         }
41
42
43     }
44     /**
45      * 如果用匿名线程,匿名线程中有抛出异常,无捕获的话,主线程是会捕获这个异常
46      */
47     public static  void test01(){
48         System.out.println("ThreadTest.test01()==>主线程运行开始");
49         final List<String> list=new ArrayList<String>();
50         try {
51             list.add("sxf");
52             list.add("chn");
53
54             Thread thread=new Thread(new Runnable() {
55
56                 @Override
57                 public void run() {
58                     System.out
59                             .println("ThreadTest.test01().new Runnable() {...}.run()子线程加爱");
60                     list.add("love");
61                     System.out
62                             .println("ThreadTest.test01().new Runnable() {...}.run()子线程抛出异常");
63                     int a=3/0;
64                     System.out
65                             .println("ThreadTest.test01().new Runnable() {...}.run()z县城结束");
66                 }
67             });
68             thread.start();
69
70
71         } catch (Exception e) {
72             System.out.println("ThreadTest.test01()子线程抛出异常"+e);
73         }
74
75         try {
76             Thread.sleep(3000L);
77         } catch (InterruptedException e) {
78             // TODO Auto-generated catch block
79             e.printStackTrace();
80         }
81         for(String aString:list){
82             System.out.println("ThreadTest.test01()打印==>"+aString);
83         }
84         System.out.println("ThreadTest.test01()==>主线程运行结束");
85     }
86 }

View Code

 线程类

 1 package com.ehking.bankchannel.domesticremit.facade.impl;
 2
 3 public class ThreadTask implements Runnable{
 4
 5     private int a;
 6
 7     public ThreadTask(int a){
 8         this.a=a;
 9     }
10
11     @Override
12     public void run() {
13         if(a%2==0){
14             System.out.println("ThreadTask.run()【"+a+"】运行正常.......");
15         }else{
16             System.out.println("ThreadTask.run()【"+a+"】抛出异常");
17             int s=2/0;
18         }
19
20     }
21
22
23 }

View Code

 

时间: 2025-01-31 05:43:44

java多线程:线程体往外抛出异常的处理机制实践的相关文章

java 多线程-线程通信实例讲解_java

线程通信的目标是使线程间能够互相发送信号.另一方面,线程通信使线程能够等待其他线程的信号. 通过共享对象通信 忙等待 wait(),notify()和 notifyAll() 丢失的信号 假唤醒 多线程等待相同信号 不要对常量字符串或全局对象调用 wait() 通过共享对象通信 线程间发送信号的一个简单方式是在共享对象的变量里设置信号值.线程 A 在一个同步块里设置 boolean 型成员变量 hasDataToProcess 为 true,线程 B 也在同步块里读取 hasDataToProc

Java多线程-线程的同步与锁的问题_java

一.同步问题提出 线程的同步是为了防止多个线程访问一个数据对象时,对数据造成的破坏. 例如:两个线程ThreadA.ThreadB都操作同一个对象Foo对象,并修改Foo对象上的数据. package cn.thread; public class Foo { private int x = 100; public int getX() { return x; } public int fix(int y) { x = x - y; return x; } } package cn.thread

Java多线程--线程常用操作方法

1.取得和设置线程名称 class MyThread implements Runnable{ // 实现Runnable接口 public void run(){ // 覆写run()方法 for(int i=0;i<3;i++){ System.out.println(Thread.currentThread().getName() + "运行,i = " + i) ; // 取得当前线程的名字 } } }; public class ThreadNameDemo{ publ

Java多线程--线程操作范例

1.实例要求 设计一个线程操作类,要求可以产生三个线程对象,并可以分别设置三个线程的休眠时间: 线程A : 休眠10秒 线程B: 休眠20秒 线程C : 休眠30秒 2.通过继承Thread类 在Thread类中直接存在了name属性. class MyThread extends Thread{ private int time ; public MyThread(String name,int time){ super(name) ; // 设置线程名称 this.time = time ;

Java多线程的同步示例及对象锁机制

java多线程的同步依靠的是对象锁机制,synchronized关键字的背后就是利用了封锁来实现对共享资源的互斥访问. 下面以一个简单的实例来进行对比分析.实例要完成的工作非常简单,就是创建10个线程,每个线程都打印从0到99这100个数字,我们希望线程之间不会出现交叉乱序打印,而是顺序地打印. 先来看第一段代码,这里我们在run()方法中加入了synchronized关键字,希望能对run方法进行互斥访问,但结果并不如我们希望那样,这 是因为这里synchronized锁住的是this对象,即

新手学JAVA(十)-多线程----线程的创建和启动

Java使用Thread类代表线程,所有的线程对象都必须是Thread类或者其子类的实例.每个下次你哼的作用是完成一定的任务,实际上就是执行一段程序流(一段顺序执行的代码).Java使用线程执行体来代表这段程序流     在Java线程的创建有三种方式      通过继承Thread类创建线程类 步骤如下 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务.因此把run()方法称为线程执行体. 创建Thread子类的实例,即创建了线程的对象.

学习Java多线程之线程定义、状态和属性_java

一 .线程和进程 1. 什么是线程和进程的区别: 线程是指程序在执行过程中,能够执行程序代码的一个执行单元.在java语言中,线程有四种状态:运行 .就绪.挂起和结束. 进程是指一段正在执行的程序.而线程有事也被成为轻量级的进程,他得程序执行的最小单元,一个进程可以拥有多个线程,各个线程之间共享程序的内功空间(代码段.数据段和堆空间)及一些进程级的资源(例如打开的文件),但是各个线程都拥有自己的棧空间. 2. 为何要使用多进程 在操作系统级别上来看主要有以下几个方面: - 使用多线程可以减少程序

Java多线程编程中synchronized线程同步的教程_java

0.关于线程同步 (1)为什么需要同步多线程?线程的同步是指让多个运行的线程在一起良好地协作,达到让多线程按要求合理地占用释放资源.我们采用Java中的同步代码块和同步方法达到这样的目的.比如这样的解决多线程无固定序执行的问题: public class TwoThreadTest { public static void main(String[] args) { Thread th1= new MyThread1(); Thread th2= new MyThread2(); th1.sta

java多线程编程之java线程简介_java

一.线程概述 线程是程序运行的基本执行单元.当操作系统(不包括单线程的操作系统,如微软早期的DOS)在执行一个程序时,会在系统中建立一个进程,而在这个进程中,必须至少建立一个线程(这个线程被称为主线程)来作为这个程序运行的入口点.因此,在操作系统中运行的任何程序都至少有一个主线程.进程和线程是现代操作系统中两个必不可少的运行模型.在操作系统中可以有多个进程,这些进程包括系统进程(由操作系统内部建立的进程)和用户进程(由用户程序建立的进程):一个进程中可以有一个或多个线程.进程和进程之间不共享内存