线程的其他特征

睡眠：

//使用sleep控制线程运行
public class Test9 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        new Thread(new MyTask()).start();
        new Thread(new MyTask2()).start();

    }

}

class  MyTask implements Runnable{
    @Override
    public void run() {
        //
        for (int i = 0; i < 10000; i++) {
            System.out.println("线程名:"+Thread.currentThread().getName()+":"+i);
        }

    }


}

class  MyTask2 implements Runnable{
    @Override
    public void run() { 
        for (int i = 0; i < 10000; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {

                e.printStackTrace();
            }
            System.out.println("线程名:"+Thread.currentThread().getName()+":"+i);
        }


    }


}

优先级：

//使用优先级控制线程运行
public class Test10 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Thread t1=new Thread(new MyTask3());
        t1.setPriority(10);
        t1.start();
        Thread t2=new Thread(new MyTask4());
        t2.setPriority(10);
        t2.start();

    }

}

class  MyTask3 implements Runnable{
    @Override
    public void run() {
        //
        for (int i = 0; i < 10000; i++) {
            System.out.println("线程名:"+Thread.currentThread().getName()+":"+i);
        }

    }


}

class  MyTask4 implements Runnable{
    @Override
    public void run() { 
        for (int i = 0; i < 10000; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {

                e.printStackTrace();
            }
            System.out.println("线程名:"+Thread.currentThread().getName()+":"+i);
        }


    }   

}

join

在一个线程中调用另一个线程的join方法  则当前线程阻塞  让另一个线程先运行

//使用join控制线程运行
public class Test11 {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // main线程
        LifeCircle lc=new LifeCircle();
        System.out.println(lc.isAlive());//线程状态值
        lc.start();
        System.out.println(lc.isAlive());
        lc.join();//则表示当前线程阻塞 让lc运行完 再运行
        System.out.println("主程序");
        System.out.println(lc.isAlive());

    }

}

class LifeCircle extends Thread{

    @Override
    public void run() {
        int i=0;
        while((++i)<10){
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


        }
    }
}

yiled

yield 与sleep的区别

1.sleep给其他线程运行的机会  但不考虑其他线程的优先级 但是yield只会让给相同或更高优先级的线程
2.sleep有异常  yield 没有
3.当线程执行了sleep方法后  将转到阻塞状态  而执行了yield方法之后 则转到就绪状态 所以yield后可能执行一次或几次。




public class Test12 {

    /**
     * yield余sleep的区别
     * 1.sleep给其他线程运行的机会  但不考虑其他线程的优先级 但是yield只会让给相同或更高优先级的线程
     * 2.sleep有异常  yield 没有
     * 3.当线程执行了sleep方法后  将转到阻塞状态  而执行了yield方法之后 则转到就绪状态 所以yield后可能执行一次或几次
     */
    public static void main(String[] args) {
        //挂起线程
        YieldOne y1=new YieldOne();
        YieldOne y2=new YieldOne();

        Thread t1=new Thread(y1,"a");//10
        Thread t2=new Thread(y2,"b");//1

        t1.setPriority(1);
        t1.start();

        t2.setPriority(10);//第二个线程的优先级高
        t2.start();


    }

}

class  YieldOne implements Runnable{
    @Override
    public void run() {
        if("a".equals(Thread.currentThread().getName())){
            Thread.yield();//yield只会将执行权交给优先级高的线程
//          try {
//              Thread.sleep(100);
//          } catch (InterruptedException e) {//sleep不管优先级   只要调用sleep 则当前线程睡 其他接过执行权
//              // TODO Auto-generated catch block
//              e.printStackTrace();
//          }
        }
        for (int i = 0; i <100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);;
        }
    }




}