浅谈Java的两种多线程实现方式

多线程是Java中非常重要的特性之一，它可以充分利用计算机的多核资源，在同一个应用程序中同时执行多个任务，提高程序的并发性和性能。Java在实现多线程方面提供了两种方式：继承Thread类和实现Runnable接口。以下分别进行详细讲解。

继承Thread类

继承Thread类是实现多线程的最简单方法，只需要继承Thread类并重写其run()方法即可。run()方法包含了线程的具体执行逻辑。下面是一个简单的继承Thread类的示例：

public class MyThread extends Thread {

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

在上面的示例代码中，我们定义了一个MyThread类继承了Thread类，并重写了其run()方法。在主线程中，我们可以创建一个MyThread对象并调用其start()方法来启动子线程：

public static void main(String[] args) {
    MyThread t = new MyThread();
    t.start();
    System.out.println("Main thread is running...");
}

上述代码输出结果为：

Main thread is running...
MyThread is running...

在上述代码中，子线程和主线程是并行执行的。通过开启子线程，我们可以实现多个任务的并行执行，提高程序的效率。

实现Runnable接口

实现Runnable接口是另一种实现多线程的方式。与继承Thread类不同，实现Runnable接口可以避免单继承的限制，以及Thread类可能带来的其他一些问题。同样，我们需要在自定义的类中重写run()方法来实现线程的具体逻辑。下面是一个简单的实现Runnable接口的示例：

public class MyRunnable implements Runnable {

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

与继承Thread类的方式相比，我们需要使用Thread类来包装MyRunnable类，并调用其start()方法来启动子线程：

public static void main(String[] args) {
    MyRunnable r = new MyRunnable();
    Thread t = new Thread(r);
    t.start();
    System.out.println("Main thread is running...");
}

输出结果与上述继承Thread类的示例相同。

实现Runnable接口的优势在于，我们可以通过一个Runnable对象启动多个线程，因为它不会改变任何全局状态。此外，Runnable接口还可以实现线程的复用和资源共享。例如，可以创建多个Thread对象并将同一个Runnable对象传递给它们。

示例说明

下面是另一个继承Thread类的例子，展示了如何同时启动多个线程，并阻塞主线程等待子线程结束：

public class MyThread extends Thread {
    private int count;

    public MyThread(int count) {
        this.count = count;
    }

    @Override
    public void run() {
        for (int i = 0; i < count; i++) {
            System.out.println("Thread " + getId() + " : " + i);
        }
    }
}

public static void main(String[] args) {
    int n = 3;
    Thread[] threads = new Thread[n];
    for (int i = 0; i < n; i++) {
        threads[i] = new MyThread(5);
        threads[i].start();
    }
    // 等待所有子线程执行完毕
    for (Thread thread : threads) {
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    System.out.println("All threads finished.");
}

在上面的示例中，我们定义了一个MyThread类，实现了一个简单的计数器，每个线程可以指定计数的次数。在主线程中，我们创建了3个线程，并分别启动它们。在启动完所有子线程之后，主线程需要等待每个子线程都执行完毕后再继续执行。我们可以使用Thread类的join()方法来实现等待。最后，主线程输出“All threads finished.”。

在下面的示例中，我们用一个实现Runnable接口的类来演示如何在线程之间共享变量：

public class MyRunnable implements Runnable {
    private int count;

    public MyRunnable(int count) {
        this.count = count;
    }

    @Override
    public void run() {
        for (int i = 0; i < count; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }
}

public static void main(String[] args) {
    int n = 3;
    MyRunnable runnable = new MyRunnable(5);
    for (int i = 0; i < n; i++) {
        Thread thread = new Thread(runnable);
        thread.setName("Thread-" + i);
        thread.start();
    }
}

在上面的示例中，我们定义了一个MyRunnable类，实现了一个简单的计数器。在主线程中，我们创建了3个线程，并将同一个MyRunnable对象传递给它们。三个线程共享同一个计数器，并且在线程内部通过Thread.currentThread().getName()获取了当前线程的名字。最终输出结果类似于：

Thread-0 : 0
Thread-1 : 0
Thread-2 : 0
Thread-0 : 1
Thread-1 : 1
Thread-2 : 1
...

在以上示例中，我们分别使用了继承Thread类和实现Runnable接口的方式实现了多线程。无论采用哪种方式，我们都需要定义一个run()方法，并在其中编写线程的具体逻辑。此外，我们还可以使用join()方法等待子线程执行完毕，以及使用synchronized关键字实现线程同步。