Java并发编程（二）：线程优先级及守护线程

女爷i 2022-05-14 04:19 218阅读 0赞

### 文章目录 ###

*   *   *  1、简述
         *  2、如何设置线程优先级
         *  3、什么是守护线程

### 1、简述 ###

在操作系统中，线程是可以划分优先级的，优先级较高的线程，得到CPU优先执行的几率就较高一些。设置线程的优先级，有助于帮助线程规划期选择下一个哪一个线程优先执行，但是线程优先级高不代表一定会优先执行，这在下文会说明原因

### 2、如何设置线程优先级 ###

设置线程优先级的方法是 setPriority，jdk中该方法的代码如下：

public final void setPriority(int newPriority) {
            ThreadGroup g;
            checkAccess();
            if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
                throw new IllegalArgumentException();
            }
            if((g = getThreadGroup()) != null) {
                if (newPriority > g.getMaxPriority()) {
                    newPriority = g.getMaxPriority();
                }
                setPriority0(priority = newPriority);
            }
        }

在java中，线程的优先级分为1~10，这10个等级，如果优先级的值小于1或大于10，则jdk就会抛出异常 throw new IllegalArgumentException（）。在jdk中使用3个常量来预定义优先级的值：

/**
         * 线程最小优先级
         */
        public final static int MIN_PRIORITY = 1;
    
       /**
         * 线程默认优先级
         */
        public final static int NORM_PRIORITY = 5;
    
        /**
         * 线程最大优先级
         */
        public final static int MAX_PRIORITY = 10;

线程优先级具有3中特性，分别是：继承性、规则性、随机性，下面将一一说明：

**1、继承性**

在Java中，线程的优先级具有继承性，比如线程A启动线程，则线程B的优先级与线程A是一样的

public class ThreadA extends Thread {
        @Override
        public void run() {
            System.out.println(" ThreadA run priority=" + this.getPriority());
            ThreadB thread2 = new ThreadB();
            thread2.start();
        }
    }
    
    public class ThreadB extends Thread {
        @Override
        public void run() {
            System.out.println(" ThreadB run priority=" + this.getPriority());
        }
    }
    
    public class ThreadDemo {
        public static void main(String[] args) {
            Thread.currentThread().setPriority(6);
            System.out.println(" main thread priority=" + Thread.currentThread().getPriority());
    
            ThreadA threadA = new ThreadA();
            threadA.start();
        }
    }

输出结果：

main thread priority=6
     ThreadA run priority=6
     ThreadB run priority=6

从结果可以看出，ThreadA继承了main的优先级，ThreadB继承了ThreadA的优先级

**2、规则性**

public class ThreadA extends Thread {
        @Override
        public void run() {
            long beginTime = System.currentTimeMillis();
            long aCount = 0;
            for (int i = 0; i < 50000; i++) {
                Random random = new Random();
                aCount += random.nextInt() + i;
            }
            long endTime = System.currentTimeMillis();
            System.out.println(" ★ ★ ★ ★ ★ thread A use time=" + (endTime - beginTime));
        }
    }
    
    public class ThreadB extends Thread {
        @Override
        public void run() {
            long beginTime = System.currentTimeMillis();
            long bCount = 0;
            for (int i = 0; i < 50000; i++) {
                Random random=new Random();
                bCount+=random.nextInt()+i;
            }
            long endTime = System.currentTimeMillis();
            System.out.println(" ☆ ☆ ☆ ☆ ☆ thread B use time=" + (endTime - beginTime));
        }
    }
    
    
    public static void main(String[] args) {
            for (int i = 0; i < 5; i++) {
                ThreadA threadA = new ThreadA();
                threadA.setPriority(10);
                threadA.start();
    
                ThreadB threadB = new ThreadB();
                threadB.setPriority(6);
                threadB.start();
            }
        }

输出结果：

★ ★ ★ ★ ★ thread A use time=23
     ☆ ☆ ☆ ☆ ☆ thread B use time=29
     ★ ★ ★ ★ ★ thread A use time=29
     ☆ ☆ ☆ ☆ ☆ thread B use time=34
     ★ ★ ★ ★ ★ thread A use time=34
     ★ ★ ★ ★ ★ thread A use time=36
     ☆ ☆ ☆ ☆ ☆ thread B use time=38
     ☆ ☆ ☆ ☆ ☆ thread B use time=37
     ★ ★ ★ ★ ★ thread A use time=7
     ☆ ☆ ☆ ☆ ☆ thread B use time=4

运行多次之后，我们发现高优先级的线程总是大部分先执 完，但不代表高优先级的 线程全部先执行完。说明线程的优先级具有一定的规则性，也就是CPU尽量将执行资源 让给优先级比较高的线程。

**3、随机性**

前面的事例证明了线程的优先级较高则优先执行完 run（）方法中的任务， 但这个结果不是肯定的， 因为线程的优先级还具有随机性，也就是线程优先级高的线程并不一定每次都先执行完  
。将上述事例两个线程的优先级分别调整为相近的优先级，运行多次后就会发现这种随机性。

### 3、什么是守护线程 ###

在Java线程中有两种类型的线程，一种是用户线程，另一种是守护线程。

守护线程是一种特殊的线程，典型的守护线程就是垃圾回收线程，当进程中没有用户线程了，则垃圾回收线程也就没有存在的必要了，会自动销毁。

public class MyThread extends Thread {
        private int i = 0;
    
        @Override
        public void run() {
            try {
                while (true) {
                    i++;
                    System.out.println(" i=" + (i));
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public class ThreadDemo {
        public static void main(String[] args) {
            try {
                MyThread thread = new MyThread();
                thread.setDaemon(true);
                thread.start();
                Thread.sleep(5000);
                System.out.println("主线程执行完毕了，守护线程也要停止了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

输出结果：

i=1
     i=2
     i=3
     i=4
     i=5
    主线程执行完毕了，守护线程也要停止了