Java-并发编程基础：Thread、Runnable、synchronized

并发介绍

为什么需要多线程？

---充分利用CPU、提升效率、处理异步任务

创建线程方式1、继承 Thread 类

class MyThread extends Thread {
    // 重写run()，run()为线程运行时执行的方法
    @Override
    public void run() {
        System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // start()启动线程，启动后自动调用重写的run()
    }
}

1、单继承，无法再继承其他类

2、每个线程有自己的对象，共享数据需静态变量

创建线程方式2、实现 Runnable 接口（推荐）

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

public class RunnableDemo {
    public static void main(String[] args) {
        // 将 实现Runnable接口的 对象作为参数传给 Thread
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
    }
}

1、可以继承其他类，更灵活

2、多个线程可共享同一个 Runnable 对象，方便共享数据

3、实际开发中，更常使用 匿名内部类 或 Lambda 表达式 直接创建线程，无需单独定义 MyRunnable 类。

public class AnonymousThreadDemo {
    public static void main(String[] args) {
        // 使用匿名内部类实现 Runnable 接口
        // new Runnable() { ... }：声明一个没有名字的类，这个类实现了 Runnable 接口
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 正在执行");
            }
        });
        t1.start();
    }
}

线程的常用方法

start()	启动线程，JVM 调用 run()	thread.start();
run()	线程执行体，不要直接调用	-
sleep(ms)	当前线程休眠（暂停执行）指定毫秒	Thread.sleep(1000);
join()	等待该线程执行完毕	thread.join();
yield()	当前线程让出CPU，但不保证其他线程能抢占	Thread.yield();
interrupt()	中断线程（设置中断标志）	thread.interrupt();

线程安全问题与 synchronized

问题场景：多线程操作共享变量

// 方式1：synchronized修饰方法
class SafeCounter {
    private int count = 0;
    // 给共享资源加一把锁。一个线程获得锁才能操作共享资源，使用完成后释放锁
    public synchronized void increment() { // 锁住当前对象
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

// 方式2：私有锁、同步代码块
class SafeCounter {
    private int count = 0;
    private final Object lock = new Object(); // 私有锁

    public void increment() {
        synchronized (lock) { // 锁住指定的对象
            count++;
        }
    }
}

线程的生命周期（状态）

状态	说明
NEW	线程对象已创建，但尚未调用 start()
RUNNABLE	可运行状态（可能正在运行，也可能在等待CPU时间片）
BLOCKED	被阻塞，等待获取锁（如 synchronized）
WAITING	无限等待，直到被显式唤醒（如 wait()、join()）
TIMED_WAITING	有限时等待（如 sleep(ms)、wait(timeout)）
TERMINATED	线程执行完毕，已终止

线程状态变化的核心：start() → RUNNABLE；遇到锁 → BLOCKED；

调用 sleep()/wait() → TIMED_WAITING/WAITING；run()执行完 → TERMINATED。