분산 잠금의 세 가지 구현 방법은 무엇입니까?

분산 잠금을 구현하는 세 가지 방법: 1. 데이터베이스를 기반으로 분산 잠금을 구현합니다. 2. 캐시(Redis 등)를 기반으로 분산 잠금을 구현합니다. 3. Zookeeper를 기반으로 분산 잠금을 구현합니다. 성능 관점에서(높음에서 낮음으로): "캐시 모드 > Zookeeper 모드 > = 데이터베이스 모드".

이 기사의 운영 환경: Windows 시스템, redis 6.0, thinkpad t480 컴퓨터.

분산 잠금을 구현하는 세 가지 방법:

1. 데이터베이스를 기반으로 분산 잠금을 구현합니다.
2. Zookeeper를 기반으로 분산 잠금을 구현합니다.

1. 데이터베이스 기반 분산 잠금 구현

1. 비관적 잠금

업데이트 독점 잠금에는 select…를 사용하세요.

참고: 기타 추가 기능은 기본적으로 구현과 동일합니다. "where name= lock "이면 이름 필드를 색인화해야 합니다. 그렇지 않으면 테이블이 잠깁니다. 테이블이 크지 않은 경우와 같은 일부 경우에는 MySQL 최적화 프로그램이 이 인덱스를 사용하지 않아 테이블 잠금 문제가 발생합니다.

2. 낙관적 잠금

소위 낙관적 잠금과 이전 잠금의 가장 큰 차이점은 CAS 아이디어를 기반으로 하며 작업 중에 잠금 대기를 발생시키지 않고 리소스를 소비하지 않는다는 것입니다. , 업데이트 버전이 실패한 후에만 동시성 충돌이 없는 것으로 간주됩니다. 우리의 긴급 판매 및 반짝 판매는 이러한 구현을 사용하여 과잉 판매를 방지합니다.

증분 버전 번호 필드를 추가하여 낙관적 잠금 구현

2. 캐시 기반 분산 잠금 구현(Redis 등)

1. 명령 사용 소개: (1) SETNX

SETNX key val: 키가 존재하지 않는 경우에만 키 val을 사용하여 문자열을 설정하고 키가 있으면 1을 반환하고, 아무것도 하지 않고 0을 반환합니다.

(2)expire
expire key timeout: 키에 대한 시간 초과를 설정합니다. 단위는 두 번째입니다. 교착 상태를 방지하기 위해 이 시간 이후에 잠금이 자동으로 해제됩니다.
(3) delete
delete 키: delete 키

Redis를 사용하여 분산 잠금을 구현할 때 주로 이 세 가지 명령을 사용합니다.

2. 구현 아이디어:

(1) 잠금을 획득할 때 setnx를 사용하여 잠그고 만료 명령을 사용하여 잠금에 시간 초과를 추가하면 잠금 값이 자동으로 해제됩니다. lock은 무작위로 생성된 UUID로, 잠금이 해제되는 시기를 판단하는 데 사용됩니다.

(2) 잠금 획득 시 획득 제한 시간도 설정되어 있으며, 이 시간을 초과할 경우 잠금 획득이 포기됩니다.

(3) 잠금을 해제할 때 UUID를 사용하여 잠금인지 확인합니다. 잠금인 경우 삭제를 실행하여 잠금을 해제합니다.

3. 간단한 분산 잠금 구현 코드:

 /**
    * 分布式锁的简单实现代码    */
   public class DistributedLock {
   
       private final JedisPool jedisPool;
   
       public DistributedLock(JedisPool jedisPool) {
          this.jedisPool = jedisPool;
      }
  
      /**
       * 加锁
       * @param lockName       锁的key
       * @param acquireTimeout 获取超时时间
       * @param timeout        锁的超时时间
       * @return 锁标识
       */
      public String lockWithTimeout(String lockName, long acquireTimeout, long timeout) {
          Jedis conn = null;
          String retIdentifier = null;
          try {
              // 获取连接
              conn = jedisPool.getResource();
              // 随机生成一个value
              String identifier = UUID.randomUUID().toString();
              // 锁名，即key值
              String lockKey = "lock:" + lockName;
              // 超时时间，上锁后超过此时间则自动释放锁
              int lockExpire = (int) (timeout / );
  
              // 获取锁的超时时间，超过这个时间则放弃获取锁
              long end = System.currentTimeMillis() + acquireTimeout;
              while (System.currentTimeMillis()  results = transaction.exec();
                     if (results == null) {
                         continue;
                     }
                     retFlag = true;
                 }
                 conn.unwatch();
                 break;
             }
         } catch (JedisException e) {
             e.printStackTrace();
         } finally {
             if (conn != null) {
                 conn.close();
             }
         }
         return retFlag;
     }
 }

4. 방금 구현한 분산 잠금 테스트

예제에서는 50개의 스레드를 사용하여 제품의 즉시 종료를 시뮬레이션하고 – 연산자를 사용하여 제품에 대한 결과가 정렬되며, 해당 기능을 이용하여 잠겨있는지 확인할 수 있습니다.

플래시 세일 서비스를 시뮬레이션하고, 그 안에 jedis 스레드 풀을 구성하고, 초기화 중에 분산 잠금에 전달하여 사용하세요.

public class Service {

    private static JedisPool pool = null;

    private DistributedLock lock = new DistributedLock(pool);

    int n = 500;

    static {
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大连接数
        config.setMaxTotal(200);
        // 设置最大空闲数
        config.setMaxIdle(8);
        // 设置最大等待时间
        config.setMaxWaitMillis(1000 * 100);
        // 在borrow一个jedis实例时，是否需要验证，若为true，则所有jedis实例均是可用的
        config.setTestOnBorrow(true);
        pool = new JedisPool(config, "127.0.0.1", 6379, 3000);
    }

    public void seckill() {
        // 返回锁的value值，供释放锁时候进行判断
        String identifier = lock.lockWithTimeout("resource", 5000, 1000);
        System.out.println(Thread.currentThread().getName() + "获得了锁");
        System.out.println(--n);
        lock.releaseLock("resource", identifier);
    }
}

플래시 킬 서비스를 수행하기 위한 스레드 시뮬레이션

public class ThreadA extends Thread {
    private Service service;

    public ThreadA(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.seckill();
    }
}

public class Test {
    public static void main(String[] args) {
        Service service = new Service();
        for (int i = 0; i 결과는 다음과 같습니다. 결과는 다음과 같습니다. <p></p><p></p><p>잠금을 사용하는 부분을 주석 처리하면 <img src="https://img.php.cn/upload/article/000/000/024/0c1cb2ceea4c8cbfa184228a02822f99-1.png" alt="분산 잠금의 세 가지 구현 방법은 무엇입니까?"></p><pre class="brush:php;toolbar:false">public void seckill() {
    // 返回锁的value值，供释放锁时候进行判断
    //String indentifier = lock.lockWithTimeout("resource", 5000, 1000);
    System.out.println(Thread.currentThread().getName() + "获得了锁");
    System.out.println(--n);
    //lock.releaseLock("resource", indentifier);
}

에서 볼 수 있습니다. 결과적으로 일부는 비동기식으로 수행됩니다.

셋, Zookeeper를 기반으로 분산 잠금을 구현합니다.

ZooKeeper는 분산 애플리케이션에 일관성 서비스를 제공하는 오픈 소스 구성 요소입니다. 구조는 동일하다고 규정합니다. 디렉터리에는 고유한 파일 이름이 하나만 있을 수 있습니다. ZooKeeper를 기반으로 분산 잠금을 구현하는 단계는 다음과 같습니다.

(1) mylock 디렉터리를 생성합니다.

(2) 스레드 A가 잠금을 획득하려는 경우 mylock 디렉터리에 임시 시퀀스 노드를 생성합니다. mylock 디렉터리 노드의 모든 하위 항목을 가져온 다음 자신보다 작은 형제 노드를 얻습니다. 존재하지 않으면 현재 스레드가 가장 작은 시퀀스 번호를 가지며 잠금을 획득함을 의미합니다.

(4) 스레드 B가 모두 획득합니다. ;

(5) 스레드 A가 처리를 마친 후 스레드 B는 변경 이벤트를 모니터링하고 가장 작은 노드인지 확인합니다. 노드가 그렇다면 잠금을 획득합니다.

여기서는 ZooKeeper 클라이언트인 Apache의 오픈 소스 라이브러리인 Curator를 권장합니다. Curator에서 제공하는 InterProcessMutex는 잠금을 획득하는 데 사용되는 분산 잠금 장치이며, 잠금을 해제하는 방법은 해제 메서드입니다.

구현 소스 코드는 다음과 같습니다.

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.RetryNTimes;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.data.Stat;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * 分布式锁Zookeeper实现
 *
 */
@Slf4j
@Component
public class ZkLock implements DistributionLock {
private String zkAddress = "zk_adress";
    private static final String root = "package root";
    private CuratorFramework zkClient;

    private final String LOCK_PREFIX = "/lock_";

    @Bean
    public DistributionLock initZkLock() {
        if (StringUtils.isBlank(root)) {
            throw new RuntimeException("zookeeper 'root' can't be null");
        }
        zkClient = CuratorFrameworkFactory
                .builder()
                .connectString(zkAddress)
                .retryPolicy(new RetryNTimes(2000, 20000))
                .namespace(root)
                .build();
        zkClient.start();
        return this;
    }

    public boolean tryLock(String lockName) {
        lockName = LOCK_PREFIX+lockName;
        boolean locked = true;
        try {
            Stat stat = zkClient.checkExists().forPath(lockName);
            if (stat == null) {
                log.info("tryLock:{}", lockName);
                stat = zkClient.checkExists().forPath(lockName);
                if (stat == null) {
                    zkClient
                            .create()
                            .creatingParentsIfNeeded()
                            .withMode(CreateMode.EPHEMERAL)
                            .forPath(lockName, "1".getBytes());
                } else {
                    log.warn("double-check stat.version:{}", stat.getAversion());
                    locked = false;
                }
            } else {
                log.warn("check stat.version:{}", stat.getAversion());
                locked = false;
            }
        } catch (Exception e) {
            locked = false;
        }
        return locked;
    }

    public boolean tryLock(String key, long timeout) {
        return false;
    }

    public void release(String lockName) {
        lockName = LOCK_PREFIX+lockName;
        try {
            zkClient
                    .delete()
                    .guaranteed()
                    .deletingChildrenIfNeeded()
                    .forPath(lockName);
            log.info("release:{}", lockName);
        } catch (Exception e) {
            log.error("删除", e);
        }
    }

    public void setZkAddress(String zkAddress) {
        this.zkAddress = zkAddress;
    }
}

장점: 고가용성, 재진입 및 차단 잠금 기능을 갖추고 있어 실패 교착 상태 문제를 해결할 수 있습니다.

단점: 노드를 자주 생성하고 삭제해야 하기 때문에 Redis 방식만큼 성능이 좋지 않습니다.

넷째, 비교

데이터베이스 분산 잠금 구현

단점:

1. DB 작업 성능이 좋지 않고 테이블 잠금이 발생할 위험이 있습니다.
2. Non-Blocking 작업이 실패한 후 CPU 리소스를 차지하여 폴링이 필요합니다.
3. 오랜 시간 동안 더 많은 연결 리소스를 차지할 수 있습니다

Redis(캐시) 분산 잠금 구현
단점:

1 잠금 삭제 실패의 만료 시간을 제어하기 어렵습니다
2.

ZK 분산 잠금 구현
단점: Redis 구현만큼 성능이 좋지 않습니다. 주된 이유는 쓰기 작업(잠금 획득 및 잠금 해제)을 리더에서 실행해야 하고 그런 다음 팔로어와 동기화됩니다.

간단히 말하면 ZooKeeper는 성능과 안정성이 뛰어납니다.

이해의 용이성 관점에서(낮음에서 높음으로) 데이터베이스 > 캐시 > Zookeeper

구현 복잡성 관점에서(낮음에서 높음으로) Zookeeper > 캐시 > 데이터베이스

(높음에서 낮음으로) 캐시 > Zookeeper > = 데이터베이스

안정성 관점에서 (높음에서 낮음으로) Zookeeper > 캐시 > 데이터베이스

관련 권장 사항: "프로그래밍 교육"

위 내용은 분산 잠금의 세 가지 구현 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!