太棒了! 目前共计 1,153 篇日志。 继续努力。

结课测试｜这些金融架构的问题，你都掌握了么？

01-16

结束语 | 金融之道，与你同行，虽远尤欣

01-16

春节策划第3期 | 如何运用架构知识解读春运买票和手游案例？

01-16

春节策划第2期 | 读书如抽丝，为你推荐一些我读过的好书

01-16

春节策划第1期 | 分布式金融系统知识，你掌握了多少？

01-16

答疑集锦（三） | 思考题解析与数据库底层实现

01-16

21 | 容灾（下）：如何通过混沌工程提高系统稳定性？

01-16

20 | 容灾（上）如何实现正确的跨机房实时容灾？

01-16

19 | 正确性案例（下）：如何在运行时进行数据系统的动态分库？

01-16

18 | 正确性案例（中）：常见分布式数据方案的设计原理是什么？

01-16

17 | 正确性案例（上）：如何实现分布式的事件溯源架构？

01-16

16 | 分布式一致性（下）：怎么理解最简单的分布式一致性算法？

01-16

15 | 分布式正确性的存在性（上）：什么情况下不存在分布式共识算法？

01-16

14 | 正确性分级（下）：多机有容灾有哪几种不同的一致性？

01-16

13 | 正确性分级（中）：多机无容灾有哪几种不同的一致性实现？

01-16

12 | 正确性分级（上）：单机无备份有哪几种不同的一致性？

01-16

答疑集锦（二） | 思考题解析与账务系统优化

01-16

11 | 系统优化：如何让金融系统运行得更快？

01-16

10 | 数据存储的合理性：金融业务可以不用关系型数据库吗？

01-16

09 | 数据传输的质量：金融业务对数据传输有什么要求？

01-16

08 | 计算结果的正确性：怎么保证计算结果是正确的？

01-16

07 | 计算过程的正确性：如何设计正确的数据处理架构？

01-16

06 | 计算输入的正确性：怎么选择正确时间的数据？

01-16

答疑集锦（一） | 思考题解析与外汇架构知识拓展

01-16

05 | 领域驱动设计（下）：如何设计统一的金融业务模型？

01-16

04 | 领域驱动设计（上）：如何设计金融软件顶层架构？

01-16

03 | 产品大观：不同金融业务都有哪些技术实现要点？

01-16

02 | 原理解读：如何理解第三方支付的业务逻辑和系统组件？

01-16

01 | 业务初探：扫了二维码之后发生了什么？

01-16

开篇词 | 如何成为金融级人才？

01-16

期末测试｜来赴一场满分之约！

01-16

结束语｜在技术的世界里享受思维的乐趣

01-16

40｜垃圾回收：现代语言是如何自动管理回收内存的？

01-16

39｜Geohash：点外卖时我们是如何查找到附近餐厅的？

01-16

38｜倒排索引：搜索引擎是如何做全文检索的？

01-16

37｜Thrift编码方法：为什么RPC往往不采用JSON作为网络传输格式？

01-16

36｜分布式事务：如何理解两阶段提交？

01-16

35｜洗牌算法：随机的哲学，如何用程序来洗一副牌？

01-16

即学即练｜工程实战篇：复习卡一键直达

01-16

即学即练｜分布式篇：复习卡一键直达

01-16

即学即练｜计算机网络篇：复习卡 & 算法题特训

01-16

即学即练｜操作系统篇：复习卡 & 算法题特训

01-16

即学即练｜基础算法思想篇：复习卡 & 算法题特训

01-16

即学即练｜基础数据结构篇：复习卡 & 算法题特训

01-16

特别策划｜面试：BAT面试三关准备方法大揭秘

01-16

34｜前缀树：Web框架中如何实现路由匹配？

01-16

33｜限流算法：如何防止系统过载？

01-16

32｜时间轮：Kafka是如何实现定时任务的？

01-16

31｜跳表：Redis是如何存储有序集合的？

01-16

30｜布隆过滤器：如何解决Redis缓存穿透问题？

01-16

29｜位图：如何用更少空间对大量数据进行去重和排序？

01-16

28｜MVCC：如何突破数据库并发读写性能瓶颈？

01-16

27｜LSM Tree：LevelDB的索引是如何建立的？

01-16

26｜B+ Tree：PostgreSQL 的索引是如何建立的？

01-16

25｜一致性哈希：如何在集群上合理分配流量？

01-16

24｜UUID：如何高效生成全局的唯一ID？

01-16

23｜Raft：分布式系统间如何达成共识？

01-16

22｜PageRank：谷歌是如何计算网页排名的

01-16

21｜分而治之：MapReduce如何解决大规模分布式计算问题

01-16

20｜滑动窗口：TCP是如何进行流量控制和拥塞控制的？

01-16

19｜选路算法：距离矢量算法为什么会产生无穷计算问题？

01-16

18｜选路算法：链路状态算法是如何分发全局信息的

01-16

17｜选路算法：Dijkstra是如何解决最短路问题的？

01-16

16｜日志型文件系统：写入文件的时候断电了会发生什么？

01-16

15｜LRU：在虚拟内存中页面是如何置换的？

01-16

14｜调度算法：操作系统中的进程是如何调度的？

01-16

13｜哈夫曼树：HTTP2.0是如何更快传输协议头的？

01-16

12｜拓扑排序：Webpack是如何确定构建顺序的？

01-16

11｜字符串匹配：如何实现最快的grep工具

01-16

10｜搜索算法： 一起来写一个简单的爬虫？

01-16

09｜二分：如何高效查询Kafka中的消息？

01-16

08｜外部排序：如何为TB级数据排序？

01-16

07｜堆：如何实现一个高效的优先队列？

01-16

06｜TreeMap：红黑树真的有那么难吗？

01-16

05｜HashMap：一个优秀的散列表是怎么来的？

01-16

04｜栈：函数调用的秘密究竟是什么？

01-16

03｜双端队列：并行计算中的工作窃取算法如何实现？

01-16

02｜双向链表：list如何实现高效地插入与删除？

01-16

01｜动态数组：按需分配的vector为什么要二倍扩容？

01-16

先导篇｜诶，这个 git diff 好像不是很直观？

01-16

开篇词｜真实世界的算法，和你想的不一样

01-16

加餐｜谈谈Kong Ingress Controller

01-15

结束语｜是终点，更是起点

01-15

期末测试｜来赴一场满分之约！

01-15

33｜视频：高级篇实操总结

01-15

32｜实战演练：玩转Kubernetes（3）

01-15

31｜网络通信：CNI是怎么回事？又是怎么工作的？

01-15

30｜系统监控：如何使用Metrics Server和Prometheus？

01-15

29｜集群管理：如何用名字空间分隔系统资源？

01-15

28｜应用保障：如何让Pod运行得更健康？

01-15

27｜滚动更新：如何做到平滑的应用升级降级？

01-15

26｜StatefulSet：怎么管理有状态的应用？

01-15

25｜PersistentVolume + NFS：怎么使用网络共享存储？

01-15

24｜PersistentVolume：怎么解决数据持久化的难题？

01-15

加餐｜docker-compose：单机环境下的容器编排工具

01-15

23｜视频：中级篇实操总结

01-15

22｜实战演练：玩转Kubernetes（2）

01-15

21｜Ingress：集群进出流量的总管

01-15

20｜Service：微服务架构的应对之道

01-15

19｜Daemonset：忠实可靠的看门狗

01-15

18｜Deployment：让应用永不宕机

01-15

17｜更真实的云原生：实际搭建多节点的Kubernetes集群

01-15

16｜视频：初级篇实操总结

01-15

15｜实战演练：玩转Kubernetes（1）

01-15

14｜ConfigMap/Secret：怎样配置、定制我的应用

01-15

13｜Job/CronJob：为什么不直接用Pod来处理业务？

01-15

12｜Pod：如何理解这个Kubernetes里最核心的概念？

01-15

11｜YAML：Kubernetes世界里的通用语

01-15

加餐｜Kubernetes“弃用Docker”是怎么回事？

01-15

10｜自动化的运维管理：探究Kubernetes工作机制的奥秘

01-15

09｜走近云原生：如何在本机搭建小巧完备的Kubernetes环境

01-15

08｜视频：入门篇实操总结

01-15

07｜实战演练：玩转Docker

01-15

06｜打破次元壁：容器该如何与外界互联互通

01-15

05｜镜像仓库：该怎样用好Docker Hub这个宝藏

01-15

04｜创建容器镜像：如何编写正确、高效的Dockerfile

01-15

03｜容器化的应用：会了这些你就是Docker高手

01-15

02｜被隔离的进程：一起来看看容器的本质

01-15

01｜初识容器：万事开头难

01-15

课前准备｜动手实践才是最好的学习方式

01-15

开篇词｜迎难而上，做云原生时代的弄潮儿

01-15

期末考试 |《全链路压测实战30讲》满分试卷，等你来挑战！

01-15

结束语 | 做能落地的全链路压测项目

01-15

35 | 压测报告：怎样写出一份让老板满意的报告？

01-15

34 | 容量规划：如何精准地对生产系统做容量预估？

01-15

33 | 异常场景：如何模拟线上不同组件的异常场景？

01-15

32 | 稳定性场景：怎样搞定线上稳定性场景？

01-15

31 | 容量场景：决定线上容量场景的关键因素是什么？

01-15

30 | 预压测：如何基于小流量快速验证容量压测效果？

01-15

29 | 基准场景：一个案例，带你搞懂基准场景的关键要点

01-15

28 | 定向监控：怎样快速发现业务异常？

01-15

27 | 全局监控（下）：如何快速落地全局监控？

01-15

26 | 全局监控（上）：如何快速落地全局监控？

01-15

25 | 环境搭建：我们的系统是怎么搭建起来的？

01-15

24 | 压测平台：如何改造分布式调度平台？

01-15

23 | 压测平台：如何改造对象存储和性能监控？

01-15

22 | 压测平台：如何解决 GoReplay 动态数据关联？

01-15

21 | 压测平台：高效搭建 GoReplay 压测平台

01-15

20 | Mock：如何屏蔽第三方接口的影响？

01-15

19｜日志隔离：如何落地日志隔离？

01-15

18 | 流量隔离：RabbitMQ 消息隔离是怎么做的？

01-15

17 | 流量隔离：MongoDB 数据库隔离是怎么做的？

01-15

16 | 流量隔离：Redis 缓存隔离是怎么做的？

01-15

15 | 流量隔离：MySQL数据库隔离是怎么做的？

01-15

14 | 标记透传：如何基于微服务技术进行标记透传？

01-15

13 | 标记透传：微服务系统如何做标记透传方案选型？

01-15

12 | 链路追踪：如何对一个具体的项目进行追踪改造？

01-15

11 | 链路追踪：如何选择一款适合自己项目的工具？

01-15

10 | 场景执行：压测执行过程中的关键步骤是什么？

01-15

09 | 压测模型：如何建立一套完整的全链路压测模型？

01-15

08 | 基础设施：全链路压测的环境有什么特点？

01-15

07 | 全栈监控：如何设计全栈监控策略？

01-15

06 | 流量构建：流量平台如何选型？

01-15

05 | 铺底数据：真实的压测数据应该做成什么样子？

01-15

04 | 核心链路：如何梳理符合真实业务场景的核心链路？

01-15

03 | 压测方案：你是否忽略了一个重量级文档？

01-15

02 | RESAR 全链路流程：如何搞定所有容量场景？

01-15

01 | 全链路压测：为什么很多测试人员迷信它？

01-15

开篇词 | 打破认知神话，做接地气的全链路压测

01-15

新书 |《跃迁：从技术到管理的硅谷路径》

01-15

尾声：成长不是顿悟，而是练习

01-15

36 | 如何对更多的工作说“不”

01-15

35 | 理解并建立自己的工作弹性

01-15

34 | 如何从错误中成长？

01-15

33 | 技术人的犯错成本

01-15

32 | 硅谷人如何做 Code Review

01-15

31 | 工程师、产品经理、数据工程师是如何一起工作的？

01-15

30 | 编程马拉松

01-15

29 | 说说硅谷互联网公司的开发流程

01-15

28 | 如何激发团队人员的责任心

01-15

27 | 小议Java语言

01-15

26 | 如何做自己的职场规划？

01-15

25 | 兼容并包的领导方式

01-15

24 | 编程语言漫谈

01-15

23 | 如何处理工作中的人际关系？

01-15

22 | 不要做微观的管理者

01-15

21 | 每个工程师都应该了解的：中美在支付技术和大环境下的差异

01-15

20 | 项目管理中的三个技巧

01-15

19 | 硅谷面试：那些你应该知道的事儿

01-15

18 | 每个工程师都应该了解的：API 的设计和实现

01-15

17 | 管理者不用亲力亲为：关键是什么？

01-15

16 | 技术人如何建立个人影响力?

01-15

15 | 每个工程师都应该了解的：系统拆分

01-15

14 | 硅谷人到底忙不忙？

01-15

13 | 管理者在进行工作分配时，会考虑哪些问题？

01-15

12 | 每个工程师都应该了解的：数据库知识

01-15

11 | 管理和被管理：期望值差异

01-15

10 | 项目延期了，作为负责人该怎么办？

01-15

09 | 每个工程师都应该了解的：大数据时代的算法

01-15

08 | 说说硅谷公司中的一对一沟通

01-15

07 | 当别人给我们提意见时，该如何应对？

01-15

06 | 每个工程师都应该了解的：聊聊幂等

01-15

05 | 当我们给别人提意见时，要注意些什么？

01-15

04 | 如何帮助团队成员成长

01-15

03 | 每个工程师都应该了解的：A/B测试

01-15

02 | Bug引发事故，该不该追究责任？

01-15

01 | 职场分身术：从给答案到做引导

01-15

开篇词 | 从工程师到管理者，我的思考与实践

01-15

期末考试｜《Go语言项目开发实战》满分试卷，等你来挑战！

01-12

结束语 | 如何让自己的 Go 研发之路走得更远？

01-12

直播加餐｜如何从小白进阶成 Go 语言专家？

01-12

特别放送 | 分布式作业系统设计和实现

01-12

特别放送 | Go Modules实战

01-12

特别放送 | IAM排障指南

01-12

特别放送 | Go Modules依赖包管理全讲

01-12

特别放送 | 给你一份Go项目中最常用的Makefile核心语法

01-12

特别放送 | 给你一份清晰、可直接套用的Go编码规范

01-12

51 | 基于 GitHub Actions 的 CI 实战

01-12

50 | 服务编排（下）：基于Helm的服务编排部署实战

01-12

49 | 服务编排（上）：Helm服务编排基础知识

01-12

48 | IAM 容器化部署实战

01-12

47 | 如何编写Kubernetes资源定义文件？

01-12

46 | 如何制作Docker镜像？

01-12

45｜基于Kubernetes的云原生架构设计

01-12

44｜技术演进（下）：软件架构和应用生命周期技术演进之路

01-12

43｜技术演进（上）：虚拟化技术演进之路

01-12

42 | 软件部署实战（下）：IAM系统安全加固、水平扩缩容实战

01-12

41 | 软件部署实战（中）：IAM 系统生产环境部署实战

01-12

40 | 软件部署实战（上）：部署方案及负载均衡、高可用组件介绍

01-12

39｜性能分析（下）：API Server性能测试和调优实战

01-12

38｜性能分析（上）：如何分析 Go 语言代码的性能？

01-12

37 | 代码测试（下）：Go 语言其他测试类型及 IAM 测试介绍

01-12

36 | 代码测试（上）：如何编写 Go 语言单元测试和性能测试用例？

01-12

35 | 效率神器：如何设计和实现一个命令行客户端工具？

01-12

34 | SDK 设计（下）：IAM项目Go SDK设计和实现

01-12

33 | SDK 设计（上）：如何设计出一个优秀的 Go SDK？

01-12

32 | 数据处理：如何高效处理应用程序产生的数据？

01-12

31 | 数据流：通过iam-authz-server设计，看数据流服务的设计

01-12

30 | ORM：CURD 神器 GORM 包介绍及实战

01-12

29｜控制流（下）：iam-apiserver服务核心功能实现讲解

01-12

28 | 控制流（上）：通过iam-apiserver设计，看Web服务的构建

01-12

27 | 权限模型：5大权限模型是如何进行资源授权的？

01-12

26 | IAM项目是如何设计和实现访问认证功能的？

01-12

25 | 认证机制：应用程序如何进行访问认证？

01-12

24 | Web 服务：Web 服务核心功能有哪些，如何实现？

01-12

23 | 应用构建实战：如何构建一个优秀的企业应用框架？

01-12

22 | 应用构建三剑客：Pflag、Viper、Cobra 核心功能介绍

01-12

21 | 日志处理（下）：手把手教你从 0 编写一个日志包

01-12

20 | 日志处理（上）：如何设计日志包并记录日志？

01-12

19 | 错误处理（下）：如何设计错误包？

01-12

18 | 错误处理（上）：如何设计一套科学的错误码？

01-12

17 | API 文档：如何生成 Swagger API 文档 ？

01-12

16 | 代码检查：如何进行静态代码检查？

01-12

15 | 研发流程实战：IAM项目是如何进行研发流程管理的？

01-12

14 | 项目管理：如何编写高质量的Makefile？

01-12

13 | API 风格（下）：RPC API介绍

01-12

12 | API 风格（上）：如何设计RESTful API？

01-12

11 | 设计模式：Go常用设计模式概述

01-12

10 | 设计方法：怎么写出优雅的 Go 项目？

01-12

09 | 研发流程设计（下）：如何管理应用的生命周期？

01-12

08 | 研发流程设计（上）：如何设计 Go 项目的开发流程？

01-12

07 | 工作流设计：如何设计合理的多人开发模式？

01-12

06 | 目录结构设计：如何组织一个可维护、可扩展的代码目录？

01-12

05 | 规范设计（下）：commit 信息风格迥异、难以阅读，如何规范？

01-12

04 | 规范设计（上）：项目开发杂乱无章，如何规范？

01-12

03 | 项目部署：如何快速部署 IAM 系统？

01-12

02 | 环境准备：如何安装和配置一个基本的 Go 开发环境？

01-12

01 | IAM系统概述：我们要实现什么样的 Go 项目？

01-12

开篇词 | 从 0 开始搭建一个企业级 Go 应用

01-12

结课测试 | 这些HTTP协议知识，你真的掌握了吗？

08-22

结束语 | 做兴趣使然的Hero

08-22

罗剑锋老师出新课了？

08-22

44 | 先睹为快：HTTP/3实验版本长什么样子？

08-22

43 | 如何进行Docker实验环境搭建？

08-22

42 | DHE/ECDHE算法的原理

08-22

41 | Linux/Mac实验环境搭建与URI查询参数

08-22

40 | HTTP性能优化面面观（下）

08-22

39 | HTTP性能优化面面观（上）

08-22

38 | WebSocket：沙盒里的TCP

08-22

37 | CDN：加速我们的网络服务

08-22

36 | WAF：保护我们的网络服务

08-22

35 | OpenResty：更灵活的Web服务器

08-22

34 | Nginx：高性能的Web服务器

08-22

33 | 我应该迁移到HTTP/2吗？

08-22

32 | 未来之路：HTTP/3展望

08-22

31 | 时代之风（下）：HTTP/2内核剖析

08-22

30 | 时代之风（上）：HTTP/2特性概览

08-22

29 | 我应该迁移到HTTPS吗？

08-22

28 | 连接太慢该怎么办：HTTPS的优化

08-22

27 | 更好更快的握手：TLS1.3特性解析

08-22

26 | 信任始于握手：TLS1.2连接过程解析

08-22

25 | 固若金汤的根本（下）：数字签名与证书

08-22

24 | 固若金汤的根本（上）：对称加密与非对称加密

08-22

23 | HTTPS是什么？SSL/TLS又是什么？

08-22

22 | 冷链周转：HTTP的缓存代理

08-22

21 | 良心中间商：HTTP的代理服务

08-22

20 | 生鲜速递：HTTP的缓存控制

08-22

19 | 让我知道你是谁：HTTP的Cookie机制

08-22

18 | 四通八达：HTTP的重定向和跳转

08-22

17 | 排队也要讲效率：HTTP的连接管理

08-22

16 | 把大象装进冰箱：HTTP传输大文件的方法

08-22

15 | 海纳百川：HTTP的实体数据

08-22

14 | HTTP有哪些优点？又有哪些缺点？

08-22

13 | HTTP有哪些特点？

08-22

12 | 响应状态码该怎么用？

08-22

11 | 你能写出正确的网址吗？

08-22

10 | 应该如何理解请求方法？

08-22

09 | HTTP报文是什么样子的？

08-22

08 | 键入网址再按下回车，后面究竟发生了什么？

08-22

07 | 自己动手，搭建HTTP实验环境

08-22

06 | 域名里有哪些门道？

08-22

05 | 常说的“四层”和“七层”到底是什么？“五层”“六层”哪去了？

08-22

04 | HTTP世界全览（下）：与HTTP相关的各种协议

08-22

03 | HTTP世界全览（上）：与HTTP相关的各种概念

08-22

02 | HTTP是什么？HTTP又不是什么？

08-22

01 | 时势与英雄：HTTP的前世今生

08-22

开篇词｜To Be a HTTP Hero

08-22

记一次Redisson isExists方法失效问题排查

08-17

06 | switch表达式：怎么简化多情景操作？

06-13

用户故事 | 与新特性开发者对话

06-13

用户故事 | 保持好奇心，积极拥抱变化

06-13

期末测试｜来赴一场满分之约！

06-13

结束语 | Java的未来，依然是星辰大海

06-13

18 | 模块系统：怎么模块化你的应用程序？

06-13

17 | 模块系统：为什么Java需要模块化？

06-13

16 | 改进的废弃，怎么避免使用废弃的特性？

06-13

15 | 现代密码：你用的加密算法过时了吗？

06-13

14 | 禁止空指针，该怎么避免崩溃的空指针？

06-13

13 | 外部函数接口，能不能取代Java本地接口？

06-13

12 | 外部内存接口：零拷贝的障碍还有多少？

06-13

11 | 矢量运算：Java的机器学习要来了吗？

06-13

10 | Flow，是异步编程的终极选择吗？

06-13

09 | 异常恢复，付出的代价能不能少一点？

06-13

08 | 抛出异常，是不是错误处理的第一选择？

06-13

07 | switch匹配：能不能适配不同的类型？

06-13

05 | 类型匹配：怎么切除臃肿的强制转换？

06-13

04 | 封闭类：怎么刹住失控的扩展性？

06-13

03 | 档案类：怎么精简地表达不可变数据？

06-13

02 | 文字块：怎么编写所见即所得的字符串？

06-13

01 | JShell：怎么快速验证简单的小问题？

06-13

开篇词 | 拥抱Java新特性，像设计者一样工作和思考

06-13

结束语 | 站在聚光灯下

05-05

35 | 分布式事务：使用 Nacos+Seata 实现 TCC 补偿模式

05-05

34 | 分布式事务：使用 Nacos+Seata 实现AT模式

05-05

33 | 分布式事务：搭建 Seata 服务器

05-05

32 | Alibaba Seata 框架：什么是分布式事务？

05-05

31 | 消息驱动：如何通过 RabbitMQ 插件实现延迟消息？

05-05

30 | 消息驱动：如何高效处理 Stream 中的异常？

05-05

29 | 消息驱动：如何集成 Stream 实现消息驱动？

05-05

28 | 消息驱动：谁说消息队列只能削峰填谷？

05-05

27 | 微服务网关：如何借助 Nacos 实现动态路由规则？

05-05

26 | 微服务网关：如何设置请求转发、跨域和限流规则？

05-05

25 | 微服务网关：Gateway 中的路由和谓词有何应用？

05-05

24 | 为什么微服务架构少不了微服务网关？

05-05

23 | 调用链追踪：如何通过 ELK 实现日志检索？

05-05

22 | 调用链追踪：集成 Sleuth 和 Zipkin，实现链路打标

05-05

21 | Sleuth 体系架构：为什么微服务架构需要链路追踪？

05-05

加餐：说透微服务 | 什么是主链路规划？

05-05

20 | Sentinel 实战：如何接入 Nacos 实现规则持久化？

05-05

19 | Sentinel 实战：如何为项目添加异常降级方案？

05-05

18 | Sentinel 实战：如何实施流量整形与限流策略？

05-05

17 | Sentinel 体系结构：什么是服务容错（降级熔断、流量整形）?

05-05

16 | 如何集成 Nacos Config 实现配置项动态刷新？

05-05

15 | 配置中心在微服务中发挥着怎样的作用？

05-05

14 | OpenFeign 实战：OpenFeign 组件有哪些高级玩法？

05-05

13 | OpenFeign 实战：如何实现服务间调用功能？

05-05

12 | OpenFeign：服务间调用组件 OpenFeign 是怎么“隔空取物”的？

05-05

11 | Loadbalancer 实战：通过自定义负载均衡策略实现金丝雀测试

05-05

10 | 集成 Nacos：如何通过服务发现机制向服务提供者发起调用？

05-05

09 | 集成 Nacos：如何将服务提供者注册到 Nacos 服务器？

05-05

08 | 服务治理：Nacos集群环境搭建

05-05

07 | Nacos体系架构：什么是服务治理？

05-05

06 | 牛刀小试：如何搭建优惠券计算服务和用户服务？

05-05

05 | 牛刀小试：如何搭建优惠券模板服务？

05-05

04 | 十八般兵器：如何搭建项目所需的开发环境？

05-05

03 | 初窥门径：我们要搭建一个怎样的微服务实战项目？

05-05

02 | 微服务全家桶：走进 Spring Cloud 的世界

05-05

01 | 是什么推动了单体应用到微服务架构的演进？

05-05

开篇词 | 跟着学，你也能成为微服务高手

05-05

结束语 | 不忘初心

04-23

结课测试 | “Kotlin编程第一课”100分试卷等你来挑战！

04-23

35 | 用Kotlin写一个GitHub Trending App

04-23

34 | Kotlin与Jetpack简直是天生一对！

04-23

33 | Java Android开发者还会有未来吗？

04-23

32 | 图解Flow：原来你是只纸老虎？

04-23

31 | 图解Channel：如何理解它的CSP通信模型？

04-23

30 | CoroutineScope是如何管理协程的？

04-23

29 | Dispatchers是如何工作的？

04-23

28 | launch的背后到底发生了什么？

04-23

加餐五 | 深入理解协程基础元素

04-23

27 | 图解挂起函数：原来你就是个状态机？

04-23

26 | 协程源码的地图：如何读源码才不会迷失？

04-23

25 | 集合操作符：你也会“看完就忘”吗？

04-23

答疑（一）| Java和Kotlin到底谁好谁坏？

04-23

24 | 实战：让KtHttp支持Flow

04-23

23 | 异常：try-catch居然会不起作用？坑！

04-23

22 | 并发：协程不需要处理同步吗？

04-23

21 | select：到底是在选择什么？

04-23

20 | Flow：为什么说Flow是“冷”的？

04-23

19 | Channel：为什么说Channel是“热”的？

04-23

题目解答 | 期中考试版本参考实现

04-23

期中考试 | 用Kotlin实现图片处理程序

04-23

18 | 实战：让KtHttp支持挂起函数

04-23

17 | Context：万物皆为Context？

04-23

16 | Job：协程也有生命周期吗？

04-23

15 | 挂起函数：Kotlin协程的核心

04-23

14 | 如何启动协程？

04-23

13 | 什么是“协程思维模型”？

04-23

春节刷题计划（四）| 一题三解，搞定分式加减法

04-23

春节刷题计划（三）| 一题双解，搞定求解方程

04-23

春节刷题计划（二）| 一题三解，搞定版本号判断

04-23

春节刷题计划（一）| 当Kotlin遇上LeetCode

04-23

加餐四 | 什么是“空安全思维”？

04-23

加餐三 | 什么是“不变性思维”？

04-23

加餐二 | 什么是“表达式思维”？

04-23

12 | 实战：用Kotlin实现一个网络请求框架KtHttp

04-23

11 | 注解与反射：进阶必备技能

04-23

10 | 泛型：逆变or协变，傻傻分不清？

04-23

09 | 委托：你为何总是被低估？

04-23

加餐一 | 初识Kotlin函数式编程

04-23

08 | 实战：用Kotlin写一个英语词频统计程序

04-23

07 | 高阶函数：为什么说函数是Kotlin的“一等公民”？

04-23

06 | 扩展：你的能力边界到底在哪里？

04-23

05 | object关键字：你到底有多少种用法？

04-23

04 | 实战：构建一个Kotlin版本的四则运算计算器

04-23

03 | Kotlin原理：编译器在幕后干了哪些“好事”？

04-23

02 | 面向对象：理解Kotlin设计者的良苦用心

04-23

01 | Kotlin基础语法：正式开启学习之旅

04-23

开篇词 | 入门Kotlin有多容易，精通Kotlin就有多难

04-23

加餐06 | BCC：入门eBPF的前端工具

04-04

加餐05 | eBPF：怎么更加深入地查看内核中的函数？

04-04

加餐04 | 理解ftrace（2）：怎么理解ftrace背后的技术tracepoint和kprobe？

04-04

加餐03 | 理解ftrace（1）：怎么应用ftrace查看长延时内核函数？

04-04

加餐02 | 理解perf：怎么用perf聚焦热点函数？

04-04

加餐01 | 案例分析：怎么解决海量IPVS规则带来的网络延时抖动问题？

04-04

加餐福利 | 课后思考题答案合集

04-04

用户故事 | 莫名：相信坚持的力量，终会厚积薄发

04-04

结课测试｜这些容器技术的问题，你都掌握了么？

04-04

结束语 | 跳出舒适区，突破思考的惰性

04-04

20 | 容器安全（2）：在容器中，我不以root用户来运行程序可以吗？

04-04

19 | 容器安全（1）：我的容器真的需要privileged权限吗?

04-04

18 | 容器网络配置（3）：容器中的网络乱序包怎么这么高？

04-04

17｜容器网络配置（2）：容器网络延时要比宿主机上的高吗?

04-04

16 | 容器网络配置（1）：容器网络不通了要怎么调试?

04-04

15 | 容器网络：我修改了/proc/sys/net下的参数，为什么在容器中不起效？

04-04

14 | 容器中的内存与I/O：容器写文件的延时为什么波动很大？

04-04

13 | 容器磁盘限速：我的容器里磁盘读写为什么不稳定?

04-04

12 | 容器文件Quota：容器为什么把宿主机的磁盘写满了？

04-04

11 | 容器文件系统：我在容器中读写文件怎么变慢了？

04-04

10 | Swap：容器可以使用Swap空间吗？

04-04

09 | Page Cache：为什么我的容器内存使用量总是在临界点?

04-04

08 | 容器内存：我的容器为什么被杀了？

04-04

07 | Load Average：加了CPU Cgroup限制，为什么我的容器还是很慢？

04-04

06 | 容器CPU（2）：如何正确地拿到容器CPU的开销？

04-04

05｜容器CPU（1）：怎么限制容器的CPU使用？

04-04

04 | 理解进程（3）：为什么我在容器中的进程被强制杀死了？

04-04

03｜理解进程（2）：为什么我的容器里有这么多僵尸进程？

04-04

02 | 理解进程（1）：为什么我在容器中不能kill 1号进程？

04-04

01 | 认识容器：容器的基本操作和实现原理

04-04

开篇词 | 一个态度两个步骤，成为容器实战高手

04-04

期末测试 | 有关Java性能调优，你掌握了多少呢？

03-06

结束语 | 栉风沐雨，砥砺前行！

03-06

44 | 记一次双十一抢购性能瓶颈调优

03-06

43 | 如何使用缓存优化系统性能？

03-06

42 | 电商系统的分布式事务调优

03-06

41 | 如何设计更优的分布式锁？

03-06

40 | 答疑课堂：MySQL中InnoDB的知识点串讲

03-06

39 | 数据库参数设置优化，失之毫厘差之千里

03-06

38 | 电商系统表设计优化案例分析

03-06

37 | 什么时候需要分表分库？

03-06

36 | 记一次线上SQL死锁事故：如何避免死锁？

03-06

35 | MySQL调优之索引：索引的失效与优化

03-06

34 | MySQL调优之事务：高并发场景下的数据库事务调优

03-06

33 | MySQL调优之SQL语句：如何写出高性能SQL语句？

03-06

32 | 答疑课堂：模块五思考题集锦

03-06

31 | 装饰器模式：如何优化电商系统中复杂的商品价格策略？

03-06

30 | 生产者消费者模式：电商库存设计优化

03-06

29 | 如何使用设计模式优化并发编程？

03-06

28 | 原型模式与享元模式：提升系统性能的利器

03-06

27 | 单例模式：如何创建单一对象优化系统性能？

03-06

26 | 答疑课堂：模块四热点问题解答

03-06

25 | 内存持续上升，我该如何排查问题？

03-06

24 | 如何优化JVM内存分配？

03-06

23 | 如何优化垃圾回收机制？

03-06

22 | 深入JVM即时编译器JIT，优化Java编译

03-06

21 | 磨刀不误砍柴工：欲知JVM调优先了解JVM内存模型

03-06

加餐 | 什么是数据的强、弱一致性？

03-06

20 | 答疑课堂：模块三热点问题解答

03-06

19 | 如何用协程来优化多线程业务？

03-06

18 | 如何设置线程池大小？

03-06

17 | 并发容器的使用：识别不同场景下最优容器

03-06

16 | 多线程调优（下）：如何优化多线程上下文切换？

03-06

15 | 多线程调优（上）：哪些操作导致了上下文切换？

03-06

14 | 多线程之锁优化（下）：使用乐观锁优化并行操作

03-06

13 | 多线程之锁优化（中）：深入了解Lock同步锁的优化方法

03-06

12 | 多线程之锁优化（上）：深入了解Synchronized同步锁的优化方法

03-06

11 | 答疑课堂：深入了解NIO的优化实现原理

03-06

10 | 网络通信优化之通信协议：如何优化RPC网络通信？

03-06

09 | 网络通信优化之序列化：避免使用Java序列化

03-06

08 | 网络通信优化之I/O模型：如何解决高并发下I/O瓶颈？

03-06

07 | 深入浅出HashMap的设计与优化

03-06

06 | Stream如何提高遍历集合效率？

03-06

加餐 | 推荐几款常用的性能测试工具

03-06

05 | ArrayList还是LinkedList？使用不当性能差千倍

03-06

04 | 慎重使用正则表达式

03-06

03 | 字符串性能优化不容小觑，百M内存轻松存储几十G数据

03-06

02 | 如何制定性能调优策略？

03-06

01 | 如何制定性能调优标准？

03-06

开篇词 | 怎样才能做好性能调优？

03-06

期末测试 | 这些Kafka核心要点，你都掌握了吗？

02-28

结束语 | 以梦为马，莫负韶华！

02-28

用户故事 | 黄云：行百里者半九十

02-28

加餐 | 搭建开发环境、阅读源码方法、经典学习资料大揭秘

02-28

42 | Kafka Streams在金融领域的应用

02-28

41 | Kafka Streams DSL开发实例

02-28

40 | Kafka Streams与其他流处理平台的差异在哪里？

02-28

39 | 从0搭建基于Kafka的企业级实时日志流处理平台

02-28

38 | 调优Kafka，你做到了吗？

02-28

37 | 主流的Kafka监控框架

02-28

36 | 你应该怎么监控Kafka？

02-28

35 | 跨集群备份解决方案MirrorMaker

02-28

34 | 云环境下的授权该怎么做？

02-28

33 | Kafka认证机制用哪家？

02-28

32 | KafkaAdminClient：Kafka的运维利器

02-28

31 | 常见工具脚本大汇总

02-28

30 | 怎么重设消费者组位移？

02-28

29 | Kafka动态配置了解下？

02-28

28 | 主题管理知多少?

02-28

27 | 关于高水位和Leader Epoch的讨论

02-28

26 | 你一定不能错过的Kafka控制器

02-28

25 | 消费者组重平衡全流程解析

02-28

24 | 请求是怎么被处理的？

02-28

23 | Kafka副本机制详解

02-28

22 | 消费者组消费进度监控都怎么实现？

02-28

21 | Java 消费者是如何管理TCP连接的?

02-28

20 | 多线程开发消费者实例

02-28

19 | CommitFailedException异常怎么处理？

02-28

18 | Kafka中位移提交那些事儿

02-28

17 | 消费者组重平衡能避免吗？

02-28

16 | 揭开神秘的“位移主题”面纱

02-28

15 | 消费者组到底是什么？

02-28

14 | 幂等生产者和事务生产者是一回事吗？

02-28

13 | Java生产者是如何管理TCP连接的？

02-28

12 | 客户端都有哪些不常见但是很高级的功能？

02-28

11 | 无消息丢失配置怎么实现？

02-28

10 | 生产者压缩算法面面观

02-28

09 | 生产者消息分区机制原理剖析

02-28

08 | 最最最重要的集群参数配置（下）

02-28

07 | 最最最重要的集群参数配置（上）

02-28

06 | Kafka线上集群部署方案怎么做？

02-28

05 | 聊聊Kafka的版本号

02-28

04 | 我应该选择哪种Kafka？

02-28

03 | Kafka只是消息引擎系统吗？

02-28

02 | 一篇文章带你快速搞定Kafka术语

02-28

01 | 消息引擎系统ABC

02-28

开篇词 | 为什么要学习Kafka？

02-28

第二季回归丨这次我们一起实战后端存储

02-20

结束语 | 程序员如何构建知识体系？

02-20

期末测试 | 消息队列100分试卷等你来挑战！

02-20

期中测试丨10个消息队列热点问题自测

02-20

35 | 答疑解惑（三）：主流消息队列都是如何存储消息的？

02-20

34 | 动手实现一个简单的RPC框架（四）：服务端

02-20

33 | 动手实现一个简单的RPC框架（三）：客户端

02-20

32 | 动手实现一个简单的RPC框架（二）：通信与序列化

02-20

31 | 动手实现一个简单的RPC框架（一）：原理和程序的结构

02-20

30 | 流计算与消息（二）：在流计算中使用Kafka链接计算任务

02-20

29 | 流计算与消息（一）：通过Flink理解流计算的原理

02-20

28 | 答疑解惑（二）：我的100元哪儿去了？

02-20

27 | Pulsar的存储计算分离设计：全新的消息队列设计思路

02-20

26 | MQTT协议：如何支持海量的在线IoT设备?

02-20

25 | RocketMQ与Kafka中如何实现事务？

02-20

24 | Kafka的协调服务ZooKeeper：实现分布式系统的“瑞士军刀”

02-20

23 | RocketMQ客户端如何在集群中找到正确的节点？

02-20

22 | Kafka和RocketMQ的消息复制实现的差异点在哪？

02-20

21 | Kafka Consumer源码分析：消息消费的实现过程

02-20

20 | RocketMQ Producer源码分析：消息生产的实现过程

02-20

19 | 数据压缩：时间换空间的游戏

02-20

18 | 如何用硬件同步原语（CAS）替代锁？

02-20

17 | 如何正确使用锁保护共享数据，协调异步线程？

02-20

16 | 缓存策略：如何使用缓存来减少磁盘IO？

02-20

15 | Kafka如何实现高性能IO？

02-20

加餐 | JMQ的Broker是如何异步处理消息的？

02-20

14 | 内存管理：如何避免内存溢出和频繁的垃圾回收？

02-20

13 | 传输协议：应用程序之间对话的语言

02-20

12 | 序列化与反序列化：如何通过网络传输结构化的数据？

02-20

11 | 如何实现高性能的异步网络传输？

02-20

10 | 如何使用异步设计提升系统性能？

02-20

09 | 学习开源代码该如何入手？

02-20

08 | 答疑解惑（一） : 网关如何接收服务端的秒杀结果？

02-20

07 | 消息积压了该如何处理？

02-20

06 | 如何处理消费过程中的重复消息？

02-20

05 | 如何确保消息不会丢失?

02-20

04 | 如何利用事务消息实现分布式事务？

02-20

03 | 消息模型：主题和队列有什么区别？

02-20

02 | 该如何选择消息队列？

02-20

01 | 为什么需要消息队列？

02-20

预习 | 怎样更好地学习这门课？

02-20

开篇词 | 优秀的程序员，你的技术栈中不能只有“增删改查”

02-20

MySQL是怎样运行的.pdf

02-18

期末测试｜对于性能优化，你掌握了多少呢？

02-12

毕业问卷获奖用户名单

02-12

来领奖啦！你填写毕业问卷了吗？

02-12

结束语 | 从业 IT 20年后，我将最看重什么？

02-12

加餐7｜深入剖析HTTP/3协议

02-12

加餐6｜分布式系统的本质是什么？

02-12

加餐5 | 如何理解分布式系统？

02-12

大咖助场4｜傅健：那些年，影响我们达到性能巅峰的常见绊脚石（下）

02-12

大咖助场3｜傅健：那些年，影响我们达到性能巅峰的常见绊脚石（上）

02-12

加餐4｜百万并发下Nginx的优化之道

02-12

大咖助场2｜庄振运：与程序员相关的SSD性能知识

02-12

大咖助场1 | 李玥：高并发场景下如何优化微服务的性能?

02-12

加餐3 | 大厂面试到底在考些什么？

02-12

30 | 如何权衡关系数据库与NoSQL数据库？

02-12

29 | 流式计算：如何通过集群实现实时计算？

02-12

28 | MapReduce：如何通过集群实现离线计算？

02-12

27 | 消息队列：如何基于异步消息提升性能？

02-12

26 | 应用层多播：如何快速地分发内容？

02-12

25 | 过期缓存：如何防止缓存被流量打穿？

02-12

24 | 一致性哈希：如何高效地均衡负载？

02-12

23 | 负载均衡：选择Nginx还是OpenResty？

02-12

22 | NWR算法：如何修改读写模型以提升性能？

02-12

21 | AKF立方体：怎样通过可扩展性来提高性能？

02-12

20 | CAP理论：怎样舍弃一致性去换取性能？

02-12

19 | 如何通过监控找到性能瓶颈？

02-12

加餐2 ｜答疑精选：这些问题你都清楚吗？

02-12

加餐1｜特别福利：陶辉视频课精选

02-12

期中考试｜行至半程，你的收获如何呢？

02-12

18 | 如何通过gRPC实现高效远程过程调用？

02-12

17 | Protobuf是如何进一步提高编码效率的？

02-12

16 | HTTP/2是怎样提升性能的？

02-12

15 | 如何提升HTTP/1.1性能？

02-12

14 | 优化TLS/SSL性能该从何下手？

02-12

13 | 实战：单机如何实现管理百万主机的心跳服务？

02-12

12 | 如何调整TCP拥塞控制的性能？

02-12

11 | 如何修改TCP缓冲区才能兼顾并发数量与传输速度？

02-12

10 | 如何提升TCP四次挥手的性能？

02-12

09 | 如何提升TCP三次握手的性能？

02-12

08 | 事件驱动：C10M是如何实现的？

02-12

07 | 性能好，效率高的一对多通讯该如何实现？

02-12

06 | 锁：如何根据业务场景选择合适的锁？

02-12

05 | 协程：如何快速地实现高并发服务？

02-12

04 | 零拷贝：如何高效地传输文件？

02-12

03 | 索引：如何用哈希表管理亿级对象？

02-12

02 | 内存池：如何提升内存分配的效率？

02-12

01 | CPU缓存：怎样写代码能够让CPU执行得更快？

02-12

开篇词 | 万变不离其宗，性能优化也有章可循

02-12

结束语 | 从学习Redis到向Redis学习

02-09

期末测试 | 这些Redis核心知识，你都掌握了吗？

02-09

加餐（七） | 从微博的Redis实践中，我们可以学到哪些经验？

02-09

加餐（六）| Redis的使用规范小建议

02-09

加餐（五） | Redis有哪些好用的运维工具？

02-09

加餐（四） | Redis客户端如何与服务器端交换命令和数据？

02-09

加餐（三）| 用户Kaito：我希望成为在压力中成长的人

02-09

加餐（二）| 用户Kaito：我是如何学习Redis的？

02-09

加餐（一）| 经典的Redis学习资料有哪些？

02-09

41 | 第35～40讲课后思考题答案及常见问题答疑

02-09

40 | Redis的下一步：基于NVM内存的实践

02-09

39 | Redis 6.0的新特性：多线程、客户端缓存与安全

02-09

期中测试题答案 | 这些问题，你都答对了吗？

02-09

期中测试题 | 一套习题，测出你的掌握程度

02-09

38 | 通信开销：限制Redis Cluster规模的关键因素

02-09

37 | 数据分布优化：如何应对数据倾斜？

02-09

36 | Redis支撑秒杀场景的关键技术和实践都有哪些？

02-09

35 | Codis VS Redis Cluster：我该选择哪一个集群方案？

02-09

34 | 第23~33讲课后思考题答案及常见问题答疑

02-09

33 | 脑裂：一次奇怪的数据丢失

02-09

32 | Redis主从同步与故障切换，有哪些坑？

02-09

31 | 事务机制：Redis能实现ACID属性吗？

02-09

30 | 如何使用Redis实现分布式锁？

02-09

29 | 无锁的原子操作：Redis如何应对并发访问？

02-09

28 | Pika：如何基于SSD实现大容量Redis？

02-09

27 | 缓存被污染了，该怎么办？

02-09

26 | 缓存异常（下）：如何解决缓存雪崩、击穿、穿透难题？

02-09

25 | 缓存异常（上）：如何解决缓存和数据库的数据不一致问题？

02-09

24 | 替换策略：缓存满了怎么办？

02-09

23 | 旁路缓存：Redis是如何工作的？

02-09

22 | 第11～21讲课后思考题答案及常见问题答疑

02-09

21 | 缓冲区：一个可能引发“惨案”的地方

02-09

20 | 删除数据后，为什么内存占用率还是很高？

02-09

19 | 波动的响应延迟：如何应对变慢的Redis？（下）

02-09

18 | 波动的响应延迟：如何应对变慢的Redis？（上）

02-09

17 | 为什么CPU结构也会影响Redis的性能？

02-09

16 | 异步机制：如何避免单线程模型的阻塞？

02-09

15 | 消息队列的考验：Redis有哪些解决方案？

02-09

14 | 如何在Redis中保存时间序列数据？

02-09

13 | GEO是什么？还可以定义新的数据类型吗？

02-09

12 | 有一亿个keys要统计，应该用哪种集合？

02-09

11 | “万金油”的String，为什么不好用了？

02-09

10 | 第1～9讲课后思考题答案及常见问题答疑

02-09

09 | 切片集群：数据增多了，是该加内存还是加实例？

02-09

08 | 哨兵集群：哨兵挂了，主从库还能切换吗？

02-09

07 | 哨兵机制：主库挂了，如何不间断服务？

02-09

06 | 数据同步：主从库如何实现数据一致？

02-09

05 | 内存快照：宕机后，Redis如何实现快速恢复？

02-09

04 | AOF日志：宕机了，Redis如何避免数据丢失？

02-09

03 | 高性能IO模型：为什么单线程Redis能那么快？

02-09

02 | 数据结构：快速的Redis有哪些慢操作？

02-09

01 | 基本架构：一个键值数据库包含什么？

02-09

开篇词 | 这样学Redis，才能技高一筹

02-09

架构实战营 百度网盘

01-12

结课测试｜这些架构技能你都掌握了吗？

12-26

结束语 | 坚持，成就你的技术梦想

12-26

加餐｜业务架构实战营开营了

12-26

加餐｜扒一扒中台皇帝的外衣

12-26

加餐｜单服务器高性能模式性能对比

12-26

第二季回归 | 照着做，你也能顺利晋升！

12-26

致「从0开始学架构」专栏订阅用户

12-26

新书首发 | 《从零开始学架构》

12-26

架构师必读书单 | “华仔，放学别走！” 第5期

12-26

架构师成长之路 | “华仔，放学别走！” 第4期

12-26

如何高效地学习开源项目 | “华仔，放学别走！” 第3期

12-26

架构专栏特别放送 | “华仔，放学别走！” 第2期

12-26

架构专栏特别放送 | “华仔，放学别走！”第1期

12-26

50 | 架构实战：架构设计文档模板

12-26

49 | 谈谈App架构的演进

12-26

48 | 再谈开源项目：如何选择、使用以及二次开发？

12-26

47 | 架构重构内功心法第三式：运筹帷幄

12-26

46 | 架构重构内功心法第二式：合纵连横

12-26

45 | 架构重构内功心法第一式：有的放矢

12-26

44 | 互联网架构模板：“平台”技术

12-26

43 | 互联网架构模板：“用户层”和“业务层”技术

12-26

42 | 互联网架构模板：“网络层”技术

12-26

41 | 互联网架构模板：“开发层”和“服务层”技术

12-26

40 | 互联网架构模板：“存储层”技术

12-26

39 | 互联网技术演进的模式

12-26

38 | 架构师应该如何判断技术演进的方向？

12-26

37 | 微内核架构详解

12-26

36 | 微服务架构最佳实践 - 基础设施篇

12-26

35 | 微服务架构最佳实践 - 方法篇

12-26

34 | 深入理解微服务架构：银弹 or 焦油坑？

12-26

33 | 传统的可扩展架构模式：分层架构和SOA

12-26

32 | 可扩展架构的基本思想和模式

12-26

31 | 如何应对接口级的故障？

12-26

30 | 异地多活设计4步走

12-26

29 | 异地多活设计4大技巧

12-26

28 | 业务高可用的保障：异地多活架构

12-26

27 | 如何设计计算高可用架构？

12-26

26 | 高可用存储架构：集群和分区

12-26

25 | 高可用存储架构：双机架构

12-26

24 | FMEA方法，排除架构可用性隐患的利器

12-26

23 | 想成为架构师，你必须掌握的CAP细节

12-26

22 | 想成为架构师，你必须知道CAP理论

12-26

21 | 高性能负载均衡：算法

12-26

20 | 高性能负载均衡：分类及架构

12-26

19 | 单服务器高性能模式：Reactor与Proactor

12-26

18 | 单服务器高性能模式：PPC与TPC

12-26

17 | 高性能缓存架构

12-26

16 | 高性能NoSQL

12-26

15 | 高性能数据库集群：分库分表

12-26

14 | 高性能数据库集群：读写分离

12-26

13 | 架构设计流程：详细方案设计

12-26

12 | 架构设计流程：评估和选择备选方案

12-26

11 | 架构设计流程：设计备选方案

12-26

10 | 架构设计流程：识别复杂度

12-26

09 | 架构设计原则案例

12-26

08 | 架构设计三原则

12-26

07 | 复杂度来源：低成本、安全、规模

12-26

06 | 复杂度来源：可扩展性

12-26

05 | 复杂度来源：高可用

12-26

04 | 复杂度来源：高性能

12-26

03 | 架构设计的目的

12-26

02 | 架构设计的历史背景

12-26

01 | 架构到底是指什么？

12-26

开篇词 | 照着做，你也能成为架构师！

12-26

用户故事 | 李兆龙：博观而约取，厚积而薄发

11-04

结课测试｜这些分布式数据库的问题，你都掌握了吗？

11-04

结束语 | 享受职业带给你的快乐

11-04

30 | 实践篇大串讲：重难点回顾+思考题答疑+知识全景图

11-04

29 | 产品图鉴：哪些分布式数据库值得看？

11-04

28 | 选型案例：银行是怎么选择分布式数据库的？

11-04

27 | 产品测试：除了性能跑分，还能测个啥？

11-04

26 | 容器化：分布式数据库要不要上云，你想好了吗？

11-04

25 | 容灾与备份：如何设计逃生通道保证业务连续性？

11-04

24 | 全球化部署：如何打造近在咫尺且永不宕机的数据库？

11-04

23 | 数据库查询串讲：重难点回顾+思考题答疑+知识全景图

11-04

22｜RUM猜想：想要读写快还是存储省？又是三选二

11-04

21 | 查询执行引擎：如何让聚合计算加速？

11-04

20 | 关联查询：如何提升多表Join能力？

11-04

19 | 查询性能优化：计算与存储分离架构下有哪些优化思路？

11-04

18 | HTAP是不是赢者通吃的游戏？

11-04

17 | 为什么不建议你使用自增主键？

11-04

16 | 为什么不建议你使用存储过程？

11-04

15 | 分布式事务串讲：重难点回顾+思考题答疑+知识全景图

11-04

14 | 隔离性：实现悲观协议，除了锁还有别的办法吗？

11-04

13 | 隔离性：为什么使用乐观协议的分布式数据库越来越少?

11-04

12 | 隔离性：看不见的读写冲突，要怎么处理？

11-04

11｜隔离性：读写冲突时，快照是最好的办法吗？

11-04

10 | 原子性：如何打破事务高延迟的魔咒？

11-04

09｜原子性：2PC还是原子性协议的王者吗？

11-04

08 | 基础篇大串讲：重难点回顾+思考题答疑+知识全景图

11-04

07 | 数据复制：为什么有时候Paxos不是最佳选择？

11-04

06 | 分片机制：为什么说Range是更好的分片策略？

11-04

05 | 全局时钟：物理时钟和逻辑时钟你Pick谁？

11-04

04 | 架构风格：NewSQL和PGXC到底有啥不一样？

11-04

03｜强一致性：别再用BASE做借口，来看看什么是真正的事务一致性

11-04

02｜强一致性：那么多数据一致性模型，究竟有啥不一样？

11-04

01｜什么是分布式数据库？

11-04

开篇词｜为什么要学习分布式数据库？

11-04

记一次canal server简单压测

09-12

结课测试 | 这些网络协议你都掌握了吗？

09-12

结束语 | 放弃完美主义，执行力就是限时限量认真完成

09-12

第2季回归 | 这次我们来“趣谈Linux操作系统”

09-12

加餐2 | “趣谈网络协议”专栏食用指南

09-12

加餐1 | 创作故事：我是如何创作“趣谈网络协议”专栏的？

09-12

协议专栏特别福利 | 答疑解惑第五期

09-12

协议专栏特别福利 | 答疑解惑第四期

09-12

协议专栏特别福利 | 答疑解惑第三期

09-12

协议专栏特别福利 | 答疑解惑第二期

09-12

协议专栏特别福利 | 答疑解惑第一期

09-12

第40讲 | 搭建一个网络实验环境：授人以鱼不如授人以渔

09-12

第39讲 | 知识串讲：用双十一的故事串起碎片的网络协议（下）

09-12

第38讲 | 知识串讲：用双十一的故事串起碎片的网络协议（中）

09-12

第37讲 | 知识串讲：用双十一的故事串起碎片的网络协议（上）

09-12

第36讲 | 跨语言类RPC协议：交流之前，双方先来个专业术语表

09-12

第35讲 | 二进制类RPC协议：还是叫NBA吧，总说全称多费劲

09-12

第34讲 | 基于JSON的RESTful接口协议：我不关心过程，请给我结果

09-12

第33讲 | 基于XML的SOAP协议：不要说NBA，请说美国职业篮球联赛

09-12

第32讲 | RPC协议综述：远在天边，近在眼前

09-12

第31讲 | 容器网络之Calico：为高效说出善意的谎言

09-12

第30讲 | 容器网络之Flannel：每人一亩三分地

09-12

第29讲 | 容器网络：来去自由的日子，不买公寓去合租

09-12

第28讲 | 云中网络的隔离GRE、VXLAN：虽然住一个小区，也要保护隐私

09-12

第27讲 | 云中的网络QoS：邻居疯狂下电影，我该怎么办？

09-12

第26讲 | 云中的网络安全：虽然不是土豪，也需要基本安全和保障

09-12

第25讲 | 软件定义网络：共享基础设施的小区物业管理办法

09-12

第24讲 | 云中网络：自己拿地成本高，购买公寓更灵活

09-12

第23讲 | 移动网络：去巴塞罗那，手机也上不了脸书

09-12

第22讲 | VPN：朝中有人好做官

09-12

第21讲 | 数据中心：我是开发商，自己拿地盖别墅

09-12

第20讲 | CDN：你去小卖部取过快递么？

09-12

第19讲 | HttpDNS：网络世界的地址簿也会指错路

09-12

第18讲 | DNS协议：网络世界的地址簿

09-12

第17讲 | P2P协议：我下小电影，99%急死你

09-12

第16讲 | 流媒体协议：如何在直播里看到美女帅哥？

09-12

第15讲 | HTTPS协议：点外卖的过程原来这么复杂

09-12

第14讲 | HTTP协议：看个新闻原来这么麻烦

09-12

第13讲 | 套接字Socket：Talk is cheap, show me the code

09-12

第12讲 | TCP协议（下）：西行必定多妖孽，恒心智慧消磨难

09-12

第11讲 | TCP协议（上）：因性恶而复杂，先恶后善反轻松

09-12

第10讲 | UDP协议：因性善而简单，难免碰到“城会玩”

09-12

第9讲 | 路由协议：西出网关无故人，敢问路在何方

09-12

第8讲 | 世界这么大，我想出网关：欧洲十国游与玄奘西行

09-12

第7讲 | ICMP与ping：投石问路的侦察兵

09-12

第6讲 | 交换机与VLAN：办公室太复杂，我要回学校

09-12

第5讲 | 从物理层到MAC层：如何在宿舍里自己组网玩联机游戏？

09-12

第4讲 | DHCP与PXE：IP是怎么来的，又是怎么没的？

09-12

第3讲 | ifconfig：最熟悉又陌生的命令行

09-12

第2讲 | 网络分层的真实含义是什么？

09-12

第1讲 | 为什么要学习网络协议？

09-12

开篇词 | 想成为技术牛人？先搞定网络协议！

09-12

结束语 | Kubernetes：赢开发者赢天下

08-25

特别放送 | 基于 Kubernetes 的云原生应用管理，到底应该怎么做？

08-25

特别放送 | 2019 年，容器技术生态会发生些什么？

08-25

52 | 答疑：在问题中解决问题，在思考中产生思考

08-25

51 | 谈谈Kubernetes开源社区和未来走向

08-25

50 | 让日志无处可逃：容器日志收集与管理

08-25

49 | Custom Metrics: 让Auto Scaling不再“食之无味”

08-25

48 | Prometheus、Metrics Server与Kubernetes监控体系

08-25

47 | 绝不仅仅是安全：Kata Containers 与 gVisor

08-25

46 | 解读 CRI 与 容器运行时

08-25

45 | 幕后英雄：SIG-Node与CRI

08-25

44 | Kubernetes GPU管理与Device Plugin机制

08-25

43 | Kubernetes默认调度器的优先级与抢占机制

08-25

42 | Kubernetes默认调度器调度策略解析

08-25

41 | 十字路口上的Kubernetes默认调度器

08-25

40 | Kubernetes的资源模型与资源管理

08-25

39 | 谈谈Service与Ingress

08-25

38 | 从外界连通Service与Service调试“三板斧”

08-25

37 | 找到容器不容易：Service、DNS与服务发现

08-25

36 | 为什么说Kubernetes只有soft multi-tenancy？

08-25

35 | 解读Kubernetes三层网络方案

08-25

34 | Kubernetes网络模型与CNI网络插件

08-25

33 | 深入解析容器跨主机网络

08-25

32 | 浅谈容器网络

08-25

31 | 容器存储实践：CSI插件编写指南

08-25

30 | 编写自己的存储插件：FlexVolume与CSI

08-25

29 | PV、PVC体系是不是多此一举？从本地持久化卷谈起

08-25

28 | PV、PVC、StorageClass，这些到底在说啥？

08-25

27 | 聪明的微创新：Operator工作原理解读

08-25

26 | 基于角色的权限控制：RBAC

08-25

25 | 深入解析声明式API（二）：编写自定义控制器

08-25

24 | 深入解析声明式API（一）：API对象的奥秘

08-25

23 | 声明式API与Kubernetes编程范式

08-25

22 | 撬动离线业务：Job与CronJob

08-25

21 | 容器化守护进程的意义：DaemonSet

08-25

20 | 深入理解StatefulSet（三）：有状态应用实践

08-25

19 | 深入理解StatefulSet（二）：存储状态

08-25

18 | 深入理解StatefulSet（一）：拓扑状态

08-25

17 | 经典PaaS的记忆：作业副本与水平扩展

08-25

16 | 编排其实很简单：谈谈“控制器”模型

08-25

15 | 深入解析Pod对象（二）：使用进阶

08-25

14 | 深入解析Pod对象（一）：基本概念

08-25

13 | 为什么我们需要Pod？

08-25

12 | 牛刀小试：我的第一个容器化应用

08-25

11 | 从0到1：搭建一个完整的Kubernetes集群

08-25

10 | Kubernetes一键部署利器：kubeadm

08-25

09 | 从容器到容器云：谈谈Kubernetes的本质

08-25

08 | 白话容器基础（四）：重新认识Docker容器

08-25

07 | 白话容器基础（三）：深入理解容器镜像

08-25

06 | 白话容器基础（二）：隔离与限制

08-25

05 | 白话容器基础（一）：从进程说开去

08-25

04 | 预习篇 · 小鲸鱼大事记（四）：尘埃落定

08-25

03 | 预习篇 · 小鲸鱼大事记（三）：群雄并起

08-25

02 | 预习篇 · 小鲸鱼大事记（二）：崭露头角

08-25

01 | 预习篇 · 小鲸鱼大事记（一）：初出茅庐

08-25

开篇词 | 打通“容器技术”的任督二脉

08-25

45 | CSP模型：Golang的主力队员

08-14

44 | 协程：更轻量级的线程

08-14

43 | 软件事务内存：借鉴数据库的并发经验

08-14

42 | Actor模型：面向对象原生的并发模型

08-14

41 | 案例分析（四）：高性能数据库连接池HiKariCP

08-14

40 | 案例分析（三）：高性能队列Disruptor

08-14

39 | 案例分析（二）：高性能网络应用框架Netty

08-14

38 | 案例分析（一）：高性能限流器Guava RateLimiter

08-14

37 | 设计模式模块热点问题答疑

08-14

36 | 生产者-消费者模式：用流水线思想提高效率

08-14

35 | 两阶段终止模式：如何优雅地终止线程？

08-14

34 | Worker Thread模式：如何避免重复创建线程？

08-14

33 | Thread-Per-Message模式：最简单实用的分工方法

08-14

32 | Balking模式：再谈线程安全的单例模式

08-14

31 | Guarded Suspension模式：等待唤醒机制的规范实现

08-14

30 | 线程本地存储模式：没有共享，就没有伤害

08-14

29 | Copy-on-Write模式：不是延时策略的COW

08-14

28 | Immutability模式：如何利用不变性解决并发问题？

08-14

27 | 并发工具类模块热点问题答疑

08-14

26 | Fork/Join：单机版的MapReduce

08-14

25 | CompletionService：如何批量执行异步任务？

08-14

24 | CompletableFuture：异步编程没那么难

08-14

23 | Future：如何用多线程实现最优的“烧水泡茶”程序？

08-14

22 | Executor与线程池：如何创建正确的线程池？

08-14

21 | 原子类：无锁工具类的典范

08-14

20 | 并发容器：都有哪些“坑”需要我们填？

08-14

19 | CountDownLatch和CyclicBarrier：如何让多线程步调一致？

08-14

18 | StampedLock：有没有比读写锁更快的锁？

08-14

17 | ReadWriteLock：如何快速实现一个完备的缓存？

08-14

16 | Semaphore：如何快速实现一个限流器？

08-14

15 | Lock和Condition（下）：Dubbo如何用管程实现异步转同步？

08-14

14 | Lock和Condition（上）：隐藏在并发包中的管程

08-14

13 | 理论基础模块热点问题答疑

08-14

12 | 如何用面向对象思想写好并发程序？

08-14

11 | Java线程（下）：为什么局部变量是线程安全的？

08-14

10 | Java线程（中）：创建多少线程才是合适的？

08-14

09 | Java线程（上）：Java线程的生命周期

08-14

08 | 管程：并发编程的万能钥匙

08-14

07 | 安全性、活跃性以及性能问题

08-14

06 | 用“等待-通知”机制优化循环等待

08-14

05 | 一不小心就死锁了，怎么办？

08-14

04 | 互斥锁（下）：如何用一把锁保护多个资源？

08-14

03 | 互斥锁（上）：解决原子性问题

08-14

02 | Java内存模型：看Java如何解决可见性和有序性问题

08-14

01 | 可见性、原子性和有序性问题：并发编程Bug的源头

08-14

Java Agent原理分析

07-29

14 | 查漏补缺：OAuth 2.0 常见问题答疑

07-15

13 | 各大开放平台是如何使用OAuth 2.0的？

07-15

12 | 架构案例：基于OAuth 2.0/JWT的微服务参考架构

07-15

11 | 实战案例：使用Spring Security搭建一套基于JWT的OAuth 2.0架构

07-15

10 | 串讲：OAuth 2.0的工作流程与安全问题

07-15

09 | 实战：利用OAuth 2.0实现一个OpenID Connect用户身份认证协议

07-15

08 | 实践OAuth 2.0时，使用不当可能会导致哪些安全漏洞？

07-15

07 | 如何在移动App中使用OAuth 2.0？

07-15

06 | 除了授权码许可类型，OAuth 2.0还支持什么授权流程？

07-15

05 | 如何安全、快速地接入OAuth 2.0？

07-15

04 | 在OAuth 2.0中，如何使用JWT结构化令牌？

07-15

03 | 授权服务：授权码和访问令牌的颁发流程是怎样的？

07-15

02 | 授权码许可类型中，为什么一定要有授权码？

07-15

01 | OAuth 2.0是要通过什么方式解决什么问题？

07-15

开篇词 | 为什么要学OAuth 2.0？

07-15

第39讲 | 谈谈常用的分布式ID的设计方案？Snowflake是否受冬令时切换影响？

07-11

第38讲 | 对比Java标准NIO类库，你知道Netty是如何实现更高性能的吗？

07-11

第37讲 | 谈谈Spring Bean的生命周期和作用域？

07-11

第36讲 | 谈谈MySQL支持的事务隔离级别，以及悲观锁和乐观锁的原理和应用场景？

07-11

第35讲 | JVM优化Java代码时都做了什么？

07-11

第34讲 | 有人说“Lambda能让Java程序慢30倍”，你怎么看？

07-11

第33讲 | 后台服务出现明显“变慢”，谈谈你的诊断思路？

07-11

第32讲 | 如何写出安全的Java代码？

07-11

第31讲 | 你了解Java应用开发中的注入攻击吗？

07-11

第30讲 | Java程序运行在Docker等容器环境有哪些新问题？

07-11

第29讲 | Java内存模型中的happen-before是什么？

07-11

第28讲 | 谈谈你的GC调优思路?

07-11

第27讲 | Java常见的垃圾收集器有哪些？

07-11

第26讲 | 如何监控和诊断JVM堆内和堆外内存使用？

07-11

第25讲 | 谈谈JVM内存区域的划分，哪些区域可能发生OutOfMemoryError?

07-11

第24讲 | 有哪些方法可以在运行时动态生成一个Java类？

07-11

第23讲 | 请介绍类加载过程，什么是双亲委派模型？

07-11

第22讲 | AtomicInteger底层实现原理是什么？如何在自己的产品代码中应用CAS操作？

07-11

第21讲 | Java并发类库提供的线程池有哪几种？ 分别有什么特点？

07-11

第20讲 | 并发包中的ConcurrentLinkedQueue和LinkedBlockingQueue有什么区别？

07-11

第19讲 | Java并发包提供了哪些并发工具类？

07-11

第18讲 | 什么情况下Java程序会产生死锁？如何定位、修复？

07-11

第17讲 | 一个线程两次调用start()方法会出现什么情况？

07-11

第16讲 | synchronized底层如何实现？什么是锁的升级、降级？

07-11

第15讲 | synchronized和ReentrantLock有什么区别呢？

07-11

第14讲 | 谈谈你知道的设计模式？

07-11

第13讲 | 谈谈接口和抽象类有什么区别？

07-11

第12讲 | Java有几种文件拷贝方式？哪一种最高效？

07-11

第11讲 | Java提供了哪些IO方式？ NIO如何实现多路复用？

07-11

第10讲 | 如何保证集合是线程安全的? ConcurrentHashMap如何实现高效地线程安全？

07-11

第9讲 | 对比Hashtable、HashMap、TreeMap有什么不同？

07-11

第8讲 | 对比Vector、ArrayList、LinkedList有何区别？

07-11

第7讲 | int和Integer有什么区别？

07-11

第6讲 | 动态代理是基于什么原理？

07-11

第5讲 | String、StringBuffer、StringBuilder有什么区别？

07-11

第4讲 | 强引用、软引用、弱引用、幻象引用有什么区别？

07-11

第3讲 | 谈谈final、finally、 finalize有什么不同？

07-11

第2讲 | Exception和Error有什么区别？

07-11

第1讲 | 谈谈你对Java平台的理解？

07-11

开篇词 | 以面试题为切入点，有效提升你的Java内功

07-11

56 | 算法实战（五）：如何用学过的数据结构和算法实现一个短网址系统？

07-11

55 | 算法实战（四）：剖析微服务接口鉴权限流背后的数据结构和算法

07-11

54 | 算法实战（三）：剖析高性能队列Disruptor背后的数据结构和算法

07-11

53 | 算法实战（二）：剖析搜索引擎背后的经典数据结构和算法

07-11

52 | 算法实战（一）：剖析Redis常用数据类型对应的数据结构

07-11

51 | 并行算法：如何利用并行处理提高算法的执行效率？

07-11

50 | 索引：如何在海量数据中快速查找某个数据？

07-11

49 | 搜索：如何用A*搜索算法实现游戏中的寻路功能？

07-11

48 | B+树：MySQL数据库索引是如何实现的？

07-11

47 | 向量空间：如何实现一个简单的音乐推荐系统？

07-11

46 | 概率统计：如何利用朴素贝叶斯算法过滤垃圾短信？

07-11

45 | 位图：如何实现网页爬虫中的URL去重功能？

07-11

44 | 最短路径：地图软件是如何计算出最优出行路径的？

07-11

43 | 拓扑排序：如何确定代码源文件的编译依赖关系？

07-11

42 | 动态规划实战：如何实现搜索引擎中的拼写纠错功能？

07-11

41 | 动态规划理论：一篇文章带你彻底搞懂最优子结构、无后效性和重复子问题

07-11

40 | 初识动态规划：如何巧妙解决“双十一”购物时的凑单问题？

07-11

39 | 回溯算法：从电影《蝴蝶效应》中学习回溯算法的核心思想

07-11

38 | 分治算法：谈一谈大规模计算框架MapReduce中的分治思想

07-11

37 | 贪心算法：如何用贪心算法实现Huffman压缩编码？

07-11

36 | AC自动机：如何用多模式串匹配实现敏感词过滤功能？

07-11

35 | Trie树：如何实现搜索引擎的搜索关键词提示功能？

07-11

34 | 字符串匹配基础（下）：如何借助BM算法轻松理解KMP算法？

07-11

33 | 字符串匹配基础（中）：如何实现文本编辑器中的查找功能？

07-11

32 | 字符串匹配基础（上）：如何借助哈希算法实现高效字符串匹配？

07-11

31 | 深度和广度优先搜索：如何找出社交网络中的三度好友关系？

07-11

30 | 图的表示：如何存储微博、微信等社交网络中的好友关系？

07-11

29 | 堆的应用：如何快速获取到Top 10最热门的搜索关键词？

07-11

28 | 堆和堆排序：为什么说堆排序没有快速排序快？

07-11

27 | 递归树：如何借助树来求解递归算法的时间复杂度？

07-11

26 | 红黑树（下）：掌握这些技巧，你也可以实现一个红黑树

07-11

25 | 红黑树（上）：为什么工程中都用红黑树这种二叉树？

07-11

24 | 二叉树基础（下）：有了如此高效的散列表，为什么还需要二叉树？

07-11

23 | 二叉树基础（上）：什么样的二叉树适合用数组来存储？

07-11

22 | 哈希算法（下）：哈希算法在分布式系统中有哪些应用？

07-11

21 | 哈希算法（上）：如何防止数据库中的用户信息被脱库？

07-11

20 | 散列表（下）：为什么散列表和链表经常会一起使用？

07-11

19 | 散列表（中）：如何打造一个工业级水平的散列表？

07-11

18 | 散列表（上）：Word文档中的单词拼写检查功能是如何实现的？

07-11

17 | 跳表：为什么Redis一定要用跳表来实现有序集合？

07-11

16 | 二分查找（下）：如何快速定位IP对应的省份地址？

07-11

15 | 二分查找（上）：如何用最省内存的方式实现快速查找功能？

07-11

14 | 排序优化：如何实现一个通用的、高性能的排序函数？

07-11

13 | 线性排序：如何根据年龄给100万用户数据排序？

07-11

12 | 排序（下）：如何用快排思想在O(n)内查找第K大元素？

07-11

11 | 排序（上）：为什么插入排序比冒泡排序更受欢迎？

07-11

10 | 递归：如何用三行代码找到“最终推荐人”？

07-11

09 | 队列：队列在线程池等有限资源池中的应用

07-11

08 | 栈：如何实现浏览器的前进和后退功能？

07-11

07 | 链表（下）：如何轻松写出正确的链表代码？

07-11

06 | 链表（上）：如何实现LRU缓存淘汰算法?

07-11

05 | 数组：为什么很多编程语言中数组都从0开始编号？

07-11

04 | 复杂度分析（下）：浅析最好、最坏、平均、均摊时间复杂度

07-11

03 | 复杂度分析（上）：如何分析、统计算法的执行效率和资源消耗？

07-11

02 | 如何抓住重点，系统高效地学习数据结构与算法？

07-11

01 | 为什么要学习数据结构和算法？

07-11

开篇词 | 从今天起，跨过“数据结构与算法”这道坎

07-11

06 | gRPC 序列化机制

07-11

05 | gRPC 安全性设计

07-11

04 | gRPC 服务调用原理

07-11

03 | gRPC 线程模型分析

07-11

02 | 客户端创建和调用原理

07-11

01 | gRPC 入门及服务端创建和调用原理

07-11

45 | 自增id用完怎么办？

07-10

44 | 答疑文章（三）：说一说这些好问题

07-10

43 | 要不要使用分区表？

07-10

42 | grant之后要跟着flush privileges吗？

07-10

41 | 怎么最快地复制一张表？

07-10

40 | insert语句的锁为什么这么多？

07-10

39 | 自增主键为什么不是连续的？

07-10

38 | 都说InnoDB好，那还要不要使用Memory引擎？

07-10

37 | 什么时候会使用内部临时表？

07-10

36 | 为什么临时表可以重名？

07-10

35 | join语句怎么优化？

07-10

34 | 到底可不可以使用join？

07-10

33 | 我查这么多数据，会不会把数据库内存打爆？

07-10

32 | 为什么还有kill不掉的语句？

07-10

31 | 误删数据后除了跑路，还能怎么办？

07-10

30 | 答疑文章（二）：用动态的观点看加锁

07-10

29 | 如何判断一个数据库是不是出问题了

07-10

28 | 读写分离有哪些坑？

07-10

27 | 主库出问题了，从库怎么办？

07-10

26 | 备库为什么会延迟好几个小时？

07-10

25 | MySQL是怎么保证高可用的？

07-10

24 | MySQL是怎么保证主备一致的？

07-10

23 | MySQL是怎么保证数据不丢的？

07-10

22 | MySQL有哪些“饮鸩止渴”提高性能的方法？

07-10

21 | 为什么我只改一行的语句，锁这么多？

07-10

20 | 幻读是什么，幻读有什么问题？

07-10

19 | 为什么我只查一行的语句，也执行这么慢？

07-10

18 | 为什么这些SQL语句逻辑相同，性能却差异巨大？

07-10

17 | 如何正确地显示随机消息？

07-10

16 | “order by”是怎么工作的？

07-09

15 | 答疑文章（一）：日志和索引相关问题

07-08

14 | count(*)这么慢，我该怎么办？

07-08

13 | 为什么表数据删掉一半，表文件大小不变？

07-08

12 | 为什么我的MySQL会“抖”一下？

07-08

11 | 怎么给字符串字段加索引？

07-08

10 | MySQL为什么有时候会选错索引？

07-08

09 | 普通索引和唯一索引，应该怎么选择？

07-08

08 | 事务到底是隔离的还是不隔离的？

07-08

07 | 行锁功过：怎么减少行锁对性能的影响？

07-07

06 | 全局锁和表锁 ：给表加个字段怎么有这么多阻碍？

07-07

05 | 深入浅出索引（下）

07-07

04 | 深入浅出索引（上）

07-07

03 | 事务隔离：为什么你改了我还看不见？

07-07

02 | 日志系统：一条SQL更新语句是如何执行的？

07-07

Java代码书写规范

07-06

01 | 基础架构：一条SQL查询语句是如何执行的？

07-06

15 | 小公司也能做好容量保障：建设经济实用型的容量保障体系

05-30

14 | 容量保障组织建设：容量保障需要什么样的团队？

05-29

13 | 大促容量保障体系建设：怎样做好大促活动的容量保障工作（下）

05-28

12 | 大促容量保障体系建设：怎样做好大促活动的容量保障工作（上）

05-27

11 | 与时俱进：云原生下的容量保障新趋势

05-25

10 | 浅谈排队论：数学之美，通过建模计算容量

05-24

09 | 容量预测（下）：为不同服务“画像”，提升容量预测准确性

05-23

08 | 容量预测（上）：第三只眼，通过AI预测服务容量瓶颈

05-22

07 | 工具进化：如何实现一个分布式压测平台

05-21

06 | 全链路压测：系统整体容量保障的“核武器”（下）

05-20

05 | 全链路压测：系统整体容量保障的“核武器”（上）

05-19

04 | 容量治理的三板斧：扩容、限流与降级

05-18

03 | 容量指标分析经典5问：响应时间真的是越短越好吗？

05-17

02 | 容量测试与验证：怎样科学实施容量测试？

05-16

01 | 容量保障的目标：容量保障的目标是什么？该如何度量？

05-15

06 | 面向未来的思考：泛服务化与 Service Mesh

05-14

05 | Service Mesh 的请求路由流程分析

05-13

04 | 详解 Service Mesh 的事实规范

05-12

03 | 异构系统跨语言服务化初探

05-11

02 | 从单体应用到 Service Mesh 的曲折历程

05-10

01 | 我们高呼的下一代微服务 Service Mesh 到底是什么？

05-09

准备Plan B：如何设计兜底方案?（八）

05-08

秒杀系统“减库存”设计的核心逻辑（七）

05-07

影响性能的因素有哪些？又该如何提高系统的性能？（六）

05-06

流量削峰这事应该怎么做？（五）

05-05

二八原则：有针对性地处理好系统的“热点数据”（四）

05-04

如何才能做好动静分离？有哪些方案可选？（三）

05-03

设计秒杀系统时应该注意的5个架构原则（二）

05-02

秒杀系统架构设计都有哪些关键点（一）

05-01

Netty权威指南.pdf

04-30

Java并发编程实战（中文版）.pdf

04-30

kafka版本演进-鱼骨图

04-29

记一次自定义拦截器失效的问题排查

04-12

xxl-job在少儿英语中的实践-2

03-15

Leaf在项目中的应用

03-15

分布式ID服务Leaf（PPT）

12-24

（转）软件架构探索：The Fenix Project

12-13

动态数据源自定义注解的使用说明

12-13

XXL-JOB在少儿英语中的实践-1

12-13

Java SPI与Dubbo SPI

06-07

Docker中实现nginx日志切分

05-31

JedisCluster源码分析

05-24

数据密集型应用系统设计.pdf

05-17

Mybatis高效率批量更新

05-10

Java线程池原理分析（转）

04-18

Nginx配置https服务器

03-03

macOS编译OpenJDK13

03-02