Android（java）学习笔记64：线程的控制

1.线程休眠：

ava中线程休眠指让正在运行的线程暂停执行一段时间，进入阻塞状态，通过调用Thread类的静态方法sleep得以实现。

当线程调用sleep进入阻塞状态后，在其休眠的时间内，该线程不会获得执行的机会，即使系统中没有其他可运行的线程，处于休眠中的线程也不会执行，一次常用sleep方法来暂停程序的执行。

1 线程休眠的sleep()方法的语法格式：

2 try {

3   Thread.sleep (2000);

4 } catch (InterruptedException  e)  {

5    e.printStackTrace();

6 }

下面我们根据具体的实例来了解sleep()的用法：

当然这里是利用自己新建一个新的类ThreadSleep，也可以利用匿名类：

 1 package cn.itcast_04;

 2 

 3 import java.util.Date;

 4 

 5 public class ThreadSleep extends Thread {

 6     @Override

 7     public void run() {

 8         for (int x = 0; x < 100; x++) {

 9             System.out.println(getName() + ":" + x + ",日期：" + new Date());

10             // 睡眠

11             // 困了，我稍微休息1秒钟

12             try {

13                 Thread.sleep(1000);

14             } catch (InterruptedException e) {

15                 e.printStackTrace();

16             }

17         }

18     }

19 }

下面我们新建的一个ThreadSleepDemo类，调用main方法测试上面这个类：

 1 package cn.itcast_04;

 2 

 3 /*

 4  * 线程休眠

 5  *        public static void sleep(long millis)

 6  */

 7 public class ThreadSleepDemo {

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

 9         ThreadSleep ts1 = new ThreadSleep();

10         ThreadSleep ts2 = new ThreadSleep();

11         ThreadSleep ts3 = new ThreadSleep();

12 

13         ts1.setName("林青霞");

14         ts2.setName("林志玲");

15         ts3.setName("林志颖");

16 

17         ts1.start();

18         ts2.start();

19         ts3.start();

20     }

21 }

程序运行得出结果：

 

2.线程的挂起

线程的挂起是指暂停当前正在执行的线程，当另一个线程执行完毕后，才继续执行当前线程（类似于单片机程序中的中断）。实现线程的挂起，可以使用Thread类中的join方法来完成。这就好比此时你正在看电视，却突然有人上门收水费，读者必须付完水费后才能继续看电视。

下面是使用join()方法的实例：

 1 package cn.itcast_04;

 2 

 3 public class ThreadJoin extends Thread {

 4     @Override

 5     public void run() {

 6         for (int x = 0; x < 100; x++) {

 7             System.out.println(getName() + ":" + x);

 8         }

 9     }

10 }

 

测试类如下：

 1 package cn.itcast_04;

 2 

 3 /*

 4  * public final void join():等待该线程终止。 

 5  */

 6 public class ThreadJoinDemo {

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

 8         ThreadJoin tj1 = new ThreadJoin();

 9         ThreadJoin tj2 = new ThreadJoin();

10         ThreadJoin tj3 = new ThreadJoin();

11 

12         tj1.setName("李渊");

13         tj2.setName("李世民");

14         tj3.setName("李元霸");

15 

16         tj1.start();

17         try { 18 tj1.join(); 19 } catch (InterruptedException e) { 20 e.printStackTrace(); 21 } 22         

23         tj2.start();

24         tj3.start();

25     }

26 }

执行结果：等“李渊”这个线程走完了，其余两个才会开始抢。

 

3.线程的礼让：

线程礼让就是给当前正在处于运行状态下的线程一个提醒，告知它可以将资源礼让给其他线程，这仅仅是一种暗示，没有任何一种机制保证当前的线程会将资源礼让。

代码案例：

 1 package cn.itcast_04;

 2 

 3 public class ThreadYield extends Thread {

 4     @Override

 5     public void run() {

 6         for (int x = 0; x < 100; x++) {

 7             System.out.println(getName() + ":" + x);

 8             Thread.yield();

 9         }

10     }

11 }

测试类的代码:

 1 package cn.itcast_04;

 2 

 3 /*

 4  * public static void yield():暂停当前正在执行的线程对象，并执行其他线程。 

 5  * 让多个线程的执行更和谐，但是不能靠它保证一人一次。

 6  */

 7 public class ThreadYieldDemo {

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

 9         ThreadYield ty1 = new ThreadYield();

10         ThreadYield ty2 = new ThreadYield();

11 

12         ty1.setName("林青霞");

13         ty2.setName("刘意");

14 

15         ty1.start();

16         ty2.start();

17     }

18 }

运行结果如下：

 

4.后台的线程：

代码示例如下：

 1 package cn.itcast_04;

 2 

 3 public class ThreadDaemon extends Thread {

 4     @Override

 5     public void run() {

 6         for (int x = 0; x < 100; x++) {

 7             System.out.println(getName() + ":" + x);

 8         }

 9     }

10 }

 

测试代码如下：

 1 package cn.itcast_04;

 2 

 3 /*

 4  * public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。

 5  * 当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。 

 6  * 

 7  * 游戏：坦克大战。

 8  */

 9 public class ThreadDaemonDemo {

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

11         ThreadDaemon td1 = new ThreadDaemon();

12         ThreadDaemon td2 = new ThreadDaemon();

13 

14         td1.setName("关羽");

15         td2.setName("张飞");

16 

17         // 设置守护线程，表示一旦主线程main结束，这两个守护main线程的守护线程就要跟着结束

18         td1.setDaemon(true);

19         td2.setDaemon(true);

20 

21         td1.start();

22         td2.start();

23 

24         Thread.currentThread().setName("刘备");

25         for (int x = 0; x < 5; x++) {

26             System.out.println(Thread.currentThread().getName() + ":" + x);

27         }

28     }

29 }

执行结果如下：

线程“刘备”结束之后，其他两个线程也跑了一会再结束。（缓冲）

可以根据经典坦克大战游戏类比学习：

 

 

5.线程的中断：

 代码演示：

 1 package cn.itcast_04;

 2 

 3 import java.util.Date;

 4 

 5 public class ThreadStop extends Thread {

 6     @Override

 7     public void run() {

 8         System.out.println("开始执行：" + new Date());

 9 

10         // 我要休息10秒钟，亲，不要打扰我哦

11      try { 12 Thread.sleep(10000); 13 } catch (InterruptedException e) { 14 // e.printStackTrace(); 15 System.out.println("线程被终止了"); 16 } 17 

18         System.out.println("结束执行：" + new Date());

19     }

20 }

 

 1 package cn.itcast_04;

 2 

 3 /*

 4  * public final void stop():让线程停止，过时了，但是还可以使用。

 5  * public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。

 6  */

 7 public class ThreadStopDemo {

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

 9         ThreadStop ts = new ThreadStop();

10         ts.start();

11 

12         // 你超过三秒不醒过来，我就干死你

13         try {

14             Thread.sleep(3000);

15             // ts.stop();

16             ts.interrupt();

17         } catch (InterruptedException e) {

18             e.printStackTrace();

19         }

20     }

21 }

执行结果：休眠了3秒钟之后，这个ts线程就被杀死了，如下图中terminated

图1：ts.stop()方法

 

图2：ts.interrupt()方法