day36 接着讲线程

java中  线程分为两类：用户线程和守护线程

默认我们创建的都是用户线程
* 先查看线程是什么类型通过isDaemon（）方法判断
*
* 守护线程 称为后台线程 或者 服务线程
* 当程序中所有用户线程全部执行在一起，守护线程也会随之结束
*
* 守护线程通过普通线程调用setDaemon方法设置而来
* 守护线程和用户线程结束上的区别 进程的结束
* java进程中所有的用户线程都结束时 进程结束   会强制杀死正在执行的守护线程

 Thread rose = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("rose:let go");
            }
        };

        Thread jack = new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("jack: i will follow you");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        rose.start();
        jack.setDaemon(true);
        jack.start();

Join方法可以协调线程之间的同步运行

 

public class JoinDemo {
    static boolean isFinish = false;

    public static void main(String[] args) {

        Thread download = new Thread() {
            @Override
            public void run() {
                System.out.println("开始下载图片....");
                for (int i = 1; i <= 100; i++) {
                    System.out.println("down" + i + "%");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                System.out.println("图片下载完毕");
                isFinish = true;

            }
        };
        Thread show = new Thread() {
            @Override
            public void run() {
                System.out.println("show：开始显示文字");
                try {
                    System.out.println("show：开始显示文字");
                    Thread.sleep(3000);
                    System.out.println("show：显示文字完毕");


//                    download.join();
                    System.out.println("show：开始显示图片");
                    if (!isFinish) {
                        throw new RuntimeException("加载失败");
                    }
                    System.out.println("show：显示图片完成");


                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        show.start();
        download.start();
    }
}

获取执行方法的线程

 

java中所有代码都是靠线程执行的 main方法也不例外  jvm启动后会创建一条线程来执行main方法
* 该线程的名字叫做main  通常情况下叫他主线程
*
* 我们自己定义的线程在不指定名字的情况下系统会分配一个名字  格式为 thread-xxx  （xxx是一个数字）
*
* Thread提供了一个静态方法
* static Thread currentThread（）  获取执行方法的线程

/**
 * API:  ThreadLocal  他可以在一个线程跨越多个方法时
 * 共享数据使用  内部用到currentThread（）方法辨别线程
 *
 * Spring框架 事务控制就是依靠currentThread（）实现的
 */

public class Method {
    public static void main(String[] args) {
        /**
         * API:  ThreadLocal  他可以在一个线程跨越多个方法时
         * 共享数据使用  内部用到currentThread（）方法辨别线程
         *
         * Spring框架 事务控制就是依靠currentThread（）实现的
         */
        Thread main = Thread.currentThread();

        doMain();//获取的依然是主线程,因为是主线程在执行doMain方法

    }
    public static void doMain(){
        Thread t = Thread.currentThread();
        System.out.println(t);
    }
}

线程的优先级

 

 线程共10个优先级  分别对应1-10  1最低  5为默认
* 线程启动后纳入到线程调度其中统一管理 线程不能主动索取时间片
* 调度器会尽可能平均分配时间片给每一个线程 调整线程的优先级获取时间片的概率
* 优先级越高 获取时间片的次数就越多
* cpu为多核心  分配到不同核心上的线程优先级不起作用

public class PriorityDemo {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("1");
                }
            }
        };

        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("2");
                }
            }
        };

        Thread t3 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("3");
                }
            }
        };

        t1.setPriority(Thread.MIN_PRIORITY);
        t3.setPriority(Thread.MAX_PRIORITY);

        t1.start();
        t2.start();
        t3.start();

    }
}

方法Thread.sleep();

输入一个数，实现倒计时

public class SleepDemo {
    public static void main(String[] args) {
//        System.out.println("1");
        try {
            Scanner scanner = new Scanner(System.in);
            Integer s = scanner.nextInt();
//            Thread.sleep(1000*s);
            for (int i = s; i >0; i--) {
                System.out.println(i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("--------");
    }
}

 

---

---

/**
 * 向Sleep这样的方法会导致线程进入阻塞状态，该方法要求必须处理中断异常InterruptedException
 * 当以个线程调用sleep处于阻塞状态的过程中该线程的interrupt方法被调用了，那么就会立即中断该线程
 * 的阻塞，此时sleep方法会抛出异常
 */

public class SleepDemo2 {
    public static void main(String[] args) {
        Thread lin = new Thread(){
            @Override
            public void run() {
                System.out.println("111");
                try {
                    Thread.sleep(1000000);
                } catch (InterruptedException e) {
//                    e.printStackTrace();
                    System.out.println("222222");
                }
                System.out.println("3333333333");
            }
        };


        Thread t2 = new Thread(){
            @Override
            public void run() {
                System.out.println("你好");
                for (int i = 0; i < 8; i++) {
                    System.out.println("扣你吉瓦");
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
//                        e.printStackTrace();
                    }
                }
                System.out.println("放剋");
                lin.interrupt();
            }
        };
        lin.start();
        t2.start();
    }
}

 

  获取线程的详细信息

public class ThreadInfoDemo {
    public static void main(String[] args) {
        //获取主线程
        Thread main = Thread.currentThread();
        //获取主线程的名字
        String name = main.getName();
        System.out.println(name);

        //获取主线程的Id    ID：非空且唯一
        long id = main.getId();
        System.out.println(id);

        //获取线程的优先级：优先级对应的整数为 1 -10
        int priority = main.getPriority();
        System.out.println("主线程的优先级：" + priority);

        //查看线程是否存活
        boolean alive = main.isAlive();
        System.out.println("主线程是否是活着的" + alive);

        //查看线程是否是守护线程
        boolean daemon = main.isDaemon();
        System.out.println("主线程是否是守护线程" + daemon);

        main.interrupt(); //中断线程

        //查看线程是否被中断
        boolean interrupted = main.isInterrupted();
        System.out.println("主线程是否被中断："+interrupted);
    }
}