Java 多线程编程是指在一个 Java 应用程序中同时运行多个线程。线程是一个程序执行的最小单位，它包含在进程中，利用多线程可以提高应用程序的性能和响应能力。多线程编程在 Java 中是一个重要的概念，尤其是在处理并发任务时。

一、线程的概念

程序、进程、多任务和线程等是非常容易混淆的概念。为了更好地理解多线程机制，有必要搞清楚这些概念。

程序（Program）

程序是含有指令和数据的文件，被储存在磁盘或其他的数据储存设备中，也就是说程序是静态的代码。

进程（Process）

进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建、运行到消亡的全过程。简单的说，一个进程就是一个执行中的程序。

多任务（Multi task）

多任务是指在一个系统中可以同时运行多个进程，即有多个独立运行的任务，每一个任务对应一个进程。每个进程都有一段专用的内存区域，即使是多次启动同一段程序产生不同的进程也是如此。

线程（Thread）

线程是操作系统中进行调度和执行的最小单位，它包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。所谓多线程就是同时执行一个以上的线程，一个线程的执行不必等待另一个线程执行完后才执行，所有线程都可以发生在同一时刻。但操作系统并没有将多个线程看作多个独立的应用去实现线程的调度和管理以及资源分配。

注意：多任务与多线程是两个不同的概念，多任务是针对操作系统而言的，表示操作系统可以同时运行多个应用程序，而多线程是指一个进程而言的，表示在一个进程内部可以同时执行多个线程。

二、Java的Thread 线程类与 Runnable 接口

Java语言中实现多线程的方法有两种：一种是继承 java.lang 包中的 Thread 类；另一种是用户在定义自己的类中实现 Runnable 接口。但不管采用哪种方法，都要用到Java语言类库中的Thread类以及相关的方法。

1. 利用Thread 类的子类来创建线程

Java语言的基本类库中已定义了 Thread 这个基本类，内置了一组方法,使程序利用该类提供的方法去产生一个新的线程、执行一个线程、终止一个线程的工作，或是查看线程的执行状态。

继承Thread类是实现线程的一种方法。Thread类的构造方法如下：

public Thread()

创建一个线程对象，此线程对象的名称是“Thread-n”的形式，其中是一个整数。使用这个构造方法，必须创建Thread类的一个子类并覆盖其run()方法

public Thread(String name)

创建一个线程对象，参数name指定了线程的名称

public Thread(String name)

创建一个线程对象，此线程对象的名称是“Thread-n”的形式，其中n是一个整数。参数target 的run()方法将被线程对象调用,来作为其执行代码

public Thread ( Runnable target ，String name)

功能同上，参数target的run()方法将被线程对象调用，来做为其执行代码。参数name指定了新创建线程的名称

要在一个 Thread 的子类里面激活线程，必粗准备好下列两件事。

（1）此类必须是继承自 Thread 类。

（2）线程所要执行的代码必须写在 run() 方法内。

语法如下：

calss 类名 extends Thread      //从 Thread 类派生子类
{
    类中的成员变量;
    类中的成员方法;
    修饰符 run()               //覆盖父类 Thread 里的 run() 方法
    {
        线程的代码
    }
}

run() 方法规定了线程要执行的任务，但一般不是直接调用 run() 方法，而是通过线程里面的 start() 方法来启动线程。

代码示例：利用 Thread 类的子类来创建线程

// 定义一个类，继承 Thread 类
class MyThread extends Thread {
    // 重写 run 方法，这个方法将在线程启动后执行
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                // 让线程睡眠一段时间，模拟实际工作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        // 启动线程
        thread1.start();
        thread2.start();
        // 主线程的工作
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2. 用 Runnable 接口来创建线程

在Java中，除了通过继承 Thread 类来创建线程外，更常见的做法是使用 Runnable 接口来创建线程。这是因为Java不支持多重继承，而一个类可能已经继承了其他类，这时候就无法再继承Thread 类来创建线程。此外，使用 Runnable接口的方式更加符合面向对象编程的“单一职责原则”，因为线程的任务（即run()方法的内容）和线程的管理（如启动、等待、停止等）被分离到了不同的类中。

用 Runnable 接口来创建线程方法如下：

首先，你需要创建一个实现了Runnable接口的类。这个类必须实现run()方法，该方法包含了线程要执行的任务。

public class MyRunnable implements Runnable {  
    @Override  
    public void run() {  
        // 这里是线程要执行的任务  
        for (int i = 0; i < 5; i++) {  
            System.out.println("线程 " + Thread.currentThread().getId() + " 正在运行，计数 " + i);  
            try {  
                Thread.sleep(100);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

然后，你需要创建一个Thread对象，并将实现了Runnable接口的类的实例作为参数传递给Thread类的构造函数。

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

通过上面的介绍，我们知道有两种创建线程对象的方式，这两种方式各有特点。

直接继承Thread类的特点是：编写简单，可以直接操纵线程；但缺点是若继承 Thread 类，就不能再继承其他类。

使用Runnable接口的特点是：可以将Thread类与所要处理的任务的类分开，形成清晰的模型；还可以从其他类继承，从而实现多重继承的功能。

另外，若直接使用Thread类，在类中 this 即指当前线程；若使用 Runnabe 接口，要在 * 类中获得当前线程，必须使用 Thread.currentThread() 方法。

三、线程之间的通信

多线程的执行往往需要相互之间的配合。为了更有效地协调不同线 程的工作，需要在线程间建立沟通渠道。

java.lang.Object 类的 wait() 、notify() 等方法为线程间的通信提供了有效手段。

如下所示：

public final void wait()

如果一个正在执行同步代码(synchronized)的线程A执行了wait()调用(在对象x上),该线程暂停执行而进入对象x的等待队列,并释放已获得的对象x的互斥锁。线程A要一直等到其他线程在对象x上调用notify()或notifyA1l()方法,才能够在重新获得对象x的互斥锁后继续执行(从wait()语句后继续执行)

public void notify()

唤醒正在等待该对象互斥锁的第一个线程

public void notifyAll()

唤醒正在等待该对象互斥锁的所有线程,具有最高优先级的线程首先被唤醒并执行

注意：对于一个线程，若基于对象 x 调用 wait() 或 notify() 方法，该线程必须已经获得对象 x 的互斥锁。换句话说，wait() 和 notify() 只能在同步代码块里调用。

四、多线程的同步控制

在 Java 多线程编程中，同步控制是非常重要的。它确保了多个线程在访问共享资源时不会发生冲突或数据不一致的问题。其主要通过 synchronized 关键字和 Lock 接口实现。

1. 使用synchronized 关键字

synchronized关键字可以修饰方法或者代码块，用于控制多线程对共享资源的访问。当一个线程获得锁时，其他线程需要等待该线程释放锁后才能继续执行。

示例：

public class SynchronizedDemo {
    private int count = 0;
    // 修饰方法
    public synchronized void add() {
        count++;
    }
    // 修饰代码块
    public void subtract() {
        synchronized (this) {
            count--;
        }
    }
}

2. 使用 Lock 接口

Lock接口提供了比synchronized更灵活的锁定机制，可以实现公平锁和非公平锁。公平锁表示锁的获取顺序是按照线程请求锁的顺序来分配的，而非公平锁则不保证这一点。

示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockDemo {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    public void add() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 释放锁
        }
    }
    public void subtract() {
        lock.lock(); // 加锁
        try {
            count--;
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}