Java线程(四)：线程中断、线程让步、线程睡眠、线程合并

青旅半醒 2022-08-07 00:22 270阅读 0赞

# [Java线程(四)：线程中断、线程让步、线程睡眠、线程合并 ][Java_] #

分类： [ Java SE][Java SE] [ Java 线程][Java] 2013-12-26 20:29  4395人阅读 [评论][Link 1](4) 收藏 [举报][Link 2]

[传统线程][Link 3] [Java][Java 1]

目录[(?)][Link 4][\[+\]][Link 4]

1.  [线程中断][Link 5]
2.  [线程让步][Link 6]
3.  [线程睡眠][Link 7]
4.  [线程合并][Link 8]
5.  [线程优先级][Link 9]
6.  [wait和sleep区别][wait_sleep]

本文来自： [高爽|Coder][Coder]，原文地址： [http://blog.csdn.net/ghsau/article/details/17560467][Java_]，转载请注明。  
       最近在Review线程专栏，修改了诸多之前描述不够严谨的地方，凡是带有Review标记的文章都是修改过了。本篇文章是插进来的，因为原来没有写，现在来看传统线程描述的不太完整，所以就补上了。理解了线程同步和线程通信之后，再来看本文的知识点就会简单的多了，本文是做为传统线程知识点的一个补充。有人会问：JDK5之后有了更完善的处理多线程问题的类(并发包)，我们还需要去了解传统线程吗？答：需要。在实际开发中，无外乎两种情况，一个是开发新内容，另一个是维护原有程序。开发新内容可以使用新的技术手段，但是我们不能保证原有程序是用什么实现的，所以我们需要了解原有的。另外一点，了解传统线程的工作原理，使我们在使用并发包时更加得心应手。

# 线程中断 #

线程中断涉及到三个方法，如下：

<table> 
 <tbody> 
  <tr> 
   <td align="right"><span><code>void</code></span></td> 
   <td><code><strong><a rel="nofollow">interrupt</a></strong>()</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;中断线程。</td> 
  </tr> 
  <tr> 
   <td align="right"><span><code>static&nbsp;boolean</code></span></td> 
   <td><code><strong><a rel="nofollow">interrupted</a></strong>()</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;测试当前线程是否已经中断。</td> 
  </tr> 
  <tr> 
   <td align="right"><span><code>boolean</code></span></td> 
   <td><code><strong><a rel="nofollow">isInterrupted</a></strong>()</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;测试线程是否已经中断。</td> 
  </tr> 
 </tbody> 
</table>

interrupt()方法用于中断线程，通常的理解来看，只要某个线程启动后，调用了该方法，则该线程不能继续执行了，来看个小例子：

**\[java\]** [ view plain][Link 4] [copy][Link 4] [print][Link 4] [?][Link 4] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  public class InterruptTest \{  
2.      public static void main(String\[\] args) throws InterruptedException \{  
3.          MyThread t = new MyThread("MyThread");  
4.          t.start();  
5.          Thread.sleep(100);// 睡眠100毫秒  
6.          t.interrupt();// 中断t线程  
7.      \}  
8.  \}  
9.  class MyThread extends Thread \{  
10.     int i = 0;  
11.     public MyThread(String name) \{  
12.         super(name);  
13.     \}  
14.     public void run() \{  
15.         while(true) \{ // 死循环，等待被中断  
16.             System.out.println(getName() + getId() + "执行了" + ++i + "次");  
17.         \}  
18.     \}  
19. \}

public class InterruptTest {
    	public static void main(String[] args) throws InterruptedException {
    		MyThread t = new MyThread("MyThread");
    		t.start();
    		Thread.sleep(100);// 睡眠100毫秒
    		t.interrupt();// 中断t线程
    	}
    }
    class MyThread extends Thread {
    	int i = 0;
    	public MyThread(String name) {
    		super(name);
    	}
    	public void run() {
    		while(true) {// 死循环，等待被中断
    			System.out.println(getName() + getId() + "执行了" + ++i + "次");
    		}
    	}
    }

运行后，我们发现，线程t一直在执行，没有被中断，原来interrupt()是骗人的，汗！其实interrupt()方法并不是中断线程的执行，而是为调用该方法的线程对象打上一个标记，设置其中断状态为true，通过isInterrupted()方法可以得到这个线程状态，我们将上面的程序做一个小改动：

**\[java\]** [ view plain][Link 4] [copy][Link 4] [print][Link 4] [?][Link 4] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  public class InterruptTest \{  
2.      public static void main(String\[\] args) throws InterruptedException \{  
3.          MyThread t = new MyThread("MyThread");  
4.          t.start();  
5.          Thread.sleep(100);// 睡眠100毫秒  
6.          t.interrupt();// 中断t线程  
7.      \}  
8.  \}  
9.  class MyThread extends Thread \{  
10.     int i = 0;  
11.     public MyThread(String name) \{  
12.         super(name);  
13.     \}  
14.     public void run() \{  
15.         while(!isInterrupted()) \{ // 当前线程没有被中断，则执行  
16.             System.out.println(getName() + getId() + "执行了" + ++i + "次");  
17.         \}  
18.     \}  
19. \}

public class InterruptTest {
    	public static void main(String[] args) throws InterruptedException {
    		MyThread t = new MyThread("MyThread");
    		t.start();
    		Thread.sleep(100);// 睡眠100毫秒
    		t.interrupt();// 中断t线程
    	}
    }
    class MyThread extends Thread {
    	int i = 0;
    	public MyThread(String name) {
    		super(name);
    	}
    	public void run() {
    		while(!isInterrupted()) {// 当前线程没有被中断，则执行
    			System.out.println(getName() + getId() + "执行了" + ++i + "次");
    		}
    	}
    }

这样的话，线程被顺利的中断执行了。很多人实现一个线程类时，都会再加一个flag标记，以便控制线程停止执行，其实完全没必要，通过线程自身的中断状态，就可以完美实现该功能。如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。 我们可以捕获该异常，并且做一些处理。另外，Thread.interrupted()方法是一个静态方法，它是判断当前线程的中断状态，需要注意的是，线程的中断状态会由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

# 线程让步 #

线程让步，其方法如下：

<table> 
 <tbody> 
  <tr> 
   <td align="right"><span><code>static&nbsp;void</code></span></td> 
   <td><code><strong><a rel="nofollow">yield</a></strong>()</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;暂停当前正在执行的线程对象，并执行其他线程</td> 
  </tr> 
 </tbody> 
</table>

线程让步用于正在执行的线程，在某些情况下让出CPU资源，让给其它线程执行，来看一个小例子：

**\[java\]** [ view plain][Link 4] [copy][Link 4] [print][Link 4] [?][Link 4] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  public class YieldTest \{  
2.      public static void main(String\[\] args) throws InterruptedException \{  
3.          // 创建线程对象  
4.          YieldThread t1 = new YieldThread("t1");  
5.          YieldThread t2 = new YieldThread("t2");  
6.          // 启动线程  
7.          t1.start();  
8.          t2.start();  
9.          // 主线程休眠100毫秒  
10.         Thread.sleep(100);  
11.         // 终止线程  
12.         t1.interrupt();  
13.         t2.interrupt();  
14.     \}  
15. \}  
16. class YieldThread extends Thread \{  
17.     int i = 0;  
18.     public YieldThread(String name) \{  
19.         super(name);  
20.     \}  
21.     public void run() \{  
22.         while(!isInterrupted()) \{  
23.             System.out.println(getName() + "执行了" + ++i + "次");  
24.             if(i % 10 == 0) \{ // 当i能对10整除时，则让步  
25.                 Thread.yield();  
26.             \}  
27.         \}  
28.     \}  
29. \}

public class YieldTest {
    	public static void main(String[] args) throws InterruptedException {
    		// 创建线程对象
    		YieldThread t1 = new YieldThread("t1");
    		YieldThread t2 = new YieldThread("t2");
    		// 启动线程
    		t1.start();
    		t2.start();
    		// 主线程休眠100毫秒
    		Thread.sleep(100);
    		// 终止线程
    		t1.interrupt();
    		t2.interrupt();
    	}
    }
    class YieldThread extends Thread {
    	int i = 0;
    	public YieldThread(String name) {
    		super(name);
    	}
    	public void run() {
    		while(!isInterrupted()) {
    			System.out.println(getName() + "执行了" + ++i + "次");
    			if(i % 10 == 0) {// 当i能对10整除时，则让步
    				Thread.yield();
    			}
    		}
    	}
    }

输出结果略，从输出结果可以看到，当某个线程(t1或者t2)执行到10次、20次、30次等时，就会马上切换到另一个线程执行，接下来再交替执行，如此往复。**注意，如果存在synchronized线程同步的话，线程让步不会释放锁(监视器对象)**。

# 线程睡眠 #

线程睡眠涉及到两个方法，如下：

<table> 
 <tbody> 
  <tr> 
   <td align="right"><span><code>static&nbsp;void</code></span></td> 
   <td><code><strong><a rel="nofollow">sleep</a></strong>(long&nbsp;millis)</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。</td> 
  </tr> 
  <tr> 
   <td align="right"><span><code>static&nbsp;void</code></span></td> 
   <td><code><strong><a rel="nofollow">sleep</a></strong>(long&nbsp;millis, int&nbsp;nanos)</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。</td> 
  </tr> 
 </tbody> 
</table>

**线程睡眠的过程中，如果是在synchronized线程同步内，是持有锁(监视器对象)的**，也就是说，线程是关门睡觉的，别的线程进不来，来看一个小例子：

**\[java\]** [ view plain][Link 4] [copy][Link 4] [print][Link 4] [?][Link 4] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  public class SleepTest \{  
2.      public static void main(String\[\] args) \{  
3.          // 创建共享对象  
4.          Service service = new Service();  
5.          // 创建线程  
6.          SleepThread t1 = new SleepThread("t1", service);  
7.          SleepThread t2 = new SleepThread("t2", service);  
8.          // 启动线程  
9.          t1.start();  
10.         t2.start();  
11.     \}  
12.       
13. \}  
14. class SleepThread extends Thread \{  
15.     private Service service;  
16.     public SleepThread(String name, Service service) \{  
17.         super(name);  
18.         this.service = service;  
19.     \}  
20.     public void run() \{  
21.         service.calc();  
22.     \}  
23. \}  
24. class Service \{  
25.     public synchronized void calc() \{  
26.         System.out.println(Thread.currentThread().getName() + "准备计算");  
27.         System.out.println(Thread.currentThread().getName() + "感觉累了，开始睡觉");  
28.         try \{  
29.             Thread.sleep(10000);// 睡10秒  
30.         \} catch (InterruptedException e) \{  
31.             return;  
32.         \}  
33.         System.out.println(Thread.currentThread().getName() + "睡醒了，开始计算");  
34.         System.out.println(Thread.currentThread().getName() + "计算完成");  
35.     \}  
36. \}

public class SleepTest {
    	public static void main(String[] args) {
    		// 创建共享对象
    		Service service = new Service();
    		// 创建线程
    		SleepThread t1 = new SleepThread("t1", service);
    		SleepThread t2 = new SleepThread("t2", service);
    		// 启动线程
    		t1.start();
    		t2.start();
    	}
    	
    }
    class SleepThread extends Thread {
    	private Service service;
    	public SleepThread(String name, Service service) {
    		super(name);
    		this.service = service;
    	}
    	public void run() {
    		service.calc();
    	}
    }
    class Service {
    	public synchronized void calc() {
    		System.out.println(Thread.currentThread().getName() + "准备计算");
    		System.out.println(Thread.currentThread().getName() + "感觉累了，开始睡觉");
    		try {
    			Thread.sleep(10000);// 睡10秒
    		} catch (InterruptedException e) {
    			return;
    		}
    		System.out.println(Thread.currentThread().getName() + "睡醒了，开始计算");
    		System.out.println(Thread.currentThread().getName() + "计算完成");
    	}
    }

输出结果：

**\[java\]** [ view plain][Link 4] [copy][Link 4] [print][Link 4] [?][Link 4] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  t1准备计算  
2.  t1感觉累了，开始睡觉  
3.  t1睡醒了，开始计算  
4.  t1计算完成  
5.  t2准备计算  
6.  t2感觉累了，开始睡觉  
7.  t2睡醒了，开始计算  
8.  t2计算完成

t1准备计算
    t1感觉累了，开始睡觉
    t1睡醒了，开始计算
    t1计算完成
    t2准备计算
    t2感觉累了，开始睡觉
    t2睡醒了，开始计算
    t2计算完成

# 线程合并 #

线程合并涉及到三个方法，如下：

<table> 
 <tbody> 
  <tr> 
   <td align="right"><span><code>&nbsp;void</code></span></td> 
   <td><code><strong><a rel="nofollow">join</a></strong>()</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;等待该线程终止。</td> 
  </tr> 
  <tr> 
   <td align="right"><span><code>&nbsp;void</code></span></td> 
   <td><code><strong><a rel="nofollow">join</a></strong>(long&nbsp;millis)</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;等待该线程终止的时间最长为 <code>millis</code> 毫秒。</td> 
  </tr> 
  <tr> 
   <td align="right"><span><code>&nbsp;void</code></span></td> 
   <td><code><strong><a rel="nofollow">join</a></strong>(long&nbsp;millis, int&nbsp;nanos)</code><br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;等待该线程终止的时间最长为 <code>millis</code> 毫秒 + <code>nanos</code> 纳秒。</td> 
  </tr> 
 </tbody> 
</table>

线程合并是优先执行调用该方法的线程，再执行当前线程，来看一个小例子：

**\[java\]** [ view plain][Link 4] [copy][Link 4] [print][Link 4] [?][Link 4] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  public class JoinTest \{  
2.      public static void main(String\[\] args) throws InterruptedException \{  
3.          JoinThread t1 = new JoinThread("t1");  
4.          JoinThread t2 = new JoinThread("t2");  
5.          t1.start();  
6.          t2.start();  
7.          t1.join();  
8.          t2.join();  
9.          System.out.println("主线程开始执行！");  
10.     \}  
11. \}  
12. class JoinThread extends Thread \{  
13.     public JoinThread(String name) \{  
14.         super(name);  
15.     \}  
16.     public void run() \{  
17.         for(int i = 1; i <= 10; i++)  
18.             System.out.println(getName() + getId() + "执行了" + i + "次");  
19.     \}  
20. \}

public class JoinTest {
    	public static void main(String[] args) throws InterruptedException {
    		JoinThread t1 = new JoinThread("t1");
    		JoinThread t2 = new JoinThread("t2");
    		t1.start();
    		t2.start();
    		t1.join();
    		t2.join();
    		System.out.println("主线程开始执行！");
    	}
    }
    class JoinThread extends Thread {
    	public JoinThread(String name) {
    		super(name);
    	}
    	public void run() {
    		for(int i = 1; i <= 10; i++)
    			System.out.println(getName() + getId() + "执行了" + i + "次");
    	}
    }

t1和t2都执行完才继续主线程的执行，所谓合并，就是等待其它线程执行完，再执行当前线程，执行起来的效果就好像把其它线程合并到当前线程执行一样。

# 线程优先级 #

线程最低优先级为1，最高优先级为10，看起来就有10个级别，但这10个级别能不能和CPU对应上，还未可知，Thread类中提供了优先级的三个常量，如下：

<table> 
 <tbody> 
  <tr> 
   <th align="left" colspan="3">java.lang.<a title="java.lang 中的类" rel="nofollow">Thread</a></th> 
  </tr> 
  <tr> 
   <td align="right"><span><code>public&nbsp;static&nbsp;final&nbsp;int</code></span></td> 
   <td align="left"><code><a rel="nofollow">MAX_PRIORITY</a></code></td> 
   <td align="right"><code>10</code></td> 
  </tr> 
  <tr> 
   <td align="right"><span><code>public&nbsp;static&nbsp;final&nbsp;int</code></span></td> 
   <td align="left"><code><a rel="nofollow">MIN_PRIORITY</a></code></td> 
   <td align="right"><code>1</code></td> 
  </tr> 
  <tr> 
   <td align="right"><span><code>public&nbsp;static&nbsp;final&nbsp;int</code></span></td> 
   <td align="left"><code><a rel="nofollow">NORM_PRIORITY</a></code></td> 
   <td align="right"><code>5</code></td> 
  </tr> 
 </tbody> 
</table>

我们创建线程对象后，如果不显示的设置优先级的话，默认为5。优先级可以看成一种特权，优先级高的，获取CPU调度的机会就大，优先级低的，获取CPU调度的机会就小，这个和我们现实生活很一样啊，优胜劣汰。线程优先级的示例就不写了，比较简单。

# wait()和sleep()区别 #

区别太大了，但是在Java线程面试题中是很常见的问题，相信你阅读过本专栏后，能够轻松的解答，这里不再赘述。

本文来自： [高爽|Coder][Coder]，原文地址： [http://blog.csdn.net/ghsau/article/details/17560467][Java_]，转载请注明。

[Java_]: http://blog.csdn.net/ghsau/article/details/17560467
[Java SE]: http://blog.csdn.net/ghsau/article/category/793599
[Java]: http://blog.csdn.net/ghsau/article/category/1707779
[Link 1]: http://blog.csdn.net/ghsau/article/details/17560467#comments
[Link 2]: http://blog.csdn.net/ghsau/article/details/17560467#report
[Link 3]: http://www.csdn.net/tag/%e4%bc%a0%e7%bb%9f%e7%ba%bf%e7%a8%8b
[Java 1]: http://www.csdn.net/tag/Java
[Link 4]: http://blog.csdn.net/ghsau/article/details/17560467#
[Link 5]: http://blog.csdn.net/ghsau/article/details/17560467#t0
[Link 6]: http://blog.csdn.net/ghsau/article/details/17560467#t1
[Link 7]: http://blog.csdn.net/ghsau/article/details/17560467#t2
[Link 8]: http://blog.csdn.net/ghsau/article/details/17560467#t3
[Link 9]: http://blog.csdn.net/ghsau/article/details/17560467#t4
[wait_sleep]: http://blog.csdn.net/ghsau/article/details/17560467#t5
[Coder]: http://blog.csdn.net/ghsau
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/129594
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/129594/fork