并发编程-Java 线程安全机制

世纪摆渡人

于 2025-05-13 10:10:43 发布

阅读量1k

点赞数 12

分类专栏：并发编程文章标签： java 安全 jvm

本文链接：https://blog.csdn.net/weixin_45226668/article/details/147916755

版权

并发编程专栏收录该内容

9 篇文章

订阅专栏

并发编程-Java 线程安全机制

概要

在多线程编程中，线程安全是一个非常重要的话题。线程安全是指多个线程在执行某些操作时，不会因为竞争资源或其他线程干扰而导致程序出现异常的行为。对于并发应用而言，保证线程安全至关重要，因为一旦线程安全问题出现，程序的稳定性和数据的正确性会受到严重影响。

一、什么是线程安全？

线程安全是指在多线程环境下，多个线程同时访问某个对象时，不会引起数据不一致或程序崩溃的状态。简单来说，就是多个线程并发执行时，程序的行为仍然是可预见的。

在没有适当机制的情况下，如果多个线程同时对同一个资源进行修改，可能会导致以下问题：

数据竞争：多个线程对同一数据进行修改，导致不可预测的结果。
脏读：线程A写入数据后，线程B读取了数据，但线程A的写入并未完全提交。
死锁：两个或多个线程互相等待对方释放资源，导致程序卡住。

为了避免这些问题，Java提供了多种线程安全的机制。

二、如何实现线程安全？

实现线程安全通常有两种方法：

同步控制：通过某种机制（如锁）来控制对共享资源的访问，确保一次只有一个线程能够访问资源。
无锁并发编程：通过设计无锁算法或者利用并发集合类来避免锁的使用，提升性能。

1、使用 synchronized 关键字

synchronized 是 Java 中实现线程安全的最基础机制，它可以用来修饰方法或者代码块。当一个线程访问某个同步代码块时，其他线程必须等待该线程释放锁，才能进入该同步代码块。
代码示例：使用 synchronized 修饰方法

public class Counter {
    private int count = 0;
 
    // synchronized 修饰实例方法，保证同一时刻只有一个线程可以执行
    public synchronized void increment() {
        count++;
    }
 
    public 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 < 1000; i++) {
                counter.increment();
            }
        });
 
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        t1.start();
        t2.start();
 
        t1.join();
        t2.join();
 
        System.out.println("Final count: " + counter.getCount()); // Output: 2000
    }
}

在上述代码中，increment() 方法使用了 synchronized 修饰，确保每次只有一个线程能访问该方法，从而避免了数据竞争。

代码示例：使用 synchronized 修饰代码块

public class Counter {
    private int count = 0;
 
    public void increment() {
        synchronized (this) {  // synchronized 修饰代码块
            count++;
        }
    }
 
    public 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 < 1000; i++) {
                counter.increment();
            }
        });
 
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        t1.start();
        t2.start();
 
        t1.join();
        t2.join();
 
        System.out.println("Final count: " + counter.getCount()); // Output: 2000
    }
}

在这个例子中，synchronized 用于同步 increment() 方法中的代码块。这样，count++ 语句成为了一个原子操作，避免了多个线程同时修改 count 的情况。

2、使用 ReentrantLock 实现线程安全

ReentrantLock 是 Java 提供的一个高级锁机制，比 synchronized 更灵活。它是 java.util.concurrent.locks 包的一部分，提供了显式的锁获取和释放功能。

代码示例：使用 ReentrantLock

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();
 
    public void increment() {
        lock.lock();  // 获取锁
        try {
            count++;
        } finally {
            lock.unlock();  // 确保释放锁
        }
    }
 
    public 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 < 1000; i++) {
                counter.increment();
            }
        });
 
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        t1.start();
        t2.start();
 
        t1.join();
        t2.join();
 
        System.out.println("Final count: " + counter.getCount()); // Output: 2000
    }
}

ReentrantLock 提供了比 synchronized 更多的控制，如尝试锁定（tryLock()）、定时锁定等，可以帮助开发者处理复杂的并发问题。

3、使用 volatile 关键字

volatile 关键字用于保证变量的可见性。当一个线程修改了某个 volatile 变量的值，其他线程能立即看到这个变化。volatile 只保证可见性，不能保证原子性，因此它不能代替 synchronized 或 ReentrantLock 来保证线程安全。

代码示例：使用 volatile 保证可见性

public class Flag {
    private volatile boolean flag = false;
 
    public void setFlagTrue() {
        flag = true;
    }
 
    public boolean getFlag() {
        return flag;
    }
 
    public static void main(String[] args) throws InterruptedException {
        Flag flag = new Flag();
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
                flag.setFlagTrue();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
 
        Thread t2 = new Thread(() -> {
            while (!flag.getFlag()) {
                // 等待 flag 变为 true
            }
            System.out.println("Flag is true now!");
        });
 
        t1.start();
        t2.start();
 
        t1.join();
        t2.join();
    }
}

在这个例子中，flag 是 volatile 类型的变量，确保线程 t2 能立刻看到 t1 对 flag 的修改。

4、使用 Atomic 类

Java java.util.concurrent.atomic 包提供了一些原子类（如 AtomicInteger, AtomicLong, AtomicReference 等），这些类通过底层的CAS（Compare-And-Swap）算法来保证线程安全，而不需要使用同步锁。它们可以提供比 synchronized 更高效的并发访问。

代码示例：使用 AtomicInteger

import java.util.concurrent.atomic.AtomicInteger;
 
public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
 
    public void increment() {
        count.incrementAndGet();  // 原子性操作
    }
 
    public int getCount() {
        return count.get();
    }
 
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        t1.start();
        t2.start();
 
        t1.join();
        t2.join();
 
        System.out.println("Final count: " + counter.getCount()); // Output: 2000
    }
}

在这个例子中，AtomicInteger 提供了原子操作 incrementAndGet()，确保在并发环境下的线程安全。

三、总结：常见线程安全机制对比

机制	适用场景	优点	缺点
synchronized	控制代码块或方法的同步访问	简单易用，JVM层面优化	性能开销较大，不够灵活
ReentrantLock	需要更多控制的并发场景	提供更多的功能，如超时、可中断等	比 synchronized 更复杂
volatile	只保证可见性的简单场景	性能开销小，适用于简单场景	不能保证原子性，不能替代锁机制
Atomic 类	高并发计数、标志位操作等	高效的原子操作，无需显式加锁	仅适用于简单的原子操作，不适用于复杂逻辑

小结

Java 中实现线程安全的方式多种多样，从基本的 synchronized 到灵活的 ReentrantLock，从高效的 Atomic 类到简单的 volatile，每种方式都有其适用场景。理解每种机制的优缺点，合理选择实现线程安全的方式，对于提升程序的性能和可靠性至关重要。在多线程编程中，掌握线程安全机制，将大大提高开发效率，并避免难以排查的并发问题。

以上是关于并发编程-Java 线程安全机制的部分见解