Java - 比较和交换和同步块

Question

public class SimulatedCAS { 
  private int value;

  public synchronized int get() { return value; }

  public synchronized int compareAndSwap(int expectedValue, int newValue) 
  {
  int oldValue = value; 
  if (oldValue == expectedValue) 
      value = newValue;
  return oldValue; 
  }
}

public class CasCounter 
{ 
   private SimulatedCAS value;

   public int getValue() 
   { 
     return value.get();
   }
  
  public int increment() 
  { 
      int value.get(); 
      while (v != value.compareAndSwap(v, v + 1)) 
      {
         v = value.get(); 
      }
  }

}

I refereed a Book "Java Concurrency in Practice"

a Counter must be increased by multiple threads. I tried using the compare and swap method but at the end it make used of synchronized keyword which might again result in blocking and waiting of threads. using a synchronized block provides me the same performance can anybody state. what is the difference between using compare and swap and synchronized block? or any other way to implement compare and swap without using synchronized block.

Answer 1

Real Compare and Swap does optimistic locking. It changes value and then makes a rollback if something has changed the variable simultaneously. So, if the variable is modified rarely, then CAS performs better, than synchronized.

But if the variable is modified often, then synchronized performs better, because it doesn't allow anything to mess with the variable while it is changed. And so there's no need to make an expensive rollback.

Answer 2

I need to increment counter with multiple threads

The AtomicInteger class is good for that.

You can create it with final AtomicInteger i=new AtomicInteger(initial_value);Then you can call i.set(new_value) to set its value, and you can call i.get() to get its value, and most importantly for your application, you can call i.incrementAndGet() to atomically increment the value.

If N different threads all call i.incrementAndGet() at "the same time," then

• Each thread is guaranteed to see a different return value, and
• The final value after they're all done is guaranteed to increase by exactly N.

The AtomicInteger class has quite a few other methods as well. Most of them make useful guarantees about what happens when multiple threads access the varaible.