10 守护线程，线程优先级

Daemon线程（守护线程）

Daemon线程是一种支持型线程，它主要被用作程序中后台调度以及支持性工作。

Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。

通过调用Thread.setDaemon(true)将线程设置为Daemon线程。

/**
 * 守护线程
 */
public class DaemonThread {
    public static void main(String[] args) {
        Thread thread = new Thread(new DaemonRunner(), "DaemonRunner");
        thread.setDaemon(true);
        thread.start();
        System.out.println("main线程执行完毕");
    }
    static class DaemonRunner implements Runnable {
        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("DaemonThread finally run.");
            }
        }
    }
}

// thread.setDaemon(true) 设置为守护线程执行结果
main线程执行完毕

// thread.setDaemon(fasle) 设置为非守护线程执行结果
main线程执行完毕
DaemonThread finally run.

守护线程随Java虚拟机退出而退出。即main线程执行完毕后，守护线程立即终止。

---

线程优先级

Java 通过一个整型成员变量priority来控制优先级。优先级高的线程分配时间片的数量要多于优先级低的线程。

优先级的范围从1~10。数字越大优先级越高。默认优先级是5。

但是并不能保证优先级高的线程就会先执行，实际上这个设置没有效果(切下面示例)

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * java 线程优先级测试
 */
public class Priority {

    private static volatile boolean notStart = true;
    private static volatile boolean notEnd = true;

    public static void main(String[] args) throws Exception {
        List<Job> jobs = new ArrayList<Job>();
        for (int i = 0; i < 10; i++) {
            int priority = i < 5 ? Thread.MIN_PRIORITY : Thread.MAX_PRIORITY;
            Job job = new Job(priority);
            jobs.add(job);
            Thread thread = new Thread(job, "Thread:" + i);
            thread.setPriority(priority);
            thread.start();
        }
        notStart = false;//通知Job开始执行jobCount++；没执行一次+1就让出CPU给其他线程
        TimeUnit.SECONDS.sleep(10);
        notEnd = false;//通知Job停止jobCount++
        for (Job job : jobs) {
            System.out.println("Job Priority : " + job.priority + ", Count : " + job.jobCount);
        }
    }

    static class Job implements Runnable {
        private int priority;
        private long jobCount;
        public Job(int priority) {
            this.priority = priority;
        }
        public void run() {
            while (notStart) {
                Thread.yield();
            }
            while (notEnd) {
                Thread.yield();
                jobCount++;
            }
        }
    }
}

Job Priority : 1, Count : 41521853
Job Priority : 1, Count : 41414249
Job Priority : 1, Count : 39152917
Job Priority : 1, Count : 41640620
Job Priority : 1, Count : 41606401
Job Priority : 10, Count : 41551815
Job Priority : 10, Count : 41044043
Job Priority : 10, Count : 41260994
Job Priority : 10, Count : 39221399
Job Priority : 10, Count : 41101206

线程sleep方法

​ 睡眠，当前线程睡眠一段时间，暂时将cpu让给其他线程执行，睡眠时间到了，就开始竞争cpu。

线程yield方法

​ 当前线程正则执行的时候停下来进入等待队列。即让当前线程重新竞争cpu