大家都知道线程执行体run()方法一旦执行完毕，线程就会退出，同时JVM会释放掉线程占用的所有资源，让线程呈现出一中只读状态。在处理数据来源不确定，处理时间不确定的场景下就无法保证线程的合理运作。由于JDK提供的线程暂停是非线程安全的，可能造成死锁，已经被不推荐使用，这样我们就需要一种机制对线程做暂停，重新启动，停止等操作。以下是我写的一段代码，从工作经验中所得。

1. public class BaseThread extends Thread{
   
2.         private final static Logger logger = Logger.getLogger(BaseThread.class);
   
3. 
   
4.         /**
   
5.          * isDead:是否杀死线程
   
6.          */
   
7.         private boolean isDead = false;
   
8.         
   
9.         /**
   
10.          * isStop:是否停止
    
11.          */
    
12.         private boolean isStop = false;
    
13.         
    
14.         /**
    
15.          * isRun:是否已开始执行
    
16.          */
    
17.         private boolean isRun = false;
    
18.         
    
19.         /**
    
20.          * isWait:是否处于等待
    
21.          */
    
22.         private boolean isSleep = false;
    
23.         
    
24.         public BaseThread() {
    
25.                 super();
    
26.                 this.setDaemon(false);//设置为非守护线程
    
27.                 logger.info("线程:["+this.getId()+"] 被创建");
    
28.         }
    
29.         
    
30.         public BaseThread(String threadName) {
    
31.                 super(threadName);
    
32.                 this.setDaemon(false);//设置为非守护线程
    
33.                 logger.info("线程:["+threadName+"-"+this.getId()+"] 被创建");
    
34.         }
    
35. 
    
36.         /**
    
37.          *<p>Title: run</p>
    
38.          *<p>Description:JDK线程类自带方法</p>
    
39.          * @param @return 设定文件
    
40.          * @return  boolean 返回类型
    
41.          * @throws
    
42.         */
    
43.         public void run() {
    
44.                 this.isRun = true;
    
45.                 while(!isDead){
    
46.                         while(true){
    
47.                                 if(!isStop){
    
48.                                         if(preConditions())execute();
    
49.                                 }else{
    
50.                                         break;
    
51.                                 }
    
52.                                 sleep(256);//缓解CPU压力，即唤醒线程需要至多256ms
    
53.                         }
    
54.                 }
    
55.                 isRun = false;
    
56.                 logger.info("线程:[" + this.getName() +"-"+this.getId()+ "] 消亡");
    
57.         }
    
58.         
    
59.         /**
    
60.          *<p>Title: preConditions</p>
    
61.          *<p>Description:执行体前置条件</p>
    
62.          * @param @return 设定文件
    
63.          * @return  boolean 返回类型
    
64.          * @throws
    
65.         */
    
66.         protected boolean preConditions(){
    
67.                 return true;
    
68.         }
    
69.         
    
70.         /**
    
71.          *<p>Title: execute</p>
    
72.          *<p>Description:线程执行体</p>
    
73.          * @param  设定文件
    
74.          * @return  void 返回类型
    
75.          * @throws
    
76.         */
    
77.         protected void execute(){
    
78.                         
    
79.         }
    
80. 
    
81.         /**
    
82.          *<p>Title: kill</p>
    
83.          *<p>Description:结束线程</p>
    
84.          * @param  设定文件
    
85.          * @return  void 返回类型
    
86.          * @throws
    
87.         */
    
88.         public void kill(){
    
89.                 this.isStop = true;
    
90.                 this.isDead = true;
    
91.                 this.isRun = false;
    
92.                 logger.info("线程:["+this.getName()+"-"+this.getId()+"] 被终止");
    
93.         }
    
94.         
    
95.         /**
    
96.          *<p>Title: halt</p>
    
97.          *<p>Description:暂停进程，非休眠</p>
    
98.          * @param  设定文件
    
99.          * @return  void 返回类型
    
100.          * @throws
     
101.         */
     
102.         public void halt(){
     
103.                 this.isStop = true;
     
104.                 logger.info("线程:["+this.getName()+"-"+this.getId()+"] 被暂停");
     
105.         }
     
106.         
     
107.         /**
     
108.          *<p>Title: reStart</p>
     
109.          *<p>Description:重新执行线程</p>
     
110.          * @param  设定文件
     
111.          * @return  void 返回类型
     
112.          * @throws
     
113.         */
     
114.         public void reStart(){
     
115.                 this.isStop = false;
     
116.                 logger.info("线程:["+this.getName()+"-"+this.getId()+"] 被重新执行");
     
117.         }
     
118. 
     
119.         /**
     
120.          *<p>Title: isRun</p>
     
121.          *<p>Description:是否处于执行态</p>
     
122.          * @param @return 设定文件
     
123.          * @return  boolean 返回类型
     
124.          * @throws
     
125.         */
     
126.         public boolean isRun() {
     
127.                 return isRun;
     
128.         }
     
129. 
     
130.         /**
     
131.          *<p>Title: isSleep</p>
     
132.          *<p>Description:是否处于休眠态</p>
     
133.          * @param @return 设定文件
     
134.          * @return  boolean 返回类型
     
135.          * @throws
     
136.         */
     
137.         public boolean isSleep() {
     
138.                 return isSleep;
     
139.         }
     
140.         
     
141.         public boolean isDead(){
     
142.                 return isDead;
     
143.         }
     
144.         
     
145.         /**
     
146.          *<p>Title: sleep</p>
     
147.          *<p>Description:休眠线程</p>
     
148.          * @param @param millis
     
149.          * @param @throws InterruptedException 设定文件
     
150.          * @return  void 返回类型
     
151.          * @throws
     
152.         */
     
153.         public void sleep(int millis){
     
154.                 isSleep = true;
     
155.                 try {
     
156.                         Thread.sleep(millis);
     
157.                         this.sleepTime += millis;
     
158.                         if(notifyPreConditions())notifyObs();
     
159.                 } catch (InterruptedException e) {
     
160.                         e.printStackTrace();
     
161.                 }
     
162.                 isSleep = false;
     
163.         }

复制代码

线程启动后，会一直处于运行状态，线程每次执行都会无条件休眠256ms以缓解不必要的实时性带来的巨大CPU消耗.
同时使用模板方法，让子类有更好的扩展延伸性 。
将执行体独立成一个方法execute ()便于扩展，同时在执行体前加入一个preConditions ()执行体前置条件，将执行体执行的充分条件独立，避免多余代码运算，提高效率。

太专业了，为楼主无私奉献的精神呐喊！果断顶起！！！！

收藏了，谢谢楼主