10-线程控制之休眠线程

线程休眠： public static void sleep(long millis) 控制当前线程休眠若干毫秒 （1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000）

 1 public class day23_10线程控制之休眠线程 {
 2 /*
 3  * 线程睡眠
 4  *           public static void sleep(long millis)
 5  */
 6     public static void main(String[] args) {
 7         ThreadSleep ts1=new ThreadSleep();
 8         ThreadSleep ts2=new ThreadSleep();
 9         ThreadSleep ts3=new ThreadSleep();
10         
11         ts1.setName("虎兔");
12         ts2.setName("兔兔");
13         ts3.setName("虎虎");
14         
15         ts1.start();
16         ts2.start();
17         ts3.start();
18     }
19 }
20 
21 class ThreadSleep extends Thread{
22     @Override
23     public void run() {
24         for(int x=0;x<100;x++) {
25             System.out.println(getName()+":"+x+",日期"+new Date());
26             //睡眠，让其休息1秒钟
27             try {
28                 Thread.sleep(1000);
29             } catch (InterruptedException e) {
30                 e.printStackTrace();
31             }
32         }
33     }
34 }

代码练习案例

自己的理解就是每隔多少毫秒再执行，中间隔得时间就是休息时间。比如这一次线程执行时时间是08:37:04，睡眠1秒的话，下一次就是08:37:05啦

11-线程控制之加入线程

线程加入： public final void join():当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续

 1 public class day23_11线程控制之加入线程 {
 2     public static void main(String[] args) {
 3         ThreadJoin tj1 = new ThreadJoin();
 4         ThreadJoin tj2 = new ThreadJoin();
 5         ThreadJoin tj3 = new ThreadJoin();
 6 
 7         tj1.setName("虎兔");
 8         tj2.setName("兔兔");
 9         tj3.setName("虎虎");
10 
11         tj1.start();
12         try {
13             tj1.join();//tj1走完，tj2,tj3才可以走
14         } catch (InterruptedException e) {
15             e.printStackTrace();
16         }
17         tj2.start();
18         tj3.start();
19     }
20 }
21 
22 class ThreadJoin extends Thread {
23     @Override
24     public void run() {
25         for (int x = 0; x < 100; x++) {
26             System.out.println(getName()+":"+x);
27         }
28     }
29 }

代码练习案例

自己的理解就是使用该方法的线程对象必须先全部执行完，其余的线程才会在他后面开始执行，其余的线程只能跟在他屁股后面

12-线程控制之礼让线程

线程礼让：

public static void yield() :暂停当前正在执行的线程对象,并执行其他线程。 让多个线程的执行更和谐,但是不能靠它保证一人一次。

 1 public class day23_12线程控制之礼让线程 {
 2 
 3     public static void main(String[] args) {
 4         ThreadYield ty2=new ThreadYield();
 5         ThreadYield ty3=new ThreadYield();
 6         
 7         ty2.setName("兔兔");
 8         ty3.setName("虎虎");
 9         
10         ty2.start();
11         ty3.start();
12 
13     }
14 
15 }
16 class ThreadYield extends Thread {
17     @Override
18     public void run() {
19         for (int x = 0; x < 100; x++) {
20             System.out.println(getName()+":"+x);
21             Thread.yield();//没调用这个方法之前是随机抢的
22             //但是不能靠它保证一人一次
23         }
24     }
25 }

代码练习案例

自己理解就是没使用yield()之前完全就是随机的抢，很可能某一个线程一直在抢到，而使用后yield()稍微和谐合理一些，一人一次抢到的可能性更多一点，但是不能保证肯定是一人抢到一次的。

 

13-线程控制之守护线程

线程守护：

public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。 on -如果为true,则将该线程标记为守护线程。

 1 public class day23_13线程控制之守护线程 {
 2 
 3     public static void main(String[] args) {
 4         ThreadDaemon td1=new ThreadDaemon();
 5         ThreadDaemon td2=new ThreadDaemon();
 6 
 7         
 8         td1.setName("兔兔");
 9         td2.setName("虎虎");
10         
11         //设置守护线程
12         td1.setDaemon(true);
13         td2.setDaemon(true);
14         
15         td1.start();
16         td2.start();
17 
18         Thread.currentThread().setName("虎兔");//他们三个抢
19         for(int x = 0; x < 5; x++) {
20             System.out.println(Thread.currentThread().getName()+":"+x);
21         }
22     }
23 
24 }
25 class ThreadDaemon extends Thread {
26     @Override
27     public void run() {
28         for (int x = 0; x < 100; x++) {
29             System.out.println(getName()+":"+x);
30         }
31     }
32 }

代码练习案例

自己的理解就是设为守护线程的会在未被设为守护线程的执行完后就结束，但注意可能不是完全立即结束，可能再执行一两下才就结束

 

14-线程控制之中断线程

线程中断：

public final void stop() :让线程停止，过时了,但是还可以使用。 public void interrupt () :中断线程。把线程的状态终止,并抛出一个InterruptedException.