（14）Java多线程之线程状态

1.引言

      在本篇博客中主要记录一下线程的状态，线程都存在哪一些状态？如何改变线程的状态。关于线程状态的信息都存储在State枚举类中。首先我们看一下线程的状态图：

现成的状态大致分为六种：

• New：代表创建了线程对象，但是未执行start方法。
• Runable：代表正在Java虚拟机中正在执行的线程。
• blocked：代表线程受阻塞
• Waiting：代表无限期的等待，知道其他线程给改线程发表唤醒命令
• Timed Waiting：代表线程等待一定的时间
• Terminated：代表线程已经退出

2. 验证线程所处的状态

现在我们就来使用 Demo来验证线程在一定情况下所处的状态

2.1 验证New状态

2.1.1 代码示例

• 首先创建一个线程

public class MyThread extends Thread {
    public void run() {
    }
}

• main方法

public class App {
    public static void main(String[] args) throws Exception {
        MyThread td=new MyThread();
        System.out.println(td.getState());

    }

}

• 运行结果

2.1.2代码解释

• 注意：当线程对象创建之后，但是没有执行start方法，此时线程的状态为：NEW

2.2 验证Runable状态

2.2.1 代码

• 创建线程

public class MyThread extends Thread {
    public void run() {
        System.out.println(this.getState());
    }
}

• main方法

public class App {
    public static void main(String[] args) throws Exception {
        MyThread td=new MyThread();
        td.start();

    }

}

• 运行结果

2.2.2代码解释

• 当代码执行start方法之后，线程的状态变为Runable，注意：此时的线程并未执行完（也就是说线程在执行run方法），如果执行完，那么线程的状态就变成了terminated

2.3 验证terminated状态

2.3.1 代码示例

• 线程代码

public class MyThread extends Thread {
    public void run() {

    }
}

• main函数

public class App {
    public static void main(String[] args) throws Exception {
        MyThread td=new MyThread();
        td.start();
        //保证td线程已经执行结束了
        Thread.sleep(1000);
        System.out.println(td.getState());

    }

}

• 运行结果

2.3.2 代码解释

• 当线程运行结束后：线程的状态修改为terminated

2.4 验证状态Timed_waiting

2.4.1 代码示例

• 自定义线程

public class MyThread extends Thread {
    public void run() {
        try {
            //让子线程睡2秒中。这里也可以是wait(timeout)方法，也可以是join(timeout)方法
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

• main方法

public class App {
    public static void main(String[] args) throws Exception {
        MyThread td=new MyThread();
        td.start();
        //保证子线程在睡眠状态
        Thread.sleep(1000);
        System.out.println(td.getState());

    }

}

• 运行结果

2.4.2 代码解释

• 注意：我们不仅仅可以使用sleep方法让线程进入timed_waiting状态，也可以使用wait方法和join方法。
• 再次注意：如果想要使用wait或者join方法进入timed_waiting,wait方法必须带参数，比如wait(2000)，如果使用wait()方法（不带时间参数），那么将进入waiting状态

2.5 验证Blocked状态

2.5.1 代码示例

• 创建service方法

public class service {
    public static synchronized void printString() throws Exception {
        System.out.println("线程等待5秒钟");
        Thread.sleep(5000); 
    }
}

• 创建线程类

public class MyThread extends Thread {
    private  Service service;
    public MyThread(Service service){
        this.service=service;

    }
    public void run() {
        try {
            service.printString();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

• main方法

public class App {
    public static void main(String[] args) throws Exception {
        Service service=new Service();
        MyThread td1=new MyThread(service);
        MyThread td2=new MyThread(service);
        td1.start();
        td2.start();
        Thread.sleep(1000);
        System.out.println(td2.getState());

    }

}

• 运行结果

2.5.2 代码解释

• td2线程正在等待获取对象锁，此时线程状态是Blocked

2.6验证Waiting状态

2.6.1 代码示例

• 线程代码

public class MyThread extends Thread {
    private  Object lock;
    public MyThread(Object lock){
        this.lock=lock;

    }
    public void run() {

        synchronized (lock) {
            try {
                //注意这里
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

• main方法

public class App {
    public static void main(String[] args) throws Exception {
        Object lock=new Object();
        MyThread td=new MyThread(lock);
        td.start();
        Thread.sleep(1000);
        System.out.println(td.getState());

    }

}

• 运行结果

2.6.2代码解释

• 注意状态Waiting和状态timed_waiting的区别
• 执行wait方法使线程进入的是Waiting状态

3.从线程状态解释生产者/消费者模式

      通过上面的实例我们已经大致的了解了线程的状态都有哪几种，在什么情况下县线程会进入什么状态，接下来我们使用线程的状态来解释一下：生产者消费者模式（多生产多消费）

3.1 解释生产者/消费者模式

      首先我们从消费者说起，首先我们的产品的个数为0，消费者执行wait方法，然后消费者线程状态修改为waiting,这里我们可以看出waiting状态是没有权限争夺对象锁的，也就是一直处于等待状态，然后消费者唤醒生产者线程，生产者生产一个产品，然后唤醒消费者线程，注意：这里唤醒消费者线程假设我们使用的是notifyAll()方法，那么所有的消费者线程状态将变为Runable状态的准备阶段（假设我们将Runable状态分为准备阶段和运行阶段），如果某一个线程获取到了对象锁，那么该线程将会进入Runable的运行阶段，其他线程将会进入Blocked状态（也就是等待获得对象锁，注意：Blocked状态是有权限获得对象锁的）。以此反复，从而形成了生产者消费者模式。