Java的Thread类中的常用方法解析

Java可以通过Thread类实现多线程，下面来介绍几个Thread类中常用的方法

void start()

开启线程，jvm自动调用run方法

void run()

设置线程任务，这个run方法是Thread重写的接口Runnable中的run方法

String getName()

获取线程名字

void setName(String name)

给线程设置名字

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();//创建线程对象
        t1.setName("金莲");//给线程设置名字
        t1.start();//调用start方法,开启线程,jvm自动调用run方法
        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName()+"线程执行了"+i);
        }
    }
}

static Thread currentThread()

获取正在执行的线程对象(此方法在哪个线程中使用，获取的就是哪个线程对象)，也可以在主线程当中使用。

static void sleep(long millis)

线程睡眠，超时后自动醒来继续执行，传递的是毫秒值

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000L); //线程睡眠
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"执行了"+i);
        }
    }
}

void setPriority(int newPriority)

设置线程优先级，优先级越高的线程，抢到CPU使用权的几率越大，但是不是每次都先抢到

int getPriority()

获取线程优先级

void setDaemon(boolean on)

设置为守护线程，当非守护线程执行完毕，守护线程就要结束，但是守护线程也不是立马结束，当非守护线程结束之后，系统会告诉守护线程非守护线程结束了，你也结束吧，在告知的过程中，守护线程会执行，只不过执行到半路就结束了。

public class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.setName("张三");
        MyThread1 t2 = new MyThread1();
        t2.setName("李四");
        t2.setDaemon(true);//将t2设置成守护线程
        t1.start();
        t2.start();
    }
}

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了"+i);
        }
    }
}

public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了"+i);
        }
    }
}

可以看到第一个线程结束以后，守护线程并没有执行完就结束了。

static void yield()

礼让线程，让当前线程让出CPU使用权，如果两个线程一起执行，可能会执行一会儿线程A，再执行一会线程B，或者可能线程A执行完毕了，线程B还要执行好久。yield()方法能尽量让两个线程交替执行。

void join()

插入线程或者叫做插队线程
两个方法一起展示如下：

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了"+i);
            Thread.yield();
        }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("张三");
        MyThread t2 = new MyThread();
        t2.setName("李四");
        t1.start();
        t1.join();//表示把t1插入到当前线程之前,t1要插到t2线程之前
        t2.start();
    }
}

使用static void yield()可以看到执行结果比较平均

使用void join() 可以看到第一个线程执行完才会执行第二个