Java 다중 스레드 프로그래밍에서 LockSupport 클래스의 스레드 차단 사용에 대한 자세한 설명

LockSupport는 잠금 및 기타 동기화 클래스를 생성하는 데 사용되는 기본 스레드 차단 기본 요소입니다.
LockSupport의 park() 및 unpark() 기능은 각각 스레드를 차단하고 스레드 차단을 해제하는 것이며, park() 및 unpark()에서는 "Thread.suspens 및 Thread.resume"으로 인해 발생할 수 있는 교착 상태가 발생하지 않습니다. "질문.
park() 및 unpark()에는 권한이 있으므로 park()를 호출하는 스레드와 unpark()를 시도하는 다른 스레드 간의 경쟁은 활성 상태로 유지됩니다.

기본 사용법
LockSupport는 바이너리 세마포어와 매우 유사합니다(라이센스가 1개만 사용 가능). 라이센스가 사용되지 않은 경우 현재 스레드가 라이센스를 획득하고 라이센스가 있으면 계속 실행됩니다. 점유된 경우 현재 스레드가 차단되어 권한을 얻기를 기다리고 있습니다.

public static void main(String[] args)
{
   LockSupport.park();
   System.out.println("block.");
}

이 코드를 실행하면 메인 스레드가 항상 차단되어 있는 것을 확인할 수 있습니다. 라이센스는 기본적으로 점유되어 있기 때문에 park() 호출시 라이센스를 획득할 수 없어 차단 상태에 들어간다.

다음 코드: 먼저 권한을 해제한 후 권한을 얻으면 메인 스레드가 정상적으로 종료될 수 있습니다. LockSupport 권한 획득과 해제는 일반적으로 동일합니다. 여러 번 unpark하면 하나의 park만 사용해도 문제가 없습니다.

public static void main(String[] args)
{
   Thread thread = Thread.currentThread();
   LockSupport.unpark(thread);//释放许可
   LockSupport.park();// 获取许可
   System.out.println("b");
}

LockSupport는 재진입이 불가능합니다. 스레드가 LockSupport .park()를 연속으로 두 번 호출하면 스레드는 확실히 차단된 상태로 유지됩니다.

public static void main(String[] args) throws Exception
{
 Thread thread = Thread.currentThread();

 LockSupport.unpark(thread);

 System.out.println("a");
 LockSupport.park();
 System.out.println("b");
 LockSupport.park();
 System.out.println("c");
}

이 코드는 a와 b를 인쇄하지만 c는 인쇄하지 않습니다. 왜냐하면 park가 두 번째 호출될 때 스레드는 권한을 얻을 수 없고 잠금.

인터럽트에 대한 LockSupport의 응답성을 살펴보겠습니다.

public static void t2() throws Exception
{
 Thread t = new Thread(new Runnable()
 {
  private int count = 0;

  @Override
  public void run()
  {
   long start = System.currentTimeMillis();
   long end = 0;

   while ((end - start) <= 1000)
   {
    count++;
    end = System.currentTimeMillis();
   }

   System.out.println("after 1 second.count=" + count);

  //等待或许许可
   LockSupport.park();
   System.out.println("thread over." + Thread.currentThread().isInterrupted());

  }
 });

 t.start();

 Thread.sleep(2000);

 // 中断线程
 t.interrupt();


 System.out.println("main over");
}

마지막 스레드는 thread over.true를 인쇄합니다. 이는 스레드가 park를 호출하여 차단된 경우 인터럽트 요청에 응답할 수 있지만(인터럽트 상태는 true로 설정됨) InterruptedException을 발생시키지 않음을 보여줍니다.

LockSupport 기능 목록

// 返回提供给最近一次尚未解除阻塞的 park 方法调用的 blocker 对象，如果该调用不受阻塞，则返回 null。
static Object getBlocker(Thread t)
// 为了线程调度，禁用当前线程，除非许可可用。
static void park()
// 为了线程调度，在许可可用之前禁用当前线程。
static void park(Object blocker)
// 为了线程调度禁用当前线程，最多等待指定的等待时间，除非许可可用。
static void parkNanos(long nanos)
// 为了线程调度，在许可可用前禁用当前线程，并最多等待指定的等待时间。
static void parkNanos(Object blocker, long nanos)
// 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
static void parkUntil(long deadline)
// 为了线程调度，在指定的时限前禁用当前线程，除非许可可用。
static void parkUntil(Object blocker, long deadline)
// 如果给定线程的许可尚不可用，则使其可用。
static void unpark(Thread thread)

LockSupport 예시
아래 "예제 1"과 "예제 2"를 비교하세요 LockSupport의 사용법을 더 명확하게 이해할 수 있습니다.
예시 1

public class WaitTest1 {

  public static void main(String[] args) {

    ThreadA ta = new ThreadA("ta");

    synchronized(ta) { // 通过synchronized(ta)获取“对象ta的同步锁”
      try {
        System.out.println(Thread.currentThread().getName()+" start ta");
        ta.start();

        System.out.println(Thread.currentThread().getName()+" block");
        // 主线程等待
        ta.wait();

        System.out.println(Thread.currentThread().getName()+" continue");
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  static class ThreadA extends Thread{

    public ThreadA(String name) {
      super(name);
    }

    public void run() {
      synchronized (this) { // 通过synchronized(this)获取“当前对象的同步锁”
        System.out.println(Thread.currentThread().getName()+" wakup others");
        notify();  // 唤醒“当前对象上的等待线程”
      }
    }
  }
}

예시 2

import java.util.concurrent.locks.LockSupport;

public class LockSupportTest1 {

  private static Thread mainThread;

  public static void main(String[] args) {

    ThreadA ta = new ThreadA("ta");
    // 获取主线程
    mainThread = Thread.currentThread();

    System.out.println(Thread.currentThread().getName()+" start ta");
    ta.start();

    System.out.println(Thread.currentThread().getName()+" block");
    // 主线程阻塞
    LockSupport.park(mainThread);

    System.out.println(Thread.currentThread().getName()+" continue");
  }

  static class ThreadA extends Thread{

    public ThreadA(String name) {
      super(name);
    }

    public void run() {
      System.out.println(Thread.currentThread().getName()+" wakup others");
      // 唤醒“主线程”
      LockSupport.unpark(mainThread);
    }
  }
}

실행 결과:

main start ta
main block
ta wakup others
main continue

설명: 공원과 대기의 차이. wait가 스레드를 차단하기 전에 동기화를 통해 동기화 잠금을 획득해야 합니다.

Java 멀티 스레드 프로그래밍에서 LockSupport 클래스의 스레드 차단 사용법에 대한 자세한 설명은 PHP 중국어 웹사이트를 참고하세요!