面试官：Redis 单线程已经很快，为何 6，大连埃森哲java面试题

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

因此，Redis最终实现上是将大键的删除操作异步化，采用非阻塞删除（对应命令UNLINK），大键的空间回收交由单独线程实现，主线程只做关系解除，可以快速返回，继续处理其他事件，避免服务器长时间阻塞。

以删除（DEL命令）为例，看看Redis是如何实现的，下面就是删除函数的入口，其中，lazyfree_lazy_user_del是是否修改DEL命令的默认行为，一旦开启，执行DEL时将会以UNLINK形式执行。

void delCommand(client *c) {

delGenericCommand(c,server.lazyfree_lazy_user_del);

}

/* This command implements DEL and LAZYDEL. */

void delGenericCommand(client *c, int lazy) {

int numdel = 0, j;

for (j = 1; j < c->argc; j++) {

expireIfNeeded(c->db,c->argv[j]);

// 根据配置确定DEL在执行时是否以lazy形式执行

int deleted = lazy ? dbAsyncDelete(c->db,c->argv[j]) :

dbSyncDelete(c->db,c->argv[j]);

if (deleted) {

signalModifiedKey(c,c->db,c->argv[j]);

notifyKeyspaceEvent(NOTIFY_GENERIC,

“del”,c->argv[j],c->db->id);

server.dirty++;

numdel++;

}

}

addReplyLongLong(c,numdel);

}

同步删除很简单，只要把key和value删除，如果有内层引用，则进行递归删除，这里不做介绍。下面看下异步删除，Redis在回收对象时，会先计算回收收益，只有回收收益在超过一定值时，采用封装成Job加入到异步处理队列中，否则直接同步回收，这样效率更高。回收收益计算也很简单，比如String类型，回收收益值就是1，而Set类型，回收收益就是集合中元素个数。

/* Delete a key, value, and associated expiration entry if any, from the DB.

• If there are enough allocations to free the value object may be put into

• a lazy free list instead of being freed synchronously. The lazy free list

• will be reclaimed in a different bio.c thread. */

#define LAZYFREE_THRESHOLD 64

int dbAsyncDelete(redisDb *db, robj *key) {

/* Deleting an entry from the expires dict will not free the sds of

• the key, because it is shared with the main dictionary. */

if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr);

/* If the value is composed of a few allocations, to free in a lazy way

• is actually just slower… So under a certain limit we just free

• the object synchronously. */

dictEntry *de = dictUnlink(db->dict,key->ptr);

if (de) {

robj *val = dictGetVal(de);

// 计算value的回收收益

size_t free_effort = lazyfreeGetFreeEffort(val);

/* If releasing the object is too much work, do it in the background

• by adding the object to the lazy free list.

• Note that if the object is shared, to reclaim it now it is not

• possible. This rarely happens, however sometimes the implementation

• of parts of the Redis core may call incrRefCount() to protect

• objects, and then call dbDelete(). In this case we’ll fall

• through and reach the dictFreeUnlinkedEntry() call, that will be

• equivalent to just calling decrRefCount(). */

// 只有回收收益超过一定值，才会执行异步删除，否则还是会退化到同步删除

if (free_effort > LAZYFREE_THRESHOLD && val->refcount == 1) {

atomicIncr(lazyfree_objects,1);

bioCreateBackgroundJob(BIO_LAZY_FREE,val,NULL,NULL);

dictSetVal(db->dict,de,NULL);

}

}

/* Release the key-val pair, or just the key if we set the val

• field to NULL in order to lazy free it later. */

if (de) {

dictFreeUnlinkedEntry(db->dict,de);

if (server.cluster_enabled) slotToKeyDel(key->ptr);

return 1;

} else {

return 0;

}

}

通过引入a threaded lazy free，Redis实现了对于Slow Operation的Lazy操作，避免了在大键删除，FLUSHALL，FLUSHDB时导致服务器阻塞。当然，在实现该功能时，不仅引入了lazy free线程，也对Redis聚合类型在存储结构上进行改进。

因为Redis内部使用了很多共享对象，比如客户端输出缓存。当然，Redis并未使用加锁来避免线程冲突，锁竞争会导致性能下降，而是去掉了共享对象，直接采用数据拷贝，如下，在3.x和6.x中ZSet节点value的不同实现。

// 3.2.5版本ZSet节点实现，value定义robj *obj

/* ZSETs use a specialized version of Skiplists */

typedef struct zskiplistNode {

robj *obj;

double score;

struct zskiplistNode *backward;

struct zskiplistLevel {

struct zskiplistNode *forward;

unsigned int span;

} level[];

} zskiplistNode;

// 6.0.10版本ZSet节点实现，value定义为sds ele

/* ZSETs use a specialized version of Skiplists */

typedef struct zskiplistNode {

sds ele;

double score;

struct zskiplistNode *backward;

struct zskiplistLevel {

struct zskiplistNode *forward;

unsigned long span;

} level[];

} zskiplistNode;

去掉共享对象，不但实现了lazy free功能，也为Redis向多线程跨进带来了可能，正如作者所述：

Now that values of aggregated data types are fully unshared, and client output buffers don’t contain shared objects as well, there is a lot to exploit. For example it is finally possible to implement threaded I/O in Redis, so that different clients are served by different threads. This means that we’ll have a global lock only when accessing the database, but the clients read/write syscalls and even the parsing of the command the client is sending, can happen in different threads.

多线程I/O及其局限性

---

Redis在4.0版本引入了Lazy Free，自此Redis有了一个Lazy Free线程专门用于大键的回收，同时，也去掉了聚合类型的共享对象，这为多线程带来可能，Redis也不负众望，在6.0版本实现了多线程I/O。

实现原理

正如官方以前的回复，Redis的性能瓶颈并不在CPU上，而是在内存和网络上。因此6.0发布的多线程并未将事件处理改成多线程，而是在I/O上，此外，如果把事件处理改成多线程，不但会导致锁竞争，而且会有频繁的上下文切换，即使用分段锁来减少竞争，对Redis内核也会有较大改动，性能也不一定有明显提升。

如上图红色部分，就是Redis实现的多线程部分，利用多核来分担I/O读写负荷。在事件处理线程每次获取到可读事件时，会将所有就绪的读事件分配给I/O线程，并进行等待，在所有I/O线程完成读操作后，事件处理线程开始执行任务处理，在处理结束后，同样将写事件分配给I/O线程，等待所有I/O线程完成写操作。

以读事件处理为例，看下事件处理线程任务分配流程：

int handleClientsWithPendingReadsUsingThreads(void) {

…

/* Distribute the clients across N different lists. */

listIter li;

listNode *ln;

listRewind(server.clients_pending_read,&li);

int item_id = 0;

// 将等待处理的客户端分配给I/O线程

while((ln = listNext(&li))) {

client *c = listNodeValue(ln);

int target_id = item_id % server.io_threads_num;

listAddNodeTail(io_threads_list[target_id],c);

item_id++;

}

…

/* Wait for all the other threads to end their work. */

// 轮训等待所有I/O线程处理完

while(1) {

unsigned long pending = 0;

for (int j = 1; j < server.io_threads_num; j++)

pending += io_threads_pending[j];

if (pending == 0) break;

}

…

总结

三个工作日收到了offer，头条面试体验还是很棒的，这次的头条面试好像每面技术都问了我算法，然后就是中间件、MySQL、Redis、Kafka、网络等等。

• 第一个是算法

关于算法，我觉得最好的是刷题，作死的刷的，多做多练习，加上自己的理解，还是比较容易拿下的。

而且，我貌似是将《算法刷题LeetCode中文版》、《算法的乐趣》大概都过了一遍，尤其是这本

《算法刷题LeetCode中文版》总共有15个章节：编程技巧、线性表、字符串、栈和队列、树、排序、查找、暴力枚举法、广度优先搜索、深度优先搜索、分治法、贪心法、动态规划、图、细节实现题

《算法的乐趣》共有23个章节：

• 第二个是Redis、MySQL、kafka（给大家看下我都有哪些复习笔记）

基本上都是面试真题解析、笔记和学习大纲图，感觉复习也就需要这些吧（个人意见）

• 第三个是网络（给大家看一本我之前得到的《JAVA核心知识整理》包括30个章节分类，这本283页的JAVA核心知识整理还是很不错的，一次性总结了30个分享的大知识点）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
一本我之前得到的《JAVA核心知识整理》包括30个章节分类，这本283页的JAVA核心知识整理还是很不错的，一次性总结了30个分享的大知识点）**

[外链图片转存中…(img-K43iRhjY-1713559617656)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-4dqvr2S0-1713559617656)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！