详解Java多线程基础

在 Ja va 并发编程里，多线程是绕不开的核心话题，也是很多开发者入门时容易踩坑的地方。今天咱们就把几个最基础、最常用的多线程知识点重新捋一遍——从线程的创建方式到生命周期，从休眠到安全同步，再到集合类的选型。不说废话，直接上干货。

线程创建两种方式

方式 1：继承 Thread 类

继承后重写run()，调用start()启动线程

// 1.定义线程类
class MyThread extends Thread{
    @Override
    public void run() {
        // 线程执行任务
        for (int i = 0; i < 5; i++) {
            System.out.println("线程执行："+i);
        }
    }
}
// 测试
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // 启动线程，自动执行run方法
    }
}

方式 2：实现 Runnable 接口

避免单继承限制，更常用

// 1.实现接口
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("任务运行："+i);
        }
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
        MyRunnable task = new MyRunnable();
        Thread t2 = new Thread(task);
        t2.start();
    }
}

如何实现多线程

// 1.定义线程类
class MyThread extends Thread{
    @Override
    public void run() {
        // 线程执行任务
        for (int i = 0; i < 5; i++) {
            // 加上当前线程名字，你能看清谁在跑
            System.out.println(getName() + " 执行："+i);
        }
    }
}
// 测试
public class ThreadDemo {
    public static void main(String[] args) {
        // 创建 2 个线程
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        // 给线程起名字
        t1.setName("线程A");
        t2.setName("线程B");
        // 启动 → 这才是多线程！
        t1.start();
        t2.start();
    }
}
// 1. 定义任务（不是线程，是任务）
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            // 打印当前线程名字，能看清谁在跑
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
        // 1. 创建任务
        MyRunnable task = new MyRunnable();
        // 2. 创建 2 个线程，执行同一个任务！！！
        Thread t1 = new Thread(task, "线程1");
        Thread t2 = new Thread(task, "线程2");
        // 3. 启动两个线程 → 这就是多线程！
        t1.start();
        t2.start();
    }
}

线程生命周期

新建new线程对象-调用start（），等待CPU调度-CPU执行run方法-sleep，等待锁，IO阻塞-任务执行完毕/异常终止

sleep 线程休眠

让线程暂停指定毫秒，让出 CPU 执行权

class SleepThread implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println("计数："+i);
            try {
                // 休眠1000毫秒=1秒
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class SleepTest {
    public static void main(String[] args) {
        new Thread(new SleepThread()).start();
    }
}

线程安全问题 & synchronized 同步锁

多线程同时操作共享数据，会出现数据错乱，加锁保证同一时间仅一个线程访问

//无锁不安全示例
class Ticket implements Runnable{
    private int ticket = 10;
    @Override
    public void run() {
        while (ticket > 0){
            System.out.println("剩余票数："+ticket--);
        }
    }
}
// 多线程抢票，会出现重复票数、负数票
public class UnSafeTest {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket,"窗口1").start();
        new Thread(ticket,"窗口2").start();
    }
}
//synchronized 加锁解决安全问题
class SafeTicket implements Runnable{
    private int ticket = 10;
    // 锁对象
    private final Object lock = new Object();
    @Override
    public void run() {
        while (true){
            // 同步代码块，同一时间只允许一个线程进入
            synchronized (lock){
                if(ticket <= 0){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"出票，剩余："+ticket--);
            }
        }
    }
}
public class SafeLockTest {
    public static void main(String[] args) {
        SafeTicket ticket = new SafeTicket();
        new Thread(ticket,"窗口A").start();
        new Thread(ticket,"窗口B").start();
    }
}

HashMap vs 线程安全集合

• HashMap：线程不安全，多线程下会出错、数据丢失、死循环。
• 线程安全集合：多线程下不会出错，保证数据正确。

HashMap 为什么线程不安全？

原因：

• 没有加锁
• 多线程同时修改、插入数据时，会互相覆盖、冲突
• JDK 1.8 之前会造成死循环

多线程使用 HashMap 会出现什么问题？

• 数据覆盖
• 数据丢失
• 并发修改异常
• 极端情况下链表成环（卡死）

Ja va 提供哪些线程安全的 Map？

• Hashtable（古老，效率低）
• Collections.synchronizedMap(Map)（包装成安全 map）
• ConcurrentHashMap（推荐！最常用！高性能！）

1）HashMap（线程不安全）

单线程用，多线程绝对不能用！

Map map = new HashMap<>();

2）Hashtable（线程安全，但性能差）

• 方法全部加 synchronized
• 多线程会串行等待，性能差
• 现在基本不用

Map map = new Hashtable<>();

3）Collections.synchronizedMap（安全，性能一般）

把不安全的 Map 包装成安全的

Map map = Collections.synchronizedMap(new HashMap<>());

4）ConcurrentHashMap（企业级首选！）

• Ja va 最推荐的线程安全 Map
• 分段锁 / CAS 机制，高并发、高性能
• 多线程开发必须用它

Map map = new ConcurrentHashMap<>();