이 이중 확인 잠금 장치가 손상되지 않았습니까?

Question

이 article은 잠금 경합을 줄이는 아이디어 인 "Double-Checked Locking"에 대해 설명합니다. 기사에서 설명하는대로 작동하지 않습니다. "(여전히) 깨진 다중 스레드 버전"이중 확인 잠금 "관용구"표의 코드 샘플을 참조하십시오.

이제는 작동해야하는 변형을 발견했다고 생각합니다. 문제는 그것이 올바른지 여부입니다. 공유 대기열을 통해 데이터를 교환하는 소비자와 생산자가 있다고 가정 해 보겠습니다.

class Producer { 
    private Queue queue = ...; 
    private AtomicInteger updateCount; 

    public void add(Data data) { 
     synchronized(updateCount) { 
      queue.add(task); 
      updateCount.incrementAndGet(); 
     } 
    } 
} 

class Consumer { 
    private AtomicInteger updateCount = new AtomicInteger(0); 
    private int updateCountSnapshot = updateCount.get(); 

    public void run() { 
     while(true) { 
      // do something 
      if(updateCountSnapshot != updateCount.get()) { 
       // synchronizing on the same updateCount 
       // instance the Producer has 
       synchronized(updateCount) { 
        Data data = queue.poll() 
        // mess with data 
        updateCountSnapshot = updateCount.get(); 
       } 
      } 
     } 
    } 
} 

질문은이 접근 방식이 효과가 있다고 생각하는지 여부입니다. 나는 많은 사람들이 깨지기 때문에 깨지기 때문에 확신하고 싶습니다 ... 그 생각은 updateCount가 변경되면 소비자에게 동기화 된 블록을 입력 할 때 잠금 경합을 줄이는 것입니다.

Answer 1

Code Review에 대해 더 알고 싶습니다.

는 다음과 같은 사항을 고려해야합니다

는

• 이되지 재확인 잠금입니다.
• 데이터가 도착하지 않으면 소비자가 아무 것도하지 않고 CPU를 먹을 것입니다.
• AtomicInteger를 세마포로 사용합니다.
• BlockingQueue가이 모든 작업을 수행합니다.
• updateCount이 공유되었는지 제대로 확인하지 않았습니다.
• 원자 단위로 동기화 할 필요는 없습니다.

다음은 간단한 데모 용 프로듀서/소비자 쌍입니다.

public class TwoThreads { 

    public static void main(String args[]) throws InterruptedException { 
     System.out.println("TwoThreads:Test"); 
     new TwoThreads().test(); 
    } 

    // The end of the list. 
    private static final Integer End = -1; 

    static class Producer implements Runnable { 

     final Queue<Integer> queue; 

     public Producer(Queue<Integer> queue) { 
      this.queue = queue; 
     } 

     @Override 
     public void run() { 
      try { 
       for (int i = 0; i < 1000; i++) { 
        queue.add(i); 
        Thread.sleep(1); 
       } 
       // Finish the queue. 
       queue.add(End); 
      } catch (InterruptedException ex) { 
       // Just exit. 
      } 
     } 

    } 

    static class Consumer implements Runnable { 

     final Queue<Integer> queue; 

     public Consumer(Queue<Integer> queue) { 
      this.queue = queue; 
     } 

     @Override 
     public void run() { 
      boolean ended = false; 
      while (!ended) { 
       Integer i = queue.poll(); 
       if (i != null) { 
        ended = i == End; 
        System.out.println(i); 
       } 
      } 
     } 

    } 

    public void test() throws InterruptedException { 
     Queue<Integer> queue = new LinkedBlockingQueue<>(); 
     Thread pt = new Thread(new Producer(queue)); 
     Thread ct = new Thread(new Consumer(queue)); 
     // Start it all going. 
     pt.start(); 
     ct.start(); 
     // Wait for it to finish. 
     pt.join(); 
     ct.join(); 
    } 

}