Java：Thread中的常用方法

---

Thread中的常用方法

方法	描述
public void start()	使该线程开始执行；Java 虚拟机调用该线程的 run 方法
public void run()	通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
public static Thread currentThread()	返回对当前正在执行的线程对象的引用。
public final void setName(String name)	改变线程名称，使之与参数 name 相同
public Thread(String name)	Thread的有参构造方法 ，创建线程的时候设置名字
public static void yield()	暂停当前正在执行的线程对象，并执行其他线程。
public static void sleep(long millisec)	让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
public final void join()	在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
public final void join(long millisec)	等待该线程阻塞的时间最长为 millis 毫秒。
public final boolean isAlive()	测试线程是否处于活动状态。
public static boolean holdsLock(Object x)	当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
public void interrupt()	中断线程。
public static void dumpStack()	将当前线程的堆栈跟踪打印至标准错误流。
public final void setPriority(int priority)	更改线程的优先级
public final void setDaemon(boolean on)	将该线程标记为守护线程或用户线程。

---

---

部分方法测试

1：currentThread()、getName()和setName()

---

2：Thread(String name)和yield()

调用 yield 会让当前线程从 Running 进入 Runnable 状态，即让出 cpu 的使用权， 与其他同样是 Runnable 状态的线程一齐竞争 cpu 的使用权。

class HelloThread extends Thread{
    
    
    public HelloThread(String name) {
    
    
        super(name);
    }
    public HelloThread(){
    
    
    }
    @Override
    public void run(){
    
    
        for(int i = 0;i<=5;i++){
    
    
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

public class ThreadMethodTest {
    
    
    public static void main(String[] args) {
    
    
        //创建线程的时候设置名字，需要在子类中定义一个有参的构造方法并通过super调用父类有参的构造方法
        HelloThread helloThread = new HelloThread("线程一");
        helloThread.start();
        for(int i = 0;i<=5;i++){
    
    
            System.out.println(Thread.currentThread().getName()+"---"+i);
            if(i == 2){
    
    
                // 当i为2时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
                Thread.yield();
            }
        }
    }
}

---

3：sleep()

调用 Thread.sleep() 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞），睡眠结束线程恢复执行（但是不一定会立刻执行）

class HelloThread extends Thread{
    
    
    public HelloThread(String name) {
    
    
        super(name);
    }
    public HelloThread(){
    
    
    }
    @Override
    public void run(){
    
    
        for(int i = 0;i<=3;i++){
    
    
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

public class ThreadMethodTest {
    
    
    public static void main(String[] args) {
    
    
        //创建线程的时候设置名字，需要在子类中定义一个有参的构造方法并通过super调用父类有参的构造方法
        HelloThread helloThread = new HelloThread("线程一");
        helloThread.start();
        for(int i = 0;i<=3;i++){
    
    
            System.out.println(Thread.currentThread().getName()+"---"+i);
            try {
    
    
                //设置进入1000毫秒阻塞状态
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

---

4：join()

在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。

class HelloThread extends Thread{
    
    
    public HelloThread(String name) {
    
    
        super(name);
    }
    public HelloThread(){
    
    
    }
    @Override
    public void run(){
    
    
        for(int i = 0;i<=3;i++){
    
    
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}

public class ThreadMethodTest {
    
    
    public static void main(String[] args) {
    
    
        //创建线程的时候设置名字，需要在子类中定义一个有参的构造方法并通过super调用父类有参的构造方法
        HelloThread helloThread = new HelloThread("线程一");
        helloThread.start();
        for(int i = 0;i<=3;i++){
    
    
            System.out.println(Thread.currentThread().getName()+"---"+i);
            if(i == 2){
    
    
                try {
    
    
                    //此时主线程等待线程一的计算完成，主线程再运行
                    helloThread.join();
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

---

5：isAlive()

测试线程是否处于活动状态。返回false、true

class HelloThread extends Thread{
    
    
    public HelloThread(String name) {
    
    
        super(name);
    }
    public HelloThread(){
    
    
    }
    @Override
    public void run(){
    
    
        System.out.println(Thread.currentThread().getName()+"正在执行");
    }
}

public class ThreadMethodTest {
    
    
    public static void main(String[] args) {
    
    
        //创建线程的时候设置名字，需要在子类中定义一个有参的构造方法并通过super调用父类有参的构造方法
        HelloThread helloThread = new HelloThread("线程一");
        helloThread.start();
        System.out.println(helloThread.getName()+"的状态:"+helloThread.isAlive());
        System.out.println(Thread.currentThread().getName()+"正在执行");
        try {
    
    
            //helloThread线程开始执行，主线程等待
            helloThread.join();
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        //此时线程一的已经执行完，状态已经死亡
        System.out.println(helloThread.getName()+"的状态:"+helloThread.isAlive());
        System.out.println(Thread.currentThread().getName()+"的状态:"+Thread.currentThread().isAlive());
    }
}