java多线程系列基础篇10-----线程优先级和守护线程

1 线程优先级的介绍

java中的线程优先级的范围是1-10，默认的优先级是5。"高优先级线程"会优先于"低优先级线程"执行

java中有两种线程:用户线程和守护线程。可以通过isDaemon()方法来区别他们：如果返回false，则说明该线程是"用户线程"；否则就是"守护线程"

用户线程一般用户执行用户级任务，而守护线程也就是后台线程，一般用来执行后台任务，需要注意的是：java虚拟机在"用户线程"都结束后会退出

JDK中关于线程优先级和守护线程的介绍如下

每个线程都有一个自己的优先级，高优先级会优先于低优先级执行，每个线程都可以被标记为一个守护进程或非守护进程，在一些运行的主线程中创建新的子线程时，子线程的优先级被设置为等于"创建它的主线程的优先级"，当且仅当"创建它的主线程是守护线程"时"子线程才会是守护线程"

当java虚拟机启动时，通常有一个单一的非守护线程(该线程通过是通过main()方法启动).。JVM会一直运行直到下面的任意一个条件发生，JVM就会终止运行。

01)调用了exit()方法，并且exit()有权被正常执行

02)所有的"非守护线程"都死了(即jvm中仅仅只有"守护线程")

每一个线程都被标记为"守护线程"或"用户线程".当只有守护线程运行时,JVM会自动退出。

线程优先级的示例

package com.tuhu.filt.javadatasleep;

public class Demo {
    public static void main(String[] args) {
        System.out.println(
                Thread.currentThread().getName()
                +"("
                +Thread.currentThread().getPriority()
                +")"
        );

        Thread t1 = new MyThread2("t1");
        Thread t2 = new MyThread2("t2");
        t1.setPriority(1); //设置t1的优先级为1
        t2.setPriority(10);//设置t2的优先级为10
        t1.start();
        t2.start();
    }
}
class MyThread2 extends  Thread{
    public MyThread2(String name){
        super(name);
    }

    public void run(){
        for(int i = 0;i < 5;i++){
            System.out.println(
                    Thread.currentThread().getName()
                    +" ("
                    +Thread.currentThread().getPriority()
                    +")"
                    +", loop "
                    +i
            );
        }
    }
}

main(5)
t2 (10), loop 0
t2 (10), loop 1
t2 (10), loop 2
t2 (10), loop 3
t2 (10), loop 4
t1 (1), loop 0
t1 (1), loop 1
t1 (1), loop 2
t1 (1), loop 3
t1 (1), loop 4

01 它主线程main的优先级是5

02 t1的优先级设为1  t2的优先级设为10 cpu在执行t1和t2的时候，根据时间片轮询调度，所以能够并发执行

3 守护线程的示例

package com.tuhu.filt.javadataDemo;

public class Demo {
    public static void main(String[] args) {
        System.out.println(
                Thread.currentThread().getName()
                        +"(isDaemon="+Thread.currentThread().isDaemon()+ ")"
        );
        Thread t1 = new MyThread("t1");
        Thread t2 = new MyThread("t2");
        //将t2设置为守护线程
        t2.setDaemon(true);
        t1.start();
        t2.start();
    }
}
class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    public void run(){
        try{
            for (int i = 0;i < 5;i++){
                Thread.sleep(3);
                System.out.println(
                        this.getName()
                        +"(isDaemon="
                        +this.isDaemon()
                        +")"
                        +", loop "+i
                );
            }
        }catch (InterruptedException e){
        }
    }
}
class MyDaemon extends Thread{
    public MyDaemon(String name){
        super(name);
    }
    public void run(){
        try{
            for(int i = 0;i<10000;i++){
                Thread.sleep(1);
                System.out.println(
                        this.getName()
                        +"(isDaemon="
                        +this.isDaemon()
                        +")"
                        +", loop"
                        +i
                );
            }
        }catch (InterruptedException e){

        }
    }
}

main(isDaemon=false)
t1(isDaemon=false), loop 0
t2(isDaemon=true), loop 0
t1(isDaemon=false), loop 1
t2(isDaemon=true), loop 1
t2(isDaemon=true), loop 2
t1(isDaemon=false), loop 2
t2(isDaemon=true), loop 3
t1(isDaemon=false), loop 3
t2(isDaemon=true), loop 4
t1(isDaemon=false), loop 4

01 主线程main是用户线程，它创建的子线程t1也是用户线程

02 t2是守护线程，在"主线程main" 和 "子线程t1"(他们都是用户线程)执行完毕，只剩t2这个守护线程的时候JVM自动退出