初步学习Java中线程的实现与生命周期

初步学习Java中线程的实现与生命周期攻略

什么是线程？

• 线程是程序执行的一个单元，也是进程内的一个独立控制流。

• 一个进程中可以有多个线程，它们共享内存空间和一些进程级的数据，但每个线程有自己的计数器、栈空间及局部变量。

• 线程的使用可以提高程序的效率。

常用的线程实现方式

Java中有两种创建线程的方式：继承Thread类和实现Runnable接口。

继承Thread类

public class MyThread extends Thread {
    public void run() {
        // 线程执行的代码
        System.out.println("Thread is running...");
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 启动线程
    }
}

实现Runnable接口

public class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的代码
        System.out.println("Thread is running...");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}

线程生命周期

线程的生命周期包括5个状态：新建、就绪、运行、阻塞、死亡。

新建状态

当使用new关键字创建一个线程对象时，线程处于新建状态。

就绪状态

当线程对象被创建后，调用start()方法后，线程进入就绪状态，等待获取CPU调用run()方法开始执行。

public class MyThread extends Thread {

    public void run() {
        // 线程执行的代码
        System.out.println("Thread is running...");
    }

    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();

        myThread1.start(); // 就绪状态
        myThread2.start(); // 就绪状态
        myThread3.start(); // 就绪状态
    }
}

运行状态

当线程获得CPU时间片以后，进入运行状态。

public class MyThread extends Thread {

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread is running: " + i);
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 就绪状态

        System.out.println("Main thread is running...");

        try {
            myThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread is over.");
    }
}

阻塞状态

当线程因为某些原因（如等待I/O操作、调用sleep()方法）不能继续执行时，进入阻塞状态。

public class MyThread extends Thread {

    public void run() {
        System.out.println("Thread is running...");
        try {
            Thread.sleep(5000); // 线程进入阻塞状态，等待5秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread is over.");
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 就绪状态
        System.out.println("Main thread is running...");
    }
}

死亡状态

线程执行完run()方法后，线程进入死亡状态。

public class MyThread extends Thread {

    public void run() {
        System.out.println("Thread is running...");
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 就绪状态

        try {
            myThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Thread is over.");

    }
}

示例说明

示例一

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread is running: " + i);
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 就绪状态

        System.out.println("Main thread is running...");

        try {
            myThread.join(); // 等待子线程结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread is over.");
    }
}

该示例中，我们继承了Thread类，重写了run()方法，实现了一个简单的多线程程序。在main()方法中，我们创建了一个MyThread对象，并且通过start()方法启动线程，进入就绪状态。

在主线程中，我们通过调用join()方法来等待子线程执行完成后再执行主线程。

示例二

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Thread is running...");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 就绪状态

        System.out.println("Main thread is running...");
    }
}

该示例中，我们实现了Runnable接口，重写了run()方法，创建了Thread对象，并且将MyRunnable对象作为参数传递给Thread的构造方法中。通过start()方法启动线程，进入就绪状态。

在主线程中，我们直接调用System.out.println()方法来输出信息。可以看到子线程是在主线程之后执行的，因为它处于不同的线程之中。