详解Java中Thread 和Runnable区别

当开发多线程程序时，Java中有两种方式可以创建线程：继承Thread类或实现Runnable接口。虽然它们最终实现的目标是相同的，但它们之间仍然存在一些重要区别。本文将详细讲解Thread和Runnable的区别，让您在编写多线程程序时选择最佳方案。

一、继承Thread类

继承Thread类是创建线程的传统方式。这是通过继承Thread类并覆盖其中的run方法来实现的。当我们启动线程时，它会自动调用run方法。例如：

public class MyThread extends Thread {
    public void run() {
        // 实现线程的具体逻辑
    }
}

MyThread thread = new MyThread();
thread.start();

这段代码创建了一个继承自Thread类的类，并重写了run方法。我们通过创建该类的对象并在其上调用start方法来启动线程。当start方法被调用时，会自动执行MyThread类中的run方法。

二、实现Runnable接口

另一种创建线程的方式是实现Runnable接口。这可以通过实现Runnable接口并包含run方法来实现。与继承Thread类不同，此时我们需要将包含run方法的对象传递给Thread构造函数：

public class MyRunnable implements Runnable {
    public void run() {
        // 实现线程的具体逻辑
    }
}

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

这段代码实现了Runnable接口，并将实现了run方法的MyRunnable对象传递给Thread构造函数。通过创建新的Thread实例并调用start方法，我们可以启动线程，此时会自动调用MyRunnable类的run方法。

三、哪种方式更好？

现在您可能会问，哪种方式更好？其实这完全取决于您的需求。继承Thread类可以让您更轻松地操作线程并拥有更多的方法（例如join，getName等）。但是，由于Java只允许单继承，因此如果您的类已经继承自另一个类，那么实现Runnable接口可能更具灵活性。

此外，实现Runnable接口可以将线程与任务分离。这使得您可以在多个线程之间共享相同的任务对象，从而减少内存占用。

四、示例说明

我们来看两个实例，一个使用Thread类，一个使用Runnable接口：

1. 使用Thread类

public class MyThread extends Thread {
    private int count = 5;

    public void run() {
        while (count > 0) {
            System.out.println(Thread.currentThread().getName() + " count: " + count);
            count--;
        }
    }
}

MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();

这段代码创建了三个MyThread的实例，并分别启动它们。每个线程都有自己的count变量，并在while循环中递减。输出的结果如下：

Thread-2 count: 5
Thread-1 count: 5
Thread-0 count: 5
Thread-1 count: 4
Thread-0 count: 4
Thread-2 count: 4
Thread-1 count: 3
Thread-0 count: 3
Thread-2 count: 3
Thread-1 count: 2
Thread-0 count: 2
Thread-2 count: 2
Thread-1 count: 1
Thread-0 count: 1
Thread-2 count: 1

2. 使用Runnable接口

public class MyRunnable implements Runnable {
    private int count = 5;

    public void run() {
        while (count > 0) {
            System.out.println(Thread.currentThread().getName() + " count: " + count);
            count--;
        }
    }
}

Thread t1 = new Thread(new MyRunnable());
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread(new MyRunnable());
t1.start();
t2.start();
t3.start();

这段代码创建了三个MyRunnable的实例，并将它们作为参数传递给Thread的构造函数。每个线程都有自己的count变量，并在while循环中递减。输出的结果如下：

Thread-0 count: 5
Thread-1 count: 5
Thread-2 count: 5
Thread-1 count: 4
Thread-0 count: 4
Thread-2 count: 4
Thread-1 count: 3
Thread-0 count: 3
Thread-2 count: 3
Thread-1 count: 2
Thread-0 count: 2
Thread-2 count: 2
Thread-1 count: 1
Thread-0 count: 1
Thread-2 count: 1

可以看到，两个示例的输出是相同的。因此，在实现多线程时，无论您选择哪种方式，最终实现的目标都是相同的。