Analisis mendalam tentang kunci yang diedarkan dalam Redis

Artikel ini terutamanya memperkenalkan anda kepada pelaksanaan dan analisis kod kunci yang diedarkan dalam Redis saya harap ia akan membantu anda!

Kunci Teragih Semula

Pemegang kunci teragih digunakan dalam projek semua orang dan biasanya digunakan untuk memesan data, seperti sebagai membayar balik pesanan (jika ia boleh dibayar balik beberapa kali). Atau pengguna membuat pesanan melalui berbilang terminal. [Cadangan berkaitan: Tutorial video Redis]

Kebergantungan Maven

Saya terutamanya berdasarkan Spring-Boot 2.1.2 Jedis Laksanakan

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
    </parent>

    <groupId>cn.edu.cqvie</groupId>
    <artifactId>redis-lock</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <redis.version>2.9.0</redis.version>
        <spring-test.version>5.0.7</spring-test.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${redis.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>log4j-over-slf4j</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Fail konfigurasi

application.properties Kandungan fail konfigurasi adalah seperti berikut:

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.timeout=30000
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.min-idle=2
spring.redis.jedis.pool.max-idle=4


logging.level.root=INFO

Takrifan antara muka

Takrifan antara muka, teras kami untuk mengunci sebenarnya hanyalah dua kaedah lock dan unlock.

public interface RedisLock {

    long TIMEOUT_MILLIS = 30000;

    int RETRY_MILLIS = 30000;

    long SLEEP_MILLIS = 10;

    boolean tryLock(String key);

    boolean lock(String key);

    boolean lock(String key, long expire);

    boolean lock(String key, long expire, long retryTimes);

    boolean unlock(String key);
}

Pelaksanaan kunci teragih

Pelaksanaan saya adalah melalui setnx Jika ada tryLock logik, ia akan dicuba semula melalui 自旋

<🎜. >

// AbstractRedisLock.java 抽象类
public abstract class AbstractRedisLock implements RedisLock {

    @Override
    public boolean lock(String key) {
        return lock(key, TIMEOUT_MILLIS);
    }

    @Override
    public boolean lock(String key, long expire) {
        return lock(key, TIMEOUT_MILLIS, RETRY_MILLIS);
    }
}

// 具体实现
@Component
public class RedisLockImpl extends AbstractRedisLock {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    private ThreadLocal<String> threadLocal = new ThreadLocal<String>();
    private static final String UNLOCK_LUA;

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();

    }

    @Override
    public boolean tryLock(String key) {
        return tryLock(key, TIMEOUT_MILLIS);
    }

    public boolean tryLock(String key, long expire) {
        try {
            return !StringUtils.isEmpty(redisTemplate.execute((RedisCallback<String>) connection -> {
                JedisCommands commands = (JedisCommands) connection.getNativeConnection();
                String uuid = UUID.randomUUID().toString();
                threadLocal.set(uuid);
                return commands.set(key, uuid, "NX", "PX", expire);
            }));
        } catch (Throwable e) {
            logger.error("set redis occurred an exception", e);
        }
        return false;
    }

    @Override
    public boolean lock(String key, long expire, long retryTimes) {
        boolean result = tryLock(key, expire);

        while (!result && retryTimes-- > 0) {
            try {
                logger.debug("lock failed, retrying...{}", retryTimes);
                Thread.sleep(SLEEP_MILLIS);
            } catch (InterruptedException e) {
                return false;
            }
            result = tryLock(key, expire);
        }
        return result;
    }

    @Override
    public boolean unlock(String key) {
        try {
            List<String> keys = Collections.singletonList(key);
            List<String> args = Collections.singletonList(threadLocal.get());
            Long result = redisTemplate.execute((RedisCallback<Long>) connection -> {
                Object nativeConnection = connection.getNativeConnection();

                if (nativeConnection instanceof JedisCluster) {
                    return (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, keys, args);
                }
                if (nativeConnection instanceof Jedis) {
                    return (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, keys, args);
                }
                return 0L;
            });
            return result != null && result > 0;
        } catch (Throwable e) {
            logger.error("unlock occurred an exception", e);
        }
        return false;
    }
}

Kod ujian

Akhirnya mari kita lihat cara menggunakannya (Berikut ialah senario jualan kilat simulasi)

< 🎜. >

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisLockImplTest {

    private Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private RedisLock redisLock;
    @Autowired
    private StringRedisTemplate redisTemplate;
    private ExecutorService executors = Executors.newScheduledThreadPool(8);

    @Test
    public void lock() {
        // 初始化库存
        redisTemplate.opsForValue().set("goods-seckill", "10");
        List<Future> futureList = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            futureList.add(executors.submit(this::seckill));
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 等待结果，防止主线程退出
        futureList.forEach(action -> {
            try {
                action.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });

    }

    public int seckill() {
        String key = "goods";
        try {
            redisLock.lock(key);
            int num = Integer.valueOf(Objects.requireNonNull(redisTemplate.opsForValue().get("goods-seckill")));
            if (num > 0) {
                redisTemplate.opsForValue().set("goods-seckill", String.valueOf(--num));
                logger.info("秒杀成功，剩余库存：{}", num);
            } else {
                logger.error("秒杀失败，剩余库存：{}", num);
            }
            return num;
        } catch (Throwable e) {
            logger.error("seckill exception", e);
        } finally {
            redisLock.unlock(key);
        }
        return 0;
    }
}

Ringkasan

Artikel ini ialah pelaksanaan mudah kunci Redis, yang melaksanakan operasi cuba semula kunci berdasarkan

. Walau bagaimanapun, masih terdapat kelemahan Ia tidak menyokong pembaharuan automatik kunci, kemasukan semula kunci dan keadilan (sedang dilaksanakan melalui putaran, yang bersamaan dengan kaedah yang tidak adil).

jedisUntuk lebih banyak pengetahuan berkaitan pengaturcaraan, sila lawati:

Pengenalan kepada Pengaturcaraan

! !

Atas ialah kandungan terperinci Analisis mendalam tentang kunci yang diedarkan dalam Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!