java--06--多线程（二）

1 等待线程
Thread中提供一个让一个线程等待另外一个线程完成的方法–join(),在某个程序执行流中调用其他线程的join，调用者将会被堵塞，知道被调用的线程执行完成为止
例：

public class TextDemo_10 extends Thread {    public TextDemo_10(String name) {        super(name);    }    public void run(){        for(int a=0;a<100;a++){            System.out.println(getName()+"  "+a);        }    }    public static void main(String[] args) {        new TextDemo_10("新线程").start();        for (int a = 0; a < 100; a++) {            if (a == 20) {                TextDemo_10 demo_10 = new TextDemo_10("被加入的线程");                //开始执行被加入的线程                demo_10.start();                try {                    demo_10.join(1000);                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }            }            System.out.println(Thread.currentThread().getName()+"  "+a);        }    }}

2 后台线程
当所有的前台线程都死亡后，后台线程会立即死亡。

public class TextDemo_11 extends Thread{    public void run(){        for(int a=0;a<100;a++){            System.out.println(getName()+"  "+a);        }    }    public static void main(String[] args){        TextDemo_11 demo_11=new TextDemo_11();        //将该线程设置 为后台线程        demo_11.setDaemon(true);        //启动后台线程        demo_11.start();        for(int a=0;a<100;a++){            System.out.println(Thread.currentThread().getName());        }        //当main线程执行完成后，后台线程将会立即停止运行    }}

从运行结果可知：
子线程只执行到了131就执行完成，可知当前台程序执行完毕后，后台程序会立即停止执行。
3 睡眠线程
通过Thread中的sleep方法来使当前正在执行的线程暂停一段时间，
需要特别说明的是该线程调用后将进入阻塞状态，在这段时间内，该线程不会获得执行的机会，即使当前没有其他可执行的线程，也不会执行该阻塞线程，可用于来暂停程序的执行

public static void main(String[] args){        for (int a = 1; a < 100; a++) {            System.out.println("当前时间为：" + new Date());            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }    }

运行结果为间隔1秒钟打印出当前时间

4 线程让步
yield()会让当前正在执行的线程暂停但不会阻塞，该线程将会进入就绪状态,yield只是让系统的线程调度器重新调度一下，有可能有个线程调用了yield()，可是系统调度器又将其调度出来重新执行，
当线程调用了yield后，只有当前线程优先级相同或者比当前线程更高的处于就绪状态的线程才会获得执行的机会。

public class TextDemo_12 extends Thread{    public TextDemo_12(String name){        super(name);    }    public void run(){        for(int a=0;a<100;a++){            System.out.println(getName()+"  "+a);            if(a==20){                //当a等于20时让当前线程让步                Thread.yield();            }        }    }       public static void main(String[] args){        TextDemo_12 demo_12=new TextDemo_12("高级线程");        //将该线程的优先级设置为最高        demo_12.setPriority(MAX_PRIORITY);        demo_12.start();        TextDemo_12 demo_122=new TextDemo_12("低级线程");        demo_122.setPriority(MIN_PRIORITY);        demo_122.start();    }}

总结：sleep()和yield()的区别
1 sleep会暂停当前线程的执行，给其他线程机会，不会理会其他线程的优先级，但是yield()只会给优先级相同或比它优先级更高的线程执行的机会。
2 sleep会将该线程转入阻塞状态，直到经过了指定的时间才会进入就绪的状态，而yield()则强制进入阻塞状态，因此有可能某个线程在调用了yield()后又被执行

5 改变线程的优先级

public class TextDemo_12 extends Thread{    public TextDemo_12(String name){        super(name);    }    public void run(){        for(int a=0;a<100;a++){            //输出当前线程的名称和优先级            System.out.println(getName()+"  "+getPriority()+"  "+a);        }    }    public static void main(String[] args){        Thread.currentThread().setPriority(6);        for(int a=1;a<100;a++){            if(a==10){                TextDemo_12 demo_12=new TextDemo_12("低级");                demo_12.start();                //创建时的优先级为父线程的优先级，应该为6                System.out.println("创建时的优先级为"+demo_12.getPriority());                //设置优先级                demo_12.setPriority(MAX_PRIORITY);            }            if(a==20){                TextDemo_12 demo_12=new TextDemo_12("高级");                demo_12.start();                //创建时的优先级为父线程的优先级，应该为6                System.out.println("创建时的优先级为:"+demo_12.getPriority());                //设置优先级                demo_12.setPriority(MIN_PRIORITY);            }        }    }}

需要注意的是每个线程默认的优先级都与创建他的父类的优先级相同，
优先级可以用1-10的整数但是需要操作系统的支持，因此应该避免用整数，应该用MAX_PRIORITY和MIN_PRIORITY和NORM_PRIORITY静态变量来衡量，可保证更好的可移植性。
未完待续。。。