更加强健的线程模型，解决线程卡死，退出异常情况

线程模型

 1 package net.sz;
 2 
 3 import java.util.Random;
 4 import java.util.concurrent.ConcurrentLinkedQueue;
 5 import org.apache.log4j.Logger;
 6 
 7 /**
 8  *
 9  * <br>
10  * author 失足程序员<br>
11  * mail 492794628@qq.com<br>
12  * phone 13882122019<br>
13  */
14 public class ThreadTest implements Runnable {
15 
16     private static final Logger log = Logger.getLogger(ThreadTest.class);
17 
18     public ConcurrentLinkedQueue<Runnable> runs = new ConcurrentLinkedQueue<>();
19 
20     Runnable run;
21     long lastTimer;
22 
23     @Override
24     public void run() {
25         while (true) {
26             run = null;
27             lastTimer = 0;
28             try {
29                 /*如果队列为空强制线程等待*/
30                 while (runs.isEmpty()) {
31                     synchronized (runs) {
32                         /*直到收到通知消息*/
33                         runs.wait();
34                     }
35                 }
36 
37                 /*取出任务*/
38                 run = runs.poll();
39                 lastTimer = System.currentTimeMillis();
40                 if (run != null) {
41                     /*执行任务*/
42                     run.run();
43                 }
44             } catch (Exception e) {
45                 /*捕获异常*/
46                 log.error("", e);
47             }
48         }
49     }
50 }

我相信这段代码，70%左右的java开发人员，在线程队列执行的线程，线程模型都是这样设计的

我也是，而且这样的代码持续了很多年；

线程执行 Runnable 接口实现，内部封装了任务列表，

线程执行的时候取出队列里面第一个，执行，

之所以加上开始执行时间就是为了检查当前线程对象执行任务的时候卡死了，比如一直等待；

并且在死循环里面添加了 try cache 捕获异常现象；看上去连线程退出的机会都没有了是不是呢？

感觉没啥问题啊，

接下来我们看看

线程模型使用

 1 public class TestMain {
 2 
 3     private static final Logger log = Logger.getLogger(TestMain.class);
 4     static ThreadTest threadTest = new ThreadTest();
 5 
 6     public static void main(String[] args) throws InterruptedException {
 7         /*创建线程任务队列*/
 8         Thread thread = new Thread(threadTest);
 9         /*启动线程*/
10         thread.start();
11         long i = 0;
12 
13         Random random = new Random();
14 
15         Thread thread1 = new Thread(new Runnable() {
16             @Override
17             public void run() {
18                 while (true) {
19                     try {
20                         /*相当于没 2秒 有一个任务需要处理*/
21                         Thread.sleep(2000);
22                     } catch (Exception e) {
23                     }
24                     /*创建任务*/
25                     threadTest.runs.add(new Runnable() {
26                         @Override
27                         public void run() {
28                             int nextInt = random.nextInt(10000);
29                             if (nextInt < 2000) {
30                                 try {
31                                     /*相当于有20%的概率暂停 5秒 模拟任务的执行耗时*/
32                                     Thread.sleep(5000);
33                                 } catch (Exception e) {
34                                 }
35                             } else if (nextInt < 5000) {
36                                 try {
37                                     /*相当于有50%的概率暂停 2秒 模拟任务的执行耗时*/
38                                     Thread.sleep(2000);
39                                 } catch (Exception e) {
40                                 }
41                             }
42                             log.error(System.currentTimeMillis());
43                         }
44                     });
45                     /*通知线程有新任务了*/
46                     synchronized (threadTest.runs) {
47                         threadTest.runs.notify();
48                     }