保证i++原子性操作_non-atomic operation on volatile field-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_41921994/article/details/115731999

本文对比了Java中三种不同的并发控制方式：juc中的Lock、synchronized关键字以及AtomicInteger。通过示例代码展示了它们在多线程环境下确保数据同步的效果，指出volatile无法保证原子性操作的问题。Lock提供了更细粒度的锁控制，synchronized关键字简单易用，而AtomicInteger利用原子操作实现高效并发更新。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.使用juc中的lock

package org.example.base.test;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author l
 * @date Created in 2021/4/19 17:23
 */
public class AtomicTest {

    private int i;
    private final Lock lock = new ReentrantLock();

    public void add() {
        lock.lock();
        try {
            i++;
        } finally {
            lock.unlock();
        }

    }

    public Integer getI() {
        return i;
    }

    public static void main(String[] args) {
        AtomicTest atomicTest = new AtomicTest();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    atomicTest.add();
                }
            }).start();
        }

        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        //每次输出都是10000
        System.out.println(atomicTest.getI());
    }


}

2.使用java关键字synchronized

package org.example.base.test;

/**
 * @author l
 * @date Created in 2021/4/19 17:23
 */
public class AtomicTest {

    private int i;

    public synchronized void add() {
        i++;
    }

    public Integer getI() {
        return i;
    }

    public static void main(String[] args) {
        AtomicTest atomicTest = new AtomicTest();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    atomicTest.add();
                }
            }).start();
        }

        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        //每次输出都是10000
        System.out.println(atomicTest.getI());
    }


}

3.使用juc中的AtomicInteger

package org.example.base.test;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author l
 * @date Created in 2021/4/19 17:23
 */
public class AtomicTest {

    AtomicInteger i = new AtomicInteger(0);

    public void add() {
        i.getAndIncrement();
    }

    public Integer getI() {
        return i.get();
    }

    public static void main(String[] args) {
        AtomicTest atomicTest = new AtomicTest();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    atomicTest.add();
                }
            }).start();
        }

        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        //每次输出都是10000
        System.out.println(atomicTest.getI());
    }


}

4.volatile并不能保证原子性操作

package org.example.base.test;


/**
 * @author l
 * @date Created in 2021/4/19 17:23
 */
public class AtomicTest {

    private volatile int i;

    public void add() {
        //Non-atomic operation on volatile field 'i'
        i++;
    }

    public Integer getI() {
        return i;
    }

    public static void main(String[] args) {
        AtomicTest atomicTest = new AtomicTest();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    atomicTest.add();
                }
            }).start();
        }

        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        //每次输出的值都不确定，并且小于10000
        System.out.println(atomicTest.getI());
    }


}