synchronized 能保证原子性。它通过获取和释放监视器锁，将代码块或方法标记为临界区，确保同一时刻只有一个线程能执行该段代码，从而把原本可能被打断的操作变成不可分割的整体。

为什么 synchronized 能实现原子性

因为 JVM 在执行 synchronized 块时，会先尝试获取对象监视器（Monitor）的锁。如果锁已被占用，当前线程会被阻塞；只有拿到锁后，才能进入临界区执行代码。执行完毕后，必须释放锁，其他等待的线程才能竞争锁。这种互斥机制保证了临界区内代码的原子性。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        // 这个操作是原子的
        count++;
    }

    public synchronized int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i  {
            for (int i = 0; i 
<p>预期输出：Final Count: 20000</p>
<h2>synchronized 的可见性与有序性保障</h2><p>除了原子性，synchronized 还具备可见性和有序性。当线程释放锁时，会将工作内存中的变量刷新到主内存；当线程获取锁时，会清空工作内存并从主内存重新读取变量。这解决了多线程环境下的数据一致性问题。</p><div class="aritcle_card flexRow artxards">
											<div class="artcardd flexRow">
												<a class="aritcle_card_img" rel="nofollow" href="/xiazai/skill11083" title="Java调试"><img
														src="https://img.php.cn/upload/skill/001/246/273/6adaf20dbae7c507.jpg" alt="Java调试" onerror="this.onerror='';this.src='/static/lhimages/moren/morentu.png'" ></a>
												<div class="aritcle_card_info flexColumn">
													<a rel="nofollow" href="/xiazai/skill11083" title="Java调试" class="overflowclass">Java调试</a>
													<p class="overflowclass">通过 JDWP 实现 Java 远程调试：连接远程 JVM、设置断点、单步执行代码、查看变量值、获取调用栈。适用于需要调试远程 Java 应用、排查运行时状态、追踪代码执行流程的场景。
术语注解
JDWP：Java Debug Wire Protocol，Java 调试有线协议（Java 远程调试底层通信协议）
remote JVM：远程 Java 虚拟机
step through code：代码单步调试（步入 / 步过 / 步出调试）
inspect variables：变量查看 / 变量检视
stac</p>
												</div>
												<a rel="nofollow" href="/xiazai/skill11083" title="Java调试" class="aritcle_card_btn flexRow flexcenter"><b></b><span>下载</span>
												</a>
											</div>
										</div><p>@@##@@</p>
<pre class="brush:php;toolbar:false;">public class VisibilityExample {
    private boolean flag = false;

    public synchronized void setFlag() {
        flag = true;
    }

    public synchronized boolean isFlag() {
        return flag;
    }

    public static void main(String[] args) throws InterruptedException {
        VisibilityExample example = new VisibilityExample();
        Thread writer = new Thread(() -> {
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            example.setFlag();
        });
        Thread reader = new Thread(() -> {
            while (!example.isFlag()) {
                // 自旋等待
            }
            System.out.println("Flag is now true!");
        });
        writer.start();
        reader.start();
        writer.join();
        reader.join();
    }
}

预期输出：Flag is now true!

在复杂业务逻辑中如何保证原子性

当涉及多个变量的复合操作时，必须将所有相关操作放在同一个 synchronized 块内。例如，检查并更新状态的操作，如果分开加锁，仍可能出现竞态条件。因此，应将整个业务逻辑包裹在一个同步块中，确保其原子性。

public class ComplexOperation {
    private int balance = 100;
    private boolean overdraftAllowed = false;

    public synchronized void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("Withdrawal successful. Balance: " + balance);
        } else if (overdraftAllowed) {
            balance -= amount;
            System.out.println("Overdraft applied. Balance: " + balance);
        } else {
            System.out.println("Insufficient funds.");
        }
    }

    public synchronized void allowOverdraft(boolean allowed) {
        overdraftAllowed = allowed;
    }

    public static void main(String[] args) throws InterruptedException {
        ComplexOperation op = new ComplexOperation();
        Thread t1 = new Thread(() -> {
            op.withdraw(50);
        });
        Thread t2 = new Thread(() -> {
            op.allowOverdraft(true);
            op.withdraw(60);
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

预期输出：Withdrawal successful. Balance: 50\nOverdraft applied. Balance: -10

Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南