主题:
- 线程的未捕获异常
- 线程工厂
- 线程暂停
- 线程池
线程的未捕获异常
在线程异常的时候,多线程运行不能按照顺序执行过程中捕获异常的方式来处理异常,异常会被直接抛出到控制台(由于线程的本质,使得你不能捕获从线程中逃逸的异常。一旦异常逃逸出任务的run方法,它就会向外传播到控制台,除非你采用特殊的形式捕获这种异常。)
如下例:
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadException implements Runnable{ @Override public void run() { throw new RuntimeException(); } //现象:控制台打印出异常信息,并运行一段时间后才停止 public static void main(String[] args){ //就算把线程的执行语句放到try-catch块中也无济于事 try{ ExecutorService exec = Executors.newCachedThreadPool(); exec.execute(new ThreadException()); }catch(RuntimeException e){ System.out.println("Exception has been handled!"); } } }
使用UncaughtExceptionHandler可以捕获异常,并且重启新的线程来完成redo工作,这个例子里是重新初始化:init();
import io.github.viscent.mtia.util.Debug; import io.github.viscent.mtia.util.Tools; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.logging.Level; import java.util.logging.Logger; public class ThreadMonitorDemo { volatile boolean inited = false; static int threadIndex = 0; final static Logger LOGGER = Logger.getAnonymousLogger(); final BlockingQueue<String> channel = new ArrayBlockingQueue<String>(100); public static void main(String[] args) throws InterruptedException { ThreadMonitorDemo demo = new ThreadMonitorDemo(); demo.init(); for (int i = 0; i < 100; i++) { demo.service("test-" + i); } Thread.sleep(2000); System.exit(0); } public synchronized void init() { if (inited) { return; } Debug.info("init..."); WokrerThread t = new WokrerThread(); t.setName("Worker0-" + threadIndex++); // 为线程t关联一个UncaughtExceptionHandler t.setUncaughtExceptionHandler(new ThreadMonitor()); t.start(); inited = true; } public void service(String message) throws InterruptedException { channel.put(message); } private class ThreadMonitor implements Thread.UncaughtExceptionHandler { @Override public void uncaughtException(Thread t, Throwable e) { Debug.info("Current thread is `t`:%s, it is still alive:%s", Thread.currentThread() == t, t.isAlive()); // 将线程异常终止的相关信息记录到日志中 String threadInfo = t.getName(); LOGGER.log(Level.SEVERE, threadInfo + " terminated:", e); // 创建并启动替代线程 LOGGER.info("About to restart " + threadInfo); // 重置线程启动标记 inited = false; init(); } }// 类ThreadMonitor定义结束 private class WokrerThread extends Thread { @Override public void run() { Debug.info("Do something important..."); String msg; try { for (;;) { msg = channel.take(); process(msg); } } catch (InterruptedException e) { // 什么也不做 } } private void process(String message) { Debug.info(message); // 模拟随机性异常 int i = (int) (Math.random() * 100); if (i < 2) { throw new RuntimeException("test"); } Tools.randomPause(100); } }// 类ThreadMonitorDemo定义结束 }
线程工厂
工厂设计模式是java中最常用的设计模式之一。它是一种创造性的模式,可用于开发一个或多个类需要的对象。有了这个工厂,我们可以集中创建对象。
创造逻辑的集中给我们带来了一些优势,例如:
很容易更改所创建对象的类或创建这些对象的方式。
很容易为有限的资源限制对象的创建。例如,我们只能有N个类型的对象。
很容易生成关于对象创建的统计数据。
线程工厂实际上是一个接口:
public interface ThreadFactory { Thread newThread(Runnable r); }
实际上就是使用工厂模式在创建线程的时候统一操作。
ThreadPoolExecutor具有ThreadFactory作为参数的构造函数。执行器创建新线程时使用此工厂。
使用ThreadFactory,可以自定义由executor创建的线程,以便它们具有正确的线程名、优先级、设置为daemon等。
import java.util.ArrayList; import java.util.Date; import java.util.Iterator; import java.util.List; import java.util.concurrent.ThreadFactory; import java.util.concurrent.TimeUnit; public class CustomThreadFactory implements ThreadFactory { private int counter; private String name; private List<String> stats; public CustomThreadFactory(String name) { counter = 1; this.name = name; stats = new ArrayList<String>(); } @Override public Thread newThread(Runnable runnable) { Thread t = new Thread(runnable, name + "-Thread_" + counter); t.setDaemon(true);//守護線程 t.setPriority(Thread.MAX_PRIORITY );//統一設置優先級 counter++; stats.add(String.format("Created thread %d with name %s on %s \n", t.getId(), t.getName(), new Date())); return t; } public String getStats() { StringBuffer buffer = new StringBuffer(); Iterator<String> it = stats.iterator(); while (it.hasNext()) { buffer.append(it.next()); } return buffer.toString(); } public static void main(String[] args) { CustomThreadFactory factory = new CustomThreadFactory("CustomThreadFactory"); Task task = new Task(); Thread thread; System.out.printf("Starting the Threads\n\n"); for (int i = 1; i <= 10; i++) { thread = factory.newThread(task); thread.start(); } System.out.printf("All Threads are created now\n\n"); System.out.printf("Give me CustomThreadFactory stats:\n\n" + factory.getStats()); } } class Task implements Runnable { @Override public void run() { try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } } }
线程暂停
有3种暂停的方式
- 1、自己进入睡眠暂停;
- 2、使用CyclicBarrier,在某个阶段,多个线程统一暂停(await()),这里有介绍https://www.cnblogs.com/starcrm/p/12469364.html
- 3、使用Condition信号暂停;
第一种情况的例子:
try { Thread.sleep(2000); } catch (InterruptedException ex) { }
第三种情况的例子,通过主线程进行控制:
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class PauseControl extends ReentrantLock { private static final long serialVersionUID = 176912639934052187L; // 线程暂挂标志 private volatile boolean suspended = false; private final Condition condSuspended = newCondition(); /** * 暂停线程 */ public void requestPause() { suspended = true; } /** * 恢复线程 */ public void proceed() { lock(); try { suspended = false; condSuspended.signalAll(); } finally { unlock(); } } /** * 当前线程仅在线程暂挂标记不为true的情况下才执行指定的目标动作。 * * @targetAction 目标动作 * @throws InterruptedException */ public void pauseIfNeccessary(Runnable targetAction) throws InterruptedException { lock(); try { while (suspended) { condSuspended.await(); } targetAction.run(); } finally { unlock(); } } } import java.util.Scanner; public class ThreadPauseDemo { final static PauseControl pc = new PauseControl(); public static void main(String[] args) { final Runnable action = new Runnable() { @Override public void run() { Debug.info("Master,I'm working..."); Tools.randomPause(300); } }; Thread slave = new Thread() { @Override public void run() { try { for (;;) { pc.pauseIfNeccessary(action); } } catch (InterruptedException e) { // 什么也不做 } } }; slave.setDaemon(true); slave.start(); askOnBehaveOfSlave(); } static void askOnBehaveOfSlave() { String answer; int minPause = 2000; try (Scanner sc = new Scanner(System.in)) { for (;;) { Tools.randomPause(8000, minPause); pc.requestPause(); Debug.info("Master,may I take a rest now?%n"); Debug.info("%n(1) OK,you may take a rest%n" + "(2) No, Keep working!%nPress any other key to quit:%n"); answer = sc.next(); if ("1".equals(answer)) { pc.requestPause(); Debug.info("Thank you,my master!"); minPause = 8000; } else if ("2".equals(answer)) { Debug.info("Yes,my master!"); pc.proceed(); minPause = 2000; } else { break; } }// for结束 }// try结束 Debug.info("Game over!"); } }
线程池
线程池是预初始化线程的集合。一般来说,集合的大小是固定的,但不是强制的。它有助于使用相同的线程执行N个任务。如果有比线程更多的任务,那么任务需要在队列结构(FIFO–先进先出)中等待。
当任何线程完成其执行时,它都可以从队列中获取新任务并执行它。所有任务完成后,线程将保持活动状态,并等待线程池中的更多任务。
线程池的意义在于:
1、减少在创建和销毁线程上所花的时间以及系统资源的开销,提升任务执行性能。
2、控制进程中线程数量的峰值,避免系统开销过大。
通过线程池,可创建一定数量的线程,并由线程池管理。在需要执行任务时,直接使用其中的线程。任务执行完成后,线程保留,并可用于执行下一个任务。如果任务比线程多,则等待线程空闲。
直接构建ThreadPoolExecutor
我们可以使用以下构造函数实例化ThreadPoolExecutor,其中ThreadFactory和RejectedExecutionHandler是可选参数,默认值分别是Executors.defaultThreadFactory()和ThreadPoolExecutor.AbortPolicy
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
- int corePoolSize : 定义核心池大小。对于每个新请求,即使池中有空闲线程,也会根据核心池大小创建一个新线程
- int maximumPoolSize : 当发出请求并且核心池大小中的所有线程都忙时,将创建一个新线程,直到它达到最大池大小。在最大池大小之后,所有新请求都将进入队列。
- long keepAliveTime: 这是等待空闲线程死亡的时间。只有当线程计数大于核心池大小且小于或等于最大核心池大小时,空闲线程才会在keepAliveTime之后死亡。
- TimeUnit unit: keepAliveTime参数的时间单位
- BlockingQueue<Runnable> workQueue : BlockingQueue是一个队列,如果一个线程想要获取一个元素,并且队列是空的,那么线程将被阻塞,并等待元素在队列中可用。以同样的方式添加元素时,如果队列中没有空间,线程将被阻塞并等待获得可用空间。
- ThreadFactory threadFactory : 这是可选参数。传递用户定义的ThreadFactory
- RejectedExecutionHandler handler: 这是可选参数。在两种情况下,ThreadPoolExecutor.execute()可以拒绝新任务。
- 1、执行器已关闭。
- 2、超过工作队列容量和最大线程使用有限的界限,即它们是饱和时
- ThreadPoolExecutor.AbortPolicy:它中止任务并始终抛出RejectedExecutionException。
- ThreadPoolExecutor.CallerRunsPolicy:它自己(客户端)执行被拒绝的任务。
- ThreadPoolExecutor.DiscardPolicy:删除任务。
- ThreadPoolExecutor.DiscardOldestPolicy:当ThreadPoolExecutor.execute()由于工作队列的有限边界和最大限制而拒绝任务时,此策略只将任务放在工作队列的头。
默认策略是ThreadPoolExecutor.AbortPolicy。
例子
import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class ThreadPoolExecutorDemoOne { public static void main(final String[] args) throws Exception { final ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3, 100, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new ThreadPoolExecutor.CallerRunsPolicy()); executor.execute(new BookReader("Ramayan")); executor.execute(new BookReader("Mahabharat")); executor.execute(new BookReader("Veda")); System.out.println("Old Max Pool Size:"+ executor.getMaximumPoolSize()); executor.setMaximumPoolSize(4); System.out.println("New Max Pool Size:"+ executor.getMaximumPoolSize()); executor.shutdown(); } } class BookReader implements Runnable { private String bookName; public BookReader(String bookName) { this.bookName = bookName; } @Override public void run() { for(int i = 0; i<5; i++) { System.out.println("Reading book: "+ bookName); try { Thread.sleep(200); } catch (InterruptedException ex) { System.out.println("I'm interrupted"); } } } }
使用Executors工厂方法创建ThreadPoolExecutor实例
可以使用Executors类提供的静态工厂方法来获取ThreadPoolExecutor,而不是直接使用上述构造函数之一创建ThreadPoolExecutor的实例。
- newCachedThreadPool()–创建一个线程池,该线程池根据需要创建新线程,提供无容量的阻塞队列 SynchronousQueue,因此任务提交之后,将会创建新的线程执行;线程空闲超过60s将会销毁 。
- newCachedThreadPool(ThreadFactory ThreadFactory)–创建一个线程池,该线程池根据需要创建新线程,但在可用时将重用先前构造的线程,并在需要时使用提供的ThreadFactory创建新线程。
- newFixedThreadPool(int nThreads)–创建一个线程池,该线程池重用在共享的无边界队列上操作的固定数量的线程。构造一个固定线程数目的线程池,配置的corePoolSize与maximumPoolSize大小相同,同时使用了一个无界LinkedBlockingQueue存放阻塞任务,因此多余的任务将存在再阻塞队列,不会由RejectedExecutionHandler处理
- newFixedThreadPool(int nThreads,ThreadFactory ThreadFactory)–创建一个线程池,该线程池重用在共享的无边界队列上操作的固定数量的线程,在需要时使用提供的ThreadFactory创建新线程。
- newSingleThreadExecutor()–创建一个执行器,该执行器使用一个工作线程并在无限队列上操作,由一个线程串行执行任务。
- newSingleThreadExecutor(ThreadFactory ThreadFactory)–创建一个执行器,该执行器使用一个在无限队列上操作的工作线程,并在需要时使用提供的ThreadFactory创建一个新线程。
Executors的例子
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ExecutorExp { public static void main(String[] args) { ExecutorService executor = Executors.newSingleThreadExecutor(); for(int i = 0; i < 4; i++) { executor.execute(new VoidTask()); } executor.shutdown(); } } class VoidTask implements Runnable{ @Override public void run() { System.out.println("Executing task (thread name)- " + Thread.currentThread().getName()); // delay to keep the thread busy // so that pool is used try { Thread.sleep(500); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
newFixedThreadPool.
此方法创建一个线程池,该线程池重用在共享的无界队列上操作的固定数量的线程。使用此方法时,内部Executors类使用以下参数创建ThreadPoolExecutor实例:
new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
实例
public class ExecutorExp { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(2); for(int i = 0; i < 4; i++) { executor.execute(new VoidTask()); } executor.shutdown(); } } class VoidTask implements Runnable{ @Override public void run() { System.out.println("Executing task (thread name)- " + Thread.currentThread().getName()); // delay to keep the thread busy // so that pool is used try { Thread.sleep(500); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
newCachedThreadPool
该线程池根据需要创建新线程,但在以前构造的线程可用时将重用它们。使用此方法时,内部Executors类使用以下参数创建ThreadPoolExecutor实例
new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
实例
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
public class ExecutorExp { public static void main(String[] args) { ExecutorService executor = Executors.newCachedThreadPool(); for(int i = 0; i < 40; i++) { executor.execute(new VoidTask()); } executor.shutdown(); } } class VoidTask implements Runnable{ @Override public void run() { System.out.println("Executing task (thread name)- " + Thread.currentThread().getName()); // delay to keep the thread busy // so that pool is used try { Thread.sleep(500); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } //为了验证最大线程数Integer.MAX_VALUE,我们看一下结果,感觉这个 Executing task (thread name)- pool-1-thread-3 Executing task (thread name)- pool-1-thread-4 Executing task (thread name)- pool-1-thread-1 Executing task (thread name)- pool-1-thread-2 Executing task (thread name)- pool-1-thread-7 Executing task (thread name)- pool-1-thread-8 Executing task (thread name)- pool-1-thread-5 Executing task (thread name)- pool-1-thread-6 Executing task (thread name)- pool-1-thread-11 Executing task (thread name)- pool-1-thread-10 Executing task (thread name)- pool-1-thread-9 Executing task (thread name)- pool-1-thread-12 Executing task (thread name)- pool-1-thread-15 Executing task (thread name)- pool-1-thread-13 Executing task (thread name)- pool-1-thread-14 Executing task (thread name)- pool-1-thread-16 Executing task (thread name)- pool-1-thread-17 Executing task (thread name)- pool-1-thread-18 Executing task (thread name)- pool-1-thread-19 Executing task (thread name)- pool-1-thread-20 Executing task (thread name)- pool-1-thread-21 Executing task (thread name)- pool-1-thread-23 Executing task (thread name)- pool-1-thread-22 Executing task (thread name)- pool-1-thread-24 Executing task (thread name)- pool-1-thread-25 Executing task (thread name)- pool-1-thread-26 Executing task (thread name)- pool-1-thread-27 Executing task (thread name)- pool-1-thread-28 Executing task (thread name)- pool-1-thread-29 Executing task (thread name)- pool-1-thread-30 Executing task (thread name)- pool-1-thread-31 Executing task (thread name)- pool-1-thread-32 Executing task (thread name)- pool-1-thread-33 Executing task (thread name)- pool-1-thread-34 Executing task (thread name)- pool-1-thread-35 Executing task (thread name)- pool-1-thread-36 Executing task (thread name)- pool-1-thread-37 Executing task (thread name)- pool-1-thread-39 Executing task (thread name)- pool-1-thread-38 Executing task (thread name)- pool-1-thread-40
构造有定时功能的线程池
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize); } public static ScheduledExecutorService newScheduledThreadPool( int corePoolSize, ThreadFactory threadFactory) { return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory); } public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory) { super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, new DelayedWorkQueue(), threadFactory); }
实例
import java.util.Date; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class ScheduledThreadPoolExecutorExample { public static void main(String[] args) { ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(2); DelayTask task = new DelayTask("Repeat Task"); System.out.println("Created : " + task.getName()); executor.scheduleWithFixedDelay(task, 2, 2, TimeUnit.SECONDS); } } class DelayTask implements Runnable { private String name; public DelayTask(String name) { this.name = name; } public String getName() { return name; } public void run() { System.out.println("Executing : " + name + ", Current Seconds : " + new Date().getSeconds()); } }
Callable接口
Callable接口与Runnable接口相似,都用于定义线程的可执行任务。Callable在JDK 1.5引入,与Runnable相比,有三个优势:
1、可以在任务中抛出异常
2、可以终止任务
3、可以获取任务的返回值
这时候就会出现一个问题:新旧两种定义线程任务的方式,怎么前后兼容呢?
这时候就出现了FutureTask这个类
public class FutureTask<V> implements RunnableFuture<V> { // 封装实现Callable接口的任务 public FutureTask(Callable<V> callable) { //...} // 封装实现Runnable接口的任务,result是返回值,在任务完成后赋值(futureTask.get()会返回这个值)。 public FutureTask(Runnable runnable, V result) {//...} } public interface RunnableFuture<V> extends Runnable, Future<V> { void run(); }
使用FutureTask包装Runnable
import java.util.concurrent.Callable; public class MyRunnable implements Runnable { @Override public void run() { for(int i=0;i<3;i++){ System.out.println("num="+(i+1)); } } } import java.util.concurrent.FutureTask; public class Test { public static void main(String[] agrs){ String str = "default value"; FutureTask<String> task = new FutureTask<String>(new MyRunnable(),str); new Thread(task).start(); System.out.println(getFutureValue(task)); System.out.println("after task.get()!"); } public static String getFutureValue(FutureTask<String> task){ String str = "default value1"; try{ str = task.get(); }catch (Exception e){ System.out.println("task is canceled!"); } return str; } }
线程池管理线程任务
通过ExecutorService,可以使用4个方法执行线程任务。其中3个执行Runnable任务:
其中3个执行Runnable任务:
- void execute(Runnable command);
- < T > Future< T > submit(Runnable task, T result);
- Future< ? > submit(Runnable task);
1个执行Callable任务:
- < T > Future< T > submit(Callable< T > task); //执行Callable任务
只有通过submit方法执行的线程任务,才能获取到Future,才能通过Future管理线程。
示例代码如下:
import java.util.concurrent.Callable; public class MyCallable implements Callable<String> { @Override public String call() throws Exception{ int num=0; for(int i=0;i<3;i++){ num++; Thread.sleep(100); System.out.println("num="+num); } return String.valueOf(num); } } import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class Test { public static void main(String[] agrs){ ExecutorService service = Executors.newFixedThreadPool(2); Future<String> future = service.submit(new MyCallable()); // 使用submit()执行Callable任务 System.out.println("执行结果:"+getFutureValue(future)); System.out.println("after task.get()!"); service.shutdown(); } public static String getFutureValue(Future<String> task){ String str = "default value"; try{ str = task.get(); }catch (Exception e){ System.out.println("task is canceled!"); } return str; } }
Executor和ExecutorService的区别
见图
Executors 是工厂helper类,包含几个用于为您创建预配置线程池实例的方法。这些类是一个很好的线程池起点。如果不需要应用任何自定义微调,请使用它。
Executor和ExecutorService接口用于在Java中处理不同的线程池实现。通常,您应该保持代码与线程池的实际实现分离,并在整个应用程序中使用这些接口。
Executor接口有一个execute方法来提交Runnable实例以供执行。