Java并发之线程管理(线程基础知识)
2017-04-27 17:16
423 查看
因为书中涵盖的知识点比较全,所以就以书中的目录来学习和记录。当然,学习书中知识的时候自己的思考和实践是最重要的。说到线程,脑子里大概知道是个什么东西,但很多东西都还是懵懵懂懂,这是最可怕的。所以想着细致的来学习一下,就从这本实战开始学习。
疑问点:什么时候会用到多线程?什么情况下使用多线程来解决问题比较合适?
一般来说,java创建线程有两种常用的方式(线程池后面再谈):
1、继承Thread类,并且覆盖run()方法。
2、实现Runnable接口类,使用带参数的Thread构造器来创建Thread对象,参数就是Runnable接口的一个对象。
那么创建完了怎么运行呢?调用run()方法?调用run()方法只是简单的 类对象调用自己的成员方法,那么怎么会开启线程呢?而且每一个线程还有自己的信息(线程名字,线程ID,优先级等)。那么应该是怎么运行呢?答案是调用start()方法。
来个实例更加直观:
继承Thread类
实现Runnable接口
ID:保存线程的唯一标识符
Name:线程名称
Priority:线程对象的优先级,线程优先级从1-10,1是最低优先级,10是最高优先级。
Status:线程状态。在Java中,线程的状态有6种:new(创建)、runnbale(运行)、blocked(阻塞)、waiting(等待)、time waiting和terminated(终止)。状态转换图:
这个图和上面的六种状态有点差异,六种状态是在Thread类中的枚举类State中的六种枚举。
在记忆的时候可以像上图中所示的那样,线程的状态转换图总是会忘掉,可以类比来记忆。线程的物种状态 创建、就绪、运行、阻塞和终止状态 类比开车的过程。
创建--->把车从车库拿出来
就绪--->坐在驾驶位置上,发动,拉手刹
运行--->车启动,开始走
阻塞--->路口红灯需要停车等待
就绪--->红灯停止,拉手刹开车
终止--->到达目的地,停车
例子举的不是很恰当,其实状态转换主要还是就绪、运行和阻塞三个状态的切换。运行状态运行一段时间后因为某些原因转阻塞状态,阻塞状态解除后 不会立马到运行状态而是到就绪状态,只有就绪状态才有可能获取CPU调度然后重新 变为运行状态。
调用interrupt()方法,当前执行的线程就会被中断。
判断一个线程是否被中断了,有两种方式:
interrupted(),检查当前执行的线程是否被中断
isInterrupted():当interrupt()方法被调用时,Thread类中表名线程是否被中断的属性会被设置为true。isInterrupted()方法返回这个属性的值。
推荐使用isInterrupted(),因为interrupted()方法是一个静态方法。
run()方法中捕获异常,打印线程信息
在dirctoryProcess()方法中抛出异常。
休眠指定时间后线程自动恢复
线程休眠的方式有两种:
Thread.sleep(1000);//休眠一秒,其中这里的单位为ms
TimeUnit.SECONDS.sleep(1);//休眠一秒,这里的单位为s
DataSourceLoader睡眠3秒
NetWorkConnectionLoader睡眠6秒
执行Main
输出结果如下:
从结果可以看出:对于main函数线程,如果t1,t2没有调用join函数(),则“
”这句话应该是先打印的,由于t1,t2调用join函数,结果是main要等待t1,t2执行完成后再执行main线程,即使t1,t2睡眠了一段时间。
java还提供了另外两种形式的join()方法:
join(long milliseconds)
join(long milliseconds,long nanos)
当一个线程调用其他线程的join()方法时,如果使用的是第一种join()方式,那么它不必等到被调用线程运行终止,如果参数指定的毫秒时钟已经到达,它将继续运行。例如:thread1中有这样的代码thread2.join(1000),thread1将挂起,知道满足下面两个条件之一:
thread2运行已经完成
时钟已经过去了1000毫秒
当两个条件中的任何一个成立是,join()方法将返回。
第二种join()方法跟第一种相似,只是需要接受毫秒和纳秒两个参数。
其实join()方法在底层调用的就是join(long milliseconds)方法,只不过传递的值是0,即:
join()底层实现有一个wait()方法,这样看就比较好记忆了
举的例子是一个队列中的数据插入和取出:
其中WriteTask负责向队列中插入数据,循环一百次,插入的内容为 时间和 字符串类型的 事件
记录队列中信息的类 Event
取出数据的线程是一个守护线程 ClearTask
最后是执行的Main:
三个写线程,一个取线程,值得注意的是,只有当三个写线程都休眠的时候,取线程才开始工作。
受检异常(非运行时异常)(Checked Exception)
非受检异常(运行时异常)(UnChecked Exception)
由于线程的run()方法不能接受抛出异常,对于受检异常来说,可以在编写程序时捕获,对于非受检异常来说,因为不知道会不会抛出异常,这样就比较麻烦。好在Java提供了一种在线程对象里捕获和处理运行时异常的一种机制。具体如下:
实现用来处理运行时异常的类,这个类实现UnCaughtExceptionHandler接口并且实现这个接口的uncaughtException()方法
在run()方法里面制造运行时异常:
main函数如下:
这样就捕获了运行时异常,运行结果如下:
如果不捕获异常,那么输出结果如下:
设置临界区,保证临界区里的数据一次只能有一个线程访问
为每个线程维护一个该共享数据的局部变量,这样,每个线程各自使用自己的局部变量。ThreadLocal就是这种思路的实现。
使用ThreadLocal的大致思路是:把共享数据包装在ThreadLocal<T>中。包装完成后ThreadLocal提供了取值和设值的方法。提供的方法有:
get():返回此线程局部变量的当前线程副本中的值。
set():将次线程局部变量的当前线程副本中的值设置为指定值。
remove():移除此线程局部变量当前线程的值。
initialValue():返回次线程局部变量的当前线程的“初始值”。线程第一次使用get()方法访问变量时将调用此方法,但如果线程之前调用了set(T)方法,则不会对该线程再调用initialValue()方法。通常,此方法对每个线程最多调用一次,但如果在调用get()后又调用了remove(),则可能再次调用此方法。
使用方式如下:
线程组允许把一个组的线程当做一个单元,对组内线程对象进行访问并操作他们。对一些执行相同任务的线程,只要一个单一的调用,所有这些线程的运行都会被中断。
例子是这样的:创建十个线程并让他们休眠一个随机时间(这段时间比如执行了一个查询),当其中一个线程查找成功的时候,我们将中断其他的9个线程。
疑问点:线程组和线程之间是如何绑定的?
如上所示,这样就绑定了线程searchTask和线程组threadGroup。线程组提供了一些方法,
activeCount():线程组中活动线程的估计数
interrupt():中断此线程中的所有线程
...其他方法以后用到的时候查看API
等待线程组中有线程满足结束条件
中断线程组中的所有线程
对于线程组来说,线程组直接实现了UncaughtExceptionHandler接口,
这样的话,我们就可以声明一个类MyThreadGroup来继承ThreadGroup类,并实现UncaughtExceptionHandler接口唯一的方法:uncaughtException()方法
这样的话以后在使用MyThreadGroup的时候,出现了运行时异常,就可以交给已经实现的uncaughtException()方法处理了。
工厂类就是用来创建对象的,那么如何使用线程工厂类呢?
其实从上面的接口看到,ThreadFactory定义了唯一的方法:newThread(Runnable r);方法需要一个Runnable类型的参数,这个参数就是我们定义的线程类。回顾一下不用线程工厂类的时候创建线程对象时怎么用的?
使用了工厂之后呢?这么写,继承ThreadFactory接口实现newThread()方法,这里创建线程
然后创建线程的时候这么写:
这么写有什么好处呢?创建线程集中在了new Thread()方法中。
更容易修改类,或者改变创建对象的方式
更容易为有限资源创建对象的数目,可以限制一个类型的对象的个数
更容易为创建的对象生成统计数据
疑问点:什么时候会用到多线程?什么情况下使用多线程来解决问题比较合适?
线程的创建和运行
就像学习任何知识一样,要学线程,先得学一下线程是怎么声明(创建)和运行起来的。一般来说,java创建线程有两种常用的方式(线程池后面再谈):
1、继承Thread类,并且覆盖run()方法。
2、实现Runnable接口类,使用带参数的Thread构造器来创建Thread对象,参数就是Runnable接口的一个对象。
那么创建完了怎么运行呢?调用run()方法?调用run()方法只是简单的 类对象调用自己的成员方法,那么怎么会开启线程呢?而且每一个线程还有自己的信息(线程名字,线程ID,优先级等)。那么应该是怎么运行呢?答案是调用start()方法。
来个实例更加直观:
继承Thread类
//创建 public class Thread2 extends Thread{ @Override public void run() { System.out.println("继承Thread类创建线程"); } } //运行 private static void createThread2() { Thread2 t2 = new Thread2(); Thread thread = new Thread(t2); thread.start(); }
实现Runnable接口
//创建 public class Thread1 implements Runnable { @Override public void run() { System.out.println("实现Runnable接口创建线程"); } } //运行 private static void createThread1() { Runnable t1 = new Thread1(); Thread thread = new Thread(t1); thread.start(); }
线程信息的获取和设置
Thread类有一些保存信息的属性,这些属性可以用来标识线程,显示线程状态或者控制线程的优先级。其实这些信息在Thread类中都可以找到,也就是Thread类的一些成员变量。ID:保存线程的唯一标识符
Name:线程名称
Priority:线程对象的优先级,线程优先级从1-10,1是最低优先级,10是最高优先级。
Status:线程状态。在Java中,线程的状态有6种:new(创建)、runnbale(运行)、blocked(阻塞)、waiting(等待)、time waiting和terminated(终止)。状态转换图:
这个图和上面的六种状态有点差异,六种状态是在Thread类中的枚举类State中的六种枚举。
public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; }
在记忆的时候可以像上图中所示的那样,线程的状态转换图总是会忘掉,可以类比来记忆。线程的物种状态 创建、就绪、运行、阻塞和终止状态 类比开车的过程。
创建--->把车从车库拿出来
就绪--->坐在驾驶位置上,发动,拉手刹
运行--->车启动,开始走
阻塞--->路口红灯需要停车等待
就绪--->红灯停止,拉手刹开车
终止--->到达目的地,停车
例子举的不是很恰当,其实状态转换主要还是就绪、运行和阻塞三个状态的切换。运行状态运行一段时间后因为某些原因转阻塞状态,阻塞状态解除后 不会立马到运行状态而是到就绪状态,只有就绪状态才有可能获取CPU调度然后重新 变为运行状态。
线程的中断
就是结束正在运行的线程。中断方式有以下几种:调用interrupt()方法,当前执行的线程就会被中断。
task.interrupt();
判断一个线程是否被中断了,有两种方式:
interrupted(),检查当前执行的线程是否被中断
isInterrupted():当interrupt()方法被调用时,Thread类中表名线程是否被中断的属性会被设置为true。isInterrupted()方法返回这个属性的值。
推荐使用isInterrupted(),因为interrupted()方法是一个静态方法。
public static boolean interrupted() { return currentThread().isInterrupted(true); }
线程中断的控制
如果线程实现了复杂的算法那并且分布在几个方法中,或者线程中有递归调用的方法,如何去中断线程?因为直接 调用interrupt()方法不能立竿见影。java还提供了InterruptException异常。当检查到线程中断的时候,就抛出异常,然后在run()方法中捕获并处理这个异常。run()方法中捕获异常,打印线程信息
@Override public void run() { File file = new File(initPath); if (file.isDirectory()) { try { dirctoryProcess(file); } catch (InterruptedException e) { System.out.printf("%s:the search has been interrupted", Thread.currentThread().getName()); } } }
在dirctoryProcess()方法中抛出异常。
private void dirctoryProcess(File file) throws InterruptedException { File[] list = file.listFiles(); if (list != null) { for (int i = 0; i < list.length; i++) { if (list[i].isDirectory()) { dirctoryProcess(list[i]); } else { fileProcess(list[i]); } } } if (Thread.interrupted()) { throw new InterruptedException(); } }
线程的休眠和恢复
java里面提供了sleep()方法来休眠线程。需要掌握的知识点:休眠指定时间后线程自动恢复
线程休眠的方式有两种:
Thread.sleep(1000);//休眠一秒,其中这里的单位为ms
TimeUnit.SECONDS.sleep(1);//休眠一秒,这里的单位为s
等待线程的终止(join())
当一个线程对象的join()方法被调用时,调用它的线程将被挂起,直到这个线程对象完成它的任务。意思就是:如果在线程B中线程A调用了join()方法,那么只有A线程执行完毕后,才会接着执行线程B下面的代码。DataSourceLoader睡眠3秒
public class DataSourceLoader implements Runnable { @Override public void run() { System.out.printf("Begining data sources loading: %s\n",new Date()); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } System.out.printf("Data Sources loading has finised:%s\n",new Date()); } }
NetWorkConnectionLoader睡眠6秒
public class NetWorkConnectionLoader implements Runnable { @Override public void run() { System.out.printf("Begining data sources loading: %s\n",new Date()); try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); } System.out.printf("Data Sources loading has finised:%s\n",new Date()); } }
执行Main
public class Main { public static void main(String[] args) { DataSourceLoader dsLoader = new DataSourceLoader(); Thread t1 = new Thread(dsLoader,"DataSourceThread"); NetWorkConnectionLoader ncLoader = new NetWorkConnectionLoader(); Thread t2 = new Thread(ncLoader,"NetWorkConnectionThread"); t1.start(); t2.start(); try { t1.join(); t2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.printf("Main: Configuration has been loaded:%s\n",new Date()); } }
输出结果如下:
Begining data sources loading: Tue Apr 25 14:46:39 CST 2017 Begining data sources loading: Tue Apr 25 14:46:39 CST 2017 Data Sources loading has finised:Tue Apr 25 14:46:42 CST 2017 NetWorkConnectionLoader loading has finised:Tue Apr 25 14:46:45 CST 2017 Main: Configuration has been loaded:Tue Apr 25 14:46:45 CST 2017
从结果可以看出:对于main函数线程,如果t1,t2没有调用join函数(),则“
Main: Configuration has been loaded:Tue Apr 25 14:46:45 CST 2017
”这句话应该是先打印的,由于t1,t2调用join函数,结果是main要等待t1,t2执行完成后再执行main线程,即使t1,t2睡眠了一段时间。
java还提供了另外两种形式的join()方法:
join(long milliseconds)
join(long milliseconds,long nanos)
当一个线程调用其他线程的join()方法时,如果使用的是第一种join()方式,那么它不必等到被调用线程运行终止,如果参数指定的毫秒时钟已经到达,它将继续运行。例如:thread1中有这样的代码thread2.join(1000),thread1将挂起,知道满足下面两个条件之一:
thread2运行已经完成
时钟已经过去了1000毫秒
当两个条件中的任何一个成立是,join()方法将返回。
第二种join()方法跟第一种相似,只是需要接受毫秒和纳秒两个参数。
其实join()方法在底层调用的就是join(long milliseconds)方法,只不过传递的值是0,即:
public final void join() throws InterruptedException { join(0); }
join()底层实现有一个wait()方法,这样看就比较好记忆了
public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (millis == 0) { while (isAlive()) { wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } }
守护线程的创建和运行
守护线程(Daemon):这种线程的优先级很低,通常来说,当一个应用程序中没有其他线程运行的时候,守护线程才运行(这个是守护线程的特性)。当守护线程是程序中唯一运行的线程时,守护线程执行结束后,JVM也就结束了。一个典型的守护线程是Java的垃圾回收器。举的例子是一个队列中的数据插入和取出:
其中WriteTask负责向队列中插入数据,循环一百次,插入的内容为 时间和 字符串类型的 事件
public class WriterTask implements Runnable { Deque<Event> deque; public WriterTask (Deque<Event> deque){ this.deque=deque; } @Override public void run() { // Writes 100 events for (int i=1; i<100; i++) { // Creates and initializes the Event objects Event event=new Event(); event.setDate(new Date()); event.setEvent(String.format("The thread %s has generated an event",Thread.currentThread().getId())); // Add to the data structure deque.addFirst(event); try { // Sleeps during one second TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } } }
记录队列中信息的类 Event
public class Event { private Date date; private String event; public Date getDate() { return date; } public void setDate(Date date) { this.date = date; } public String getEvent() { return event; } public void setEvent(String event) { this.event = event; } }
取出数据的线程是一个守护线程 ClearTask
public class CleanerTask extends Thread { private Deque<Event> deque; public CleanerTask(Deque<Event> deque) { this.deque = deque; // Establish that this is a Daemon Thread setDaemon(true); } @Override public void run() { while (true) { Date date = new Date(); clean(date); } } private void clean(Date date) { long difference; boolean delete; if (deque.size()==0) { return; } delete=false; do { Event e = deque.getLast(); difference = date.getTime() - e.getDate().getTime(); if (difference > 10000) { System.out.printf("Cleaner: %s\n",e.getEvent()); deque.removeLast(); delete=true; } } while (difference > 10000); if (delete){ System.out.printf("Cleaner: Size of the queue: %d\n",deque.size()); } } }
最后是执行的Main:
public static void main(String[] args) { Deque<Event> deque=new ArrayDeque<Event>(); WriterTask writer=new WriterTask(deque); for (int i=0; i<3; i++){ Thread thread=new Thread(writer); thread.start(); } CleanerTask cleaner=new CleanerTask(deque); cleaner.start(); }
三个写线程,一个取线程,值得注意的是,只有当三个写线程都休眠的时候,取线程才开始工作。
线程中不可控异常的处理
java中异常Exception下面分两类,受检异常(非运行时异常)(Checked Exception)
非受检异常(运行时异常)(UnChecked Exception)
由于线程的run()方法不能接受抛出异常,对于受检异常来说,可以在编写程序时捕获,对于非受检异常来说,因为不知道会不会抛出异常,这样就比较麻烦。好在Java提供了一种在线程对象里捕获和处理运行时异常的一种机制。具体如下:
实现用来处理运行时异常的类,这个类实现UnCaughtExceptionHandler接口并且实现这个接口的uncaughtException()方法
public class ExceptionHandler implements UncaughtExceptionHandler { @Override public void uncaughtException(Thread t, Throwable e) { System.out.printf("An exception has been captured\n"); System.out.printf("Thread: %s\n",t.getId()); System.out.printf("Exception: %s: %s\n",e.getClass().getName(),e.getMessage()); System.out.printf("Stack Trace: \n"); e.printStackTrace(System.out); System.out.printf("Thread status: %s\n",t.getState()); } }
在run()方法里面制造运行时异常:
@Override public void run() { // The next instruction always throws and exception int numero=Integer.parseInt("TTT"); }
main函数如下:
public static void main(String[] args) { Task task=new Task(); Thread thread=new Thread(task); thread.setUncaughtExceptionHandler(new ExceptionHandler()); thread.start(); try { thread.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.printf("Thread has finished\n"); }
这样就捕获了运行时异常,运行结果如下:
An exception has been captured Thread: 10 Exception: java.lang.NumberFormatException: For input string: "TTT" Stack Trace: java.lang.NumberFormatException: For input string: "TTT" at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65) at java.lang.Integer.parseInt(Integer.java:580) at java.lang.Integer.parseInt(Integer.java:615) at com.packtpub.java7.concurrency.chapter1.recipe8.task.Task.run(Task.java:16) at java.lang.Thread.run(Thread.java:745) Thread status: RUNNABLE Thread has finished
如果不捕获异常,那么输出结果如下:
Exception in thread "Thread-0" java.lang.NumberFormatException: For input string: "TTT" at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65) at java.lang.Integer.parseInt(Integer.java:580) at java.lang.Integer.parseInt(Integer.java:615) at com.packtpub.java7.concurrency.chapter1.recipe8.task.Task.run(Task.java:16) at java.lang.Thread.run(Thread.java:745) Thread has finished
线程局部变量的使用(ThreadLocal)
多线程中,共享数据是不安全的。为了保证共享数据的安全性有两种思路:设置临界区,保证临界区里的数据一次只能有一个线程访问
为每个线程维护一个该共享数据的局部变量,这样,每个线程各自使用自己的局部变量。ThreadLocal就是这种思路的实现。
使用ThreadLocal的大致思路是:把共享数据包装在ThreadLocal<T>中。包装完成后ThreadLocal提供了取值和设值的方法。提供的方法有:
get():返回此线程局部变量的当前线程副本中的值。
set():将次线程局部变量的当前线程副本中的值设置为指定值。
remove():移除此线程局部变量当前线程的值。
initialValue():返回次线程局部变量的当前线程的“初始值”。线程第一次使用get()方法访问变量时将调用此方法,但如果线程之前调用了set(T)方法,则不会对该线程再调用initialValue()方法。通常,此方法对每个线程最多调用一次,但如果在调用get()后又调用了remove(),则可能再次调用此方法。
使用方式如下:
public class SafeTask implements Runnable { private static ThreadLocal<Date> startDate= new ThreadLocal<Date>() { protected Date initialValue(){ return new Date(); } }; @Override public void run() { // Writes the start date System.out.printf("Starting Thread: %s : %s\n",Thread.currentThread().getId(),startDate.get()); try { TimeUnit.SECONDS.sleep((int)Math.rint(Math.random()*10)); } catch (InterruptedException e) { e.printStackTrace(); } // Writes the start date System.out.printf("Thread Finished: %s : %s\n",Thread.currentThread().getId(),startDate.get()); } }
线程的分组
Java提供了ThreadGroup类表示一组线程。线程组可以包含线程对象,也可以包含其他的线程组对象,它是一个树形结构。线程组允许把一个组的线程当做一个单元,对组内线程对象进行访问并操作他们。对一些执行相同任务的线程,只要一个单一的调用,所有这些线程的运行都会被中断。
例子是这样的:创建十个线程并让他们休眠一个随机时间(这段时间比如执行了一个查询),当其中一个线程查找成功的时候,我们将中断其他的9个线程。
疑问点:线程组和线程之间是如何绑定的?
ThreadGroup threadGroup = new ThreadGroup("Searcher"); SearchTask searchTask=new SearchTask(result); for (int i=0; i<5; i++) { Thread thread=new Thread(threadGroup, searchTask); thread.start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } }
如上所示,这样就绑定了线程searchTask和线程组threadGroup。线程组提供了一些方法,
activeCount():线程组中活动线程的估计数
interrupt():中断此线程中的所有线程
...其他方法以后用到的时候查看API
等待线程组中有线程满足结束条件
private static void waitFinish(ThreadGroup threadGroup) { while (threadGroup.activeCount()>9) { try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } }
中断线程组中的所有线程
threadGroup.interrupt();
线程组中不可控异常的处理
在线程中处理不可控异常,上面的做法是编写一个类继承UncaughtExceptionHandler接口,然后使用thread.setUncaughtExceptionHandler(UncaughtExceptionHandler eh)来实现。因为Thread没有继承UncaughtExceptionHandler接口,而是提供了一个方法:public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) { checkAccess(); uncaughtExceptionHandler = eh; }
对于线程组来说,线程组直接实现了UncaughtExceptionHandler接口,
class ThreadGroup implements Thread.UncaughtExceptionHandler {
这样的话,我们就可以声明一个类MyThreadGroup来继承ThreadGroup类,并实现UncaughtExceptionHandler接口唯一的方法:uncaughtException()方法
public class MyThreadGroup extends ThreadGroup { public MyThreadGroup(String name) { super(name); } @Override public void uncaughtException(Thread t, Throwable e) { } }
这样的话以后在使用MyThreadGroup的时候,出现了运行时异常,就可以交给已经实现的uncaughtException()方法处理了。
使用工厂类创建线程
Java提供了ThreadFactory接口,这个接口实现了线程对象工厂。public interface ThreadFactory { Thread newThread(Runnable r); }
工厂类就是用来创建对象的,那么如何使用线程工厂类呢?
其实从上面的接口看到,ThreadFactory定义了唯一的方法:newThread(Runnable r);方法需要一个Runnable类型的参数,这个参数就是我们定义的线程类。回顾一下不用线程工厂类的时候创建线程对象时怎么用的?
public class Thread1 implements Runnable{ @override public void run(){ } } Runnable t1 = new Thread1(); Thread t = new Thread(t1); t.start();
使用了工厂之后呢?这么写,继承ThreadFactory接口实现newThread()方法,这里创建线程
public class MyThreadFactory implements ThreadFactory { @Override public Thread newThread(Runnable r) { Thread t=new Thread(r,"thread_name"); return t; } }
然后创建线程的时候这么写:
Task task = new Task(); 2 Thread thread=factory.newThread(task);
这么写有什么好处呢?创建线程集中在了new Thread()方法中。
更容易修改类,或者改变创建对象的方式
更容易为有限资源创建对象的数目,可以限制一个类型的对象的个数
更容易为创建的对象生成统计数据
相关文章推荐
- Java线程并发控制基础知识
- Java 并发编程之美:线程相关的基础知识
- Java高效并发-1 java线程基础知识
- Java并发基础知识(内存栅栏+volatile+synchronized详解+java锁优化+wait notify+AbstractQueuedSynchronizer详解+线程中断)
- Java并发(基础知识)—— 创建、运行以及停止一个线程
- java并发线程的基础知识(一)
- Java并发编程之线程管理(基本线程同步5)
- Java并发之线程管理
- java基础加强6--线程并发库
- java线程基础知识
- Java并发总结(一):线程基础
- Java基础之线程——管理线程同步方法(BankOperation2)
- Java并发编程之线程管理(基本线程同步4)
- java基础知识10(TCP:客户端并发上传图片)
- java多线程并发(二)(线程基础)
- Java并发编程之线程管理(基本线程同步2)
- Java并发总结(一):线程基础
- Java基础之线程——管理线程同步代码块(BankOperation4)
- java多线程并发(一)(线程基础)
- java 高并发 基础知识