[Java Study] 13-4. 원자적 연산(CAS), 동시성 컬렉션

// 원자적 연산 i = 1 // 1. 1의 값을 i에 대입한다. // 원자적 연산이 아님 (순서가 나누어져있다.) i = i + 1; // 1. 오른쪽에 있는 1의 값을 읽는다. // 2. 읽은 값에 1을 더한다. // 3. 더한 값을 i에 대입한다.

처음에 i = 0이라고 가정하겠다. 스레드1: i = i + 1 연산 수행 스레드1: i의 값을 읽는다. i는 0이다. 스레드1: 읽은 0에 1을 더해서 1을 만든다. 스레드1: 더한 1을 왼쪽의 i변수에 대입한다. 결과: i의 값은 1이다. 스레드2: i = i + 1 연산 수행 스레드2: i의 값을 읽는다. i는 1이다. 스레드2: 읽은 1에 1을 더해서 2을 만든다. 스레드2: 더한 2을 왼쪽의 i변수에 대입한다. 결과: i의 값은 2이다.

처음에 i = 0이라고 가정하겠다. 스레드1: i = i + 1 연산 수행 스레드2: i = i + 1 연산 수행 스레드1: i의 값을 읽는다. i는 0이다. 스레드2: i의 값을 읽는다. i는 0이다. 스레드1: 읽은 0에 1을 더해서 1을 만든다. 스레드2: 읽은 0에 1을 더해서 1을 만든다. 스레드1: 더한 1을 왼쪽의 i변수에 대입한다. 스레드2: 더한 1을 왼쪽의 i변수에 대입한다. 결과: i의 값은 1이다.

public class IncrementPerformanceMain { public static final long COUNT = 100_000_000; public static void main(String[] args) { test(new BaseInteger()); // 실패 test(new VolatileInteger()); // 실패 test(new SyncInteger()); // 성공 test(new MyAtomicInteger()); // 성공 } private static void test(IncrementInteger incrementInteger) { long startMs = System.currentTimeMillis(); for (int i = 0; i < COUNT; i++) { incrementInteger.increment(); } long endMs = System.currentTimeMillis(); System.out.println(incrementInteger.getClass().getSimpleName() + ": ms=" + (endMs - startMs)); } }

public class BaseInteger implements IncrementInteger { // 기본 연산 private int value; @Override public void increment() { value++; } @Override public int get() { return value; } }

public class VolatileInteger implements IncrementInteger { private volatile int value; @Override public void increment() { value++; } @Override public int get() { return value; } }

public class SyncInteger implements IncrementInteger { private volatile int value; @Override public synchronized void increment() { value++; } @Override public synchronized int get() { return value; } }

public class MyAtomicInteger implements IncrementInteger { AtomicInteger atomicInteger = new AtomicInteger(0); @Override public void increment() { atomicInteger.incrementAndGet(); } @Override public int get() { return atomicInteger.get(); } }

public class CasMainV1 { public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(0); System.out.println("start value = " + atomicInteger.get()); // 0 => 1(CAS 연산) boolean result1 = atomicInteger.compareAndSet(0, 1); System.out.println("result1 = " + result1 + ", value = " + atomicInteger.get()); // 1 => 1(CAS 연산) boolean result2 = atomicInteger.compareAndSet(0, 1); System.out.println("result2 = " + result2 + ", value = " + atomicInteger.get()); } }

public class SpinLock { // CAS 연산을 통해 Lock 획득에 대해 동기화문제 해결 private final AtomicBoolean lock = new AtomicBoolean(false); public void lock() { log("락 획득 시도"); while (!lock.compareAndSet(false, true)) { // 락 획득할 때 까지 스핀 대기(바쁜 대기) 한다. log("락 획득 실패 - 스핀 대기"); } log("락 획득 완료"); } public void unlock() { lock.set(false); log("락 반납 완료"); } }

public class SynchronizedMain { public static void main(String[] args) { // 동기화 적용! // synchronized를 추가한 프록시 역할 List<String> list = Collections.synchronizedList(new ArrayList<>()); list.add("data1"); list.add("data2"); list.add("data3"); System.out.println(list.getClass()); System.out.println("list = " + list); } }

public class ListMain { public static void main(String[] args) { List<Integer> list = new CopyOnWriteArrayList<>(); list.add(1); list.add(2); list.add(3); System.out.println("list = " + list); Set<Integer> list = new CopyOnWriteArraySet<>(); list.add(1); list.add(2); list.add(3); System.out.println("list = " + list); // 순서 유지 Set<Integer> skipListSet = new ConcurrentSkipListSet<>(); skipListSet.add(3); skipListSet.add(2); skipListSet.add(1); System.out.println("skipListSet = " + skipListSet); } }