JUST DO IT

  • 首页
  • 归档

  • 搜索
极客时间
太棒了! 目前共计 1,153 篇日志。 继续努力。

2023

结课测试|这些金融架构的问题,你都掌握了么?

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

2022

结课测试 | 这些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

2021

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

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

2020

分布式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
1 2 3
jkl_yuiop

jkl_yuiop

1,153 日志
32 分类
1 标签
RSS
E-mail
Creative Commons
Links
  • 学习笔记
© 2023 jkl_yuiop

如需同步其他《极客时间》专栏,请邮件leeshengis@163.com(免费)