线程的状态

目录

状态一 --- New

状态二 --- Runnable

状态三 --- BLOCKED

状态四 --- WAITING

状态五 --- TIMED_WAITING

状态六 --- TERMINATED

线程状态的转移

1.由NEW >>> Runnable

2.Runnable>>>TERMINATED

3.线程WAITING、TIMED_WAITING、BLOCKED三种状态的转变

4.yield()

---

状态一 --- New

此时线程已经有了明确的工作内容,但未开始工作,即已经实例化了Thread对象,重写了run方法,但是并未调用start()方法。

---

状态二 --- Runnable

这种状态表示线程已经开始工作，如New状态的线程，调用了start()方法，就变为Runnable状态。但Runnable分为了两种情况，一种是线程已经在CPU上运行，另一种是未在CPU上运行，但随时准备着被CPU调度执行。

---

状态三 --- BLOCKED

BLOCKED表示等待获取锁，这种情况一般是由于其他线程加锁了，导致该线程被阻塞。

---

状态四 --- WAITING

由于其他线程使用了wait()，join()等方式，导致该线程被阻塞，该线程必须等其他线程结束，才会开始执行，这种一般是死等的方式。

---

状态五 --- TIMED_WAITING

由于其他线程使用了sleep(long miles),join(long miles),wait(long miles)，导致该线程被阻塞，这种状态表示给该线程限定了最大等待时间，而并不是死等。

---

状态六 --- TERMINATED

该状态表示线程执行完毕了。

---

线程状态的转移

1.由NEW >>> Runnable

要想获取线程的状态，可以调用Thread类中的getState()方法，其返回枚举类State。

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(){
           public void run(){
               while(true){

               }
           }
        };
        
        //在还没有调用start方法前
        System.out.println(t.getName()+" State:"+t.getState());// NEW 
        t.start();
        System.out.println("after t start ");
        
        //调用start方法后
        System.out.println(t.getName()+" State:"+t.getState());//Runnable
    }
}

在调用start前打印为NEW,调用之后为Runnable。

---

2.Runnable>>>TERMINATED

public static void main(String[] args) {
        Thread t = new Thread(){
           public void run(){
               boolean flag = true;
               while(flag){
                   try {
                       sleep(3000);
                       flag = false;
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
        };
        t.start();
        System.out.println(t.getName()+" State:"+t.getState());
        
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //4秒之后，t线程的run方法已经执行完。
        System.out.println(t.getName()+" State:"+t.getState());
    }

这很好理解，最后会打印TERMINATED。

---

3.线程WAITING、TIMED_WAITING、BLOCKED三种状态的转变

public static void main(String[] args) throws InterruptedException {
        final Object o = new Object();
        Thread t1 = new Thread(new Runnable(){
            public void run(){
                synchronized (o){
                    for(int i = 0;i<30;i++){
                        try {
//                  Thread.sleep(1000);//1.两种方法都能让线程
                                      //从Runnable变为TIMED_WAITING
                            wait(1000);

//                          sleep();//这两种则是变为WAITING
//                          wait();  
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        },"t1");
        t1.start();
        t1.join();
      //t1.join(1000);//2.此处两种用法，
                     //无参数会让t2线程处于WAITING,另为TIMED_WAITING。
        //

        Thread t2 = new Thread(new Runnable(){
            public void run(){
                synchronized (o){//3.由于t1的synchronized加锁，
                                   //t1未运行完，则t2处于BLOCKED
                    for(int i = 0;i<3;i++){
                        try {
//                            Thread.sleep(1000);
                            wait(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        },"t2");
        t2.start();

    }

---

4.yield()

        此函数的作用是主动让出CPU，当两个线程同时运作，抢占式执行时，如果t1线程比较急，那么可以在t2线程的run方法中使用Thread.yield()，这样一来，在多次循环中，每次遇到该语句，t2就会让出CPU的权限，使得t1线程更多被CPU调度并执行。

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("t1 -- RUNNING");

                    // Thread.yield();
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("t2 -- RUNNING");
                }
            }
        }, "t2");
        t2.start();

以上就是本文的全部内容了。