Java——线程的四种不同形式

一，休眠线程

public static void sleep(long millis) throws InterruptedException

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

参数：millis - 以毫秒为单位的休眠时间。

抛出：InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态被清除。

package com.yy.threadmethod;public class Demo3_Sleep {
/*** *当父亲坏了，那么，儿子不能比父亲更坏*当父亲没坏，儿子如果有坏的东西，必须自己去处理* * public static void sleep(long millis)*                  throws InterruptedException在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。 ** 参数：millis - 以毫秒为单位的休眠时间。 * 抛出：InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。* * */public static void main(String[] args) throws InterruptedException {demo1();                                //创建一条线程，对其进行睡眠，使其每秒打印一次demo2();                                //创建两条线程，分别进行睡眠，让两条线程交替输出}private static void demo2() {new Thread(){                               //父类Thread类里面的run方法是没有throw抛异常的，子类在重写父类的方法的时候，就不能去抛异常，这里只能抓异常surroundpublic void run(){for (int i = 0; i < 10; i++) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() + "......aaaaaa");}}}.start();//开启一条线程new Thread(){public void run(){for (int i = 0; i < 10; i++) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() + "......bbbb");}}}.start();//开启另一条线程
}private static void demo1() throws InterruptedException {for (int i = 20; i >= 0; i--) {System.out.println("倒计时：" + i + "秒");Thread.sleep(100);}}}

二，守护线程

守护线程：设置一个线程为守护线程，该线程不会单独执行，当其他的非守护线程都结束后，自动退出，退出的时候会有一定的缓冲时间，不会立马就结束；

public final void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

参数：on - 如果为 true，则将该线程标记为守护线程。

被标记成守护线程的线程，相当于象棋里的車马象士，而没被标记为守护线程的线程，相当与将帅。

package com.yy.threadmethod;public class Demo4_Daemon {
/*** 守护线程* 设置一个线程为守护线程，该线程不会单独执行，当其他的非守护线程都结束后，自动退出，退出的时候会有一定的缓冲时间，不会立马就结束* * */public static void main(String[] args) {Thread t1 = new Thread(){               //匿名内部类public void run(){                  //重写run()方法for (int i = 0; i < 2; i++) {System.out.println(getName() + "...wsq" );} }};Thread t2 = new Thread(){public void run(){for (int i = 0; i < 50; i++) {System.out.println(getName() + "...yy" );} }};t2.setDaemon(true);                     //当传入true就是意味着设置为守护线程，把t2设置成守护线程，相当于象棋中的車马象士，去守护t1，ti就相当于是将帅’t1.start();t2.start();}}

三，加入线程

join()：当前线程暂停，等待指定的线程执行结束之后，当前线程再继续

join(int)：join()的一个重载方法，可以等待指定的毫秒之后继续

public final void join()
throws InterruptedException等待该线程终止。
抛出：
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态被清除。
public final void join(long millis,int nanos)
throws InterruptedException等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
参数：
millis - 以毫秒为单位的等待时间。
nanos - 要等待的 0-999999 附加纳秒。
抛出：
IllegalArgumentException - 如果 millis 值为负，则 nanos 的值不在 0-999999 范围内。
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态被清除。

package com.yy.threadmethod;public class Demo5_Join {public static void main(String[] args) {final Thread t1 = new Thread(){             //匿名内部类(局部内部类)在使用它所在方法中的局部变量的时候，必须用final修饰public void run(){for (int i = 0; i < 10; i++) {System.out.println(getName() + "..." + "海阔天空");}}};Thread t2 = new Thread(){public void run(){for (int i = 0; i < 10; i++) {if(i == 2){                     //当i=2时，也就是t2执行两次之后，t1线程开始插队try {
//                          t1.join();              //这表示t1线程开始插队，然后，直到t1线程运行完毕后，才轮到t2线程运行t1.join(1);             //这表示t1线程插队，插队1毫秒之后，两条线程继续交替进行，也就是继续多线程进行} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(getName() + "..." + "光辉岁月");}}};t1.start();t2.start();}}

四，礼让线程

yield:礼让线程，让出CPU

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

package com.yy.threadmethod;public class Demo6_Yield {public static void main(String[] args) {new MyThread().start();                     //定义一条线程        new MyThread().start();                     //定义另一条线程}
}class MyThread extends Thread{public void run(){for (int i = 1; i <= 1000; i++) {       if(i % 10 == 0){                        //若i是10的倍数Thread.yield();                     //让出CPU,让另一条线程进行}System.out.println(getName() + "..." + i);}}
}