解决Java中线程安全问题

public class StackClosedDemo {
    // 每个线程调用该方法时，都会创建独立的count副本
    public void calculate() {
        int count = 0;
        count++; // 无线程安全问题
        System.out.println(Thread.currentThread().getName() + ": " + count);
    }
    public static void main(String[] args) {
        StackClosedDemo demo = new StackClosedDemo();
        // 10个线程各自操作自己的局部变量
        for (int i = 0; i < 10; i++) {
            new Thread(demo::calculate, "Thread-" + i).start();
        }
    }
}

// 自定义不可变类（final类+final成员变量+无setter）
public final class ImmutableUser {
    private final String name;
    private final int age;
    public ImmutableUser(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 仅提供getter，无setter
    public String getName() { return name; }
    public int getAge() { return age; }
}

public class ThreadLocalDemo {
    // 每个线程有独立的Integer副本，初始值为0
    private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
    public void increment() {
        threadLocal.set(threadLocal.get() + 1);
        System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
    }
    public static void main(String[] args) {
        ThreadLocalDemo demo = new ThreadLocalDemo();
        // 3个线程各自操作自己的副本
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 2; j++) {
                    demo.increment();
                }
            }, "Thread-" + i).start();
        }
    }
}
// 输出（顺序可能不同）：
// Thread-0: 1、Thread-0: 2
// Thread-1: 1、Thread-1: 2
// Thread-2: 1、Thread-2: 2

public class SynchronizedDemo {
    private int count = 0;
    // 同步实例方法，锁是this对象
    public synchronized void increment() {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 1000个线程执行increment
        for (int i = 0; i < 1000; i++) {
            new Thread(demo::increment).start();
        }
        Thread.sleep(1000);
        System.out.println("最终count：" + demo.count); // 输出1000
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
    private int count = 0;
    private Lock lock = new ReentrantLock(); // 默认非公平锁
    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 释放锁，避免死锁
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ReentrantLockDemo demo = new ReentrantLockDemo();
        for (int i = 0; i < 1000; i++) {
            new Thread(demo::increment).start();
        }
        Thread.sleep(1000);
        System.out.println("最终count：" + demo.count); // 输出1000
    }
}

public class VolatileDemo {
    private volatile boolean stop = false; // 保证可见性和有序性
    public void runThread() {
        new Thread(() -> {
            int i = 0;
            while (!stop) { // 能立即感知stop的修改
                i++;
            }
            System.out.println("线程停止，i=" + i);
        }).start();
    }
    public static void main(String[] args) throws InterruptedException {
        VolatileDemo demo = new VolatileDemo();
        demo.runThread();
        Thread.sleep(3000);
        demo.stop = true; // 修改后，线程立即停止
    }
}