多线程总结三：控制线程

Java的线程支持提供了一些便捷的工具方法，通过这些便捷的工具方法可以很好的控制线程的执行。

1、join线程：join
当某个程序执行流中调用其他线程的join()方法时，执行中的线程会被阻塞，直到被join()方法加入的join线程执行
完为止。join()方法将大问题划分为许多小问题，每个小问题分配一个线程，当所有的小问题都得到处理以后，再调用主
线程来进一步操作。

 1 /**

 2  * @Title: JoinThread.java 

 3  * @Package  

 4  * @author 任伟

 5  * @date 2014-12-8 上午11:23:38 

 6  * @version V1.0  

 7  */

 8 

 9 /** 

10  * @ClassName: JoinThread 

11  * @Description: join线程

12  * @author 任伟

13  * @date 2014-12-8 上午11:23:38  

14  */

15 public class JoinThread extends Thread{

16     

17     //提供一个有参数的构造器，用于设置该线程的名字

18     public JoinThread(String name){

19         super(name);

20     }

21     

22     /* (non-Javadoc)

23      * @see java.lang.Thread#run()

24      */

25     @Override

26     public void run() {

27         for(int i=0; i<100; i++){

28             System.out.println(this.getName() + " " + i);

29         }

30     }

31     

32     public static void main(String[] args) {

33         //启动子线程

34         new JoinThread("新线程").start();

35         for(int i=0; i<100; i++){

36             if(20==i){

37                 JoinThread jt = new JoinThread("被Join的线程");

38                 jt.start();

39                 try {

40                     jt.join();

41                 } catch (InterruptedException e) {

42                     e.printStackTrace();

43                 }

44             }

45             System.out.println(Thread.currentThread().getName()+" "+i);

46         }

47     }

48 }

JoinThread

 

2、后台线程：setDaemon
后台线程又称为“守护线程”或“精灵线程”。其特征是：如果所有的前台线程都死亡，后台线程会自动死亡。调用Thread
对象的setDaemon(true)方法可以将指定的线程设置为后台线程。前台线程创建的子线程默认是前台线程，后台线程创建的子
线程默认是后台台线程。

 1 /**

 2  * @Title: DaemonThread.java 

 3  * @Package  

 4  * @author 任伟

 5  * @date 2014-12-8 上午11:41:13 

 6  * @version V1.0  

 7  */

 8 

 9 /** 

10  * @ClassName: DaemonThread 

11  * @Description: 后台线程

12  * @author 任伟

13  * @date 2014-12-8 上午11:41:13  

14  */

15 public class DaemonThread extends Thread {

16     /* (non-Javadoc)

17      * @see java.lang.Thread#run()

18      */

19     @Override

20     public void run() {

21         for(int i=0; i<10000; i++){

22             System.out.println(this.getName()+" "+i);

23         }

24     }

25     

26     public static void main(String[] args) {

27         DaemonThread t = new DaemonThread();

28         //将此线程设置为后台线程

29         t.setDaemon(true);

30         t.start();

31         

32         for(int i=0; i<10; i++){

33             System.out.println(Thread.currentThread().getName()+" "+i);

34         }

35     }

36 }

DaemonThread

 

3、线程睡眠：Sleep
当当前线程调用sleep()方法进入阻塞状态以后，该线程不会获得执行的机会，因此sleep()方法常用来暂停程序的执行。

 1 /**

 2  * @Title: SleepTest.java 

 3  * @Package  

 4  * @author 任伟

 5  * @date 2014-12-8 上午11:53:51 

 6  * @version V1.0  

 7  */

 8 

 9 /** 

10  * @ClassName: SleepTest 

11  * @Description: 使线程睡眠

12  * @author 任伟

13  * @date 2014-12-8 上午11:53:51  

14  */

15 public class SleepTest {

16     public static void main(String[] args) {

17         for(int i=0; i<10; i++){

18             System.out.println("当前时间：" + new Date());

19             try {

20                 Thread.sleep(1000);

21             } catch (InterruptedException e) {

22                 e.printStackTrace();

23             }

24         }

25     }

26 }

SleepTest

 

4、线程优先级
每个线程执行时都会具有一定的优先级，每个线程默认的优先级都与创建它的父线程优先级相同。Thread类提供了
setPriority(int newPriority)、getPriority()来设置和返回线程优先级。
MAX_PRIORITY: 10
MIN_PRIORITY: 1
NORM_PRIORITY: 5

5、线程让步：yield
yield()让当前线程暂停一下，让系统的线程调度器重新调度一次，当然也可能调度到自己.

 1 /**

 2  * @Title: YieldTest.java 

 3  * @Package  

 4  * @author 任伟

 5  * @date 2014-12-8 下午12:03:34 

 6  * @version V1.0  

 7  */

 8 

 9 /** 

10  * @ClassName: YieldTest 

11  * @Description: 线程让步方法测试

12  * @author 任伟

13  * @date 2014-12-8 下午12:03:34  

14  */

15 public class YieldTest extends Thread{

16 

17     public YieldTest(String name){

18         super(name);

19     }

20     

21     public void run() {

22         for(int i=0; i<50; i++){

23             System.out.println(this.getName()+" "+i);

24             //当i=20，使用yield()方法让当前线程让步

25             if(20==i){

26                 Thread.yield();

27             }

28         }

29     }

30     

31     public static void main(String[] args) {

32         YieldTest yt1 = new YieldTest("线程1");

33         YieldTest yt2 = new YieldTest("线程2");

34         yt1.setPriority(Thread.MAX_PRIORITY);

35         yt2.setPriority(Thread.MIN_PRIORITY);

36 

37         

38         yt1.start();

39         yt2.start();

40     }

41 }

YieldTest