Question

AtomicInteger和Integer之间是否有性能差异？

Answer 1

这两种类型的选择不应取决于性能。 AtomicInteger的主要选择是，如果要通过对整数的操作来实现线程安全性。

然而，性能差异可能在很大程度上取决于选择的操作系统，因为原子操作的详细实现取决于操作系统。

Answer 2

好吧，如果你在多线程环境中使用它，例如，计数器，那么你必须synchronize访问整数

public final class Counter {
  private long value = 0;
  public synchronized long getValue() {
    return value;
  }

  public synchronized long increment() {
    return ++value;
  }
}

虽然没有同步就可以使用AtomicInteger获得更好的性能

public class NonblockingCounter {
    private AtomicInteger value;

    public int getValue() {
        return value.get();
    }

    public int increment() {
        return value.incrementAndGet();
    }
}

推荐阅读http://cephas.net/blog/2006/09/06/atomicinteger/

编辑使用incrementAndGet

Answer 3

AtomicInteger允许一些（并非所有！）操作，否则需要使用特殊硬件指令以无锁方式执行同步。这对性能的影响有点复杂：

首先，它只是一个微优化，只有当这个特定的操作在你的应用程序的关键路径上时才会有用。
特殊硬件指令可能无法在非主流平台上使用，在这种情况下AtomicInteger可能会使用同步实现。
当没有争用时，JVM通常可以优化掉锁定开销（例如，单线程应用程序）。在那种情况下，可能没什么区别。
如果存在低到中等的锁争用（即多个线程，但它们主要做除了访问该整数之外的其他事情），则无锁算法的性能优于同步。
如果存在非常严重的锁争用（即大量线程花费大量时间尝试访问该整数），则同步可能会表现得更好，因为无锁算法基于在失败时不断重试操作碰撞。

Answer 4

除了非常小的同步开销之外，没有。

Answer 5

今天遇到了这个帖子，但想分享我的结果（请不要对代码发表评论，因为我必须手动输入以下类，因为我运行的系统没有连接到互联网：）

下面的代码输出如下：

原子结果：Elapsed = 25257 ms，ExpectedValue = 50000，FinalValue = 50000，true 优点结果：Elapsed = 25257 ms，ExpectedValue = 50000，FinalValue = 48991，false

对于我在特定应用程序中的使用，我选择在监控类中使用Atomic值作为状态编号。如果其他人想要查看一些硬性结果，我选择发布此信息。

祝你有美好的一天！

类：

我创建了一个带有原始long和原子长度和访问器增量方法的主类，一个IncrementAtomicRunnable和一个IncrementPrimitiveRunnable。

LongOverhead：

public class LongOverhead{
  AtomicLong atomicLong;
  long primitiveLong;

  public LongOverhead(){
    atomicLong = new AtomicLong(0l);
    primitiveLong = 0l;
  }

  public void incrAtomicLong(){
    atomicLong.getAndAdd(1l);
  }

  public long getAtomicLong(){
    return atomicLong.get();
  }

  public void incrPrimitiveLong(){
    primitiveLong++;
  }

  public long getPrimitiveLong(){
    return primitiveLong;
  }

  public static void main(String [] args){
    String template = "%s Results:  Elapsed = %d ms, ExpectedValue = %d, FinalValue = %d, %b";

    int loopTotal = 1000;
    int waitMilliseconds = 25;
    int totalThreads = 50;
    int expectedValue = loopTotal * totalThreads;
    int whileSleep = 250;

    LongOverhead atomic = new LongOverhead();
    LongOverhead primitive = new LongOverhead();

    List<Thread> atomicThreads = new ArrayList<>();
    List<Thread> primitiveThreads = new ArrayList<>();

    for(int x=0;x<totalThreads;x++){
      Thread a = new Thread(new IncrementalAtomicRunnable(atomic, loopTotal, waitMilliseconds), "AtomicIncr" + x);
      atomicThreads.add(a);

      Thread p = new Thread(new IncrementalPrimitiveRunnable(primitive, loopTotal, waitMilliseconds), "PrimitiveIncr" + x);
      primitiveThreads.add(p);
    }

    boolean cont = true;
    long atomicStart = System.currentTimeMillis();
    for(Thread t:  atomicThreads){
      t.start();
    }

    while(cont){
      try{
        Thread.sleep(whileSleep);
      }catch(InterruptedException e){
         e.printStackTrace();
      }

      boolean foundAlive = false;
      for(Thread t: atomicThreads){
        foundAlive = (State.TERMINATED != t.getState());
        if(foundAlive){
          break;
        }
      }

      cont = foundAlive;

    }

    long atomicFinish = System.currentTimeMillis();
    long atomicElapsed = atomicFinish - atomicStart;
    long atomicFinal = atomic.getAtomicLong();

    cont = true;
    long primitiveStart = System.currentTimeMillis();
    for(Thread t:  primitiveThreads){
      t.start();
    }

    while(cont){
      try{
        Thread.sleep(whileSleep);
      }catch(InterruptedException e){
         e.printStackTrace();
      }

      boolean foundAlive = false;
      for(Thread t: primitiveThreads){
        foundAlive = (State.TERMINATED != t.getState());
        if(foundAlive){
          break;
        }
       }

       cont = foundAlive;
    long primitiveFinish = System.currentTimeMillis();
    long primitiveElapsed = primitiveFinish - primitiveStart;
    long primitiveFinal = primitive.getPrimitiveLong();

    System.out.println(String.format(template, "ATOMIC", atomicElapsed, expectedValue, atomicFinal, (expectedValue==atomicFinal)));
    System.out.println(String.format(template, "PrImItIvE", primitiveElapsed, expectedValue, primitiveFinal, (expectedValue==primitiveFinal)));
  }

IncrementAtomicRunnable：

public class IncrementAtomicRunnable implements Runnable{
  protected LongOverhead oh;
  protected int loopTotal;
  protected int waitMilliseconds;
  protected String currentThreadName;

  public IncrementAtomicRunnable(LongOverhead oh, int loopTotal, int waitMilliseconds){
    this.oh = oh;
    this.loopTotal = loopTotal;
    this.waitMilliseconds = waitMilliseconds;
  }

  @Override
  public void run(){
    currentThreadName = Thread.currentThread().getName();
    System.out.println(currentThreadName + " for ATOMIC is starting.....");
    for(int x=0;x<loopTotal;x++){
      oh.incrAtomicLong();
      try{
        Thread.sleep(waitMilliseconds);
      }catch(InterruptedException e){
        System.out.println("InterruptedThread[" + currentThreadName + "], eating exception @@@@@");
      }
    }

    System.out.println("....." + currentThreadName + " for ATOMIC is finished.");
  }
}

最后 IncrementPrimitiveRunnable：

public class IncrementPrimitiveRunnable extends IncrementAtomicRunnable{
  public IncrmentPrimitiveRunnable(LongOverhead oh, int loopTotal, int waitMilliseconds){
    super(oh, loopTotal, waitMilliseconds);
  }

  @Override
  public void run(){
    super.currentThreadName = Thread.currentThread().getName();
    System.out.println(currentThreadName + " for PRIMITIVE is starting.....");
    for(int x=0;x<loopTotal;x++){
      oh.incrPrimitiveLong();
      try{
        Thread.sleep(waitMilliseconds);
      }catch(InterruptedException e){
        System.out.println("InterruptedThread[" + currentThreadName + "], eating exception @@@@@");
      }
    }

    System.out.println("....." + currentThreadName + " for PRIMITIVE is finished.");
  }
}

AtomicInteger与Integer的性能差异

5 个答案: