目录

1. setName和getName方法

2. 静态方法currentThread

3. 静态方法sleep

4. setPriority和getPriority方法

5. setDaemon方法

6. 静态方法yield

7. join方法

---

          下面介绍这些方法的使用，以下面的MyThread为例：

public class MyThread extends Thread{

    //由于子类不能继承父类的构造方法，所以需要自己写一个构造方法
    /*无参构造不需要自己写，因为JVM在运行时会检查有无构造方法，如果没有写则会自动添加一个无参构        
      造，实际上也是调用的父类的无参构造*/
    /*但是一旦自己写了有参构造方法，那JVM就不会自动优化了，因为会检查到已经有一个构造方法了，这时 
      无参构造就需要自己写*/
    public MyThread(String name){

        //这里调用父类Thread的有参构造方法
        super(name);
    }

    public MyThread(){

    }

    @Override
    public void run() {
        for(int i=0;i<100;i++)
            System.out.println(Thread.currentThread().getName()+"正在运行...");
    }
}

1. setName和getName方法

        setName用来设置线程的名字，也可以使用构造方法进行设置，因为Thread类就有一个有参构造方法是可以命名的；getName用来获取线程名称。

public class Main {
    public static void main(String[] args) {

        //如果不命名能否获得线程的名称
        Thread t1=new MyThread();
        Thread tt1=new MyThread();
        System.out.println(t1.getName());
        System.out.println(tt1.getName());

        //间接使用父类的构造器给线程命名
        Thread t2=new MyThread("thread2");
        System.out.println(t2.getName());

        //直接使用Thread的有参构造器
        Thread tt2=new Thread("thread22");
        System.out.println(tt2.getName());

        //使用setName给线程命名
        Thread t3=new MyThread();
        t3.setName("thread3");
        System.out.println(t3.getName());

    }
}

        补充：对于子类重写的方法，如果父类的方法没有抛异常，那么子类重写的这个方法也不能抛异常，这种情况下只能使用try-catch来捕捉异常；如果父类的方法抛了异常，那么子类重写的这个方法只能抛出父类所抛异常的父类。比如父类使用了throws NullPointerException，那么子类只能使用NullPointerException的父类，比如RuntimeException。

        运行结果：

        其中Thread-0和Thread-1是运行时系统赋予的名字，所以每个线程即使不命名也都有自己的名字，我们可以查看Thread类的无参构造函数：

        从中可以看到Thread的无参构造函数在创建实例时会进行命名，命名格式为Thread-序号，从0开始，再来看一下nextThreadNum函数：

        这里面是有一个静态成员变量threadInitNumber，每创建一个线程就进行++操作，就实现了序号的自增。

        下面则是Thread的一个可以设置名称的有参构造函数：

        相对于无参构造函数，是直接把“Thread-”和自增函数换成了name。 

2. 静态方法currentThread

        currentThread用来获取当前运行的线程，在上面的MyThread中可以看到通过调用currentThread先获取到当前线程，再调用getName获取到当前线程的名称。

public class Main {
    public static void main(String[] args) {

       Thread t=new MyThread();
    
       //通过启动线程来调用run方法，这样获取到的线程就是我们创建的线程
       t.start();
    }
}

        运行结果：

3. 静态方法sleep

        sleep方法用于让执行它的线程进入一定时间的休眠状态，等时间结束后会自动醒来，然后重新竞争CPU，竞争成功后继续运行代码；它的参数是long型的，用来输入要休眠的时间，单位为毫秒，1000毫秒等于1秒。

public class Main {
    public static void main(String[] args) throws InterruptedException {

        System.out.println("休眠前");
        
        //让main线程进行休眠
        Thread.sleep(8000);
        
        System.out.println("休眠结束后");
    }
}

        运行结果： 

        JVM在启动时会自动启动多条线程，其中一条就是main线程，用于执行main函数中的代码。

4. setPriority和getPriority方法

        多线程在占用CPU时有两种方式：一种是抢占式调度，多个线程同时竞争CPU，谁能成功抢到CPU完全是随机的，并且每次分配的CPU占用时间也是随机的；另一种是非抢占式调度，CPU轮流分配给这些线程，每次分配的时间都是差不多的。而java采用的是抢占式调度，多个线程需要进行竞争，谁能抢到CPU完全随机，只不过可以通过设置线程的优先级来提高随机到该线程的概率，注意只是提高了概率，并不是谁优先级高就一定先抢到；优先级从1到10，数字越大优先级越高，默认的优先级是5。

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        Thread t2=new MyThread("thread2");

        //查看自己创建的线程的默认优先级和main线程的优先级
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        System.out.println(Thread.currentThread().getPriority());

    }
}

        运行结果优先级都是5：

        通过查看Thread的源码就可以知道最小优先级是1，最大优先级是10，默认优先级是5：

        可以通过给两个线程设置不同的优先级，多运行几次，看看谁先执行完的次数多：

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        Thread t2=new MyThread("thread2");

        //分别设置t1和t2的优先级，运行多次查看哪个线程最后执行完的次数多
        t1.setPriority(2);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}

        实际运行多次后会发现，由于t2线程设置的优先级为10，所以t2先执行完的次数更多，但也有t1先执行完的情况，这就是为什么说优先级只是提高随机到的概率了。

5. setDaemon方法

        这个方法的作用就是将当前线程设置为守护线程，通俗一点来讲就是“备胎线程”，当其他线程运行结束时，守护线程如果还没有执行完就会在很短的时间内陆续结束运行。

        至于为什么是陆续结束而不是瞬间就结束，是因为当其他线程运行结束后会告诉守护线程自己执行结束了，这个告诉守护线程的过程也需要时间的，守护线程在这段时间内由于还没有收到结束的信息会继续执行，等收到执行结束的消息后就会立刻停止运行。所以陆续停止运行指的就是这段时间内仍在运行，收到消息后立刻停止运行，并且不同线程收到停止运行所需的时间也不同，就表现为了陆续停止。

        这里为了减少演示的时间，另写了一个重复执行10次的线程作为普通线程，上面的MyThread作为守护线程：

//另写的一个线程
public class AnotherThread extends Thread{
    public AnotherThread(String name){
        super(name);
    }

    public AnotherThread(){

    }

    @Override
    public void run() {
        for(int i=0;i<10;i++)
            //同时也修改了MyThread的输出为"第"+i+"次运行"，能够明显的看出运行的次数
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
    }
}

         然后开始测试：

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        Thread t2=new AnotherThread("thread2");

        //设置t1为守护进程
        t1.setDaemon(true);

        //启动两个线程，观察守护线程t1的运行次数
        t1.start();
        t2.start();
    }
}

        运行结果：

         由运行结果可以看出，守护线程t1还没有运行完100次循环就结束了，但在普通线程结束后又运行了一段时间，这就是守护线程的陆续运行结束。 

6. 静态方法yield

        yield方法又叫出让线程或礼让线程，在线程执行时使用，用来出让CPU的占用权，可以使得多个线程在执行时占用CPU的次数更均匀。要注意的是，这个方法只能是让多线程运行的结果尽可能均匀，并不是绝对的，虽然出让了CPU的占用权，但出让后这个线程也可以再次竞争CPU的占用权，由于java使用的是抢占式调度，所以出让CPU后谁能抢到还是随机的，还是有可能出现尽管使用了yield方法还是有某个线程长时间连续执行的现象，通俗的讲就是“给你机会你不中用呀”。

        演示：

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

    public MyThread(){

    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
            
            //执行完一次输出后出让CPU占用权
            Thread.yield();
        }
            
    }
}

//测试
public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        Thread t2=new MyThread("thread2");

        //启动两个线程，观察两个线程运行结果是否均匀
        t1.start();
        t2.start();
    }
}

        运行结果：

        还是有这种给t2线程机会不中用的情况：

        也有运行结果均匀的情况：

7. join方法

        join方法可以让调用它的线程插入到当前正在运行的线程之前先执行，等其执行完毕后原来的当前线程才会执行。

        分三种情况演示：

•  第一种情况

//MyThread类
public class MyThread extends Thread{

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

    public MyThread(){

    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
        }

    }
}

//第一种情况演示
public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");
        
        //在main线程中执行10次打印
        for(int i=0;i<10;i++)
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
        
        t1.start();
        
        t1.join();
    }
}

        运行结果：

         这种情况join似乎并没有起作用，这是因为先执行的for循环，此时t1线程还没有开启。

• 第二种情况

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");

        t1.start();

        //在main线程中执行10次打印
        for(int i=0;i<10;i++)
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
        
        t1.join();
    }
}

        这种情况join似乎也没有起到作用，这是因为main线程执行到for循环时还没有执行到t1.join，此时还是main线程和t1线程共同抢占CPU。

• 第三种情况

public class Main {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new MyThread("thread1");

        t1.start();

        t1.join();

        //在main线程中执行10次打印
        for(int i=0;i<10;i++)
            System.out.println(Thread.currentThread().getName()+"第"+i+"次运行");
    }
}

        运行结果： 

        从结果可以看到这种情况下join起到了作用，main线程不会和t1线程抢夺CPU，t1线程先执行完后main线程的循环部分才开始执行，这是因为先执行的join方法，让t1线程先运行，然后main线程等待t1线程结束后才继续执行，这时才执行for循环。

        所以要想join方法起到作用，就要让join方法先于main线程中的其他程序被执行。