【Java 多线程】12个原子操作类一次性搞定

AtomicLong count = new AtomicLong(10); // 初始化值为 10
LongBinaryOperator accumulator = (current, delta) -> current + delta; // 定义累积函数为加法操作
long oldValue = count.getAndAccumulate(5, accumulator); // 获取并累加值，返回累加前的旧值
System.out.println("旧值: " + oldValue); // 输出旧的count值（累加前的值）
System.out.println("新值: " + count.get()); // 输出新的count值（累加后的值）

AtomicLongArray atomicLongArray = new AtomicLongArray(10);
// 使用索引初始化数组的值
atomicLongArray.set(0, 1); // 设置索引为0的元素值为1
atomicLongArray.set(2, 10); // 设置索引为2的元素值为10

// 使用getAndUpdate方法更新索引为0的元素值，并且更新过程中打印原始值和新值
long oldValue = atomicLongArray.getAndUpdate(0, currentValue -> currentValue + 1L); // 获取并增加索引为0的元素值
System.out.println("旧值: " + oldValue); // 输出旧值，即更新前的值
System.out.println("新值: " + atomicLongArray.get(0)); // 输出新值，即更新后的值通过直接获取验证

// 使用Lambda表达式更新索引为2的元素值，将其乘以2并返回旧值和新值
oldValue = atomicLongArray.getAndUpdate(2, currentValue -> currentValue * 2); // 获取并乘以2索引为2的元素值
System.out.println("旧值: " + oldValue); // 输出旧值，即更新前的值（原来的值）
System.out.println("新值: " + atomicLongArray.get(2)); // 输出新值，即更新后的值通过直接获取验证

class User {
    private String name;

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

    public String getName() {
       return name;
    }

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

    @Override
    public String toString() {
       return "User{" +
             "name='" + name + ''' +
             '}';
    }
}

public class AtomicStampedReferenceExample {

    public static void main(String[] args) {
       // 创建一个 User 对象
       User user = new User("Alice");

       // 使用 AtomicStampedReference 包装 User 对象
       AtomicStampedReference<User> userRef = new AtomicStampedReference<>(user, 0);
       int stamp = userRef.getStamp();
       // 打印初始状态
       System.out.println("Initial state: " + userRef.getReference());

       // 线程 1 更新 name 属性
       Thread thread1 = new Thread(() -> {
          // 获取当前版本号


          // 创建新的 User 对象，并更新 name 属性
          User newUser = new User("Bob");

          // 使用 compareAndSet 方法尝试更新 User 对象
          boolean success = userRef.compareAndSet(userRef.getReference(), newUser, stamp, stamp + 1);

          if (success) {
             System.out.println("Thread 1 updated name to: " + newUser.getName());
          } else {
             System.out.println("Thread 1 failed to update name.");
          }
       });

       // 线程 2 尝试更新 name 属性
       Thread thread2 = new Thread(() -> {
          // 获取当前版本号

          // 创建新的 User 对象，并更新 name 属性
          User newUser = new User("Charlie");

          // 使用 compareAndSet 方法尝试更新 User 对象
          boolean success = userRef.compareAndSet(userRef.getReference(), newUser, stamp, stamp + 1);

          if (success) {
             System.out.println("Thread 2 updated name to: " + newUser.getName());
          } else {
             System.out.println("Thread 2 failed to update name.");
          }
       });

       // 启动线程
       thread1.start();
       try {
          TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
          e.printStackTrace();
       }

       thread2.start();

       // 等待线程执行完成
       try {
          thread1.join();
          thread2.join();
       } catch (InterruptedException e) {
          e.printStackTrace();
       }

       // 打印最终状态
       System.out.println("Final state: " + userRef.getReference());
    }
}

public class AtomicReferenceTest {
    public static AtomicReference<User> atomicReference= new AtomicReference<User>();

    public static void main(String[] args) {
        User user = new User("conan", 15);
        atomicReference.set(user);
        System.out.println("user = " + user.old);
        AtomicReferenceFieldUpdater<User, String> userStringAtomicReferenceFieldUpdater = AtomicReferenceFieldUpdater.newUpdater(
                User.class,String.class, "name"  //通过反射实现的
        );
        userStringAtomicReferenceFieldUpdater.compareAndSet(user,"conan","aaa");
        System.out.println("userStringAtomicReferenceFieldUpdater = " + user.name);

    }


    static class User{
        public volatile  String name;
        private  int old;

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

        public String getName() {
            return name;
        }

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

        public int getOld() {
            return old;
        }

        public void setOld(int old) {
            this.old = old;
        }
    }
}