Java多线程 原子操作类详细

什么是原子操作？

在计算机科学中，原子操作是指不可被进一步分割的操作。即使在并行的情况下执行，原子操作也会被看作是单个操作，不会被其他操作中断。在多线程编程中，对共享数据的修改必须是原子操作，否则就会出现竞态条件（Race Condition）的问题。

Java多线程中的原子操作

Java并发包中提供了一系列的原子操作类，包括以下几个常用的类：

• AtomicInteger
• AtomicLong
• AtomicReference
• AtomicBoolean

这些类提供了原子性的读写操作以及一些类似于CAS（Compare-And-Swap）的操作，可以有效地避免竞态条件的问题。

AtomicInteger

AtomicInteger是一个原子类，用于原子性地更新整型数据。它提供了四个主要的方法：get()、set()、getAndIncrement()和incrementAndGet()，分别用于获取值、设置值、获取值并自增和自增并获取值。

以下是一个简单的示例，展示如何使用AtomicInteger：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private static final int THREADS_COUNT = 100;
    public static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws Exception {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new AddThread());
            threads[i].start();
        }

        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i].join();
        }

        System.out.println("result: " + count);
    }

    private static class AddThread implements Runnable {
        public void run() {
            count.getAndIncrement();
        }
    }
}

在上面的代码中，我们创建了100个线程，每个线程都调用count的getAndIncrement()方法。由于AtomicInteger提供了原子性的修改操作，因此我们可以确保不会出现竞态条件，最终输出的结果应该是100。

AtomicReference

AtomicReference是一个原子类，用于原子性地更新引用数据类型。它提供了get()、set()、compareAndSet()等方法，可以方便地进行原子性的读写操作和比较并替换操作。以下是一个简单的示例：

import java.util.concurrent.atomic.AtomicReference;

public class AtomicExample {
    public static class User {
        private String name;
        private int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

    public static void main(String[] args) {
        AtomicReference<User> userRef = new AtomicReference<User>(new User("Tom", 18));

        User oldUser = userRef.get();
        System.out.println("old user: " + oldUser.getName() + "," + oldUser.getAge());

        User newUser = new User("Jerry", 20);
        userRef.compareAndSet(oldUser, newUser);

        User updatedUser = userRef.get();
        System.out.println("new user: " + updatedUser.getName() + "," + updatedUser.getAge());
    }
}

在上面的代码中，我们创建了一个AtomicReference对象，用于存储User类型的数据。首先，我们获取了原始的User对象，并输出了其属性值。然后，我们创建了一个新的User对象，并使用compareAndSet()方法替换原始的User对象。最后，我们输出了替换后的User对象。

总结

Java并发包提供了一系列的原子操作类，可以方便地进行原子性的读写操作和比较并替换操作。使用这些类可以有效地避免竞态条件的问题，提高多线程程序的性能和正确性。