从零开始学习Java多线程(二)

前面已经简单介绍进程和线程,为后续学习做铺垫。本文讨论多线程传参,Java多线程异常处理机制。

1. 多线程的参数传递

在传统开发过程中,我们习惯在调用函数时,将所需的参数传入其中,通过函数内部逻辑处理返回结果,大多情况下,整个过程均是由一条线程执行,排除运行不必要的的偶发性,似乎并不会出现意料之外的结果。而在多线程环境下,在使用线程时需要对线程进行一些必要的初始化,线程对这些数据进行处理后返回结果,由于线程的运行和结束并不可控,线程传参变得复杂起来,本文就以上问题介绍三种常用的传递参数方式。

一)构造方法传参

在创建线程时,需要创建一个Thread类的或者其子类的实例,通过调用其start()方法执行run()方法中的代码块,在此之前,我们可以通过构造函数传递线程运行所需要的数据,并使用变量保存起来。代码如下:

 1 public class MyThread extends Thread {
 2
 3     //定义变量保存参数
 4     private String msg;
 5
 6     public MyThread() {
 7     }
 8
 9     public MyThread(String msg) {
10         this.msg = msg;
11     }
12
13     //多线程的入口
14     public void run() {
15         System.out.println("MyThread " + msg);
16     }
17
18     public static void main(String[] args) {
19         MyThread myThread = new MyThread("is running");
20         myThread.start();
21     }
22 }

运行结果:

MyThread is running

Process finished with exit code 0

这种方式的优点很明显:简单、安全。在线程运行之前数据已经准备完成,避免线程丢失数据,如果传递更复杂数据,可以定义集合或者类等数据结构。缺点就是传递比较多的参数时,这种方式会使构造方法过于复杂,为了避免这种情况可以通过类方法和变量传递参数

(二)变量和类方法传递参数

在Thread实例类中定义需要传递的参数变量,并且定义一系列public的方法(或变量),在创建完Tread实例后通过调用方法给参数逐个赋值。上面的代码也可以通过定义setMsg()方法传递参数,代码如下:

 1 public class MyThread extends Thread {
 2
 3     //定义变量保存参数
 4     private String msg;
 5
 6     public void setMsg(String msg) {
 7         this.msg = msg;
 8     }
 9
10     public MyThread() {
11     }
12
13     public MyThread(String msg) {
14         this.msg = msg;
15     }
16
17     //多线程的入口
18     public void run() {
19         System.out.println("MyThread " + msg);
20         System.out.println(Thread.currentThread().getThreadGroup());
21     }
22
23     public static void main(String[] args) {
24         MyThread myThread = new MyThread();
25         myThread.setMsg("is running");
26         myThread.start();
27     }
28 }

(三)通过回调函数传递数据

以上线程传递参数最常用的两种方式,但是可以发现参数都在main方法中设置,然后Thread实例被动的接受参数,假如在线程运行中动态的获取参数,如在run()方法先获取三个随机数,通过Work类的process方法对这随机数求和,最后通过Data类的value值返回结果。此例看出在返回value之前,因为随机数的不确定性,我们并不能事先传递的值value。

 1 class Data {
 2     public int value = 0;
 3 }
 4
 5 class Work {
 6     //回调函数
 7     public void process(Data data, Integer[] numbers) {
 8         for (int n : numbers) {
 9             data.value += n;
10         }
11     }
12 }
13
14 public class MyThread extends Thread {
15     //回调函数的对象
16     private Work work;
17
18     public MyThread(Work work) {
19         this.work = work;
20     }
21
22     public void run() {
23         java.util.Random random = new java.util.Random();
24         Data data = new Data();
25         int n1 = random.nextInt(1000);
26         int n2 = random.nextInt(2000);
27         int n3 = random.nextInt(3000);
28         work.process(data, new Integer[]{n1, n2, n3}); // 使用回调函数
29         System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+"
30                 + String.valueOf(n3) + "=" + data.value);
31     }
32
33     public static void main(String[] args) {
34         Thread thread = new MyThread(new Work());
35         thread.start();
36     }
37
38 }

上面代码中process()方法即是回调函数,实质上是一个事件函数。整个事件流程为:将求和对象work传入线程,线程执行过程中三个随机数的产生触发了求和事件,通过传递进来的work对象调用process()方法,最后将结果返回线程并在控制台输出。这种传递数据的方式是在上面两种传参的基础上进行了薄层封装,并没有直接将参数传递给线程,而是通过传递的对象进行逻辑处理之后将结果返回。

2. Java多线程异常处理机制

先来看对于未检查异常在run()方法中是如何处理的。

运行结果:

由上可以看出对于未检查异常,从线程将会直接宕掉,主线程继续运行。那么在主线程中能不能捕获到异常呢?我们直接将全部代码块try catch起来

然后你会发现并没有什么卵用,主线程没有捕获到任何异常信息,和未检出异常如出一辙,从线程直接宕掉,主线程继续运行

如果先检查异常呢?

IDEA提示:

结果还是让人失望,程序还没运行,IDEA已经提示报错,原来run()方法本身不支持抛出异常的,方法重写更不允许throws,所以run()方法不支持往外抛出异常。

最后再试下能不能在run()方法中try catch捕获异常,

运行结果:

原来在run()方法中try catch是能捕捉到异常的。所以对于多线程已检查的异常我们可以通过try catch进行处理,而对于未检查的异常,如果没有处理,一旦抛出该线程立马宕掉,主线程则继续运行,那么未检查的异常也全部需要try catch吗?当然这也是一种方式。除此之外,Java还提供了异常处理器。

(一)Java异常处理器

在Java线程run()方法中,对于未检查异常,借助于异常处理器进行处理。异常处理器可以直接理解为异常处理的方法,下面为具体如何使用。

UncaughtExceptionHandler,是Thread的内部接口。

Thread内部有两个变量,用来记录异常处理器。

Thread内部也分别提供了它们的get/set方法,set()方法其实没什么特别,主要是用来设置这两个内部变量,重点在于它们的get()方法。

对于getUncaughtExceptionHandler方法,如果当前UncaughtExceptionHandler对象不为空,那么直接返回该对象,如果为空,返回该线程所属的线程组,由此得知,ThreadGroup实现了UncaughtExceptionHandler接口。

与此同时,内部实现了uncaughtException方法,

而对于getDefaultUncaughtExceptionHandler()方法,只是简单的返回内部对象。

至此,我们可以了解到Thread内部有两个异常处理器,分别提供了get/set方法,对于set方法只是单纯的设置异常处理器,对于get方法,getDefaultUncaughtExceptionHandler()方法直接获取处理器;getUncaughtExceptionHandler()方法,进行判空,如果非空直接返回,如果为空返回该线程所属的线程组,并且当前线程组是实现了Thread.UncaughtExceptionHandler接口,内部实现了public void uncaughtException(Thread t, Throwable e),其本质上它才是线程处理器。

对于defaultUncaughtExceptionHandler,表示应该程序默认的,整个程序可以使用的,它的get/set方法均为static修饰;对于uncaughtExceptionHandler,属于实例方法,也就是说每个线程可以拥有一个,简言之:每个线程都可以有一个uncaughtExceptionHandler,整个应用可以有一个defaultUncaughtExceptionHandler。它们之间是个体与全局的关系,如果个体拥有那么就不再使用全局的;否则,走全局。这样做的好处是非常灵活,既可以保证单个线程特别处理,又可以保障整个程序做到统一处理,在诸多场景发挥多种用处。

(二)异常处理逻辑

当run()方法中发生异常,JVM调用异常分发器,也就是借助getUncaughtExceptionHandler方法获取异常处理器,然后执行它的uncaughtException方法。

所以关键之处在于uncaughtException()方法,再来看它的源码:

 1 public void uncaughtException(Thread t, Throwable e) {
 2         //是否存在父线程组
 3         if (parent != null) {
 4             parent.uncaughtException(t, e);
 5         } else {
 6             //获取默认异常处理器
 7             Thread.UncaughtExceptionHandler ueh =
 8                     Thread.getDefaultUncaughtExceptionHandler();
 9             //如果非空,调用其uncaughtException方法
10             if (ueh != null) {
11                 ueh.uncaughtException(t, e);
12                 //否则打出标准错误信息
13             } else if (!(e instanceof ThreadDeath)) {
14                 System.err.print("Exception in thread \""
15                         + t.getName() + "\" ");
16                 e.printStackTrace(System.err);
17             }
18         }
19     }

如果已经设置异常处理器,那么直接返回,如果没有设置,返回当前线程组,并且调用线程组的uncaughtException方法时(如上图),如果该线程组重写了uncaughtException方法,直接调用;如果没有,调用该线程组的父线程组;如果父线程组仍然没有重写,调用爷爷线程组,以此类推。但是如果所有的线程组都没有重写,进入else里面,在else中获取默认处理器,如果默认有,执行uncaughtException方法,如果没有直接system.err。

以上就是异常处理器的处理逻辑,可以看出uncaughtExceptionHandler处理器优先级要高于defaultUncaughtException,这也符合就近原则,如果自身拥有了,又何必调用全局拥有的呢!

(三)异常处理器代码演示

 1 public class TestThread {
 2
 3     public static void main(String[] args) {
 4             MyThread myThread = new MyThread();
 5             myThread.setUncaughtExceptionHandler((Thread t,Throwable e)->{
 6                 System.out.println("出现异常...");
 7                 System.out.println("线程名称: "+myThread.getName());
 8                 System.out.println("异常信息: "+e.getMessage());
 9             });
10             myThread.start();
11             System.out.println("main runing....");
12             System.out.println("main runing....");
13             System.out.println("main runing....");
14             System.out.println("main runing....");
15     }
16 }
17 class MyThread extends Thread {
18     public void run() {
19             //抛出异常
20             int i = 13 / 0;
21     }
22 }

运行结果:

以上示例可以看出,尽管为检查异常,通过异常处理器依然能够感知异常和信息获取,不会直接宕掉了。主要注意的是,必须在调用start()方法之前设置异常处理器,否则线程依旧直接宕掉。

(四)总结

Java多线程异常处理机制依赖于Thread内部两个异常处理器,uncaughtExceptionHandler和defaultUncaughtExceptionHandler。两者之间为个体和全局之间的关系,如果前者已经设置,那么直接使用,否则使用后者。大致步骤为:

a. 如果设置了异常处理器uncaughtExceptionHandler直接使用。

b. 如果没设置,将会在祖先线程组中查找第一个重写了uncaughtException的线程组,然后调用他的uncaughtException方法

c. 如果都没有重写,那么使用应用默认的全局异常处理器defaultUncaughtExceptionHandler

d. 如果还是没有设置,直接标准错误打印信息

如果想要设置线程特有的异常处理器,可以调用set方法进行设置;如果想要对全局进行设置,可以调用静态方法进行设置,需要注意的是必须要在调用start()方法之前设置。

原文地址:https://www.cnblogs.com/supiaol/p/10531156.html

时间: 2024-10-11 13:24:35

从零开始学习Java多线程(二)的相关文章

如何从零开始学习Java语言

1.如何从零开始学习Java语言 许多朋友在学习新的语言上有些困惑,如何学好Java语言. 如何学好Java语言,分二种技术人员 1)第一种:有编程语言的技术人员 IT行业的朋友,应为本事就有编程语言的技术,学习Java语言不是困难的事情.所谓的懂一门语言就会其他语言.为什么这么说,应他们有一些编程的基本知识,他们知道如何去学习技术.(但这里有一点却记:不要认为自己懂了一门编程语言就学习其他语言很简单.就跳过一些基本知识不学习.)如果你是这样的话,请立即改正这错误观点,因为这样你即时学会了这门语

【转】从零开始学习Gradle之二---如何使用Task

原文:http://www.blogjava.net/wldandan/archive/2012/07/05/382246.html 上一篇文章中,我们提到了Gradle的一些基本概念,如Project.Task以及Action,并且创建了我们的第一个Task.这次我们来看看Gradle中关于Project和Task的更多细节. 1. Project和Task 对于build.gradle配置文件,当运行Gradle <Task> 时,Gradle会为我们创建一个Project的对象,来映射b

java多线程(二)——用到的设计模式

接上篇:java多线程(一)http://www.cnblogs.com/ChaosJu/p/4528895.html java实现多线程的方式二,实现Runable接口用到设计模式——静态代理模式 一.代理模式 代理模式的定义 代理模式(Proxy Pattern)是对象的结构型模式,代理模式给某一个对象提供了一个代理对象,并由代理对象控制对原对象的引用. 代理模式不会改变原来的接口和行为,只是转由代理干某件事,代理可以控制原来的目标,例如:代理商,代理商只会卖东西,但并不会改变行为,不会制造

Java多线程(二) 多线程的锁机制

当两条线程同时访问一个类的时候,可能会带来一些问题.并发线程重入可能会带来内存泄漏.程序不可控等等.不管是线程间的通讯还是线程共享数据都需要使用Java的锁机制控制并发代码产生的问题.本篇总结主要著名Java的锁机制,阐述多线程下如何使用锁机制进行并发线程沟通. 1.并发下的程序异常 先看下下面两个代码,查看异常内容. 异常1:单例模式 1 package com.scl.thread; 2 3 public class SingletonException 4 { 5 public stati

学习 java netty (二) -- ServerBootstrap

前言:我们自己使用java nio开发网络程序是非常繁琐的,netty为我们做好了一切,其中ServerBootstrap是一个启动辅助类,了解它我们就能开发出简单的nio 服务端程序. 不理解Nio中channel和handler等可参考上一篇文章 学习 java netty (一) – java nio ServerBootstrap(): //创建一个ServerBootstrap对象 ServerBootstrap server = new ServerBootstrap; Server

java多线程二之线程同步的三种方法

java多线程的难点是在:处理多个线程同步与并发运行时线程间的通信问题.java在处理线程同步时,常用方法有: 1.synchronized关键字. 2.Lock显示加锁. 3.信号量Semaphore. 线程同步问题引入: 创建一个银行账户Account类,在创建并启动100个线程往同一个Account类实例里面添加一块钱.在没有使用上面三种方法的情况下: 代码: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Java学习之多线程二

1.wait和sleep的区别 sleep: 不释放锁对象, 释放CPU使用权 在休眠的时间内,不能唤醒 wait: 释放锁对象, 释放CPU使用权 在等待的时间内,能唤醒 2.线程的生命周期(五中状态的切换流程)  新建(new Thread) 当创建Thread类的一个实例(对象)时,此线程进入新建状态(未被启动). 例如:Thread  t1=new Thread();  就绪(runnable) 线程已经被启动,正在等待被分配给CPU时间片,也就是说此时线程正在就绪队列中排队等候得到CP

从零开始学习java(一)java基础语法

从公司裸辞一个月,原本工作是做VB的,现在想从事java:在找工作的时候总是要什么项目经验,多少有些不爽,所有语言都有共 通性,我就不信java有这么难?给自己点时间来学习.坚持一个月自学,看看自己的努力究竟有多少用.本次学习从<java核心技术> 第9版开始,每读一章写一篇文章,如果写的不对的话,请指教. "像Java这种功能强大的语言大都不太容易学习",第一章开头就给我一个下马威...你既然这样说,那我就学给你看!第一二章是 讲java的概念,发展的,就此跳过! 1.h

Java多线程——&lt;二&gt;将任务交给线程,线程声明及启动

一.任务和线程 <thinking in java>中专门有一小节中对线程和任务两个概念进行了具体的区分,这也恰好说明任务和线程是有区别的. 正如前文所提到的,任务只是一段代码,一段要达成你目的的代码,这段代码写在哪,怎么写其实无所谓,只是因为你希望java的多线程机制能够识别并调用你编写的任务,所以规定了Runnable接口,让你的任务来实现该接口,把你想做的工作在实现该接口的run方法中实现. 那么,已经定义了任务类,那任务和线程有什么关系呢? java的线程是用来驱动任务执行的,也就是说