Java多线程状态及方法实例解析

前言

多线程是Java开发中一个重要的概念，也是面试中的必备知识点，因此这里将会详细讲解Java多线程状态以及方法的使用，方便大家对这个重要的概念进行深入学习。

什么是多线程

进程是计算机中正在执行的程序，每个进程都有自己的内存空间、指令指针、系统栈和寄存器等资源。而线程就是在进程内部运行的子任务，一个进程可以包含多个线程。

Java多线程

在Java中，多线程的实现主要是通过Thread类和Runnable接口来实现的。Thread类是一个封装了线程控制相关的方法的类，在使用时可以通过继承Thread类来创建一个线程。而Runnable接口则是一个定义了一个run()方法的接口，可以通过实现这个接口来创建一个线程。

线程的生命周期

一个线程在其一生中总共会经历6种状态，包括新建、就绪、运行、阻塞、等待和终止，分别对应着生命周期中的不同阶段。

新建状态

当使用new操作符创建一个线程对象时，此时线程对象被创建出来，但是这个线程并没有启动运行，处于新建状态。在这个状态下，线程对象不会拥有执行时间，并且不占用操作系统资源。

就绪状态

当调用线程的start()方法时，此时线程对象会进入到就绪状态，准备好从操作系统中获取CPU时间片去执行。在这个状态下，线程会拥有执行时间，但是还没有开始执行。

运行状态

当线程获得CPU时间片时，此时线程对象会进入运行状态，开始执行线程的任务。在这个状态下，线程会拥有执行时间并且占用CPU资源。

阻塞状态

一个线程一旦进入阻塞状态，就不能再继续执行，必须等待某些特殊条件的出现才能再次被唤醒。在Java中，线程进入了阻塞状态，可以通过以下几个方法来使其进入：

• 调用sleep()方法，使线程暂时休眠一段时间；
• 请求I/O操作，使线程进入等待状态；
• 调用suspend()方法，使线程挂起；
• 等待锁的释放。

等待状态

一个线程进入等待状态时，它将会一直等待，直到另一个线程对它进行唤醒。在Java中，线程进入了等待状态，可以通过以下几个方法来使其进入：

• 等待线程结束，可以通过调用join()方法使当前线程等待另一个线程结束；
• 等待某个条件，可以通过调用wait()方法使当前线程等待某个条件的出现。

终止状态

一个线程完成了它的工作并结束了它的生命周期，此时线程进入终止状态。

线程的方法

Java中提供了许多线程相关的方法，包括sleep()、wait()、yield()、interrupt()、join()等。接下来将对其中的几个方法进行详细的介绍。

sleep()

sleep()方法是让当前线程休眠一段时间，让出CPU控制权给其他线程。具体的使用方法为：

public static void sleep(long millis) throws InterruptedException

其中millis参数为线程休眠的时间，单位是毫秒。

示例：

public class ThreadTest {
    public static void main(String[] args){
        MyThread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(500); //线程睡眠500ms
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.setFlag(false);
    }
}
class MyThread extends Thread {
    private boolean flag = true;
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public void run() {
        while (flag) {
            System.out.println("hello world");
        }
    }
}

wait()

wait()方法是让线程处于等待状态，让出CPU控制权，等待其他线程对它进行唤醒。具体的使用方法为：

public final void wait() throws InterruptedException

wait()方法必须在synchronized块中调用，并且会释放当前线程拥有的锁。

示例：

public class ThreadTest {
    static Object object = new Object();
    public static void main(String[] args){
        synchronized (object){
            try {
                System.out.println("wait...");
                object.wait(); //线程进入等待状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("notify");
        }
    }
}

yield()

yield()方法是让出CPU时间片，让其他线程优先执行。具体的使用方法为：

public static native void yield()

示例：

public class ThreadTest {
    public static void main(String[] args){
        MyThread1 thread1 = new MyThread1();
        MyThread2 thread2 = new MyThread2();
        thread1.start();
        thread2.start();
    }
}
class MyThread1 extends Thread {
    public void run() {
        for (int i = 0;i<5; i++) {
            System.out.println("Thread1");
            Thread.yield(); //让出CPU时间片
        }
    }
}
class MyThread2 extends Thread {
    public void run() {
        for (int i = 0;i<5; i++) {
            System.out.println("Thread2");
            Thread.yield(); //让出CPU时间片
        }
    }
}

interrupt()

interrupt()方法是将线程的中断标志位置为true，表示该线程中断。具体的使用方法为：

public void interrupt()

示例：

public class ThreadTest {
    public static void main(String[] args){
        MyThread thread = new MyThread();
        thread.start();
        try {
            Thread.sleep(500); //线程睡眠500ms
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt(); //中断线程
    }
}
class MyThread extends Thread {
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("hello world");
        }
        System.out.println("end");
    }
}

join()

join()方法是让当前线程等待另一个线程结束后再继续执行。具体的使用方法为：

public final void join() throws InterruptedException

示例：

public class ThreadTest {
    public static void main(String[] args){
        MyThread thread = new MyThread();
        thread.start();
        try {
            thread.join(); //等待线程结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }
}
class MyThread extends Thread {
    public void run() {
        System.out.println("start");
        try {
            Thread.sleep(2000); //线程睡眠1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

总结

本文详细介绍了Java多线程状态及方法的相关知识点，包括线程的生命周期和线程的方法。同时，本文给出了多个示例代码，便于读者更好地理解和掌握这些概念。