Java 线程的创建和启动

引言

在现代编程中，多线程是提高程序性能和响应能力的重要手段。Java 作为一种强类型、面向对象的编程语言，提供了强大的多线程支持。本文将介绍 Java 中线程的基本概念，并详细讲解如何创建和启动线程。

什么是线程？

线程是进程中的一个执行单元，是程序执行流的最小单元。一个进程可以包含多个线程，每个线程可以独立执行任务，同时共享进程的资源。通过多线程，程序可以同时处理多个任务，从而提高执行效率。

创建线程的两种方式

在 Java 中，可以通过两种主要方式来创建线程：继承 Thread 类和实现 Runnable 接口。

1. 继承 Thread 类

继承 Thread 类是最直接的一种方式。需要创建一个继承 Thread 的子类，并重写其中的 run 方法。在 run 方法中定义线程执行的任务。

public class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的任务
        System.out.println("Hello from MyThread!");
    }

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

在上述代码中，我们创建了一个继承自 Thread 的 MyThread 类，并在 run 方法中定义了线程的任务。通过调用 start 方法来启动线程。

2. 实现 Runnable 接口

实现 Runnable 接口是另一种创建线程的方式。这种方式更为灵活，因为它允许类继承其他类的同时仍然可以实现多线程。需要实现 Runnable 接口，并实现其中的 run 方法。然后通过 Thread 类的构造函数创建线程对象。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的任务
        System.out.println("Hello from MyRunnable!");
    }

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

在上述代码中，我们实现了 Runnable 接口，并在 run 方法中定义了线程的任务。通过 Thread 类的构造函数创建线程对象，并调用 start 方法来启动线程。

线程的生命周期

线程的生命周期可以分为以下几种状态：

1. 新建（New）：线程对象创建后，处于新建状态。
2. 就绪（Runnable）：线程对象调用 start 方法后，进入就绪状态，等待 CPU 调度执行。
3. 运行（Running）：线程获得 CPU 资源后，开始执行 run 方法，处于运行状态。
4. 阻塞（Blocked）：线程因为某种原因（如等待资源）暂时停止执行，进入阻塞状态。
5. 死亡（Dead）：线程执行完 run 方法或者被终止，进入死亡状态。

线程的控制

Java 提供了多种方法来控制线程的执行：

1. sleep 方法

Thread.sleep 方法可以让当前线程暂停执行一段时间（以毫秒为单位），进入阻塞状态。

public class SleepExample extends Thread {
    @Override
    public void run() {
        try {
            System.out.println("Thread is going to sleep");
            Thread.sleep(2000); // 暂停2秒
            System.out.println("Thread is awake");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        SleepExample thread = new SleepExample();
        thread.start();
    }
}

2. join 方法

Thread.join 方法可以等待指定的线程执行完毕再继续执行当前线程。

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

    public static void main(String[] args) {
        JoinExample thread = new JoinExample();
        thread.start();
        try {
            thread.join(); // 等待 thread 执行完毕
            System.out.println("Thread has finished");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3. yield 方法

Thread.yield 方法可以让当前正在执行的线程让出 CPU 资源，但不会进入阻塞状态，仍然处于就绪状态。

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

    public static void main(String[] args) {
        YieldExample thread1 = new YieldExample();
        YieldExample thread2 = new YieldExample();
        thread1.start();
        thread2.start();
    }
}

结论

Java 提供了强大的多线程支持，使得开发者可以通过继承 Thread 类或实现 Runnable 接口来创建和启动线程。通过合理使用线程控制方法，如 sleep、join 和 yield，可以更好地管理线程的执行。