深入了解Java的多线程API

获取线程的相关信息

我们继续来深入了解Java给我们提供的线程相关的方法

        Thread main = Thread.currentThread();
        String name = main.getName();
        System.out.println("线程的名字：" + name);

        int priority = main.getPriority();
        System.out.println("优先级为：" + priority);

        long id = main.getId();
        System.out.println("线程的Id：" + id);

        boolean daemon = main.isDaemon();
        System.out.println("是否为守护线程：" + daemon);

        boolean isAlive = main.isAlive();
        System.out.println("是否活着：" + isAlive);

        boolean isInterrupted = main.isInterrupted();
        System.out.println("是否中断：" + isInterrupted);

---

 

线程优先级

线程start后会纳入到线程调度器中统一管理,线程只能被动的被分配时间片并发运行,而无法主动索取时 间片.线程调度器尽可能均匀的将时间片分配给每个线程.

线程有10个优先级,使用整数1-10表示

1为最小优先级,10为最高优先级.5为默认值

调整线程的优先级可以最大程度的干涉获取时间片的几率.优先级越高的线程获取时间片的次数越 多,反之则越少.

Thread提供了对应的常量:MAX_PRIORITY表示最高优先级10，MIN_PRIORITY表示最低优先级， NORM_PRIORITY表示默认优先级5

        Thread min = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    System.out.println("min");
                }
            }
        };
        Thread max = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    System.out.println("max");
                }
            }
        };
        Thread norm = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    System.out.println("nor");
                }
            }
        };

        min.setPriority(Thread.MIN_PRIORITY);
        max.setPriority(Thread.MAX_PRIORITY);

        max.start();
        min.start();
        norm.start();

---

 

线程的阻塞 

 线程提供了一个静态方法:

static void sleep(long ms)

使运行该方法的线程进入阻塞状态指定的毫秒,超时后线程会自动回到RUNNABLE状态等待再次获 取时间片并发运行.

        Scanner scanner = new Scanner(System.in);
        System.out.println("请设置倒计时的时间");
        long time = scanner.nextLong();
        System.out.println("倒计时开始");
        for (long i = time; i > 0; i--) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("场地已清空");

值得注意的是：sleep方法不能拿来当精确的计时器，有误差，不能拿来精准控制时间

sleep阻塞

sleep方法处理异常:InterruptedException.

当一个线程调用sleep方法处于睡眠阻塞的过程中,该线程的interrupt()方法被调用时,sleep方法会抛出该 异常从而打断睡眠阻塞. 

 

        Thread t1 = new Thread("张三") {
            @Override
            public void run() {
                System.out.println(getName() + "睡觉咯");
                try {
                    Thread.sleep(100000000);
                } catch (InterruptedException e) {
                    System.out.println(getName() + ":干嘛呢，我睡觉呢，吵什么！");
                }
                System.out.println(getName() + ":醒了");
            }
        };

        Thread t2 = new Thread("李四") {
            @Override
            public void run() {
                System.out.println(getName() + "干活咯");
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                System.out.println(getName() + "给我飞起来");
                t1.interrupt();
            }
        };
        t2.start();
        t1.start();

守护线程 

守护线程也称为:后台线程、精灵线程

守护线程是通过普通线程调用setDaemon(boolean on)方法设置而来的,因此创建上与普通线程无 异. 守护线程的结束时机上有一点与普通线程不同,即:进程的结束.

进程结束:当一个进程中的所有普通线程都结束时,进程就会结束,此时会杀掉所有正在运行的守护线 程.

用途： GC就是运行在守护线程上的 当我们有一个任务不需要关注何时结束，当程序需要结束时可以一起结束的任务就可以放在守护线 程上执行 

 

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

        Thread jack = new Thread("jack") {
            @Override
            public void run() {
                while (true) {
                    System.out.println(getName() + ":you jump,i jump!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        jack.setDaemon(true);
        rose.start();
        jack.start();

        while (true) ;