Java 멀티스레딩 - 잠금 및 샘플 코드에 대한 자세한 설명

Java 5부터 java.util.concurrent.locks 패키지에는 일부 잠금 구현이 포함되어 있으므로 자체 잠금을 구현할 필요가 없습니다. 하지만 여전히 이러한 잠금 장치를 사용하는 방법을 이해해야 합니다.

간단한 잠금

Java의 동기화 블록부터 시작하겠습니다.

public class Counter{
  private int count = 0;
 
  public int inc(){
    synchronized(this){
      return ++count;
    }
  }
}

inc()에 동기화(this)가 있는 것을 볼 수 있습니다. 메소드) 코드 블록. 이 코드 블록은 하나의 스레드만 동시에 return ++count를 실행할 수 있음을 보장합니다. 동기화된 동기화 블록의 코드는 더 복잡할 수 있지만 ++count와 같은 간단한 작업만으로도 스레드 동기화의 의미를 표현하기에 충분합니다.

다음 Counter 클래스는 동일한 목적을 달성하기 위해 동기화 대신 Lock을 사용합니다.

public class Counter{
  private Lock lock = new Lock();
  private int count = 0;
 
  public int inc(){
    lock.lock();
    int newCount = ++count;
    lock.unlock();
    return newCount;
  }
}

lock() 메서드는 Lock 인스턴스 객체를 잠그므로 lock()에 대한 모든 호출은 객체) 메소드 스레드는 Lock 객체의 Unlock() 메소드가 호출될 때까지 차단됩니다.

다음은 Lock 클래스의 간단한 구현입니다.

public class Counter{
public class Lock{
  private boolean isLocked = false;
 
  public synchronized void lock()
    throws InterruptedException{
    while(isLocked){
      wait();
    }
    isLocked = true;
  }
 
  public synchronized void unlock(){
    isLocked = false;
    notify();
  }
}

"스핀 잠금"이라고도 하는 while(isLocked) 루프에 주의하세요. isLocked가 true인 경우 lock()을 호출하는 스레드는 wait() 호출을 기다리는 것을 차단합니다. 스레드가 통지() 호출(거짓 깨우기라고도 함)을 수신하지 않고 wait()에서 반환되는 것을 방지하기 위해 스레드는 isLocked 조건을 다시 확인하여 실행을 계속하는 것이 안전한지 여부를 결정합니다. 다시 기다려야 하며, 스레드가 깨어난 후에도 안전하게 실행을 계속할 수 있다고 간주되지 않습니다. isLocked가 false인 경우 현재 스레드는 while(isLocked) 루프를 종료하고 isLocked를 다시 true로 설정하여 lock() 메서드를 호출하는 다른 스레드가 Lock 인스턴스를 잠글 수 있도록 합니다.

스레드가 중요 섹션(lock()과 Unlock() 사이)의 코드를 완료하면 Unlock()이 호출됩니다. Unlock()을 실행하면 isLocked가 false로 재설정되고 lock() 메서드에서 wait() 함수를 호출한 후 대기 상태에 있던 스레드 중 하나(있는 경우)에 알림(깨어나기)이 발생합니다.

잠금 재진입

Java의 동기화된 동기화 블록은 재진입이 가능합니다. 이는 Java 스레드가 코드의 동기화된 동기화 블록에 들어가서 동기화된 블록이 사용하는 동기화 개체에 해당하는 모니터에 대한 잠금을 획득한 경우 이 스레드가 동일한 모니터 개체에 의해 동기화된 다른 블록에 들어갈 수 있음을 의미합니다. 자바 코드. 예는 다음과 같습니다.

public class Reentrant{
  public synchronized outer(){
    inner();
  }
 
  public synchronized inner(){
    //do something
  }
}

outer()와 inner()는 모두 동기화로 선언되어 있으며 이는 Java의 동기화(this) 블록과 동일합니다. 스레드가 external()을 호출하는 경우 두 메서드(코드 블록)가 동일한 모니터 개체("this")에 의해 동기화되기 때문에 external() 내에서 inner()를 호출하는 데 문제가 없습니다. 스레드가 이미 모니터 개체에 대한 잠금을 소유한 경우 모니터 개체에 의해 동기화된 모든 코드 블록에 액세스할 수 있습니다. 이것이 재진입입니다. 스레드는 이미 소유한 잠금으로 동기화된 코드 블록에 들어갈 수 있습니다.

앞서 설명한 잠금 구현은 재진입이 불가능합니다. Reentrant 클래스를 다음과 같이 다시 작성하면 스레드가 external()을 호출할 때 inner() 메서드의 lock.lock()에서 차단됩니다.

public class Reentrant2{
  Lock lock = new Lock();
 
  public outer(){
    lock.lock();
    inner();
    lock.unlock();
  }
 
  public synchronized inner(){
    lock.lock();
    //do something
    lock.unlock();
  }
}

outer()를 호출하는 스레드는 먼저 Lock 인스턴스를 잠근 다음 계속해서 inner()를 호출합니다. inner() 메서드에서 스레드는 Lock 인스턴스를 다시 잠그려고 시도하지만 Lock 인스턴스가 external() 메서드에서 이미 잠겨 있기 때문에 작업이 실패합니다(즉, 스레드가 차단됩니다).

Unlock()은 두 lock() 시간 사이에 호출되지 않으며 lock에 대한 두 번째 호출은 차단됩니다. lock() 구현을 살펴보면 이유가 분명합니다.

public class Lock{
  boolean isLocked = false;
 
  public synchronized void lock()
    throws InterruptedException{
    while(isLocked){
      wait();
    }
    isLocked = true;
  }
 
  ...
}

스레드가 lock() 메서드를 종료할 수 있는지 여부는 while 루프(스핀 잠금)의 조건에 따라 결정됩니다. 현재 판단 조건은 어떤 스레드가 잠겼는지에 관계없이 isLocked가 false인 경우에만 잠금 작업이 허용된다는 것입니다.

이 Lock 클래스를 재진입 가능하게 만들려면 약간 변경해야 합니다.

public class Lock{
  boolean isLocked = false;
  Thread lockedBy = null;
  int lockedCount = 0;
 
  public synchronized void lock()
    throws InterruptedException{
    Thread callingThread =
      Thread.currentThread();
    while(isLocked && lockedBy != callingThread){
      wait();
    }
    isLocked = true;
    lockedCount++;
    lockedBy = callingThread;
 }
 
  public synchronized void unlock(){
    if(Thread.curentThread() ==
      this.lockedBy){
      lockedCount--;
 
      if(lockedCount == 0){
        isLocked = false;
        notify();
      }
    }
  }
 
  ...
}

현재 while 루프(스핀 잠금)도 고려됩니다. 이 Lock 인스턴스를 잠근 스레드입니다. 현재 잠금 객체가 잠겨 있지 않거나(isLocked = false) 현재 호출 스레드가 이미 Lock 인스턴스를 잠근 경우 while 루프는 실행되지 않으며 lock()을 호출하는 스레드는 메서드를 종료할 수 있습니다(번역 참고: 현재 의미론에서 "이 메서드를 종료할 수 있다는 것은 wait()가 호출되지 않고 차단이 발생함을 의미합니다."

또한 동일한 스레드가 잠금 개체를 반복적으로 잠그는 횟수를 기록해야 합니다. 그렇지 않으면 현재 잠금이 여러 번 잠겼더라도 단일 unblock() 호출로 전체 잠금이 잠금 해제됩니다. 우리는 Unlock() 호출이 해당 lock() 호출 수에 도달하기 전에 잠금이 해제되는 것을 원하지 않습니다.

이제 Lock 클래스가 재진입 가능합니다.

잠금 공정성

Java의 동기화 블록은 블록에 들어가려는 스레드의 순서를 보장하지 않습니다. 따라서 여러 스레드가 동일한 동기화된 블록에 대한 액세스를 위해 지속적으로 경쟁하는 경우 그중 하나 이상이 액세스 권한을 얻지 못할 위험이 있습니다. 즉, 액세스 권한은 항상 다른 스레드에 할당됩니다. 이러한 상황을 스레드 기아라고 합니다. 이 문제를 피하려면 잠금이 공정해야 합니다. 본 글에서 제시하는 잠금은 동기화된 블록을 이용하여 내부적으로 구현된 것이므로 공정성을 보장하지 않습니다.

在 finally 语句中调用 unlock()

如果用 Lock 来保护临界区，并且临界区有可能会抛出异常，那么在 finally 语句中调用 unlock()就显得非常重要了。这样可以保证这个锁对象可以被解锁以便其它线程能继续对其加锁。以下是一个示例：

lock.lock();
try{
  //do critical section code,
  //which may throw exception
} finally {
  lock.unlock();
}

这个简单的结构可以保证当临界区抛出异常时 Lock 对象可以被解锁。如果不是在 finally 语句中调用的 unlock()，当临界区抛出异常时，Lock 对象将永远停留在被锁住的状态，这会导致其它所有在该 Lock 对象上调用 lock()的线程一直阻塞。

以上就是关于 java 多线程锁的资料整理，后续继续补充相关资料，谢谢大家对本站的支持！

更多java 多线程-锁详解及示例代码相关文章请关注PHP中文网！