线程介绍及 Java 实现线程的三种方式

1. 什么是线程？

线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程可以包含多个线程，这些线程共享进程的内存空间和资源，但每个线程拥有独立的执行栈和程序计数器。

1.1 线程与进程的区别

• 进程：进程是操作系统分配资源的基本单位，每个进程都有独立的内存空间和系统资源。进程之间的通信需要通过进程间通信（IPC）机制。

• 线程：线程是进程中的一个执行单元，多个线程共享同一个进程的内存空间和资源。线程之间的通信更加高效，因为它们可以直接访问共享的内存。

1.2 线程的优点

• 并发执行：多线程可以并发执行，提高程序的执行效率。

• 资源共享：线程共享进程的内存和资源，减少了资源开销。

• 响应性：多线程可以提高程序的响应性，特别是在图形用户界面（GUI）应用程序中。

1.3 线程的缺点

• 复杂性：多线程编程比单线程编程复杂，容易引发竞态条件、死锁等问题。

• 调试困难：多线程程序的调试和测试比单线程程序困难。

2. Java 中实现线程的三种方式

在 Java 中，实现线程主要有三种方式：继承 Thread 类、实现 Runnable 接口和使用 Callable 和 Future。下面将详细介绍这三种方式。

2.1 继承 Thread 类

通过继承 Thread 类并重写 run() 方法来创建线程。

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

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

优点：

• 简单直接，适合简单的线程任务。

缺点：

• Java 是单继承的，继承 Thread 类后无法再继承其他类。

• 代码的可扩展性和复用性较差。

2.2 实现 Runnable 接口（推荐使用）

通过实现 Runnable 接口并实现 run() 方法来创建线程。 

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

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

优点：

• 避免了单继承的限制，可以继承其他类。

• 代码的可扩展性和复用性较好。

缺点：

• 相对于继承 Thread 类，代码稍微复杂一些。

2.3 使用 Callable 和 Future

通过实现 Callable 接口并重写 call() 方法来创建线程，Callable 可以返回结果并抛出异常。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 线程执行的代码
        return "Thread is running";
    }
}

public class Main {
    public static void main(String[] args) {
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();  // 启动线程

        try {
            String result = futureTask.get();  // 获取线程执行结果
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

优点：

• 可以返回线程执行的结果。

• 可以抛出异常，方便错误处理。

缺点：

• 相对于前两种方式，代码更加复杂。

3. 线程同步与通信

在多线程编程中，线程之间的同步和通信是一个重要的问题。常见的同步机制包括：

• 互斥锁（Mutex）：用于保护共享资源，防止多个线程同时访问。

• 信号量（Semaphore）：用于控制对共享资源的访问数量。

• 条件变量（Condition Variable）：用于线程之间的条件等待和通知。

3.1 Java 中的线程同步

在 Java 中，可以使用 synchronized 关键字或 java.util.concurrent 包中的工具类来实现线程同步。

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Count: " + counter.getCount());
    }
}

4. 总结

线程是实现并发编程的重要工具，能够提高程序的执行效率和响应性。然而，多线程编程也带来了复杂性和调试困难。通过合理地使用线程同步机制，可以避免竞态条件和死锁等问题。在 Java 中，实现线程主要有三种方式：继承 Thread 类、实现 Runnable 接口和使用 Callable 和 Future。开发者可以根据具体需求选择合适的工具和方法。