<!--jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

public class RedisPoolUtil {

    private static final String LOCK_SUCCESS = "OK";
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "PX";

    private RedisPoolUtil(){}
    /**
     * 
     * @param jedis 
     * @param lockKey 加锁
     * @param requestId 请求的标志位
     * @param expireTime 超时时间
     * @return
     */
    public static boolean tryGetDistributedLock(Jedis jedis,String lockKey, String requestId, int expireTime) {

        String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);

        if (LOCK_SUCCESS.equals(result)) {
            return true;
        }else{
            try{
                Thread.sleep(10);//休眠100毫秒
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        return false;
    }
}

 public static boolean releaseDistributedLock(Jedis jedis, String lockKey, String requestId) {

        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));

        if ("OK".equals(result)) {
            return true;
        }
        return false;

    }

try{
Boolean result = RedisPoolUtil.tryGetDistributedLock(jedis, "xxxxx", uuid, 5000);

if(result) {
        xxxx代码片段
}else{

}

}catch(){

}finally{
RedisPoolUtil.releaseDistributedLock(jedis,"xxxxx", uuid);
}

public class Activity {
    private Long id;
    private String name;
    private BigDecimal price;
}

public class IdGeneratorService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final String ID_KEY = "id:generator:activity";

    public Long incrementId() {
        return stringRedisTemplate.opsForValue().increment(ID_KEY);
    }

long id = idGeneratorService.incrementId(); 调用生成

local function get_max_seq()
    local key = tostring(KEYS[1])
    local incr_amoutt = tonumber(KEYS[2])
    local seq = tostring(KEYS[3])
    local month_in_seconds = 24 * 60 * 60 * 30
    if (1 == redis.call(

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
setnx

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
, key, seq))
    then
        redis.call(

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
expire

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
, key, month_in_seconds)
        return seq
    else
        local prev_seq = redis.call(

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
get

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
, key)
        if (prev_seq < seq)
        then
            redis.call(

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
set

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
, key, seq)
            return seq
        else
        --[[
            不能直接返回redis.call(

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
incr

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
, key),因为返回的是number浮点数类型,会出现不精确情况。
            注意: 类似"16081817202494579"数字大小已经快超时lua和reids最大数值,请谨慎的增加seq的位数
        --]]
            redis.call(

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
incrby

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
, key, incr_amoutt)
            return redis.call(

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
get

以上的 lua 的脚本来自于Ydoing，一个博客的大佬，我们现在既然会使用他生成全局唯一的ID，那么是不是就得搞清楚为什么会选择 Redis 来实现分布式全局唯一的ID。

Redis 的所有命令是单线程的

上一段开头，阿粉就说 Redis 的命令都是单线程的，相信如果你在面试官面前这么说，面试官肯定会问你一句，为什么 Redis 是单线程而不是多线程的呢？

Redis 基于 Reactor 模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以 Redis 才叫单线程模型。

当你说到这个 Reactor 模式的时候，如果大家深入研究过 Netty 的模型，就会发现，这个模式在 Netty 中也是有使用的，我们这时候是不是就得需要去官网上去瞅瞅看，为什么这么说。

什么是Reactor模型

Reactor模型实际上都知道，就是一个多路复用I/O模型，主要用于在高并发、高吞吐量的环境中进行I/O处理。

而这种多路复用的模型所依赖的永远都是那么几个内容，事件分发器，事件处理器，还有调用的客户端，



Reactor模型是一个同步的I/O多路复用模型，我们还是先把这个同步的I/O多路复用模型给弄清楚了再看其他的。

这个相信大家肯定不是很熟悉，而阿粉在之前也给大家说了关于Netty中的Channel，文章地址发给大家，用Socket编程？我还是选择了Netty,在文章中，我们已经给大家说了关于Channel，而这种单线程的模型是什么样子的呢？



图已经给大家画出来了，丑是丑了点，但是意思还是表达出来了。

这种模型也就是说：Redis 单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求，其他模块仍用了多个线程。

而面试官还会有一种问法，为什么使用 Redis 就会快。

这个相信大家肯定能回答出来，因为 Redis 是一种基于内存的存储数据，为什么内存快？

因为这种快速是针对存储在磁盘上的数据来说的，因为内存中的数据，断电之后，消失了，你下次来的时候，不还是需要从磁盘读取出来，然后保存，所以说在Redis速度快。扯远了，回来继续说 Redis的单线程。

我们来看看官网给我们的解释：

1
2
3
4
5
6
7
8
Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.


其实翻译过来大致就是说，当我们使用 Redis 的时候，CPU 成为瓶颈的情况并不常见，因为 Redis 通常是内存或网络受限的。

其实说白了，官网就是说我们 Redis 就是这么的快，并且正是由于在单线程模式的情况下已经很快了，就没有必要在使用多线程了。这整的是不是就有点恶心了。阿粉也说说自己的见解，毕竟这官网的话有点糊弄人的意思。

其实 Redis 使用单个 CPU 绑定一个内存，针对内存的处理就是单线程的,而我们使用多个 CPU 模拟出多个线程来，光在多个 CPU 之间的切换，然后再操作 Redis ，实际上就不如直接从内存中拿出来，毕竟耗时在这里摆着。

你认为的 Redis 为什么是单线程的？
, key)
        end
    end
end
return get_max_seq()

Redis is single threaded. How can I exploit multiple CPU / cores?
It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound. For instance, using pipelining Redis running on an average Linux system can deliver even 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

You can find more information about using multiple Redis instances in the Partitioning page.

However with Redis 4.0 we started to make Redis more threaded. For now this is limited to deleting objects in the background, and to blocking commands implemented via Redis modules. For future releases, the plan is to make Redis more and more threaded.

<settings>
	<setting name = "cacheEnabled" value = "true" />
</settings>

typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
typeAliasRegistry.registerAlias("LRU", LruCache.class);
typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
typeAliasRegistry.registerAlias("WEAK", WeakCache.class);

public class PerpetualCache implements Cache {
  private final String id;
  private Map<Object, Object> cache = new HashMap<>();
  public PerpetualCache(String id) {
    this.id = id;
  }

public class CacheKey implements Cloneable, Serializable {
  private static final long serialVersionUID = 1146682552656046210L;
  public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();
  private static final int DEFAULT_MULTIPLYER = 37;
  private static final int DEFAULT_HASHCODE = 17;
  private final int multiplier;
  private int hashcode; //用于表示CacheKey的哈希码
  private long checksum; //总和校验，当出现复合key的时候，分布计算每个key的哈希码，然后求总和
  private int count;//当出现复合key的时候，计算key的总个数
  // 8/21/2017 - Sonarlint flags this as needing to be marked transient.  While true if content is not serializable, this is not always true and thus should not be marked transient.
  private List<Object> updateList;//当出现复合key的时候，保存每个key
  

public class FifoCache implements Cache {

  private final Cache delegate; //被装饰的Cache对象
  private final Deque<Object> keyList;//用于记录key 进入缓存的先后顺序
  private int size;//记录了缓存页的上限，超过该值需要清理缓存（FIFO）

  public FifoCache(Cache delegate) {
    this.delegate = delegate;
    this.keyList = new LinkedList<>();
    this.size = 1024;
  }

public class LruCache implements Cache {

  private final Cache delegate;
  private Map<Object, Object> keyMap;
  private Object eldestKey;//记录最少被使用的缓存项key

  public LruCache(Cache delegate) {
    this.delegate = delegate;
    setSize(1024);//重新设置缓存的大小，会重置KeyMap 字段 如果到达上限 则更新eldestKey
  }
    public void putObject(Object key, Object value) {
      delegate.putObject(key, value);
      // 删除最近未使用的key
      cycleKeyList(key);
    }

public class SoftCache implements Cache {
  //在SoftCache 中，最近使用的一部分缓存项不会被GC回收，这就是通过将其value添加到
  private final Deque<Object> hardLinksToAvoidGarbageCollection;
  //引用队列，用于记录GC回收的缓存项所对应的SoftEntry对象
  private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;
  //底层被修饰的Cache 对象
  private final Cache delegate;
  //连接的个数，默认是256
  private int numberOfHardLinks;

  public SoftCache(Cache delegate) {
    this.delegate = delegate;
    this.numberOfHardLinks = 256;
    this.hardLinksToAvoidGarbageCollection = new LinkedList<>();
    this.queueOfGarbageCollectedEntries = new ReferenceQueue<>();
  }
  
  public void putObject(Object key, Object value) {
      // 清除被GC回收的缓存项
      removeGarbageCollectedItems();
      // 向缓存中添加缓存项
      delegate.putObject(key, new SoftEntry(key, value, queueOfGarbageCollectedEntries));
    }
   public Object getObject(Object key) {
       Object result = null;
       // 查找对应的缓存项
       @SuppressWarnings("unchecked") // assumed delegate cache is totally managed by this cache
       SoftReference<Object> softReference = (SoftReference<Object>) delegate.getObject(key);
       if (softReference != null) {
         result = softReference.get();
         // 已经被GC 回收
         if (result == null) {
           // 从缓存中清除对应的缓存项
           delegate.removeObject(key);
         } else {
           // See #586 (and #335) modifications need more than a read lock 
           synchronized (hardLinksToAvoidGarbageCollection) {
             hardLinksToAvoidGarbageCollection.addFirst(result);
             if (hardLinksToAvoidGarbageCollection.size() > numberOfHardLinks) {
               hardLinksToAvoidGarbageCollection.removeLast();
             }
           }
         }
       }
       return result;
     }
    public void clear() {
        synchronized (hardLinksToAvoidGarbageCollection) {
          // 清理强引用集合
          hardLinksToAvoidGarbageCollection.clear();
        }
        // 清理被GC回收的缓存项
        removeGarbageCollectedItems();
        delegate.clear();
      }
    //其中指向key的引用是强引用，而指向value的引用是弱引用
    private static class SoftEntry extends SoftReference<Object> {
      private final Object key;
  
      SoftEntry(Object key, Object value, ReferenceQueue<Object> garbageCollectionQueue) {
        super(value, garbageCollectionQueue);
        this.key = key;
      }
    }

public class WeakCache implements Cache {
  private final Deque<Object> hardLinksToAvoidGarbageCollection;
  private final ReferenceQueue<Object> queueOfGarbageCollectedEntries;
  private final Cache delegate;
  private int numberOfHardLinks;

  public WeakCache(Cache delegate) {
    this.delegate = delegate;
    this.numberOfHardLinks = 256;
    this.hardLinksToAvoidGarbageCollection = new LinkedList<>();
    this.queueOfGarbageCollectedEntries = new ReferenceQueue<>();
  }

rabbitmq-plugins enable rabbitmq_web_stomp
rabbitmq-plugins enable rabbitmq_web_stomp_examples
#重启
service rabbitmq-server stop && service rabbitmq-server start

 if (typeof WebSocket == 'undefined') {
        console.log('不支持websocket')
    }

    // 初始化 ws 对象

    var ws = new WebSocket('ws://localhost:15674/ws');

    // 获得Stomp client对象
    var client = Stomp.over(ws);

    // 定义连接成功回调函数
    var on_connect = function(x) {
        //data.body是接收到的数据
        client.subscribe("/Fanout_Exchange/testMessage", function(data) {
            var msg = data.body;
            alert("收到数据：" + msg);
        });
    };

    // 定义错误时回调函数
    var on_error =  function() {
        console.log('连接错误，请重试');
    };

    // 连接RabbitMQ
    client.connect('guest', 'guest', on_connect, on_error, '/');
    console.log(">>>RabbitMQ已连接，测试正式开始");

    //这里先定义Queue和交换机以及RoutingKey

    /**
     * 消息的routing key与队列的binding key相同的队列
     */
    public static final String DIRECT_QUEUE_NAME = "Direct_Queue";
    /**
     * direct 交换机
     */
    public static final String DIRECT_EXCHANGE_NAME = "Direct_Exchange";
    /**
     * routing key
     */
    public static final String DIRECT_ROUTING_KEY_NAME = "Direct_Routing_Key";
    
    //创建队列+队列交换机绑定
    /**
     * Direct交换机
     * @return
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(DIRECT_EXCHANGE_NAME);
    }
    /**
     * 创建一条持久化的、非排他的、非自动删除的队列
     * @return
     */
    @Bean
    public Queue directQueue(){
        return new Queue(DIRECT_QUEUE_NAME);
    }

    /**
     * Binding,将该routing key的消息通过交换机转发到该队列 匹配键：DIRECT_ROUTING_KEY_NAME
     * @return
     */
    @Bean
    public Binding directBinding(){
        return BindingBuilder.bind(directQueue()).to(directExchange()).with(DIRECT_ROUTING_KEY_NAME);
    }

    /**
     * 与fanout绑定的第一个队列
     */
    public static final String FIRST_FANOUT_QUEUE_NAME = "First_Fanout_Queue";
    
    /**
     * 与fanout交换机绑定的第二个队列
     */
    public static final String SECOND_FANOUT_QUEUE_NAME = "Send_Fanout_Queue";
    
    /**
     * fanout 交换机
     */
    public static final String FANOUT_EXCHANGE_NAME = "Fanout_Exchange";


     @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE_NAME);
    }

    @Bean
    public Queue firstFanoutQueue() {
        return new Queue(FIRST_FANOUT_QUEUE_NAME);
    }

    @Bean
    public Queue secondFanoutQueue() {
        return new Queue(SECOND_FANOUT_QUEUE_NAME);
    }

    @Bean
    public Binding firstFanoutBinding() {
        return BindingBuilder.bind(firstFanoutQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding secondFanoutBinding() {
        return BindingBuilder.bind(secondFanoutQueue()).to(fanoutExchange());
    }

    /**
     * 处理对象的MQ队列
     */
    public static final String HANDLER_OBJECT_QUEUE_NAME = "Handler_Object_Queue";

    /**
     * 处理对象的MQ队列
     */
    public static final String HANDLER_OBJECT_EXCHANGE = "Handler_Object_Exchange";
    
    @Bean
    public Queue handleObjectQueue() {
        return new Queue(HANDLER_OBJECT_QUEUE_NAME);
    }

    @Bean
    public HeadersExchange headersExchange(){
        return new HeadersExchange(HANDLER_OBJECT_EXCHANGE);
    }
    @Bean

    public Binding headerBinding(){
        Map<String, Object> map = new HashMap<>();
        map.put("header1", "value1");
        map.put("header2", "value2");
        return BindingBuilder.bind(handleObjectQueue()).to(headersExchange()).whereAll(map).match();
    }

 /**
     * 与topic绑定的第一个队列
     *
     */
    public final static String FIRST_TOPIC_QUEUE = "First_Topic_Queue";
    /**
     * 与topic绑定的第二个队列
     *
     */
    public final static String SECOND_TOPIC_QUEUE = "Second_Topic_Queue";
    /**
     * 与topic绑定的第二个队列
     *
     */
    public final static String TOPIC_EXANGE_NAME = "Topic_Exchange";
    
    /**
     *  Topic型交换机模型:将routingKey与binding key做通配符匹配，转发消息到匹配的队列
     *  “#”匹配一个词或多个词，“*”只匹配一个词。
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXANGE_NAME);
    }
    @Bean
    public Queue firstTopicQueue() { return new Queue(FIRST_TOPIC_QUEUE);}

    @Bean
    public Queue secondTopicQueue() {
        return new Queue(SECOND_TOPIC_QUEUE);
    }

    /**
     * 将FirstQueue和TopicExchange绑定，绑定的键为FIRST_TOPIC_QUEUE
     */
    @Bean
    public Binding firstTopicBinding() {
        return BindingBuilder.bind(firstTopicQueue()).to(topicExchange()).with(FIRST_TOPIC_QUEUE);
    }
    /**
     * 将SecondQueue和TopicExchange绑定，绑定的键为通配符使用的 Topic_#
     * 消息携带的路由键是以Topic.开头,都会分发到该队列
     */
    @Bean
    public Binding secondTopicBinding() {
        return BindingBuilder.bind(secondTopicQueue()).to(topicExchange()).with("Topic.#");
    }

 rabbitTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXANGE_NAME, routingKey, message,new CorrelationData(UUID.randomUUID().toString()));

    #是否支持发布确认
    publisher-confirms: true
    #是否支持发布返回
    publisher-returns: true

        //ACK确认机制
        rabbitTemplate.setConfirmCallback(confirmCallback);
        rabbitTemplate.convertAndSend(RabbitMQConfig.SIMPLE_QUEUE_NAME, message);

confirm确认 此处的confirm确认是发送的ACK确认机制
    RabbitTemplate.ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() {
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            if(ack){
                System.out.println(correlationData);
                //如果confirm返回成功 则进行更新
                System.out.println("confirm确认消息已经发出");
            } else {
                //失败则进行具体的后续操作:重试 或者补偿等手段
                System.err.println("异常处理...");
            }
        }
    };