黑马程序员_Java基础[28]_线程3、优先级、线程组

---------- android培训 、 java培训 、期待与您交流！ ----------

/*
 * 停止线程
 *
 * 1、定义循环结束标记
 *         因为线程运行代码一般都是循环，只要控制了循环即可
 *             如何停止方法，
 *             原理就是，run方法结束
 *             开启多线程运行，运行代码通常都是循环结构，
 *             只要控制住循环，就可以让run结束，也就是线程结束
 * 2、使用interrupt（中断）方法
 *         该方法是结束线程的冻结状态，使线程回到运行状态
 * 注意：stop 方法已经过时，不在使用。
 *
 * 特殊情况：
 * 当线程处于了冻结状态，
 * 就不会读取到标记，那么线程就不会结束。
 *
 * 当没有指定的方式让冻结的线程恢复到运行状态时，需要对冻结进行清除
 * 强制让线程恢复到运行状态中来，这样就可以操作编辑让线程结束。
 * Thread 类中提供了该方法： interrupt();
 *
 * setDaemon();设置为守护线程（后台线程）。
 *         1、必须在启动线程前运行。
 *         2、【开启后台，前台线程一结束，后头就跟着结束】
 *
 * 【】
 * 【jion】
 *  就是让main线程释放执行权的意思，并且直到jion结束，main才能获得执行权
 * 当jion前是一个线程时，主线程会在该线程结束后取得执行权
 * 当jion前是两个以上的线程时候，主线程放弃执行权后，这两个以上的线程会相互抢夺执行权，
 *         一直到jion当前线程结束，主线程才能获取执行权，并参与与剩下的线程相互抢夺中。
 *         至于jion当前线程结束前，其他线程能否执行完毕，随机性非常强。
 *
 * 【】
 * 【 优先级】，【线程组】
 * setPriority();设置优先级
 * yield()   零时释放，遇见该方法就释放执行权
 *
 *
 * 什么时候使用线程
 * 当一个程序中，出现多个独立循环的时候，
 * 当某些代码，需要被同时执行时，就用单独的线程需要封装。
 * 看【】
 */



//【1】
class StopThread implements Runnable{
    private boolean flag=true;
    public synchronized void run(){
        while(flag){
            try{
                wait();
            }
            catch(InterruptedException e){
                System.out.println(Thread.currentThread().getName()+"....exception");
                flag=false;
            }
            System.out.println(Thread.currentThread().getName()+"....run");
        }
    }
    public void changeFlage(){
        flag=false;
    }
}
public class D_Th_clossThread {
    public static void main(String []args){
        
        StopThread st=new StopThread();
        
        //new Thread(new StopThread() ).start();

        Thread t1=new Thread(st);
        Thread t2=new Thread(st);
        t1.setDaemon(true);//设置为后台线程
        t2.setDaemon(true);
        t1.start();
        t2.start();

        int num=0;
        while(true)
        {
            if((num++) ==60){
                //st.changeFlage();
                t1.interrupt();
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"...."+num);
        }
        System.out.println("over");
    }
}
//【2】
class  Demo implements Runnable{
    public void run() {
        for(int i=0;i<70;i++){
            System.out.println(Thread.currentThread().getName()+"..."+i);
        }    
    }    
}
/*个人理解，jion 就是让main线程释放执行权的意思，并且知道jion结束，main才能获得执行权
 * 当jion前是一个线程时，主线程会在该线程结束后取得执行权
 * 当jion前是两个以上的线程时候，主线程放弃执行权后，这两个以上的线程会相互抢夺执行权，
 *         一直到jion当前线程结束，主线程才能获取执行权，并参与与剩下的线程相互抢夺中。
 *         至于jion当前线程结束前，其他线程能否执行完毕，随机性非常强。
 */
class JoinDemo{
    public static void main(String []arge)throws Exception{
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
            //t1.join();
        t2.start();
        t1.join();
        for(int i=0;i<80;i++){
            System.out.println("main..."+i);
        }
        System.out.println("over");
    }
}


/* 【3】
 * 优先级，线程组，
 * setPriority（）；设置优先级
 * yield()   零时释放，遇见该方法就释放执行权
 */
class  Demo1 implements Runnable{
    public void run() {
        for(int i=0;i<70;i++){
            System.out.println(Thread.currentThread().getName()+"..."+i);
            Thread.yield();//零时释放，遇见该代码就释放执行权
        }    
    }

}
class JoinDemo2{
    public static void main(String []arge)throws Exception{
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        t1.setPriority(Thread.MAX_PRIORITY);//设置优先级为max
        t2.start();
        t1.join();
        for(int i=0;i<80;i++){
            System.out.println("main..."+i);
        }
        System.out.println("over");
    }
}
/*【4】
 * 设定该类中，出现3个循环，在这种情况下，是只有main一个线程，那么就能挨个运行，ps如果是超大循环。。。
 * 在这种情况下，这三个需要被同时运行的代码就可以用线程封装起来。
 */
class ThreadTest{
    public static void main(String []args){
        //[1] 匿名内部类  使用Thread调用子类把其中一个循环进行封装后，就可以达到2个线程同时运行。
        new Thread(){
            public void run(){
                for(int i=0;i<100;i++){    
                }
            }
        }.start();
        //[2] 主线程代码快
        for(int i=0;i<100;i++){    
        }
        //[3] 和[1] 用其中一种就行
        Runnable r=new Runnable(){
            public void run(){
                for(int i=0;i<100;i++){    
                }
            }
        };
        new Thread(r).start();

        //这样一封装，就能达到3个线程同时运算，达到高效。
    }
}

---------- android培训、 java培训 、期待与您交流！----------
黑马官网： http://edu.youkuaiyun.com/heima