자바 다 중 스 레 드 - lock 인터페이스 (다 중 스 레 드 공유 자원 잠 금)

자바 는 코드 블록 을 동기 화 하 는 다른 메커니즘 을 제공 합 니 다.synchronized 키워드 보다 더 강력 하고 유연 합 니 다.Lockers 는 다 중 스 레 드 프로 그래 밍 에서 중요 한 개념 은 잠 금 입 니 다. 만약 에 하나의 자원 이 여러 스 레 드 로 공유 된다 면 데이터 의 완전 성 을 확보 하기 위해 사무 적 인 작업 을 할 때 공유 자원 을 잠 가 야 합 니 다. 그러면 사무 적 인 작업 을 할 때 하나의 스 레 드 만 자원 을 조작 할 수 있 습 니 다.이것 은 Lock 인터페이스 와 이 를 실현 하 는 클래스 (예 를 들 어 ReentrantLock) 를 기반 으로 합 니 다.참고:http://www.jb51.net/article/45761.htm
Lock 의 장점:

synchronized 블록 을 보다 유연 한 방식 으로 구축 할 수 있 습 니 다.synchronized 키 워드 를 사용 하려 면 synchronized 코드 블록 을 구조 화 하 는 제어 권 을 가 져 야 합 니 다.Lock 인 터 페 이 스 는 임계 구역 을 실현 하기 위해 더 복잡 한 구 조 를 얻 을 수 있 습 니 다.

Lock 인 터 페 이 스 는 synchronized 키워드 보다 더 많은 추가 기능 을 제공 합 니 다.새로운 기능 중 하 나 는 실 현 된 tryLock () 방법 이다.이 방법 은 자물쇠 의 제어 권 을 가 져 오 려 고 시도 하고 이 자 물 쇠 를 가 져 올 수 없다 면 다른 스 레 드 가 이 자 물 쇠 를 사용 하고 있 기 때문에 이 자 물 쇠 를 되 돌려 줍 니 다.synchronized 키 워드 를 사용 합 니 다. 스 레 드 A 가 synchronized 코드 블록 을 실행 하려 고 할 때 스 레 드 B 가 실행 중인 경우 스 레 드 A 는 스 레 드 B 가 synchronized 코드 블록 을 실행 할 때 까지 차단 합 니 다.자 물 쇠 를 사용 하면 try Lock () 방법 을 실행 할 수 있 습 니 다. 이 방법 은 Boolean 값 을 되 돌려 줍 니 다. 다른 스 레 드 가 이 자물쇠 가 보호 하 는 코드 를 실행 하고 있 는 지 여부 입 니 다.

여러 독자 와 한 명의 작성 자가 있 을 때 Lock 인 터 페 이 스 는 읽 기와 쓰기 조작 을 분리 할 수 있다.Lock 인 터 페 이 스 는 synchronized 키워드 보다 더 좋 은 성능 을 제공 합 니 다.

예 를 하나 보다.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Lockers                   ，              ，          ，
 *                   ，                            ，
 *           。
 */
public class Lockers {
    public static void main(String[] args) throws Exception {
        Lockers.testLockTest();
    }

    public static void testLockTest() throws Exception {
        final LockTest lockTest = new LockTest();
        //     1，  lockTest addValue  (  )
        Runnable task1 = new Runnable() {
            public void run() {
                lockTest.addValue(55.55);
            }
        };
        //     2，  lockTest getValue  (  )
        Runnable task2 = new Runnable() {
            public void run() {
                System.out.println("value: " + lockTest.getValue());
            }
        };

        //         
        ExecutorService cachedService = Executors.newCachedThreadPool();
        Future future = null;
        //       1  ，  addValue        ，  ，        
        for (int i = 0; i < 3; i++) {
            future = cachedService.submit(task1);
        }
        //         1    
        future.get();
        //      2，    
        future = cachedService.submit(task2);
        //     2    ，        
        future.get();
        cachedService.shutdownNow();
    }

    /**
     *   Lock   。      Lock，      Synchronized   。
     */
    public static class LockTest {
        Lock lock = new ReentrantLock();    //  
        double value = 0d;                  //  
        int addtimes = 0;

        /**
         *   value  ，        2 ，      ，          
         *          ，              Synchronized   。
         */
        public void addValue(double v) {
            lock.lock();//    
            System.out.println("    (   ),   ...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            this.value += v;
            this.addtimes++;

            System.out.println("    (   )！");
            lock.unlock();//    
        }

        public double getValue() {
            return this.value;
        }
    }

}

실행 결과:

    (   ),   ...
    (   )！
    (   ),   ...
    (   )！
    (   ),   ...
    (   )！
value: 166.64999999999998