Java 멀티쓰레드 프로그래밍 락-프리 알고리즘과 원자적 연산의 고급 활용

 

락-프리 알고리즘과 원자적 연산은 고성능 멀티쓰레드 애플리케이션 개발의 핵심인데요.

이 글에서는 관련 예제를 통해 이러한 기술의 고급 활용 방법을 탐구하고 더 나은 프로그램을 짤 수 있도록 다뤄보겠습니다.

1. 락-프리 스택 구현

AtomicReference를 사용한 락-프리 스택 구현 예제

public class LockFreeStack {
    private AtomicReference<Node> top = new AtomicReference<>(null);

    private static class Node {
        T item;
        Node next;

        Node(T item) {
            this.item = item;
        }
    }

    public void push(T item) {
        Node newHead = new Node<>(item);
        while (true) {
            Node oldHead = top.get();
            newHead.next = oldHead;
            if (top.compareAndSet(oldHead, newHead)) {
                return;
            }
        }
    }

    public T pop() {
        while (true) {
            Node oldHead = top.get();
            if (oldHead == null) {
                return null;
            }
            Node newHead = oldHead.next;
            if (top.compareAndSet(oldHead, newHead)) {
                return oldHead.item;
            }
        }
    }
}
        

 

 

2. 사용자 정의 AtomicLong 구현

 

Unsafe 클래스를 사용한 커스텀 AtomicLong 구현으로 성능을 최적화

public class CustomAtomicLong {
    private static final Unsafe unsafe;
    private static final long valueOffset;
    private volatile long value;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            unsafe = (Unsafe) f.get(null);
            valueOffset = unsafe.objectFieldOffset
                (CustomAtomicLong.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    public CustomAtomicLong(long initialValue) {
        value = initialValue;
    }

    public final boolean compareAndSet(long expect, long update) {
        return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
    }

    public final long getAndIncrement() {
        while (true) {
            long current = get();
            long next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

    public final long get() {
        return value;
    }
}
        

 

 

3. 락-프리 큐 최적화

 

CAS(Compare-And-Swap) 연산을 활용한 효율적인 락-프리 큐 구현.

public class OptimizedLockFreeQueue {
    private static class Node {
        volatile T item;
        volatile Node next;

        Node(T item) {
            this.item = item;
        }
    }

    private AtomicReference<Node> head, tail;

    public OptimizedLockFreeQueue() {
        Node dummy = new Node<>(null);
        head = new AtomicReference<>(dummy);
        tail = new AtomicReference<>(dummy);
    }

    public void enqueue(T item) {
        Node newNode = new Node<>(item);
        while (true) {
            Node curTail = tail.get();
            Node tailNext = curTail.next;
            if (curTail == tail.get()) {
                if (tailNext != null) {
                    tail.compareAndSet(curTail, tailNext);
                } else {
                    if (curTail.compareAndSet(null, newNode)) {
                        tail.compareAndSet(curTail, newNode);
                        return;
                    }
                }
            }
        }
    }

    public T dequeue() {
        while (true) {
            Node curHead = head.get();
            Node curTail = tail.get();
            Node headNext = curHead.next;
            if (curHead == head.get()) {
                if (curHead == curTail) {
                    if (headNext == null) {
                        return null;
                    }
                    tail.compareAndSet(curTail, headNext);
                } else {
                    T item = headNext.item;
                    if (head.compareAndSet(curHead, headNext)) {
                        return item;
                    }
                }
            }
        }
    }
}
        

 

 

 

 

락-프리 알고리즘과 원자적 연산의 고급 활용은 고성능 멀티쓰레드 애플리케이션 개발에 필수적입니다. 이러한 기법들을 마스터하면 동시성 문제를 효과적으로 해결하고 애플리케이션의 확장성을 크게 향상시킬 수 있습니다.

락-프리 프로그래밍은 복잡하지만 퍼포먼스 면에서 매우 강력한 기술이니 지속적인 학습과 실험을 통해 이 기술을 완벽히 익혀 고급 개발자로 나가면 좋을 듯합니다.