多线程基础

引言：什么是线程？

线程（Thread）是程序执行的最小单位。一个进程（程序）可以包含多个线程，这些线程同时执行，互不干扰。

想象一家餐厅：
├── 进程 = 整个餐厅
└── 线程 = 餐厅里的员工

一个餐厅（进程）可以有多个员工（线程）同时工作：
- 一个员工在炒菜
- 一个员工在洗碗
- 一个员工在招待客人

他们共享餐厅的资源，但同时做不同的事情

线程的创建方式

方式1：继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行中: " + Thread.currentThread().getName());
    }
}

// 使用
MyThread thread = new MyThread();
thread.start();  // 启动线程（不是run()！）

方式2：实现Runnable接口（推荐）

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行中: " + Thread.currentThread().getName());
    }
}

// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();

方式3：使用Lambda表达式（Java 8+）

// 最简洁的方式
Thread thread = new Thread(() -> {
    System.out.println("Lambda线程执行中!");
});
thread.start();

线程的状态

线程在生命周期中会经历不同的状态：

获取线程状态

Thread thread = new Thread(() -> {
    System.out.println("执行中...");
});

System.out.println(thread.getState());  // NEW
thread.start();
System.out.println(thread.getState());  // RUNNABLE

线程的常用方法

sleep() - 线程休眠

Thread thread = new Thread(() -> {
    System.out.println("线程开始执行");
    try {
        Thread.sleep(2000);  // 休眠2秒
        System.out.println("线程2秒后继续执行");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
thread.start();

join() - 等待线程结束

Thread thread = new Thread(() -> {
    System.out.println("子线程开始");
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {}
    System.out.println("子线程结束");
});

thread.start();
thread.join();  // 等待thread执行完毕
System.out.println("主线程继续执行");

线程同步

当多个线程访问共享资源时，需要进行同步控制，否则可能导致数据不一致。

问题演示：多线程抢票

class TicketSeller implements Runnable {
    private int tickets = 10;  // 共享资源

    @Override
    public void run() {
        while (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第" + tickets + "张票");
            tickets--;
            try {
                Thread.sleep(100);  // 模拟网络延迟
            } catch (InterruptedException e) {}
        }
    }
}

// 问题：多个线程可能卖出同一张票！
TicketSeller seller = new TicketSeller();
new Thread(seller, "窗口1").start();
new Thread(seller, "窗口2").start();
new Thread(seller, "窗口3").start();

synchronized - 同步方法

class TicketSeller implements Runnable {
    private int tickets = 10;

    @Override
    public synchronized void run() {  // 同步方法
        while (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第" + tickets + "张票");
            tickets--;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {}
        }
    }
}

synchronized - 同步代码块

class TicketSeller implements Runnable {
    private int tickets = 10;
    private Object lock = new Object();  // 锁对象

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {  // 同步代码块
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖出第" + tickets + "张票");
                    tickets--;
                } else {
                    break;
                }
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {}
        }
    }
}

线程安全的类

Java提供了一些线程安全的类，可以在多线程环境下直接使用：

StringBuffer线程安全示例

// StringBuffer是线程安全的，所有方法都用synchronized修饰
StringBuffer sb = new StringBuffer();
sb.append("Hello");
sb.append(" World");
System.out.println(sb.toString());

volatile关键字

volatile保证变量的可见性，即一个线程修改了volatile变量的值，其他线程能立即看到。

class VolatileDemo extends Thread {
    private volatile boolean running = true;  // volatile保证可见性

    @Override
    public void run() {
        while (running) {
            System.out.println("线程运行中...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {}
        }
        System.out.println("线程停止");
    }

    public void stopThread() {
        running = false;  // 主线程修改，子线程立即看到
    }
}

小结