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("异常处理...");
            }
        }
    };

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.mq-amqp</groupId>
            <artifactId>mq-amqp-client</artifactId>
            <version>1.0.5</version>
        </dependency>

@Component
public class Producer {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    /**
     * 发生消息到RabbitMQ,使用SpringBoot默认的交换机
     *
     * @param message
     */
    public void sendMessage(String message) {
        
        rabbitTemplate.setConfirmCallback(confirmCallback);
        rabbitTemplate.convertAndSend(RabbitMQConfig.SIMPLE_QUEUE_NAME, message);
    }

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

    @Autowired
    private RabbitTemplate rabbitTemplate; 
    //记住这个，这Template是SpringBoot里面整合RabbitMQ自带的，不是我自己专门写的哈，大家不要一看到这个注入，就寻思是个自己写的。

    /**
     * 普通默认点对点的消息消费者
     * @param message
     */
    @RabbitListener(queues = {RabbitMQConfig.SIMPLE_QUEUE_NAME})
    @RabbitHandler
    public void receiveMessage(String message, Channel channel, @Headers Map<String,Object> headers) { //
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //处理监听得到的消息
                String message = null;
                try {
                    message = new String(body, "UTF-8");
                    //消息处理逻辑
                    sendMessage(message);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                    channel.abort();
                } finally {
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };
        boolean autoAck = false;
        //消息消费完成确认
        try {
            channel.basicConsume(RabbitMQConfig.SIMPLE_QUEUE_NAME, autoAck, consumer);
        }catch (Exception e){

        }
        System.out.println("消费者进行消息消费：消费主体是-----"+ message);
    }
    

        //消息发送
        for (int i = 0;i < 100 ;i++){
            producer.sendMessage("生产消息消息"+i);
        }
        消费者一模一样的复制出一份，在消费消息的时候打印一下就可以啦

/**
     * Fanout型交换机MQ模型:订阅模式，消息到达交换机会转发到与该交换机绑定的队列
     */

    /**
     * 与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";

    /**
     * FanoutExchange,持久化、非自动删除
     *
     * @return
     */
    @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());
    }

  /**
     * Fanout型交换机的MQ模型消费消息
     * @param message
     */
    @RabbitListener(queues = {RabbitMQConfig.FIRST_FANOUT_QUEUE_NAME})
    @RabbitHandler
    public void receiveFanoutMessage(String message) {
        System.out.println("11111Fanout消费者进行消息消费：消费主体是-----"+ message);
    }

    /**
     * Fanout型交换机的MQ模型消费消息
     * @param message
     */
    @RabbitListener(queues = {RabbitMQConfig.SECOND_FANOUT_QUEUE_NAME})
    @RabbitHandler
    public void receiveFanoutMessage2(String message) {
        System.out.println("2222Fanout消费者进行消息消费：消费主体是-----"+ message);
    }

    /**
     * 发送消息至fanout交换机,由于fanout只关注订阅关系，所以routing key随便指定都可以
     * @param message
     */
    public void sendFanoutMessage(String message){
        rabbitTemplate.convertAndSend(RabbitMQConfig.FANOUT_EXCHANGE_NAME, "------", message);
    }

 private final static String QUEUE_NAME = "Test_queue";

    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try {
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Hello World";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" 我生产了一条消息 " + message );
        }catch (Exception e){

        }
    }

  我生产了一条消息Hello World

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        DeliverCallback deliverCallback = (consumerTag, deliver) -> {
            String message = new String(deliver.getBody(), "UTF-8");
            System.out.println(" 我是来消费消息的" + message );
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {});
    }

 我是来消费消息的'Hello World'