标签: atomicinteger

原子整数IncrementAndGet（）方法线程安全吗？我没有在其中看到任何使用synced关键字的信息。我正在使用以下代码来生成唯一ID：

public enum UniqueIdGenerator {
    INSTANCE;

    private AtomicLong instance = new AtomicLong(System.currentTimeMillis());

    public long incrementAndGet() {
        return instance.incrementAndGet();
    }
}

我在徘徊，如果多个线程将调用该方法以生成唯一ID会导致任何问题？

UniqueIdGenerator.INSTANCE.incrementAndGet()

谢谢！

我想在Metal应用程序中实现A-Buffer算法，以实现顺序无关的透明度。该技术的描述提到了使用原子计数器。我从来没有使用过这些，甚至从未听说过。我只是在《金属着色语言规范》中读到了原子变量，但无法弄清楚如何实际实现或使用一个。

有人在金属领域有经验吗？您能指出一个如何设置和使用简单整数计数器的示例吗？基本上，每个渲染过程我都需要能够从片段着色器中增加一个从零开始的整数。这用于索引A缓冲区。

谢谢！

嗨，我是多线程新手。试图理解原子整数的概念。我有一个共享计数器变量，它由两个线程递增

class MyCounterClass{
    volatile AtomicInteger sharedCounter = new AtomicInteger(0);

    public int incrementCounter() {
        for(int i = 0; i <10000; i++){
            // add 1
            sharedCounter.incrementAndGet();
        }

        return this.sharedCounter.get();
    }
}

public static void main(String[] args) throws InterruptedException {
        MyCounterClass myCounterClassObj = new MyCounterClass();
        Thread t1 = new Thread(() -> {
            System.out.println("Thread " + Thread.currentThread().getName() + " " +myCounterClassObj.incrementCounter());
        });

        Thread t2 = new Thread(() -> {
            System.out.println("Thread " + Thread.currentThread().getName()+ " " + myCounterClassObj.incrementCounter());
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();
    }
} …

我有以下几种情况:我在这里展示的是简单的代码形式,以澄清我的担忧:

public void callMe()
{
 AtomicInteger howManyOdds = new AtomicInteger(0);
 AtomicInteger howManyEvens = new AtomicInteger(0);
 loopThrough(100,howManyOdds,howManyEvens);
 System.out.println(howManyOdds.get()+" "+howManyEvens.get());
}
private void loopThrough(int counter,AtomicInteger howManyOdds,AtomicInteger howManyEvens)
{
 for(int i = 1 ; i <= counter ;i++)
 {
  if(i%2 == 0)
  howManyEvens.getAndAdd(1);
  else
  howManyOdds.getAndAdd(1);
 }
}

我知道它可以通过int[]但它看起来有点奇怪.在这种情况下,AtomicInteger是Mutable Integer的良好替代品吗？如果不是那么为什么？

是否可以安全地假设之前的代码(AtomicInteger a).addAndGet(-1)将始终在此调用之前执行,即JVM 不会对addAndGet调用周围的指令重新排序？

如果是,是否可以安全地假设检查同一AtomicInteger实例状态的其他线程(例如if (a.compareAndSet(0, -1)))将在addAndGet调用之前看到第一个线程已更改的所有内容？

我有一个大小为10的原子整数数组.我使用这个数组来组织由线程发送的数字1-10.此1-10最终将能够更改为大于10的数字范围,列表将包含该范围内的10个最大数字.我可以看到数字进入循环并认识到它们大于当前的数字.但是,打印出来时,数组中的数字不会超过2个.我试图在调试模式下跟踪我的代码,但是,它看起来好像是按照预期的那样工作.我觉得我的逻辑可能有一个简单的错误？我完全确定所有的值都进入了函数,因为我已经三次检查了这个.我从数组的末尾开始,它应包含最高值,然后在确定插槽后向下交换.我很感激你的帮助.这只是我正在做的一个简单的实验,以便在我尝试解决家庭作业之前掌握基础知识.

这是我的代码示例:

 public class testing{

            static AtomicIntegerArray maxList = new AtomicIntegerArray(10); 
            final static int n = 10;

    static void setMax(int value)
            {

            for(int i = 9; i >= 0; i--)
            {       
                if(value > maxList.get(i))
                { 
                    int temp = maxList.get(i);

                maxList.set(i,value);

                if(i == 0)
                {
                    maxList.set(i, value);
                }

                else
                {   for(int j = i-1; j > 0; j--)
                    {
                        maxList.set(j, temp);
                        temp = maxList.get(j-1);
                    }
                }
                break;
            }
        }


    public static void main(String[] args)
    {
        for (int i = 0; i …

我正在编写一个程序，它计算数组中 0 到 100 万（不包括）之间整数的平方。我最多使用 8 个线程（包括）。
为了索引数组，我使用了一个原子整数。
我希望无论线程数如何，run 方法中的 for 循环体都会执行一百万次。
为了计算它被执行的次数，我使用了另一个原子整数。

   static AtomicInteger cnt = new AtomicInteger(0);
    static AtomicInteger ii = new AtomicInteger(0);
    static long[] arr = new long[1_000_000];

    public static class Worker extends Thread {

        public static void main(String[] args) throws IOException, InterruptedException {
            int maxThreads = Runtime.getRuntime().availableProcessors() * 2;
            for (int n = 1; n <= maxThreads; n++) {
                int numThreads = n;
                Thread[] threads = new Thread[numThreads];
                ii = new AtomicInteger(0);
                for (int i = …

能否请您帮助我掌握 AtomicInteger 类的一些方法的要点：updateAndGet, accumulateAndGet.

为什么第一个接收IntUnaryOperator作为参数？在这个接口的功能方法中可以应用什么逻辑？我的想法是，获得普通int价值会更容易。（与IntBinaryOperator界面相同）。

提前致谢。

我从原子学教程中获取了这段代码,它说:

"通过使用AtomicInteger作为Integer的替代,我们能够在线程安全的庄园中同时增加数量,而无需同步对变量的访问.方法incrementAndGet()是一个原子操作,所以我们可以安全地从多个调用此方法线程".

它说这将返回正确的结果,但是实例都没有达到1000,它们通常相当少,例如

test1 result = 532
test2 result = 128

怎么了 ？

public class AtomicsTest {

    public static void main(String... args){

        AtomicsTest test = new AtomicsTest();        
        test.test1();        
        test.test2();                             
    }

    public void test1() {
        AtomicInteger atomicInt = new AtomicInteger(0);

        ExecutorService executor = Executors.newSingleThreadExecutor();                
        IntStream.range(0,1000).forEach(i->executor.submit( atomicInt::incrementAndGet ));
        System.out.println("test1 result = "+ atomicInt.get());
        executor.shutdown();
    }

    public void test2() {

        AtomicInteger atomicInt = new AtomicInteger(0);

        ExecutorService executor = Executors.newFixedThreadPool(2);            
        IntStream.range(0,1000).forEach(i->executor.submit( atomicInt::incrementAndGet ));
        System.out.println("test2 result = " + atomicInt.get());        
        executor.shutdown();           
    }    
}

我正在阅读一些有关Java中原子变量的文档。随处可见，AtomicInteger应该是线程安全的。

根据我对原子整数的理解，它基于比较和交换算法的原理。当两个线程试图在同一时间递增同一原子变量时，我无法理解它将如何工作。

说我已经定义了AtomicInteger var = 1，这被两个线程Thread_1和Thread_2。什么时候会发生两个线程将尝试递增var的同时T1。我知道这种情况很少见，但是如果发生的话该怎么办。在比较和交换中，它通过单个原子操作读取和更新变量，并从内存中检查值。因此，如果在什么时间T1-1，VAR的值为5，并都Thread1和Thread2将开始增加呢？哪一个会失败？会是随机行为吗？或我缺少一些非常基本的东西。