1。设置线程名
    继承Thread类的线程，可以直接使用.setName()方法，设置线程名。也可以使用构造方法，需要注意java默认不继承构造方法，所以需要自己调用下父类的构造方法。

public class Demo {
    public static void main(String[] args) {
        MyThread myThread1=new MyThread("飞机");
        myThread1.start();
        MyThread myThread2=new MyThread();
        myThread2.setName("火箭");
        myThread2.start();
        //当jvm虚拟机启动后，会自动的启动多条线程，其中一条是main主线程
        //主线程的作用是调用main方法，并执行其中的代码，在以前，我们写的所有代码，其实都是运行在main线程中
        Thread thread=Thread.currentThread();
        System.out.println(thread.getName());

        //获取优先级
        System.out.println(myThread1.getPriority());
        //线程的默认优先级都是5，包括main线程
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; ++i) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //在不设置线程名的情况下，线程名默认是Thread+线程序号
            System.out.println(getName());
        }
    }

    //构造方法子类默认不继承，所以这里需要通过super关键字调用父类Thread的构造方法，给Thread设置名字
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }
}

 实现runnable接口的线程，可以使用.setName方法。但是不能使用构造方法，因为他不像上面继承Thread类的线程，他没有父类的构造方法可以调用。

public class Mythread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; ++i) {
            String name = Thread.currentThread().getName();
            System.out.println("你好世界！"+"----"+name);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Mythread mythread=new Mythread();

        Thread t1=new Thread(mythread);
        t1.setName("线程1");
        Thread t2=new Thread(mythread);
        t2.setName("线程2");

        t1.start();
        t2.start();
        //获取优先级
        System.out.println(t1.getPriority());
    }
}

2. join方法  当前线程需要等待 调用join方法的线程执行完毕，当前线程才能继续执行

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();

        // 在默认情况下，当前线程和在当前线程添加的线程会交替执行
        // 使用了join方法后，当前线程会等待myThread执行完毕，后继续执行本线程
        myThread.join();
        for (int i = 0; i < 10; i++) {
            Thread.sleep(1);//模拟主线程执行耗时
            System.out.println(Thread.currentThread().getName());
        }
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; ++i) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("自定义线程"+i);
        }
    }
}

执行结果：MyThread执行完后，才执行main线程的输出语句

3。

setDaemon

守护线程：当其他非守护线程执行完毕，守护线程不管是否执行完毕，都会停止。

就像舔狗（守护线程）和女神（非守护线程），如果女神走了，那舔狗啥都不管，也走。

主线程

public class Demo {
    public static void main(String[] args) {
        NvShenThread nvShenThread=new NvShenThread();
        TianGouThread tianGouThread =new TianGouThread();
        //将舔狗线程设置为守护线程 守护线程：当其他非守护线程执行完毕，会自动停止守护线程
        //应用场景：qq聊天和发送文件，聊天框关闭，发送文件也应当停止
        tianGouThread.setDaemon(true);
        nvShenThread.start();
        tianGouThread.start();
    }
}

女神线程（非守护线程）

public class NvShenThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("女神线程执行"+"----"+i);
        }
    }
}

舔狗线程（守护线程）

public class TianGouThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("舔狗线程执行"+"----"+i);
        }
    }
}