复习-JavaGuide on 随记

mysql执行计划

Tue, 14 Mar 2023 22:34:52 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

本文来自公号 MySQL 技术，JavaGuide 对其做了补充完善。原文地址：https://mp.weixin.qq.com/s/d5OowNLtXBGEAbT31sSH4g

优化 SQL 的第一步应该是读懂 SQL 的执行计划。本篇文章，我们一起来学习下 MySQL EXPLAIN 执行计划相关知识。

什么是执行计划？#

执行计划 是指一条 SQL 语句在经过 MySQL 查询优化器 的优化会后，具体的执行方式。

执行计划通常用于 SQL 性能分析、优化等场景。通过 EXPLAIN 的结果，可以了解到如数据表的查询顺序、数据查询操作的操作类型、哪些索引可以被命中、哪些索引实际会命中、每个数据表有多少行记录被查询等信息。

如何获取执行计划？#

-- 提交准备数据
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for dept_emp
-- ----------------------------
DROP TABLE IF EXISTS `dept_emp`;
CREATE TABLE `dept_emp` (
 `id` int(0) NOT NULL,
 `emp_no` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
 `other1` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
 `other2` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
 PRIMARY KEY (`id`) USING BTREE,
 INDEX `index_emp_no`(`emp_no`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of dept_emp
-- ----------------------------
INSERT INTO `dept_emp` VALUES (1, 'a1', 'o11', '012');
INSERT INTO `dept_emp` VALUES (2, 'a2', 'o21', 'o22');
INSERT INTO `dept_emp` VALUES (3, 'a3', 'o31', 'o32');
INSERT INTO `dept_emp` VALUES (4, 'a4', 'o41', 'o42');
INSERT INTO `dept_emp` VALUES (5, 'a5', 'o51', 'o52');

SET FOREIGN_KEY_CHECKS = 1;

MySQL 为我们提供了 EXPLAIN 命令，来获取执行计划的相关信息。

sql常见面试题总结01

Sun, 12 Mar 2023 17:53:18 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

题目来源于：牛客题霸 - SQL 必知必会

检索数据#

select 用于从数据库中查询数据。

从 Customers 表中检索所有的 ID#

现有表 Customers 如下：

cust_id
A
B
C

编写 SQL 语句，从 Customers 表中检索所有的 cust_id。

答案：

select cust_id
from Customers;

检索并列出已订购产品的清单#

表 OrderItems 含有非空的列 prod_id 代表商品 id，包含了所有已订购的商品（有些已被订购多次）。

prod_id
a1
a2
a3
a4
a5
a6
a7

编写 SQL 语句，检索并列出所有已订购商品（prod_id）的去重后的清单。

答案：

select distinct prod_id
from OrderItems;

知识点：distinct 用于返回列中的唯一不同值。

检索所有列#

现在有 Customers 表（表中含有列 cust_id 代表客户 id，cust_name 代表客户姓名）

cust_id	cust_name
a1	andy
a2	ben
a3	tony
a4	tom
a5	an
a6	lee
a7	hex

需要编写 SQL 语句，检索所有列。

sql语法基础知识总结

Sun, 12 Mar 2023 17:52:48 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

本文整理完善自下面这两份资料：

SQL 语法速成手册

MySQL 超全教程

基本概念#

数据库术语#

数据库（database） - 保存有组织的数据的容器（通常是一个文件或一组文件）。
数据表（table） - 某种特定类型数据的结构化清单。
模式（schema） - 关于数据库和表的布局及特性的信息。模式定义了数据在表中如何存储，包含存储什么样的数据，数据如何分解，各部分信息如何命名等信息。数据库和表都有模式。
列（column） - 表中的一个字段。所有表都是由一个或多个列组成的。
行（row） - 表中的一个记录。
主键（primary key） - 一列（或一组列），其值能够唯一标识表中每一行。

SQL 语法#

SQL（Structured Query Language)，标准 SQL 由 ANSI 标准委员会管理，从而称为 ANSI SQL。各个 DBMS 都有自己的实现，如 PL/SQL、Transact-SQL 等。

SQL 语法结构#

SQL 语法结构包括：

子句 - 是语句和查询的组成成分。（在某些情况下，这些都是可选的。）
表达式 - 可以产生任何标量值，或由列和行的数据库表
谓词 - 给需要评估的 SQL 三值逻辑（3VL）（true/false/unknown）或布尔真值指定条件，并限制语句和查询的效果，或改变程序流程。
查询 - 基于特定条件检索数据。这是 SQL 的一个重要组成部分。
语句 - 可以持久地影响纲要和数据，也可以控制数据库事务、程序流程、连接、会话或诊断。

SQL 语法要点#

SQL 语句不区分大小写，但是数据库表名、列名和值是否区分，依赖于具体的 DBMS 以及配置。例如：SELECT 与 select 、Select 是相同的。
多条 SQL 语句必须以分号（;）分隔。
处理 SQL 语句时，所有空格都被忽略。

SQL 语句可以写成一行，也可以分写为多行。

redis问题图解

Mon, 27 Feb 2023 22:11:02 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

主从复制原理
哨兵模式(简单)

哨兵模式详解

先配置主从模式，再配置哨兵模式

所有的哨兵 sentinel.conf 都是配置为监听master–> 192.168.14.101，如果主机宕机，sentinel.conf 中的配置也会自动更改为选举后的

Java客户端连接原理

客户端是和Sentinel来进行交互的,通过Sentinel来获取真正的Redis节点信息,然后来操作.实际工作时,Sentinel 内部维护了一个主题队列,用来保存Redis的节点信息,并实时更新,客户端订阅了这个主题,然后实时的去获取这个队列的Redis节点信息.

/**
代码相对比较简单
**/
//1.设置sentinel 各个节点集合
Set<String> sentinelSet = new HashSet<>();
sentinelSet.add("192.168.14.101:26379");
sentinelSet.add("192.168.14.102:26380");
sentinelSet.add("192.168.14.103:26381");
 
//2.设置jedispool 连接池配置文件
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(10);
config.setMaxWaitMillis(1000);
 
//3.设置mastername,sentinelNode集合,配置文件,Redis登录密码
JedisSentinelPool jedisSentinelPool = new JedisSentinelPool("mymaster",sentinelSet,config,"123");
Jedis jedis = null;
try {
 jedis = jedisSentinelPool.getResource();
 //获取Redis中key=hello的值
 String value = jedis.get("hello");
 System.out.println(value);
} catch (Exception e) {
 e.printStackTrace();
} finally {
 if(jedis != null){
 jedis.close();
 }
}

3种常用的缓存读写策略详解

Fri, 24 Feb 2023 09:31:52 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

看到很多小伙伴简历上写了“熟练使用缓存”，但是被我问到“缓存常用的3种读写策略”的时候却一脸懵逼。

在我看来，造成这个问题的原因是我们在学习 Redis 的时候，可能只是简单了写一些 Demo，并没有去关注缓存的读写策略，或者说压根不知道这回事。

但是，搞懂3种常见的缓存读写策略对于实际工作中使用缓存以及面试中被问到缓存都是非常有帮助的！

下面介绍到的三种模式各有优劣，不存在最佳模式，根据具体的业务场景选择适合自己的缓存读写模式。

Cache Aside Pattern（旁路缓存模式）#

Cache Aside Pattern 是我们平时使用比较多的一个缓存读写模式，比较适合读请求比较多的场景。

Cache Aside Pattern 中服务端需要同时维系 db 和 cache，并且是以 db 的结果为准。

下面我们来看一下这个策略模式下的缓存读写步骤。

写：

先更新 db
然后直接删除 cache 。

简单画了一张图帮助大家理解写的步骤。

读 :

从 cache 中读取数据，读取到就直接返回
cache 中读取不到的话，就从 db 中读取数据返回
再把数据放到 cache 中。

简单画了一张图帮助大家理解读的步骤。

你仅仅了解了上面这些内容的话是远远不够的，我们还要搞懂其中的原理。

比如说面试官很可能会追问：“在写数据的过程中，可以先删除 cache ，后更新 db 么？”

答案： 那肯定是不行的！因为这样可能会造成 数据库（db）和缓存（Cache）数据不一致的问题。

举例：请求 1 先写数据 A，请求 2 随后读数据 A 的话，就很有可能产生数据不一致性的问题。

这个过程可以简单描述为：

请求 1 先把 cache 中的 A 数据删除 -> 请求 2 从 db 中读取数据【此时请求2把脏数据(对于请求1来说是)更新到缓存去了】->请求 1 再把 db 中的 A 数据更新，即请求1的操作非原子

redis内存碎片

Fri, 24 Feb 2023 09:26:00 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

什么是内存碎片?#

你可以将内存碎片简单地理解为那些不可用的空闲内存。

举个例子：操作系统为你分配了 32 字节的连续内存空间，而你存储数据实际只需要使用 24 字节内存空间，那这多余出来的 8 字节内存空间如果后续没办法再被分配存储其他数据的话，就可以被称为内存碎片。

Redis 内存碎片虽然不会影响 Redis 性能，但是会增加内存消耗。

为什么会有 Redis 内存碎片?#

Redis 内存碎片产生比较常见的 2 个原因：

1、Redis 存储存储数据的时候向操作系统申请的内存空间可能会大于数据实际需要的存储空间。

以下是这段 Redis 官方的原话：

To store user keys, Redis allocates at most as much memory as the maxmemory setting enables (however there are small extra allocations possible).

Redis 使用 zmalloc 方法(Redis 自己实现的内存分配方法)进行内存分配的时候，除了要分配 size 大小的内存之外，还会多分配 PREFIX_SIZE 大小的内存。

zmalloc 方法源码如下（源码地址：https://github.com/antirez/redis-tools/blob/master/zmalloc.c）：

void *zmalloc(size_t size) {
 // 分配指定大小的内存
 void *ptr = malloc(size+PREFIX_SIZE);
 if (!ptr) zmalloc_oom_handler(size);
#ifdef HAVE_MALLOC_SIZE
 update_zmalloc_stat_alloc(zmalloc_size(ptr));
 return ptr;
#else
 *((size_t*)ptr) = size;
 update_zmalloc_stat_alloc(size+PREFIX_SIZE);
 return (char*)ptr+PREFIX_SIZE;
#endif
}

另外，Redis 可以使用多种内存分配器来分配内存（ libc、jemalloc、tcmalloc），默认使用 jemalloc，而 jemalloc 按照一系列固定的大小（8 字节、16 字节、32 字节……）来分配内存的。jemalloc 划分的内存单元如下图所示：

redis特殊数据结构

Thu, 23 Feb 2023 23:02:58 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

除了 5 种基本的数据结构之外，Redis 还支持 3 种特殊的数据结构：Bitmap、HyperLogLog、GEO。

Bitmap#

介绍#

Bitmap 存储的是连续的二进制数字（0 和 1），通过 Bitmap, 只需要一个 bit 位来表示某个元素对应的值或者状态，key 就是对应元素本身。我们知道 8 个 bit 可以组成一个 byte，所以 Bitmap 本身会极大的节省储存空间。

你可以将 Bitmap 看作是一个存储二进制数字（0 和 1）的数组，数组中每个元素的下标叫做 offset（偏移量）。

常用命令#

命令	介绍
SETBIT key offset value	设置指定 offset 位置的值
GETBIT key offset	获取指定 offset 位置的值
BITCOUNT key start end	获取 start 和 end 之前值为 1 的元素个数
BITOP operation destkey key1 key2 …	对一个或多个 Bitmap 进行运算，可用运算符有 AND, OR, XOR 以及 NOT

Bitmap 基本操作演示 ：

redis基本数据结构

Thu, 23 Feb 2023 14:22:58 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

Redis 共有 5 种基本数据结构：String（字符串）、List（列表）、Set（集合）、Hash（散列）、Zset（有序集合）。

这 5 种数据结构是直接提供给用户使用的，是数据的保存形式，其底层实现主要依赖这 8 种数据结构：简单动态字符串（SDS）、LinkedList（双向链表）、Hash Table（哈希表）、SkipList（跳跃表）、Intset（整数集合）、ZipList（压缩列表）、QuickList（快速列表）。

Redis 基本数据结构的底层数据结构实现如下：

String	List	Hash	Set	Zset
SDS	LinkedList/ZipList/QuickList	Hash Table、ZipList	ZipList、Intset	ZipList、SkipList

Redis 3.2 之前，List 底层实现是 LinkedList 或者 ZipList。 Redis 3.2 之后，引入了 LinkedList 和 ZipList 的结合 QuickList，List 的底层实现变为 QuickList。

你可以在 Redis 官网上找到 Redis 数据结构非常详细的介绍：

未来随着 Redis 新版本的发布，可能会有新的数据结构出现，通过查阅 Redis 官网对应的介绍，你总能获取到最靠谱的信息。

String（字符串）#

介绍#

String 是 Redis 中最简单同时也是最常用的一个数据结构。

String 是一种二进制安全的数据结构，可以用来存储任何类型的数据比如字符串、整数、浮点数、图片（图片的 base64 编码或者解码或者图片的路径）、序列化后的对象。

redis面试题02

Thu, 23 Feb 2023 11:16:04 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

Redis 事务#

如何使用 Redis 事务？#

Redis 可以通过 MULTI，EXEC，DISCARD 和 WATCH 等命令来实现事务(transaction)功能。

> MULTI
OK
> SET PROJECT "JavaGuide"
QUEUED
> GET PROJECT
QUEUED
> EXEC
1) OK
2) "JavaGuide"

MULTI 命令后可以输入多个命令，Redis 不会立即执行这些命令，而是将它们放到队列，当调用了 EXEC 命令后，再执行所有的命令。

这个过程是这样的：

开始事务（MULTI）；
命令入队(批量操作 Redis 的命令，先进先出（FIFO）的顺序执行)；
执行事务(EXEC)。

你也可以通过 DISCARD 命令取消一个事务，它会清空事务队列中保存的所有命令。

> MULTI
OK
> SET PROJECT "JavaGuide"
QUEUED
> GET PROJECT
QUEUED
> DISCARD
OK

你可以通过 WATCH 命令监听指定的 Key，当调用 EXEC 命令执行事务时，如果一个被 WATCH 命令监视的 Key 被 其他客户端/Session 修改的话，整个事务都不会被执行。

# 客户端 1
> SET PROJECT "RustGuide"
OK
> WATCH PROJECT
OK
> MULTI
OK
> SET PROJECT "JavaGuide"
QUEUED

# 客户端 2
# 在客户端 1 执行 EXEC 命令提交事务之前修改 PROJECT 的值
> SET PROJECT "GoGuide"

# 客户端 1
# 修改失败，因为 PROJECT 的值被客户端2修改了
> EXEC
(nil)
> GET PROJECT
"GoGuide"

不过，如果 WATCH 与事务在同一个 Session 里，并且被 WATCH 监视的 Key 被修改的操作发生在事务内部，这个事务是可以被执行成功的（相关 issue ： WATCH 命令碰到 MULTI 命令时的不同效果）。

redis面试题01

Wed, 22 Feb 2023 11:31:11 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

Redis 基础#

什么是 Redis？#

Redis 是一个基于 C 语言开发的开源数据库（BSD 许可），与传统数据库不同的是 Redis 的数据是存在内存中的（内存数据库），读写速度非常快，被广泛应用于缓存方向。并且，Redis 存储的是 KV 键值对数据。

为了满足不同的业务场景，Redis 内置了多种数据类型实现（比如 String、Hash、【List、Set、】Sorted Set、Bitmap）。并且，Redis 还支持事务、持久化、Lua 脚本、多种开箱即用的集群方案（Redis Sentinel、Redis Cluster）。

Redis 没有外部依赖，Linux 和 OS X 是 Redis 开发和测试最多的两个操作系统，官方推荐生产环境使用 Linux 部署 Redis。

个人学习的话，你可以自己本机安装 Redis 或者通过 Redis 官网提供的在线 Redis 环境来实际体验 Redis。

全世界有非常多的网站使用到了 Redis ， techstacks.io 专门维护了一个使用 Redis 的热门站点列表，感兴趣的话可以看看。

Redis 为什么这么快？#

Redis 内部做了非常多的性能优化，比较重要的主要有下面 3 点：

Redis 基于内存，内存的访问速度是磁盘的上千倍；
Redis 基于 Reactor 模式设计开发了一套高效的事件处理模型，主要是单线程事件循环和 IO 多路复用（Redis 线程模式后面会详细介绍到）；
Redis 内置了多种优化过后的数据结构实现，性能非常高。

下面这张图片总结的挺不错的，分享一下，出自 Why is Redis so fast? 。

web-real-time-message-push

Tue, 21 Feb 2023 09:26:53 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

原文地址：https://juejin.cn/post/7122014462181113887，JavaGuide 对本文进行了完善总结。

我有一个朋友做了一个小破站，现在要实现一个站内信 Web 消息推送的功能，对，就是下图这个小红点，一个很常用的功能。

不过他还没想好用什么方式做，这里我帮他整理了一下几种方案，并简单做了实现。

# 什么是消息推送？#

推送的场景比较多，比如有人关注我的公众号，这时我就会收到一条推送消息，以此来吸引我点击打开应用。

消息推送通常是指网站的运营工作等人员，通过某种工具对用户当前网页或移动设备 APP 进行的主动消息推送。

消息推送一般又分为 Web 端消息推送和移动端消息推送。

移动端消息推送示例：

Web 端消息推送示例：

在具体实现之前，咱们再来分析一下前边的需求，其实功能很简单，只要触发某个事件（主动分享了资源或者后台主动推送消息），Web 页面的通知小红点就会实时的 +1 就可以了。

通常在服务端会有若干张消息推送表，用来记录用户触发不同事件所推送不同类型的消息，前端主动查询（拉）或者被动接收（推）用户所有未读的消息数。

消息推送无非是推（push）和拉（pull）两种形式，下边我们逐个了解下。

# 消息推送常见方案#

# 短轮询#

轮询(polling) 应该是实现消息推送方案中最简单的一种，这里我们暂且将轮询分为短轮询和长轮询。

短轮询很好理解，指定的时间间隔，由浏览器向服务器发出 HTTP 请求，服务器实时返回未读消息数据给客户端，浏览器再做渲染显示。

一个简单的 JS 定时器就可以搞定，每秒钟请求一次未读消息数接口，返回的数据展示即可。

setInterval(() => {
 // 方法请求
 messageCount().then((res) => {
 if (res.code === 200) {
 this.messageCount = res.data
 }
 })
}, 1000);

效果还是可以的，短轮询实现固然简单，缺点也是显而易见，由于推送数据并不会频繁变更，无论后端此时是否有新的消息产生，客户端都会进行请求，势必会对服务端造成很大压力，浪费带宽和服务器资源。

# 长轮询#

长轮询是对上边短轮询的一种改进版本，在尽可能减少对服务器资源浪费的同时，保证消息的相对实时性。长轮询在中间件中应用的很广泛，比如 Nacos 和 Apollo 配置中心，消息队列 Kafka、RocketMQ 中都有用到长轮询。

Java定时任务详解

Tue, 21 Feb 2023 09:17:31 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

为什么需要定时任务？#

我们来看一下几个非常常见的业务场景：

某系统凌晨要进行数据备份。
某电商平台，用户下单半个小时未支付的情况下需要自动取消订单。
某媒体聚合平台，每 10 分钟动态抓取某某网站的数据为自己所用。
某博客平台，支持定时发送文章。
某基金平台，每晚定时计算用户当日收益情况并推送给用户最新的数据。
……

这些场景往往都要求我们在某个特定的时间去做某个事情。

单机定时任务技术选型#

Timer#

java.util.Timer是 JDK 1.3 开始就已经支持的一种定时任务的实现方式。

Timer 内部使用一个叫做 TaskQueue 的类存放定时任务，它是一个基于最小堆实现的优先级队列。TaskQueue 会按照任务距离下一次执行时间的大小将任务排序，保证在堆顶的任务最先执行。这样在需要执行任务时，每次只需要取出堆顶的任务运行即可！

Timer 使用起来比较简单，通过下面的方式我们就能创建一个 1s 之后执行的定时任务。

// 示例代码：
TimerTask task = new TimerTask() {
 public void run() {
 System.out.println("当前时间: " + new Date() + "n" +
 "线程名称: " + Thread.currentThread().getName());
 }
};
System.out.println("当前时间: " + new Date() + "n" +
 "线程名称: " + Thread.currentThread().getName());
Timer timer = new Timer("Timer");
long delay = 1000L;
timer.schedule(task, delay);


//输出：
当前时间: Fri May 28 15:18:47 CST 2021n线程名称: main
当前时间: Fri May 28 15:18:48 CST 2021n线程名称: Timer

不过其缺陷较多，比如一个 Timer 一个线程，这就导致 Timer 的任务的执行只能串行执行，一个任务执行时间过长的话会影响其他任务（性能非常差），再比如发生异常时任务直接停止（Timer 只捕获了 InterruptedException ）。

敏感词过滤方案总结

Tue, 21 Feb 2023 08:57:26 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

系统需要对用户输入的文本进行敏感词过滤如色情、政治、暴力相关的词汇。

敏感词过滤用的使用比较多的 Trie 树算法 和 DFA 算法。

算法实现#

Trie 树#

Trie 树 也称为字典树、单词查找树，哈系树(这里是不是写错了，哈希树？)的一种变种，通常被用于字符串匹配，用来解决在一组字符串集合中快速查找某个字符串的问题。像浏览器搜索的关键词提示一般就是基于 Trie 树来做的。

假如我们的敏感词库中有以下敏感词：

高清有码
高清 AV
东京冷
东京热

我们构造出来的敏感词 Trie 树就是下面这样的：

当我们要查找对应的字符串“东京热”的话，我们会把这个字符串切割成单个的字符“东”、“京”、“热”，然后我们从 Trie 树的根节点开始匹配。

可以看出， Trie 树的核心原理其实很简单，就是通过公共前缀来提高字符串匹配效率。

Apache Commons Collecions 这个库中就有 Trie 树实现：

Trie<String, String> trie = new PatriciaTrie<>();
trie.put("Abigail", "student");
trie.put("Abi", "doctor");
trie.put("Annabel", "teacher");
trie.put("Christina", "student");
trie.put("Chris", "doctor");
Assertions.assertTrue(trie.containsKey("Abigail"));
assertEquals("{Abi=doctor, Abigail=student}", trie.prefixMap("Abi").toString());
assertEquals("{Chris=doctor, Christina=student}", trie.prefixMap("Chr").toString());

Aho-Corasick（AC）自动机是一种建立在 Trie 树上的一种改进算法，是一种多模式匹配算法，由贝尔实验室的研究人员 Alfred V. Aho 和 Margaret J.Corasick 发明。

AC 自动机算法使用 Trie 树来存放模式串的前缀，通过失败匹配指针（失配指针）来处理匹配失败的跳转。

权限系统设计详解

Mon, 20 Feb 2023 15:54:05 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

作者：转转技术团队

原文：https://mp.weixin.qq.com/s/ONMuELjdHYa0yQceTj01Iw

ly：比较繁琐，大概看了前面的部分

老权限系统的问题与现状#

转转公司在过去并没有一个统一的权限管理系统，权限管理由各业务自行研发或是使用其他业务的权限系统，权限管理的不统一带来了不少问题：

各业务重复造轮子，维护成本高
各系统只解决部分场景问题，方案不够通用，新项目选型时没有可靠的权限管理方案
缺乏统一的日志管理与审批流程，在授权信息追溯上十分困难

基于上述问题，去年底公司启动建设转转统一权限系统，目标是开发一套灵活、易用、安全的权限管理系统，供各业务使用。

业界权限系统的设计方式#

目前业界主流的权限模型有两种，下面分别介绍下：

基于角色的访问控制（RBAC）
基于属性的访问控制（ABAC）

RBAC 模型#

基于角色的访问控制（Role-Based Access Control，简称 RBAC） 指的是通过用户的角色（Role）授权其相关权限，实现了灵活的访问控制，相比直接授予用户权限，要更加简单、高效、可扩展。

一个用户可以拥有若干角色，每一个角色又可以被分配若干权限这样，就构造成“用户-角色-权限” 的授权模型。在这种模型中，用户与角色、角色与权限之间构成了多对多的关系。

用一个图来描述如下：

当使用 RBAC模型 时，通过分析用户的实际情况，基于共同的职责和需求，授予他们不同角色。这种 用户 -> 角色 -> 权限 间的关系，让我们可以不用再单独管理单个用户权限，用户从授予的角色里面获取所需的权限。

以一个简单的场景（Gitlab 的权限系统）为例，用户系统中有 Admin、Maintainer、Operator 三种角色，这三种角色分别具备不同的权限，比如只有 Admin 具备创建代码仓库、删除代码仓库的权限，其他的角色都不具备。我们授予某个用户 Admin 这个角色，他就具备了 创建代码仓库 和 删除代码仓库 这两个权限。

通过 RBAC模型 ，当存在多个用户拥有相同权限时，我们只需要创建好拥有该权限的角色，然后给不同的用户分配不同的角色，后续只需要修改角色的权限，就能自动修改角色内所有用户的权限。

ABAC 模型#

基于属性的访问控制（Attribute-Based Access Control，简称 ABAC） 是一种比 RBAC模型 更加灵活的授权模型，它的原理是通过各种属性来动态判断一个操作是否可以被允许。这个模型在云系统中使用的比较多，比如 AWS，阿里云等。

考虑下面这些场景的权限控制：

授权某个人具体某本书的编辑权限
当一个文档的所属部门跟用户的部门相同时，用户可以访问这个文档
当用户是一个文档的拥有者并且文档的状态是草稿，用户可以编辑这个文档
早上九点前禁止 A 部门的人访问 B 系统
在除了上海以外的地方禁止以管理员身份访问 A 系统
用户对 2022-06-07 之前创建的订单有操作权限

可以发现上述的场景通过 RBAC模型 很难去实现，因为 RBAC模型 仅仅描述了用户可以做什么操作，但是操作的条件，以及操作的数据，RBAC模型 本身是没有这些限制的。但这恰恰是 ABAC模型 的长处，ABAC模型 的思想是基于用户、访问的数据的属性、以及各种环境因素去动态计算用户是否有权限进行操作。

sso单点登录

Mon, 20 Feb 2023 15:20:23 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

本文授权转载自： https://ken.io/note/sso-design-implement 作者：ken.io

SSO 介绍#

什么是 SSO？#

SSO 英文全称 Single Sign On，单点登录。SSO 是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。

例如你登录网易账号中心（https://reg.163.com/ ）之后访问以下站点都是登录状态。

网易直播 https://v.163.com
网易博客 https://blog.163.com
网易花田 https://love.163.com
网易考拉 https://www.kaola.com
网易 Lofter http://www.lofter.com

SSO 有什么好处？#

用户角度 :用户能够做到一次登录多次使用，无需记录多套用户名和密码，省心。
系统管理员角度 : 管理员只需维护好一个统一的账号中心就可以了，方便。
新系统开发角度: 新系统开发时只需直接对接统一的账号中心即可，简化开发流程，省时。

SSO 设计与实现#

本篇文章也主要是为了探讨如何设计&实现一个 SSO 系统

以下为需要实现的核心功能：

单点登录
单点登出
支持跨域单点登录
支持跨域单点登出

核心应用与依赖#

应用/模块/对象	说明
前台站点	需要登录的站点
SSO 站点-登录	提供登录的页面
SSO 站点-登出	提供注销登录的入口
SSO 服务-登录	提供登录服务
SSO 服务-登录状态	提供登录状态校验/登录信息查询的服务
SSO 服务-登出	提供用户注销登录的服务
数据库	存储用户账户信息
缓存	存储用户的登录信息，通常使用 Redis

用户登录状态的存储与校验#

常见的 Web 框架对于 Session 的实现都是生成一个 SessionId 存储在浏览器 Cookie 中。然后将 Session 内容存储在服务器端内存中，这个 ken.io 在之前 Session 工作原理中也提到过。整体也是借鉴这个思路。

jwt身份认证优缺点

Mon, 20 Feb 2023 14:40:15 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

在 JWT 基本概念详解这篇文章中，我介绍了：

什么是 JWT?
JWT 由哪些部分组成？
如何基于 JWT 进行身份验证？
JWT 如何防止 Token 被篡改？
如何加强 JWT 的安全性？

这篇文章，我们一起探讨一下 JWT 身份认证的优缺点以及常见问题的解决办法。

JWT 的优势#

相比于 Session 认证的方式来说，使用 JWT 进行身份认证主要有下面 4 个优势。

无状态#

JWT 自身包含了身份验证所需要的所有信息，因此，我们的服务器不需要存储 Session 信息。这显然增加了系统的可用性和伸缩性，大大减轻了服务端的压力。

不过，也正是由于 JWT 的无状态，也导致了它最大的缺点：不可控！

就比如说，我们想要在 JWT 有效期内废弃一个 JWT 或者更改它的权限的话，并不会立即生效，通常需要等到有效期过后才可以。再比如说，当用户 Logout 的话，JWT 也还有效。除非，我们在后端增加额外的处理逻辑比如将失效的 JWT 存储起来，后端先验证 JWT 是否有效再进行处理。具体的解决办法，我们会在后面的内容中详细介绍到，这里只是简单提一下。

有效避免了 CSRF 攻击#

[ˈfɔːdʒəri] forgery 伪造

CSRF（Cross Site Request Forgery） 一般被翻译为 跨站请求伪造，属于网络攻击领域范围。相比于 SQL 脚本注入、XSS 等安全攻击方式，CSRF 的知名度并没有它们高。但是，它的确是我们开发系统时必须要考虑的安全隐患。就连业内技术标杆 Google 的产品 Gmail 也曾在 2007 年的时候爆出过 CSRF 漏洞，这给 Gmail 的用户造成了很大的损失。

jwt-intro

Mon, 20 Feb 2023 14:28:07 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

什么是 JWT?#

JWT （JSON Web Token）是目前最流行的跨域认证解决方案，是一种基于 Token 的认证授权机制。从 JWT 的全称可以看出，JWT 本身也是 Token，一种规范化之后的 JSON 结构的 Token。

跨域认证的问题
互联网服务离不开用户认证。一般流程是下面这样。

这种模式的问题在于，扩展性（scaling）不好。单机当然没有问题，如果是服务器集群，或者是跨域的服务导向架构，就要求 session 数据共享，每台服务器都能够读取 session。

举例来说，A 网站和 B 网站是同一家公司的关联服务。现在要求，用户只要在其中一个网站登录，再访问另一个网站就会自动登录，请问怎么实现？

一种解决方案是 session 数据持久化，写入数据库或别的持久层。各种服务收到请求后，都向持久层请求数据。这种方案的优点是架构清晰，缺点是工程量比较大。另外，持久层万一挂了，就会单点失败。

另一种方案是服务器索性不保存 session 数据了，所有数据都保存在客户端，每次请求都发回服务器。JWT 就是这种方案的一个代表。

JWT 自身包含了身份验证所需要的所有信息，因此，我们的服务器不需要存储 Session 信息。这显然增加了系统的可用性和伸缩性，大大减轻了服务端的压力。

ly：我觉得这里的重点就是，服务器不存储Session以维护"用户"和cookie(session id)的关系了

可以看出，JWT 更符合设计 RESTful API 时的「Stateless（无状态）」原则 。

并且，使用 JWT 认证可以有效避免 CSRF 攻击，因为 JWT 一般是存在在 localStorage 中，使用 JWT 进行身份验证的过程中是不会涉及到 Cookie 的。

我在 JWT 优缺点分析这篇文章中有详细介绍到使用 JWT 做身份认证的优势和劣势。

下面是 RFC 7519 对 JWT 做的较为正式的定义。

认证授权基础概念详解

Mon, 20 Feb 2023 09:44:23 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

认证 (Authentication) 和授权 (Authorization)的区别是什么？#

这是一个绝大多数人都会混淆的问题。首先先从读音上来认识这两个名词，很多人都会把它俩的读音搞混，所以我建议你先先去查一查这两个单词到底该怎么读，他们的具体含义是什么。

说简单点就是：

认证 (Authentication)： 你是谁。[ɔːˌθentɪˈkeɪʃn] 身份验证
授权 (Authorization)： 你有权限干什么。[ˌɔːθəraɪˈzeɪʃn] 授权

稍微正式点（啰嗦点）的说法就是：

Authentication（认证） 是验证您的身份的凭据（例如用户名/用户 ID 和密码），通过这个凭据，系统得以知道你就是你，也就是说系统存在你这个用户。所以，Authentication 被称为身份/用户验证。
Authorization（授权） 发生在 Authentication（认证） 之后。授权嘛，光看意思大家应该就明白，它主要掌管我们访问系统的权限。比如有些特定资源只能具有特定权限的人才能访问比如 admin，有些对系统资源操作比如删除、添加、更新只能特定人才具有。

认证：

授权：

这两个一般在我们的系统中被结合在一起使用，目的就是为了保护我们系统的安全性。

RBAC 模型了解吗？#

系统权限控制最常采用的访问控制模型就是 RBAC 模型 。

什么是 RBAC 呢？

RBAC 即基于角色的权限访问控制（Role-Based Access Control）。这是一种通过角色关联权限，角色同时又关联用户的授权的方式。

简单地说：一个用户可以拥有若干角色，每一个角色又可以被分配若干权限，这样就构造成“用户-角色-权限” 的授权模型。在这种模型中，用户与角色、角色与权限之间构成了多对多的关系，如下图

在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。

本系统的权限设计相关的表如下（一共 5 张表，2 张用户建立表之间的联系）：

通过这个权限模型，我们可以创建不同的角色并为不同的角色分配不同的权限范围（菜单）。

通常来说，如果系统对于权限控制要求比较严格的话，一般都会选择使用 RBAC 模型来做权限控制。

单元测试

Mon, 20 Feb 2023 09:38:24 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

何谓单元测试？#

维基百科是这样介绍单元测试的：

在计算机编程中，单元测试（Unit Testing）是针对程序模块（软件设计的最小单位）进行的正确性检验测试工作。

程序单元是应用的 最小可测试部件 。在过程化编程中，一个单元就是单个程序、函数、过程等；对于面向对象编程，最小单元就是方法，包括基类（超类）、抽象类、或者派生类（子类）中的方法。

由于每个单元有独立的逻辑，在做单元测试时，为了隔离外部依赖，确保这些依赖不影响验证逻辑，我们经常会用到 Fake、Stub 与 Mock 。

关于 Fake、Mock 与 Stub 这几个概念的解读，可以看看这篇文章：测试中 Fakes、Mocks 以及 Stubs 概念明晰 - 王下邀月熊 - 2018 。

为什么需要单元测试？#

为重构保驾护航#

我在重构这篇文章中这样写到：

单元测试可以为重构提供信心，降低重构的成本。我们要像重视生产代码那样，重视单元测试。

每个开发者都会经历重构，重构后把代码改坏了的情况并不少见，很可能你只是修改了一个很简单的方法就导致系统出现了一个比较严重的错误。

如果有了单元测试的话，就不会存在这个隐患了。写完一个类，把单元测试写了，确保这个类逻辑正确；写第二个类，单元测试…..写 100 个类，道理一样，每个类做到第一点“保证逻辑正确性”，100 个类拼在一起肯定不出问题。你大可以放心一边重构，一边运行 APP；而不是整体重构完，提心吊胆地 run。

提高代码质量#

由于每个单元有独立的逻辑，做单元测试时需要隔离外部依赖，确保这些依赖不影响验证逻辑。因为要把各种依赖分离，单元测试会促进工程进行组件拆分，整理工程依赖关系，更大程度减少代码耦合。这样写出来的代码，更好维护，更好扩展，从而提高代码质量。

减少 bug#

一个机器，由各种细小的零件组成，如果其中某件零件坏了，机器运行故障。必须保证每个零件都按设计图要求的规格，机器才能正常运行。

一个可单元测试的工程，会把业务、功能分割成规模更小、有独立的逻辑部件，称为单元。单元测试的目标，就是保证各个单元的逻辑正确性。单元测试保障工程各个“零件”按“规格”（需求）执行，从而保证整个“机器”（项目）运行正确，最大限度减少 bug。

快速定位 bug#

如果程序有 bug，我们运行一次全部单元测试，找到不通过的测试，可以很快地定位对应的执行代码。修复代码后，运行对应的单元测试；如还不通过，继续修改，运行测试…..直到测试通过。

持续集成依赖单元测试#

持续集成需要依赖单元测试，当持续集成服务自动构建新代码之后，会自动运行单元测试来发现代码错误。

谁逼你写单元测试？#

领导要求#

有些经验丰富的领导，或多或少都会要求团队写单元测试。对于有一定工作经验的队友，这要求挺合理；对于经验尚浅的、毕业生，恐怕要死要活了，连代码都写不好，还要写单元测试，are you kidding me？

培训新人单元测试用法，是一项艰巨的任务。新人代码风格未形成，也不知道单元测试多重要，强制单元测试会让他们感到困惑，没办法按自己思路写代码。

大牛都写单元测试#

国外很多家喻户晓的开源项目，都有大量单元测试。例如， retrofit、 okhttp、 butterknife…. 国外大牛都写单元测试，我们也写吧！

很多读者都有这种想法，一开始满腔热血。当真要对自己项目单元测试时，便困难重重，很大原因是项目对单元测试不友好。最后只能对一些不痛不痒的工具类做单元测试，久而久之，当初美好愿望也不了了之。

保住面子#

都是有些许年经验的老鸟，还天天被测试同学追 bug，好意思么？花多一点时间写单元测试，确保没低级 bug，还能彰显大牛风范，何乐而不为？

心虚#

笔者也是个不太相信自己代码的人，总觉得哪里会突然冒出莫名其妙的 bug，也怕别人不小心改了自己的代码（被害妄想症），新版本上线提心吊胆……花点时间写单元测试，有事没事跑一下测试，确保原逻辑没问题，至少能睡安稳一点。

代码重构指南

Fri, 17 Feb 2023 17:28:30 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

前段时间重读了《重构：改善代码既有设计》，收货颇多。于是，简单写了一篇文章来聊聊我对重构的看法。

何谓重构？#

学习重构必看的一本神书《重构：改善代码既有设计》从两个角度给出了重构的定义：

重构（名词）：对软件内部结构的一种调整，目的是在不改变软件可观察行为的前提下，提高其可理解性，降低其修改成本。

重构（动词）：使用一系列重构手法，在不改变软件可观察行为的前提下，调整其结构。

用更贴近工程师的语言来说：重构就是利用设计模式(如组合模式、策略模式、责任链模式)、软件设计原则（如 SOLID 原则、YAGNI 原则、KISS 原则）和重构手段（如封装、继承、构建测试体系）来让代码更容易理解，更易于修改。

软件设计原则指导着我们组织和规范代码，同时，重构也是为了能够尽量设计出尽量满足软件设计原则的软件。

正确重构的核心在于 步子一定要小，每一步的重构都不会影响软件的正常运行，可以随时停止重构。

常见的设计模式如下 ：

更全面的设计模式总结，可以看 java-design-patterns 这个开源项目。

常见的软件设计原则如下 ：

更全面的设计原则总结，可以看 java-design-patterns 和 hacker-laws-zh 这两个开源项目。

为什么要重构？#

在上面介绍重构定义的时候，我从比较抽象的角度介绍了重构的好处：重构的主要目的主要是提升代码&架构的灵活性/可扩展性以及复用性。

如果对应到一个真实的项目，重构具体能为我们带来什么好处呢？

让代码更容易理解 ：通过添加注释、命名规范、逻辑优化等手段可以让我们的代码更容易被理解；
避免代码腐化 ：通过重构干掉坏味道代码；
加深对代码的理解 ：重构代码的过程会加深你对某部分代码的理解；
发现潜在 bug ：是这样的，很多潜在的 bug ，都是我们在重构的过程中发现的；
……

看了上面介绍的关于重构带来的好处之后，你会发现重构的最终目标是 提高软件开发速度和质量 。

重构并不会减慢软件开发速度，相反，如果代码质量和软件设计较差，当我们想要添加新功能的话，开发速度会越来越慢。到了最后，甚至都有想要重写整个系统的冲动。

[

《重构：改善代码既有设计》这本书中这样说：

重构的唯一目的就是让我们开发更快，用更少的工作量创造更大的价值。

何时进行重构？#

重构在是开发过程中随时可以进行的，见机行事即可，并不需要单独分配一两天的时间专门用来重构。

提交代码之前#

《重构：改善代码既有设计》这本书介绍了一个 营地法则 的概念:

编程时，需要遵循营地法则：保证你离开时的代码库一定比来时更健康。

这个概念表达的核心思想其实很简单：在你提交代码的之前，花一会时间想一想，我这次的提交是让项目代码变得更健康了，还是更腐化了，或者说没什么变化？

项目团队的每一个人只有保证自己的提交没有让项目代码变得更腐化，项目代码才会朝着健康的方向发展。

当我们离开营地（项目代码）的时候，请不要留下垃圾（代码坏味道）！尽量确保营地变得更干净了！

开发一个新功能之后&之前#

在开发一个新功能之后，我们应该回过头看看是不是有可以改进的地方。在添加一个新功能之前，我们可以思考一下自己是否可以重构代码以让新功能的开发更容易。

一个新功能的开发不应该仅仅只有功能验证通过那么简单，我们还应该尽量保证代码质量。

有一个两顶帽子的比喻：在我开发新功能之前，我发现重构可以让新功能的开发更容易，于是我戴上了重构的帽子。重构之后，我换回原来的帽子，继续开发新能功能。新功能开发完成之后，我又发现自己的代码难以理解，于是我又戴上了重构帽子。比较好的开发状态就是就是这样在重构和开发新功能之间来回切换。

代码命名指南

Fri, 17 Feb 2023 17:22:14 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

我还记得我刚工作那一段时间，项目 Code Review 的时候，我经常因为变量命名不规范而被 “diss”!

究其原因还是自己那会经验不足，而且，大学那会写项目的时候不太注意这些问题，想着只要把功能实现出来就行了。

但是，工作中就不一样，为了代码的可读性、可维护性，项目组对于代码质量的要求还是很高的！

前段时间，项目组新来的一个实习生也经常在 Code Review 因为变量命名不规范而被 “diss”，这让我想到自己刚到公司写代码那会的日子。

于是，我就简单写了这篇关于变量命名规范的文章，希望能对同样有此困扰的小伙伴提供一些帮助。

确实，编程过程中，有太多太多让我们头疼的事情了，比如命名、维护其他人的代码、写测试、与其他人沟通交流等等。

据说之前在 Quora 网站，由接近 5000 名程序员票选出来的最难的事情就是“命名”。

大名鼎鼎的《重构》的作者老马（Martin Fowler）曾经在 TwoHardThings这篇文章中提到过CS 领域有两大最难的事情：一是 缓存失效 ，一是 程序命名 。

这个句话实际上也是老马引用别人的，类似的表达还有很多。比如分布式系统领域有两大最难的事情：一是 保证消息顺序 ，一是 严格一次传递 。

今天咱们就单独拎出 “命名” 来聊聊！

这篇文章配合我之前发的《编码 5 分钟，命名 2 小时？史上最全的 Java 命名规范参考！》这篇文章阅读效果更佳哦！

为什么需要重视命名？#

咱们需要先搞懂为什么要重视编程中的命名这一行为，它对于我们的编码工作有着什么意义。

为什么命名很重要呢？ 这是因为 好的命名即是注释，别人一看到你的命名就知道你的变量、方法或者类是做什么的！

简单来说就是 别人根据你的命名就能知道你的代码要表达的意思 （不过，前提这个人也要有基本的英语知识，对于一些编程中常见的单词比较熟悉）。

简单举个例子说明一下命名的重要性。

《Clean Code》这本书明确指出：

好的代码本身就是注释，我们要尽量规范和美化自己的代码来减少不必要的注释。

若编程语言足够有表达力，就不需要注释，尽量通过代码来阐述。

举个例子：

去掉下面复杂的注释，只需要创建一个与注释所言同一事物的函数即可
// check to see if the employee is eligible for full benefits
if ((employee.flags & HOURLY_FLAG) && (employee.age > 65))
应替换为

软件工程简明教程

Fri, 17 Feb 2023 15:38:09 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

大部分软件开发从业者，都会忽略软件开发中的一些最基础、最底层的一些概念。但是，这些软件开发的概念对于软件开发来说非常重要，就像是软件开发的基石一样。这也是我写这篇文章的原因。

何为软件工程？#

1968 年 NATO（北大西洋公约组织）提出了软件危机（Software crisis）一词。同年，为了解决软件危机问题，“软件工程”的概念诞生了。一门叫做软件工程的学科也就应运而生。

随着时间的推移，软件工程这门学科也经历了一轮又一轮的完善，其中的一些核心内容比如软件开发模型越来越丰富实用！

什么是软件危机呢？

简单来说，软件危机描述了当时软件开发的一个痛点：我们很难高效地开发出质量高的软件。

Dijkstra（Dijkstra算法的作者）在 1972年图灵奖获奖感言中也提高过软件危机，他是这样说的：“导致软件危机的主要原因是机器变得功能强大了几个数量级！坦率地说：只要没有机器，编程就完全没有问题。当我们有一些弱小的计算机时，编程成为一个温和的问题，而现在我们有了庞大的计算机，编程也同样成为一个巨大的问题”。

说了这么多，到底什么是软件工程呢？

工程是为了解决实际的问题将理论应用于实践。软件工程指的就是将工程思想应用于软件开发。

上面是我对软件工程的定义，我们再来看看比较权威的定义。IEEE 软件工程汇刊给出的定义是这样的：　(1)将系统化的、规范的、可量化的方法应用到软件的开发、运行及维护中，即将工程化方法应用于软件。　(2)在(1)中所述方法的研究。

总之，软件工程的终极目标就是：在更少资源消耗的情况下，创造出更好、更容易维护的软件。

软件开发过程#

维基百科是这样定义软件开发过程的：

软件开发过程（英语：software development process），或软件过程（英语：software process），是软件开发的开发生命周期（software development life cycle），其各个阶段实现了软件的需求定义与分析、设计、实现、测试、交付和维护。软件过程是在开发与构建系统时应遵循的步骤，是软件开发的路线图。

需求分析：分析用户的需求，建立逻辑模型。
软件设计：根据需求分析的结果对软件架构进行设计。
编码：编写程序运行的源代码。
测试 : 确定测试用例，编写测试报告。
交付：将做好的软件交付给客户。
维护：对软件进行维护比如解决 bug，完善功能。

软件开发过程只是比较笼统的层面上，一定义了一个软件开发可能涉及到的一些流程。

软件开发模型更具体地定义了软件开发过程，对开发过程提供了强有力的理论支持。

软件开发模型#

软件开发模型有很多种，比如瀑布模型（Waterfall Model）、快速原型模型（Rapid Prototype Model）、V模型（V-model）、W模型（W-model）、敏捷开发模型。其中最具有代表性的还是 瀑布模型 和 敏捷开发 。

瀑布模型 定义了一套完成的软件开发周期，完整地展示了一个软件的的生命周期。

敏捷开发模型 是目前使用的最多的一种软件开发模型。 MBA智库百科对敏捷开发的描述是这样的:

敏捷开发 是一种以人为核心、迭代、循序渐进的开发方法。在敏捷开发中，软件项目的构建被切分成多个子项目，各个子项目的成果都经过测试，具备集成和可运行的特征。换言之，就是把一个大项目分为多个相互联系，但也可独立运行的小项目，并分别完成，在此过程中软件一直处于可使用状态。

像现在比较常见的一些概念比如 持续集成 、重构、小版本发布 、低文档 、站会、结对编程 、测试驱动开发 都是敏捷开发的核心。

restFul

Fri, 17 Feb 2023 14:35:02 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

这篇文章简单聊聊后端程序员必备的 RESTful API 相关的知识。

开始正式介绍 RESTful API 之前，我们需要首先搞清：API 到底是什么？

# 何为 API？#

API（Application Programming Interface） 翻译过来是应用程序编程接口的意思。

我们在进行后端开发的时候，主要的工作就是为前端或者其他后端服务提供 API 比如查询用户数据的 API 。

但是， API 不仅仅代表后端系统暴露的接口，像框架中提供的方法也属于 API 的范畴。

为了方便大家理解，我再列举几个例子 🌰：

你通过某电商网站搜索某某商品，电商网站的前端就调用了后端提供了搜索商品相关的 API。
你使用 JDK 开发 Java 程序，想要读取用户的输入的话，你就需要使用 JDK 提供的 IO 相关的 API。
……

你可以把 API 理解为程序与程序之间通信的桥梁，其本质就是一个函数而已。另外，API 的使用也不是没有章法的，它的规则由（比如数据输入和输出的格式）API 提供方制定。

# 何为 RESTful API？#

RESTful API 经常也被叫做 REST API，它是基于 REST 构建的 API。这个 REST 到底是什么，我们后文在讲，涉及到的概念比较多。

如果你看 RESTful API 相关的文章的话一般都比较晦涩难懂，主要是因为 REST 涉及到的一些概念比较难以理解。但是，实际上，我们平时开发用到的 RESTful API 的知识非常简单也很容易概括！

性能测试入门

Fri, 17 Feb 2023 11:37:08 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

性能测试一般情况下都是由测试这个职位去做的，那还需要我们开发学这个干嘛呢？了解性能测试的指标、分类以及工具等知识有助于我们更好地去写出性能更好的程序，另外作为开发这个角色，如果你会性能测试的话，相信也会为你的履历加分不少。

这篇文章是我会结合自己的实际经历以及在测试这里取的经所得，除此之外，我还借鉴了一些优秀书籍，希望对你有帮助。

本文思维导图：

# 一不同角色看网站性能#

# 1.1 用户#

当用户打开一个网站的时候，最关注的是什么？当然是网站响应速度的快慢。比如我们点击了淘宝的主页，淘宝需要多久将首页的内容呈现在我的面前，我点击了提交订单按钮需要多久返回结果等等。

所以，用户在体验我们系统的时候往往根据你的响应速度的快慢来评判你的网站的性能。

# 1.2 开发人员#

用户与开发人员都关注速度，这个速度实际上就是我们的系统处理用户请求的速度。

开发人员一般情况下很难直观的去评判自己网站的性能，我们往往会根据网站当前的架构以及基础设施情况给一个大概的值,比如：

项目架构是分布式的吗？
用到了缓存和消息队列没有？
高并发的业务有没有特殊处理？
数据库设计是否合理？
系统用到的算法是否还需要优化？
系统是否存在内存泄露的问题？
项目使用的 Redis 缓存多大？服务器性能如何？用的是机械硬盘还是固态硬盘？
……

# 1.3 测试人员#

测试人员一般会根据性能测试工具来测试，然后一般会做出一个表格。这个表格可能会涵盖下面这些重要的内容：

响应时间；
请求成功率；
吞吐量；
……

# 1.4 运维人员#

运维人员会倾向于根据基础设施和资源的利用率来判断网站的性能，比如我们的服务器资源使用是否合理、数据库资源是否存在滥用的情况、当然，这是传统的运维人员，现在 Devpos 火起来后，单纯干运维的很少了。我们这里暂且还保留有这个角色。

# 二性能测试需要注意的点#

几乎没有文章在讲性能测试的时候提到这个问题，大家都会讲如何去性能测试，有哪些性能测试指标这些东西。

# 2.1 了解系统的业务场景#

性能测试之前更需要你了解当前的系统的业务场景。 对系统业务了解的不够深刻，我们很容易犯测试方向偏执的错误，从而导致我们忽略了对系统某些更需要性能测试的地方进行测试。比如我们的系统可以为用户提供发送邮件的功能，用户配置成功邮箱后只需输入相应的邮箱之后就能发送，系统每天大概能处理上万次发邮件的请求。很多人看到这个可能就直接开始使用相关工具测试邮箱发送接口，但是，发送邮件这个场景可能不是当前系统的性能瓶颈，这么多人用我们的系统发邮件，还可能有很多人一起发邮件，单单这个场景就这么人用，那用户管理可能才是性能瓶颈吧！

# 2.2 历史数据非常有用#

当前系统所留下的历史数据非常重要，一般情况下，我们可以通过相应的些历史数据初步判定这个系统哪些接口调用的比较多、哪些 service 承受的压力最大，这样的话，我们就可以针对这些地方进行更细致的性能测试与分析。

另外，这些地方也就像这个系统的一个短板一样，优化好了这些地方会为我们的系统带来质的提升。

# 三性能测试的指标#

# 3.1 响应时间#

响应时间就是用户发出请求到用户收到系统处理结果所需要的时间。 重要吗？实在太重要！

比较出名的 2-5-8 原则是这样描述的：通常来说，2到5秒，页面体验会比较好，5到8秒还可以接受，8秒以上基本就很难接受了。另外，据统计当网站慢一秒就会流失十分之一的客户。

超时&重试详解

Fri, 17 Feb 2023 10:57:02 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

由于网络问题、系统或者服务内部的 Bug、服务器宕机、操作系统崩溃等问题的不确定性，我们的系统或者服务永远不可能保证时刻都是可用的状态。

为了最大限度的减小系统或者服务出现故障之后带来的影响，我们需要用到的 超时（Timeout） 和 重试（Retry） 机制。

想要把超时和重试机制讲清楚其实很简单，因为它俩本身就不是什么高深的概念。

虽然超时和重试机制的思想很简单，但是它俩是真的非常实用。你平时接触到的绝大部分涉及到远程调用的系统或者服务都会应用超时和重试机制。尤其是对于微服务系统来说，正确设置超时和重试非常重要。单体服务通常只涉及数据库、缓存、第三方 API、中间件等的网络调用，而微服务系统内部各个服务之间还存在着网络调用。

# 超时机制#

# 什么是超时机制？#

超时机制说的是当一个请求超过指定的时间（比如 1s）还没有被处理的话，这个请求就会直接被取消并抛出指定的异常或者错误（比如 504 Gateway Timeout）。

我们平时接触到的超时可以简单分为下面 2 种：

连接超时（ConnectTimeout） ：客户端与服务端建立连接的最长等待时间。
读取超时（ReadTimeout） ：客户端和服务端已经建立连接，客户端等待服务端处理完请求的最长时间。实际项目中，我们关注比较多的还是读取超时。

一些连接池客户端框架中可能还会有获取连接超时和空闲连接清理超时**。

如果没有设置超时的话，就可能会导致服务端连接数爆炸和大量请求堆积的问题。

这些堆积的连接和请求会消耗系统资源，影响新收到的请求的处理。严重的情况下，甚至会拖垮整个系统或者服务。

我之前在实际项目就遇到过类似的问题，整个网站无法正常处理请求，服务器负载直接快被拉满。后面发现原因是项目超时设置错误加上客户端请求处理异常，导致服务端连接数直接接近 40w+，这么多堆积的连接直接把系统干趴了。

# 超时时间应该如何设置？#

超时到底设置多长时间是一个难题！超时值设置太高或者太低都有风险。如果设置太高的话，会降低超时机制的有效性，比如你设置超时为 10s 的话，那设置超时就没啥意义了，系统依然可能会出现大量慢请求堆积的问题。如果设置太低的话，就可能会导致在系统或者服务在某些处理请求速度变慢的情况下（比如请求突然增多），大量请求重试（超时通常会结合重试）继续加重系统或者服务的压力，进而导致整个系统或者服务被拖垮的问题。

通常情况下，我们建议读取超时设置为 1500ms ,这是一个比较普适的值。如果你的系统或者服务对于延迟比较敏感的话，那读取超时值可以适当在 1500ms 的基础上进行缩短。反之，读取超时值也可以在 1500ms 的基础上进行加长，不过，尽量还是不要超过 1500ms 。连接超时可以适当设置长一些，建议在 1000ms ~ 5000ms 之内。

没有银弹！超时值具体该设置多大，还是要根据实际项目的需求和情况慢慢调整优化得到。

更上一层，参考美团的Java线程池参数动态配置open in new window思想，我们也可以将超时弄成可配置化的参数而不是固定的，比较简单的一种办法就是将超时的值放在配置中心中。这样的话，我们就可以根据系统或者服务的状态动态调整超时值了。

# 重试机制#

# 什么是重试机制？#

重试机制一般配合超时机制一起使用，指的是多次发送相同的请求来避免瞬态故障和偶然性故障。

瞬态故障可以简单理解为某一瞬间系统偶然出现的故障，并不会持久。偶然性故障可以理解为哪些在某些情况下偶尔出现的故障，频率通常较低。

重试的核心思想是通过消耗服务器的资源来尽可能获得请求更大概率被成功处理。由于瞬态故障和偶然性故障是很少发生的，因此，重试对于服务器的资源消耗几乎是可以被忽略的。

# 重试的次数如何设置？#

重试的次数不宜过多，否则依然会对系统负载造成比较大的压力。

重试的次数通常建议设为 3 次。并且，我们通常还会设置重试的间隔，比如说我们要重试 3 次的话，第 1 次请求失败后，等待 1 秒再进行重试，第 2 次请求失败后，等待 2 秒再进行重试，第 3 次请求失败后，等待 3 秒再进行重试。

服务限流详解

Thu, 16 Feb 2023 17:06:11 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

针对软件系统来说，限流就是对请求的速率进行限制，避免瞬时的大量请求击垮软件系统。毕竟，软件系统的处理能力是有限的。如果说超过了其处理能力的范围，软件系统可能直接就挂掉了。

限流可能会导致用户的请求无法被正确处理，不过，这往往也是权衡了软件系统的稳定性之后得到的最优解。

现实生活中，处处都有限流的实际应用，就比如排队买票是为了避免大量用户涌入购票而导致售票员无法处理。

常见限流算法有哪些？#

简单介绍 4 种非常好理解并且容易实现的限流算法！

图片来源于 InfoQ 的一篇文章《分布式服务限流实战，已经为你排好坑了》。

固定窗口计数器算法#

固定窗口其实就是时间窗口。固定窗口计数器算法 规定了我们单位时间处理的请求数量。

假如我们规定系统中某个接口 1 分钟只能访问 33 次的话，使用固定窗口计数器算法的实现思路如下：

给定一个变量 counter 来记录当前接口处理的请求数量，初始值为 0（代表接口当前 1 分钟内还未处理请求）。
1 分钟之内每处理一个请求之后就将 counter+1 ，当 counter=33 之后（也就是说在这 1 分钟内接口已经被访问 33 次的话），后续的请求就会被全部拒绝。
等到 1 分钟结束后，将 counter 重置 0，重新开始计数。

这种限流算法无法保证限流速率，因而无法保证突然激增的流量。

就比如说我们限制某个接口 1 分钟只能访问 1000 次，该接口的 QPS 为 500，前 55s 这个接口 1 个请求没有接收，后 1s 突然接收了 1000 个请求。然后，在当前场景下，这 1000 个请求在 1s 内是没办法被处理的，系统直接就被瞬时的大量请求给击垮了。

滑动窗口计数器算法#

滑动窗口计数器算法 算的上是固定窗口计数器算法的升级版。

冗余设计

Thu, 16 Feb 2023 16:54:24 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

title	category
冗余设计详解	高可用

冗余设计是保证系统和数据高可用的最常的手段。

对于服务来说，冗余的思想就是相同的服务部署多份，如果正在使用的服务突然挂掉的话，系统可以很快切换到备份服务上，大大减少系统的不可用时间，提高系统的可用性。

对于数据来说，冗余的思想就是相同的数据备份多份，这样就可以很简单地提高数据的安全性。

实际上，日常生活中就有非常多的冗余思想的应用。

拿我自己来说，我对于重要文件的保存方法就是冗余思想的应用。我日常所使用的重要文件都会同步一份在 Github 以及个人云盘上，这样就可以保证即使电脑硬盘损坏，我也可以通过 Github 或者个人云盘找回自己的重要文件。

高可用集群（High Availability Cluster，简称 HA Cluster）、同城灾备、异地灾备、同城多活和异地多活是冗余思想在高可用系统设计中最典型的应用。

高可用集群 : 同一份服务部署两份或者多份，当正在使用的服务突然挂掉的话，可以切换到另外一台服务，从而保证服务的高可用。
同城灾备 ：一整个集群可以部署在同一个机房，而同城灾备中相同服务部署在同一个城市的不同机房中。并且，备用服务不处理请求。这样可以避免机房出现意外情况比如停电、火灾。
异地灾备 ：类似于同城灾备，不同的是，相同服务部署在异地（通常距离较远，甚至是在不同的城市或者国家）的不同机房中
同城多活 ：类似于同城灾备，但备用服务可以处理请求，这样可以充分利用系统资源，提高系统的并发。
异地多活 : 将服务部署在异地的不同机房中，并且，它们可以同时对外提供服务。

高可用集群单纯是服务的冗余，并没有强调地域。同城灾备、异地灾备、同城多活和异地多活实现了地域上的冗余。

同城和异地的主要区别在于机房之间的距离。异地通常距离较远，甚至是在不同的城市或者国家。

和传统的灾备设计相比，同城多活和异地多活最明显的改变在于**“多活”，即所有站点都是同时在对外提供服务的。异地多活是为了应对突发状况比如火灾**、地震等自然或者人为灾害。

光做好冗余还不够，必须要配合上 故障转移 才可以！所谓故障转移，简单来说就是实现不可用服务快速且自动地切换到可用服务，整个过程不需要人为干涉。

举个例子：哨兵模式的 Redis 集群中，如果 Sentinel（哨兵）检测到 master 节点出现故障的话，它就会帮助我们实现故障转移，自动将某一台 slave 升级为 master，确保整个 Redis 系统的可用性。整个过程完全自动，不需要人工介入。我在《Java 面试指北》的「技术面试题篇」中的数据库部分详细介绍了 Redis 集群相关的知识点&面试题，感兴趣的小伙伴可以看看。

再举个例子：Nginx 可以结合 Keepalived 来实现高可用。如果 Nginx 主服务器宕机的话，Keepalived 可以自动进行故障转移，备用 Nginx 主服务器升级为主服务。并且，这个切换对外是透明的，因为使用的虚拟 IP，虚拟 IP 不会改变。我在《Java 面试指北》的「技术面试题篇」中的「服务器」部分详细介绍了 Nginx 相关的知识点&面试题，感兴趣的小伙伴可以看看。

高可用系统设计指南

Thu, 16 Feb 2023 15:43:06 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

什么是高可用？可用性的判断标准是啥？#

高可用描述的是一个系统在大部分时间都是可用的，可以为我们提供服务的。高可用代表系统即使在发生硬件故障或者系统升级的时候，服务仍然是可用的。

一般情况下，我们使用多少个 9 来评判一个系统的可用性，比如 99.9999% 就是代表该系统在所有的运行时间中只有 0.0001% 的时间是不可用的，这样的系统就是非常非常高可用的了！当然，也会有系统如果可用性不太好的话，可能连 9 都上不了。

除此之外，系统的可用性还可以用某功能的失败次数与总的请求次数之比来衡量，比如对网站请求 1000 次，其中有 10 次请求失败，那么可用性就是 99%。

哪些情况会导致系统不可用？#

黑客攻击；
硬件故障，比如服务器坏掉。
并发量/用户请求量激增导致整个服务宕掉或者部分服务不可用。
代码中的坏味道导致内存泄漏或者其他问题导致程序挂掉。
网站架构某个重要的角色比如 Nginx 或者数据库突然不可用。
自然灾害或者人为破坏。
……

有哪些提高系统可用性的方法？#

注重代码质量，测试严格把关#

我觉得这个是最最最重要的，代码质量有问题比如比较常见的内存泄漏、循环依赖都是对系统可用性极大的损害。大家都喜欢谈限流、降级、熔断，但是我觉得从代码质量这个源头把关是首先要做好的一件很重要的事情。如何提高代码质量？比较实际可用的就是 CodeReview，不要在乎每天多花的那 1 个小时左右的时间，作用可大着呢！

另外，安利几个对提高代码质量有实际效果的神器：

Sonarqube；
Alibaba 开源的 Java 诊断工具 Arthas；
阿里巴巴 Java 代码规范（Alibaba Java Code Guidelines）；
IDEA 自带的代码分析等工具。

使用集群，减少单点故障#

先拿常用的 Redis 举个例子！我们如何保证我们的 Redis 缓存高可用呢？答案就是使用集群，避免单点故障。当我们使用一个 Redis 实例作为缓存的时候，这个 Redis 实例挂了之后，整个缓存服务可能就挂了。使用了集群之后，即使一台 Redis 实例挂了，不到一秒就会有另外一台 Redis 实例顶上。

限流#

流量控制（flow control），其原理是监控应用流量的 QPS 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。——来自 alibaba-Sentinel 的 wiki。

超时和重试机制设置#

一旦用户请求超过某个时间的得不到响应，就抛出异常。这个是非常重要的，很多线上系统故障都是因为没有进行超时设置或者超时设置的方式不对导致的。我们在读取第三方服务的时候，尤其适合设置超时和重试机制。一般我们使用一些 RPC 框架的时候，这些框架都自带的超时重试的配置。如果不进行超时设置可能会导致请求响应速度慢，甚至导致请求堆积进而让系统无法再处理请求。重试的次数一般设为 3 次，再多次的重试没有好处，反而会加重服务器压力（部分场景使用失败重试机制会不太适合）。

rocketmq常见面试题

Wed, 15 Feb 2023 09:58:47 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

本文来自读者 PR。

主要是rocket mq的几个问题

1 单机版消息中心#

一个消息中心，最基本的需要支持多生产者、多消费者，例如下：

class Scratch {

 public static void main(String[] args) {
 // 实际中会有 nameserver 服务来找到 broker 具体位置以及 broker 主从信息
 Broker broker = new Broker();
 Producer producer1 = new Producer();
 producer1.connectBroker(broker);
 Producer producer2 = new Producer();
 producer2.connectBroker(broker);

 Consumer consumer1 = new Consumer();
 consumer1.connectBroker(broker);
 Consumer consumer2 = new Consumer();
 consumer2.connectBroker(broker);

 for (int i = 0; i < 2; i++) {
 producer1.asyncSendMsg("producer1 send msg" + i);
 producer2.asyncSendMsg("producer2 send msg" + i);
 }
 System.out.println("broker has msg:" + broker.getAllMagByDisk());

 for (int i = 0; i < 1; i++) {
 System.out.println("consumer1 consume msg：" + consumer1.syncPullMsg());
 }
 for (int i = 0; i < 3; i++) {
 System.out.println("consumer2 consume msg：" + consumer2.syncPullMsg());
 }
 }

}

class Producer {

 private Broker broker;

 public void connectBroker(Broker broker) {
 this.broker = broker;
 }

 public void asyncSendMsg(String msg) {
 if (broker == null) {
 throw new RuntimeException("please connect broker first");
 }
 new Thread(() -> {
 broker.sendMsg(msg);
 }).start();
 }
}

class Consumer {
 private Broker broker;

 public void connectBroker(Broker broker) {
 this.broker = broker;
 }

 public String syncPullMsg() {
 return broker.getMsg();
 }

}

class Broker {

 // 对应 RocketMQ 中 MessageQueue，默认情况下 1 个 Topic 包含 4 个 MessageQueue
 private LinkedBlockingQueue<String> messageQueue = new LinkedBlockingQueue(Integer.MAX_VALUE);

 // 实际发送消息到 broker 服务器使用 Netty 发送
 public void sendMsg(String msg) {
 try {
 messageQueue.put(msg);
 // 实际会同步或异步落盘，异步落盘使用的定时任务定时扫描落盘
 } catch (InterruptedException e) {

 }
 }

 public String getMsg() {
 try {
 return messageQueue.take();
 } catch (InterruptedException e) {

 }
 return null;
 }

 public String getAllMagByDisk() {
 StringBuilder sb = new StringBuilder("\n");
 messageQueue.iterator().forEachRemaining((msg) -> {
 sb.append(msg + "\n");
 });
 return sb.toString();
 }
}

问题：

rocketmq介绍

Wed, 15 Feb 2023 09:58:20 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

消息队列扫盲#

消息队列顾名思义就是存放消息的队列，队列我就不解释了，别告诉我你连队列都不知道是啥吧？

所以问题并不是消息队列是什么，而是 消息队列为什么会出现？消息队列能用来干什么？用它来干这些事会带来什么好处？消息队列会带来副作用吗？

# 消息队列为什么会出现？#

消息队列算是作为后端程序员的一个必备技能吧，因为分布式应用必定涉及到各个系统之间的通信问题，这个时候消息队列也应运而生了。可以说分布式的产生是消息队列的基础，而分布式怕是一个很古老的概念了吧，所以消息队列也是一个很古老的中间件了。

# 消息队列能用来干什么？#

# 异步#

你可能会反驳我，应用之间的通信又不是只能由消息队列解决，好好的通信为什么中间非要插一个消息队列呢？我不能直接进行通信吗？

很好👍，你又提出了一个概念，同步通信。就比如现在业界使用比较多的 Dubbo 就是一个适用于各个系统之间同步通信的 RPC 框架。

我来举个🌰吧，比如我们有一个购票系统，需求是用户在购买完之后能接收到购买完成的短信。

我们省略中间的网络通信时间消耗，假如购票系统处理需要 150ms ，短信系统处理需要 200ms ，那么整个处理流程的时间消耗就是 150ms + 200ms = 350ms。

当然，乍看没什么问题。可是仔细一想你就感觉有点问题，我用户购票在购票系统的时候其实就已经完成了购买，而我现在通过同步调用非要让整个请求拉长时间，而短信系统这玩意又不是很有必要，它仅仅是一个辅助功能增强用户体验感而已。我现在整个调用流程就有点 头重脚轻 的感觉了，购票是一个不太耗时的流程，而我现在因为同步调用，非要等待发送短信这个比较耗时的操作才返回结果。那我如果再加一个发送邮件呢？

这样整个系统的调用链又变长了，整个时间就变成了550ms。

当我们在学生时代需要在食堂排队的时候，我们和食堂大妈就是一个同步的模型。

我们需要告诉食堂大妈：“姐姐，给我加个鸡腿，再加个酸辣土豆丝，帮我浇点汁上去，多打点饭哦😋😋😋” 咦~~~ 为了多吃点，真恶心。

然后大妈帮我们打饭配菜，我们看着大妈那颤抖的手和掉落的土豆丝不禁咽了咽口水。

最终我们从大妈手中接过饭菜然后去寻找座位了…

回想一下，我们在给大妈发送需要的信息之后我们是 同步等待大妈给我配好饭菜 的，上面我们只是加了鸡腿和土豆丝，万一我再加一个番茄牛腩，韭菜鸡蛋，这样是不是大妈打饭配菜的流程就会变长，我们等待的时间也会相应的变长。

那后来，我们工作赚钱了有钱去饭店吃饭了，我们告诉服务员来一碗牛肉面加个荷包蛋 (传达一个消息) ，然后我们就可以在饭桌上安心的玩手机了 (干自己其他事情) ，等到我们的牛肉面上了我们就可以吃了。这其中我们也就传达了一个消息，然后我们又转过头干其他事情了。这其中虽然做面的时间没有变短，但是我们只需要传达一个消息就可以干其他事情了，这是一个异步的概念。

所以，为了解决这一个问题，聪明的程序员在中间也加了个类似于服务员的中间件——消息队列。这个时候我们就可以把模型给改造了。

这样，我们在将消息存入消息队列之后我们就可以直接返回了(我们告诉服务员我们要吃什么然后玩手机)，所以整个耗时只是 150ms + 10ms = 160ms。

但是你需要注意的是，整个流程的时长是没变的，就像你仅仅告诉服务员要吃什么是不会影响到做面的速度的。

# 解耦#

回到最初同步调用的过程，我们写个伪代码简单概括一下。

message-queue

Wed, 15 Feb 2023 09:56:36 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

“RabbitMQ？”“Kafka？”“RocketMQ？”…在日常学习与开发过程中，我们常常听到消息队列这个关键词。我也在我的多篇文章中提到了这个概念。可能你是熟练使用消息队列的老手，又或者你是不懂消息队列的新手，不论你了不了解消息队列，本文都将带你搞懂消息队列的一些基本理论。

如果你是老手，你可能从本文学到你之前不曾注意的一些关于消息队列的重要概念，如果你是新手，相信本文将是你打开消息队列大门的一板砖。

什么是消息队列？#

我们可以把消息队列看作是一个存放消息的容器，当我们需要使用消息的时候，直接从容器中取出消息供自己使用即可。由于队列 Queue 是一种先进先出的数据结构，所以消费消息时也是按照顺序来消费的。

参与消息传递的双方称为生产者和消费者，生产者负责发送消息，消费者负责处理消息。

我们知道操作系统中的进程通信的一种很重要的方式就是消息队列。我们这里提到的消息队列稍微有点区别，更多指的是各个服务以及系统内部各个组件/模块之前的通信，属于一种中间件。

随着分布式和微服务系统的发展，消息队列在系统设计中有了更大的发挥空间，使用消息队列可以降低系统耦合性、实现任务异步、有效地进行流量削峰，是分布式和微服务系统中重要的组件之一。

消息队列有什么用？#

通常来说，使用消息队列能为我们的系统带来下面三点好处：

通过异步处理提高系统性能（减少响应所需时间）。
削峰/限流
降低系统耦合性。

如果在面试的时候你被面试官问到这个问题的话，一般情况是你在你的简历上涉及到消息队列这方面的内容，这个时候推荐你结合你自己的项目来回答。

通过异步处理提高系统性能（减少响应所需时间）#

将用户的请求数据存储到消息队列之后就立即返回结果。随后，系统再对消息进行消费。

因为用户请求数据写入消息队列之后就立即返回给用户了，但是请求数据在后续的业务校验、写数据库等操作中可能失败。因此，使用消息队列进行异步处理之后，需要适当修改业务流程进行配合，比如用户在提交订单之后，订单数据写入消息队列，不能立即返回用户订单提交成功，需要在消息队列的订单消费者进程真正处理完该订单之后，甚至出库后，再通过电子邮件或短信通知用户订单成功，以免交易纠纷。这就类似我们平时手机订火车票和电影票。

削峰/限流#

先将短时间高并发产生的事务消息存储在消息队列中，然后后端服务再慢慢根据自己的能力去消费这些消息，这样就避免直接把后端服务打垮掉。

举例：在电子商务一些秒杀、促销活动中，合理使用消息队列可以有效抵御促销活动刚开始大量订单涌入对系统的冲击。如下图所示：

降低系统耦合性#

使用消息队列还可以降低系统耦合性。我们知道如果模块之间不存在直接调用，那么新增模块或者修改模块就对其他模块影响较小，这样系统的可扩展性无疑更好一些。还是直接上图吧：

生产者（客户端）发送消息到消息队列中去，接受者（服务端）处理消息，需要消费的系统直接去消息队列取消息进行消费即可而不需要和其他系统有耦合，这显然也提高了系统的扩展性。

消息队列使用发布-订阅模式工作，消息发送者（生产者）发布消息，一个或多个消息接受者（消费者）订阅消息。 从上图可以看到消息发送者（生产者）和消息接受者（消费者）之间没有直接耦合，消息发送者将消息发送至分布式消息队列即结束对消息的处理，消息接受者从分布式消息队列获取该消息后进行后续处理，并不需要知道该消息从何而来。对新增业务，只要对该类消息感兴趣，即可订阅该消息，对原有系统和业务没有任何影响，从而实现网站业务的可扩展性设计。

消息接受者对消息进行过滤、处理、包装后，构造成一个新的消息类型，将消息继续发送出去，等待其他消息接受者订阅该消息。因此基于事件（消息对象）驱动的业务架构可以是一系列流程。

另外，为了避免消息队列服务器宕机造成消息丢失，会将成功发送到消息队列的消息存储在消息生产者服务器上，等消息真正被消费者服务器处理后才删除消息。在消息队列服务器宕机后，生产者服务器会选择分布式消息队列服务器集群中的其他服务器发布消息。

备注： 不要认为消息队列只能利用发布-订阅模式工作，只不过在解耦这个特定业务环境下是使用发布-订阅模式的。除了发布-订阅模式，还有点对点订阅模式（一个消息只有一个消费者），我们比较常用的是发布-订阅模式。另外，这两种消息模型是 JMS 提供的，AMQP 协议还提供了 5 种消息模型。

使用消息队列哪些问题？#

系统可用性降低： 系统可用性在某种程度上降低，为什么这样说呢？在加入 MQ 之前，你不用考虑消息丢失或者说 MQ 挂掉等等的情况，但是，引入 MQ 之后你就需要去考虑了！
系统复杂性提高： 加入 MQ 之后，你需要保证消息没有被重复消费、处理消息丢失的情况、保证消息传递的顺序性等等问题！
一致性问题： 我上面讲了消息队列可以实现异步，消息队列带来的异步确实可以提高系统响应速度。但是，万一消息的真正消费者并没有正确消费消息怎么办？这样就会导致数据不一致的情况了!

JMS 和 AMQP#

JMS 是什么？#

JMS（JAVA Message Service,java 消息服务）是 java 的消息服务，JMS 的客户端之间可以通过 JMS 服务进行异步的消息传输。JMS（JAVA Message Service，Java 消息服务）API 是一个消息服务的标准或者说是规范，允许应用程序组件基于 JavaEE 平台创建、发送、接收和读取消息。它使分布式通信耦合度更低，消息服务更加可靠以及异步性。

cdn

Tue, 14 Feb 2023 16:57:38 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

什么是 CDN ？#

CDN 全称是 Content Delivery Network/Content Distribution Network，翻译过的意思是 内容分发网络 。

我们可以将内容分发网络拆开来看：

内容：指的是静态资源比如图片、视频、文档、JS、CSS、HTML。
分发网络 ：指的是将这些静态资源分发到位于多个不同的地理位置机房中的服务器上，这样，就可以实现静态资源的就近访问比如北京的用户直接访问北京机房的数据。

所以，简单来说，CDN 就是将静态资源分发到多个不同的地方以实现就近访问，进而加快静态资源的访问速度，减轻服务器以及带宽的负担。

类似于京东建立的庞大的仓储运输体系，京东物流在全国拥有非常多的仓库，仓储网络几乎覆盖全国所有区县。这样的话，用户下单的第一时间，商品就从距离用户最近的仓库，直接发往对应的配送站，再由京东小哥送到你家。

你可以将 CDN 看作是服务上一层的特殊缓存服务，分布在全国各地，主要用来处理静态资源的请求。

我们经常拿全站加速和内容分发网络做对比，不要把两者搞混了！全站加速（不同云服务商叫法不同，腾讯云叫 ECDN、阿里云叫 DCDN）既可以加速静态资源又可以加速动态资源，**内容分发网络（CDN）**主要针对的是 静态资源 。

绝大部分公司都会在项目开发中交使用 CDN 服务，但很少会有自建 CDN 服务的公司。基于成本、稳定性和易用性考虑，建议直接选择专业的云厂商（比如阿里云、腾讯云、华为云、青云）或者 CDN 厂商（比如网宿、蓝汛）提供的开箱即用的 CDN 服务。

很多朋友可能要问了：既然是就近访问，为什么不直接将服务部署在多个不同的地方呢？

成本太高，需要部署多份相同的服务。
静态资源通常占用空间比较大且经常会被访问到，如果直接使用服务器或者缓存来处理静态资源请求的话，对系统资源消耗非常大，可能会影响到系统其他服务的正常运行。

同一个服务在在多个不同的地方部署多份（比如同城灾备、异地灾备、同城多活、异地多活）是为了实现系统的高可用而不是就近访问。

CDN 工作原理是什么？#

搞懂下面 3 个问题也就搞懂了 CDN 的工作原理：

静态资源是如何被缓存到 CDN 节点中的？
如何找到最合适的 CDN 节点？
如何防止静态资源被盗用？

静态资源是如何被缓存到 CDN 节点中的？#

你可以通过预热的方式将源站的资源同步到 CDN 的节点中。这样的话，用户首次请求资源可以直接从 CDN 节点中取，无需回源。这样可以降低源站压力，提升用户体验。

数据库读写分离&分库分表详解

Tue, 14 Feb 2023 16:38:42 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

读写分离#

什么是读写分离？#

见名思意，根据读写分离的名字，我们就可以知道：读写分离主要是为了将对数据库的读写操作分散到不同的数据库节点上。 这样的话，就能够小幅提升写性能，大幅提升读性能。

我简单画了一张图来帮助不太清楚读写分离的小伙伴理解。

一般情况下，我们都会选择一主多从，也就是一台主数据库负责写，其他的从数据库负责读。主库和从库之间会进行数据同步，以保证从库中数据的准确性。这样的架构实现起来比较简单，并且也符合系统的写少读多的特点。

读写分离会带来什么问题？如何解决？#

读写分离对于提升数据库的并发非常有效，但是，同时也会引来一个问题：主库和从库的数据存在延迟，比如你写完主库之后，主库的数据同步到从库是需要时间的，这个时间差就导致了主库和从库的数据不一致性问题。这也就是我们经常说的 主从同步延迟 。

主从同步延迟问题的解决，没有特别好的一种方案（可能是我太菜了，欢迎评论区补充）。你可以根据自己的业务场景，参考一下下面几种解决办法。

1.强制将读请求路由到主库处理。

既然你从库的数据过期了，那我就直接从主库读取嘛！这种方案虽然会增加主库的压力，但是，实现起来比较简单，也是我了解到的使用最多的一种方式。

比如 Sharding-JDBC 就是采用的这种方案。通过使用 Sharding-JDBC 的 HintManager 分片键值管理器，我们可以强制使用主库。

HintManager hintManager = HintManager.getInstance();
hintManager.setMasterRouteOnly();
// 继续JDBC操作

对于这种方案，你可以将那些必须获取最新数据的读请求都交给主库处理。

2.延迟读取。

还有一些朋友肯定会想既然主从同步存在延迟，那我就在延迟之后读取啊，比如主从同步延迟 0.5s,那我就 1s 之后再读取数据。这样多方便啊！方便是方便，但是也很扯淡。

不过，如果你是这样设计业务流程就会好很多：对于一些对数据比较敏感的场景，你可以在完成写请求之后，避免立即进行请求操作。比如你支付成功之后，跳转到一个支付成功的页面，当你点击返回之后才返回自己的账户。

另外，《MySQL 实战 45 讲》这个专栏中的《读写分离有哪些坑？》这篇文章还介绍了很多其他比较实际的解决办法，感兴趣的小伙伴可以自行研究一下。

如何实现读写分离？#

不论是使用哪一种读写分离具体的实现方案，想要实现读写分离一般包含如下几步：

部署多台数据库，选择其中的一台作为主数据库，其他的一台或者多台作为从数据库。
保证主数据库和从数据库之间的数据是实时同步的，这个过程也就是我们常说的主从复制。
系统将写请求交给主数据库处理，读请求交给从数据库处理。[ 使用上 ]

落实到项目本身的话，常用的方式有两种：

1.代理方式

我们可以在应用和数据中间加了一个代理层。应用程序所有的数据请求都交给代理层处理，代理层负责分离读写请求，将它们路由到对应的数据库中。

提供类似功能的中间件有 MySQL Router（官方）、Atlas（基于 MySQL Proxy）、Maxscale、MyCat。

2.组件方式

在这种方式中，我们可以通过引入第三方组件来帮助我们读写请求。

这也是我比较推荐的一种方式。这种方式目前在各种互联网公司中用的最多的，相关的实际的案例也非常多。如果你要采用这种方式的话，推荐使用 sharding-jdbc ，直接引入 jar 包即可使用，非常方便。同时，也节省了很多运维的成本。

你可以在 shardingsphere 官方找到 sharding-jdbc 关于读写分离的操作。

主从复制原理是什么？#

MySQL binlog(binary log 即二进制日志文件) 主要记录了 MySQL 数据库中数据的所有变化(数据库执行的所有 DDL 和 DML 语句)。因此，我们根据主库的 MySQL binlog 日志就能够将主库的数据同步到从库中。

zookeeper实战

Tue, 14 Feb 2023 10:45:39 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

1. 前言#

这篇文章简单给演示一下 ZooKeeper 常见命令的使用以及 ZooKeeper Java客户端 Curator 的基本使用。介绍到的内容都是最基本的操作，能满足日常工作的基本需要。

如果文章有任何需要改善和完善的地方，欢迎在评论区指出，共同进步！

2. ZooKeeper 安装和使用#

2.1. 使用Docker 安装 zookeeper#

a.使用 Docker 下载 ZooKeeper

docker pull zookeeper:3.5.8

b.运行 ZooKeeper

docker run -d --name zookeeper -p 2181:2181 zookeeper:3.5.8

2.2. 连接 ZooKeeper 服务#

a.进入ZooKeeper容器中

先使用 docker ps 查看 ZooKeeper 的 ContainerID，然后使用 docker exec -it ContainerID /bin/bash 命令进入容器中。

b.先进入 bin 目录,然后通过 ./zkCli.sh -server 127.0.0.1:2181命令连接ZooKeeper 服务

root@eaf70fc620cb:/apache-zookeeper-3.5.8-bin# cd bin

如果你看到控制台成功打印出如下信息的话，说明你已经成功连接 ZooKeeper 服务。

2.3. 常用命令演示#

2.3.1. 查看常用命令(help 命令)#

通过 help 命令查看 ZooKeeper 常用命令

zookeeper进阶

Mon, 13 Feb 2023 17:30:07 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

FrancisQ 投稿。

1. 好久不见#

离上一篇文章的发布也快一个月了，想想已经快一个月没写东西了，其中可能有期末考试、课程设计和驾照考试，但这都不是借口！

一到冬天就懒的不行，望广大掘友督促我🙄🙄✍️✍️。

文章很长，先赞后看，养成习惯。❤️ 🧡 💛 💚 💙 💜

2. 什么是ZooKeeper#

ZooKeeper 由 Yahoo 开发，后来捐赠给了 Apache ，现已成为 Apache 顶级项目。ZooKeeper 是一个开源的分布式应用程序协调服务器，其为分布式系统提供一致性服务。其一致性是通过基于 Paxos 算法的 ZAB 协议完成的。其主要功能包括：配置维护、分布式同步、集群管理、分布式事务等。

简单来说， ZooKeeper 是一个 分布式协调服务框架 。分布式？协调服务？这啥玩意？🤔🤔

其实解释到分布式这个概念的时候，我发现有些同学并不是能把 分布式和集群 这两个概念很好的理解透。前段时间有同学和我探讨起分布式的东西，他说分布式不就是加机器吗？一台机器不够用再加一台抗压呗。当然加机器这种说法也无可厚非，你一个分布式系统必定涉及到多个机器，但是你别忘了，计算机学科中还有一个相似的概念—— Cluster ，集群不也是加机器吗？但是 集群和分布式 其实就是两个完全不同的概念。

比如，我现在有一个秒杀服务，并发量太大单机系统承受不住，那我加几台服务器也一样提供秒杀服务，这个时候就是 Cluster 集群 。

但是，我现在换一种方式，我将一个秒杀服务 拆分成多个子服务 ，比如创建订单服务，增加积分服务，扣优惠券服务等等，然后我将这些子服务都部署在不同的服务器上 ，这个时候就是 Distributed 分布式 。

而我为什么反驳同学所说的分布式就是加机器呢？因为我认为加机器更加适用于构建集群，因为它真是只有加机器。而对于分布式来说，你首先需要将业务进行拆分，然后再加机器（不仅仅是加机器那么简单），同时你还要去解决分布式带来的一系列问题。

比如各个分布式组件如何协调起来，如何减少各个系统之间的耦合度，分布式事务的处理，如何去配置整个分布式系统等等。ZooKeeper 主要就是解决这些问题的。

3. 一致性问题#

设计一个分布式系统必定会遇到一个问题—— 因为分区容忍性（partition tolerance）的存在，就必定要求我们需要在系统可用性（availability）和数据一致性（consistency）中做出权衡 。这就是著名的 CAP 定理。

zookeeper介绍

Mon, 13 Feb 2023 15:59:20 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

1. 前言#

相信大家对 ZooKeeper 应该不算陌生。但是你真的了解 ZooKeeper 到底有啥用不？如果别人/面试官让你给他讲讲对于 ZooKeeper 的认识，你能回答到什么地步呢？

拿我自己来说吧！我本人曾经使用 Dubbo 来做分布式项目的时候，使用了 ZooKeeper 作为注册中心。为了保证分布式系统能够同步访问某个资源，我还使用 ZooKeeper 做过分布式锁。另外，我在学习 Kafka 的时候，知道 Kafka 很多功能的实现依赖了 ZooKeeper。

前几天，总结项目经验的时候，我突然问自己 ZooKeeper 到底是个什么东西？想了半天，脑海中只是简单的能浮现出几句话：

ZooKeeper 可以被用作注册中心、分布式锁；
ZooKeeper 是 Hadoop 生态系统的一员；
构建 ZooKeeper 集群的时候，使用的服务器最好是奇数台。

由此可见，我对于 ZooKeeper 的理解仅仅是停留在了表面。

所以，通过本文，希望带大家稍微详细的了解一下 ZooKeeper 。如果没有学过 ZooKeeper ，那么本文将会是你进入 ZooKeeper 大门的垫脚砖。如果你已经接触过 ZooKeeper ，那么本文将带你回顾一下 ZooKeeper 的一些基础概念。

另外，本文不光会涉及到 ZooKeeper 的一些概念，后面的文章会介绍到 ZooKeeper 常见命令的使用以及使用 Apache Curator 作为 ZooKeeper 的客户端。

如果文章有任何需要改善和完善的地方，欢迎在评论区指出，共同进步！

2. ZooKeeper 介绍#

2.1. ZooKeeper 由来#

正式介绍 ZooKeeper 之前，我们先来看看 ZooKeeper 的由来，还挺有意思的。

rpc_http

Sat, 11 Feb 2023 19:59:58 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

我正在参与掘金技术社区创作者签约计划招募活动，点击链接报名投稿。

我想起了我刚工作的时候，第一次接触RPC协议，当时就很懵，我HTTP协议用的好好的，为什么还要用RPC协议？

于是就到网上去搜。

不少解释显得非常官方，我相信大家在各种平台上也都看到过，解释了又好像没解释，都在用一个我们不认识的概念去解释另外一个我们不认识的概念，懂的人不需要看，不懂的人看了还是不懂。

这种看了，又好像没看的感觉，云里雾里的很难受，我懂。

为了避免大家有强烈的审丑疲劳，今天我们来尝试重新换个方式讲一讲。

从TCP聊起#

作为一个程序员，假设我们需要在A电脑的进程发一段数据到B电脑的进程，我们一般会在代码里使用socket进行编程。

这时候，我们可选项一般也就TCP和UDP二选一。TCP可靠，UDP不可靠。 除非是马总这种神级程序员（早期QQ大量使用UDP），否则，只要稍微对可靠性有些要求，普通人一般无脑选TCP就对了。

类似下面这样。

fd = socket(AF_INET,SOCK_STREAM,0);
复制代码

其中SOCK_STREAM，是指使用字节流传输数据，说白了就是TCP协议。

在定义了socket之后，我们就可以愉快的对这个socket进行操作，比如用bind()绑定IP端口，用connect()发起建连。

在连接建立之后，我们就可以使用send()发送数据，recv()接收数据。

光这样一个纯裸的TCP连接，就可以做到收发数据了，那是不是就够了？

不行，这么用会有问题。

使用纯裸TCP会有什么问题#

八股文常背，TCP是有三个特点，面向连接、可靠、基于字节流。

这三个特点真的概括的非常精辟，这个八股文我们没白背。

每个特点展开都能聊一篇文章，而今天我们需要关注的是基于字节流这一点。

字节流可以理解为一个双向的通道里流淌的数据，这个数据其实就是我们常说的二进制数据，简单来说就是一大堆 01 串。纯裸TCP收发的这些 01 串之间是没有任何边界的，你根本不知道到哪个地方才算一条完整消息。

正因为这个没有任何边界的特点，所以当我们选择使用TCP发送 “夏洛"和"特烦恼” 的时候，接收端收到的就是 “夏洛特烦恼” ，这时候接收端没发区分你是想要表达 “夏洛”+“特烦恼” 还是 “夏洛特”+“烦恼” 。

这就是所谓的粘包问题，之前也写过一篇专门的文章聊过这个问题。

说这个的目的是为了告诉大家，纯裸TCP是不能直接拿来用的，你需要在这个基础上加入一些自定义的规则，用于区分消息边界。

于是我们会把每条要发送的数据都包装一下，比如加入消息头，消息头里写清楚一个完整的包长度是多少，根据这个长度可以继续接收数据，截取出来后它们就是我们真正要传输的消息体。

而这里头提到的消息头，还可以放各种东西，比如消息体是否被压缩过和消息体格式之类的，只要上下游都约定好了，互相都认就可以了，这就是所谓的协议。

每个使用TCP的项目都可能会定义一套类似这样的协议解析标准，他们可能有区别，但原理都类似。

于是基于TCP，就衍生了非常多的协议，比如HTTP和RPC。

HTTP和RPC#

我们回过头来看网络的分层图。

TCP是传输层的协议，而基于TCP造出来的HTTP和各类RPC协议，它们都只是定义了不同消息格式的应用层协议而已。

HTTP协议（Hyper Text Transfer Protocol），又叫做超文本传输协议。我们用的比较多，平时上网在浏览器上敲个网址就能访问网页，这里用到的就是HTTP协议。

而RPC（Remote Procedure Call），又叫做远程过程调用。它本身并不是一个具体的协议，而是一种调用方式。

举个例子，我们平时调用一个本地方法就像下面这样。

 res = localFunc(req)
复制代码

如果现在这不是个本地方法，而是个远端服务器暴露出来的一个方法remoteFunc，如果我们还能像调用本地方法那样去调用它，这样就可以屏蔽掉一些网络细节，用起来更方便，岂不美哉？

rpc基础及面试题

Sat, 11 Feb 2023 19:41:34 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

简单介绍一下 RPC 相关的基础概念。

何为 RPC?#

RPC（Remote Procedure Call） 即远程过程调用，通过名字我们就能看出 RPC 关注的是远程调用而非本地调用。

为什么要 RPC ？ 因为，两个不同的服务器上的服务提供的方法不在一个内存空间，所以，需要通过网络编程才能传递方法调用所需要的参数。并且，方法调用的结果也需要通过网络编程来接收。但是，如果我们自己手动网络编程来实现这个调用过程的话工作量是非常大的，因为，我们需要考虑底层传输方式（TCP还是UDP）、序列化方式等等方面。

RPC 能帮助我们做什么呢？ 简单来说，通过 RPC 可以帮助我们调用远程计算机上某个服务的方法，这个过程就像调用本地方法一样简单。并且！我们不需要了解底层网络编程的具体细节。

举个例子：两个不同的服务 A、B 部署在两台不同的机器上，服务 A 如果想要调用服务 B 中的某个方法的话就可以通过 RPC 来做。

一言蔽之：RPC 的出现就是为了让你调用远程方法像调用本地方法一样简单。

RPC 的原理是什么?#

为了能够帮助小伙伴们理解 RPC 原理，我们可以将整个 RPC的核心功能看作是下面👇 5 个部分实现的：

客户端（服务消费端） ：调用远程方法的一端。
客户端 Stub（桩） ：这其实就是一代理类。代理类主要做的事情很简单，就是把你调用方法、类、方法参数等信息传递到服务端。
网络传输 ：网络传输就是你要把你调用的方法的信息比如说参数啊这些东西传输到服务端，然后服务端执行完之后再把返回结果通过网络传输给你传输回来。网络传输的实现方式有很多种比如最近基本的 Socket或者性能以及封装更加优秀的 Netty（推荐）。
服务端 Stub（桩） ：这个桩就不是代理类了。我觉得理解为桩实际不太好，大家注意一下就好。这里的服务端 Stub 实际指的就是接收到客户端执行方法的请求后，去指定对应的方法然后返回结果给客户端的类。
服务端（服务提供端） ：提供远程方法的一端。

具体原理图如下，后面我会串起来将整个RPC的过程给大家说一下。

服务消费端（client）以本地调用的方式调用远程服务；
客户端 Stub（client stub）接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体（序列化）：RpcRequest；
客户端 Stub（client stub）找到远程服务的地址，并将消息发送到服务提供端；
服务端 Stub（桩）收到消息将消息反序列化为Java对象: RpcRequest；
服务端 Stub（桩）根据RpcRequest中的类、方法、方法参数等信息调用本地的方法；
服务端 Stub（桩）得到方法执行结果并将组装成能够进行网络传输的消息体：RpcResponse（序列化）发送至消费方；
客户端 Stub（client stub）接收到消息并将消息反序列化为Java对象:RpcResponse ，这样也就得到了最终结果。over!

相信小伙伴们看完上面的讲解之后，已经了解了 RPC 的原理。

分布式锁

Sat, 11 Feb 2023 13:24:32 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

网上有很多分布式锁相关的文章，写了一个相对简洁易懂的版本，针对面试和工作应该够用了。

什么是分布式锁？#

对于单机多线程来说，在 Java 中，我们通常使用 ReetrantLock 类、synchronized 关键字这类 JDK 自带的 本地锁 来控制一个 JVM 进程内的多个线程对本地共享资源的访问。

下面是我对本地锁画的一张示意图。

从图中可以看出，这些线程访问共享资源是互斥的，同一时刻只有一个线程可以获取到本地锁访问共享资源。

分布式系统下，不同的服务/客户端通常运行在独立的 JVM 进程上。如果多个 JVM 进程共享同一份资源的话，使用本地锁就没办法实现资源的互斥访问了。于是，分布式锁 就诞生了。

举个例子：系统的订单服务一共部署了 3 份，都对外提供服务。用户下订单之前需要检查库存，为了防止超卖，这里需要加锁以实现对检查库存操作的同步访问。由于订单服务位于不同的 JVM 进程中，本地锁在这种情况下就没办法正常工作了。我们需要用到分布式锁，这样的话，即使多个线程不在同一个 JVM 进程中也能获取到同一把锁，进而实现共享资源的互斥访问。

下面是我对分布式锁画的一张示意图。

从图中可以看出，这些独立的进程中的线程访问共享资源是互斥的，同一时刻只有一个线程可以获取到分布式锁访问共享资源。

一个最基本的分布式锁需要满足：

互斥：任意一个时刻，锁只能被一个线程持有；
高可用 ：锁服务是高可用的。并且，即使客户端的释放锁的代码逻辑出现问题(这里说的是异常，不是说代码写的有问题)，锁最终一定还是会被释放，不会影响其他线程对共享资源的访问。
可重入：(同)一个节点获取了锁之后，还可以再次获取锁。

通常情况下，我们一般会选择基于 Redis 或者 ZooKeeper 实现分布式锁，Redis 用的要更多一点，我这里也以 Redis 为例介绍分布式锁的实现。

基于 Redis 实现分布式锁#

如何基于 Redis 实现一个最简易的分布式锁？#

不论是实现锁(本地)还是分布式锁，核心都在于**“互斥”**。

在 Redis 中， SETNX 命令是可以帮助我们实现互斥。SETNX 即 SET if Not eXists (对应 Java 中的 setIfAbsent 方法)，如果 key 不存在的话，才会设置 key 的值。如果 key 已经存在， SETNX 啥也不做。

分布式id

Sat, 11 Feb 2023 13:00:31 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

分布式 ID 介绍#

什么是 ID？#

日常开发中，我们需要对系统中的各种数据使用 ID 唯一表示，比如用户 ID 对应且仅对应一个人，商品 ID 对应且仅对应一件商品，订单 ID 对应且仅对应一个订单。

我们现实生活中也有各种 ID，比如身份证 ID 对应且仅对应一个人、地址 ID 对应且仅对应

简单来说，ID 就是数据的唯一标识。

什么是分布式 ID？#

分布式 ID 是分布式系统下的 ID。分布式 ID 不存在与现实生活中(属于技术上的问题，跟业务无关)，属于计算机系统中的一个概念。

我简单举一个分库分表的例子。

我司的一个项目，使用的是单机 MySQL 。但是，没想到的是，项目上线一个月之后，随着使用人数越来越多，整个系统的数据量将越来越大。单机 MySQL 已经没办法支撑了，需要进行分库分表（推荐 Sharding-JDBC）。

在分库之后， 数据遍布在不同服务器上的数据库，数据库的自增主键已经没办法满足生成的主键唯一了。我们如何为不同的数据节点生成全局唯一主键呢？

这个时候就需要生成分布式 ID了。

分布式 ID 需要满足哪些要求?#

分布式 ID 作为分布式系统中必不可少的一环，很多地方都要用到分布式 ID。

一个最基本的分布式 ID 需要满足下面这些要求：

全局唯一 ：ID 的全局唯一性肯定是首先要满足的！
高性能 ：分布式 ID 的生成速度要快，对本地资源消耗要小。
高可用 ：生成分布式 ID 的服务要保证可用性无限接近于 100%。
方便易用 ：拿来即用，使用方便，快速接入！

除了这些之外，一个比较好的分布式 ID 还应保证：

api网关

Fri, 10 Feb 2023 22:26:59 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

什么是网关？有什么用？#

微服务背景下，一个系统被拆分为多个服务，但是像安全认证，流量控制，日志，监控等功能是每个服务都需要的，没有网关的话，我们就需要在每个服务中单独实现，这使得我们做了很多重复的事情并且没有一个全局的视图来统一管理这些功能。

一般情况下，网关可以为我们提供请求转发、安全认证（身份/权限认证）、流量控制、负载均衡、降级熔断、日志、监控等功能。

上面介绍了这么多功能，实际上，网关主要做了一件事情：请求过滤 。

有哪些常见的网关系统？#

Netflix Zuul#

Zuul 是 Netflix 开发的一款提供动态路由、监控、弹性、安全的网关服务。

Zuul 主要通过过滤器（类似于 AOP）来过滤请求，从而实现网关必备的各种功能。

我们可以自定义过滤器来处理请求，并且，Zuul 生态本身就有很多现成的过滤器供我们使用。就比如限流可以直接用国外朋友写的 spring-cloud-zuul-ratelimit (这里只是举例说明，一般是配合 hystrix 来做限流)：

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
 <groupId>com.marcosbarbero.cloud</groupId>
 <artifactId>spring-cloud-zuul-ratelimit</artifactId>
 <version>2.2.0.RELEASE</version>
</dependency>

Zuul 1.x 基于同步 IO，性能较差。Zuul 2.x 基于 Netty 实现了异步 IO，性能得到了大幅改进。

Github 地址： https://github.com/Netflix/zuul
官方 Wiki ： https://github.com/Netflix/zuul/wiki

Spring Cloud Gateway#

SpringCloud Gateway 属于 Spring Cloud 生态系统中的网关，其诞生的目标是为了替代老牌网关 **Zuul **。准确点来说，应该是 Zuul 1.x。SpringCloud Gateway 起步要比 Zuul 2.x 更早。

为了提升网关的性能，SpringCloud Gateway 基于 Spring WebFlux 。Spring WebFlux 使用 Reactor 库来实现响应式编程模型，底层基于 Netty 实现异步 IO。

raft算法

Fri, 10 Feb 2023 17:10:36 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

1 背景#

当今的数据中心和应用程序在高度动态的环境中运行，为了应对高度动态的环境，它们通过额外的服务器进行横向扩展，并且根据需求进行扩展和收缩。同时，服务器和网络故障也很常见。

因此，系统必须在正常操作期间处理服务器的上下线。它们必须对变故做出反应并在几秒钟内自动适应；对客户来说的话，明显的中断通常是不可接受的。

幸运的是，分布式共识可以帮助应对这些挑战。

1.1 拜占庭将军#

在介绍共识算法之前，先介绍一个简化版拜占庭将军的例子来帮助理解共识算法。

假设多位拜占庭将军中没有叛军，信使的信息可靠但有可能被暗杀的情况下，将军们如何达成是否要进攻的一致性决定？

解决方案大致可以理解成：先在所有的将军中选出一个大将军，用来做出所有的决定。

举例如下：假如现在一共有 3 个将军 A，B 和 C，每个将军都有一个随机时间的倒计时器，倒计时一结束，这个将军就把自己当成大将军候选人，然后派信使传递选举投票的信息给将军 B 和 C，如果将军 B 和 C 还没有把自己当作候选人（自己的倒计时还没有结束），并且没有把选举票投给其他人，它们就会把票投给将军 A，信使回到将军 A 时，将军 A 知道自己收到了足够的票数，成为大将军。在有了大将军之后，是否需要进攻就由大将军 A 决定，然后再去派信使通知另外两个将军，自己已经成为了大将军。如果一段时间还没收到将军 B 和 C 的回复（信使可能会被暗杀），那就再重派一个信使，直到收到回复。

1.2 共识算法#

共识是可容错系统中的一个基本问题：即使面对故障，服务器也可以在共享状态上达成一致。

共识算法允许一组节点像一个整体一样一起工作，即使其中的一些节点出现故障也能够继续工作下去，其正确性主要是源于复制状态机的性质：一组Server的状态机计算相同状态的副本，即使有一部分的Server宕机了它们仍然能够继续运行。

图-1 复制状态机架构

一般通过使用复制日志来实现复制状态机。每个Server存储着一份包括命令序列的日志文件，状态机会按顺序执行这些命令。因为每个日志包含相同的命令，并且顺序也相同，所以每个状态机处理相同的命令序列。由于状态机是确定性的，所以处理相同的状态，得到相同的输出。

因此共识算法的工作就是保持复制日志的一致性。服务器上的共识模块从客户端接收命令并将它们添加到日志中。它与其他服务器上的共识模块通信，以确保即使某些服务器发生故障。每个日志最终包含相同顺序的请求。一旦命令被正确地复制，它们就被称为已提交。每个服务器的状态机按照日志顺序处理已提交的命令，并将输出返回给客户端，因此，这些服务器形成了一个单一的、高度可靠的状态机。

适用于实际系统的共识算法通常具有以下特性：

安全。确保在非拜占庭条件（也就是上文中提到的简易版拜占庭）下的安全性，包括网络延迟、分区、包丢失、复制和重新排序。
高可用。只要大多数服务器都是可操作的，并且可以相互通信，也可以与客户端进行通信，那么这些服务器就可以看作完全功能可用的。因此，一个典型的由五台服务器组成的集群可以容忍任何两台服务器端故障。假设服务器因停止而发生故障；它们稍后可能会从稳定存储上的状态中恢复并重新加入集群。
一致性不依赖时序。错误的时钟和极端的消息延迟，在最坏的情况下也只会造成可用性问题，而不会产生一致性问题。
在集群中大多数服务器响应，命令就可以完成，不会被少数运行缓慢的服务器来影响整体系统性能。

2 基础#

2.1 节点类型#

一个 Raft 集群包括若干服务器，以典型的 5 服务器集群举例。在任意的时间，每个服务器一定会处于以下三个状态中的一个：

Leader：负责发起心跳，响应客户端，创建日志，同步日志。
Candidate：Leader 选举过程中的临时角色，由 Follower 转化而来，发起投票参与竞选。
Follower：接受 Leader 的心跳和日志同步数据，投票给 Candidate。

在正常的情况下，只有一个服务器是 Leader，剩下的服务器是 Follower。Follower 是被动的，它们不会发送任何请求，只是响应来自 Leader 和 Candidate 的请求。

paxos算法

Fri, 10 Feb 2023 17:02:45 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

背景#

Paxos 算法是 Leslie Lamport（莱斯利·兰伯特）在 1990 年提出了一种分布式系统共识算法。这也是第一个被证明完备的共识算法（前提是不存在拜占庭将军问题，也就是没有恶意节点）。

为了介绍 Paxos 算法，兰伯特专门写了一篇幽默风趣的论文。在这篇论文中，他虚拟了一个叫做 Paxos 的希腊城邦来更形象化地介绍 Paxos 算法。

不过，审稿人并不认可这篇论文的幽默。于是，他们就给兰伯特说：“如果你想要成功发表这篇论文的话，必须删除所有 Paxos 相关的故事背景”。兰伯特一听就不开心了：“我凭什么修改啊，你们这些审稿人就是缺乏幽默细胞，发不了就不发了呗！”。

于是乎，提出 Paxos 算法的那篇论文在当时并没有被成功发表。

直到 1998 年，系统研究中心 (Systems Research Center，SRC）的两个技术研究员需要找一些合适的分布式算法来服务他们正在构建的分布式系统，Paxos 算法刚好可以解决他们的部分需求。因此，兰伯特就把论文发给了他们。在看了论文之后，这俩大佬觉得论文还是挺不错的。于是，兰伯特在 1998 年重新发表论文《The Part-Time Parliament》。

论文发表之后，各路学者直呼看不懂，言语中还略显调侃之意。这谁忍得了，在 2001 年的时候，兰伯特专门又写了一篇《Paxos Made Simple》的论文来简化对 Paxos 的介绍，主要讲述两阶段共识协议部分，顺便还不忘嘲讽一下这群学者。

《Paxos Made Simple》这篇论文就 14 页，相比于《The Part-Time Parliament》的 33 页精简了不少。最关键的是这篇论文的摘要就一句话：

The Paxos algorithm, when presented in plain English, is very simple.

翻译过来的意思大概就是：当我用无修饰的英文来描述时，Paxos 算法真心简单！

有没有感觉到来自兰伯特大佬满满地嘲讽的味道？

CAP&BASE 理论

Fri, 10 Feb 2023 15:03:48 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

经历过技术面试的小伙伴想必对 CAP & BASE 这个两个理论已经再熟悉不过了！

我当年参加面试的时候，不夸张地说，只要问到分布式相关的内容，面试官几乎是必定会问这两个分布式相关的理论。一是因为这两个分布式基础理论是学习分布式知识的必备前置基础，二是因为很多面试官自己比较熟悉这两个理论（方便提问）。

我们非常有必要将这两个理论搞懂，并且能够用自己的理解给别人讲出来。

CAP 理论#

CAP 理论/定理起源于 2000 年，由加州大学伯克利分校的 Eric Brewer 教授在分布式计算原理研讨会（PODC）上提出，因此 CAP 定理又被称作 布鲁尔定理（Brewer’s theorem）

2 年后，麻省理工学院的 Seth Gilbert 和 Nancy Lynch 发表了布鲁尔猜想的证明，CAP 理论正式成为分布式领域的定理。

简介#

[kənˈsɪstənsi] consistency 一致性
[əˌveɪlə'bɪləti] availability 可用性 ,
[pɑːˈtɪʃn] 分割 [ˈtɒlərəns] 容忍,

CAP 也就是 Consistency（一致性）、Availability（可用性）、Partition Tolerance（分区容错性） 这三个单词首字母组合。

CAP 理论的提出者布鲁尔在提出 CAP 猜想的时候，并没有详细定义 Consistency、Availability、Partition Tolerance 三个单词的明确定义。

因此，对于 CAP 的民间解读有很多，一般比较被大家推荐的是下面 👇 这种版本的解读。

在理论计算机科学中，CAP 定理（CAP theorem）指出对于一个分布式系统来说，当设计读写操作时，只能同时满足以下三点中的两个：

一致性（Consistency） : 所有节点访问同一份最新的数据副本
可用性（Availability）: 非故障的节点在合理的时间内返回合理的响应（不是错误或者超时的响应）。
分区容错性（Partition Tolerance） : 分布式系统出现网络分区的时候，仍然能够对外提供服务。

什么是网络分区？

Mybatis原理系列(3)

Fri, 10 Feb 2023 11:27:48 +0000

转载自https://www.jianshu.com/p/4e268828db48（添加小部分笔记）感谢作者!

还没看完

在上篇文章中，我们讲解了MyBatis的启动流程，以及启动过程中涉及到的组件，在本篇文中，我们继续探索SqlSession,SqlSessionFactory,SqlSessionFactoryBuilder的关系。SqlSession作为MyBatis的核心组件，可以说MyBatis的所有操作都是围绕SqlSession来展开的。对SqlSession理解透彻，才能全面掌握MyBatis。

1. SqlSession初识#

SqlSession在一开始就介绍过是高级接口，类似于JDBC操作的connection对象，它包装了数据库连接，通过这个接口我们可以实现增删改查，提交/回滚事物，关闭连接，获取代理类等操作。SqlSession是个接口，其默认实现是DefaultSqlSession。SqlSession是线程不安全的，每个线程都会有自己唯一的SqlSession，不同线程间调用同一个SqlSession会出现问题，因此在使用完后需要close掉。

SqlSession的方法

2. SqlSession的创建#

SqlSessionFactoryBuilder的build()方法使用建造者模式创建了SqlSessionFactory接口对象，SqlSessionFactory接口的默认实现是DefaultSqlSessionFactory。SqlSessionFactory使用实例工厂模式来创建SqlSession对象。SqlSession,SqlSessionFactory,SqlSessionFactoryBuilder的关系如下(图画得有点丑…)：

类图

DefaultSqlSessionFactory中openSession是有两种方法一种是openSessionFromDataSource，另一种是openSessionFromConnection。这两种是什么区别呢？从字面意义上将，一种是从数据源中获取SqlSession对象，一种是由已有连接获取SqlSession。SqlSession实际是对数据库连接的一层包装，数据库连接是个珍贵的资源，如果频繁的创建销毁将会影响吞吐量，因此使用数据库连接池化技术就可以复用数据库连接了。因此openSessionFromDataSource会从数据库连接池中获取一个连接，然后包装成一个SqlSession对像。openSessionFromConnection则是直接包装已有的连接并返回SqlSession对像。

openSessionFromDataSource 主要经历了以下几步：

从获取configuration中获取Environment对象，Environment包含了数据库配置
从Environment获取DataSource数据源
从DataSource数据源中获取Connection连接对象
从DataSource数据源中获取TransactionFactory事物工厂
从TransactionFactory中创建事物Transaction对象
创建Executor对象
包装configuration和Executor对象成DefaultSqlSession对象

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
 Transaction tx = null;
 try {
 final Environment environment = configuration.getEnvironment();
 final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
 tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
 final Executor executor = configuration.newExecutor(tx, execType);
 return new DefaultSqlSession(configuration, executor, autoCommit);
 } catch (Exception e) {
 closeTransaction(tx); // may have fetched a connection so lets call close()
 throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
 } finally {
 ErrorContext.instance().reset();
 }
 }

 private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {
 try {
 boolean autoCommit;
 try {
 autoCommit = connection.getAutoCommit();
 } catch (SQLException e) {
 // Failover to true, as most poor drivers
 // or databases won't support transactions
 autoCommit = true;
 }
 final Environment environment = configuration.getEnvironment();
 final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
 final Transaction tx = transactionFactory.newTransaction(connection);
 final Executor executor = configuration.newExecutor(tx, execType);
 return new DefaultSqlSession(configuration, executor, autoCommit);
 } catch (Exception e) {
 throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
 } finally {
 ErrorContext.instance().reset();
 }
 }

3. SqlSession的使用#

SqlSession 获取成功后，我们就可以使用其中的方法了，比如直接使用SqlSession发送sql语句，或者通过mapper映射文件的方式来使用，在上两篇文章中我们都是通过mapper映射文件来使用的，接下来就介绍第一种，直接使用SqlSession发送sql语句。

Mybatis原理系列(2)

Fri, 10 Feb 2023 11:04:31 +0000

转载自https://www.jianshu.com/p/7d6b891180a3（添加小部分笔记）感谢作者!

在上篇文章中，我们举了一个例子如何使用MyBatis，但是对其中dao层，entity层，mapper层间的关系不得而知，从此篇文章开始，笔者将从MyBatis的启动流程着手，真正的开始研究MyBatis源码了。

1. MyBatis启动代码示例#

在上篇文章中，介绍了MyBatis的相关配置和各层代码编写，本文将以下代码展开描述和介绍MyBatis的启动流程，并简略的介绍各个模块的作用，各个模块的细节部分将在其它文章中呈现。

回顾下上文中使用mybatis的部分代码，包括七步。每步虽然都是一行代码，但是隐藏了很多细节。接下来我们将围绕这起步展开了解。

@Slf4j
public class MyBatisBootStrap {

 public static void main(String[] args) {
 try {
 // 1. 读取配置
 InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
 // 2. 创建SqlSessionFactory工厂
 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
 // 3. 获取sqlSession
 SqlSession sqlSession = sqlSessionFactory.openSession();
 // 4. 获取Mapper
 TTestUserMapper userMapper = sqlSession.getMapper(TTestUserMapper.class);
 // 5. 执行接口方法
 TTestUser userInfo = userMapper.selectByPrimaryKey(16L);
 System.out.println("userInfo = " + JSONUtil.toJsonStr(userInfo));
 // 6. 提交事物
 sqlSession.commit();
 // 7. 关闭资源
 sqlSession.close();
 inputStream.close();
 } catch (Exception e){
 log.error(e.getMessage(), e);
 }
 }
}

2. 读取配置#

// 1. 读取配置
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");

在mybatis-config.xml中我们配置了属性，环境，映射文件路径等，其实不仅可以配置以上内容，还可以配置插件，反射工厂，类型处理器等等其它内容。在启动流程中的第一步我们就需要读取这个配置文件，并获取一个输入流为下一步解析配置文件作准备。

Mybatis原理系列(1)

Fri, 10 Feb 2023 08:54:26 +0000

转载自https://www.jianshu.com/p/ada025f97a07（添加小部分笔记）感谢作者!

作为Java码农，无论在面试中，还是在工作中都会遇到MyBatis的相关问题。笔者从大学开始就接触MyBatis，到现在为止都是会用，知道怎么配置，怎么编写xml，但是不知道Mybatis核心原理，一遇到问题就复制错误信息百度解决。为了改变这种境地，鼓起勇气开始下定决心阅读MyBatis源码，并开始记录阅读过程，希望和大家分享。

1. 初识MyBatis#

还记得当初接触MyBatis时，觉得要配置很多，而且sql要单独写在xml中，相比Hibernate来说简直不太友好，直到后来出现了复杂的业务需求，需要编写相应的复杂的sql，此时用Hibernate反而更加麻烦了，用MyBatis是真香了。因此笔者对MyBatis的第一印象就是将业务关注的sql和java代码进行了解耦，在业务复杂变化的时候，相应的数据库操作需要相应进行修改，如果通过java代码构建操作数据逻辑，这不断变动的需求对程序员的耐心是极大的考验。如果将sql统一的维护在一个文件里，java代码用接口定义，在需求变动时，只用改相应的sql，从而减少了修改量，提高开发效率。以上也是经常在面试中经常问到的Hibernate和MyBatis间的区别一点。

切到正题，Mybatis是什么呢？

Mybatis SQL 映射框架使得一个面向对象构建的应用程序去访问一个关系型数据库变得更容易。MyBatis使用XML描述符或注解将对象与存储过程或SQL语句耦合。与对象关系映射工具相比，简单性是MyBatis数据映射器的最大优势。

以上是Mybatis的官方解释，其中“映射”，“面向对象”，“关系型”，“xml”等等都是Mybatis的关键词，也是我们了解了Mybatis原理后，会恍然大悟的地方。笔者现在不详述这些概念，在最后总结的时候再进行详述。我们只要知道Mybatis为我们操作数据库提供了很大的便捷。

2. 源码下载#

这里建议使用maven即可，在pom.xml添加以下依赖

 <dependencies>
 <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>8.0.32</version>
 </dependency>

 <dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis</artifactId>
 <version>3.5.6</version>
 </dependency>
 
 <!--这里还添加了一些辅助的依赖-->
 <!--lombok-->
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <version>1.18.8</version>
 </dependency>
 <!--日志模块-->
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-api</artifactId>
 <version>2.17.1</version>
 </dependency> 
 </dependencies>

然后在ExternalLibraries 的mybatis:3.5.6里找到，就能看到目录结构，随便找一个进去 idea右上角会出现DownloadSource之类的字样，点击即可

我们首先要从github上下载源码，仓库地址，然后在IDEA中clone代码

在打开中的IDEA中，选择vsc -> get from version control -> 复制刚才的地址

image.png

点击clone即可

image.png

Mybatis面试

Thu, 09 Feb 2023 16:34:39 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

部分疑问参考自 https://blog.csdn.net/Gherbirthday0916 感谢作者!

#{} 和 ${} 的区别是什么？#

注：这道题是面试官面试我同事的。

答：

${}是 Properties 文件中的变量占位符，它可以用于标签属性值和 sql 内部，属于静态文本替换，比如${driver}会被静态替换为com.mysql.jdbc. Driver。
#{}是 sql 的参数占位符，MyBatis 会将 sql 中的#{}替换为? 号，在 sql 执行前会使用 PreparedStatement 的参数设置方法，按序给 sql 的? 号占位符设置参数值，比如 ps.setInt(0, parameterValue)，#{item.name} 的取值方式为使用反射从参数对象中获取 item 对象的 name 属性值，相当于 param.getItem().getName()。 [这里用到了反射]

在底层构造完整SQL语句时，MyBatis的两种传参方式所采取的方式不同。#{Parameter}采用预编译的方式构造SQL，避免了 SQL注入 的产生。而**${Parameter}采用拼接的方式构造SQL，在对用户输入过滤不严格**的前提下，此处很可能存在SQL注入

xml 映射文件中，除了常见的 select、insert、update、delete 标签之外，还有哪些标签？#

注：这道题是京东面试官面试我时问的。

ConditionalOnClass实践

Thu, 09 Feb 2023 15:38:01 +0000

两个测试方向#

方向1：两个maven项目#

详见git上的 conditional_on_class_main 项目以及 conditional_on_class2 项目

基础maven项目 conditional_on_class2
pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>org.example</groupId>
 <artifactId>conditional_on_class_2</artifactId>
 <version>1.0-SNAPSHOT</version>

</project>

java类

package com;

public class LyReferenceImpl {
 public String sayWord() {
 return "hello one";
 }
}

简单的SpringBoot项目 conditional_on_class_main

<!--pom文件-->
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>org.example</groupId>
 <artifactId>conditional_on_class_main</artifactId>
 <version>1.0-SNAPSHOT</version>

 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.7.8</version>
 </parent>
 <dependencies>

 <!--把1配置的bean引用进来-->
 <dependency>
 <groupId>org.example</groupId>
 <artifactId>conditional_on_class_2</artifactId>
 <version>1.0-SNAPSHOT</version>
 <scope>provided</scope>
 <optional>true</optional>
 </dependency>

 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 </dependencies>
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 <configuration>
 <excludes>
 <!-- 默认会将conditional_on_class_2 打包进去,现在会配置SayExist
						如果放开注释,那么会配置SayNotExist-->
 <!--<dependency>
 <groupId>org.example</groupId>
 <artifactId>conditional_on_class_2</artifactId>
 </dependency>-->
 </excludes>
 <jvmArguments>-Dfile.encoding=UTF-8</jvmArguments>
 </configuration>
 <executions>
 <execution>
 <goals>
 <goal>repackage</goal><!--可以把依赖的包都打包到生成的Jar包中 -->
 </goals>
 </execution>
 </executions>
 </plugin>
 </plugins>
 </build>

</project>

//两个配置类 
//配置类1
package com.config;

import com.service.ISay;
import com.service.SayExist;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//不要放在方法里面,否则会报错"java.lang.ArrayStoreException: sun.reflect.annotation.TypeNotPresentExceptionProxy"
@ConditionalOnClass(value = com.LyReferenceImpl.class)
public class ExistConfiguration {

 @Bean
 public ISay getISay1(){
 return new SayExist();
 }
}

//配置类2
package com.config;

import com.service.ISay;
import com.service.SayNotExist;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnMissingClass("com.LyReferenceImpl")
public class NotExistConfiguration {

 @Bean
 public ISay getISay1(){
 return new SayNotExist();
 }
}

方向2：3个maven项目(建议用这个理解)#

注意，这里可能还漏了一个问题，那就是这个conditional_on_class1 的configuration之所以能够被自动装配，是因为和 conditional_on_class_main1的Application类是同一个包，所以不用特殊处理。如果是其他包名的话，那么是需要用到spring boot的自动装配机制的：在conditional_on_class1 工程的 resources 包下创建META-INF/spring.factories，并写上Config类的全类名

SpringBoot自动装配原理

Thu, 09 Feb 2023 10:37:36 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

每次问到 Spring Boot，面试官非常喜欢问这个问题：“讲述一下 SpringBoot 自动装配原理？”。

我觉得我们可以从以下几个方面回答：

什么是 SpringBoot 自动装配？
SpringBoot 是如何实现自动装配的？如何实现按需加载？
如何实现一个 Starter？

篇幅问题，这篇文章并没有深入，小伙伴们也可以直接使用 debug 的方式去看看 SpringBoot 自动装配部分的源代码。

前言#

使用过 Spring 的小伙伴，一定有被 XML 配置统治的恐惧。即使 Spring 后面引入了基于注解的配置，我们在开启某些 Spring 特性或者引入第三方依赖的时候，还是需要用 XML 或 Java 进行显式配置。

举个例子。没有 Spring Boot 的时候，我们写一个 RestFul Web 服务，还首先需要进行如下配置。

@Configuration
public class RESTConfiguration
{
 @Bean
 public View jsonTemplate() {
 MappingJackson2JsonView view = new MappingJackson2JsonView();
 view.setPrettyPrint(true);
 return view;
 }

 @Bean
 public ViewResolver viewResolver() {
 return new BeanNameViewResolver();
 }
}
spring-servlet.xml
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/context/ http://www.springframework.org/schema/context/spring-context.xsd
 http://www.springframework.org/schema/mvc/ http://www.springframework.org/schema/mvc/spring-mvc.xsd">

 <context:component-scan base-package="com.howtodoinjava.demo" />
 <mvc:annotation-driven />

 <!-- JSON Support -->
 <bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
 <bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>

</beans>

但是，Spring Boot 项目，我们只需要添加相关依赖，无需配置，通过启动下面的 main 方法即可。

spring 设计模式

Wed, 08 Feb 2023 20:18:14 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

“JDK 中用到了哪些设计模式? Spring 中用到了哪些设计模式? ”这两个问题，在面试中比较常见。

我在网上搜索了一下关于 Spring 中设计模式的讲解几乎都是千篇一律，而且大部分都年代久远。所以，花了几天时间自己总结了一下。

由于我的个人能力有限，文中如有任何错误各位都可以指出。另外，文章篇幅有限，对于设计模式以及一些源码的解读我只是一笔带过，这篇文章的主要目的是回顾一下 Spring 中的设计模式。

控制反转(IoC)和依赖注入(DI)#

IoC(Inversion of Control,控制反转) 是 Spring 中一个非常非常重要的概念，它不是什么技术，而是一种解耦的设计思想。IoC 的主要目的是借助于“第三方”(Spring 中的 IoC 容器) 实现具有依赖关系的对象之间的解耦(IOC 容器管理对象，你只管使用即可)，从而降低代码之间的耦合度。

IoC 是一个原则，而不是一个模式，以下模式（但不限于）实现了 IoC 原则。

Spring IoC 容器就像是一个工厂一样，当我们需要创建一个对象的时候，只需要配置好配置文件/注解即可，完全不用考虑对象是如何被创建出来的。 IoC 容器负责创建对象，将对象连接在一起，配置这些对象，并从创建中处理这些对象的整个生命周期，直到它们被完全销毁。

在实际项目中一个 Service 类如果有几百甚至上千个类作为它的底层，我们需要实例化这个 Service，你可能要每次都要搞清这个 Service 所有底层类的构造函数，这可能会把人逼疯。如果利用 IOC 的话，你只需要配置好，然后在需要的地方引用就行了，这大大增加了项目的可维护性且降低了开发难度。

关于 Spring IOC 的理解，推荐看这一下知乎的一个回答：https://www.zhihu.com/question/23277575/answer/169698662 ，非常不错。

控制反转怎么理解呢? 举个例子："对象 a 依赖了对象 b，当对象 a 需要使用对象 b 的时候必须自己去创建。但是当系统引入了 IOC 容器后，对象 a 和对象 b 之前就失去了直接的联系。这个时候，当对象 a 需要使用对象 b 的时候，我们可以指定 IOC 容器去创建一个对象 b 注入到对象 a 中"。对象 a 获得依赖对象 b 的过程,由主动行为变为了被动行为，控制权反转，这就是控制反转名字的由来。

Spring事务详情

Wed, 08 Feb 2023 16:08:16 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

前段时间答应读者的 Spring 事务 分析总结终于来了。这部分内容比较重要，不论是对于工作还是面试，但是网上比较好的参考资料比较少。

什么是事务？#

事务是逻辑上的一组操作，要么都执行，要么都不执行。

相信大家应该都能背上面这句话了，下面我结合我们日常的真实开发来谈一谈。

我们系统的每个业务方法可能包括了多个原子性的数据库操作，比如下面的 savePerson() 方法中就有两个原子性的数据库操作。这些原子性的数据库操作是有依赖的，它们要么都执行，要不就都不执行。

	public void savePerson() {
		personDao.save(person);
		personDetailDao.save(personDetail);
	}

另外，需要格外注意的是：事务能否生效数据库引擎是否支持事务是关键。比如常用的 MySQL 数据库默认使用支持事务的 innodb引擎。但是，如果把数据库引擎变为 myisam，那么程序也就不再支持事务了！

事务最经典也经常被拿出来说例子就是转账了。假如小明要给小红转账 1000 元，这个转账会涉及到两个关键操作就是：

将小明的余额减少 1000 元。

将小红的余额增加 1000 元。

万一在这两个操作之间突然出现错误比如银行系统崩溃或者网络故障，导致小明余额减少而小红的余额没有增加，这样就不对了。事务就是保证这两个关键操作要么都成功，要么都要失败。

public class OrdersService {
	private AccountDao accountDao;

	public void setOrdersDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

 @Transactional(propagation = Propagation.REQUIRED,
 isolation = Isolation.DEFAULT, readOnly = false, timeout = -1)
	public void accountMoney() {
 //小红账户多1000
		accountDao.addMoney(1000,xiaohong);
		//模拟突然出现的异常，比如银行中可能为突然停电等等
 //如果没有配置事务管理的话会造成，小红账户多了1000而小明账户没有少钱
		int i = 10 / 0;
		//小王账户少1000
		accountDao.reduceMoney(1000,xiaoming);
	}
}

另外，数据库事务的 ACID 四大特性是事务的基础，下面简单来了解一下。

Spring/SpringBoot常用注解

Wed, 08 Feb 2023 14:56:32 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

0.前言#

可以毫不夸张地说，这篇文章介绍的 Spring/SpringBoot 常用注解基本已经涵盖你工作中遇到的大部分常用的场景。对于每一个注解我都说了具体用法，掌握搞懂，使用 SpringBoot 来开发项目基本没啥大问题了！

为什么要写这篇文章？

最近看到网上有一篇关于 SpringBoot 常用注解的文章被转载的比较多，我看了文章内容之后属实觉得质量有点低，并且有点会误导没有太多实际使用经验的人（这些人又占据了大多数）。所以，自己索性花了大概两天时间简单总结一下了。

因为我个人的能力和精力有限，如果有任何不对或者需要完善的地方，请帮忙指出！Guide 哥感激不尽！

1. `@SpringBootApplication`#

这里先单独拎出@SpringBootApplication 注解说一下，虽然我们一般不会主动去使用它。

Guide 哥：这个注解是 Spring Boot 项目的基石，创建 SpringBoot 项目之后会默认在主类加上。

@SpringBootApplication
public class SpringSecurityJwtGuideApplication {
 public static void main(java.lang.String[] args) {
 SpringApplication.run(SpringSecurityJwtGuideApplication.class, args);
 }
}

我们可以把 @SpringBootApplication看作是 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解的集合。

package org.springframework.boot.autoconfigure;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
 ......
}

package org.springframework.boot;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

根据 SpringBoot 官网，这三个注解的作用分别是：

spring 常见面试题总结

Tue, 07 Feb 2023 16:48:03 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

这篇文章主要是想通过一些问题，加深大家对于 Spring 的理解，所以不会涉及太多的代码！

下面的很多问题我自己在使用 Spring 的过程中也并没有注意，自己也是临时查阅了很多资料和书籍补上的。网上也有一些很多关于 Spring 常见问题/面试题整理的文章，我感觉大部分都是互相 copy，而且很多问题也不是很好，有些回答也存在问题。所以，自己花了一周的业余时间整理了一下，希望对大家有帮助。

Spring 基础#

什么是 Spring 框架?#

Spring 是一款开源的轻量级 Java 开发框架，旨在提高开发人员的开发效率以及系统的可维护性。

我们一般说 Spring 框架指的都是 Spring Framework，它是很多模块的集合，使用这些模块可以很方便地协助我们进行开发，比如说 Spring 支持 IoC（Inversion of Control:控制反转）和 AOP(Aspect-Oriented Programming:面向切面编程)、可以很方便地对数据库进行访问、可以很方便地集成第三方组件（电子邮件，任务，调度，缓存等等）、对单元测试支持比较好、支持 RESTful Java 应用程序的开发。

[

Spring 最核心的思想就是不重新造轮子，开箱即用，提高开发效率。

Spring 翻译过来就是春天的意思，可见其目标和使命就是为 Java 程序员带来春天啊！感动！

🤐 多提一嘴： 语言的流行通常需要一个杀手级的应用，Spring 就是 Java 生态的一个杀手级的应用框架。

Spring 提供的核心功能主要是 IoC 和 AOP。学习 Spring ，一定要把 IoC 和 AOP 的核心思想搞懂！

Spring 官网：https://spring.io/
Github 地址： https://github.com/spring-projects/spring-framework

Spring 包含的模块有哪些？#

Spring4.x 版本 ：

git

Tue, 07 Feb 2023 16:14:19 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

版本控制#

什么是版本控制#

版本控制是一种记录一个或若干文件内容变化，以便将来查阅特定版本修订情况的系统。除了项目源代码，你还可以对任何类型的文件进行版本控制。

为什么要版本控制#

有了它你就可以将某个文件回溯到之前的状态，甚至将整个项目都回退到过去某个时间点的状态，你可以比较文件的变化细节，查出最后是谁修改了哪个地方，从而找出导致怪异问题出现的原因，又是谁在何时报告了某个功能缺陷等等。

本地版本控制系统#

许多人习惯用复制整个项目目录的方式来保存不同的版本，或许还会改名加上备份时间以示区别。这么做唯一的好处就是简单，但是特别容易犯错。有时候会混淆所在的工作目录，一不小心会写错文件或者覆盖意想外的文件。

为了解决这个问题，人们很久以前就开发了许多种本地版本控制系统，大多都是采用某种简单的数据库来记录文件的历次更新差异。

集中化的版本控制系统#

接下来人们又遇到一个问题，如何让在不同系统上的开发者协同工作？于是，集中化的版本控制系统（Centralized Version Control Systems，简称 CVCS）应运而生。

集中化的版本控制系统都有一个单一的集中管理的服务器，保存所有文件的修订版本，而协同工作的人们都通过客户端连到这台服务器，取出最新的文件或者提交更新。

这么做虽然解决了本地版本控制系统无法让在不同系统上的开发者协同工作的诟病，但也还是存在下面的问题：

单点故障： 中央服务器宕机，则其他人无法使用；如果中心数据库磁盘损坏又没有进行备份，你将丢失所有数据。本地版本控制系统也存在类似问题，只要整个项目的历史记录被保存在单一位置，就有丢失所有历史更新记录的风险。
必须联网才能工作： 受网络状况、带宽影响。

分布式版本控制系统#

于是分布式版本控制系统（Distributed Version Control System，简称 DVCS）面世了。 Git 就是一个典型的分布式版本控制系统。

这类系统，客户端并不只提取最新版本的文件快照，而是把代码仓库完整地镜像下来。这么一来，任何一处协同工作用的服务器发生故障，事后都可以用任何一个镜像出来的本地仓库恢复。因为每一次的克隆操作，实际上都是一次对代码仓库的完整备份。

分布式版本控制系统可以不用联网就可以工作，因为每个人的电脑上都是完整的版本库，当你修改了某个文件后，你只需要将自己的修改推送给别人就可以了。但是，在实际使用分布式版本控制系统的时候，很少会直接进行推送修改，而是使用一台充当“中央服务器”的东西。这个服务器的作用仅仅是用来方便“交换”大家的修改，没有它大家也一样干活，只是交换修改不方便而已。

分布式版本控制系统的优势不单是不必联网这么简单，后面我们还会看到 Git 极其强大的分支管理等功能。

认识 Git#

Git 简史#

Linux 内核项目组当时使用分布式版本控制系统 BitKeeper 来管理和维护代码。但是，后来开发 BitKeeper 的商业公司同 Linux 内核开源社区的合作关系结束，他们收回了 Linux 内核社区免费使用 BitKeeper 的权力。 Linux 开源社区（特别是 Linux 的缔造者 Linus Torvalds）基于使用 BitKeeper 时的经验教训，开发出自己的版本系统，而且对新的版本控制系统做了很多改进。

maven

Tue, 07 Feb 2023 13:28:19 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

这部分内容主要根据 Maven 官方文档整理，做了对应的删减，主要保留比较重要的部分，不涉及实战，主要是一些重要概念的介绍。

Maven 介绍#

Maven 官方文档是这样介绍的 Maven 的：

Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project’s build, reporting and documentation from a central piece of information.

Apache Maven 的本质是一个软件项目管理和理解工具。基于项目对象模型 (Project Object Model，POM) 的概念，Maven 可以从一条中心信息 管理项目的构建、报告和文档。

什么是 POM？ 每一个 Maven 工程都有一个 pom.xml 文件，位于根目录中，包含项目构建生命周期的详细信息。通过 pom.xml 文件，我们可以定义项目的坐标、项目依赖、项目信息、插件信息等等配置。

对于开发者来说，Maven 的主要作用主要有 3 个：

Atomic预备知识

Fri, 03 Feb 2023 11:04:33 +0000

Java实现CAS的原理[非javaguide]#

i是非线程安全的，因为**i不是原子操作；可以使用synchronized和CAS实现加锁**

synchronized是悲观锁，一旦获得锁，其他线程进入后就会阻塞等待锁；而CAS是乐观锁，执行时不会加锁，假设没有冲突，如果因为冲突失败了就重试，直到成功

乐观锁和悲观锁
- 这是一种分类方式
- 悲观锁，总是认为每次访问共享资源会发生冲突，所以必须对每次数据操作加锁，以保证临界区的程序同一时间只能有一个线程在执行
- 乐观锁，又称**“无锁”**，假设对共享资源访问没有冲突，线程可以不停的执行，无需加锁无需等待；一旦发生冲突，通常是使用一种称为CAS的技术保证线程执行安全
  - 无锁没有锁的存在，因此不可能发生死锁，即乐观锁天生免疫死锁
  - 乐观锁用于**“读多写少”的环境，避免加锁频繁影响性能；悲观锁用于“写多读少”，避免频繁失败及重试**影响性能
CAS概念，即CompareAndSwap ，比较和交换，CAS中，有三个值（概念上）
V：要更新的变量(var)；E：期望值（expected）；N：新值（new）判断V是否等于E，如果等于，将V的值设置为N；如果不等，说明已经有其它线程更新了V，则当前线程放弃更新，什么都不做。一般来说，预期值E本质上指的是“旧值”（判断是否修改了）
1. 如果有一个多个线程共享的变量i原本等于5，我现在在线程A中，想把它设置为新的值6;
2. 我们使用CAS来做这个事情；
3. （首先要把原来的值5在线程中保存起来）
4. 接下来是原子操作：首先我们用（现在的i）去与5对比，发现它等于5，说明没有被其它线程改过，那我就把它设置为新的值6，此次CAS成功，i的值被设置成了6；
5. 如果不等于5，说明i被其它线程改过了（比如现在i的值为2），那么我就什么也不做，此次CAS失败，i的值仍然为2。

其中i为V，5为E，6为N

CAS是一种原子操作，它是一种系统原语，是一条CPU原子指令，从CPU层面保证它的原子性（不可能出现说，判断了对比了i为5之后，正准备更新它的值，此时该值被其他线程改了）

当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。

Java实现CAS的原理 - Unsafe类

在Java中，如果一个方法是native的，那Java就不负责具体实现它，而是交给底层的JVM使用c或者c++去实现

Java中有一个Unsafe类，在sun.misc包中，里面有一些native方法，其中包括：

boolean compareAndSwapObject(Object o, long offset,Object expected, Object x);
boolean compareAndSwapInt(Object o, long offset,int expected,int x);
boolean compareAndSwapLong(Object o, long offset,long expected,long x);


//------>AtomicInteger.class

public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;

// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
 try {
 valueOffset = unsafe.objectFieldOffset
 (AtomicInteger.class.getDeclaredField("value"));
 } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;
public final int getAndIncrement() {
	return unsafe.getAndAddInt(this, valueOffset, 1);

}

MySQL高性能优化规范建议总结

Fri, 20 Jan 2023 11:36:34 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

索引优化相关

in 代替 or

not exist 代替 not in

数据库命名规范#

所有数据库对象名称必须使用小写字母并用下划线分割
所有数据库对象名称禁止使用 MySQL 保留关键字（如果表名中包含关键字查询时，需要将其用单引号括起来）
数据库对象的命名要能做到见名识意，并且最好不要超过 32 个字符
临时库表必须以 tmp_ 为前缀并以日期为后缀，备份表必须以 bak_ 为前缀并以日期 (时间戳) 为后缀
所有存储相同数据的列名和列类型必须一致（一般作为关联列，如果查询时关联列类型不一致会自动进行数据类型隐式转换，会造成列上的索引失效，导致查询效率降低）

数据库基本设计规范#

所有表必须使用InnoDB存储引擎#

没有特殊要求（即 InnoDB 无法满足的功能如：列存储，存储空间数据等）的情况下，所有表必须使用 InnoDB 存储引擎（MySQL5.5 之前默认使用 Myisam，5.6 以后默认的为 InnoDB）。
InnoDB 支持事务，支持行级锁，更好的恢复性，高并发下性能更好

数据库和表的字符集统一使用UTF-8#

兼容性更好，统一字符集可以避免由于字符集转换产生的乱码，不同的字符集进行比较前需要进行转换会造成索引失效，如果数据库中有存储 emoji 表情的需要，字符集需要采用 utf8mb4 字符集。

参考文章：

MySQL 字符集不一致导致索引失效的一个真实案例open in new window
[MySQL 字符集详解

所有表和字段都需要添加注释#

使用 comment 从句添加表和列的备注，从一开始就进行数据字典的维护

尽量控制单表数据量的大小，建议控制在500万以内#

500 万并不是 MySQL 数据库的限制，过大会造成修改表结构，备份，恢复都会有很大的问题。
可以用历史数据归档（应用于日志数据），**分库分表（应用于业务数据）**等手段来控制数据量大小

谨慎使用MySQL分区表#

分区表在物理上表现为多个文件，在逻辑上表现为一个表；
谨慎选择分区键，跨分区查询效率可能更低；
建议采用物理分表的方式管理大数据。

经常一起使用的列放到一个表中#

避免更多的关联操作。

MySQL常见面试题总结

Fri, 20 Jan 2023 11:36:06 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!====

MySQL基础#

关系型数据库介绍#

关系型数据库，建立在关系模型的基础上的数据库。表明数据库中所存储的数据之间的联系（一对一、一对多、多对多）
关系型数据库中，我们的数据都被存放在各种表中（比如用户表），表中的每一行存放着一条数据（比如一个用户的信息）
大部分关系型数据库都使用SQL来操作数据库中的数据，并且大部分关系型数据库都支持事务的四大特性（ACID）

常见的关系型数据库
MySQL、PostgreSQL、Oracle、SQL Server、SQLite（微信本地的聊天记录的存储就是用的 SQLite） ……

MySQL介绍#

MySQL是一种关系型数据库，主要用于持久化存储我们系统中的一些数据比如用户信息
由于 MySQL 是开源免费并且比较成熟的数据库，因此，MySQL 被大量使用在各种系统中。任何人都可以在 GPL(General Public License 通用性公开许可证) 的许可下下载并根据个性化的需要对其进行修改。MySQL 的默认端口号是3306。

MySQL基础架构#

MySQL的一个简要机构图，客户端的一条SQL语句在MySQL内部如何执行
MySQL主要由几部分构成
1. 连接器：身份认证和权限相关（登录MySQL的时候）
2. 查询缓存：执行查询语句的时候，会先查询缓存（MySQL8.0版本后移除，因为这个功能不太实用）
3. 分析器：没有命中缓存的话，SQL语句就会经过分析器，分析器说白了就是要先看你的SQL语句要干嘛，再检查你的SQL语句语法是否正确
4. 优化器：按照MySQL认为最优的方案去执行
5. 执行器：执行语句，然后从存储引擎返回数据。执行语句之前会先判断是否有权限，如果没有权限，就会报错
6. 插件式存储引擎：主要负责数据的存储和读取，采用的是插件式架构，支持InnoDB、MyISAM、Memory等多种存储引擎

MySQL存储引擎#

MySQL核心在于存储引擎

MySQL支持哪些存储引擎？默认使用哪个？#

MySQL支持多种存储引擎，可以通过show engines命令来查看MySQL支持的所有存储引擎
默认存储引擎为InnoDB，并且，所有存储引擎中只有InnoDB是事务性存储引擎，也就是说只有InnoDB支持事务
这里使用MySQL 8.x MySQL 5.5.5之前，MyISAM是MySQL的默认存储引擎；5.5.5之后，InnoDB是MySQL的默认存储引擎，可以通过select version()命令查看你的MySQL版本
```
mysql> select version();
+-----------+
| version() |
+-----------+
| 8.0.27 |
+-----------+
1 row in set (0.00 sec) 
```
使用show variables like %storage_engine%命令直接查看MySQL当前默认的存储引擎

如果只想查看数据库中某个表使用的存储引擎的话，可以使用show table status from db_name where name = 'table_name'命令

MySQL中的隐式转换造成的索引失效

Thu, 19 Jan 2023 17:10:48 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

本篇文章基于MySQL 5.7.26，原文：https://www.guitu18.com/post/2019/11/24/61.html

前言#

关于数据库优化，最常见的莫过于索引失效，数据量多的时候比较明显，处理不及时会造成雪球效应，最终导致数据库卡死甚至瘫痪。
这里说的是隐式转换造成的索引失效

数据准备#

-- 创建测试数据表
DROP TABLE IF EXISTS test1;
CREATE TABLE `test1` (
 `id` int(11) NOT NULL,
 `num1` int(11) NOT NULL DEFAULT '0',
 `num2` varchar(11) NOT NULL DEFAULT '',
 `type1` int(4) NOT NULL DEFAULT '0',
 `type2` int(4) NOT NULL DEFAULT '0',
 `str1` varchar(100) NOT NULL DEFAULT '',
 `str2` varchar(100) DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `num1` (`num1`),
 KEY `num2` (`num2`),
 KEY `type1` (`type1`),
 KEY `str1` (`str1`),
 KEY `str2` (`str2`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- 创建存储过程
DROP PROCEDURE IF EXISTS pre_test1;
DELIMITER //
CREATE PROCEDURE `pre_test1`()
BEGIN
 DECLARE i INT DEFAULT 0;
 SET autocommit = 0;
 WHILE i < 10000000 DO
 SET i = i + 1;
 SET @str1 = SUBSTRING(MD5(RAND()),1,20);
 -- 每100条数据str2产生一个null值
 IF i % 100 = 0 THEN
 SET @str2 = NULL;
 ELSE
 SET @str2 = @str1;
 END IF;
 INSERT INTO test1 (`id`, `num1`, `num2`,
 `type1`, `type2`, `str1`, `str2`)
 VALUES (CONCAT('', i), CONCAT('', i),
 CONCAT('', i), i%5, i%5, @str1, @str2);
 -- 事务优化，每一万条数据提交一次事务
 IF i % 10000 = 0 THEN
 COMMIT;
 END IF;
 END WHILE;
END;
// DELIMITER ;
-- 执行存储过程
CALL pre_test1();

其中，七个字段，首先使用存储过程生成 1000 万条测试数据，测试表一共建立了 7 个字段（包括主键），num1和num2保存的是和ID一样的顺序数字，其中num2是字符串类型。 type1和type2保存的都是主键对 5 的取模，目的是模拟实际应用中常用类似 type 类型的数据，但是**type2是没有建立索引的。 str1和str2都是保存了一个 20 位长度的随机字符串，str1不能为NULL，str2允许为NULL，相应的生成测试数据的时候我也会在str2字段生产少量NULL值**（每 100 条数据产生一个NULL值）。

MySQL数据库时间类型数据存储建议

Thu, 19 Jan 2023 17:10:06 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

不要用字符串存储日期#

优点：简单直白
缺点
1. 字符串占有的空间更大
2. 字符串存储的日期效率比较低（逐个字符进行比较），无法用日期相关的API进行计算和比较

Datetime和Timestamp之间抉择#

Datetime 和 Timestamp 是 MySQL 提供的两种比较相似的保存时间的数据类型。他们两者究竟该如何选择呢？

通常我们都会首选 Timestamp

Datetime类型没有时区信息#

DateTime 类型是没有时区信息的（时区无关） ，DateTime 类型保存的时间都是当前会话所设置的时区对应的时间。这样就会有什么问题呢？当你的时区更换之后，比如你的服务器更换地址或者更换客户端连接时区设置的话，就会导致你从数据库中读出的时间错误。不要小看这个问题，很多系统就是因为这个问题闹出了很多笑话。
Timestamp 和时区有关。Timestamp 类型字段的值会随着服务器时区的变化而变化，自动换算成相应的时间，说简单点就是在不同时区，查询到同一个条记录此字段的值会不一样

案例

-- 建表
CREATE TABLE `time_zone_test` (
 `id` bigint(20) NOT NULL AUTO_INCREMENT,
 `date_time` datetime DEFAULT NULL,
 `time_stamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8; 

-- 插入数据
INSERT INTO time_zone_test(date_time,time_stamp) VALUES(NOW(),NOW());
-- 查看数据
select date_time,time_stamp from time_zone_test;
-- 结果
/*
 +---------------------+---------------------+
| date_time | time_stamp |
+---------------------+---------------------+
| 2020-01-11 09:53:32 | 2020-01-11 09:53:32 |
+---------------------+---------------------+
------ 
*/

修改时区并查看数据

set time_zone='+8:00';
/*
+---------------------+---------------------+
| date_time | time_stamp |
+---------------------+---------------------+
| 2020-01-11 09:53:32 | 2020-01-11 17:53:32 |
+---------------------+---------------------+
------ 
*/

关于MySQL时区设置的一个常用sql命令

SQL语句在MySQL中的执行过程

Thu, 19 Jan 2023 10:20:57 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

原文 https://github.com/kinglaw1204 感谢作者

本篇文章会分析一个SQL语句在MySQL的执行流程，包括SQL的查询在MySQL内部会怎么流转，SQL语句的更新是怎么完成的
分析之前先看看MySQL的基础架构，知道了MySQL由哪些组件组成以及这些组件的作用是什么，可以帮助我们理解和解决这些问题

MySQL基础架构分析#

MySQL基本架构概览#

下图是MySQL的简要架构图，从下图可以看到用户的SQL语句在MySQL内部是如何执行的
先简单介绍一个下图涉及的一些组件的基本作用
1. 连接器： 身份认证和权限相关（登录MySQL的时候）
2. 查询缓存：执行查询语句的时候，会先查询缓存（MySQL8.0版本后移除，因为这个功能不太实用）
3. 分析器：没有命中缓存的话，SQL语句就会经过分析器，分析器说白了就是要先看你的SQL语句干嘛，再检查你的SQL语句语法是否正确
4. 优化器：按照MySQL认为最优的方案去执行
5. 执行器：执行语句，然后从存储引擎返回数据
简单来说 MySQL 主要分为 Server 层和存储引擎层：
- Server 层：主要包括连接器、查询缓存、分析器、优化器、执行器等，所有跨存储引擎的功能都在这一层实现，比如存储过程、触发器、视图，函数等，还有一个通用的日志模块 binlog 日志模块。
- 存储引擎：主要负责数据的存储和读取，采用可以替换的插件式架构，支持 InnoDB、MyISAM、Memory 等多个存储引擎，其中 InnoDB 引擎有自有的日志模块 redolog 模块。现在最常用的存储引擎是 InnoDB，它从 MySQL 5.5 版本开始就被当做默认存储引擎了

Server层基本组件介绍#

连接器 连接器主要和身份认证和权限相关的功能相关，就好比一个级别很高的门卫一样

主要负责用户登录数据库，进行用户的身份认证，包括校验账户密码，权限等操作，如果用户账户密码已通过，连接器会到权限表中查询该用户的所有权限，之后在这个连接里的权限逻辑判断都是会依赖此时读取到的权限数据，也就是说，后续只要这个连接不断开，即使管理员修改了该用户的权限，该用户也是不受影响的。
查询缓存（MySQL8.0 版本后移除）
查询缓存主要用来缓存我们所执行的 SELECT 语句以及该语句的结果集。
- 连接建立后，执行查询语句的时候，会先查询缓存，MySQL 会先校验这个 SQL 是否执行过，以 Key-Value 的形式缓存在内存中，Key 是查询预计，Value 是结果集。如果缓存 key 被命中，就会直接返回给客户端，如果没有命中，就会执行后续的操作，完成后也会把结果缓存起来，方便下一次调用。当然在真正执行缓存查询的时候还是会校验用户的权限，是否有该表的查询条件。
- MySQL 查询不建议使用缓存，因为查询缓存失效在实际业务场景中可能会非常频繁，假如你对一个表更新的话，这个表上的所有的查询缓存都会被清空。对于不经常更新的数据来说，使用缓存还是可以的。所以，一般在大多数情况下我们都是不推荐去使用查询缓存的。
MySQL 8.0 版本后删除了缓存的功能，官方也是认为该功能在实际的应用场景比较少，所以干脆直接删掉了

innodb引擎对MVCC的实现

Mon, 16 Jan 2023 19:23:55 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

一致性非锁定读和锁定读#

一致性非锁定读#

★★非锁定★★

对于一致性非锁定读（Consistent Nonlocking Reads）的实现，通常做法是加一个版本号或者时间戳字段，在更新数据的同时版本号+1或者更新时间戳。查询时，将当前可见的版本号与对应记录的版本号进行比对，如果记录的版本小于可见版本，则表示该记录可见
InnoDB存储引擎中，多版本控制（multi versioning）即是非锁定读的实现。如果读取的行正在执行DELETE或UPDATE操作，这时读取操作不会去等待行上 锁的释放.相反地，Inn哦DB存储引擎会去读取行的一个快照数据，对于这种读取历史数据的方式，我们叫它快照读（snapshot read）。
在 Repeatable Read 和 Read Committed 两个隔离级别下，如果是执行普通的 select 语句（不包括 select ... lock in share mode ,select ... for update）则会使用 一致性非锁定读（MVCC）。并且在 Repeatable Read 下 MVCC 实现了可重复读和防止部分幻读

锁定读#

如果执行的是下列语句，就是锁定读（Locking Reads）
1. select ... lock in share
2. select ... for update
3. insert 、upate、delete
4. 锁定读下，读取的是数据的最新版本，这种读也被称为当前读current read。锁定读会对读取到的记录加锁
5. select ... lock in share mode ：对(读取到的)记录加S锁，其他事务也可以加S锁，如果加X锁则会被阻塞
6. select ... for update、insert、update、delete：对记录加X锁，且其他事务不能加任何锁
在一致性非锁定读下，即使读取的记录已被其他事务加上X锁，这时记录也是可以被读取的，即读取的快照数据。
1. 在RepeatableRead下MVCC防止了部分幻读，这边的“部分”是指在一致性非锁定读情况下，只能读取到第一次查询之前所插入的数据（根据ReadView判断数据可见性，ReadView在第一次查询时生成），但如果是当前读，每次读取的都是最新数据，这时如果两次查询中间有其他事务插入数据，就会产生幻读
2. 所以，InnoDB在实现RepeatableRead时，如果执行的是当前读，则会对读取的记录使用Next-key Lock，来防止其他事务在间隙间插入数据。
RR产生幻读的另一个场景

MySQL事务隔离级别详解

Mon, 16 Jan 2023 01:00:44 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

事务隔离级别总结#

SQL标准定义了四个隔离级别
1. READ-UNCOMMITTED(读取未提交)：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读
2. READ-COMMITED(读取已提交)：允许读取并发事务 已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生
3. REPEATABLE-READ(可重复读)：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生
4. SERIALIZABLE(可串行化)：最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。
隔离级别脏读不可重复读幻读

READ-UNCOMMITTED √ √ √

READ-COMMITTED × √ √

REPEATABLE-READ × × √

SERIALIZABLE × × ×
MySQL InnoDB 存储引擎的默认支持的隔离级别是 REPEATABLE-READ（可重读）
使用命令查看，通过SELECT @@tx_isolation;。
MySQL 8.0 该命令改为SELECT @@transaction_isolation;
```
MySQL> SELECT @@tx_isolation;
+-----------------+
| @@tx_isolation |
+-----------------+
| REPEATABLE-READ |
+-----------------+ 
```
从上面对SQL标准定义了四个隔离级别的介绍可以看出，标准的SQL隔离级别里，REPEATABLE-READ(可重复读)是不可以防止幻读的。但是，InnoDB实现的REPEATABLE-READ 隔离级别其实是可以解决幻读问题发生的，分两种情况
1. 快照读：由MVCC机制来保证不出现幻读
2. 当前读：使用Next-Key Lock进行加锁来保证不出现幻读，Next-Key Lock是行锁（Record Lock ）和间隙锁（Gap Lock）的结合，行锁只能锁住已经存在的行，为了避免插入新行，需要依赖间隙锁 (只用间隙锁不行，因为间隙锁是 > 或 < ，不包括等于，所以再可重复读下原记录可能会被删掉)
因为隔离级别越低，事务请求的锁越少，所以大部分数据库系统的隔离级别都是 READ-COMMITTED ，但是你要知道的是 InnoDB 存储引擎默认使用 REPEATABLE-READ 并不会有任何性能损失。

隔离级别	脏读	不可重复读	幻读
READ-UNCOMMITTED	√	√	√
READ-COMMITTED	×	√	√
REPEATABLE-READ	×	×	√
SERIALIZABLE	×	×	×

日志

Sat, 14 Jan 2023 17:31:53 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

前言#

首先要了解一个东西：WAL，全称 Write-Ahead Logging，它的关键点就是先写日志，再写磁盘

在概念上，innodb通过***force log at commit***机制实现事务的持久性，即在事务提交的时候，必须先将该事务的所有事务日志写入到磁盘上的redo log file和undo log file中进行持久化
1. WAL 机制的原理也很简单：修改并不直接写入到数据库文件中，而是写入到另外一个称为 WAL 的文件中；如果事务失败，WAL 中的记录会被忽略，撤销修改；如果事务成功，它将在随后的某个时间被写回到数据库文件中，提交修改
2. 使用 WAL 的数据库系统不会再每新增一条 WAL 日志就将其刷入数据库文件中，一般积累一定的量然后批量写入，通常使用页为单位，这是磁盘的写入单位。同步 WAL 文件和数据库文件的行为被称为 checkpoint（检查点），一般在 WAL 文件积累到一定页数修改的时候；当然，有些系统也可以手动执行 checkpoint。执行 checkpoint 之后，WAL 文件可以被清空，这样可以保证 WAL 文件不会因为太大而性能下降。
  
  有些数据库系统读取请求也可以使用 WAL，通过读取 WAL 最新日志就可以获取到数据的最新状态
  关于checkpoint：https://www.cnblogs.com/chenpingzhao/p/5107480.html思考一下这个场景：如果重做日志可以无限地增大，同时缓冲池也足够大，那么是不需要将缓冲池中页的新版本刷新回磁盘。因为当发生宕机时，完全可以通过重做日志来恢复整个数据库系统中的数据到宕机发生的时刻。但是这需要两个前提条件：1、缓冲池可以缓存数据库中所有的数据；2、重做日志可以无限增大
  
  因此Checkpoint（检查点）技术就诞生了，目的是解决以下几个问题：1、缩短数据库的恢复时间；2、缓冲池不够用时，将脏页刷新到磁盘；3、重做日志不可用时，刷新脏页。
  - 当数据库发生宕机时，数据库不需要重做所有的日志，因为Checkpoint之前的页都已经刷新回磁盘。数据库只需对Checkpoint后的重做日志进行恢复，这样就大大缩短了恢复的时间。
  - 当缓冲池不够用时，根据LRU算法会溢出最近最少使用的页，若此页为脏页，那么需要强制执行Checkpoint，将脏页也就是页的新版本刷回磁盘。
  - 当重做日志出现不可用时，因为当前事务数据库系统对重做日志的设计都是循环使用的，并不是让其无限增大的，重做日志可以被重用的部分是指这些重做日志已经不再需要，当数据库发生宕机时，数据库恢复操作不需要这部分的重做日志，因此这部分就可以被覆盖重用。如果重做日志还需要使用，那么必须强制Checkpoint，将缓冲池中的页至少刷新到当前重做日志的位置。
3. mysql 的 WAL，大家可能都比较熟悉。mysql 通过 redo、undo 日志实现 WAL。redo log 称为重做日志，每当有操作时，在数据变更之前将操作写入 redo log，这样当发生掉电之类的情况时系统可以在重启后继续操作。undo log 称为撤销日志，当一些变更执行到一半无法完成时，可以根据撤销日志恢复到变更之间的状态。mysql 中用 redo log 来在系统 Crash 重启之类的情况时修复数据（事务的持久性），而 undo log 来保证事务的原子性。

索引

Tue, 10 Jan 2023 22:09:25 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

补充索引基础知识(引自b站sgg视频)#

存储引擎，数据的基本单位是页，如果数据很少，只有一页，那就简单，是直接二分查找(不涉及磁盘IO)；如果数据很多，有好几个页，那么需要对页建立一种数据结构，能够最快定位到哪一页，然后减少磁盘IO

索引介绍#

索引是一种用于快速查询和检索数据的数据结构，其本质可以看成是一种排序好的数据结构

索引的作用就相当于书的目录。打个比方: 我们在查字典的时候，如果没有目录，那我们就只能一页一页的去找我们需要查的那个字，速度很慢。如果有目录了，我们只需要先去目录里查找字的位置，然后直接翻到那一页就行了
索引底层数据结构存在很多种类型，常见的索引结构有：B树，B+树和Hash、红黑树。在MySQL中，无论是Innodb还是MyIsam，都使用了B+树作为索引结构

索引的优缺点#

优点：

使用索引可以大大加快数据的检索速度（大大减少检索的数据量）, 这也是创建索引的最主要的原因。
通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。

缺点：

创建索引和维护索引需要耗费许多时间。当对表中的数据进行增删改的时候，如果数据有索引，那么索引也需要动态的修改，会降低 SQL 执行效率。
索引需要使用物理文件存储，也会耗费一定空间

索引一定会提高查询性能吗

多数情况下，索引查询都是比全表扫描要快的。但是如果数据库的数据量不大，那么使用索引也不一定能够带来很大提升

索引的底层数据结构#

Hash表#

哈希表是键值对的集合，通过键（key）即可快速取出对应的值（value），因此哈希表可以快速检索数据（接近O(1))
为何能够通过key快速取出value呢？原因在于哈希算法（也叫散列算法）。通过哈希算法，我们可以快速找到key对应的index，找到了index也就找到了对应的value
```
hash = hashfunc(key)
index = hash % array_size
```
注意，图中keys[天蓝色]是字符串，不是什么莫名其妙的人
哈希算法有个 Hash 冲突 问题，也就是说多个不同的 key 最后得到的 index 相同。通常情况下，我们常用的解决办法是 链地址法。链地址法就是将哈希冲突数据存放在链表中。就比如 JDK1.8 之前 HashMap 就是通过链地址法来解决哈希冲突的。不过，JDK1.8 以后HashMap为了减少链表过长的时候搜索时间过长引入了红黑树。
为了减少 Hash 冲突的发生，一个好的哈希函数应该**“均匀地”将数据分布**在整个可能的哈希值集合中
由于Hash索引不支持顺序和范围查询，假如要对表中的数据进行排序或者进行范围查询，那Hash索引就不行了，并且，每次IO只能取一个
例如： SELECT * FROM tb1 WHERE id < 500 ;
- 这种范围查询中，B+树优势非常大直接遍历比500小的叶子节点即可
- 如果使用Hash索引，由于Hash索引是根据hash算法来定位的，难不成把1 ~499 （小于500）的数据都进行一次hash计算来定位吗？这就是Hash最大的缺点
这里其实说的是已经找到了索引，但是索引没有数据的情形。要么通过hash一个个取数据，要么利用B+树的特性（叶子节点有完整数据）

字符集详解

Tue, 10 Jan 2023 16:48:22 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

图示总结

MySQL字符编码集有两套UTF-8编码实现：utf-8 和 utf8mb4
而其中，utf-8 不支持存储emoji符号和一些比较复杂的汉字、繁体字，会出错

何为字符集#

字符是各种文字和符号的统称，包括各个国家文字、标点符号、表情、数字等等
- 字符集就是一系列字符的集合，字符集的种类较多，每个字符集可以表示的字符范围通常不同，就比如说有些字符集无法表示汉字
计算机只能存储二进制的数据，那英文、汉字、表情等字符应该如何存储呢
- 我们要将这些字符和二进制的数据一一对应起来，比如说字符“a”对应“01100001”，反之，“01100001”对应 “a”。我们将字符对应二进制数据的过程称为"字符编码"，反之，二进制数据解析成字符的过程称为“字符解码”。

有哪些常见的字符集#

常见的字符集有ASCLL、GB2312、GBK、UTF-8
不同的字符集的主要区别在于
1. 可以表示的字符范围
2. 编码方式

ASCLL#

ASCII (American Standard Code for Information Interchange，美国信息交换标准代码) 是一套主要用于现代美国英语的字符集（这也是 ASCII 字符集的局限性所在）

为什么 ASCII 字符集没有考虑到中文等其他字符呢？ 因为计算机是美国人发明的，当时，计算机的发展还处于比较雏形的时代，还未在其他国家大规模使用。因此，美国发布 ASCII 字符集的时候没有考虑兼容其他国家的语言
ASCII 字符集至今为止共定义了 128 个字符，其中有 33 个控制字符（比如回车、删除）无法显示
一个 ASCII 码长度是一个字节也就是 8 个 bit，比如“a”对应的 ASCII 码是“01100001”。不过，最高位是 0 仅仅作为校验位，其余 7 位使用 0 和 1 进行组合，所以，ASCII 字符集可以定义 128（2^7）个字符

由于，ASCII 码可以表示的字符实在是太少了。后来，人们对其进行了扩展得到了 ASCII 扩展字符集 。ASCII 扩展字符集使用 8 位（bits）表示一个字符，所以，ASCII 扩展字符集可以定义 256（2^8）个字符

树

Mon, 09 Jan 2023 15:52:34 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

树是一种类似现实生活中的树的数据结构（倒置的树）
任何一颗非空树只有一个根节点
一棵树具有以下特点：
1. 一棵树中的任何两个节点有且仅有唯一的一条路相通（因为每个结点只会有一个父节点）
2. 一棵树如果有n个节点，那么它一定恰好有n-1条边
3. 一棵树不包括回路
下面是一颗二叉树 深度和高度是对应的；根节点所在层为1层
常用概念
1. 节点：树中每个元素都可以统称为节点
2. 根节点：顶层节点，或者说没有父节点的节点。上图中A节点就是根节点
3. 父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点。上图中的 B 节点是 D 节点、E 节点的父节点
4. 兄弟节点：具有相同父节点的节点互称为兄弟节点。上图中 D 节点、E 节点的共同父节点是 B 节点，故 D 和 E 为兄弟节点。
5. 叶子节点：没有子节点的节点。上图中的 D、F、H、I 都是叶子节点
6. 节点的高度**（跟叶子节点有关，同一层不一定一样）：该节点到叶子节点的最长路径所包含的边数。
7. 节点的深度**（跟根节点有关，同一层是一样的）：根节点到该节点的路径所包含的边数**
8. 节点的层数：节点的深度+1
9. 树的高度：根节点的高度

二叉树的分类#

**二叉树（Binary tree）**是每个节点最多只有两个分支（即不存在分支度大于2的节点）的树结构
二叉树的分支，通常被称为左子树或右子树，并且，二叉树的分支具有左右次序，不能随意颠倒
二叉树的第i层至多拥有2^(i-1) 个节点
深度为k的二叉树至多总共有 2^(k+1) -1 个节点（深度为k，最多k + 1 层，最多为满二叉树的情况）
至少有2^(k) 个节点，即深度为k-1的二叉树的最多的节点再加1

（关于节点的深度的定义国内争议比较多，我个人比较认可维基百科对节点深度的定义open in new window）。

满二叉树#

一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是 满二叉树。也就是说，如果一个二叉树的层数为 K，且结点总数是(2^k) -1 ，则它就是 满二叉树。

堆

Fri, 06 Jan 2023 10:46:19 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

什么是堆#

堆是满足以下条件的树堆中每一个节点值都大于等于（或小于等于）子树中所有节点。或者说，任意一个节点的值**都大于等于（或小于等于）**所有子节点的值

大家可以把堆(最大堆)理解为一个公司,这个公司很公平,谁能力强谁就当老大,不存在弱的人当老大,老大手底下的人一定不会比他强。这样有助于理解后续堆的操作。
- 堆不一定是完全二叉树，为了方便存储和索引，我们通常用完全二叉树的形式来表示堆
  广为人知的斐波那契堆和二项堆就不是完全二叉树，它们甚至都不是二叉树
- (二叉)堆是一个数组，它可以被看成是一个近似的完全二叉树
下面给出的图是否是堆（通过定义）

1，2是。 3不是。

堆的用途#

当我们只关心所有数据中的最大值或者最小值，存在多次获取最大值或者最小值，多次插入或删除数据时，就可以使用堆。

有小伙伴可能会想到用有序数组，初始化一个有序数组时间复杂度是 O(nlog(n))[也就是将一堆数字乱序排序，最快是O(nlog(n))]，查找最大值或者最小值时间复杂度都是 O(1)，但是，涉及到更新（插入或删除）数据时，时间复杂度为 O(n)，即使是使用复杂度为 O(log(n)) 的二分法找到要插入或者删除的数据，在移动数据时也需要 O(n) 的时间复杂度。
相对于有序数组而言，堆的主要优势在于更新数据效率较高
- 堆的初始化时间复杂度为O(nlog(n))，堆可以做到O(1)的时间复杂度取出最大值或者最小值，O(log(n))的时间复杂度插入或者删除数据

堆的分类#

堆分为最大堆和最小堆，二者的区别在于节点的排序方式
- 最大堆：堆中的每一个节点的值都大于子树中所有节点的值
- 最小堆：堆中的每一个节点的值都小于子树中所有节点的值
如图，图1是最大堆，图2是最小堆

堆的存储#

由于完全二叉树的优秀性质，利用数组存储二叉树即节省空间，又方便索引（若根结点的序号为1，那么对于树中任意节点i，其左子节点序号为 2*i，右子节点序号为 2*i+1）。
为了方便存储和索引，（二叉）堆可以用完全二叉树的形式进行存储。存储的方式如下图所示

堆的操作#

堆的更新操作主要包括两种：插入元素和删除堆顶元素

堆是一个公平的公司，有能力的人自然会走到与他能力所匹配的位置

插入元素#

将要插入的元素放到最后
从底向上，如果父节点比该元素小，则该节点和父节点交换（其实就是一棵树有3个（最多）节点，与树上最大的节点比较）直到无法交换（已经与根节点比较过）

删除堆顶元素#

根据堆的性质可知，最大堆的堆盯元素为所有元素中最大的，最小堆的堆顶元素是所有元素中最小的
当我们需要多次查找最大元素或者最小元素的时候，可以利用堆来实现
删除堆顶元素后，为了保持堆的性质，需要对堆的结构进行调整，我们可以将这个过程称之为堆化
1. 自底向上的堆化，上述的插入元素所使用的，就是自顶向上的堆化，元素从最底部向上移动
2. 自顶向下的堆化，元素由顶部向下移动。在讲解删除堆顶元素的方法时，我将阐述这两种操作的过程
自底向上堆化

在堆这个公司中，会出现老大离职的现象，老大离职之后，它的位置就空出来了
1. 首先删除堆顶元素，使得数组中下标为1的位置空出
  
  那么他的位置由谁来接替呢，当然是他的直接下属了，谁能力强就让谁上
2. 比较根节点（当前节点）的左子节点和右子节点，也就是下标为 2 ，3 的数组元素，将较大的元素填充到**根节点（下标为1）（当前遍历节点）**的位置

图

Mon, 26 Dec 2022 08:47:25 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

图是一种较为复杂的非线性结构
线性数据结构的元素满足唯一的线性关系，每个元素（除第一个和最后一个外）只有一个直接前驱和一个直接后继
树形数据结构的元素之间有着明显的层级关系
图形结构的元素之间的关系是任意的
- 图就是由顶点的有穷非空集合和顶点之间的边组成的集合，通常表示为：G（V，E），其中，G表示一个图，V表示顶点的集合，E表示边的集合
- 下面显示的即图这种数据结构，而且还是一张有向图

图的基本概念#

顶点#

图中的数据元素，我们称之为顶点，图至少有一个顶点（有穷非空集合）
对应到好友关系图，每一个用户就代表一个顶点

边#

顶点之间的关系用边表示
对应到好友关系图，两个用户是好友的话，那两者之间就存在一条边

度#

度表示一个顶点包含多少条边
有向图中，分为出度和入度，出度表示从该顶点出去的边的条数，入度表示从进入该顶点的边的条数
对应到好友关系图，度就代表了某个人的好友数量

无向图和有向图#

边表示的是顶点之间的关系，有的关系是双向的，比如同学关系，A是B的同学，那么B也肯定是A的同学，那么在表示A和B的关系时，就不用关注方向，用不带箭头的边表示，这样的图就是无向图。

有的关系是有方向的，比如父子关系，师生关系，微博的关注关系，A是B的爸爸，但B肯定不是A的爸爸，A关注B，B不一定关注A。在这种情况下，我们就用带箭头的边表示二者的关系，这样的图就是有向图。

无权图和带权图#

对于一个关系，如果我们只关心关系的有无，而不关心关系有多强，那么就可以用无权图表示二者的关系。

对于一个关系，如果我们既关心关系的有无，也关心关系的强度，比如描述地图上两个城市的关系，需要用到距离，那么就用带权图来表示，带权图中的每一条边一个数值表示权值，代表关系的强度。

下图就是一个带权有向图。

图的存储#

邻接矩阵存储#

邻接矩阵将图用二维矩阵存储，是一种比较直观的表示方式
如果第i个顶点和第j个顶点有关系，且关系权值为n，则A[i] [j] = n
在无向图中，我们只关心关系的有无，所以当顶点i和顶点j有关系时，A[i] [j]=1 ; 当顶点i和顶点j没有关系时，A[i] [j] = 0 ，如下图所示
无向图的邻接矩阵是一个对称矩阵，因为在无向图中，顶点i和顶点j有关系，则顶点j和顶点i必有关系
有向图的邻接矩阵存储邻接矩阵存储的方式优点是简单直接（直接使用一个二维数组即可），并且在获取两个顶点之间的关系的时候也非常高效*直接获取指定位置的数组元素。但是这种存储方式的确定啊也比较明显即比较浪费空间

邻接表存储#

针对上面邻接矩阵比较浪费内存空间的问题，诞生了图的另一种存储方法–邻接表
邻接链表使用一个链表来存储某个顶点的所有后继相邻顶点。对于图中每个顶点Vi ，把所有邻接于Vi 的顶点Vj 链接成一个单链表
- 无向图的邻接表存储
- 有向图的邻接表存储
邻接表中存储的元素的个数（顶点数）以及图中边的条数
- 无向图中，邻接表的元素个数等于边的条数的两倍，如下图 7条边，邻接表存储的元素个数为14 （即每条边存储了两次）
- 有向图中，邻接表元素个数等于边的条数，如图所示的有向图中，边的条数为8，邻接表

图的搜索#

广度优先搜索#

广度优先搜索：像水面上的波纹一样，一层一层向外扩展，如图

线性数据结构

Tue, 20 Dec 2022 13:34:59 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

数组#

数组（Array）是一种常见数据结构，由相同类型的元素（element）组成，并且是使用一块连续的内存来存储
直接可以利用元素的**索引（index）**可以计算出该元素对应的存储地址
数组的特点是：提供随机访问并且容量有限

假设数组长度为n：
访问：O(1) //访问特定位置的元素

插入：O(n) //最坏的情况插入在数组的首部并需要移动所有元素时

删除：O(n) //最坏的情况发生在删除数组的开头并需要移动第一元素后面所有的元素时

链表#

链表简介#

链表（LinkedList）虽然是一种线性表，但是并不会按线性的顺序存储数据，使用的不是连续的内存空间来存储数据
链表的插入和删除操作的复杂度为O(1)，只需要直到目标位置元素的上一个元素即可。但是，在查找一个节点或者访问特定位置的节点的时候复杂度为O(n)
使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理

但链表不会节省空间，相比于数组会占用更多空间，因为链表中每个节点存放的还有指向其他节点的指针。除此之外，链表不具有数组随机读取的优点

链表分类#

单链表、双向链表、循环链表、双向循环链表

假设链表中有n个元素
访问：O(n) //访问特地给位置的元素

插入删除：O(1) //必须要知道插入元素的位置

单链表#

单链表只有一个方向，结点只有一个后继指针next指向后面的节点。因此，链表这种数据结构通常在物理内存上是不连续的
我们习惯性地把第一个结点叫做头结点，链表通常有一个不保存任何值的head节点（头结点），通过头结点我们可以遍历整个链表，尾结点通常指向null
如下图

循环链表#

循环链表是一种特殊的单链表，和单链表不同的是循环链表的尾结点不是指向null，而是指向链表的头结点
如图

双向链表#

双向链表包含两个指针，一个prev指向前一个节点，另一个next指向
如图

双向循环链表#

双向循环链表的最后一个节点的next指向head，而head的prev指向最后一个节点，构成一个环

应用场景#

如果需要支持随机访问的话，链表无法做到
如果需要存储的数据元素个数不确定，并且需要经常添加和删除数据的话，使用链表比较合适
如果需要存储的数据元素的个数确定，并且不需要经常添加和删除数据的话，使用数组比较合适

数组 vs 链表#

数组支持随机访问，链表不支持
数组使用的是连续内存空间 对CPU缓存机制友好，链表则相反
数组的大小固定，而链表则天然支持动态扩容。如果生命的数组过小，需要另外申请一个更大的内存空间存放数组元素，然后将原数组拷贝进去，这个操作比较耗时

栈#

栈简介#

栈（stack）只允许在有序的线性数据集合的一端（称为栈顶top）进行加入数据（push）和移除数据（pop）。因而按照**后进先出（LIFO，Last In First Out）**的原理运作。
栈中，push和pop的操作都发生在栈顶
栈常用一维数组或链表来实现，用数组实现的叫顺序栈，用链表实现的叫做链式栈

假设堆栈中有n个元素。访问：O（n）//最坏情况插入删除：O（1）//顶端插入和删除元素

数据库基础

Tue, 20 Dec 2022 11:19:14 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

这部分内容由于涉及太多概念性内容，所以参考了维基百科和百度百科相应的介绍。

什么是数据库，数据库管理系统，数据库系统，数据库管理员#

数据库：数据库（DataBase 简称DB）就是信息的集合或者说数据库管理系统管理的数据的集合。
数据库管理系统：数据库管理系统（Database Management System 简称DBMS）是一种操纵和管理数据库的大型软件，通常用于建立、使用和维护 数据库。
数据库系统（范围最大）：数据库系统（Data Base System，简称DBS）通常由**软件、数据和数据管理员（DBA）**组成。
数据库管理员：数据库管理员（Database Adminitrator，简称DBA）负责全面管理和控制数据库系统 (是一个人)

数据库系统基本构成如下图所示

什么是元组，码，候选码，主码，外码，主属性，非主属性#

元组：元组（tuple）是关系数据库中的基本概念，关系是一张表，表中的每行（即数据库中的每条记录）就是一个元组，每列就是一个属性。在二维表里，元组也成为行
码：码就是能唯一标识实体的属性，对应表中的列
候选码：若关系中的某一属性或属性组的值能唯一的标识一个元组，而其任何、子集都不能再标识，则称该属性组为候选码。例如：在学生实体中，“学号”是能唯一的区分学生实体的，同时又假设“姓名”、“班级”的属性组合足以区分学生实体，那么**{学号}和{姓名，班级}都是候选码**。
主码：主码也叫主键，主码是从候选码中选出来的。一个实体集中只能有一个主码，但可以有多个候选码
外码：外码也叫外键。如果一个关系中的一个属性是另外一个关系中的主码则这个属性为外码。
主属性 ： 候选码中出现过的属性称为主属性(这里强调单个）。比如关系工人（工号，身份证号，姓名，性别，部门）. 显然工号和身份证号都能够唯一标示这个关系，所以都是候选码。工号、身份证号这两个属性就是主属性。如果主码是一个属性组，那么属性组中的属性都是主属性。
非主属性： 不包含在任何一个候选码中的属性称为非主属性。比如在关系——学生（学号，姓名，年龄，性别，班级）中，主码是“学号”，那么其他的“姓名”、“年龄”、“性别”、“班级”就都可以称为非主属性。

主键和外键有什么区别#

主键(主码) ：主键用于唯一标识一个元组，不能有重复，不允许为空。一个表只能有一个主键。
外键(外码) ：外键用来和其他表建立联系用，外键是另一表的主键，外键是可以有重复的，可以是空值。一个表可以有多个外键

为什么不推荐使用外键与级联#

对于外键和级联，阿里巴巴开发手册这样说道

【强制】不得使用外键与级联，一切外键概念必须在应用层解决。

说明: 以学生和成绩的关系为例，学生表中的 student_id 是主键，那么成绩表中的 student_id 则为外键。如果更新学生表中的 student_id，同时触发成绩表中的 student_id 更新，即为级联更新。

缺点： 外键与级联更新适用于单机低并发，不适合分布式、高并发集群; 级联更新是强阻塞，存在数据库更新风暴的风险; 外键影响数据库的插入速度
为什么不要使用外键
1. 增加了复杂性
  
  a. 每次做DELETE 或者UPDATE都必须考虑外键约束，会导致开发的时候很痛苦, 测试数据极为不方便; b. 外键的主从关系是定的，假如那天需求有变化，数据库中的这个字段根本不需要和其他表有关联的话就会增加很多麻烦。
2. 增加了额外操作
  
  数据库需要增加维护外键的工作，比如当我们做一些涉及外键字段的增，删，更新操作之后，需要触发相关操作去检查，保证数据的的一致性和正确性，这样会不得不消耗资源；（个人觉得这个不是不用外键的原因，因为即使你不使用外键，你在应用层面也还是要保证的。所以，我觉得这个影响可以忽略不计。）

jvm监控和故障处理工具总结

Mon, 19 Dec 2022 16:04:34 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

JDK 命令行工具#

这些命令在 JDK 安装目录下的 bin 目录下：

jps (JVM Process Status）: 类似 UNIX 的 ps 命令。用于查看所有 Java 进程的启动类、传入参数和 Java 虚拟机参数等信息；
jstat（JVM Statistics Monitoring Tool）: 用于收集 HotSpot 虚拟机各方面的运行数据;
jinfo (Configuration Info for Java) : Configuration Info for Java,显示虚拟机配置信息;
jmap (Memory Map for Java) : 生成堆转储快照;
jhat (JVM Heap Dump Browser) : 用于分析 heapdump 文件，它会建立一个 HTTP/HTML 服务器，让用户可以在浏览器上查看分析结果;
jstack (Stack Trace for Java) : 生成虚拟机当前时刻的线程快照，线程快照就是当前虚拟机内每一条线程正在执行的方法堆栈的集合。

jps: 查看所有 Java 进程#

jps(JVM Process Status) 命令类似 UNIX 的 ps 命令。

jvm参数

Mon, 19 Dec 2022 15:24:01 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

本文由 JavaGuide 翻译自 https://www.baeldung.com/jvm-parametersopen in new window，并对文章进行了大量的完善补充。翻译不易，如需转载请注明出处，作者： baeldungopen in new window 。

概述#

本篇文章中，将掌握最常用的JVM参数配置。下面提到了一些概念，堆、方法区、垃圾回收等。

堆内存相关#

Java 虚拟机所管理的内存中最大的一块，Java 堆是所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎 所有的对象实例以及数组都在这里分配内存。

显式指定堆内存-Xms和-Xmx#

与性能相关的最常见实践之一是根据应用程序要求初始化堆内存。
如果我们需要指定最小和最大堆大小（推荐显示指定大小）：
```
-Xms<heap size>[unit] 
-Xmx<heap size>[unit]
```
- heap size 表示要初始化内存的具体大小。
- unit 表示要初始化内存的单位。单位为***“ g”*** (GB) 、“ m”（MB）、“ k”（KB）。
举例，为JVM分配最小2GB和最大5GB的堆内存大小
```
-Xms2G -Xmx5G
```

显示新生代内存（Young Generation）#

在堆总可用内存配置完成之后，第二大影响因素是为 Young Generation 在堆内存所占的比例。默认情况下，YG 的最小大小为 1310 MB，最大大小为无限制。
两种指定 新生代内存(Young Generation) 大小的方法
1. 通过 -XX:NewSize 和 -XX:MaxNewSize
```
-XX:NewSize=<young size>[unit] 
-XX:MaxNewSize=<young size>[unit]
```
  如，为新生代分配最小256m的内存，最大1024m的内存我们的参数为：
```
-XX:NewSize=256m
-XX:MaxNewSize=1024m
```
2. 通过-Xmn<young size>[unit] 指定举例，为新生代分配256m的内存（NewSize与MaxNewSize设为一致） -Xmn256m
  
  将新对象预留在新生代，由于 Full GC 的成本远高于 Minor GC，因此尽可能将对象分配在新生代是明智的做法，实际项目中根据 GC 日志分析新生代空间大小分配是否合理，适当通过“-Xmn”命令调节新生代大小，最大限度降低新对象直接进入老年代的情况。

类文件结构

Sun, 18 Dec 2022 08:24:36 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

概述#

Java中，JVM可以理解的代码就叫做字节码（即扩展名为.class的文件），它不面向任何特定的处理器，只面向虚拟机
Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时效率极高，且由于字节码并不针对一种特定的机器。因此，Java程序无需重新编译便可在多种不通操作系统的计算机运行
Clojure（Lisp 语言的一种方言）、Groovy、Scala 等语言都是运行在 Java 虚拟机之上。下图展示了不同的语言被不同的编译器编译成.class文件最终运行在 Java 虚拟机之上。.class文件的二进制格式可以使用 WinHexopen in new window 查看。

.class文件是不同语言在Java虚拟机之间的重要桥梁，同时也是支持Java跨平台很重要的一个原因

Class文件结构总结#

根据Java虚拟机规范，Class文件通过ClassFile定义，有点类似C语言的结构体

ClassFile的结构如下：

ClassFile {
 u4 magic; //Class 文件的标志
 u2 minor_version;//Class 的小版本号
 u2 major_version;//Class 的大版本号
 u2 constant_pool_count;//常量池的数量
 cp_info constant_pool[constant_pool_count-1];//常量池
 u2 access_flags;//Class 的访问标记
 u2 this_class;//当前类
 u2 super_class;//父类
 u2 interfaces_count;//接口
 u2 interfaces[interfaces_count];//一个类可以实现多个接口
 u2 fields_count;//Class 文件的字段属性
 field_info fields[fields_count];//一个类可以有多个字段
 u2 methods_count;//Class 文件的方法数量
 method_info methods[methods_count];//一个类可以有个多个方法
 u2 attributes_count;//此类的属性表中的属性数
 attribute_info attributes[attributes_count];//属性表集合
}

类加载器详解

Sat, 17 Dec 2022 22:39:21 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

回顾一下类加载过程#

开始介绍类加载器和双亲委派模型之前，简单回顾一下类加载过程。

类加载过程：加载->连接->初始化。
连接过程又可分为三步：验证->准备->解析。

[

加载是类加载过程的第一步，主要完成下面 3 件事情：

通过全类名获取定义此类的二进制字节流
将字节流所代表的静态存储结构转换为方法区的运行时数据结构
在内存中生成一个代表该类的 Class 对象，作为方法区这些数据的访问入口

类加载器#

类加载器介绍#

类加载器从 JDK 1.0 就出现了，最初只是为了满足 Java Applet（已经被淘汰）的需要。后来，慢慢成为 Java 程序中的一个重要组成部分，赋予了 Java 类可以被动态加载到 JVM 中并执行的能力。

根据官方 API 文档的介绍：

A class loader is an object that is responsible for loading classes. The class ClassLoader is an abstract class. Given the binary name of a class, a class loader should attempt to locate or generate data that constitutes a definition for the class. A typical strategy is to transform the name into a file name and then read a “class file” of that name from a file system.

类加载过程

Fri, 16 Dec 2022 10:06:50 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

类的声明周期#

类加载过程#

Class文件，需要加载到虚拟机中之后才能运行和使用，那么虚拟机是如何加载这些Class文件呢
系统加载Class类文件需要三步：加载->连接->初始化。连接过程又分为三步：验证->准备->解析

加载#

类加载的第一步，主要完成3件事情

构造与类相关联的方法表

通过全类名获取定义此类的二进制字节流
将字节流所代表的静态存储结构，转换为方法区的运行时数据结构
在内存中生成一个该类的Class对象，作为方法区这些数据的访问入口

虚拟机规范对上面3点不具体，比较灵活

对于1 没有具体指明从哪里获取、怎样获取。可以从ZIP包读取（JAR/EAR/WAR格式的基础）、其他文件生成（JSP）等

非数组类的加载阶段（加载阶段获取类的二进制字节流的动作）是可控性最强的阶段，这一步我们可以去完成还可以自定义类加载器去控制字节流的获取方式（重写一个类加载器的**loadClass()**方法
数组类型不通过类加载器创建，它由Java虚拟机直接创建

加载阶段和连接阶段的部分内容是交叉执行的，即加载阶段尚未结束，连接阶段就可能已经开始了

验证#

验证是连接阶段的第一步，这一阶段的目的是确保 Class 文件的字节流中包含的信息符合《Java 虚拟机规范》的全部约束要求，保证这些信息被当作代码运行后不会危害虚拟机自身的安全。

验证阶段主要由四个检验阶段组成：

文件格式验证（Class 文件格式检查）
元数据验证（字节码语义检查）
字节码验证（程序语义检查）
符号引用验证（类的正确性检查）

准备#

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些内存都将在方法区中分配，注意：
1. 这时候进行内存分配的仅包括类变量（ClassVariables，即静态变量：被static关键字修饰的变量，只与类相关，因此被称为类变量），而不包括实例变量。
  
  实例变量会在对象实例化时，随着对象一块分配到Java堆中
2. 从概念上讲，类变量所使用的内存都应当在 方法区 中进行分配。不过有一点需要注意的是：JDK 7 之前，HotSpot 使用永久代来实现方法区的时候，实现是完全符合这种逻辑概念的。而在 JDK 7 及之后，HotSpot 已经把原本放在永久代的字符串常量池、静态变量等移动到堆中，这个时候类变量则会随着 **Class 对象（上面有提到，内存区生成Class对象）**一起存放在 Java 堆中
3. 这里所设置的初始值**“通常情况”下是数据类型默认的零值（如 0、0L、null、false 等**），比如我们定义了**public static int value=111** ，那么 value 变量在准备阶段的初始值就是 0 而不是 111（初始化阶段才会赋值）。特殊情况：比如给 value 变量加上了 final 关键字public static final int value=111 ，那么准备阶段 value 的值就被赋值为 111

java垃圾回收

Mon, 12 Dec 2022 15:58:48 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

前言#

当需要排查各种内存溢出问题、当垃圾收集成为系统达到更高并发的瓶颈时，我们就需要对这些**“自动化”的技术实施必要的监控和调节**

堆空间的基本结构#

Java的自动内存管理主要是针对对象内存的回收和对象内存的分配。且Java自动内存管理最核心的功能是堆内存中的对象分配和回收
Java堆是垃圾收集器管理的主要区域，因此也被称作GC堆（Garbage Collected Heap）
从垃圾回收的角度来说，由于现在收集器基本都采用分代垃圾收集算法，所以Java堆被划分为了几个不同的区域，这样我们就可以根据各个区域的特点选择合适的垃圾收集算法
JDK7版本及JDK7版本之前，堆内存被通常分为下面三部分：
1. 新生代内存（Young Generation）
2. 老生代（Old Generation）
3. 永久代（Permanent Generation）

JDK8版本之后PermGen（永久）已被Metaspace（元空间）取代，且已经不在堆里面了，元空间使用的是直接内存。

内存分配和回收原则#

对象优先在Eden区分配#

多数情况下，对象在新生代中Eden区分配。当Eden区没有足够空间进行分配时，会触发一次MinorGC 首先，先添加一下参数打印GC详情：-XX:+PrintGCDetails
```
public class GCTest {
	public static void main(String[] args) {
		byte[] allocation1, allocation2;
		allocation1 = new byte[30900*1024];//会用掉3万多K
	}
} 
```
运行后的结果（这里应该是配过xms和xmx了，即堆内存大小）如上，Eden区内存几乎被分配完全（即使程序什么都不做，新生代也会使用2000多K）

注： PSYoungGen 为 38400K ，= 33280K + 5120K （Survivor区总会有一个是空的，所以只加了一个5120K ）
假如我们再为allocation2分配内存会怎么样(不处理的话，年轻代会溢出)
```
allocation2 = new byte[900 * 1024];
```
在给allocation2分配内存之前，Eden区内存几乎已经被分配完。所以当Eden区没有足够空间进行分配时，虚拟机将发起一次MinorGC。GC期间虚拟机又发现allocation1无法存入空间，所以只好通过分配担保机制，把新生代的对象，提前转移到老年代去，老年代的空间足够存放allocation1，所以不会出现Full GC（这里可能是之前的说法，可能只是要表达老年代的GC，而不是Full GC(整堆GC) ）　　

执行MinorGC后，后面分配的对象如果能够存在Eden区的话，还是会在Eden区分配内存
执行如下代码验证：

 public class GCTest {
 
 	public static void main(String[] args) {
 		byte[] allocation1, allocation2,allocation3,allocation4,allocation5;
 		allocation1 = new byte[32000*1024];
 		allocation2 = new byte[1000*1024];
 		allocation3 = new byte[1000*1024];
 		allocation4 = new byte[1000*1024];
 		allocation5 = new byte[1000*1024];
 	}
 }

大对象直接进入老年代#

大对象就是需要连续空间的对象（字符串、数组等）
大对象直接进入老年代，主要是为了避免为大对象分配内存时，由于分配担保机制(这好像跟分配担保机制没有太大关系)带来的复制而降低效率。

假设大对象最后会晋升老年代，而新生代是基于复制算法来回收垃圾的，由两个Survivor区域配合完成复制算法，如果新生代中出现大对象且能屡次躲过GC，那这个对象就会在两个Survivor区域中来回复制，直至最后升入老年代，而大对象在内存里来回复制移动，就会消耗更多的时间。

jvm-intro

Fri, 09 Dec 2022 08:48:22 +0000

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

原文地址： https://juejin.im/post/5e1505d0f265da5d5d744050#heading-28 感谢原作者分享！！

JVM的基本介绍#

JVM，JavaVirtualMachine的缩写，虚拟出来的计算机，通过在实际的计算机上仿真模拟各类计算机功能实现
JVM类似一台小电脑，运行在windows或者linux这些真实操作系统环境下，直接和操作系统交互，与硬件不直接交互，操作系统帮我们完成和硬件交互的工作

Java文件是如何运行的#

场景假设：我们写了一个HelloWorld.java，这是一个文本文件。JVM不认识文本文件，所以需要一个编译，让其(xxx.java)成为一个JVM会读的二进制文件—> HelloWorld.class

类加载器如果JVM想要执行这个.class文件，需要将其**(这里应该指的二进制文件)装进类加载器**中，它就像一个搬运工一样，会把所有的.class文件全部搬进JVM里面
方法区

类加载器将.class文件搬过来，就是先丢到这一块上
方法区是用于存放类似于元数据信息方面的数据的，比如类信息、常量、静态变量、编译后代码…等
堆堆主要放一些存储的数据，比如对象实例、数组…等，它和方法区都同属于线程共享区域，即它们都是线程不安全的
栈

线程独享
栈是我们代码运行空间，我们编写的每一个方法都会放到栈里面运行。
名词：本地方法栈或本地方法接口，不过我们基本不会涉及这两块内容，这两底层使用C进行工作，和Java没有太大关系
程序计数器主要就是完成一个加载工作，类似于一个指针一样的，指向下一行我们需要执行的代码。和栈一样，都是线程独享的，就是每一个线程都会自己对应的一块区域而不会存在并发和多线程问题。
小总结
1. Java文件经过编译后编程.class字节码文件
2. 字节码文件通过类加载器被搬运到 JVM虚拟机中
3. 虚拟机主要的5大块：方法区、堆 都为线程共享区域，有线程安全问题；栈和本地方法栈和计数器都是独享区域，不存在线程安全问题，而JVM的调优主要就是围绕堆、栈两大块进行

简单的代码例子#

一个简单的学生类及main方法:

public class Student {
 public String name;

 public Student(String name) {
 this.name = name;
 }

 public void sayName() {
 System.out.println("student's name is : " + name);
 }
}

main方法：

public class App {
 public static void main(String[] args) {
 Student student = new Student("tellUrDream");
 student.sayName();
 }
}

★★ 执行main方法的步骤如下

memory-area

Wed, 07 Dec 2022 13:49:39 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

如果没有特殊说明，针对的都是HotSpot虚拟机

前言#

对于Java程序员，虚拟机自动管理机制，不需要像C/C++程序员为每一个new 操作去写对应的delete/free 操作，不容易出现内存泄漏 和 内存溢出问题
但由于内存控制权交给Java虚拟机，一旦出现内存泄漏和溢出方面问题，如果不了解虚拟机是怎么样使用内存，那么很难排查任务

运行时数据区域#

Java虚拟机在执行Java程序的过程中，会把它管理的内存，划分成若干个不同的数据区域

JDK1.8之前：

线程共享堆，方法区【永久代】(包括运行时常量池)
线程私有虚拟机栈、本地方法栈、程序计数器
本地内存(包括直接内存)

JDK1.8之后：
1.8之后整个永久代改名叫"元空间"，且移到了本地内存中

规范（概括）：
线程私有：程序计数器，虚拟机栈，本地方法栈

线程共享：堆，方法区，直接内存（非运行时数据区的一部分）

Java虚拟机规范对于运行时数据区域的规定是相当宽松的，以堆为例：

堆可以是连续，也可以不连续

大小可以固定，也可以运行时按需扩展

虚拟机实现者可以使用任何垃圾回收算法管理堆，设置不进行垃圾收集

程序计数器#

是一块较小内存空间，看作是当前线程所执行的字节码的行号指示器
java程序流程
字节码解释器，工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令

分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器
而且，为了线程切换后恢复到正确执行位置，每条线程需要一个独立程序计数器，各线程计数器互不影响，独立存储，我们称这类内存区域为**“线程私有”**的内存
总结，程序计数器的作用
- 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制
- 多线程情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切回来的时候能够知道该线程上次运行到哪
程序计数器是唯一一个不会出现OutOfMemoryError的内存区域，它的生命周期随线程创建而创建，线程结束而死亡

Java虚拟机栈#

Java虚拟机栈，简称"栈"，也是线程私有的，生命周期和线程相同，随线程创建而创建，线程死亡而死亡
除了Native方法调用的是通过本地方法栈实现的，其他所有的Java方法调用都是通过栈来实现的（需要和其他运行时数据区域比如程序计数器配合）
方法调用的数据需要通过栈进行传递，每一次方法调用都会有一个对应的栈帧被压入栈，每一个方法调用结束后，都会有一个栈帧被弹出。
栈由一个个栈帧组成，每个栈帧包括局部变量表、操作数栈、动态链接、方法返回地址。栈为先进后出，且只支持出栈和入栈

局部变量表：存放编译器可知的各种数据类型(boolean、byte、char、short、int、float、long、double)、对象引用(reference 类型，不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是一个指向一个代表对象的句柄或其他与此对象相关的位置)
操作数栈作为方法调用的中转站使用，用于存放方法执行过程中产生的中间计算结果。计算过程中产生的临时变量也放在操作数栈中
动态链接主要服务一个方法需要调用其他方法的场景。

在 Java 源文件被编译成字节码文件时，所有的变量和方法引用都作为符号引用（Symbilic Reference）保存在 Class 文件的常量池里。当一个方法要调用其他方法，需要将常量池中指向方法的符号引用转化为其在内存地址中的直接引用。动态链接的作用就是为了将符号引用转换为调用方法的直接引用。

completablefuture-intro

Tue, 06 Dec 2022 17:13:41 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

Java8被引入的一个非常有用的用于异步编程的类【没看】

简单介绍#

CompletableFuture同时实现了Future和CompletionStage接口

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
}

CompletableFuture 除了提供了更为好用和强大的 Future 特性之外，还提供了函数式编程的能力。

Future接口有5个方法：

boolean cancel(boolean mayInterruptIfRunning) ：尝试取消执行任务。
boolean isCancelled() ：判断任务是否被取消。
boolean isDone() ：判断任务是否已经被执行完成。
get() ：等待任务执行完成并获取运算结果。
get(long timeout, TimeUnit unit) ：多了一个超时时间。

CompletionStage<T> 接口中的方法比较多，CompoletableFuture的函数式能力就是这个接口赋予的，大量使用Java8引入的函数式编程

常见操作#

创建CompletableFuture#

两种方法：new关键字或 CompletableFuture自带的静态工厂方法 runAysnc()或supplyAsync()

通过new关键字这个方式，可以看作是将CompletableFuture当作Future来使用，如下：
我们通过创建了一个结果值类型为 RpcResponse<Object> 的 CompletableFuture，你可以把 resultFuture 看作是异步运算结果的载体
```
CompletableFuture<RpcResponse<Object>> resultFuture = new CompletableFuture<>();
```
如果后面某个时刻，得到了最终结果，可以调用complete()方法传入结果，表示resultFuture已经被完成：
```
// complete() 方法只能调用一次，后续调用将被忽略。
resultFuture.complete(rpcResponse);
```
通过isDone()检查是否完成：
```
public boolean isDone() {
 return result != null;
}
```
获取异步结果，使用get() ，调用get()方法的线程会阻塞直到CompletableFuture完成运算： rpcResponse = completableFuture.get();

ThreadLocal详解

Mon, 05 Dec 2022 17:31:52 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

本文来自一枝花算不算浪漫投稿，原文地址： https://juejin.cn/post/6844904151567040519open in new window。感谢作者!

思维导图

目录#

ThreadLocal代码演示#

简单使用

public class ThreadLocalTest {
 private List<String> messages = Lists.newArrayList();

 public static final ThreadLocal<ThreadLocalTest> holder = ThreadLocal.withInitial(ThreadLocalTest::new);

 public static void add(String message) {
 holder.get().messages.add(message);
 }

 public static List<String> clear() {
 List<String> messages = holder.get().messages;
 holder.remove();

 System.out.println("size: " + holder.get().messages.size());
 return messages;
 }

 public static void main(String[] args) {
 ThreadLocalTest.add("一枝花算不算浪漫");
 System.out.println(holder.get().messages);
 ThreadLocalTest.clear();
 }
}
/* 结果 
[一枝花算不算浪漫]
size: 0
*/

简单使用2

Atomic原子类介绍

Mon, 05 Dec 2022 09:24:36 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

文章开头先用例子介绍几种类型的api使用

package com.aqs;

import lombok.*;

import java.util.concurrent.atomic.*;

@Data
@Getter
@Setter
@AllArgsConstructor
@ToString
class User {
 private String name;
 //如果要为atomicReferenceFieldUpdater服务,必须加上volatile修饰
 public volatile Integer age;
}

public class AtomicTest {
 public static void main(String[] args) {
 System.out.println("原子更新数值---------------");
 AtomicInteger atomicInteger = new AtomicInteger();
 int i1 = atomicInteger.incrementAndGet();
 System.out.println("原子增加后为" + i1);
 System.out.println("原子更新数组---------------");

 int[] a = new int[3];
 AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(a);

 int i = atomicIntegerArray.addAndGet(1, 3);
 System.out.println("数组元素[" + 1 + "]增加后为" + i);
 System.out.println("数组为" + atomicIntegerArray);
 System.out.println("原子更新对象---------------");
 User user1 = new User("ly1", 10);
 User user2 = new User("ly2", 20);
 User user3 = new User("ly3", 30);
 AtomicReference<User> atomicReference = new AtomicReference<>(user1);
 boolean b = atomicReference.compareAndSet(user2, user3);
 System.out.println("更新" + (b ? "成功" : "失败"));
 System.out.println("引用里值为"+atomicReference.get());
 boolean b1 = atomicReference.compareAndSet(user1, user3);
 System.out.println("更新" + (b1 ? "成功" : "失败"));
 System.out.println("引用里值为"+atomicReference.get());
 System.out.println("原子更新对象属性---------------");
 User user4=new User("ly4",40);
 AtomicReferenceFieldUpdater<User, Integer> atomicReferenceFieldUpdater = AtomicReferenceFieldUpdater.newUpdater(User.class, Integer.class, "age");
 boolean b2 = atomicReferenceFieldUpdater.compareAndSet(user4, 41, 400);
 System.out.println("更新"+(b2?"成功":"失败"));
 System.out.println("引用里user4值为"+atomicReferenceFieldUpdater.get(user4));
 boolean b3 = atomicReferenceFieldUpdater.compareAndSet(user4, 40, 400);
 System.out.println("更新"+(b3?"成功":"失败"));
 System.out.println("引用里user4值为"+atomicReferenceFieldUpdater.get(user4));
 System.out.println("其他使用---------------");
 User user5=new User("ly5",50);
 User user6=new User("ly6",60);
 User user7=new User("ly7",70);
 AtomicMarkableReference<User> userAtomicMarkableReference=new AtomicMarkableReference<>(user5,true);
 boolean b4 = userAtomicMarkableReference.weakCompareAndSet(user6, user7, true, false);
 System.out.println("更新"+(b4?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicMarkableReference.getReference());
 boolean b5 = userAtomicMarkableReference.weakCompareAndSet(user5, user7, false, true);
 System.out.println("更新"+(b5?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicMarkableReference.getReference());
 boolean b6 = userAtomicMarkableReference.weakCompareAndSet(user5, user7, true, false);
 System.out.println("更新"+(b6?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicMarkableReference.getReference());
 System.out.println("AtomicStampedReference使用---------------");
 User user80=new User("ly8",80);
 User user90=new User("ly9",90);
 User user100=new User("ly10",100);
 AtomicStampedReference<User> userAtomicStampedReference=new AtomicStampedReference<>(user80,80);//版本80
 //...每次更改stamp都加1
 //这里假设中途被改成81了
 boolean b7 = userAtomicStampedReference.compareAndSet(user80, user100,81,90);
 System.out.println("更新"+(b7?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicStampedReference.getReference());
 boolean b8 = userAtomicStampedReference.compareAndSet(user80, user100,80,90);
 System.out.println("更新"+(b8?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicStampedReference.getReference());
 }
}
/*
原子更新数值---------------
原子增加后为1
原子更新数组---------------
数组元素[1]增加后为3
数组为[0, 3, 0]
原子更新对象---------------
更新失败
引用里值为User(name=ly1, age=10)
更新成功
引用里值为User(name=ly3, age=30)
原子更新对象属性---------------
更新失败
引用里user4值为40
更新成功
引用里user4值为400
其他使用---------------
更新失败
引用里值为User(name=ly5, age=50)
更新失败
引用里值为User(name=ly5, age=50)
更新成功
引用里值为User(name=ly7, age=70)
AtomicStampedReference使用---------------
更新失败
引用里值为User(name=ly8, age=80)
更新成功
引用里值为User(name=ly10, age=100)

Process finished with exit code 0

*/

原子类介绍#

在化学上，原子是构成一般物质的最小单位，化学反应中是不可分割的，Atomic指一个操作是不可中断的，即使在多个线程一起执行时，一个操作一旦开始就不会被其他线程干扰
原子类–>具有原子/原子操作特征的类
并发包java.util.concurrent 的原子类都放着java.util.concurrent.atomic中
根据操作的数据类型，可以将JUC包中的原子类分为4类（基本类型、数组类型、引用类型、对象的属性修改类型）
- 基本类型使用原子方式更新基本类型，包括AtomicInteger 整型原子类，AtomicLong 长整型原子类，AtomicBoolean 布尔型原子类

aqs详解

Wed, 30 Nov 2022 14:48:01 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

Semaphore [ˈseməfɔː(r)]

何为 AQS？AQS 原理了解吗？

CountDownLatch 和 CyclicBarrier 了解吗？两者的区别是什么？

用过 Semaphore 吗？应用场景了解吗？

……

AQS简单介绍#

AQS,AbstractQueueSyschronizer，即抽象队列同步器，这个类在java.util.concurrent.locks包下面

AQS是一个抽象类，主要用来构建锁和同步器

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
}

AQS 为构建锁和同步器提供了一些通用功能的实现，因此，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的 ReentrantLock，Semaphore，其他的诸如 ReentrantReadWriteLock，SynchronousQueue，FutureTask(jdk1.7) 等等皆是基于 AQS 的。

AQS原理#

AQS核心思想#

面试不是背题，大家一定要加入自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来

AQS 核心思想是，如果被请求的共享资源（AQS内部）空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是用 CLH 队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

CLH(Craig,Landin and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配。
[ 搜索了一下，CLH好像是人名 ] 在 CLH 同步队列中，一个节点表示一个线程，它保存着线程的引用（thread）、当前节点在队列中的状态（waitStatus）、前驱节点（prev）、后继节点（next）。
CLH队列结构

AQS（AbstractQueuedSynchronized）原理图

AQS使用一个int成员变量来表示同步状态，通过内置的线程等待队列来获取资源线程的排队工作。
state 变量由 volatile 修饰，用于展示当前临界资源的获锁情况。
```
private volatile int state;//共享变量，使用volatile修饰保证线程可见性
```
状态信息的操作

java常见并发容器

Tue, 29 Nov 2022 16:58:59 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

JDK提供的容器，大部分在java.util.concurrent包中

ConcurrentHashMap：线程安全的HashMap
CopyOnWriteArrayList：线程安全的List，在读多写少的场合性能非常好，远好于Vector
ConcurrentLinkedQueue：高效的并发队列，使用链表实现，可以看作一个线程安全的LinkedList，是一个非阻塞队列
BlockingQueue：这是一个接口，JDK内部通过链表、数组等方式实现了该接口。表示阻塞队列，非常适合用于作为数据共享的通道
ConcorrentSkipListMap：跳表的实现，是一个Map，使用跳表的数据结构进行快速查找

ConcurrentHashMap#

HashMap是线程不安全的，并发场景下要保证线程安全，可以使用Collections.synchronizedMap()方法来包装HashMap，但这是通过使用一个全局的锁来同步不同线程间的并发访问，因此会带来性能问题
建议使用ConcurrentHashMap，不论是读操作还是写操作都能保证高性能：读操作（几乎）不需要加锁，而写操作时通过锁分段(这里说的是JDK1.7？)技术，只对所操作的段加锁而不影响客户端对其他段的访问

CopyOnWriteArrayList#

//源码
public class CopyOnWriteArrayList<E>
extends Object
implements List<E>, RandomAccess, Cloneable, Serializable

在很多应用场景中，读操作可能会远远大于写操作
我们应该允许多个线程同时访问List内部数据（针对读）
与ReentrantReadWriteLock读写锁思想非常类似，即读读共享、写写互斥、读写互斥、写读互斥
不一样的是，CopyOnWriteArrayList读取时完全不需要加锁，且写入也不会阻塞读取操作，只有写入和写入之间需要同步等待。

CopyOnWriteArrayList是如何做到的#

CopyOnWriteArrayList 类的所有可变操作（add，set 等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。写完之后，再将修改完的副本替换原来的数据，这样就可以保证写操作不会影响读操作了。
从 CopyOnWriteArrayList 的名字就能看出 CopyOnWriteArrayList 是满足 CopyOnWrite 的
在计算机，如果你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存(注意，是指向，而不是重新拷贝★重要★)，原来的内存就可以被回收掉了

CopyOnWriteArrayList 读取和写入源码简单分析#

CopyOnWriteArrayList读取操作的实现 读取操作没有任何同步控制和锁操作，理由就是内部数组array不会发生修改，只会被另一个array替换，因此可以保证数据安全

 /** The array, accessed only via getArray/setArray. */
 private transient volatile Object[] array;
 public E get(int index) {
 return get(getArray(), index);
 }
 @SuppressWarnings("unchecked")
 private E get(Object[] a, int index) {
 return (E) a[index];
 }
 final Object[] getArray() {
 return array;
 }

CopyOnWriteArrayList写入操作的实现在添加集合的时候加了锁，保证同步，避免多线程写的时候会copy出多个副本

线程池最佳实践

Tue, 29 Nov 2022 11:31:20 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

线程池知识回顾#

1. 为什么要使用线程池#

池化技术的思想，主要是为了减少每次获取资源（线程资源）的消耗，提高对资源的利用率
线程池提供了一种限制和管理资源（包括执行一个任务）的方法，每个线程池还维护一些基本统计信息，例如已完成任务的数量

好处：

降低资源消耗
提高响应速度
提高线程的可管理性

2. 线程池在实际项目的使用场景#

线程池一般用于执行多个不相关联的耗时任务，没有多线程的情况下，任务顺序执行，使用了线程池的话可让多个不相关联的任务同时执行。

3. 如何使用线程池#

一般是通过 ThreadPoolExecutor 的构造函数来创建线程池，然后提交任务给线程池执行就可以了。构造函数如下：

 /**
 * 用给定的初始参数创建一个新的ThreadPoolExecutor。
 */
 public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
 int maximumPoolSize,//线程池的最大线程数
 long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间
 TimeUnit unit,//时间单位
 BlockingQueue<Runnable> workQueue,//任务队列，用来储存等待执行任务的队列
 ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可
 RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务
 ) {
 if (corePoolSize < 0 ||
 maximumPoolSize <= 0 ||
 maximumPoolSize < corePoolSize ||
 keepAliveTime < 0)
 throw new IllegalArgumentException();
 if (workQueue == null || threadFactory == null || handler == null)
 throw new NullPointerException();
 this.corePoolSize = corePoolSize;
 this.maximumPoolSize = maximumPoolSize;
 this.workQueue = workQueue;
 this.keepAliveTime = unit.toNanos(keepAliveTime);
 this.threadFactory = threadFactory;
 this.handler = handler;
 }

使用代码：

java线程池详解

Wed, 23 Nov 2022 14:40:41 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

一使用线程池的好处#

池化技术：减少每次获取资源的消耗，提高对资源的利用率
线程池提供一种限制和管理资源（包括执行一个任务）的方式，每个线程池还维护一些基本统计信息，例如已完成任务的数量
线程池的好处
- 降低资源消耗（重复利用，降低线程创建和销毁造成的消耗）
- 提高响应速度（任务到达直接执行，无需等待线程创建）
- 提高线程可管理性（避免无休止创建，使用线程池统一分配、调优、监控）

二 Executor框架#

Java5之后，通过Executor启动线程，比使用Thread的start方法更好，更易于管理，效率高，还能有助于避免this逃逸的问题

this逃逸，指的是构造函数返回之前，其他线程就持有该对象的引用，会导致调用尚未构造完全的对象
例子：

public class ThisEscape { 
 public ThisEscape() { 
 new Thread(new EscapeRunnable()).start(); 
 // ... 
 } 
 
 private class EscapeRunnable implements Runnable { 
 @Override
 public void run() { 
 // 通过ThisEscape.this就可以引用外围类对象, 但是此时外围类对象可能还没有构造完成, 即发生了外围类的this引用的逃逸 
 } 
 } 
}

处理办法 //不要在构造函数中运行线程

public class ThisEscape { 
 private Thread t; 
 public ThisEscape() { 
 t = new Thread(new EscapeRunnable()); 
 // ... 
 } 
 
 public void init() { 
 //也就是说对象没有构造完成前，不要调用ThisEscape.this即可
 t.start(); 
 } 
 
 private class EscapeRunnable implements Runnable { 
 @Override
 public void run() { 
 // 通过ThisEscape.this就可以引用外围类对象, 此时可以保证外围类对象已经构造完成 
 } 
 } 
}

Executor框架不仅包括线程池的管理，提供线程工厂、队列以及拒绝策略。

java内存模型

Mon, 21 Nov 2022 10:57:24 +0000

引用自https://github.com/Snailclimb/JavaGuide

从CPU缓存模型说起#

redis是为了解决程序处理速度和访问常规关系型数据库速度不对等的问题，CPU缓存则是为了解决CPU处理速度和内存处理速度不对等的问题

我们把内存看作外存的高速缓存，程序运行时把外存的数据复制到内存，由于内存的处理速度远高于外存，这样提高了处理速度
总结，CPU Cache缓存的是内存数据，用于解决CPU处理速度和内存不匹配的问题，内存缓存的是硬盘数据用于解决硬盘访问速度过慢的问题 CPU Cache示意图：

CPU Cache通常分为三层，分别叫L1，L2，L3 Cache 工作方式： 先复制一份数据到CPUCache中，当CPU需要用的时候就可以从CPUCache中读取数据，运算完成后，将运算得到的数据，写回MainMemory中，此时，会出现内存缓存不一致的问题，例子：执行了i++，如果两个线程同时执行，假设两个线程从CPUCach中读取的i=1，两个线程做了1++运算完之后再写回MainMemory，此时i=2 而正确结果为3
CPU为了解决内存缓存不一致问题，可以通过制定缓存一致协议（比如MESI协议）或其他手段。这个缓存一致协议，指的是在 CPU 高速缓存与主内存交互的时候需要遵守的原则和规范 操作系统，通过内存模型MemoryModel定义一系列规范来解决这个问题

Java内存模型#

指令重排序#

什么是指令重排序？ 简单来说就是系统在执行代码的时候并不一定是按照你写的代码的顺序依次执行
指令重排有下面2种
- 编译器优化重排：编译器（包括 JVM、JIT 编译器等）在不改变单线程程序语义的前提下，重新安排语句的执行顺序。
- 指令并行重排：现代处理器采用了指令级并行技术(Instruction-Level Parallelism，ILP)来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序

另外，内存系统也会有“重排序”，但又不是真正意义上的重排序。在 JMM 里表现为主存和本地内存的内容可能不一致，进而导致程序在多线程下执行可能出现问题。

即Java源代码会经历 编译器优化重排—>指令并行重排—>内存系统重排，最终编程操作系统可执行的指令序列

极其重要★：指令重排序可以保证串行语义一致，但是没有义务保证多线程间的语义也一致，所以在多线程下指令重排可能导致一些问题

编译器和处理器的指令重排序的处理方式不一样。对于编译器，通过禁止特定类型的编译器重排序的方式来禁止重排序。对于处理器，通过插入内存屏障（Memory Barrier，或有时叫做内存栅栏，Memory Fence）的方式来禁止特定类型的处理器重排序。指令并行重排和内存系统重排都属于是处理器级别的指令重排序。

内存屏障（Memory Barrier，或有时叫做内存栅栏，Memory Fence）是一种 CPU 指令，用来禁止处理器指令发生重排序（像屏障一样），从而保障指令执行的有序性。另外，为了达到屏障的效果，它也会使处理器写入、读取值之前，将主内存的值写入高速缓存，清空无效队列，从而保障变量的可见性。

JMM（JavaMemoryMode）#

什么是 JMM？为什么需要 JMM？#

一般来说，编程语言也可以直接复用操作系统层面的内存模型。不过，不同的操作系统内存模型不同。如果直接复用操作系统层面的内存模型，就可能会导致同样一套代码换了一个操作系统就无法执行了。Java 语言是跨平台的，它需要自己提供一套内存模型以屏蔽系统差异。

实际上，对于Java来说，可以把JMM看作是Java定义的并发编程相关的一组规范，除了抽象了线程和主内存之间的关系之外，还规定了从Java源代码到CPU可执行指令的转化过程要遵守哪些和并发相关的原则和规范，主要目的是为了简化多线程编程，增强程序可移植性。

为什么要遵守这些并发相关的原则和规范呢？因为在并发编程下，CPU多级缓存和指令重排这类设计会导致程序运行出问题，比如指令重排，为此JMM抽象了happens-before原则

JMM 说白了就是定义了一些规范来解决这些问题，开发者可以利用这些规范更方便地开发多线程程序。对于 Java 开发者说，你不需要了解底层原理，直接使用并发相关的一些关键字和类（比如 volatile、synchronized、各种 Lock）即可开发出并发安全的程序。

JMM 是如何抽象线程和主内存之间的关系？#

Java内存模型(JMM)，抽象了线程和主内存之间的关系，比如线程之间的共享变量必须存储在主内存中

并发03

Mon, 07 Nov 2022 16:04:33 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

线程池#

为什么要使用线程池
- 池化技术：线程池、数据库连接池、Http连接池
- 池化技术思想意义：为了减少每次获取资源的消耗，提高对资源的利用率
- 线程池提供了限制和管理资源(包括执行一个任务)的方式
- 每个线程池还维护基本统计信息，例如已完成任务的数量
- 好处：
  1. 降低资源消耗 重复利用已创建线程降低线程创建和销毁造成的消耗
  2. 提高响应速度任务到达时，任务可以不需等到线程创建就能继续执行
  3. 提高线程的可管理性 线程是稀缺资源，如果无限制创建，不仅消耗系统资源，还会降低系统的稳定性，使用线程池统一管理分配、调优和监控。

实现Runnable接口和Callable接口的区别

//Callable的用法 
public class TestLy {

 //如果加上volatile,就能保证可见性，线程1 才能停止
 boolean stop = false;//对象属性

 public static void main(String[] args) throws InterruptedException, ExecutionException {
 FutureTask<String> futureTask=new FutureTask<>(new Callable<String>() {
 @Override
 public String call() throws Exception {
 System.out.println("等3s再把结果给你");
 TimeUnit.SECONDS.sleep(3);
 return "hello world";
 }
 });
 new Thread(futureTask).start();
 String s = futureTask.get();
 System.out.println("3s后获取到了结果"+s);

 new Thread(new Runnable() {
 @Override
 public void run() {
 System.out.println("abc");
 }
 }).start();
 }
}
/*
等3s再把结果给你
3s后获取到了结果hello world
abc
*/

Runnable接口不会返回结果或抛出检查异常，Callable接口可以

锁升级

Sun, 06 Nov 2022 12:31:02 +0000

以下内容均转自 https://www.cnblogs.com/wuqinglong/p/9945618.html，部分疑惑参考自另一作者 https://github.com/farmerjohngit/myblog/issues/12 ，感谢原作者。

【目前还是存有部分疑虑（轻量级锁那块），可能需要详细看源码才能释疑】

概述#

传统的synchronized为重量级锁（使用操作系统互斥量（mutex）来实现的传统锁），但是随着JavaSE1.6对synchronized优化后，部分情况下他就没有那么重了。本文介绍了JavaSE1.6为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁，以及锁结构、及锁升级过程

实现同步的基础#

Java中每个对象都可以作为锁，具体变现形式

对于普通同步方法，锁是当前实例对象
对于静态同步方法，锁是当前类的Class对象
对于同步方法块，锁是synchronized括号里配置的对象

一个线程试图访问同步代码块时，必须获取锁；在退出或者抛出异常时，必须释放锁

实现方式#

JVM 基于进入和退出 Monitor 对象来实现方法同步和代码块同步，但是两者的实现细节不一样

代码块同步：通过使用 monitorenter 和 monitorexit 指令实现的
同步方法：ACC_SYNCHRONIZED 修饰

monitorenter 指令是在编译后插入到同步代码块的开始位置，而 monitorexit 指令是在编译后插入到同步代码块的结束处或异常处

对于同步方法，进入方法前添加一个 monitorenter 指令，退出方法后添加一个 monitorexit 指令。

demo：

public class Demo {

 public void f1() {
 synchronized (Demo.class) {
 System.out.println("Hello World.");
 }
 }

 public synchronized void f2() {
 System.out.println("Hello World.");
 }

}

编译之后的字节码（使用 javap )

public void f1();
 descriptor: ()V
 flags: ACC_PUBLIC
 Code:
 stack=2, locals=3, args_size=1
 0: ldc #2 // class me/snail/base/Demo
 2: dup
 3: astore_1
 4: monitorenter
 5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
 8: ldc #4 // String Hello World.
 10: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
 13: aload_1
 14: monitorexit
 15: goto 23
 18: astore_2
 19: aload_1
 20: monitorexit
 21: aload_2
 22: athrow
 23: return
 Exception table:
 from to target type
 5 15 18 any
 18 21 18 any
 LineNumberTable:
 line 6: 0
 line 7: 5
 line 8: 13
 line 9: 23
 StackMapTable: number_of_entries = 2
 frame_type = 255 /* full_frame */
 offset_delta = 18
 locals = [ class me/snail/base/Demo, class java/lang/Object ]
 stack = [ class java/lang/Throwable ]
 frame_type = 250 /* chop */
 offset_delta = 4

public synchronized void f2();
 descriptor: ()V
 flags: ACC_PUBLIC, ACC_SYNCHRONIZED
 Code:
 stack=2, locals=1, args_size=1
 0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
 3: ldc #4 // String Hello World.
 5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
 8: return
 LineNumberTable:
 line 12: 0
 line 13: 8

先说 f1() 方法，发现其中一个 monitorenter 对应了两个 monitorexit，这是不对的。但是仔细看 #15: goto 语句，直接跳转到了 #23: return 处，再看 #22: athrow 语句发现，原来第二个 monitorexit 是保证同步代码块抛出异常时锁能得到正确的释放而存在的，这就理解了。

(该文弃用)锁升级

Thu, 03 Nov 2022 11:08:59 +0000

本文主要讲解synchronized原理和偏向锁、轻量级锁、重量级锁的升级过程，基本都转自

https://blog.csdn.net/MariaOzawa/article/details/107665689 原作者: MariaOzawa

简介#

为什么需要锁
并发编程中，多个线程访问同一共享资源时，必须考虑如何维护数据的原子性
历史
- JDK1.5之前，Java依靠Synchronized关键字实现锁功能，Synchronized是Jvm实现的内置锁，锁的获取与释放由JVM隐式实现
- JDK1.5，并发包新增Lock接口实现锁功能，提供同步功能，使用时显式获取和释放锁
区别
- Lock同步锁基于Java实现，Synchronized基于底层操作系统的MutexLock实现 /ˈmjuːtɛks/ ，每次获取和释放锁都会带来用户态和内核态的切换，从而增加系统性能开销，性能糟糕，又称重量级锁
- JDK1.6之后，对Synchronized同步锁做了充分优化

Synchronized同步锁实现原理#

Synchronized实现同步锁的两种方式：修饰方法；修饰方法块

 // 关键字在实例方法上，锁为当前实例
 public synchronized void method1() {
 // code
 }

 // 关键字在代码块上，锁为括号里面的对象
 public void method2() {
 Object o = new Object();
 synchronized (o) {
 // code
 }
 }

这里使用编译–及javap 打印字节文件

javac -encoding UTF-8 SyncTest.java //先运行编译class文件命令

javap -v SyncTest.class //再通过javap打印出字节文件

结果如下，Synchronized修饰代码块时，由monitorenter和monitorexist指令实现同步。进入monitorenter指令后线程持有Monitor对象；退出monitorenter指令后，线程释放该Monitor对象

 public void method2();
 descriptor: ()V
 flags: ACC_PUBLIC
 Code:
 stack=2, locals=4, args_size=1
 0: new #2 
 3: dup
 4: invokespecial #1 
 7: astore_1
 8: aload_1
 9: dup
 10: astore_2
 11: monitorenter //monitorenter 指令
 12: aload_2
 13: monitorexit //monitorexit 指令
 14: goto 22
 17: astore_3
 18: aload_2
 19: monitorexit
 20: aload_3
 21: athrow
 22: return
 Exception table:
 from to target type
 12 14 17 any
 17 20 17 any
 LineNumberTable:
 line 18: 0
 line 19: 8
 line 21: 12
 line 22: 22
 StackMapTable: number_of_entries = 2
 frame_type = 255 /* full_frame */
 offset_delta = 17
 locals = [ class com/demo/io/SyncTest, class java/lang/Object, class java/lang/Object ]
 stack = [ class java/lang/Throwable ]
 frame_type = 250 /* chop */
 offset_delta = 4

如果Synchronized修饰同步方法，代替monitorenter和monitorexit的是 ACC_SYNCHRONIZED标志，即：JVM使用该访问标志区分方法是否为同步方法。方法调用时，调用指令检查是否设置ACC_SYNCHRONIZED标志，如有，则执行线程先持有该Monitor对象，再执行该方法；运行期间，其他线程无法获取到该Monitor对象；方法执行完成后，释放该Monitor对象 javap -v xx.class 字节文件查看

(该文弃用)锁升级

Mon, 31 Oct 2022 11:08:59 +0000

简介#

无锁 => 偏向锁 => 轻量锁 => 重量锁

复习Class类锁和实例对象锁，说明Class类锁和实例对象锁不是同一把锁，互相不影响

public static void main(String[] args) throws InterruptedException { 
 Object object=new Object();
 new Thread(()->{
 synchronized (Customer.class){
 System.out.println(Thread.currentThread().getName()+"Object.class类锁");
 try {
 TimeUnit.SECONDS.sleep(5);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.println(Thread.currentThread().getName()+"结束并释放锁");
 },"线程1").start();
 //保证线程1已经获得类锁
 try {
 TimeUnit.SECONDS.sleep(2);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 new Thread(()->{
 synchronized (object){
 System.out.println(Thread.currentThread().getName()+"获得object实例对象锁");
 }
 System.out.println(Thread.currentThread().getName()+"结束并释放锁");
 },"线程2").start();

 }

/* 输出
线程1Object.class类锁
线程2获得object实例对象锁
线程2结束并释放锁
线程1结束并释放锁
*/

总结图 , 00 , 01 , 10 ，没有11

对象内存布局和对象头

Sun, 30 Oct 2022 16:56:16 +0000

对象布局#

heap （where）: new (eden ,s0 ,s1) ,old, metaspace
对象的构成元素（what） HotSpot虚拟机里，对象在堆内存中的存储布局分为三个部分
- 对象头（Header）
  - 对象标记 MarkWord
  - 类元信息（类型指针 Class Pointer，指向方法区的地址）
  - 对象头多大 length（数组才有）
- 实例数据（Instance Data）
- 对其填充（Padding，保证整个对象大小，是8个字节的倍数）

对象头#

对象标记
1. Object o= new Object(); //new一个对象，占内存多少
2. o.hashCode() //hashCode存在对象哪个地方
3. synchronized(o){ } //对象被锁了多少次（可重入锁）
4. System.gc(); //躲过了几次gc（次数）
上面这些，哈希码、gc标记、gc次数、同步锁标记、偏向锁持有者，都保存在对象标记里面
1. 如果在64位系统中，对象头中，**mark word（对象标记）**占用8个字节（64位）；**class pointer（类元信息）**占用8个字节，总共16字节（忽略压缩指针）
2. 无锁的时候，
类型指针注意下图，指向方法区中（模板）的地址

实例数据和对齐填充#

实例数据
用来存放类的属性（Filed）数据信息，包括父类的属性信息
对齐填充
填充到长度为8字节，因为虚拟机要求对象起始地址必须是8字节的整数倍（对齐填充不一定存在）

示例

class Customer{
 int id;//4字节
 boolean flag=false; //1字节
}
//Customer customer=new Customer();
//该对象大小：对象头（对象标记8+类型指针8）+实例数据（4+1）=21字节 ===> 为了对齐填充，则为24字节

源码查看#

具体的（64位虚拟机为主）#

并发02

Fri, 28 Oct 2022 14:15:06 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

JMM（JavaMemoryModel)#

详见-知识点

volatile关键字#

保证变量可见性

使用volatile关键字保证变量可见性，如果将变量声明为volatile则指示JVM该变量是共享且不稳定的，每次使用它都到主存中读取

volatile关键字并非Java语言特有，在C语言里也有，它最原始的意义就是禁用CPU缓存。
volatile关键字只能保证数据可见性，不能保证数据原子性。synchronized关键字两者都能保证

不可见的例子

package com.concurrent; 
import java.util.concurrent.TimeUnit;

public class TestLy {

 //如果加上volatile,就能保证可见性，线程1 才能停止
 boolean stop = false;//对象属性

 public static void main(String[] args) throws InterruptedException {
 TestLy atomicTest = new TestLy();
 new Thread(() -> {
 while (!atomicTest.stop) {
 //这里不能加System.out.println ,因为这个方法内部用了synchronized修饰,会导致获取主内存的值，
 //就没法展示效果了
 /*System.out.println("1还没有停止");*/
 }
 System.out.println(Thread.currentThread().getName()+"停止了");
 },"线程1").start();

 new Thread(() -> {
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 atomicTest.stop= true;
 System.out.println(Thread.currentThread().getName()+"让线程1停止");
 },"线程2").start();
 while (true){}
 }


}

如何禁止指令重排使用volatile关键字，除了可以保证变量的可见性，还能防止JVM指令重排。当我们对这个变量进行读写操作的时候，-会通过插入特定的内存屏障来禁止指令重排

并发01

Wed, 26 Oct 2022 16:46:32 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

什么是进程和线程

进程：是程序的一次执行过程，是系统运行程序的基本单位 系统运行一个程序，即一个进程从创建、运行到消亡的过程
- 启动main函数则启动了一个JVM进程，main函数所在线程为进程中的一个线程，也称主线程
- 以下为一个个的进程
  - 查看java进程
```
jps -l
32 org.jetbrains.jps.cmdline.Launcher
10084
16244 com.Test
17400 sun.tools.jps.Jps
```
  - 杀死进程
```
 taskkill /f /pid 16244
```

何为线程

线程，比进程更小的执行单位
同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈、本地方法栈，又被称为轻量级进程

Java天生就是多线程程序，如：

public class MultiThread {
	public static void main(String[] args) {
		// 获取 Java 线程管理 MXBean
	ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
		// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
		ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
		// 遍历线程信息，仅打印线程 ID 和线程名称信息
		for (ThreadInfo threadInfo : threadInfos) {
			System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
		}
	}
}
//输出
[5] Attach Listener //添加事件
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
[3] Finalizer //调用对象 finalize 方法的线程
[2] Reference Handler //清除 reference 线程
[1] main //main 线程,程序入口

也就是说，一个Java程序的运行，是main线程和多个其他线程同时运行

io模型

Wed, 26 Oct 2022 14:17:58 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

https://zhuanlan.zhihu.com/p/360878783 IO多路复用讲解，这是一个与系统底层有关的知识点，需要一些操作系统调用代码才知道IO多路复用省的时间。

I/O#

何为I/O#

I/O(Input/Output)，即输入/输出 从计算机结构的角度来解读一下I/O，根据冯诺依曼结构，计算机结构分为5大部分：运算器、控制器、存储器、输入设备、输出设备 其中，输入设备：键盘；输出设备：显示器网卡、硬盘既属于输入设备也属于输出设备
输入设备向计算机输入（内存）数据，输出设备接收计算机（内存）输出的数据，即I/O描述了计算机系统与外部设备之间通信的过程
从应用程序的角度解读I/O
- 为了保证系统稳定性和安全性，一个进程的地址空间划分为用户空间User space和内核空间Kernel space kernel 英[ˈkɜːnl]
- 平常运行的应用程序都运行在用户空间，只有内核空间才能进行系统态级别的资源有关操作—文件管理、进程通信、内存管理
- 如果要进行IO操作，就得依赖内核空间的能力，用户空间的程序不能直接访问内核空间
- 用户进程要想执行IO操作，必须通过系统调用来间接访问内核空间
对于磁盘IO（读写文件）和网络IO（网络请求和响应），从应用程序视角来看，应用程序对操作系统的内核发起IO调用（系统调用），操作系统负责的内核执行具体IO操作
- 应用程序只是发起了IO操作调用，而具体的IO执行则由操作系统内核完成
应用程序发起I/O后，经历两个步骤
- 内核等待I/O设备准备好数据
- 内核将数据从内核空间拷贝到用户空间

有哪些常见的IO模型#

UNIX系统下，包括5种：同步阻塞I/O，同步非阻塞I/O，I/O多路复用、信号驱动I/O和异步I/O

Java中3中常见I/O模型#

BIO (Blocking I/O )#

应用程序发起read调用后，会一直阻塞，直到内核把数据拷贝到用户空间

NIO (Non-blocking/New I/O)#

对于java.nio包，提供了Channel、Selector、Buffer等抽象概念，对于高负载高并发，应使用NIO
NIO是I/O多路复用模型，属于同步非阻塞IO模型
- 一般的同步非阻塞 IO 模型中，应用程序会一直发起 read 调用。
  等待数据从内核空间拷贝到用户空间的这段时间里，线程依然是阻塞的**，**直到在内核把数据拷贝到用户空间。
  
  相比于同步阻塞 IO 模型，同步非阻塞 IO 模型确实有了很大改进。通过轮询操作，避免了一直阻塞。
  
  但是，这种 IO 模型同样存在问题：应用程序不断进行 I/O 系统调用轮询数据是否已经准备好的过程是十分消耗 CPU 资源的。
  
  ★★ 也就是说，【准备数据，数据就绪】是不阻塞的。而【拷贝数据】是阻塞的
- I/O多路复用线程首先发起select调用，询问内核数据是否准备就绪，等准备好了，用户线程再发起read调用，r**ead调用的过程（数据从内核空间–>用户空间）**还是阻塞的
  
  IO 多路复用模型，通过减少无效的系统调用，减少了对 CPU 资源的消耗。

io设计模式

Mon, 24 Oct 2022 23:40:53 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

装饰器模式#

类图：

装饰器，Decorator，装饰器模式可以在不改变原有对象的情况下拓展其功能
★装饰器模式，通过组合替代继承来扩展原始类功能，在一些继承关系较复杂的场景（IO这一场景各种类的继承关系就比较复杂）下更加实用
对于字节流，FilterInputStream（对应输入流）和FilterOutputStream（对应输出流）是装饰器模式的核心，分别用于增强（继承了）InputStream和OutputStream子类对象的功能 Filter （过滤的意思），中间（Closeable）下面这两条虚线代表实现；最下面的实线代表继承
其中BufferedInputStream（字节缓冲输入流）、DataInputStream等等都是FilterInputStream的子类，对应的BufferedOutputStream和DataOutputStream都是FilterOutputStream的子类

例子，使用BufferedInputStream（字节缓冲输入流）来增强FileInputStream功能

BufferedInputStream源码（构造函数）

private static int DEFAULT_BUFFER_SIZE = 8192;
public BufferedInputStream(InputStream in) {
 this(in, DEFAULT_BUFFER_SIZE);
}

public BufferedInputStream(InputStream in, int size) {
 super(in);
 if (size <= 0) {
 throw new IllegalArgumentException("Buffer size <= 0");
 }
 buf = new byte[size];
}

使用

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"))) {
 int content;
 long skip = bis.skip(2);
 while ((content = bis.read()) != -1) {
 System.out.print((char) content);
 }
} catch (IOException e) {
 e.printStackTrace();
}

ZipInputStream和ZipOutputStream还可以用来增强BufferedInputStream和BufferedOutputStream的能力

io基础

Sun, 23 Oct 2022 12:21:12 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

简介#

IO，即Input/Output，输入和输出，输入就是数据输入到计算机内存；输出则是输出到外部存储（如数据库、文件、远程主机）
根据数据处理方式，又分为字节流和字符流
基类
- 字节输入流 InputStream，字符输入流 Reader
- 字节输出流 OutputStream, 字符输出流 Writer

字节流#

字节输入流 InputStream InputStream用于从源头（通常是文件）读取数据（字节信息）到内存中，java.io.InputStream抽象类是所有字节输入流的父类
- 常用方法
  - read() ：返回输入流中下一个字节的数据。返回的值介于 0 到 255 之间。如果未读取任何字节，则代码返回 -1 ，表示文件结束。
  - read(byte b[ ]) : 从输入流中读取一些字节存储到数组 b 中。如果数组 b 的长度为零，则不读取。如果没有可用字节读取，返回 -1。如果有可用字节读取，则最多读取的字节数最多等于 b.length ，返回读取的字节数。这个方法等价于 read(b, 0, b.length)。
  - read(byte b[], int off, int len) ：在read(byte b[ ]) 方法的基础上增加了 off 参数（偏移量）和 len 参数（要读取的最大字节数）。
  - skip(long n) ：忽略输入流中的 n 个字节 ,返回实际忽略的字节数。
  - available() ：返回输入流中可以读取的字节数。
  - close() ：关闭输入流释放相关的系统资源。
- Java9 新增了多个实用方法

ConcurrentHashMap源码

Sat, 22 Oct 2022 18:26:52 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

总结#

Java7 中 ConcurrentHashMap 使用的分段锁，也就是每一个 Segment 上同时只有一个线程可以操作，每一个 Segment 都是一个类似 HashMap 数组的结构，每一个HashMap可以扩容，它的冲突会转化为链表。但是 Segment 的个数一但初始化就不能改变。

Java8 中的 ConcurrentHashMap 使用的 Synchronized 锁加 CAS 的机制。结构也由 Java7 中的 Segment 数组 + HashEntry 数组 + 链表 进化成了 Node 数组 + 链表 / 红黑树，Node 是类似于一个 HashEntry 的结构。它的冲突再达到一定大小时会转化成红黑树，在冲突小于一定数量时又退回链表。

源码（略过）#

ConcurrentHashMap1.7#

存储结构
- Segment数组（该数组用来加锁，每个数组元素是一个HashEntry数组（该数组可能包含链表）
- 如图，ConcurrentHashMap由多个Segment组合，每一个Segment是一个类似HashMap的结构，每一个HashMap内部可以扩容，但是Segment个数初始化后不能改变，默认16个（即默认支持16个线程并发）

ConcurrentHashMap1.8#

存储结构可以发现 Java8 的 ConcurrentHashMap 相对于 Java7 来说变化比较大，不再是之前的 Segment 数组 + HashEntry 数组 + 链表，而是 Node 数组 + 链表 / 红黑树。当冲突链表达到一定长度时，链表会转换成红黑树。

HashMap源码

Fri, 21 Oct 2022 15:30:09 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

HashMap简介#

HashMap用来存放键值对，基于哈希表的Map接口实现，是非线程安全的
可以存储null的key和value，但null作为键只能有一个
JDK8之前，HashMap由数组和链表组成，链表是为了解决哈希冲突而存在；JDK8之后，当链表大于阈值（默认8），则会选择转为红黑树（当数组长度大于64则进行转换，否则只是扩容），以减少搜索时间
HashMap默认初始化大小为16，每次扩容为原容量2倍，且总是使用2的幂作为哈希表的大小

底层数据结构分析#

JDK8之前，HashMap底层是数组和链表，即链表散列；通过key的hashCode，经过扰动函数，获得hash值，然后再通过(n-1) & hash 判断当前元素存放位置（n指的是数组长度），如果当前位置存在元素，就判断元素与要存入的元素的hash值以及key是否相同，相同则覆盖，否则通过拉链法解决

扰动函数，即hash(Object key)方法

//JDK1.8 
static final int hash(Object key) {
 int h;
 // key.hashCode()：返回散列值也就是hashcode
 // ^ ：按位异或
 // >>>:无符号右移，忽略符号位，空位都以0补齐
 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }

JDK1.7

//JDK1.7 , 则扰动了4次，性能较差
static int hash(int h) {
 // This function ensures that hashCodes that differ only by
 // constant multiples at each bit position have a bounded
 // number of collisions (approximately 8 at default load factor).

 h ^= (h >>> 20) ^ (h >>> 12);
 return h ^ (h >>> 7) ^ (h >>> 4);
}

JDK1.8之后，当链表长度大于阈值（默认为 8）时，会首先调用 treeifyBin()方法。这个方法会根据 HashMap 数组来决定是否转换为红黑树。只有当数组长度大于或者等于 64 的情况下，才会执行转换红黑树操作，以减少搜索时间。否则，就是只是执行 resize() 方法对数组扩容。相关源码这里就不贴了，重点关注 treeifyBin()方法即可！

ArrayList源码

Thu, 20 Oct 2022 17:01:47 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

简介#

底层是数组队列，相当于动态数组，能动态增长，可以在添加大量元素前先使用ensureCapacity来增加ArrayList容量，减少递增式再分配的数量 源码：
```
public class ArrayList<E> extends AbstractList<E>
 implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ }
```
1. Random Access，标志接口，表明这个接口的List集合支持快速随机访问，这里是指可通过元素序号快速访问
2. 实现Cloneable接口，能被克隆
3. 实现java.io.Serializable，支持序列化
ArrayList和Vector区别
- ArrayList和Vector都是List的实现类，Vector出现的比较早，底层都是Object[] 存储
- ArrayList线程不安全（适合频繁查找，线程不安全）
- Vector 线程安全的
ArrayList与LinkedList区别
- 都是不同步的，即不保证线程安全
- ArrayList底层为Object数组；LinkedList底层使用双向链表数据结构(1.6之前为循环链表，1.7取消了循环)
- 插入和删除是否受元素位置影响
  - ArrayList采用数组存储，所以插入和删除元素的时间复杂度受元素位置影响[ 默认增加到末尾，O(1) ; 在指定位置，则O(n) , 要往后移动]
  - LinkedList采用链表存储，所以对于add(E e)方法，还是O(1)；如果是在指定位置插入和删除，则为O(n) 因为需要遍历将指针移动到指定位置
```
//LinkedList默认添加到最后
public boolean add(E e) {
 linkLast(e);
 return true;
}
```
  - LinkedList不支持高效随机元素访问，而ArrayList支持（通过get(int index))
  - 内存空间占用 ArrayList的空间浪费主要体现在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费在，每个元素都需要比ArrayList更多空间（要存放直接前驱和直接后继以及(当前)数据)

3. 扩容机制分析 ( JDK8 )#

ArrayList的构造函数

三种方式初始化，构造方法源码
空参，指定大小，指定集合（如果集合类型非Object[].class，则使用Arrays.copyOf转为Object[].class)
以无参构造方式创建ArrayList时，实际上初始化赋值的是空数组；当真正操作时才分配容量，即添加第一个元素时扩容为10


 /**
 * 默认初始容量大小
 */
 private static final int DEFAULT_CAPACITY = 10;


 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

 /**
 *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
 */
 public ArrayList() {
 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 }

 /**
 * 带初始容量参数的构造函数。（用户自己指定容量）
 */
 public ArrayList(int initialCapacity) {
 if (initialCapacity > 0) {//初始容量大于0
 //创建initialCapacity大小的数组
 this.elementData = new Object[initialCapacity];
 } else if (initialCapacity == 0) {//初始容量等于0
 //创建空数组
 this.elementData = EMPTY_ELEMENTDATA;
 } else {//初始容量小于0，抛出异常
 throw new IllegalArgumentException("Illegal Capacity: "+
 initialCapacity);
 }
 }


 /**
 *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
 *如果指定的集合为null，throws NullPointerException。
 */
 public ArrayList(Collection<? extends E> c) {
 elementData = c.toArray();
 if ((size = elementData.length) != 0) {
 // c.toArray might (incorrectly) not return Object[] (see 6260652)
 if (elementData.getClass() != Object[].class)
 elementData = Arrays.copyOf(elementData, size, Object[].class);
 } else {
 // replace with empty array.
 this.elementData = EMPTY_ELEMENTDATA;
 }
 }

以无参构造参数函数为例 先看下面的 add()方法扩容

集合使用注意事项

Wed, 19 Oct 2022 17:26:07 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

集合判空#

//阿里巴巴开发手册

判断所有集合内部的元素是否为空，使用 isEmpty() 方法，而不是 size()==0 的方式。

isEmpty()可读性更好，且绝大部分情况下时间复杂度为O(1)

有例外：ConcurrentHashMap的size()和isEmpty() 时间复杂度均不是O(1)

public int size() {
 long n = sumCount();
 return ((n < 0L) ? 0 :
 (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
 (int)n);
}
final long sumCount() {
 CounterCell[] as = counterCells; CounterCell a;
 long sum = baseCount;
 if (as != null) {
 for (int i = 0; i < as.length; ++i) {
 if ((a = as[i]) != null)
 sum += a.value;
 }
 }
 return sum;
}
public boolean isEmpty() {
 return sumCount() <= 0L; // ignore transient negative values
}

集合转Map#

//阿里巴巴开发手册

集合_2

Tue, 18 Oct 2022 08:54:49 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

Map#

HashMap和Hashtable的区别
- HashMap是非线程安全的，Hashtable是线程安全的，因为Hashtable内部方法都经过synchronized修饰（不过要保证线程安全一般用ConcurrentHashMap）
- 由于加了synchronized修饰，HashTable效率没有HashMap高
- HashMap可以存储null的key和value，但null作为键只能有一个**；HashTable不允许有null键和null值**
- 初始容量及每次扩容
  - Hashtable默认初始大小11，之后扩容为2n+1;HashMap初始大小16，之后扩容变为原来的2倍
  - 如果指定初始大小，HashTable直接使用初始大小
    而HashMap 会将其扩充为 2 的幂次方大小（HashMap 中的**tableSizeFor()**方法保证，下面给出了源代码）。也就是说 HashMap 总是使用 2 的幂作为哈希表的大小,后面会介绍到为什么是 2 的幂次方
- 底层数据结构
  - JDK1.8之后HashMap解决哈希冲突时，当链表大于阈值（默认8）时，将链表转为红黑树（转换前判断，如果当前数组长度小于64，则先进行数组扩容，而不转成红黑树），以减少搜索时间。
  - Hashtable没有上面的机制
```
/**
HashMap 中带有初始容量的构造函数：
*/
public HashMap(int initialCapacity, float loadFactor) {
 if (initialCapacity < 0)
 throw new IllegalArgumentException("Illegal initial capacity: " +
 initialCapacity);
 if (initialCapacity > MAXIMUM_CAPACITY)
 initialCapacity = MAXIMUM_CAPACITY;
 if (loadFactor <= 0 || Float.isNaN(loadFactor))
 throw new IllegalArgumentException("Illegal load factor: " +
 loadFactor);
 this.loadFactor = loadFactor;
 this.threshold = tableSizeFor(initialCapacity);
 }
 public HashMap(int initialCapacity) {
 this(initialCapacity, DEFAULT_LOAD_FACTOR);
 } 

/*下面这个方法保证了 HashMap 总是使用 2 的幂作为哈希表的大小。*/
/**
 * Returns a power of two size for the given target capacity.
 */
 static final int tableSizeFor(int cap) {
 int n = cap - 1;
 n |= n >>> 1;
 n |= n >>> 2;
 n |= n >>> 4;
 n |= n >>> 8;
 n |= n >>> 16;
 return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
 } 
```
HashMap和hashSet区别

集合_1

Mon, 17 Oct 2022 08:55:24 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

集合包括`Collection`和`Map`，Collection 存放单一元素。Map 存放键值对#

List，Set，Queue，Map区别#

List(对付顺序的好帮手): 存储的元素是有序的、可重复的。
Set(注重独一无二的性质): 存储的元素是无序的、不可重复的。
Queue(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序，存储的元素是有序的、可重复的。
Map(用 key 来搜索的专家): 使用键值对（key-value）存储，类似于数学上的函数 y=f(x)，“x” 代表 key，“y” 代表 value，key 是无序的、不可重复的，value 是无序的、可重复的，每个键最多映射到一个值。

各种集合框架–底层数据结构#

List
- ArrayList、Vector —-> Object[] 数组
- LinkedList 双向链表 (jdk 1.6 之前为循环链表, 1.7 取消了循环)
Set
- HashSet （无序，唯一），且基于HashMap
- LinkedHashSet 是HashSet的子类，基于LinkedHashMap (LinkedHashMap内部基于HashMap实现)
- TreeSet(有序，唯一) ：红黑树（自平衡的排序二叉树）
Queue (队列)
- PriorityQueue：Object[] 数组来实现二叉堆
- ArrayQueue：Object[] 数组+ 双指针
Map
- HashMap： JDK1.8 之前 HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间
- LinkedHashMap： LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。

语法糖

Wed, 12 Oct 2022 17:36:26 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

简介#

语法糖（Syntactic Sugar）也称糖衣语法，指的是在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用，简而言之，让程序更加简洁，有更高的可读性

Java中有哪些语法糖#

Java虚拟机并不支持这些语法糖，这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖

javac命令可以将后缀为.java的源文件编译为后缀名为.class的可以运行于Java虚拟机的字节码。其中，com.sun.tools.javac.main.JavaCompiler的源码中，compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的
Java中的语法糖，包括泛型、变长参数、条件编译、自动拆装箱、内部类等

switch支持String与枚举#

switch本身原本只支持基本类型，如int、char

int是比较数值，而char则是比较其ascii码，所以其实对于编译器来说，都是int类型(整型)，比如byte。short，char(ackii 码是整型)以及int。

而对于enum类型，

对于switch中使用String，则：

public class switchDemoString {
 public static void main(String[] args) {
 String str = "world";
 switch (str) {
 case "hello":
 System.out.println("hello");
 break;
 case "world":
 System.out.println("world");
 break;
 default:
 break;
 }
 }
}
//反编译之后
public class switchDemoString
{
 public switchDemoString()
 {
 }
 public static void main(String args[])
 {
 String str = "world";
 String s;
 switch((s = str).hashCode())
 {
 default:
 break;
 case 99162322:
 if(s.equals("hello"))
 System.out.println("hello");
 break;
 case 113318802:
 if(s.equals("world"))
 System.out.println("world");
 break;
 }
 }
}

即switch判断是通过**equals()和hashCode()**方法来实现的

java_spi

Wed, 12 Oct 2022 10:12:52 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

简介#

为了实现在模块装配的时候不用再程序里面动态指明，这就需要一种服务发现机制。JavaSPI就是提供了这样的一个机制：为某个接口寻找服务实现的机制。有点类似IoC的思想，将装配的控制权交到了程序之外

SPI介绍#

SPI，ServiceProviderInterface 使用SPI：Spring框架、数据库加载驱动、日志接口、以及Dubbo的扩展实现

感觉下面这个图不太对，被调用方应该一般模块之间都是通过接口进行通讯，

当实现方提供了接口和实现，我们可以通过调用实现方的接口从而拥有实现方给我们提供的能力，这就是 API ，这种接口和实现都是放在实现方的。

当接口存在于调用方这边时，就是 SPI ，由接口调用方确定接口规则，然后由不同的厂商去根据这个规则对这个接口进行实现，从而提供服务。[可以理解成业务方，或者说使用方。它使用了这个接口，而且制定了接口规范，但是具体实现，由被调用方实现]

我的理解：被调用方（提供接口的人），调用方（使用接口的人），但是其实这里只把调用方–>使用接口的人这个关系是对的。

也就是说，正常情况下由被调用方自己提供接口和实现，即API。而现在，由调用方（这里的调用方其实可以理解成上面的被调用方），提供了接口还使用了接口，而由被调用方进行接口实现

实战演示#

SLF4J只是一个日志门面（接口），但是SLF4J的具体实现可以有多种，如：Logback/Log4j/Log4j2等等

简易版本#

ServiceProviderInterface

目录结构

│ service-provider-interface.iml
│
├─.idea
│ │ .gitignore
│ │ misc.xml
│ │ modules.xml
│ └─ workspace.xml
│
└─src
 └─edu
 └─jiangxuan
 └─up
 └─spi
 Logger.java
 LoggerService.java
 Main.class

Logger接口，即SPI 服务提供者接口，后面的服务提供者要针对这个接口进行实现

package edu.jiangxuan.up.spi;

public interface Logger {
 void info(String msg);
 void debug(String msg);
}

LoggerService类，主要是为服务使用者（调用方）提供特定功能，这个类是实现JavaSPI机制的关键所在

package edu.jiangxuan.up.spi;

import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;

public class LoggerService {
 private static final LoggerService SERVICE = new LoggerService();

 private final Logger logger;

 private final List<Logger> loggerList;

 private LoggerService() {
 ServiceLoader<Logger> loader = ServiceLoader.load(Logger.class);
 List<Logger> list = new ArrayList<>();
 for (Logger log : loader) {
 list.add(log);
 }
 // LoggerList 是所有 ServiceProvider
 loggerList = list;
 if (!list.isEmpty()) {
 // Logger 只取一个
 logger = list.get(0);
 } else {
 logger = null;
 }
 }

 //简单单例
 public static LoggerService getService() {
 return SERVICE;
 }

 public void info(String msg) {
 if (logger == null) {
 System.out.println("info 中没有发现 Logger 服务提供者");
 } else {
 logger.info(msg);
 }
 }

 public void debug(String msg) {
 if (loggerList.isEmpty()) {
 System.out.println("debug 中没有发现 Logger 服务提供者");
 }
 loggerList.forEach(log -> log.debug(msg));
 }
}

Main类（服务使用者，调用方）

unsafe类

Mon, 10 Oct 2022 17:10:27 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

sun.misc.Unsafe

提供执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，效率快，但由于有了操作内存空间的能力，会增加指针问题风险。且这些功能的实现依赖于本地方法，Java代码中只是声明方法头，具体实现规则交给本地代码

为什么要使用本地方法#

需要用到Java中不具备的依赖于操作系统的特性，跨平台的同时要实现对底层控制
对于其他语言已经完成的现成功能，可以使用Java调用
对时间敏感/性能要求非常高，有必要使用更为底层的语言

对于同一本地方法，不同的操作系统可能通过不同的方式来实现的

Unsafe创建#

sun.misc.Unsafe部分源码

public final class Unsafe {
 // 单例对象
 private static final Unsafe theUnsafe;
 ......
 private Unsafe() {
 }
 
 //Sensitive : 敏感的 英[ˈsensətɪv]
 @CallerSensitive
 public static Unsafe getUnsafe() {
 Class var0 = Reflection.getCallerClass();
 // 仅在引导类加载器`BootstrapClassLoader`加载时才合法
 if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
 throw new SecurityException("Unsafe");
 } else {
 return theUnsafe;
 }
 }
}

会先判断当前类是否由Bootstrap classloader加载。即只有启动类加载器加载的类才能够调用Unsafe类中的方法

如何使用Unsafe这个类

利用反射获得Unsafe类中已经实例化完成的单例对象theUnsafe

private static Unsafe reflectGetUnsafe() {
 try {
 Field field = Unsafe.class.getDeclaredField("theUnsafe");
 field.setAccessible(true);
 return (Unsafe) field.get(null);
 } catch (Exception e) {
 log.error(e.getMessage(), e);
 return null;
 }
}

通过Java命令行命令-Xbootclasspath/a把调用Unsafe相关方法的类A所在jar包路径追加到默认的bootstrap路径中，使得A被引导类加载器加载

big_decimal

Mon, 10 Oct 2022 14:56:26 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

精度的丢失#

float a = 2.0f - 1.9f;
float b = 1.8f - 1.7f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999905
System.out.println(a == b);// false

为什么会有精度丢失的风险

这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示

使用BigDecimal来定义浮点数的值，然后再进行浮点数的运算操作即可

BigDecimal常见方法#

我们在使用 BigDecimal 时，为了防止精度丢失，推荐使用它的BigDecimal(String val)构造方法或者 BigDecimal.valueOf(double val) 静态方法来创建对象

加减乘除

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
System.out.println(a.add(b));// 1.9
System.out.println(a.subtract(b));// 0.1
System.out.println(a.multiply(b));// 0.90
System.out.println(a.divide(b));// 无法除尽，抛出 ArithmeticException 异常
System.out.println(a.divide(b, 2, RoundingMode.HALF_UP));// 1.11

使用divide方法的时候，尽量使用3个参数版本（roundingMode.oldMode)

保留规则

public enum RoundingMode {
 // 2.5 -> 3 , 1.6 -> 2
 // -1.6 -> -2 , -2.5 -> -3
			 UP(BigDecimal.ROUND_UP), //数轴上靠近哪个取哪个
 // 2.5 -> 2 , 1.6 -> 1
 // -1.6 -> -1 , -2.5 -> -2
			 DOWN(BigDecimal.ROUND_DOWN), //数轴上离哪个远取哪个
			 // 2.5 -> 3 , 1.6 -> 2
 // -1.6 -> -1 , -2.5 -> -2
			 CEILING(BigDecimal.ROUND_CEILING),
			 // 2.5 -> 2 , 1.6 -> 1
 // -1.6 -> -2 , -2.5 -> -3
			 FLOOR(BigDecimal.ROUND_FLOOR), ////数轴上 正数：远离哪个取哪个 负数：靠近哪个取哪个
 	// 2.5 -> 3 , 1.6 -> 2
 // -1.6 -> -2 , -2.5 -> -3
			 HALF_UP(BigDecimal.ROUND_HALF_UP),// 数轴上 正数：靠近哪个取哪个 负数：远离哪个取哪个
 //......
}

大小比较
使用compareTo

Java代理模式

Mon, 10 Oct 2022 14:30:02 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

代理模式#

使用代理对象来代替对真实对象的访问，就可以在不修改原目标对象的前提下提供额外的功能操作，扩展目标对象的功能，即在目标对象的某个方法执行前后可以增加一些自定义的操作

静态代理#

静态代理中，我们对目标对象的每个方法的增强都是手动完成的（*后面会具体演示代码*），非常不灵活（*比如接口一旦新增加方法，目标对象和代理对象都要进行修改*）且麻烦(*需要对每个目标类都单独写一个代理类*）。实际应用场景非常非常少，日常开发几乎看不到使用静态代理的场景。

上面我们是从实现和应用角度来说的静态代理，从 JVM 层面来说， 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

定义一个接口及其实现类；
创建一个代理类同样实现这个接口
将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

代码:

//定义发送短信的接口
public interface SmsService {
 String send(String message);
}
//实现发送短信的接口
public class SmsServiceImpl implements SmsService {
 public String send(String message) {
 System.out.println("send message:" + message);
 return message;
 }
}
//创建代理类并同样实现发送短信的接口
public class SmsProxy implements SmsService {

 private final SmsService smsService;

 public SmsProxy(SmsService smsService) {
 this.smsService = smsService;
 }

 @Override
 public String send(String message) {
 //调用方法之前，我们可以添加自己的操作
 System.out.println("before method send()");
 smsService.send(message);
 //调用方法之后，我们同样可以添加自己的操作
 System.out.println("after method send()");
 return null;
 }
}
//实际使用
public class Main {
 public static void main(String[] args) {
 SmsService smsService = new SmsServiceImpl();
 SmsProxy smsProxy = new SmsProxy(smsService);
 smsProxy.send("java");
 }
}
//打印结果
before method send()
send message:java
after method send()

动态代理#

从JVM角度来说，动态代理是在运行时动态生成类字节码，并加载到JVM中的。 SpringAOP和RPC等框架都实现了动态代理

java-reflex

Mon, 10 Oct 2022 11:27:04 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

何为反射#

赋予了我们在运行时分析类以及执行类中方法的能力；运行中获取任意一个类的所有属性和方法，以及调用这些方法和属性

应用场景#

Spring/Spring Boot 、MyBatis等框架都用了大量反射机制，以下为

JDK动态代理

接口及实现类

 package proxy;

 public interface Car {

 public void run();
 }
 //实现类
 package proxy;

 public class CarImpl implements Car{

 public void run() {
 System.out.println("car running");
 }

 }

代理类及main方法使用 [ˌɪnvəˈkeɪʃn] 祈祷

package proxy;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 //JDK动态代理代理类 
 public class CarHandler implements InvocationHandler{
 //真实类的对象
 private Object car;
 //构造方法赋值给真实的类
 public CarHandler(Object obj){
 this.car = obj;
 }
 //代理类执行方法时，调用的是这个方法
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 System.out.println("before");
 Object res = method.invoke(car, args);
 System.out.println("after");
 return res;
 }
 }
 //main方法使用
package proxy;

import java.lang.reflect.Proxy;

public class main {

 public static void main(String[] args) {
 CarImpl carImpl = new CarImpl();
 CarHandler carHandler = new CarHandler(carImpl);
 Car proxy = (Car)Proxy.newProxyInstance(
 main.class.getClassLoader(), //第一个参数，获取ClassLoader
 carImpl.getClass().getInterfaces(), //第二个参数，获取被代理类的接口
 carHandler);//第三个参数，一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
 proxy.run();
 }
 }
//输出
before
car running
after

Cglib动态代理（没有实现接口的Car

Java序列化详解

Mon, 10 Oct 2022 10:39:01 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

什么是序列化？什么是反序列化#

当需要持久化Java对象，比如将Java对象保存在文件中、或者在网络中传输Java对象，这些场景都需要用到序列化

即：

序列化：将数据结构/对象，转换成二进制字节流
反序列化：将在序列化过程中所生成的二进制字节流，转换成数据结构或者对象的过程

对于Java，序列化的是对象(Object)，也就是实例化后的类(Class)

序列化的目的，是通过网络传输对象，或者说是将对象存储到文件系统、数据库、内存中，如图：

实际场景#

对象在进行网络传输（比如远程方法调用 RPC 的时候）之前需要先被序列化，接收到序列化的对象之后需要再进行反序列化；
将对象存储到文件中的时候需要进行序列化，将对象从文件中读取出来需要进行反序列化。
将对象存储到缓存数据库（如 Redis）时需要用到序列化，将对象从缓存数据库中读取出来需要反序列化

序列化协议对于TCP/IP 4层模型的哪一层#

4层包括，网络接口层，网络层，传输层，应用层如下图所示：

OSI七层协议模型中，表示层就是对应用层的用户数据，进行处理转换成二进制流；反过来的话，就是将二进制流转换成应用层的用户数据，即序列化和反序列化，
因为，OSI 七层协议模型中的应用层、表示层和会话层对应的都是 TCP/IP 四层模型中的应用层，所以序列化协议属于 TCP/IP 协议应用层的一部分

常见序列化协议对比#

kryo 英音 [k’rɪəʊ] ，除了JDK自带的序列化，还有hessian、kryo、protostuff

JDK自带的序列化，只需要实现java.io.Serializable接口即可

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Builder
@ToString
public class RpcRequest implements Serializable {
 private static final long serialVersionUID = 1905122041950251207L;
 private String requestId;
 private String interfaceName;
 private String methodName;
 private Object[] parameters;
 private Class<?>[] paramTypes;
 private RpcMessageTypeEnum rpcMessageTypeEnum;
}

serialVersionUID用于版本控制，会被写入二进制序列，反序列化如果发现和当前类不一致则会抛出InvalidClassException异常。一般不使用JDK自带序列化，1 不支持跨语言调用 2 性能差，序列化之后字节数组体积过大

Kryo 由于变长存储特性并使用了字节码生成机制，拥有较高的运行速度和较小字节码体积，代码：

为什么Java中只有值传递

Sun, 09 Oct 2022 11:30:05 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

形参&&实参
- 实参(实际参数，Arguments)，用于传递给函数/方法的参数，必须有确定的值
- 形参(形式参数，Parameters)，用于定义函数/方法，接收实参，不需要有确定的值
```
String hello = "Hello!";
// hello 为实参
sayHello(hello);
// str 为形参
void sayHello(String str) {
 System.out.println(str);
}
```
值传递&&引用传递
- 程序设计将实参传递给方法的方式分为两种，值传递：方法接收实参值的拷贝，会创建副本；引用传递：方法接受的是实参所引用的对象在堆中的地址，不会创建副本，对形参的修改将影响到实参

Java中只有值传递，原因：

传递基本类型参数

public static void main(String[] args) {
 int num1 = 10;
 int num2 = 20;
 swap(num1, num2);
 System.out.println("num1 = " + num1);
 System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
 int temp = a;
 a = b;
 b = temp;
 System.out.println("a = " + a);
 System.out.println("b = " + b);
}
//输出
a = 20
b = 10
num1 = 10
num2 = 20

传递引用类型参数 1

javaGuide基础3

Sat, 08 Oct 2022 15:23:15 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

异常#

unchecked exceptions (运行时异常)
checked exceptions (非运行时异常，编译异常）
Java异常类层次结构图
Exception和Error有什么区别
- 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常
- Exception : 程序本身可以处理的异常（可通过catch捕获）
  - Checked Exception ，受检查异常，必须处理(catch 或者 throws ，否则编译器通过不了) IOException，ClassNotFoundException，SQLException，FileNotFoundException
  - Unchecked Exception ，不受检查异常，可以不处理

（算数异常，类型转换异常，不合法的线程状态异常，下标超出异常，空指针异常，参数类型异常，数字格式异常，不支持操作异常） ArithmeticException，ClassCastException，IllegalThreadStateException，IndexOutOfBoundsException

 NullPointerException，IllegalArgumentException，NumberFormatException，SecurityException，UnsupportedOperationException 


 ```illegal 英[ɪˈliːɡl] 非法的``` 
 ```Arithmetic 英[əˈrɪθmətɪk] 算术```

Error： 程序无法处理的错误，不建议通过catch 捕获，已办错误发生时JVM会选择线程终止
OutOfMemoryError （堆，Java heap space），VirtualMachineError，StackOverFlowError，AssertionError （断言），IOError
Throwable类常用方法
- String getMessage() //简要描述
- String toString() //详细
- String getLocalizedMessage() //本地化信息，如果子类(Throwable的子类)没有覆盖该方法，则与gtMessage() 结果一样
- void printStackTrace() //打印Throwable对象封装的异常信息
try-catch-finally如何使用 try后面必须要有catch或者finally；无论是否捕获异常，finally都会执行；当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。

javaGuide基础2

Thu, 29 Sep 2022 10:16:13 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

面向对象基础#

区别
- 面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
- 面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。
- 面向对象编程 易维护、易复用、易扩展
对象实例与对象引用的不同
new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。

一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。
对象的相等一般比较的是内存中存放的内容是否相等；引用相等一般比较的是他们指向的内存地址是否相等
如果一个类没有声明构造方法，该程序能正确执行吗? 如果我们自己添加了类的构造方法（无论是否有参），Java 就不会再添加默认的无参数的构造方法了
- 构造方法特点：名字与类名相同；没有返回值但不能用void声明构造函数；生成类的对象时自动执行
- 构造方法不能重写(override)，但能重载 (overload)

面向对象三大特征

封装
把一个对象的状态信息(属性)隐藏在对象内部，不允许直接访问，但提供可以被外界访问的方法来操作属性

public class Student {
 private int id;//id属性私有化
 private String name;//name属性私有化

 //获取id的方法
 public int getId() {
 return id;
 }

 //设置id的方法
 public void setId(int id) {
 this.id = id;
 }

 //获取name的方法
 public String getName() {
 return name;
 }

 //设置name的方法
 public void setName(String name) {
 this.name = name;
 }
}

继承
不通类型的对象，相互之间有一定数量的共同点，同时每个对象定义了额外的特性使得他们与众不同。继承是使用已存在的类的定义作为基础建立新类的技术

javaGuide基础1

Wed, 28 Sep 2022 10:51:00 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

基础概念及常识#

Java语言特点
- 面向对象（封装、继承、多态）
- 平台无关性（Java虚拟机）
- 等等
JVM并非只有一种，只要满足JVM规范，可以开发自己专属JVM
JDK与JRE
- JDK，JavaDevelopmentKit，包含JRE，还有编译器（javac）和工具（如javadoc、jdb）。能够创建和编译程序
- JRE，Java运行时环境，包括Java虚拟机、Java类库，及Java命令等。但是不能创建新程序
字节码，采用字节码的好处
- Java中，JVM可以理解的代码称为字节码（.class文件)，不面向任何处理器，只面向虚拟机
- Java程序从源代码到运行的过程
  - java代码必须先编译为字节码，之后呢，.class–>机器码，这里JVM类加载器先加载字节码文件，然后通过解释器进行解释执行（也就是字节码需要由Java解释器来解释执行）
  - Java解释器是JVM的一部分
编译与解释并存
- 编译型：通过编译器将源代码一次性翻译成可被该平台执行的机器码，执行快、开发效率低
- 解释型：通过解释器一句一句的将代码解释成机器代码后执行，执行慢，开发效率高
- 如图
为什么说 Java 语言“编译与解释并存”？

这是因为 Java 语言既具有编译型语言的特征，也具有解释型语言的特征。因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行。
Java与C++区别
- 没学过C++，Java不提供指针直接访问内存
- Java为单继承；但是Java支持继承多接口
- Java有自动内存管理垃圾回收机制（GC），不需要程序员手动释放无用内存
注释分为单行注释、多行注释、文档注释
标识符与关键字标识符即名字，关键字则是被赋予特殊含义的标识符
自增自减运算符当 b = ++a 时，先自增（自己增加 1），再赋值（赋值给 b）；当 b = a++ 时，先赋值(赋值给 b)，再自增（自己增加 1）
continue/break/return
- continue ：指跳出当前的这一次循环，继续下一次循环。
- break ：指跳出整个循环体，继续执行循环下面的语句。
- return 用于跳出所在方法，结束该方法的运行。
变量
- 成员变量和局部变量
  - 成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰
  - 从变量在内存中的存储方式来看,如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
  - 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡（即方法栈弹出后消亡）。
  - final必须显示赋初始值，其他都自动以类型默认值赋值
- 静态变量：被类所有实例共享
字符型常量与字符串常量区别

复习-JavaGuide on 随记

mysql执行计划

什么是执行计划？#

如何获取执行计划？#

sql常见面试题总结01

检索数据#

从 Customers 表中检索所有的 ID#

检索并列出已订购产品的清单#

检索所有列#

sql语法基础知识总结

基本概念#

数据库术语#

SQL 语法#

SQL 语法结构#

SQL 语法要点#

redis问题图解

3种常用的缓存读写策略详解

Cache Aside Pattern（旁路缓存模式）#

redis内存碎片

什么是内存碎片?#

为什么会有 Redis 内存碎片?#

redis特殊数据结构

Bitmap#

介绍#

常用命令#

redis基本数据结构

String（字符串）#

介绍#

redis面试题02

Redis 事务#

如何使用 Redis 事务？#

redis面试题01

Redis 基础#

什么是 Redis？#

Redis 为什么这么快？#

web-real-time-message-push

# 什么是消息推送？#

# 消息推送常见方案#

# 短轮询#

# 长轮询#

Java定时任务详解

为什么需要定时任务？#

单机定时任务技术选型#

Timer#

敏感词过滤方案总结

算法实现#

Trie 树#

权限系统设计详解

老权限系统的问题与现状#

业界权限系统的设计方式#

RBAC 模型#

ABAC 模型#

sso单点登录

SSO 介绍#

什么是 SSO？#

SSO 有什么好处？#

SSO 设计与实现#

核心应用与依赖#

用户登录状态的存储与校验#

jwt身份认证优缺点

JWT 的优势#

无状态#

有效避免了 CSRF 攻击#

jwt-intro

什么是 JWT?#

认证授权基础概念详解

认证 (Authentication) 和授权 (Authorization)的区别是什么？#

RBAC 模型了解吗？#

什么是 Cookie ? Cookie 的作用是什么?#

单元测试

何谓单元测试？#

为什么需要单元测试？#

为重构保驾护航#

提高代码质量#

减少 bug#

快速定位 bug#

持续集成依赖单元测试#

谁逼你写单元测试？#

领导要求#

大牛都写单元测试#

# 一不同角色看网站性能#

# 二性能测试需要注意的点#

# 三性能测试的指标#