一文梳理Java中保证线程安全的5大常见方法

// dcl单例模式的正确写法
public class singleton {
    private static volatile singleton instance; // 必须加volatile
    
    private singleton() {}
    
    public static singleton getinstance() {
        if (instance == null) { // 第一次检查
            synchronized (singleton.class) { // 加锁
                if (instance == null) { // 第二次检查
                    instance = new singleton();
                }
            }
        }
        return instance;
    }
}

private static threadlocal<simpledateformat> dateformatthreadlocal = 
    threadlocal.withinitial(() -> new simpledateformat("yyyy-mm-dd"));

// 技术亮点：防止子类破坏不可变性、保证所有字段的可见性
public final class immutableuser { // 1. 类用final修饰，禁止继承
    private final long id; // 2. 所有字段用final修饰
    private final string name;
    private final date birthday; // 3. 对可变字段进行防御性拷贝

    public immutableuser(long id, string name, date birthday) {
        this.id = id;
        this.name = name;
        // 关键：不直接引用外部传入的可变对象
        this.birthday = new date(birthday.gettime());
    }

    // 4. 不提供任何setter方法
    public long getid() { return id; }
    public string getname() { return name; }
    
    // 5. getter返回可变对象的拷贝，而不是原引用
    public date getbirthday() {
        return new date(birthday.gettime());
    }
}

// 技术亮点：无锁编程、cpu原语支持、乐观锁思想
public class atomicinteger extends number implements java.io.serializable {
    private volatile int value; // 保证可见性
    
    public final int getandincrement() {
        // cas操作：compareandswapint是native方法，由cpu指令保证原子性
        return unsafe.getandaddint(this, valueoffset, 1);
    }
    
    // unsafe类中的核心方法
    // public final native boolean compareandswapint(
    //     object obj, long offset, int expect, int update);
}

// 手写一个简单的自旋锁（面试常考）
public class spinlock {
    private atomicboolean locked = new atomicboolean(false);
    
    public void lock() {
        // 循环尝试获取锁，直到成功
        while (!locked.compareandset(false, true)) {
            // 空自旋，消耗cpu但避免线程上下文切换
        }
    }
    
    public void unlock() {
        locked.set(false);
    }
}

// 技术亮点：可中断、可超时、公平锁支持
public class reentrantlockexample {
    private final reentrantlock lock = new reentrantlock(true); // 公平锁
    
    public void dosomething() {
        lock.lock(); // 1. 加锁
        try {
            // 2. 业务逻辑（必须在try块内）
            system.out.println("执行业务逻辑");
        } finally {
            // 3. 必须在finally中释放锁！！！
            lock.unlock();
        }
    }
    
    // 更安全的写法：trylock避免死锁
    public boolean trydosomething(long timeout, timeunit unit) throws interruptedexception {
        if (lock.trylock(timeout, unit)) {
            try {
                system.out.println("获取锁成功，执行业务");
                return true;
            } finally {
                lock.unlock();
            }
        }
        // 获取锁失败
        return false;
    }
}

// 技术亮点：读写分离、读-读不互斥、性能提升10倍以上
public class readwritelockcache<k, v> {
    private final map<k, v> cache = new hashmap<>();
    private final reentrantreadwritelock rwlock = new reentrantreadwritelock();
    private final lock readlock = rwlock.readlock();
    private final lock writelock = rwlock.writelock();
    
    // 读操作：加读锁，多个线程可以同时读
    public v get(k key) {
        readlock.lock();
        try {
            return cache.get(key);
        } finally {
            readlock.unlock();
        }
    }
    
    // 写操作：加写锁，阻塞所有读和写
    public void put(k key, v value) {
        writelock.lock();
        try {
            cache.put(key, value);
        } finally {
            writelock.unlock();
        }
    }
    
    // 缓存更新：先写后读的原子操作
    public v putifabsent(k key, v value) {
        writelock.lock();
        try {
            if (!cache.containskey(key)) {
                cache.put(key, value);
                return null;
            }
            return cache.get(key);
        } finally {
            writelock.unlock();
        }
    }
}

// 技术亮点：线程封闭、避免参数传递、simpledateformat线程安全问题解决
public class threadlocalexample {
    // 正确写法：使用static final修饰threadlocal
    private static final threadlocal<simpledateformat> date_format =
        threadlocal.withinitial(() -> new simpledateformat("yyyy-mm-dd hh:mm:ss"));
    
    public string formatdate(date date) {
        try {
            return date_format.get().format(date);
        } finally {
            // 关键：使用完必须remove！！！防止内存泄漏
            date_format.remove();
        }
    }
}

// 技术亮点：懒加载、线程安全、无锁、性能最高
public class singleton {
    private singleton() {} // 私有构造函数
    
    // 静态内部类，只有在第一次被调用时才会加载
    private static class singletonholder {
        private static final singleton instance = new singleton();
    }
    
    public static singleton getinstance() {
        return singletonholder.instance;
    }
}

// 技术亮点：分段锁、减少cas竞争、高并发下性能比atomiclong高10倍
public class longadder extends striped64 implements serializable {
    // 核心思想：将一个long值拆分成多个cell
    // 不同线程更新不同的cell，最后求和
    // 只有当cell竞争失败时才会扩容
    
    public void add(long x) {
        cell[] as; long b, v; int m; cell a;
        if ((as = cells) != null || !casbase(b = base, b + x)) {
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[getprobe() & m]) == null ||
                !(uncontended = a.cas(v = a.value, v + x)))
                longaccumulate(x, null, uncontended);
        }
    }
    
    public long sum() {
        cell[] as = cells;
        long sum = base;
        if (as != null) {
            for (cell a : as)
                if (a != null)
                    sum += a.value;
        }
        return sum;
    }
}

public class timeoutretryservice {
    private final lock lock = new reentrantlock();

    public boolean processwithtimeout(string orderid) {
        boolean acquired = false;
        try {
            // 🌟 技术亮点：尝试获取锁，等200ms拿不到就降级，不阻塞
            acquired = lock.trylock(200, timeunit.milliseconds);
            if (!acquired) {
                // 降级策略：放入延迟队列，或返回“操作进行中”
                system.out.println("系统繁忙，订单 " + orderid + " 稍后重试");
                return false;
            }
            // 临界区：真正处理业务
            doactualwork(orderid);
            return true;
        } catch (interruptedexception e) {
            thread.currentthread().interrupt();
            return false;
        } finally {
            // 🌟 亮点：防止意外释放未持有的锁
            if (acquired) {
                lock.unlock();
            }
        }
    }

    private void doactualwork(string orderid) {
        // 模拟幂等操作
    }
}

public class cascounter {
    private final atomicinteger count = new atomicinteger(0);

    public int incrementandget() {
        int prev, next;
        do {
            prev = count.get();
            next = prev + 1;
            // 🌟 亮点：cas自旋，无锁，高并发下吞吐量远超synchronized
        } while (!count.compareandset(prev, next));
        return next;
    }

    // jdk8 提供的更简洁写法，内部就是 cas
    public int quickincrement() {
        return count.incrementandget(); // 一行搞定
    }
}

public class requestcontextholder {
    private static final threadlocal<map<string, object>> context = 
        threadlocal.withinitial(hashmap::new);

    public static void set(string key, object value) {
        context.get().put(key, value);
    }

    public static object get(string key) {
        return context.get().get(key);
    }

    // 🌟 核心亮点：显式提供清理方法，防止线程池复用导致内存泄漏
    public static void clear() {
        context.remove(); // 必须调！
    }
}

// 使用方：在过滤器 finally 块中清理
try {
    requestcontextholder.set("userid", "10086");
    // ... 业务处理
} finally {
    requestcontextholder.clear(); // ⚠️ 关键一步
}