先说说Atom，它的存在是为了保证操作原子性，就是确保就是我修改的是我应该的修改，如果有谁干扰了，我就不干了，大概是这意思
先来个图
这里来做个解释哈
第一步，两个线程都读到旧值 0
第二步，线程 1 先 CAS 成功
第三步，线程 0 再 CAS
第四步，线程 0 重新读取
所以才会有上面的情况，因为这是为了确保修改的时候不会被干扰，不然数据不对了
因为使用atom是直接找地址拿到最新的数据来比较，同时拿到修改完成是原子性一次性完成，所以不会存在外界的干扰
代码部分
package com.java.test260428;import lombok.extern.slf4j.Slf4j;import java.util.concurrent.atomic.AtomicInteger;/*** @Description:* @Author: tutu-qiuxie* @Create: 2026/4/28 15:43*/
@Slf4j
public class AtomTest {private static AtomicInteger count=new AtomicInteger(0);public static void main(String[] args) {for (int i = 0; i < 2; i++) {new Thread(() -> {while (true) {int old = count.get();int newVal = old + 1;// 故意放慢，增加冲突概率try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}if (count.compareAndSet(old, newVal)) {log.info(Thread.currentThread().getName() + "--------------------------成功: " + newVal);break;} else {log.info(Thread.currentThread().getName() + " CAS失败，重试");}}}).start();}}
}
这里希望大家可以了解，加入休眠时间，是为了展示cas报错的现象
但是你要明白，如果有 1000 个线程同时对同一个 AtomicInteger 做加一。
这时候只有一个线程能 CAS 成功，其他线程可能失败，然后不断重试。
因此使用atom是有特定的场景的
计数，状态标记，
如果只是做高并发计数，推荐 LongAdder
你看即使我休眠了也不会出问题了
代码部分
package com.java.test260428;import java.util.concurrent.atomic.LongAdder;/*** @Description:* @Author: tutu-qiuxie* @Create: 2026/4/28 16:29*/
public class LongAdderTest {private static LongAdder count = new LongAdder();public static void main(String[] args) {for (int i = 0; i < 100; i++) {new Thread(() -> {// 故意放慢try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}count.increment();System.out.println(Thread.currentThread().getName()+ " 成功: " + count.sum());}).start();}}
}
那为啥LongAdder可以，那是因为它做到了"不要让所有线程都去抢同一个变量，而是把热点分散到多个变量上"
但是LongAdder分散了竞争，你可以这样理解
最后做个汇总，但是各有各的特点
你可以使用LongAdder
接口访问次数 请求总数 成功次数 失败次数 日志计数 监控指标 点赞数量统计
但是它不适合返回递增后的精确值，需要精确值还是要用atom
下面给个两者对比
好了，说完这个，开始简单说下synchronized
先来个图
刚开始使用处于无锁状态
已经为轻量锁了
成为重度锁了，我们可以看到synchronized在使用过程中是不断变化的，
代码部分
package com.java.test260428;import lombok.extern.slf4j.Slf4j;
import org.openjdk.jol.info.ClassLayout;/*** @Description:* @Author: tutu-qiuxie* @Create: 2026/4/28 21:38*/
@Slf4j
public class LockStateDemo {static final Object lock = new Object();public static void main(String[] args) throws Exception {log.info("1. 初始状态");printLock();Thread.sleep(5000);log.info("2. 可能进入偏向锁之前的状态");printLock();synchronized (lock) {log.info("3. 第一次 synchronized 内部");printLock();}log.info("4. synchronized 结束之后");printLock();Thread t1 = new Thread(() -> {synchronized (lock) {log.info("5. 线程 t1 获取锁");printLock();try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}log.info("6. 线程 t1 即将释放锁");printLock();}});Thread t2 = new Thread(() -> {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock) {log.info("7. 线程 t2 获取锁");printLock();}});t1.start();t2.start();t1.join();t2.join();log.info("8. 所有线程结束之后");printLock();}static void printLock() {log.info(ClassLayout.parseInstance(lock).toPrintable());}}
-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0