많이 말하지 않겠습니다. 이미 존경받는 동료 친구들이 귀중한 의견을 제시했습니다. 이 블로그 마지막에 본격적인 실행 코드가 있으면 혼동을 제거해야합니다. 멀티 스레드 시나리오에서 영화 좌석 예약 소규모 프로그램에 관한 것입니다.

몇 가지 중요한 기본 사실은 다음과 같습니다. 1> 다른 스레드는 힙 공간에서 예를 들어 정적 멤버 변수에만 경합 할 수 있습니다. 2> 휘발성 읽기 또는 쓰기는 완전히 원자화되고 직렬화 / 합판되어 메모리에서만 수행됩니다. 이것을 말하는 것은 모든 읽기가 메모리의 이전 쓰기를 따른다는 것을 의미합니다. 모든 쓰기는 메모리에서 이전 읽기를 따릅니다. 따라서 휘발성으로 작업하는 스레드는 항상 최신 값을 볼 수 있습니다.
AtomicReference는이 휘발성 속성을 사용합니다.

다음은 AtomicReference의 소스 코드 중 일부입니다. AtomicReference는 객체 참조를 나타냅니다. 이 참조는 다음과 같이 AtomicReference 인스턴스의 휘발성 멤버 변수입니다.

private volatile V value;

get ()은 단순히 변수의 최신 값을 반환합니다 (휘발성은 “이전에 발생”).

public final V get()

다음은 AtomicReference의 가장 중요한 방법입니다.

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

compareAndSet (expect, update) 메소드는 안전하지 않은 Java 클래스의 compareAndSwapObject () 메소드를 호출합니다. 안전하지 않은이 메소드 호출은 기본 호출을 호출하여 프로세서에 대한 단일 명령을 호출합니다. “예상”및 “업데이트”는 각각 개체를 참조합니다.

AtomicReference 인스턴스 멤버 변수 “value”가 동일한 오브젝트를 “expect”로 참조하는 경우에만 “update”가이 인스턴스 변수에 지정되고 “true”가 리턴됩니다. 그렇지 않으면 false가 반환됩니다. 모든 것은 원자 적으로 이루어집니다. 다른 스레드는 사이를 가로 챌 수 없습니다. 이것은 단일 프로세서 작업 (현대 컴퓨터 아키텍처의 마술)이므로 동기화 된 블록을 사용하는 것보다 빠릅니다. 그러나 여러 변수를 원자 적으로 업데이트해야하는 경우 AtomicReference가 도움이되지 않습니다.

이클립스에서 실행할 수있는 본격적인 실행 코드를 추가하고 싶습니다. 많은 혼란이 사라질 것입니다. 여기 22 명의 사용자 (MyTh 스레드)가 20 개의 좌석을 예약하려고합니다. 다음은 코드 스 니펫과 전체 코드입니다.

22 명의 사용자가 20 개의 좌석을 예약하려고하는 코드 스 니펫.

for (int i = 0; i < 20; i++) {// 20 seats
            seats.add(new AtomicReference<Integer>());
        }
        Thread[] ths = new Thread[22];// 22 users
        for (int i = 0; i < ths.length; i++) {
            ths[i] = new MyTh(seats, i);
            ths[i].start();
        }

다음은 전체 실행 코드입니다.

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

public class Solution {

    static List<AtomicReference<Integer>> seats;// Movie seats numbered as per
                                                // list index

    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        seats = new ArrayList<>();
        for (int i = 0; i < 20; i++) {// 20 seats
            seats.add(new AtomicReference<Integer>());
        }
        Thread[] ths = new Thread[22];// 22 users
        for (int i = 0; i < ths.length; i++) {
            ths[i] = new MyTh(seats, i);
            ths[i].start();
        }
        for (Thread t : ths) {
            t.join();
        }
        for (AtomicReference<Integer> seat : seats) {
            System.out.print(" " + seat.get());
        }
    }

    /**
     * id is the id of the user
     *
     * @author sankbane
     *
     */
    static class MyTh extends Thread {// each thread is a user
        static AtomicInteger full = new AtomicInteger(0);
        List<AtomicReference<Integer>> l;//seats
        int id;//id of the users
        int seats;

        public MyTh(List<AtomicReference<Integer>> list, int userId) {
            l = list;
            this.id = userId;
            seats = list.size();
        }

        @Override
        public void run() {
            boolean reserved = false;
            try {
                while (!reserved && full.get() < seats) {
                    Thread.sleep(50);
                    int r = ThreadLocalRandom.current().nextInt(0, seats);// excludes
                                                                            // seats
                                                                            //
                    AtomicReference<Integer> el = l.get(r);
                    reserved = el.compareAndSet(null, id);// null means no user
                                                            // has reserved this
                                                            // seat
                    if (reserved)
                        full.getAndIncrement();
                }
                if (!reserved && full.get() == seats)
                    System.out.println("user " + id + " did not get a seat");
            } catch (InterruptedException ie) {
                // log it
            }
        }
    }

}    

답변

String initialReference = "value 1";

AtomicReference<String> someRef =
    new AtomicReference<String>(initialReference);

String newReference = "value 2";
boolean exchanged = someRef.compareAndSet(initialReference, newReference);
System.out.println("exchanged: " + exchanged);