`

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

 
阅读更多

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

 

线程中断

 
       线程中断涉及到三个方法，如下：
void interrupt()
          中断线程。
static boolean interrupted()
          测试当前线程是否已经中断。
boolean isInterrupted()
          测试线程是否已经中断。

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

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  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 plaincopyprint?在CODE上查看代码片派生到我的代码片
  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（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

 

线程让步

 
       线程让步，其方法如下：
static void yield()
          暂停当前正在执行的线程对象，并执行其他线程

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

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  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线程同步的话，线程让步不会释放锁(监视器对象)。

 

线程睡眠

 
       线程睡眠涉及到两个方法，如下：
static void sleep(long millis)
          在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。
static void sleep(long millis, int nanos)
          在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。

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

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  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 plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. t1准备计算  
  2. t1感觉累了，开始睡觉  
  3. t1睡醒了，开始计算  
  4. t1计算完成  
  5. t2准备计算  
  6. t2感觉累了，开始睡觉  
  7. t2睡醒了，开始计算  
  8. t2计算完成  
t1准备计算
t1感觉累了，开始睡觉
t1睡醒了，开始计算
t1计算完成
t2准备计算
t2感觉累了，开始睡觉
t2睡醒了，开始计算
t2计算完成
 

线程合并

 
       线程合并涉及到三个方法，如下：
 void join()
          等待该线程终止。
 void join(long millis)
          等待该线程终止的时间最长为 millis 毫秒。
 void join(long millis, int nanos)
          等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
       线程合并是优先执行调用该方法的线程，再执行当前线程，来看一个小例子：
[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  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类中提供了优先级的三个常量，如下： java.lang.Thread
public static final int MAX_PRIORITY 10
public static final int MIN_PRIORITY 1
public static final int NORM_PRIORITY 5
       我们创建线程对象后，如果不显示的设置优先级的话，默认为5。优先级可以看成一种特权，优先级高的，获取CPU调度的机会就大，优先级低的，获取CPU调度的机会就小，这个和我们现实生活很一样啊，优胜劣汰。线程优先级的示例就不写了，比较简单。
 

wait()和sleep()区别

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

线程中断

 
       线程中断涉及到三个方法，如下：
void interrupt()
          中断线程。
static boolean interrupted()
          测试当前线程是否已经中断。
boolean isInterrupted()
          测试线程是否已经中断。
       interrupt()方法用于中断线程，通常的理解来看，只要某个线程启动后，调用了该方法，则该线程不能继续执行了，来看个小例子：
[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  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 plaincopyprint?在CODE上查看代码片派生到我的代码片
  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（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

 

线程让步

 
       线程让步，其方法如下：
static void yield()
          暂停当前正在执行的线程对象，并执行其他线程
       线程让步用于正在执行的线程，在某些情况下让出CPU资源，让给其它线程执行，来看一个小例子：
[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  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线程同步的话，线程让步不会释放锁(监视器对象)。

 

线程睡眠

 
       线程睡眠涉及到两个方法，如下：
static void sleep(long millis)
          在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。
static void sleep(long millis, int nanos)
          在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。
       线程睡眠的过程中，如果是在synchronized线程同步内，是持有锁(监视器对象)的，也就是说，线程是关门睡觉的，别的线程进不来，来看一个小例子：
[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  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 plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. t1准备计算  
  2. t1感觉累了，开始睡觉  
  3. t1睡醒了，开始计算  
  4. t1计算完成  
  5. t2准备计算  
  6. t2感觉累了，开始睡觉  
  7. t2睡醒了，开始计算  
  8. t2计算完成  
t1准备计算
t1感觉累了，开始睡觉
t1睡醒了，开始计算
t1计算完成
t2准备计算
t2感觉累了，开始睡觉
t2睡醒了，开始计算
t2计算完成
 

线程合并

 
       线程合并涉及到三个方法，如下：
 void join()
          等待该线程终止。
 void join(long millis)
          等待该线程终止的时间最长为 millis 毫秒。
 void join(long millis, int nanos)
          等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
       线程合并是优先执行调用该方法的线程，再执行当前线程，来看一个小例子：
[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  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类中提供了优先级的三个常量，如下： java.lang.Thread
public static final int MAX_PRIORITY 10
public static final int MIN_PRIORITY 1
public static final int NORM_PRIORITY 5
       我们创建线程对象后，如果不显示的设置优先级的话，默认为5。优先级可以看成一种特权，优先级高的，获取CPU调度的机会就大，优先级低的，获取CPU调度的机会就小，这个和我们现实生活很一样啊，优胜劣汰。线程优先级的示例就不写了，比较简单。
 

wait()和sleep()区别

 
       区别太大了，但是在Java线程面试题中是很常见的问题，相信你阅读过本专栏后，能够轻松的解答，这里不再赘述。
       本文来自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/17560467，转载请注明。
分享到：
| 几个Java基础题
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java多线程编程总结

    Java线程：线程的调度-让步 Java线程：线程的调度-合并 Java线程：线程的调度-守护线程 Java线程：线程的同步-同步方法 Java线程：线程的同步-同步块 Java线程：并发协作-生产者消费者模型 Java线程：并发协作-死锁...

    Java多线程编程经验

    #### 四、Java线程：线程栈模型与线程的变量 每个线程都拥有自己的调用栈，这意味着每个线程都有独立的执行路径。线程之间可以共享进程级别的资源，例如内存，但不能直接访问对方的局部变量或调用栈上的数据。 ###...

    Java_多线程编程线程：大总结

    - **线程调度**：包括休眠、优先级调整、线程让步、合并线程以及守护线程的概念。 - **并发协作**：深入探讨了生产者-消费者模型和死锁问题，提供了理解和避免死锁的策略。 - **新特征**：Java 5引入的并发工具，如`...

    java中的线程让步例子.

    Java中的线程让步是一种线程协作的方式，它允许一个正在执行的线程主动放弃当前的时间片，将CPU资源让给其他线程使用。这种方式在多线程编程中有时会用到，比如当一个线程完成某项任务后，希望其他线程能够优先执行...

    java多线程编程总结

    #### 四、Java线程：线程状态的转换 - **线程的状态** Java线程的状态包括新建 (`NEW`)、就绪 (`RUNNABLE`)、阻塞 (`BLOCKED`)、等待 (`WAITING`)、超时等待 (`TIMED_WAITING`) 和终止 (`TERMINATED`)。 #### 五...

    java线程文档大全

    4. **线程合并与让步**：join()方法用于合并线程，让当前线程等待指定线程结束后再继续执行。yield()方法则是让当前线程暂停，让其他同优先级的线程有机会执行。 5. **守护线程（Daemon）**：守护线程是一种特殊的...

    Java线程让步_动力节点Java学院整理

    Java线程让步是多线程编程中一个重要的概念，主要涉及到如何控制线程的执行顺序和资源分配。`yield()`方法是Java提供的一种线程让步的方式，它允许当前正在执行的线程暂停，将执行权短暂地让给其他等待的线程，特别...

    JAVA多线程总结

    **四、Java线程：线程状态的转换** 线程有五种基本状态：新建、可运行、运行、阻塞和终止。状态之间的转换是由系统调度和线程的同步操作决定的。 **五、Java线程：线程的同步与锁** - **同步**：防止多个线程同时...

    java 线程让步（Yield）

    Java线程让步（Yield）是Java多线程编程中的一个重要概念，它涉及到线程调度和并发控制。在多线程环境下，线程让步意味着一个正在运行的线程主动放弃当前的时间片，以便其他就绪状态的线程有机会执行。这与线程的...

    Java多线程

    #### 十四、Java线程：新特征-锁（上） Java提供了一套高级的锁机制，如`ReentrantLock`，这允许更精细的锁控制。 #### 十五、Java线程：新特征-锁（下） 进一步探讨锁的高级用法，包括公平锁、非公平锁等。 ###...

    Java多线程运算集合

    #### 十四、Java线程：新特征-阻塞队列与阻塞栈 - **阻塞队列**： - `BlockingQueue` 是一种特殊类型的队列，它提供了额外的阻塞行为。 - 当队列为空时，从队列中取元素的操作将会阻塞；当队列满时，往队列里添加...

    Java多线程编程的Java中的线程.docx

    1. 线程控制：Java提供了丰富的API来控制线程，如`sleep()`, `join()`, `yield()`, `interrupt()`, `isInterrupted()`等，用于暂停、等待、让步和中断线程。 2. 线程同步：为了防止多个线程同时访问共享资源导致数据...

    java多线程笔记

    合并（线程合并），通过`join()`方法等待另一个线程结束；以及终止线程（`stop()`或`interrupt()`），结束线程的执行。值得注意的是，`stop()`方法已弃用，因为可能引起数据不一致，推荐使用`interrupt()`。 守护...

    java多线程.

    6. **线程让步**： - `public static void yield()`：使当前正在执行的线程放弃CPU，让给同优先级的其他线程执行。 7. **中断线程**： - `public void interrupt()`：中断当前线程。 8. **检查线程状态**： - `...

    java多线程编程大总结

    6. 线程的调度：Java线程模型提供了多种方式来控制线程的执行，如休眠（sleep）、优先级（setPriority）、让步（yield）等。 7. 并发协作模型：生产者消费者模型、死锁等都是并发协作的经典问题，Java通过并发工具...

    java线程学习笔记

    Java线程学习笔记涉及了Java多线程编程的多个关键知识点，本篇知识点整理将详细解释每个概念及其在Java中的实现方式。 基本知识部分包含了Java线程编程的基础内容，它们是并发编程的基石。 任务Runnable是一个接口...

Magicbox
Global site tag (gtag.js) - Google Analytics