Java를 사용하여 수동 스핀 잠금을 구현하는 방법

머리말

동시성 프로그램을 작성할 때 매우 일반적인 요구 사항은 특정 시간에 단 하나의 스레드만 특정 코드 섹션을 실행하도록 하는 것입니다. 이러한 종류의 코드를 임계 섹션이라고 하며 일반적으로 사용됩니다. 한 번에 하나의 스레드만 특정 코드 섹션을 실행하도록 보장됩니다. 스레드가 임계 섹션의 코드를 실행하는 방법은 잠금입니다. 이번 글에서는 스핀락(spin lock)이라 불리는 것이 while 루프를 통해 구현되는데, 이를 통해 락을 획득한 스레드가 임계구역에 들어가 코드를 실행할 수 있게 된다. while 루프에서 계속 죽기 위한 잠금을 획득하지 못한 경우 이는 실제로 while 루프의 스레드 "스핀"이므로 이러한 종류의 잠금을 스핀 잠금이라고 합니다.

스핀 잠금

원자성

스핀 잠금에 대해 이야기하기 전에 원자성에 대해 이야기해야 합니다. 소위 원자성은 단순히 각 작업이 완료되지 않았거나 완료되었음을 의미합니다. 예를 들어 변수 데이터에 1을 추가하는 것은 다음 세 단계로 이루어집니다.

• 데이터 로드. 메모리에서 레지스터로.

• 데이터의 가치에 하나를 더해보세요.

• 결과를 다시 메모리에 기록하세요.

원자성은 스레드가 추가 작업을 수행할 때 다른 스레드에 의해 중단될 수 없음을 의미합니다. 이 스레드가 이 세 가지 프로세스를 완료해야만 다른 스레드가 데이터를 작업할 수 있습니다.

이제 코드로 경험해 보겠습니다. Java에서는 AtomicInteger를 사용하여 정수 데이터에 대한 원자 연산을 수행할 수 있습니다.

import java.util.concurrent.atomic.AtomicInteger;
 
public class AtomicDemo {
 
  public static void main(String[] args) throws InterruptedException {
    AtomicInteger data = new AtomicInteger();
    data.set(0); // 将数据初始化位0
    Thread t1 = new Thread(() -> {
      for (int i = 0; i < 100000; i++) {
        data.addAndGet(1); // 对数据 data 进行原子加1操作
      }
    });
    Thread t2 = new Thread(() -> {
      for (int i = 0; i < 100000; i++) {
        data.addAndGet(1);// 对数据 data 进行原子加1操作
      }
    });
    // 启动两个线程
    t1.start();
    t2.start();
    // 等待两个线程执行完成
    t1.join();
    t2.join();
    // 打印最终的结果
    System.out.println(data); // 200000
  }
}

위의 코드 분석을 통해 일반 정수 변수인 경우 두 스레드가 작동하는 경우를 알 수 있습니다. 동시에 최종 결과는 200,000 미만이 됩니다.

이제 일반 정수 변수의 문제 프로세스를 시뮬레이션해 보겠습니다.

메인 메모리에 있는 데이터의 초기 값은 0이고 두 스레드에서 얻은 데이터의 초기 값은 0입니다.

이제 스레드 1은 데이터에 1을 추가하고 스레드 1은 데이터 값을 다시 주 메모리에 동기화합니다. 전체 메모리의 데이터 변경 사항은 다음과 같습니다.

이제 스레드 2는 데이터에 1을 추가합니다. 데이터를 동기화한 후 데이터 값을 동기화합니다. 주 메모리로 돌아갑니다(원래 주 메모리 값 덮어쓰기):

원래는 위 변경 후 데이터 값이 2가 되기를 바랐으나 스레드 2가 우리 값을 덮어썼습니다. , 따라서 멀티 스레드 상황에서 Down은 최종 결과를 더 작게 만듭니다.

하지만 위 프로그램에서 최종 출력 결과는 20000입니다. 이는 데이터에 대한 +1 연산이 원자적이고 분할 불가능하고 연산 중에 다른 스레드가 데이터에 대해 연산을 수행할 수 없기 때문입니다. 이것이 원자성이 가져오는 장점입니다.

자신만의 스핀 잠금 작성

AtomicInteger 클래스

이제 원자성의 역할을 이해했으므로 이제 AtomicInteger 클래스의 또 다른 원자 연산인 CompareAndSet에 대해 알아보겠습니다. 이 연산을 비교 및 ​​스왑(CAS)이라고 합니다. 그것은 원자적이다.

public static void main(String[] args) {
  AtomicInteger atomicInteger = new AtomicInteger();
  atomicInteger.set(0);
  atomicInteger.compareAndSet(0, 1);
}

compareAndSet 함수의 의미: 먼저 첫 번째 매개변수(위 코드에 해당하는 값은 0임)와omicInteger의 값이 같을 경우, 즉omicInteger의 값을 교환합니다. 두 번째 매개변수(위 코드에 해당)로 설정됩니다. 이 작업이 성공하면 CompareAndSet 함수는 true를 반환합니다. 첫 번째 매개변수(예상 값)가 atomicInteger와 동일하지 않은 경우에도 변경으로 인한 것일 수 있습니다(여러 스레드가 작동할 수 있고 원자성이 존재하기 때문에). 단 하나의 스레드만 성공적으로 작동할 수 있습니다.)

스핀 잠금 구현 원리

AtomicInteger 클래스를 사용하여 스핀 잠금을 구현할 수 있습니다. 값 0을 사용하면 잠겨 있지 않음을 나타내고 값 1을 사용하면 잠겨 있음을 나타낼 수 있습니다.

AtomicInteger 클래스의 초기 값은 0입니다.

잠금을 설정할 때, 우리는 그것을 구현하기 위해omicInteger.compareAndSet(0, 1) 코드를 사용할 수 있습니다. 앞에서 단 하나의 스레드만이 이 작업을 완료할 수 있다고 언급했습니다. 이는 단 하나의 스레드만이 이 코드 라인을 호출한 다음 반환할 수 있다는 것을 의미합니다. true를 반환하고 다른 스레드는 false를 반환합니다. false를 반환하는 이러한 스레드는 임계 섹션에 들어갈 수 없으므로 이 스레드는omicInteger.compareAndSet(0, 1)에서 중지해야 합니다. 잠시 동안을 사용할 수 있습니다. 스레드는 (!value.compareAndSet(0, 1)); 동안 여기서 계속 중지되며, true를 반환하는 스레드만 루프에서 벗어날 수 있으며 다른 스레드는 여기에서 계속 루프를 호출합니다. 이 동작은 스핀이므로 이 잠금을 스핀 잠금이라고도 합니다.

线程在出临界区的时候需要重新将锁的状态调整为未上锁的上状态，我们使用代码value.compareAndSet(1, 0);就可以实现，将锁的状态还原为未上锁的状态，这样其他的自旋的线程就可以拿到锁，然后进入临界区了。

自旋锁代码实现

import java.util.concurrent.atomic.AtomicInteger;
 
public class SpinLock {
    
  // 0 表示未上锁状态
  // 1 表示上锁状态
  protected AtomicInteger value;
 
  public SpinLock() {
    this.value = new AtomicInteger();
    // 设置 value 的初始值为0 表示未上锁的状态
    this.value.set(0);
  }
 
  public void lock() {
    // 进行自旋操作
    while (!value.compareAndSet(0, 1));
  }
 
  public void unlock() {
    // 将锁的状态设置为未上锁状态
    value.compareAndSet(1, 0);
  }
 
}

上面就是我们自己实现的自旋锁的代码，这看起来实在太简单了，但是它确实帮助我们实现了一个锁，而且能够在真实场景进行使用的，我们现在用代码对上面我们写的锁进行测试。

测试程序：

public class SpinLockTest {
 
  public static int data;
  public static SpinLock lock = new SpinLock();
 
  public static void add() {
    for (int i = 0; i < 100000; i++) {
      // 上锁 只能有一个线程执行 data++ 操作 其余线程都只能进行while循环
      lock.lock();
      data++;
      lock.unlock();
    }
  }
 
  public static void main(String[] args) throws InterruptedException {
    Thread[] threads = new Thread[100];
    // 设置100个线程
    for (int i = 0; i < 100; i ++) {
      threads[i] = new Thread(SpinLockTest::add);
    }
    // 启动一百个线程
    for (int i = 0; i < 100; i++) {
      threads[i].start();
    }
    // 等待这100个线程执行完成
    for (int i = 0; i < 100; i++) {
      threads[i].join();
    }
    System.out.println(data); // 10000000
  }
}

在上面的代码单中，我们使用100个线程，然后每个线程循环执行100000data++操作，上面的代码最后输出的结果是10000000，和我们期待的结果是相等的，这就说明我们实现的自旋锁是正确的。

自己动手写可重入自旋锁

可重入自旋锁

在上面实现的自旋锁当中已经可以满足一些我们的基本需求了，就是一个时刻只能够有一个线程执行临界区的代码。但是上面的的代码并不能够满足重入的需求，也就是说上面写的自旋锁并不是一个可重入的自旋锁，事实上在上面实现的自旋锁当中重入的话就会产生死锁。

我们通过一份代码来模拟上面重入产生死锁的情况：

public static void add(int state) throws InterruptedException {
  TimeUnit.SECONDS.sleep(1);
  if (state <= 3) {
    lock.lock();
    System.out.println(Thread.currentThread().getName() + "\t进入临界区 state = " + state);
    for (int i = 0; i < 10; i++)
      data++;
    add(state + 1); // 进行递归重入 重入之前锁状态已经是1了 因为这个线程进入了临界区
    lock.unlock();
  }
}

在上面的代码当中加入我们传入的参数state的值为1，那么在线程执行for循环之后再次递归调用add函数的话，那么state的值就变成了2。

if条件仍然满足，这个线程也需要重新获得锁，但是此时锁的状态是1，这个线程已经获得过一次锁了，但是自旋锁期待的锁的状态是0，因为只有这样他才能够再次获得锁，进入临界区，但是现在锁的状态是1，也就是说虽然这个线程获得过一次锁，但是它也会一直进行while循环而且永远都出不来了，这样就形成了死锁了。

可重入自旋锁思想

针对上面这种情况我们需要实现一个可重入的自旋锁，我们的思想大致如下：

• 在我们实现的自旋锁当中，我们可以增加两个变量，owner一个用于存当前拥有锁的线程，count一个记录当前线程进入锁的次数。

• 如果线程获得锁，owner = Thread.currentThread()并且count = 1。

• 当线程下次再想获取锁的时候，首先先看owner是不是指向自己，则一直进行循环操作，如果是则直接进行count++操作，然后就可以进入临界区了。

• 我们在出临界区的时候，如果count大于一的话，说明这个线程重入了这把锁，因此不能够直接将锁设置为0也就是未上锁的状态，这种情况直接进行count--操作，如果count等于1的话，说明线程当前的状态不是重入状态（可能是重入之后递归返回了），因此在出临界区之前需要将锁的状态设置为0，也就是没上锁的状态，好让其他线程能够获取锁。

可重入锁代码实现

实现的可重入锁代码如下：

public class ReentrantSpinLock extends SpinLock {
 
  private Thread owner;
  private int count;
 
  @Override
  public void lock() {
    if (owner == null || owner != Thread.currentThread()) {
      while (!value.compareAndSet(0, 1));
      owner = Thread.currentThread();
      count = 1;
    }else {
      count++;
    }
 
  }
 
  @Override
  public void unlock() {
    if (count == 1) {
      count = 0;
      value.compareAndSet(1, 0);
    }else
      count--;
  }
}

下面我们通过一个递归程序去验证我们写的可重入的自旋锁是否能够成功工作。

测试程序：

import java.util.concurrent.TimeUnit;
 
public class ReentrantSpinLockTest {
 
  public static int data;
  public static ReentrantSpinLock lock = new ReentrantSpinLock();
 
  public static void add(int state) throws InterruptedException {
    TimeUnit.SECONDS.sleep(1);
    if (state <= 3) {
      lock.lock();
      System.out.println(Thread.currentThread().getName() + "\t进入临界区 state = " + state);
      for (int i = 0; i < 10; i++)
        data++;
      add(state + 1);
      lock.unlock();
    }
  }
 
  public static void main(String[] args) throws InterruptedException {
    Thread[] threads = new Thread[10];
    for (int i = 0; i < 10; i++) {
      threads[i] = new Thread(new Thread(() -> {
        try {
          ReentrantSpinLockTest.add(1);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }, String.valueOf(i)));
    }
    for (int i = 0; i < 10; i++) {
      threads[i].start();
    }
    for (int i = 0; i < 10; i++) {
      threads[i].join();
    }
    System.out.println(data);
  }
}

上面程序的输出：

Thread-3 임계 상태 진입 = 1
Thread-3 임계 상태 진입 = 2
Thread-3 임계 상태 진입 = 3
Thread-0 임계 상태 진입 = 1
Thread-0 진입 임계 상태 진입 = 2
Thread-0 임계 상태 진입 = 3
Thread-9 임계 상태 진입 = 1
Thread-9 임계 상태 진입 = 2
Thread-9 임계 상태 진입 = 3
Thread-4 임계 상태 진입 = 1
Thread-4 임계 상태 진입 = 2
Thread-4 임계 상태 진입 = 3
Thread-7 임계 상태 진입 = 1
Thread-7 임계 상태 상태 = 2
Thread-7 임계 상태 상태 진입 = 3
Thread-8 임계 상태 상태 진입 = 1
Thread-8 임계 상태 상태 진입 = 2
Thread-8 임계 상태 상태 진입 = 3
Thread-5 임계 상태 진입 = 1
Thread-5 임계 상태 진입 = 2
Thread-5 임계 상태 진입 = 3
Thread-2 임계 상태 진입 = 1
Thread-2 임계 상태 진입 section state = 2
Thread-2 임계 구역 상태 진입 = 3
Thread-6 임계 구역 상태 진입 = 1
Thread-6 임계 구역 상태 진입 = 2
Thread-6 임계 구역 상태 진입 = 3
Thread -1 임계 상태 진입 = 1
Thread-1 임계 상태 진입 = 2
Thread-1 임계 상태 진입 = 3
300

위의 출력 결과를 통해 스레드가 언제 실행될 수 있는지 알 수 있습니다. 잠금을 획득하면 재진입이 가능하고 최종 출력 결과도 정확하므로 재진입 스핀을 작성한 것이 확인됩니다. 잠금이 작동합니다!

위 내용은 Java를 사용하여 수동 스핀 잠금을 구현하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!