首页 on Logan的博客

debian的安装

Mon, 25 Nov 2024 00:00:00 +0800

debian的安装

详细文档 :

https://wiki.debian.org/zh_CN/FrontPage 详细的wiki
https://www.debian.org/doc/manuals/debian-handbook/index.zh-cn.html 手册
https://www.debian.org/doc/manuals/debian-reference/index.zh-cn.html 参考手册
https://www.debian.org/releases/stable/arm64/index.zh-cn.html 安装手册
https://wiki.debian.org/zh_CN/NetworkConfiguration 网络配置

一键装机脚本见我的GitHub:

https://github.com/loganoxo/Config/tree/master/linux/install

一、debian虚拟机的安装

1、用虚拟机安装debian12

vmware 桥接模式的虚拟机不能用quanx的代理连接国外网站; nat模式是虚拟机自己组成子网,通过nat转发流量到宿主机,所以可以通过quanx连接国外网站;
但是nat模式下,宿主机默认不能直接通过虚拟机的内部 IP（例如 172.x.x.x）进行远程连接（如 SSH），因为 NAT 模式下虚拟机的网络是一个私有子网，与宿主机的网络隔离,除非用端口转发(windows上的nat)
mac中,vmware_fusion提供了自定义网络,选这个,其实是用的桥接网络,加上nat转发流量连接外网; 宿主机既可以ssh连接虚拟机,虚拟机也可以使用quanx访问国外网站
选择第二个 Graphical install, 安装界面可以用鼠标点击; 第一个 Install 的安装界面只能用键盘不能用鼠标
美国: United States
步骤1:语言选择美国英文:安装过程中显示的语言,所选语言也将是系统安装后的默认语言;安装后可用 sudo dpkg-reconfigure locales 重新配置
步骤2:选择区域, 中国; 会影响时区; 先选other,再asia,再选china
步骤3:因为没有找到符合你选择的语言和国家组合(我选的是美国英文+中国时区)的预设区域设置，系统会提示你重新选语言,依然选美国英文
步骤4:Configure the keyboard,键盘布局,选择American English;安装后可用 sudo dpkg-reconfigure keyboard-configuration 重新配置
步骤5:hostname, 设置为 prod 或 dev 或 test ; 这样的格式
步骤6:domain name; 设置为 vm.local ; 这样的格式
步骤7:输入两次root用户的密码;
步骤8:full name; 全名,真实姓名(英文的姓+名), 用于显示的; 就设置为 helq就可以了 ;
步骤9:username; 用于登录的; 设为helq
步骤10:输入两次helq用户的密码;
步骤11:Partition disks; 选择 Guided - use entire disk ; 不分区,使用整个磁盘(虚拟机创建的虚拟磁盘);
步骤12:会提示:Partition disks; Note that all data on the disk you select will be erased, but not before you have confirmed that you really want to make the changes. 就是个磁盘擦除警告,直接选择那个磁盘,回车下一步
步骤13:Selected for partitioning:The disk can be partitioned using one of several different schemes. If you are unsure, choose the first one. 选择分区方案; 直接选择第一个: All files in one partition
步骤14:This is an overview of your currently configured partitions and mount points. Select a partition to modify its settings (file system, mount point, etc.), a free space to create partitions, or a device to initialize its partition table. 即当前配置的分区和挂载点的概述, 选择Finish partitioning and write changes to disk,继续回车
步骤15:If you continue, the changes listed below will be written to the disks. Otherwise, you will be able to make further changes manually; 一个确认提示, 选择yes, 回车继续;如果选择默认的no, 会回到上一步
步骤16:Configure the package manager;Scanning your installation media finds the label; 是否扫描额外的安装介质; 选择no ,回车继续
步骤17:A network mirror can be used to supplement the software that is included on the installation media. This may also make newer versions of software available; 网络镜像的配置; debian12不用镜像,安装包里自带了,直接选no回车继续; debian11安装时,这里也选no;但是11.7.0那个包安装时,即便有梯子下载速度也很慢,所以debian这里需要断网; 但是11.11.0的包我安装的时候联网就通过了;
步骤18:Configuring popularity-contest; 提示是否开启匿名信息统计,选择no回车
步骤19:选择默认的软件包:SSH server、standard system utilities; 回车继续
步骤20: 安装结束; 回车 continue 会自动重启; 关机后需要把虚拟机的设置里面的 CD/DVD 驱动器取消连接

二、debian的环境搭建

1、软件包的源配置

/etc/apt/sources.list
debian12那个系统DVD安装好后,发现 /etc/apt/sources.list 中的内容是 deb cdrom:[Debian GNU/Linux 12.8.0 _Bookworm_ - Official arm64 DVD Binary-1 with firmware 20241109-11:05]/ bookworm contrib main non-free-firmware,因为这个系统最初通过离线 DVD 安装的,安装的DVD中包含所有的了

a、备份原来的

1
2

su
cp /etc/apt/sources.list /etc/apt/sources.list.bak

Copied!

b、解释

deb: 二进制软件包的来源，这些包是已经编译好的，可以直接安装到你的系统中,它是普通用户用来安装应用程序和库的来源
deb-src: 源码软件包的来源。源码包包含了软件的源代码，你可以从中编译和安装软件,如果需要修改或自行编译软件，可以用到这个源
bookworm/bullseye: debian12/debian11 ;是发行版的代号
main：完全开源的软件，符合 Debian 自由软件指南;
contrib：自由软件，但需要依赖非自由的软件（如驱动或库）
non-free：非自由软件（可能有版权或许可限制，用户可以使用但不能修改）
non-free-firmware：从 non-free 中分离出来的非自由固件，专用于硬件驱动和设备运行支持

c、使用官方的源(需要梯子)

`1`	`su #进入root用户`

Copied!

I、debian12

cat > /etc/apt/sources.list << EOF
# 提供主要的软件包库,是系统大部分软件的来源,包括基础的操作系统组件和应用程序包,用于升级系统和安装软件
deb http://deb.debian.org/debian bookworm main contrib non-free non-free-firmware
deb-src http://deb.debian.org/debian bookworm main contrib non-free non-free-firmware

# 提供安全性修复的更新,包含及时修复的安全漏洞补丁,用于修复系统或软件中的已知漏洞
deb http://security.debian.org/debian-security bookworm-security main contrib non-free non-free-firmware
deb-src http://security.debian.org/debian-security bookworm-security main contrib non-free non-free-firmware

# 快速修复一些关键问题,目的是解决一些无法等到下一个点版本(例如从 12.1 到 12.2)发布才能修复的问题
deb http://deb.debian.org/debian bookworm-updates main contrib non-free non-free-firmware
deb-src http://deb.debian.org/debian bookworm-updates main contrib non-free non-free-firmware

# 反向移植,指从 Debian 的较高版本中(例如 bookworm)选取特定的软件包,并在当前稳定版本(例如 bullseye)上进行重新编译和打包;用户可以在稳定版系统中使用更高版本的应用程序或工具,而无需升级整个系统到测试版或不稳定版
# deb http://deb.debian.org/debian bookworm-backports main contrib non-free non-free-firmware
# deb-src http://deb.debian.org/debian bookworm-backports main contrib non-free non-free-firmware
EOF

Copied!

debian11 只需把 bookworm 改为 bullseye

d、使用国内镜像源

cat > /etc/apt/sources.list << EOF
# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
deb http://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye main contrib non-free
# deb-src http://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye main contrib non-free
deb http://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye-updates main contrib non-free
# deb-src http://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye-updates main contrib non-free
deb http://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye-backports main contrib non-free
# deb-src http://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye-backports main contrib non-free
# deb http://mirrors.tuna.tsinghua.edu.cn/debian-security bullseye-security main contrib non-free
# # deb-src http://mirrors.tuna.tsinghua.edu.cn/debian-security bullseye-security main contrib non-free
deb http://security.debian.org/debian-security bullseye-security main contrib non-free
# deb-src http://security.debian.org/debian-security bullseye-security main contrib non-free
EOF

Copied!

上面是debian11的配置; debian12的去找镜像网站有相关配置,这里不写了

e、更新

1
2
3

apt update && apt-get update
apt list --upgradable #查看可以更新的软件包
apt upgrade

Copied!

f、apt相关命令

sudo apt update                           # 更新包索引
sudo apt upgrade                          # 升级所有已安装的软件包到最新版本
apt list python3                          # 显示是否已安装
sudo apt install <package>                # 安装指定的软件包
sudo apt remove <package>                 # 删除指定的软件包（保留配置文件）
sudo apt purge <package>                  # 完全删除指定的软件包（包括配置文件）
apt search <keyword>                      # 搜索与关键字相关的软件包
apt show <package>                        # 查看指定软件包的详细信息
apt list --installed                      # 列出所有已安装的软件包
apt list                                  # 列出所有可用的软件包
dpkg -l | grep <package>                  # 检查指定软件包是否已安装
sudo apt autoremove                       # 清理无用的依赖（卸载后遗留的包）
sudo apt autoclean                        # 清理下载的已过期或无用的软件包缓存
sudo apt clean                            # 清理所有下载的包缓存（慎用）
sudo apt download <package>               # 下载但不安装软件包
apt-cache depends <package>               # 检查指定软件包的依赖关系
apt-cache rdepends <package>              # 检查哪些软件包依赖指定的软件包
sudo apt --fix-broken install             # 手动修复被破坏的软件包
apt list <package>                        # 列出与指定包相关的信息（包括状态、版本等）
sudo apt full-upgrade                     # 执行全面升级（可能会移除不需要的包）
sudo apt install -f                       # 修复依赖关系并安装未完成的软件包
sudo apt hold <package>                   # 将指定软件包标记为保持当前版本（不升级）
sudo apt unhold <package>                 # 取消对软件包的保持标记（允许升级）
apt policy <package>                      # 查看指定软件包的版本和安装来源
sudo apt-add-repository <repository>      # 添加 PPA 或自定义的源
sudo apt update && sudo apt upgrade -y    # 一次性更新包索引并升级所有软件包（跳过确认）
sudo apt dist-upgrade                     # 执行发行版升级（处理复杂依赖变化）
sudo apt-mark hold <package>              # 阻止软件包升级（标记为 hold 状态）
sudo apt-mark unhold <package>            # 取消 hold 标记，允许升级
sudo apt list --upgradable                # 列出可以升级的软件包
apt-cache search <package>                # 使用 apt-cache 搜索软件包
sudo apt-get check                        # 检查系统是否有破损的依赖关系
sudo apt-get changelog <package>          # 查看指定软件包的变更日志
sudo dpkg-reconfigure <package>           # 重新配置已安装的软件包
sudo dpkg --configure -a                  # 修复未正确配置的软件包

Copied!

2、网络配置

静态ip + 自定义dns
自定义dns时, 不要去修改,/etc/resolv.conf,因为可能重启后失效; 去在 /etc/network/interfaces 配置
ip addr 查看当前的ip
vmware中配置了端口转发

0、resolvconf

默认情况下,resolvconf并没有安装, 所以在 /etc/network/interfaces 中配置的 dns-nameservers 并不会自动同步到 /etc/resolv.conf, 并且每次系统重启或者使用命令 systemctl restart networking.service 后, resolv.conf 都会被 dhclient 覆盖;
dhclient 是常用的 DHCP 客户端，它会根据 DHCP 服务器提供的 DNS 信息自动更新 /etc/resolv.conf, 查看 /etc/dhcp/dhclient.conf 中有request 里面有 domain-name, domain-name-servers, 和 domain-search;是 DHCP 客户端从 DHCP 服务器请求的选项,如果 DHCP 服务器提供了这些选项，dhclient 默认会更新 /etc/resolv.conf
在不安装额外程序的情况下, 也可以使用命令 sudo chattr +i /etc/resolv.conf ,给这个文件设置只读权限, 这样就不会被覆盖了; sudo chattr -i /etc/resolv.conf 恢复权限
resolvconf 依赖于 /etc/network/interfaces、DHCP 等服务来收集 DNS 配置信息，并通过这些信息更新 /etc/resolv.conf。resolvconf会将来自多个来源（例如 DHCP 客户端、静态配置、VPN 配置等）的 DNS 信息汇总并合并，最终由 resolvconf 更新 /etc/resolv.conf;
安装 resolvconf 后, /etc/resolv.conf 被替换为符号链接,指向 /run/resolvconf/resolv.conf; 原来的resolv.conf中的内容被删除,备份在/etc/resolvconf/resolv.conf.d/original中
安装了 resolvconf 后，会在/etc/dhcp/dhclient-enter-hooks.d/ 目录下创建 resolvconf 脚本, dhclient 会通过这个脚本将获取到的 DNS 信息交给 resolvconf 管理; 这些动态信息(包括在/etc/network/interfaces中配置的)通常被写入 /run/resolvconf/interface/ 目录中
resolvconf 使用多个配置文件片段来管理 DNS 信息,配置文件路径包括：
- /etc/resolvconf/resolv.conf.d/head：内容会添加在动态生成的 /etc/resolv.conf 文件的最开头,通常是注释行（例如，文件生成说明）或管理员希望固定放在前面的配置
- /etc/resolvconf/resolv.conf.d/base：基本 DNS 信息,配置一些静态的dns,始终会添加到resolv.conf; resolvconf收集到的动态信息会跟base文件中的配置进行merge;如:base中配置了 search a.b.c,收集到的动态信息是 search x.y.z,最终结果就是:search a.b.c x.y.z
- /etc/resolvconf/resolv.conf.d/tail：尾部内容;可以用来加入一些额外的选项，比如 options inet6;如果不需要任何追加内容，可以将该文件留空。
可以直接在 /etc/network/interfaces 中配置 dns-nameservers 和 dns-search, 在resolvconf的帮助下会同步到 resolv.conf
文档目录: /usr/share/doc/resolvconf/README.gz gunzip README.gz
resolvconf 和 systemd-resolved 两个软件冲突,安装一个就会卸载另一个; systemd-resolved的功能比resolvconf更多,如mdns和dns缓存等,但我不会用,也没必要用

a、原始配置的解释

1、运行 cat /etc/resolv.conf ; 显示:

1
2
3

domain localdomain
search localdomain
nameserver 172.16.106.2

Copied!

一、找到这个 nameserver, 写在后面 /etc/network/interfaces 中的 gateway; nameserver就是使用的dns服务器, 在vmware虚拟机中,这个默认被配置为nat的网关ip,用来转发流量和dns解析; 但是也不是必须与网关ip相同, 可以配置成多个不同的dns, 写多行 nameserver, 配置的dns中就算没有网关ip, nat的外网访问依然还是保持不变, 所以网关是网关,dns是dns,两个不同的功能和概念;
虚拟机linux中的网关ip虽然默认没有文件配置(除非配置静态ip),但可以执行命令: ip route | grep default 可以查看到
在 VMware 创建的 NAT 模式的虚拟机中，虚拟机的网关 IP 并不是直接存储在虚拟机的配置文件(不在linux虚拟机的文件系统中)中，而是通过 VMware 的网络配置文件定义，并由虚拟机通过 DHCP 或静态配置使用,可能会存放在宿主机 /Library/Preferences/VMware Fusion/networking (VNET_8_HOSTONLY_SUBNET)中,这是标识了nat能用的子网段,以 .0 结尾,但是网关ip用的是以 .2 结尾的;
在 /Library/Preferences/VMware Fusion/vmnet8/nat.conf 中有下面的这个配置,也标识了网关ip;注意这是纯nat模式,和自定义模式还不相同;

1
2
3

# NAT gateway address
ip = 172.16.12.2
netmask = 255.255.255.0

Copied!

mac上vmware fusion自定义模式实际上是桥接, 在 /Library/Preferences/VMware Fusion/networking 中的 VNET_2_HOSTONLY_SUBNET 中有显示;在 /Library/Preferences/VMware Fusion/vmnet2/nat.conf 中也有如下表示(vmnet2 也在软件中显示的我的自定网络的名字):

1
2
3

# NAT gateway address
ip = 172.16.106.2
netmask = 255.255.255.0

Copied!

nat 模式的网关 ip xxx.xxx.xxx.2 通常以 .2 结尾, 因为约定俗成; .0 是一个网段的网络标识地址，表示整个子网常表示子网本身，不能分配给设备或服务使用; .1 通常用于路由器,在家庭路由器中，192.168.1.1 是常见的默认网关,虽然 VMware 可以选择使用 .1，但它通常会避开这个地址，以避免与一些软件或网络设备的默认配置产生冲突
二、这个文件就是被修改,重启后也会恢复原样; 若要进行配置,需要修改后执行 chattr +i /etc/resolv.conf 变为只读的;恢复: chattr -i /etc/resolv.conf
三、domain 和 search 最好保持不变, 就用 localdomain, 更安全, 因为外网中没有localdomain的顶级域名
localdomain 就是个默认的域名占位符,假如我 ping aaa, 他会尝试去dns中查找 aaa 和 aaa.localdomain; 可以删除localdomain,替换为自己要用的
search 就是一个搜索域, 用于补全主机名,假如配置成 com, 我执行 ping baidu 就能直接ping成功; 但是不能和本地hosts文件配合使用,如在hosts中配置: 1.1.1.1 a.com ; 则我执行 ping a, 是不会成功的, 因为会直接去dns服务器中查找(nat模式虚拟中就是那个网关ip),网络上并没有 a.com 这个地址,所以不会成功,这种只能 ping a.com;
domain 和 search 功能相同,原理也相同; 但是1、search若配置后, 会覆盖domain 的配置; 2、search 支持多个以空格分开, domain 仅支持一个

2、运行 cat /etc/network/interfaces ; 显示:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
allow-hotplug ens160
iface ens160 inet dhcp

Copied!

详情见下面修改静态ip的示例

b、静态ip+dns配置

ens160 :网络接口名称,必须使用原本默认的, 但是有些老linux使用的是 eth0,所以需要修改前预先查看当前系统使用的 网络接口名称; 在后面修改的配置文件示例作出相应的修改才行; 原来用的哪个,修改后也应该用哪个;可以用 ip link show 或者 ifconfig, 或者直接看 /etc/network/interfaces文件
如果要配置静态ip,那就必须要配置gateway(网关)ip,否则不能连接外网;局域网使用是可以的
为什么默认不需要配置?因为默认网络是动态ip,是通过dhcp自动发现的,通过dhcp,linux就知道了该找哪个网关ip;静态ip则不然;
桥接模式也需要配置网关ip(通常为路由器ip),默认使用动态ip时,也是用dhcp自动发现的;
若要配置dns,则最好在/etc/network/interfaces中配置,虽然/etc/resolv.conf中也能配置,但是重启就会没了;而/etc/network/interfaces中配置的dns则会自动同步到resolv.conf,重启也不会消失
lo 的两行是非必须的,是回环地址(127.0.0.1),可以不用显式配置,linux会在开机后自动启用lo,可以用 ping 127.0.0.1 来检测
也可以设置: dns-search com # 设置DNS搜索域 ,见上面的 resolv.conf配置详解(就是这个resolv.conf里的 search, 会自动同步到resolv.conf)

su
export PATH=$PATH:/usr/sbin

cp /etc/network/interfaces /etc/network/interfaces.bak
cat > /etc/network/interfaces << EOF
# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
# allow-hotplug ens160
# iface ens160 inet dhcp
auto ens160
iface ens160 inet static
    address 172.16.106.12
    netmask 255.255.255.0
    gateway 172.16.106.2
    dns-nameservers 223.5.5.5 119.29.29.29 8.8.8.8
EOF

cat /etc/network/interfaces #确认一下
systemctl restart networking.service
ip addr

######### 安装resolvconf
apt install resolvconf
reboot
systemctl status resolvconf.service # 服务状态为 active (exited)，说明它已经成功运行并退出（这类服务是一次性任务，在启动后完成工作便退出）
cat /etc/resolv.conf
ls -l /etc/resolv.conf
systemctl start resolvconf.service
systemctl stop resolvconf.service
systemctl enable resolvconf.service
systemctl disable resolvconf.service

cat /etc/resolv.conf # 查看dns是否被自动更改
ls -l /etc/resolv.conf # 查看是否为软链接
# 关闭 quanx
ping www.baidu.com
wget www.baidu.com
rm index.html
dig www.baidu.com # SERVER: 223.5.5.5#53(223.5.5.5) (UDP)
nslookup -debug www.baidu.com  # Server:223.5.5.5

Copied!

c、配置默认语言

尽管在安装时已经选择了默认语言(即安装的第一步,选择安装程序的显示语言,这个设置也会成为安装后系统的默认语言)
在系统安装完成后,可以通过命令重新配置; 如果安装时选择的英文, 安装后用命令把中文加为第二个语言,但是默认首选还是英文,只是添加了个中文环境信息,可以给其他软件使用;如: tldr -L zh tree ,这个命令,如果不添加中文语言环境的支持,是不会显示中文的
默认 tty界面(非远程连接、非图形化界面的系统自己的操作界面,那个黑窗口) 无论怎么配置,通常也是不支持中文的,除非安装 fbterm 这个第三方的tty

su
export PATH=$PATH:/usr/sbin
# 鼠标滚轮可以快速滚动
dpkg-reconfigure locales
# 选中 en_US.UTF-8 和 zh_CN.UTF-8
# 用空格选中(多选),上下箭头移动, tab键移至 [ok] 回车确认; 提示选择 en_US.UTF-8 为首选默认语言,选择后回车确定
# 重新登录或重启
locale     # 查看目前系统所使用的语言环境
locale -a     # 查看系统已安装的所有语言

# 环境变量有:   (默认都是 "en_US.UTF-8" ; 若修改默认的语言为中文则变为:   "zn_CN.UTF-8"  )
LANG         # 系统的主要语言和地区设置，影响所有未单独设置的 LC_* 变量。
LANGUAGE     # 定义语言优先顺序，主要用于翻译系统消息 (LC_MESSAGES)。
LC_ALL       # 强制覆盖所有 LC_* 变量的值，优先级最高，通常用于调试。

LC_CTYPE     # 定义字符分类和编码规则，影响字符输入和显示 (如 UTF-8)。
LC_NUMERIC   # 控制数值格式，例如小数点符号、分组符号等。
LC_TIME      # 定义日期和时间格式 (如美式日期 vs 欧式日期)。
LC_COLLATE   # 控制字符串比较和排序规则，影响文件名排序等。
LC_MONETARY  # 控制货币格式，例如货币符号、千分位分隔符等。
LC_MESSAGES  # 定义系统消息的语言 (如错误提示、确认信息等)。
LC_PAPER     # 控制默认纸张尺寸 (如 Letter vs A4)。
LC_NAME      # 定义人名的显示格式 (如姓氏在前或名字在前)。
LC_ADDRESS   # 控制地址格式和显示规则。
LC_TELEPHONE # 定义电话号码的格式 (如是否显示国家代码)。
LC_MEASUREMENT # 控制度量单位 (如公制 vs 英制)。
LC_IDENTIFICATION # 描述语言环境的特定信息，通常不直接影响用户体验。

# 不需要自己配置环境变量,直接使用系统默认的体验最佳

Copied!

d 、重新配置键盘布局

装好系统后,默认不用修改
键盘布局就是,在 tty 界面,或者linux自己的图形化界面的键盘映射;其目的是让操作系统正确识别和映射键盘上的按键到字符或功能;
按键 Shift+2 输出 @（在美式键盘中）还是 " (在英式键盘中)某些键盘布局会增加对语言特定符号的支持，比如法语的 é 或德语的 ß
某些布局支持 AltGr（右 Alt 键）的特殊功能，用于输入更多字符
但是远程连接的话就没这个说法了,用的是我本地的电脑自己的键盘映射,传给linux的就是实际的字符信息了;
最佳选择: 美式键盘（US Layout）：标准 QWERTY 布局，符号按键位置国际通用;
中国市场的键盘以美式 QWERTY 布局为主,硬件上没有区别,中文输入完全依赖系统输入法
默认 tty界面(非远程连接、非图形化界面的系统自己的操作界面,那个黑窗口) 无论怎么配置,通常也是不支持中文的,除非安装 fbterm 这个第三方的tty

su
export PATH=$PATH:/usr/sbin
dpkg-reconfigure keyboard-configuration
service keyboard-setup restart

Copied!

e、安装 sudo

# sudo命令需要用户需要输入自己的密码进行身份验证，而不是 root 密码。这是 sudo 的一大优点，可以避免暴露 root 密码
su
export PATH=$PATH:/usr/sbin
apt update
apt list sudo
ls /usr/sbin/sudo
apt install sudo
/usr/sbin/usermod -aG sudo $(whoami) #将helq用户加入sudo的用户组; 
# -a (append)：表示将用户添加到新的组时，保留其现有的组。如果不加 -a，用户将会退出其他组，仅加入指定的组
# -G(group)：后面跟一组组名，用逗号分隔，表示要添加用户的目标组
groups helq #确认用户已被添加到 sudo 组;输出中应该包含 sudo
# 重新登录使更改生效
sudo echo "aaa" #测试

Copied!

f、前置软件安装

su
export PATH=$PATH:/usr/sbin
apt update && apt-get update
apt install -y net-tools build-essential openssh-server curl unzip zip tree cmake jq

# 安装zsh
apt install zsh
zsh --version
sudo chsh -s $(which zsh) # 设置 zsh 为 root用户的 默认 shell
reboot # 重启
chsh -s $(which zsh) # 重新为普通用户设置

Copied!

f、允许root直接登录

默认情况下,是不允许 root直接登录的即: ssh -p 22 root@172.16.106.12 会失败

1
2

echo "PermitRootLogin yes" | sudo tee -a /etc/ssh/sshd_config >/dev/null # 解决方式, 重启启动虚拟机就可以了
reboot # 重启

Copied!

g 、虚拟机克隆的情况

# 执行下面这个命令,重新配置静态ip dns 和 hostname
su -c "wget -q -O- --header='Cache-Control: no-cache' \"https://raw.githubusercontent.com/loganoxo/Config/master/linux/install/pre.sh?$(date +%s)\" | bash -s -- \"run\" \"$(whoami)\" \"clone\" "

################# 重新生成 ssh host key ##############################
# 因为 A、B 和 C 虚拟机的 SSH 主机密钥是克隆时复制过来的，三台虚拟机的密钥相同，所以 SSH 客户端会认为它们是同一台主机。  
# ssh连接这三台机器时,本地~/.ssh/known_hosts 文件中这三台机器的指纹完全相同;  
# 当你尝试通过 SSH 连接到主机时，SSH 客户端会检查该主机的指纹是否与之前记录的匹配。如果三台虚拟机的指纹相同，当你切换连接到另一个虚拟机时，SSH 客户端会认为主机身份可能被篡改，提示警告  
# 主机指纹的目的是确保客户端连接到正确的服务器。如果三台虚拟机的指纹相同，客户端无法区分它们。这可能会带来以下问题：  
#   •  中间人攻击更容易成功，因为客户端无法验证主机的唯一性。  
#   •  如果某台虚拟机被攻破，攻击者可能利用相同的指纹冒充其他虚拟机  
# 管理混乱: 在使用工具（如 Ansible、SSH 配置文件）管理多台主机时，相同的指纹可能导致配置错误或意外连接到错误的主机  
# 尽量为每台虚拟机生成唯一的 SSH 主机密钥，确保指纹唯一性，以避免潜在问题并提高系统安全性。 
# 在 克隆出来的虚拟机中执行:
sudo rm -f /etc/ssh/ssh_host_*
sudo ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key -N ""
sudo ssh-keygen -t ecdsa -f /etc/ssh/ssh_host_ecdsa_key -N ""
sudo ssh-keygen -t ed25519 -f /etc/ssh/ssh_host_ed25519_key -N ""
sudo systemctl restart ssh
sudo reboot
# ssh-keygen: 用于生成 SSH 密钥的工具; -t rsa: 指定生成密钥的类型为 RSA。RSA 是一种常用的公钥算法  
# -f /etc/ssh/ssh_host_rsa_key : 指定生成的密钥文件的路径和文件名; 公钥会自动生成在相同路径，文件名为 /etc/ssh/ssh_host_rsa_key.pub ; 私钥存储在同目录 /etc/ssh/ssh_host_rsa_key# -N ""   : 双引号不能去掉; 设置密钥的密码为空;空密码适用于 SSH 主机密钥，因为它们需要在没有人工干预的情况下由 SSH 服务自动使用

############## 客户端中需要把之前在 ~/.ssh/known_hosts 中生成的 ip+指纹 删除
ssh-keygen -R <VM Ip>
ssh-keygen -R "172.16.106.110"
ssh-keygen -R "172.16.106.120"
ssh-keygen -R "172.16.106.130"
cat ~/.ssh/known_hosts
# 重新用 SSH 连接; 会重新提示接受新的指纹

Copied!

三、以下配置可以用脚本执行

1、安装shell插件

su helq
export PATH=$PATH:/usr/sbin
sudo apt update
# 安装 git
sudo apt install git  
git --version

# 安装 ohmyzsh
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions  
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting
rm ~/.zshrc.pre-oh-my-zsh
# 安装 ohmybash
bash -c "$(curl -fsSL https://raw.githubusercontent.com/ohmybash/oh-my-bash/master/tools/install.sh)"
rm ~/.bashrc.omb-backup-*
# 安装 starship
curl -sS https://starship.rs/install.sh | sh

Copied!

2、环境搭建

su helq
export PATH=$PATH:/usr/sbin/                                # 临时解决debian系统的默认PATH没有sbin的问题
# git
sudo apt install git
git --version
# ssh-github 私钥
### 可选-上传 ~/.ssh/ 下的github私钥 到 虚拟机
ssh -T git@github.com
# 若有权限太宽泛的问题
chmod 600 /home/helq/.ssh/loganoxo-GitHub
ssh -T git@github.com
# eval "$(ssh-agent -s)"

cd ~
mkdir -p ~/.aria2 ~/.config ~/.ssh ~/.shell_bak ~/software ~/Data ~/.local/bin ~/.config/navi ~/.zoxide ~/.undodir ~/.vim ~/Temp ~/share
git clone https://github.com/loganoxo/Config.git ~/Data/Config
mv ~/.bashrc ~/.shell_bak/ && mv ~/.profile ~/.shell_bak/ && mv ~/.zshrc ~/.shell_bak/
bash ~/Data/Config/my-ln.sh
sudo bash ~/Data/Config/linux/for_root/create_root_files.sh "$HOME" "$HOME/Data/Config/linux/for_root/template.sh"
sudo ln -sf ~/Data/Config/vim/settings.vim /root/.vimrc
source "$HOME/.zshrc"

Copied!

3、安装必备工具

debian等linux系统,若是arm架构的,则不推荐装 homebrew(linuxbrew),有很多包没有通用二进制文件,只能在本地编译,很慢又容易出依赖的问题,不友好

# 安装防火墙
sudo apt install ufw -y
sudo ufw status #inactive，说明 UFW 未启用
# 默认情况下，UFW 会阻止所有传入的网络流量，除非明确允许。例如，如果没有添加允许 SSH 的规则，远程登录将会被拒绝;
# 默认情况下，UFW 会允许所有传出的网络流量，比如从本机访问互联网的请求
# UFW 的 allow 命令默认允许的是传入流量; ufw allow ssh 等效于 ufw allow in ssh ;  传出的用法如: ufw allow out 53 
sudo ufw disable #禁用
sudo ufw default deny incoming && sudo ufw default allow outgoing
# enable之前先开放 ssh 端口, 否则远程连接会断开; 允许SSH（端口 22） HTTP（端口 80） HTTPS（端口 443）
sudo ufw allow ssh && sudo ufw allow http && sudo ufw allow https && sudo ufw allow 80
sudo ufw allow 6000:6007/tcp && sudo ufw allow 6000:6007/udp #允许使用端口 6000-6007 的 连接
sudo ufw limit ssh # 限制ssh登录尝试的连接次数,防止暴力破解密码;每个ip每30秒最多尝试6次
sudo ufw enable #启用
sudo ufw status verbose #查看所有端口开放情况
sudo ufw reset #清空所有规则并恢复默认配置
sudo ufw delete allow ssh #删除某个规则
#根据规则编号删除
sudo ufw status numbered
sudo ufw delete <编号>

# 安装 nginx
sudo apt install nginx -y
sudo systemctl list-unit-files --state=enabled #查看所有自启动的软件
sudo systemctl disable nginx.service #禁止nginx开机自启
sudo systemctl status nginx
sudo systemctl stop nginx
sudo systemctl start nginx
sudo systemctl status nginx
curl http://127.0.0.1:80 #测试
# 在本地宿主机访问 http://172.16.106.12 ; http://127.0.0.1:12382/

# 安装 go
sudo apt install golang-go
go version

Copied!

4、命令行工具

su helq
# 安装 bat
sudo apt install bat #这样安装的bat会因为避免名字冲突而让他的命令变为 batcat, 所以需要符号链接
# 切换到普通用户执行:
mkdir -p ~/.local/bin
ln -s /usr/bin/batcat ~/.local/bin/bat

# 安装fzf
# sudo apt install fzf #版本太低了
mkdir -p ~/software  
git clone https://github.com/junegunn/fzf.git ~/software/fzf  
wget -P "$HOME/software/fzf/" https://github.com/junegunn/fzf/releases/download/v0.56.3/fzf-0.56.3-linux_arm64.tar.gz  
tar -xzf ~/software/fzf/fzf-0.56.3-linux_arm64.tar.gz -C ~/software/fzf  
ln -sf ~/software/fzf/fzf ~/.local/bin/fzf

# 安装fd
sudo apt install fd-find
ln -s $(which fdfind) ~/.local/bin/fd

# 安装zoxide
mkdir -p ~/.zoxide
curl -sSfL https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | sh


# 安装vim
mkdir -p ~/.undodir ~/.vim
sudo apt install vim
curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
# 测试 :PlugStatus :PlugInstall  :PlugClean
vim -c ':PlugStatus' -c ':PlugInstall' -c ':PlugClean' -c ':qa!'


# 安装sdkman
curl -s "https://get.sdkman.io?rcupdate=false" | bash #不修改zshrc 和 bashrc
sdk version
sdk list java
sdk install java 8.0.432.fx-zulu
java -XshowSettings:properties -version #查看安装的jdk详细版本信息
sdk install java 11.0.25.fx-zulu
sdk install java 17.0.13.fx-zulu
sdk install java 17.0.13-zulu
sdk install java 17.0.12-oracle #设为默认
sdk install java 17.0.13-tem
sdk default java 17.0.12-oracle
java -version
sdk list maven
sdk install maven 3.9.9
sdk default maven 3.9.9
# 重启虚拟机
mvn -version


# 安装fnm
curl -fsSL https://fnm.vercel.app/install | bash -s -- --skip-shell #不修改zshrc 和 bashrc
ln -s ~/.local/share/fnm/fnm ~/.local/bin/fnm
# eval "$(fnm completions --shell zsh)" #命令补全,没啥用,就只是补全命令,不会补全当前存在的node版本
fnm -V                             #查看fnm的版本
fnm ls                             #查看本地已安装的nodejs的版本
fnm current                        #打印当前使用的node版本
fnm ls-remote                      #通过网络查看所有已发布的nodejs版本
fnm ls-remote --lts                #通过网络查看所有已发布的长期支持的nodejs版本
fnm ls-remote --sort <SORT>        #默认asc升序,desc为倒序
fnm install --lts                  #安装最新的LTS版本,会自动加别名 default, lts-latest
fnm install --latest               #安装最新的版本,会自动加别名 latest
# fnm install v18.3.0              #安装指定的版本
# fnm install 17                   #部分版本匹配,从你的部分输入中猜测最新的可用版本,它将安装版本为v17.9.1 的节点


# fnm use <alias/version>          #在当前shell中临时使用某个版本的node
fnm use 22
fnm use lts-latest
fnm use default

# fnm default <alias/version>      #将某个版本设为默认版本;即新shell中默认使用的node版本
fnm default lts-latest

# fnm uninstall <alias/version>    #卸载某个版本

# fnm 给某node版本起别名,用于让其他命令在使用时,将版本号用别名替换;
# fnm alias [OPTIONS] <alias/version> <NAME>  设置别名; 别名唯一;
# 若此次设置的别名 aaa 与其他版本的别名重复,则会自动取消之前的别名,给这个命令里的版本17设置别名 aaa
# fnm alias 17 aaa 
fnm alias lts-latest lts


# fnm unalias [OPTIONS] <alias_name>  取消别名
# fnm unalias lts
which -a npm
npm -g install nrm pm2 prettier yarn yrm
npm list -g
nrm ls
nrm use taobao

# 安装rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustc --version

# 安装navi
tt
# 方法一,用cargo
cargo install --locked navi
# 方法二,自己编译,有问题
git clone https://github.com/denisidoro/navi && cd navi
make BIN_DIR=/home/helq/.local/bin install
# 方法三,用脚本,有问题,在debian上执行不了
BIN_DIR=/home/helq/.local/bin bash <(curl -sL https://raw.githubusercontent.com/denisidoro/navi/master/scripts/install)

# tldr
cargo install tealdeer
tldr --update
tldr bat
tldr -L zh tree

# glow
mkdir -p ~/software  
wget -P "$HOME/software" https://github.com/charmbracelet/glow/releases/download/v2.0.0/glow_2.0.0_Linux_arm64.tar.gz  
tar xvzf ~/software/glow_2.0.0_Linux_arm64.tar.gz -C "$HOME/software/"  
mv ~/software/glow_2.0.0_Linux_arm64 ~/software/glow  
ln -s ~/software/glow/glow ~/.local/bin/glow

# the_silver_searcher
sudo apt install silversearcher-ag

# trash-cli https://github.com/andreafrancia/trash-cli
sudo apt install python3 python3-pip python3-venv
sudo apt install trash-cli # 版本很低

sudo mkdir --parent /.Trash
sudo chmod a+rw /.Trash
sudo chmod +t /.Trash   

# +t 设置粘滞位 (sticky bit) 权限;只有文件或子目录的所有者，或目录本身的所有者（通常是管理员），才能删除或重命名该目录内的内容;
# 其他用户即使有写权限，也无法删除非自己拥有的文件

#   trash-cli https://github.com/andreafrancia/trash-cli
#   trash-put   <file/directory>                # trash files and directories.
#   trash-empty                                 # 从垃圾箱中删除所有文件
#   trash-empty <days>                          # 仅删除已删除时间超过 <days> 的文件
#   trash-list | grep <path>                    # list trashed files.
#   trash-restore                               # 选择文件进行恢复, 若要覆盖同名文件则 加 --overwrite
#   trash-rm \*.o                               # 从垃圾箱中删除与模式匹配的文件
#   从 home 分区回收的文件将被移动到此处 ~/.local/share/Trash/


# uv 包含了 pipx 的功能  https://docs.astral.sh/uv/
# 默认是managed: 最先找uv管理的python,其次找系统python(若此时在conda的某个环境中,conda该环境的python也会被找到),最后才下载;only-managed:只找uv管理的python,没有则下载;
# # 安装选项:https://docs.astral.sh/uv/configuration/installer/#disabling-shell-modifications
curl -LsSf https://astral.sh/uv/install.sh | sh # 默认在 ~/.local/share/uv/
# brew install uv
export UV_PYTHON_PREFERENCE="only-managed"
uv python list
uv python install # 默认在 ~/.local/share/uv/python/
uv python install 3.12
uv python uninstall 3.12
uv tool list
uv tool install ruff # 安装命令行工具,默认在 ~/.local/bin/  ~/.local/share/uv/tools/
uv tool install ruff -p 3.12 # 指定安装的命令行工具的虚拟环境中的python版本
ruff --version
ruff check a.py # 这个命令的功能: 检查python代码是否有问题
uv tool uninstall ruff
# 命令补全: https://docs.astral.sh/uv/getting-started/installation/#upgrading-uv


# 安装miniconda (超过200人公司使用收费) 免费替代: https://github.com/conda-forge/miniforge
# https://docs.anaconda.com/miniconda/install/
# https://docs.conda.io/projects/conda/en/stable/user-guide/index.html
# miniconda3 
# 寻找适合的版本 https://repo.anaconda.com/miniconda/   带py的指base环境的python版本
########## mac  也可以用  brew install miniconda
cd ~/Temp
curl https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -o ~/Temp/miniconda.sh
shasum -a 256 ~/Temp/miniconda.sh # 验证文件的 sha256 的值
bash ~/Temp/miniconda.sh # 安装路径与mac同步为 ~/.miniconda3
rm ~/Temp/miniconda.sh
conda init bash zsh

####### linux
### 静默安装
mkdir -p ~/Temp
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O ~/Temp/miniconda.sh
bash ~/Temp/miniconda.sh -b -u -p ~/.miniconda3 # -b:不对 shell 脚本进行 PATH 修改,以非交互模式（静默模式）运行安装; -u:如果指定的安装路径（通过 -p）已有 Miniconda 安装，它会更新而不是报错或覆盖安装; -p: 指定安装路径
rm ~/Temp/miniconda.sh

### 按照提示安装
mkdir -p ~/Temp
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O ~/Temp/miniconda.sh
bash ~/Temp/miniconda.sh # 安装路径与mac同步为 ~/.miniconda3
rm ~/Temp/miniconda.sh
# 也可以用apt安装 https://docs.conda.io/projects/conda/en/stable/user-guide/install/rpm-debian.html

# 静默安装后,可选择shell环境,会修改 .zshrc .bashrc
conda init zsh
conda init bash
conda init --all # 在所有可用 shell 上初始化 conda
conda --version
conda list
conda info
# base环境 推荐 只能用于安装 anaconda、conda 和 conda 相关的软件包，例如`anaconda-client`或`conda-build`
# 配置文件 : ~/.condarc
conda config --set auto_activate_base false # 设置开启新shell的时候不自动进入conda的base环境
conda config --set changeps1 False # 抑制 conda 自己的提示修饰符
# conda config --add channels conda-forge 会加在第一个
conda config --append channels conda-forge
conda config --remove channels conda-forge
conda -V
conda create -n env_test python=3.9 # -n 是创建的环境的名字
conda activate env_test
python3 -V
conda activate # 默认是base环境
python3 -V
conda deactivate
conda update conda # 更新自己
# 安装包或者命令行工具
conda install trash-cli # 官方的 channel 没有很多的开源包
conda install -c conda-forge trash-cli # 指定 conda-forge 的channel
# install的命令行工具的执行文件放在当前环境的bin目录下,如 /home/helq/miniconda3/envs/env_test/bin/trash-put; 同时也会被pip管理
# install 也可以安装python库文件,可以在 Python 脚本或交互式环境中直接导入并使用 import numpy as np

# 卸载conda
rm -rf ~/conda
rm -rf ~/.condarc ~/.conda ~/.continuum

# 导出某个非base环境到yaml文件; 仅将 Anaconda 或 Miniconda 文件复制到新目录或另一台计算机不会重新创建环境。您必须将环境作为一个整体导出
conda activate env_test
conda export -f env_test.yml --no-builds  或者 conda env export -f env_test.yml --no-builds
# --override-channels 不导出.condarc里的channel; 
# --no-builds 不导出构建编号,当跨平台迁移的时候必加,因为同一个版本的包在不同平台上的构建编号肯定不同;如: mac导出到linux上的时候
# 导入
conda env create -f env_test.yml


# docker
# https://docs.docker.com/engine/install/debian/#install-using-the-repository
sudo apt update
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done  #卸载冲突的包
sudo apt autoremove

# Set up Docker's `apt` repository
# Add Docker's official GPG key:
sudo apt-get update && sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

# Install the Docker packages
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
# Verify
sudo docker run hello-world
sudo docker images
sudo docker container ls -a

# 以非 root 用户身份管理 Docker; 
# 创建一个名为`docker`的 Unix 组并向其中添加用户。当 Docker 守护进程启动时，它会创建一个可供`docker`组成员访问的 Unix 套接字
sudo groupadd docker              # 创建`docker`组
sudo usermod -aG docker $USER     # 将您的用户添加到`docker`组
sudo reboot                       # 注销并重新登录，以便重新评估您的组成员身份
docker run hello-world            # 验证您是否可以在没有`sudo`情况下运行`docker`命令
# 如果在分配用户组之前 用sudo权限 执行过 docker CLI 中的如 docker login 这类命令, 会创建 ~/.docker 目录;
# 在上述的情况下, 分配用户组后, 用普通用户直接执行 docker 命令, 有可能会报错, 因为 ~/.docker 的权限是 root 用户的; 报错信息可能为:
# WARNING: Error loading config file: /home/user/.docker/config.json -stat /home/user/.docker/config.json: permission denied
# 解决方式一: 删除`~/.docker/`目录（它会自动重新创建，但所有自定义设置都会丢失）
# 方式二:
sudo chown "$USER":"$USER" /home/"$USER"/.docker -R  # 将这个文件夹的 拥有者 和 所属组 设为当前用户;-R：递归修改，即包括子目录和文件
sudo chmod g+rwx "$HOME/.docker" -R # 为 .docker 目录及其内容增加组权限，使所属组的成员可以读取（read）、写入（write）、执行（execute）文件。
# 在 Debian 和 Ubuntu 上，Docker 服务(守护进程)(不是指的容器) 默认在启动时启动
sudo systemctl status docker.service # 这是 Docker 的主服务，负责管理 Docker 守护进程（dockerd），提供核心功能，包括容器管理、镜像拉取和存储等
sudo systemctl status containerd.service # 这是 containerd 容器运行时服务，是一个独立的守护进程，用于管理容器的生命周期

sudo systemctl enable docker.service
sudo systemctl enable containerd.service

# 禁止开机启动;但是当使用docker命令时,这两个服务会自动启动
sudo systemctl disable docker.service
sudo systemctl disable containerd.service


# 其他安装
sudo apt install shellcheck shfmt tmux universal-ctags

Copied!

5、文件上传下载服务

a、dufs

# https://github.com/sigoden/dufs
# 安装  或者用docker直接使用就不用安装了
cargo install dufs

# 使用1、用docker直接启动容器挂载当前目录
docker run -v `pwd`:/data -p 5000:5000 --rm sigoden/dufs /data -A   # -A 是dufs的选项
# 默认情况下，容器即使停止后，仍然会保留在本地（可以用 docker ps -a 查看）。这些“停止的容器”会占用存储空间，并且需要手动清理
# --rm 容器停止时自动删除容器及其临时文件（例如挂载的匿名卷）;避免积累过多无用的停止容器，减少磁盘空间浪费。

# 使用2、用本地dufs命令
mkdir -p ~/share/dufs && cd ~/share/dufs
sudo ufw allow 5000
dufs                                # 以只读模式提供当前目录,只允许查看和下载;默认在前台执行
nohup dufs > output.log 2>&1 &      # 后台启动
jobs -l                             # 查看后台启动程序; kill PID
dufs -A                             # 允许所有操作，如上传/删除/搜索/创建/编辑
dufs --allow-upload                 # 只允许查看和下载和上传操作
# --allow-archive 允许文件夹打包下载; --allow-search 允许搜索
dufs ~/share/dufs                   # 指定某个目录
dufs linux-distro.iso               # 指定单个文件
dufs -a admin:123@/:rw              # 指定用户名admin/密码123
dufs -b 127.0.0.1 -p 80             # 监听特定ip和端口
dufs --hidden .git,.DS_Store,tmp    # 隐藏目录列表中的路径
dufs --hidden '.*'                          # hidden dotfiles
dufs --hidden '*/'                          # hidden all folders
dufs --hidden '*.log,*.lock'                # hidden by exts
dufs --hidden '*.log' --hidden '*.lock'
dufs --render-index                 # 使用index.html 提供静态网站
dufs --render-spa                   # 提供像 React/Vue 这样的单页应用程序
# 可以记录日志,见github
# 可以将这些选项放在配置文件,见github

# 命令行客户端访问
curl -T path-to-file http://127.0.0.1:5000/new-path/path-to-file      # 上传文件
curl http://127.0.0.1:5000/path-to-file                               # download the file
curl http://127.0.0.1:5000/path-to-file?hash                          # retrieve the sha256 hash of the file
curl -C- -o file http://127.0.0.1:5000/file                           # 可断点下载
curl -o path-to-folder.zip http://127.0.0.1:5000/path-to-folder?zip   # 将文件夹下载为 zip 文件
curl -X DELETE http://127.0.0.1:5000/path-to-file-or-folder           # 删除文件/文件夹
curl -X MKCOL http://127.0.0.1:5000/path-to-folder                    # 创建目录
curl -X MOVE http://127.0.0.1:5000/path -H "Destination: http://127.0.0.1:5000/new-path" # 将文件/文件夹移动到新路径
# 列出/搜索目录内容
curl http://127.0.0.1:5000?q=Dockerfile           # search for files, similar to `find -name Dockerfile`
curl http://127.0.0.1:5000?simple                 # output names only, similar to `ls -1`
curl http://127.0.0.1:5000?json                   # output paths in json format
# 需要账户密码
curl http://127.0.0.1:5000/file --user user:pass                 # basic auth
curl http://127.0.0.1:5000/file --user user:pass --digest        # digest auth
curl http://127.0.0.1:5000/__dufs__/health # 健康检查
# 可断点上传
upload_offset=$(curl -I -s http://127.0.0.1:5000/file | tr -d '\r' | sed -n 's/content-length: //p')
dd skip=$upload_offset if=file status=none ibs=1 | \
  curl -X PATCH -H "X-Update-Range: append" --data-binary @- http://127.0.0.1:5000/file

Copied!

b、filebrowser

############################ docker模式
mkdir -p ~/share/filebrowser
mkdir -p ~/share/filebrowser/files  
touch ~/share/filebrowser/filebrowser.db  
touch ~/share/filebrowser/filebrowser.json
cat > ~/share/filebrowser/filebrowser.json << EOF
{
  "port": 80,
  "baseURL": "",
  "address": "",
  "log": "stdout",
  "database": "/database/filebrowser.db",
  "root": "/srv"
}
EOF
sudo ufw allow 12786
docker run -d \
    -v ~/share/filebrowser/files:/srv \
    -v ~/share/filebrowser/filebrowser.db:/database/filebrowser.db \
    -v ~/share/filebrowser/filebrowser.json:/.filebrowser.json \
    -u $(id -u):$(id -g) \
    -p 12786:80 \
    filebrowser/filebrowser

# 默认情况下，镜像里已经有一个包含一些默认值的配置文件，因此您只需挂载根目录和数据库即可; 默认配置文件:
# https://github.com/filebrowser/filebrowser/blob/master/docker/root/defaults/settings.json


######################## 命令行模式
curl -fsSL https://raw.githubusercontent.com/filebrowser/get/master/get.sh | bash
nohup filebrowser -r ~/share/filebrowser -a 0.0.0.0 > output.log 2>&1 &

# Username: `admin` Password: `admin`

Copied!

c、开启 sftp 服务

# 确保系统已安装 OpenSSH 服务器 默认应该都存在并启动了sftp服务的
sudo apt update
sudo apt install openssh-server
# 检查 SSH 服务状态
sudo systemctl status ssh

# 查看 /etc/ssh/sshd_config 这个文件内是否存在:
# override default of no subsystems
Subsystem	sftp	/usr/lib/openssh/sftp-server
# 若存在则自动为所有创建的用户打开sftp服务,root能访问和修改所有文件; 普通用户能查看所有文件,但是只能修改自己有权限的文件
# 所以为了安全性,可以添加一个只能sftp连接不能ssh登录shell的用户,并限制这个用户 使用 SFTP 能使用的目录;主要目的是为了不暴露普通用户密码给别人

# ChrootDirectory 指定的目录及其父目录必须满足以下条件:1、由 root 拥有;2、不可被其他用户写入（即权限中不能有 write 权限分配给非 root 用户）;这意味着普通用户的主目录（比如 /home/sftpuser），无法直接作为 ChrootDirectory，因为主目录通常是由该用户自己拥有的，而不是 root
# 解决办法:1、创建一个由 root 拥有的顶层目录（例如 /var/sftp），保证它不可写;2、在顶层目录下创建一个子目录（例如 /var/sftp/sftpuser），将该子目录的所有权赋予用户（例如 sftpuser），以允许用户上传文件
sudo useradd -s /sbin/nologin sftpuser     # 创建一个新用户，该用户仅被授予对服务器的文件传输访问权限; 不能登录shell,没有home目录
                                           # -m 会创建home目录; -d <path> 自定义home目录
sudo passwd sftpuser                       # 添加密码    123456                 
sudo mkdir -p /var/sftp/sftpuser
sudo chown root:root /var/sftp
sudo chmod 755 /var/sftp          # root用户为7所有权限; 同组用户和不同组的用户为5只允许读和执行; 4:读 2:写 1:执行
sudo chown sftpuser:sftpuser /var/sftp/sftpuser    # 将目录的所有权更改为您刚刚创建的用户
sudo chmod 775 /var/sftp/sftpuser          # 同组用户可以读和写(目录必须有执行权限才能cd进入);其他用户只读
sudo usermod -aG sftpuser $(whoami)  # 把当前用户加入 sftpuser 用户组,让当前用户可以操作`分享目录`,就让当前用户可以将自己的文件复制到这个`分享目录中`了
getent group sftpuser   # 查看用户组中有哪些用户
# 权限组生效要重新登录

## 修改 SSH 服务器配置以禁止sftpuser用户的终端访问，但允许文件传输访问
sudo vim /etc/ssh/sshd_config # 滚动到文件的最底部并添加以下配置片段; 
# 或者检查 /etc/ssh/sshd_config 中是否存在 Include /etc/ssh/sshd_config.d/*.conf 字样; 可如下方加一个新文件被引入
################################
sudo touch /etc/ssh/sshd_config.d/sftp.conf
su
cat > /etc/ssh/sshd_config.d/sftp.conf << EOF
Match User sftpuser
    ForceCommand internal-sftp
    PasswordAuthentication yes
    ChrootDirectory /var/sftp
    PermitTunnel no
    AllowAgentForwarding no
    AllowTcpForwarding no
    X11Forwarding no
EOF

################################
su helq
sudo sshd -t # 测试
sudo systemctl restart sshd     # 重启或重新加载 SSH 服务
# 到 其他机器上 : 
# 验证ssh是否关闭
ssh sftpuser@your_server_ip     # 会收到 This service allows sftp connections only.表示连接失败,无法再使用 SSH 访问 shell
# 验证sftp是否开启
sftp sftpuser@your_server_ip    # 此命令将生成带有交互式提示的成功登录消息;可以在提示符中使用`ls`列出目录内容
############## 或者可以通过 sftp客户端界面(Cyberduck或FileZilla等) 连接访问

# Match User sftpuser            告诉 SSH 服务器仅将以下命令应用于指定的用户
# ForceCommand internal-sftp     强制 SSH 服务器在登录时运行 SFTP 服务器，确保其只能上传/下载文件,禁止 shell 登录访问。
# PasswordAuthentication yes     允许该用户进行密码验证;不然可能需要用户使用基于密钥的验证
# ChrootDirectory /var/sftp/     确保不允许用户访问/var/sftp目录之外的任何内容,/var/sftp 必须由 root 拥有，且不可被其他用户写入,在 /var/sftp 内，可以创建用户有写权限的子目录，如 /var/sftp/sftpuser
# PermitTunnel                   禁止 SSH 隧道功能,提高安全性，防止用户滥用隧道功能绕过网络限制
# AllowAgentForwarding           禁止 SSH 代理转发功能,端口转发、隧道和 X11 转发,进一步限制用户的功能，防止代理滥用
# AllowTcpForwarding             禁止 TCP 转发功能,防止用户通过 SSH 隧道代理访问内部网络或外部服务器
# X11Forwarding                  禁止 X11 图形界面转发,减少不必要的功能支持，提高安全性
# 这组命令从Match User开始，也可以为不同的用户复制和重复。确保相应地修改Match User行中的用户名

Copied!

d 、开启 ftp 服务

sudo apt update && sudo apt install vsftpd         # 默认应该都是没有安装的
# 开放端口;为 FTP 打开端口`20`和`21`;在启用 TLS 时打开端口`990`; pasv_max_port pasv_min_port 限制可用于被动 FTP 的端口范围40000到50000
sudo ufw status
sudo ufw allow from any to any port 20,21,990,40000:50000 proto tcp
sudo ufw status

# 创建只用于 ftp 的用户;不允许登录shell
# chroot_local_user=YES时, ftp要求用户要有home目录,并且home目录不可写
sudo useradd -s /sbin/nologin -d /var/ftp ftpuser      # -m 会创建home目录; -d <path> 自定义home目录
sudo sh -c 'echo "/sbin/nologin" >> /etc/shells'       # ftp会检查登录的用户的shell是否正常; 这里让 /sbin/nologin 变为有效的登录 shell
sudo mkdir -p /var/ftp/ftpuser
sudo chmod 555 /var/ftp                          # 让home目录不可写; 4:读 2:写 1:执行
sudo chown nobody:nogroup /var/ftp               # 限制权限，确保进程或服务无法访问不必要的系统资源
sudo passwd ftpuser                              # 添加密码    123456          
sudo chown ftpuser:ftpuser /var/ftp/ftpuser    # 将目录的所有权更改为您刚刚创建的用户
sudo chmod 775 /var/ftp/ftpuser          # 同组用户可以读和写(目录必须有执行权限才能cd进入);其他用户只读
sudo usermod -aG ftpuser $(whoami)  # 把当前用户加入 ftpuser 用户组,让当前用户可以操作`分享目录`,就让当前用户可以将自己的文件复制到这个`分享目录中`了
getent group ftpuser   # 查看用户组中有哪些用户
sudo useradd -r -M -s /sbin/nologin ftpsecure   # 创建一个供nopriv_user使用的低权限用户
# 权限组生效要重新登录

sudo cp /etc/vsftpd.conf /etc/vsftpd.conf.bak     # 备份原始文件
su
####################################################################
cat > /etc/vsftpd.conf << EOF
# NO: 表示 vsftpd 不会以独立的守护进程方式运行;用于资源受限的系统; 因为 inetd 或 xinetd 在没有连接时不会启动 FTP 服务,从而减少资源占用
# 当 listen=YES 时,vsftpd 只会在 IPv4 地址 上启动并监听 FTP 连接, listen_ipv6就必须为 NO
listen=YES

# 启用对 IPv6 的支持,同时接受来自 IPv4 和 IPv6 的连接
listen_ipv6=NO

# 允许系统中的本地用户使用 FTP 登录
local_enable=YES

# 启用此选项后,所有本地用户在登录时将被限制在他们的HOME目录内,他们无法访问其他系统目录
chroot_local_user=YES
# 用于指定哪些本地用户可以不受 chroot_local_user 功能限制;可以在 chroot_list_file 中列出特定用户
# chroot_list_enable=YES
# chroot_list_file=/etc/vsftpd.chroot_list

# 允许用户使用写操作; 如 上传文件 删除文件
write_enable=YES

# 实际权限 = 默认权限(文件的默认权限是666; 目录的默认权限是777) - umask
local_umask=022

# 每当用户切换到某个目录时,vsftpd 会检查该目录下是否存在一个名为 .message 的文件;如果 .message 文件存在,其内容会显示给用户,作为该目录的欢迎消息或说明
dirmessage_enable=YES

# 目录列表(例如 ls 命令)中的时间戳将显示为服务器本地时区时间
use_localtime=YES

# 启用上传和下载操作的日志记录功能;默认在/var/log/vsftpd.log; 可由选项xferlog_file自定义
xferlog_enable=YES
# 用于指定 vsftpd 的日志文件位置
# xferlog_file=/var/log/vsftpd.log
# 如果启用此选项,日志将采用标准 xferlog 格式,通常与传统 FTP 服务的日志格式兼容;日志文件的默认存储路径会更改为 /var/log/xferlog
# xferlog_std_format=YES

# 指定 FTP 数据连接的来源端口为 20;(21 端口:用于控制连接;接收用户命令并返回响应)
connect_from_port_20=YES

# 默认开启被动模式;需要服务端开放40000-50000的端口,所以对客户端的防火墙很友好
pasv_enable=YES
pasv_min_port=40000
pasv_max_port=50000

# 设置空闲会话的超时时间,单位为秒;如果客户端在此期间没有任何活动(如上传、下载、浏览目录等),则服务器会自动关闭该会话
idle_session_timeout=3600

# 设置数据连接的超时时间,单位为秒;指定了 vsftpd 等待数据连接(例如文件上传、下载等)时的最大空闲时间;如果在这个时间内没有数据传输,连接会被断开
data_connection_timeout=600

# 当 vsftpd 需要执行与 FTP 客户端相关的非特权操作时,它会以 nopriv_user 的身份运行子进程或线程,可以有效地减少可能的安全漏洞
nopriv_user=ftpsecure

# 自定义的登录横幅信息
ftpd_banner=Welcome to blah FTP service.


# 禁用匿名登录,只有本地用户可以登录
anonymous_enable=NO
# 禁止匿名用户上传文件
anon_upload_enable=NO
# 禁止匿名用户创建目录
anon_mkdir_write_enable=NO
# 控制匿名用户上传的文件的所有权设置;用于加强安全性和便于管理;默认情况下,匿名用户上传的文件的所有者是 ftp 或 nobody;通过启用此选项,可以将文件的所有者更改为指定的用户
# chown_uploads=YES
# chown_username=whoever

# 指定一个空目录,作为 vsftpd 的 chroot() 监狱;chroot() 是一个将进程及其子进程的根目录改为指定目录的系统调用。
# 在 vsftpd 中,使用 chroot() 可以将某些用户限制在某个目录（或目录树）中,使得这些用户无法访问系统的其他部分
# 当 FTP 用户登录时,通常会被限制在他们的家目录内。如果启用了 chroot_local_user 或其他类似设置,FTP 用户将无法访问他们家目录以外的文件和目录
# 该目录并不是为用户上传和下载文件的目录,而是用于保护和增强安全性。在一些特定情况下,vsftpd 会切换到该目录,并限制其对文件系统的访问
secure_chroot_dir=/var/run/vsftpd/empty

# 告诉 vsftpd 在进行用户登录认证时,使用 PAM(可插拔认证模块)来进行验证;简单来说,它指定了 FTP 服务器在验证用户身份时,应该使用什么样的认证规则
# PAM 就是一个管理系统登录、密码验证等认证工作的工具;vsftpd 需要验证用户是否能登录,pam_service_name=vsftpd 就是告诉它：在验证时,去找一个专门为 vsftpd 配置的认证规则文件,通常这个文件叫 vsftpd,会放在 /etc/pam.d/ 文件夹里
pam_service_name=vsftpd

# 是否开启 FTPS
rsa_cert_file=/etc/ssl/certs/ssl-cert-snakeoil.pem
rsa_private_key_file=/etc/ssl/private/ssl-cert-snakeoil.key
ssl_enable=NO

# 使用 UTF-8 编码的文件系统
utf8_filesystem=YES

# FTP 服务器将异步处理 ABOR 请求,提高处理效率,但可能存在安全风险
# async_abor_enable=YES

# 专门用于文本文件,启用该选项后,FTP 服务器会在上传/下载文件时进行 ASCII 处理(即转换换行符),可能会增加 CPU 负担和安全隐患
# ascii_upload_enable=YES
# ascii_download_enable=YES

# 启用此选项后,vsftpd 将检查匿名 FTP 用户的电子邮件地址,如果该地址在禁止列表中,用户将无法登录
# deny_email_enable=YES
# 这是存储被禁止的电子邮件地址列表的文件。vsftpd 会检查该文件中的电子邮件地址,并阻止这些地址的匿名用户登录。每行一个电子邮件地址
# banned_email_file=/etc/vsftpd.banned_emails

# 用户使用 ls 命令时,FTP 服务器会列出当前目录及其所有子目录的内容,出于性能考虑,最好保持默认的禁用状态
# ls_recurse_enable=YES
EOF

#####################################################################

sudo systemctl restart vsftpd

Copied!

e、minio

mkdir -p ~/software/minio/share
sudo ufw allow from any to any port 19000,19001 proto tcp

docker run -d -p 19000:9000 -p 19001:9001 \
  -v ~/software/minio/share:/data \
  quay.io/minio/minio server /data --console-address ":9001"

http://ip:19001    minioadmin:minioadmin

Copied!

四、可选

a、pipx

# 可选 pipx 专门下载python命令行工具 到隔离环境的,用哪个用户下载的就在哪个用户目录下的 ~/.local/bin 中; 除非加了--global 会安装在全局的地方,但是版本低不支持
sudo apt update
sudo apt install pipx
pipx ensurepath # 就是设置环境变量中的 $PATH:~/.local/bin
sudo pipx ensurepath --global # apt的版本太低不支持
pipx install trash-cli # 安装最新版本,但是默认只能一个用户使用
pipx list
pipx uninstall-all
pipx completions # 查看补全说明

Copied!

b、clash

##################### clash代理 ########################################################
mkdir -p cd /usr/local/clash-arm64
cd /usr/local/clash-arm64
ls
clash-linux-arm64-v1.18.0.gz  config.yaml  Country.mmdb
>>>>>>>
gunzip clash-linux-arm64-v1.18.0.gz 
mv clash-linux-arm64-v1.18.0 clash
chmod +x clash
sudo mkdir /etc/clash
sudo cp clash /usr/local/bin
sudo cp config.yaml /etc/clash/
sudo cp Country.mmdb /etc/clash/
ls /etc/clash/

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
sudo vim /etc/systemd/system/clash.service

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

[Unit]
Description=Clash daemon, A rule-based proxy in Go.
After=network.target

[Service]
Type=simple
Restart=always
ExecStart=/usr/local/bin/clash -d /etc/clash

[Install]
WantedBy=multi-user.target

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
sudo systemctl stop clash
sudo systemctl enable clash
sudo systemctl start clash
sudo systemctl disable clash
sudo systemctl status clash
export http_proxy=http://127.0.0.1:25307 && export https_proxy=http://127.0.0.1:25307 && export all_proxy=socks5://127.0.0.1:25307
curl https://www.google.com
curl https://github.com
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
mkdir -p /usr/local/my-functions/ && cd /usr/local/my-functions/

echo "source /usr/local/my-functions/debian_proxy" >> /home/helq/.bashrc
echo "source /usr/local/my-functions/debian_proxy" >> /root/.bashrc

echo "alias ll='ls -l'" >> /home/helq/.bashrc
echo "alias ll='ls -l'" >> /root/.bashrc
cd ..
#重新连接
sudo systemctl status clash
getproxy
setproxy term
getproxy
curl https://www.google.com

#####################################

Copied!

c、卸载 apache2

apt list apache
which -a apache2
ls /usr/sbin/apache2


systemctl disable apache2.service #禁止自启动
apt-get --purge remove apache2 -y
sudo apt autoremove -y

Copied!

五、后续更新

# 安装 fastfetchmkdir -p "$HOME/software/fastfetch"  
wget -P "$HOME/software/fastfetch" https://github.com/fastfetch-cli/fastfetch/releases/download/2.31.0/fastfetch-linux-aarch64.deb  
sudo apt update  
sudo dpkg -i "$HOME/software/fastfetch/fastfetch-linux-aarch64.deb"  
fastfetch --version  
which -a fastfetch  
git -C "$HOME/Data/Config" pull  
  
# ssh 连接时,不要打印 系统版本和版权信息  
touch "$HOME/.hushlogin"  
  
# ffmpeg 安装  
sudo apt install ffmpeg  
# 下载 m3u8 视频  
ffmpeg -i "https://aa.ww.bb/mixed.m3u8" -c copy -bsf:a aac_adtstoasc output.mp4

Copied!

Vim使用教程

Mon, 03 Jun 2024 03:49:51 +0800

操作备忘录

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" 操作备忘录
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" 0、vim -u NONE <file> , 不加载vimrc的配置打开vim, 测试干净环境下的vim
" 1、删除（不剪切），不将其剪切内容放入默认寄存器，而是直接丢进黑洞寄存器
" <press==> "_dd
" 2、放到无名寄存器(")(vim默认的),在vim默认寄存器为系统剪切板时有用,不复制到系统剪切板,但是还能通过""p找回
" <press==> ""dd
" 3、删除并进入插入模式: s===cl===dli
" 4、* : 向后搜索光标所在的单词并居中显示结果; # : 向前搜索光标所在的单词并居中显示结果
" 5、插入模式,<Ctrl-o>,临时执行一个普通模式命令，然后自动返回插入模式
" 6、gv 重选上次的选区
" 7、J 将多行合并为一行,行与行之间会加空格; gJ  将多行合并为一行，行与行之间不加空格
" 8、在一些情况下,normal模式使用不了,如:tab terminal ; 可以用: <C-w>N 或者 <C-\><C-n> 切回normal模式
" 9、插入上一次插入的文本(i文本`esc`a`C-a`)
" 10、用<.>键可以重复上次的命令(编辑)
" 11、选区上下移动 :<C-u>'<,'>m '>+1<CR>gv   整体向下移动一行;   :<C-u>'<,'>m '<-2<CR>gv   整体向上移动一行
" 12、g' g` 标签跳转时的反引号和引号命令,前面加上g,可以不改变jumplist,即不改变跳转列表的顺序和位置
" 13、:h[elp] cursorcolumn 查看文档; :set cursorcolumn? 查看当前环境的某项配置的值
" 14、:verbose set cursorcolumn? 查看当前环境的某项配置的值,更详细,看到是在哪里被定义修改的
" 15、:map <C-c>  :imap <C-c> :verbose map <C-c>  :verbose imap <C-c>  查看按键映射;
" 16、:echo hasmapto('<Plug>Sneak_S', 'v')  执行某个函数并打印值,hasmapto是vim自带的检查映射的函数;
" 17、:call fun()  执行某个函数
"""""""""""""""""" 代码折叠命令： ( close==创建折叠 )!= (open==展开折叠)
"       za         切换当前光标下的折叠的状态(open或close) == zc+zo
"       zA         递归切换当前折叠及其嵌套折叠的状态 == zC+zO
"       zr         减少折叠级别
"       zm         增加折叠级别
"       zj         定位到下一个折叠处
"       zk         定位到上一个折叠处
"
"       zc         创建一个光标下的折叠(close)(从内向外)
"       zC         递归创建折叠及嵌套折叠(从内向外)
"       zo         展开一个光标下的折叠(open)(从外向内)
"       zO         递归打开当前折叠及其嵌套折叠,大写的字母O (从外向内)
"       zf         对所指定的文本范围进行折叠,只支持manual和marker

"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
"                                  宏命令
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
"-----------------{{{-----------------
" A. 常规使用宏的流程：
"   1. q 进入宏录制 + 寄存器字母(a-z)
"   2. 录制宏内容
"   3. q 退出宏录制
"   4. @a-z 使用字母指定的宏
"   5. @@ 重复最近使用过宏
" -------------------------------------------------------------------------------

Copied!

重复的威力

1
2

.                   # 小数点，即重复（Dot）命令，重复执行上一次命令
N{command}          # 重复某个命令 N 次，例如：10k，光标上移 10 行

Copied!

善用宏和正则表达式，同样可以达到减少重复操作的目的。

normal模式下键入5a文本<ESC> 会插入5次文本

光标移动

注意：普通（Normal）模式下，任意一个动作都可以重复。

                    # -------------------- 单位级移动 -------------------- 
h                   # 光标左移，等价于 <Left> 方向键（h 键位于左边，按该键光标左移）
j                   # 光标下移，等价于 <Down> 方向键（j 键有向下的突起，按该键光标下移）
k                   # 光标上移，等价于 <Up> 方向键 （k 键与 j 键相反，按该键光标上移）
l                   # 光标右移，等价于 <Right> 方向键（l 键位于右边，按下该键光标向右移动）
                    # -------------------- 单词级移动 --------------------
w                   # 移动到下一个标点或空格分隔的单词开头（w: word）
W                   # 移动到下一个空格分隔的单词开头（W: Word）
e                   # 移动到下一个标点或空格分隔的单词尾部（e: end）
E                   # 移动到下一个空格分隔的单词尾部（E: End）
b                   # 移动到上一个标点或空格分隔的单词开头（b: backward）
B                   # 移动到上一个空格分隔的单词开头（B: Backward）
                    # -------------------- 块级移动 ----------------------
0                   # 跳到行首，数字 0，等价于 <Home> 起始键
^                   # 跳到行首非空字符，可以使用 0w 代替 ^，按键更方便
$                   # 跳到行尾，等价于 <End> 结尾键
ge                  # 向后移动到单词词尾
gE                  # 向后移动到空白隔开的单词词尾
gg                  # 跳到第一行，等价于 Ctrl+<Home>
G                   # 跳到最后一行，等价于 Ctrl+<End>
[N]G                # 跳到第 N 行，例如 10G 是移动到第 10 行
:N                  # 跳到第 N 行，例如 :10<Enter> 是移动到第 10 行
N|                  # 移动到当前行的 N 列
{count}%            # 移动到文件百分之 {count} 的位置，例如 10% 是移动到文件 10% 的位置
<Enter>             # 移动到下一行首个非空字符
N<Enter>            # 光标向下移动 N 行

# 句子的结尾是由句号 (.)、问号 (?) 或感叹号 (!) 后跟一个或多个空格、制表符或换行符标识的;没有分隔符时,不会拆分成不同的句子

)                   # 移动到下一个句子的开头
(                   # 移动到[上一个句子/这个句子] 的开头  
}                   # 移动到下一个段落（空行分隔）
{                   # 移动到上一个段落（空行分隔）
+                   # 移动到下一行首个非空字符，等价于 <Enter> 回车键
-                   # 移动到上一行首个非空字符
H                   # 移动到屏幕上部（H: High）
M                   # 移动到屏幕中部（M: Middle）
L                   # 移动到屏幕下部（L: Low）
gm                  # 移动到的行中间
gj                  # 光标向下移动一个屏幕行，非实际行，忽略自动换行
gk                  # 光标向上移动一个屏幕行，非实际行，忽略自动换行
<S+Up>              # 按住 <Shift> 上档键再按 <Up> 方向键，向上翻页
<S+Down>            # 按住 <Shift> 上档键再按 <Down> 方向键，向下翻页
<S+Left>            # 按住 <Shift> 上档键再按 <Left> 方向键，向左移动一个单词
<S+Right>           # 按住 <Shift> 上档键再按 <Right> 方向键，向右移动一个单词
:ju[mps]            # 输出所有跳转
:cle[arjumps]       # 清除所有跳转
                    # -------------------- 翻屏移动 ----------------------
zz                  # 调整光标所在行到屏幕中央
zt                  # 调整光标所在行到屏幕上部
zb                  # 调整光标所在行到屏幕下部
Ctrl+e              # 向上滚动一行（e: extra line）
Ctrl+y              # 向下滚动一行
Ctrl+u              # 向上滚动半屏（Move up 1/2 a screen）
Ctrl+d              # 向下滚动半屏（Move down 1/2 a screen）
Ctrl+f              # 向下滚动一屏（Move forward one full screen）
Ctrl+b              # 向上滚动一屏（Move back one full screen）
                    # -------------------- 编程辅助移动 ------------------
%                   # 不仅匹配跳转到对应的 {} () []，而且能在 if、else、elseif 之间跳跃
gd                  # 跳转到局部变量定义处，即光标下的单词的定义
gD                  # 跳转到全局变量定义处，即光标下的单词的定义
gf                  # 打开名称为光标下文件名的文件
[m                  # 跳转到上一个成员函数开头(光标移动到{那里)
]m                  # 跳转到下一个成员函数开头(光标移动到{那里)
]M                  # 跳转到下一个成员函数结尾(光标移动到}那里)
[M                  # 跳转到上一个成员函数结尾(光标移动到}那里)
[{                  # 跳转到上一处未匹配的 {,从代码块内部向外找{ ,平级的不会找 下面3个同理
]}                  # 跳转到下一处未匹配的 },从代码块内部向外找}
[(                  # 跳转到上一处未匹配的 (,从代码块内部向外找(
])                  # 跳转到下一处未匹配的 ),从代码块内部向外找)
[c                  # 跳转到上一个不同处（diff 时）
]c                  # 跳转到下一个不同处（diff 时）
[[                  # 跳转到上一个行首是{的那一行  
]]                  # 跳转到下一个行首是{的那一行,这两个都没啥用  
[]                  # 跳转到上一个行首是}的那一行  
][                  # 跳转到下一个行首是}的那一行
########## 自定义: #################
# ]]  跳转到下一个{
# [[  跳转到上一个{
# ][  跳转到下一个},]开头都是下一个
# []  跳转到上一个},[开头都是上一个
##################################

[/                  # 跳转到当前/上一个注释块(/*)开始处
[*                  # 同上
]/                  # 跳转到当前/下一个注释块(*/)结尾处
]*                  # 同上

]#                  # 跳转到下一个 #if 或者 #else 处,只在C语言里有用
[#                  # 跳转到上一个 #else 或者 #endif 处,只在C语言里有用

/pattern            # 从光标处向文件尾搜索 pattern
?pattern            # 从光标处向文件头搜索 pattern
n                   # 向同一方向执行上一次搜索
N                   # 向相反方向执行上一次搜索
%                   # 匹配括号移动，包括 ()，{}，[]。结合以下两个命令相当强大。前提：需要把光标先移到括号上
*                   # 向后搜索光标所在的单词
#                   # 向前搜索光标所在的单词
<Shift>*            # 搜索光标所在位置的字符串，不用输入字符串，查询速度比 /pattern 快
f{char}             # 向后搜索当前行第一个为 {char} 的字符，Nfv 可以找到第 N 个为 v 字符，下同（f: find）
F{char}             # 向前搜索当前行第一个为 {char} 的字符
t{char}             # 向后搜索当前行第一个为 {char} 的字符前（t: to）
T{char}             # 向前搜索当前行第一个为 {char} 的字符前
;                   # 重复上次的字符查找命令（f/t 命令）
,                   # 反转方向查找上次的字符查找命令（f/t 命令）
tx                  # 搜索当前行到指定 字符串 之前
fx                  # 搜索当前行到指定 字符串 之处
<Esc>               # 放弃查找。例如，启动了 f 命令后发现想用的是 F 命令，<Esc> 退出键放弃查找

Copied!

注意：块级移动要善于使用 Vim 的书签和标签页功能，实现文件内容及文件之间快速移动。

插入模式

i                   # 在光标处进入插入模式（i: insert）
I                   # 在行首进入插入模式
a                   # 在光标后进入插入模式（a: append）
A                   # 在行尾进入插入模式
o                   # 在下一行插入新行并进入插入模式
O                   # 在上一行插入新行并进入插入模式
s                   # 删除光标所在的字符并进入插入模式
S                   # 删除当前行并插入文本 
gi                  # 进入到上一次插入模式的位置
gI                  # 在当前行第 1 列插入
<Esc>               # 退出插入模式
Ctrl+[              # 退出插入模式，等价于 <Esc> 退出键
Ctrl+C              # 退出插入模式，等价于 <Esc> 和 Ctrl+[，但不检查缩写

Copied!

插入模式的命令

注意：由 i, I, a, A, o, O, s, S 等命令进入插入模式。

<Up>                # 光标向上移动
<Down>              # 光标向下移动
<Left>              # 光标向左移动
<Right>             # 光标向右移动
<S+Up>              # 按住 <Shift> 上档键再按 <Up> 方向键，向上翻页
<S+Down>            # 按住 <Shift> 上档键再按 <Down> 方向键，向下翻页
<S+Left>            # 按住 <Shift> 上档键再按 <Left> 方向键，向左移动一个单词
<S+Right>           # 按住 <Shift> 上档键再按 <Right> 方向键，向右移动一个单词
<PageUp>            # 向上翻页，<PageUp> 是向上翻页键
<PageDown>          # 向下翻页，<PageDown> 是向下翻页键
<Delete>            # 删除光标处字符，<Delete> 是删除键
<Backspace>         # 退格键 <Backspace> 向后删除字符
<Home>              # 光标跳转行首
<End>               # 光标跳转行尾
Ctrl+d              # 减少缩进光标所在行
Ctrl+f              # 自动缩进光标所在行（相当于普通模式下的 `==` ）
Ctrl+t              # 增加缩进光标所在行
Ctrl+h              # 删除前一个字符，等价于 <Backspace> 退格键
Ctrl+o              # 临时退出插入模式，执行单条命令又返回插入模式
Ctrl+u              # 当前行删除到行首所有字符
Ctrl+w              # 删除光标前的一个单词
Ctrl+\ Ctrl+O       # 临时退出插入模式（光标保持），执行单条命令又返回插入模式
Ctrl+R 0            # 插入寄存器（内部 0 号剪贴板）内容，Ctrl+R 后可跟寄存器名
Ctrl+R "            # 插入匿名寄存器内容，相当于插入模式下 p 粘贴
Ctrl+R =            # 插入表达式计算结果，等号后面跟表达式
Ctrl+R :            # 插入上一次命令行命令
Ctrl+R /            # 插入上一次搜索的关键字
Ctrl+v {char}       # 插入非数字的字面量
Ctrl+v {code}       # 插入用三位数字表示的 ASCII/Unicode 字符编码，例如 Ctrl+v 065
Ctrl+v 065          # 插入 10 进制 ASCII 字符（两数字） 065 即 A 字符
Ctrl+v x41          # 插入 16 进制 ASCII 字符（三数字） x41 即 A 字符
Ctrl+v o101         # 插入 8 进制 ASCII 字符（三数字） o101 即 A 字符
Ctrl+v u1234        # 插入 16 进制 Unicode 字符（四数字）
Ctrl+v U12345678    # 插入 16 进制 Unicode 字符（八数字）
Ctrl+K {ch1} {ch2}  # 插入 digraph（见 :h digraph），快速输入日文或符号等

Copied!

自动补全

Ctrl+n              # 插入模式下文字自动补全，最常用的补全
Ctrl+P              # 插入模式下文字自动补全
Ctrl+e              # 有补全列表时，终止这次补全，继续输入

Ctrl+X              # 进入补全模式，注意：智能补全命令均以组合键 Ctrl+X 作为起始操作，下同
Ctrl+X Ctrl+L       # 补全整行
Ctrl+X Ctrl+N       # 插入模式下根据当前缓冲区关键字补全
Ctrl+X Ctrl+K       # 根据字典补全
Ctrl+X Ctrl+T       # 根据同义词字典补全
Ctrl+X Ctrl+F       # 插入模式下补全文件名
Ctrl+X Ctrl+I       # 根据头文件内关键字补全
Ctrl+X Ctrl+]       # 标签文件关键词补全
Ctrl+X Ctrl+D       # 补全宏定义
Ctrl+X Ctrl+V       # 补全 Vim 命令
Ctrl+X Ctrl+U       # 用户自定义补全方式
Ctrl+X Ctrl+S       # 拼写建议，例如：一个英文单词
Ctrl+X Ctrl+O       # 插入模式下全能 Omnifunc 补全

Copied!

文本编辑

r                   # 替换当前字符（r: replace）
R                   # 进入替换模式，直至按 <Esc> 退出键离开
[N]s                # 替换 N 个字符，即删除光标后 N 个字符并进入插入模式
[N]S                # 替换 N 行，即删除 N 行并进入插入模式
[N]x                # 剪切、删除光标右边 N 个字符，相当于d[N]l
[n]X                # 剪切、删除光标左边 N 个字符，相当于d[n]h

cc                  # 改写当前行，即删除当前行并进入插入模式，等价于 S
cw                  # 改写光标开始处的当前单词
ciw                 # 改写光标所处的单词
caw                 # 改写光标所处的单词，并且包括前后空格
c0                  # 改写到行首
c^                  # 改写到行首非空字符
c$                  # 改写到行末
C                   # 改写到行尾，等价于 c$
ci"                 # 改写双引号中的内容，i 的含义下同（i: inner）
ci'                 # 改写单引号中的内容
cib                 # 改写小括号中的内容
cab                 # 改写小括号中的内容，包含小括号本身
ci)                 # 改写小括号中的内容
ci]                 # 改写中括号中内容
ciB                 # 改写大括号中内容
caB                 # 改写大括号中的内容，包含大括号本身
ci}                 # 改写大括号中内容
cit                 # 改写 XML 中 tag 的内容
cis                 # 改写当前句子
c[N]w               # 改写光标后 N 个单词
c[N]l               # 改写光标后 N 个字母
c[N]h               # 改写光标前 N 个字母
[N]cc               # 修改当前 N 行
ct(                 # 改写到小括号前

dd                  # 删除（剪切）当前行，当前行会存到寄存器里（d: delete = cut）
dd[N]p              # 删除（剪切）当前行并加入 N-1 个当前行，复制空行时很有用
d0                  # 删除（剪切）到行首
d^                  # 删除（剪切）到行首非零字符
d$                  # 删除（剪切）到行末
D                   # 删除（剪切）到行末，等价于 d$
dw                  # 删除（剪切）当前单词
diw                 # 删除（剪切）光标所处的单词（iw: inner word）
daw                 # 删除（剪切）光标所处的单词，并包含前后空格
d2w                 # 删除（剪切）下 2 个单词
d[N]w               # 删除（剪切）N 个单词，并包含前后空格
d[N]l               # 删除（剪切）光标右边 N 个字符
d[N]h               # 删除（剪切）光标左边 N 个字符
[N]dd               # 删除（剪切）从当前行开始的 N 行
:Nd                 # 删除（剪切）第 N 行
:N,Md<CR>           # 删除（剪切） N ~ M 行，其中 <CR> 为 <Enter> 回车键
di"                 # 删除（剪切）双引号中的内容
di'                 # 删除（剪切）单引号中的内容
dib                 # 删除（剪切）小括号中的内容
di)                 # 删除（剪切）小括号中的内容
dab                 # 删除（剪切）小括号内的内容，包含小括号本身
di]                 # 删除（剪切）中括号中内容
diB                 # 删除（剪切）大括号中内容
di}                 # 删除（剪切）大括号中内容
daB                 # 删除（剪切）大括号内的内容，包含大括号本身
dit                 # 删除（剪切） XML 中 tag 的内容
dis                 # 删除（剪切）当前句子
dt(                 # 删除（剪切）到小括号前
dgg                 # 删除（剪切）到文件头部
d1G                 # 删除（剪切）到文件头部，同上
dG                  # 删除（剪切）到文件尾部
d}                  # 删除（剪切）下一个段落
d{                  # 删除（剪切）上一个段落
d/f<CR>             # 比较高级的组合命令，它将删除 当前位置 到下一个字母 f 之间的内容，其中 <CR> 为 <Enter> 回车键

~                   # 转换大小写
g~iw                # 替换当前单词的大小写
gUiw                # 将单词转成大写
guiw                # 将当前单词转成小写
guu                 # 全行转为小写
gUU                 # 全行转为大写
Ctrl+A              # 增加数字
Ctrl+X              # 减少数字

Copied!

文本对象

注意：只适用于可视模式或在操作符后，例如：操作包括 选择 v、删除 d、复制 y、修改 c 等。

aw                  # 操作整个单词，不包括分隔符（aw: a word）
aW                  # 操作整个单词，包括分隔符（aW: a Word）
iw                  # 操作整个单词，不包括分隔符（iw: inner word）
iW                  # 操作整个单词，包括分隔符（iW: inner Word）
is                  # 操作整个句子，不包括分隔符 (s: sentence）
ib                  # 操作内含块，从 [( 到 ])（b: block）
iB                  # 操作内含大块，从 [{ 到 ]} （B: Block）
ab                  # 操作一个块，从 [( 至 ])（b: block）
aB                  # 操作一个大块，从 [{ 到 ]}（B: Block）
ap                  # 操作一个段落（p: paragraph）
ip                  # 操作内含段落
i)                  # 操作小括号字符串
a)                  # 操作小括号字符串，包含小括号本身
i]                  # 操作中括号字符串
a]                  # 操作中括号字符串，包含中括号本身
i}                  # 操作大括号字符串
a}                  # 操作大括号字符串，包含大括号本身
i'                  # 操作单引号字符串
a'                  # 操作单引号字符串，包含单引号本身
i"                  # 操作双引号字符串
a"                  # 操作双引号字符串，包含双引号本身
a`                  # 操作一个反引号字符串
i`                  # 操作内含反引号字符串
a>                  # 操作一个 <> 块
i>                  # 操作内含 <> 块
at                  # 操作一个标签块，例如 从 <aaa> 到 </aaa>（t: tag）
it                  # 操作内含标签块，例如 从 <aaa> 到 </aaa>
2i)                 # 操作往外两层小括号内
2a)                 # 操作往外两层小括号内，包含小括号本身
[N]f)               # 移动到第 N 个小括号处
[N]t)               # 移动到第 N 个小括号前

Copied!

文本对象的配对括号、标点及配对标点内的内容的编辑修改对编程非常实用，可以简单总结为。

ci'、ci"、ci(、ci[、ci{、ci<                # 分别修改这些配对标点符号中的文本内容
ca'、ca"、ca(、ca[、ca{、ca<                # 分别修改这些配对标点符号中的文本内容，包括 标点符号 本身
di'、di"、di(、dib、di[、di{、diB、di<       # 分别删除这些配对标点符号中的文本内容
da'、da"、da(、dab、da[、da{、daB、da<       # 分别删除这些配对标点符号中的文本内容，包括 标点符号 本身
yi'、yi"、yi(、yi[、yi{、yi<                # 分别复制这些配对标点符号中的文本内容
ya'、ya"、ya(、ya[、ya{、ya<                # 分别复制这些配对标点符号中的文本内容，包括 标点符号 本身
vi'、vi"、vi(、vi[、vi{、vi<                # 分别选中这些配对标点符号中的文本内容
va'、va"、va(、va[、va{、va<                # 分别选中这些配对标点符号中的文本内容，包括 标点符号 本身

Copied!

移动文本

移动文本命令格式。

`1`	`:[range]m[ove]{address}`

Copied!

参数说明：

[range]：表示要移动的行范围。
{address}：表示移动的目标位置，这两个参数都可以缺省。

例如：

:m+1                # 下移 1 行
:m-2                # 上移 1 行
:8,10m2             # 把当前打开文件的第 8~10 行内容移动到第 2 行下方
:8,10m+2             # 把当前打开文件的第 8~10 行内容移动到光标下面第 2 行下方
## 选区上下移动 
:<C-u>'<,'>m '>+1<CR>gv   # 整体向下移动一行;   
:<C-u>'<,'>m '<-2<CR>gv   # 整体向上移动一行

Copied!

文字排版

[N]>>                     # 向右缩进 N 行，单位为 shiftwidth
[N]<<                     # 向左缩进 N 行，单位为 shiftwidth
:ce[nter]                 # 本行文字居中
:le[ft]                   # 本行文字靠左
:ri[ght]                  # 本行文字靠右
:[range]ce[nter] [width]  # 在 range 范围行的文字居中
:[range]le[ft] [indent]   # 在 range 范围行的行文字靠左
:[range]ri[ght] [width]   # 在 range 范围行的行文字靠右
gq                        # 对选中的文字重排，即对过长文字进行断行
gqq                       # 重排当前行
gq[N]q                    # 重排 N 行
gqap                      # 重排当前段落
gq[N]ap                   # 重排 N 个段落
gq[N]j                    # 重排当前行和下面 N 行
gqQ                       # 重排当前段落到文章末尾
J                         # 将多行合并为一行,行与行之间会加空格
gJ                        # 将多行合并为一行，行与行之间不加空格
==                        # 自动缩进，当前文件所有行自动缩进对齐使用 gg=G

Copied!

复制粘贴

复制命令的格式。

`1`	`:[range]co[py]{address}`

Copied!

参数说明：

[range]：表示要复制的行范围，其中 copy 可缩写为 :co 或 :t。
{address}：表示复制的目标位置，这两个参数都可以缺省，用于表示 Vim 光标所在当前行。

例如：

:3copy.             # 复制文件的第 3 行到当前行（当前行用 . 表示）
:3,5t.              # 把第 3 行到第 5 行的内容复制到当前行下方
:t5                 # 把当前行复制到第 5 行下方
:t.                 # 复制当前行到当前行下方，等价于普通模式下的 yyp
:t$                 # 把当前行复制到文本结尾
:'<,'>t0            # 把高亮选中的行复制到文件开头

Copied!

常用复制粘贴命令。

p                   # 粘贴到光标后（p: paste）
P                   # 粘贴到光标前
y                   # 复制标记内容
y0                  # 复制当前光标位置到行首的内容
y$                  # 复制当前位置到本行结束的内容
yy                  # 复制当前行（Yank (copy) a line ）
Y                   # 复制当前行，等价于 yy
yiw                 # 复制当前单词
y[N]w               # 复制 N 个单词
y[N]s               # 复制 N 个句子
[N]yy               # 复制光标下 N 行内容
ygg                 # 复制光标以上的所有行
y1G                 # 复制光标以上的所有行，同上
yG                  # 复制光标以下的所有行
yypVr{char}         # 复制字符并替换为等长指定字符，Markdown 编辑时尤为好用
:[range]y           # 复制范围，例如 :20,30y 是复制 20 到 30 行，:10y 是复制第 10 行
:[range]d           # 删除范围，例如 :20,30d 是删除（剪切） 20 到 30 行，:10d 是删除（剪切）第 10 行
"_[command]         # 使用 [command] 删除内容，并且不进行复制（不会污染寄存器）
"*[command]         # 使用 [command] 复制内容到系统剪贴板（需要 Vim 版本有 clipboard 支持）

Copied!

撤销与恢复

[N]u                # 撤销命令，N 为任意整数，表示撤销 N 步操作，下同（u: undo）
[N]U                # 撤销整行操作，N 为任意整数
Ctrl+r              # 撤销上一次 u 命令（r: redo）
Ctrl+R              # 回退前一个命令
:earlier {N}s       # 回退到 N 秒前的文件内容，其中 s 可替换为 m（分）、h（小时）、d（天）
:later {N}s         # 前进 N 秒，其中 s 可替换为 m（分）、h（小时）、d（天）

Copied!

查找替换

查找命令

普通（Normal）模式下的查找命令（注意：Esc 退出键可以中止大部分命令）。

/pattern            # 从光标处向文件尾搜索 pattern
?pattern            # 从光标处向文件头搜索 pattern
n                   # 向同一方向执行上一次搜索
N                   # 向相反方向执行上一次搜索
%                   # 匹配括号移动，包括 ()，{}，[]。结合以下两个命令相当强大。前提：需要把光标先移到括号上
*                   # 向后搜索光标所在的单词
g*									# 与*类似,但是不严格按照单词来分界;`aaa bbb`的aaa上用g* 能搜索到 aaaacccc
#                   # 向前搜索光标所在的单词
g# 									# 与#类似,但是不严格按照单词来分界;`aaa bbb`的aaa上用g* 能搜索到 aaaacccc
<Shift>*            # 搜索光标所在位置的字符串，不用输入字符串，查询速度比 /pattern 快
f{char}             # 向后搜索当前行第一个为 {char} 的字符，Nfv 可以找到第 N 个为 v 字符，下同（f: find）
F{char}             # 向前搜索当前行第一个为 {char} 的字符
t{char}             # 向后搜索当前行第一个为 {char} 的字符前（t: to）
T{char}             # 向前搜索当前行第一个为 {char} 的字符前
;                   # 重复上次的字符查找命令（f/t 命令）
,                   # 反转方向查找上次的字符查找命令（f/t 命令）
tx                  # 搜索当前行到指定 字符串 之前
fx                  # 搜索当前行到指定 字符串 之处
<Esc>               # 放弃查找。例如，启动了 f 命令后发现想用的是 F 命令，<Esc> 退出键放弃查找

Copied!

substitute 命令替换

普通（Normal）模式下的替换命令格式。

`1`	`:[range]s[ubstitute]/{pattern}/{string}/[flags]`

Copied!

参数说明：

{pattern}：就是要被替换掉的字串，可以用 regexp 來表示。
{string}：將 pattern 由 string 所取代。
[range]：有以下一些取值。

[range]取值	含义
无	默认光标所在行
.	光标所在当前行
N	第 N 行
$	最后一行
‘a	标记 a 所在的行（之前要用 ma 做过标记）
$-1	倒数第二行，可以对某一行加减某个数值获得确定的某行
1,10	第 1~10 行
1,$	第一行到最后一行
1,.	第一行到当前行
.,$	当前行到最后一行
‘a,‘b	标记 a 所在的行到标记 b 所在的行（之前要用 ma、mb 做过标记）
%	所有行（和 1，$ 等价）
?str?	从当前位置向上搜索，找到第一个 str 的行（str 可以是正则）
/str/	从当前位置向下搜索，找到第一个 str 的行（str 可以是正则）

注意：上面的所有用于 range 的表示方法都可以通过 +、- 操作来设置相对偏移量。

[flags]有以下一些取值：

[flags]取值	含义
g	对指定范围内的所有匹配项（g: global）进行替换
c	在替换前请求用户进行确认（c: confirm）
e	忽略执行过程中的错误（e: error）
i	不区分大小写（i: ignore）
无	只在指定范围内的第一个匹配项进行替换

举例：

g&                        # 重复上一次 substitute 命令
:s/old/new/               # 当前行的第一个 old 替换为 new
:s/old/new/g              # 当前行的 old 全部替换为 new
:s/old/\U&/               # 当前行的 old 替换为大写的 OLD
:N,Ms/old/new/g           # 将第 N~M 行中所有的 old 全部替换为 new
:%s/old/new/g             # 当前文件中的 old 全部替换为 new
:%s/old/new/gc            # 将当前文件中的 old 全部替换为 new，并且每处询问你是否替换
:%s/^/xxx/g               # 在每行行首插入 xxx，^ 表示行首，注释时非常有用
:%s/./# &                 # 在非空行的行首添加注释，& 代表前边匹配到非空行字符
:%s/$/xxx/g               # 在每行行尾插入 xxx，$ 表示行尾
:%s/hello/&, world/       # 将会把 hello 替换成 hello, wolrd
:%s/.*/(&)/               # 将会把所有行用 () 包含起来
:%s/\s\+$//e              # 删除每行末尾的空格
:%s/1\\2\/3/123/g         # 将 "1\2/3" 替换为 "123"，特殊字符使用反斜杠标注
:%s/\r//g                 # 删除 DOS 换行符 ^M
:%s///gn                  # 统计某个模式的匹配个数
:%s/^\n$//gc/             # 替换多个空行为一个空行
:%s/\n/\r\r/              # 每行后加入空行
:%s/^\s*$\n//g            # 删除所有空白行
:%s/^M$//g                # 删除文件中显式的 ^M 符号，即操作系统换行符问题
:%s/_\(\w\)/\u\1/g        # 将下划线转为驼峰式写法
:%s/^\(\w\)/\L\1/g        # 将首字母大写的切换成小写
:h[elp] s[ubstitute]      # 查看 substitute 替换命令的帮助文档

Copied!

global 命令替换

还有一种比替换更灵活的方式，它允许匹配到某个指定模式后执行指定的 Ex 命令，即 Vim 的 global 命令，其处理重复工作的效率极高。其命令格式为：

`1`	`:[range]g[lobal][!]/{pattern}/[cmd]`

Copied!

参数说明：

[range]：表示操作范围，:global 命令的默认作用范围是整个文件 (用 % 表示)。操作范围参考上面的 [range] 取值。
[!]：表示反转 :global 命令的行为，将在没有匹配到指定模式的行上执行 cmd。
{pattern}：指定 :global 命令要匹配的目标模式，若将该域留空，Vim 会自动使用当前(最近一次)的查找模式。
[cmd]：除 :global 命令之外的任何 Ex 命令，Vim 缺省使用 :print 命令，缩写为 :p。

例如：

:g/pattern                  # 查找并显示文件中所有包含模式 pattern 的行，并移动到最后一个匹配处
:g/pattern/p                # 查找并显示文件中所有包含模式 pattern 的行
:g/\<pattern\>/p            # 查找并显示文件中所有精确匹配单词 pattern 的行
:g!/pattern/nu              # 查找并显示文件中所有不包含模式 pattern 的行，并显示这些行号
:v/pattern/d                # 删除所有不包含 pattern 的行
:g/.*/m0                    # 将所有的行按相反的顺序排列。其中，查找模式 .* 将匹配所有行，m0 命令将每一行移动到 0 行之后
:g/^/t.                     # 重复每一行，其中 :t 或 :copy 为复制命令
:g/^/+1 d                   # 删除偶数行
:g/^/d|m.                   # 删除奇数行
:g/^$/d                     # 删除所有空白行
:g/^\s*$/d                  # 删除所有空白行
:v/./d                      # 删除所有空白行，其中 . 用于匹配除换行符 \n 外的任何单字符
:g/pattern/d_               # 删除大量匹配行，避免花费不必要的时间拷贝匹配行至默认寄存器，可以指定黑洞寄存器 _
:N,Mg/pattern/p             # 查找并显示第 N 到 M 行之间所有包含模式 pattern 的行
:%g/^ xyz/normal dd         # 表示对于以一个空格和 xyz 开头的行，执行 Normal 模式下的 dd 命令
:g/.\n\n\@!/norm o          # 非空行每行后加入空行，且多个空行合并为一个空行，\n 末尾匹配换行符，\n\@! 表示 \n 紧接着 \n，则匹配失败
:h[elp] :g[lobal]           # 查看 global 命令的帮助文档

Copied!

特别说明：

substitute 与 global 形式很相似，都是要进行查找匹配，但 substitute 执行的是替换，而 global 执行的其它命令。
global 命令实际上是分成两步执行：首先扫描 [range] 指定范围内的所有行，给匹配 {pattern} 的行打上标记；然后依次对打有标记的行执行 [cmd] 命令，如果被标记的行在对之前匹配行的命令操作中被删除、移动或合并，则其标记自动消失，而不对该行执行 [cmd] 命令。例子可以参考上面的奇数行、偶数行删除命令！

正则替换

高级的查找替换要用到正则表达式。详情可以查看下面的正则表达式命令的帮助文档。

`1`	`:h[elp] pattern # 查看正则表达式的帮助文档获取更多信息`

Copied!

注意：以下非 Vim 的命令，只代表正则表达式。

                   # ---------------- 表示【目标字符集】的元字符 ---------------
[a-z]              # 表示匹配方括号中列举的任意一个字符，即匹配 a-z 中的任意一个字符
[^a-z]             # 表示匹配除 方括号中字符以外 的任意字符
.                  # 等价于 [^\n]，表示匹配 任意一个除换行符 ( \n ) 外的其他字符
\l                 # 等价于 [a-z]，表示匹配 任意一个小写字母
\L                 # 等价于 [^a-z]，表示匹配 任意一个除小写字母外的其他字符
\u                 # 等价于 [A-Z]，表示匹配 任意一个大写字母
\U                 # 等价于 [^A-Z]，表示匹配 任意一个除大写字母外的其他字符
\w                 # 等价于 [0-9A-Za-z_]，表示匹配 任意一个单词字母
\W                 # 等价于 [^0-9A-Za-z_]，表示匹配 任意一个除单词字母外的其他字符
\d                 # 等价于 [0-9]，表示匹配 任意一个阿拉伯数字
\D                 # 等价于 [^0-9]，表示匹配 任意一个除阿拉伯数字外的其他字符
\x                 # 等价于 [0-9A-Fa-f]，表示匹配 任意一个十六进制数字
\X                 # 等价于 [^0-9A-Fa-f]，表示匹配 任意一个除十六进制数字外的其他字符
                   # ---------------- 表示【次数】的元字符 ---------------------
*                  # 表示匹配 0 个或者任意个目标字符
\+                 # 表示匹配 1 个或者任意个目标字符
\?                 # 表示匹配 0 个或者1个目标字符
\{N,M}             # 表示匹配 N~M 个目标字符，即最少匹配 N 个目标字符，最多匹配 M-1 个目标字符
\{N}               # 表示匹配 N 个目标字符，即目标字符需连续出现 N 次
\{N,}              # 表示匹配 N 任意个目标字符，即最少匹配 N 个目标字符
\{,M}              # 表示匹配 0~M 个目标字符，即最多匹配 M-1 个目标字符，也可以不匹配字符
                   # ---------------- 表示【位置】的元字符 ---------------------
^                  # 表示匹配 输入字符串的开始位置 (行首)
$                  # 表示匹配 输入字符串的结束位置 (行尾)
\<                 # 表示匹配 单词词首
\>                 # 表示匹配 单词词尾
                   # ---------------- 表示【非打印字符】的元字符 ----------------
\n                 # 表示匹配 一个换行符
\r                 # 表示匹配 一个回车符 Enter 键
\t                 # 表示匹配 一个制表符 Tab 键
\s                 # 表示匹配 任意一个空白字符，包括空格、制表符、换页符等
\S                 # 表示匹配 任意一个非空白字符
                   # ---------------- 表示【子模式】的元字符 -------------------
()                 # 任何 () 内部的匹配文本被称为 子匹配，会被自动保存到临时的仓库中以便后续引用，可以用 \1-9 来依次引用子匹配

Copied!

Magic 模式

`1`	`:h[elp] /magic # 查看更多 Magic 模式帮助信息`

Copied!

Vim 正则表达式可以分为四种模式。

magic 模式：使用 \m 前缀，其后模式的解释方式为 ‘magic’ 选项。^，$，.，* 和 [] 等字符含有特殊意义；而 +、?、()、和 {} 等其它字符则按字面意义解释。magic为默认设置，表达式中的\m前缀可以省略。
no magic 模式：使用 \M 前缀，其后模式的解释方式为 ’nomagic’ 选项。除了 ^ 和 $ 之外的特殊字符，都将被视为普通文本。
very magic 模式：使用 \v 前缀，其后模式中除 ‘0’-‘9’，‘a’-‘z’，‘A’-‘Z’ 和 ‘_’ 之外的字符都当作特殊字符解释。
very nomagic 模式：使用 \V 前缀，其后模式中只有反斜杠（\）具有特殊意义。

不同模式之间的区别，在于哪些特殊字符需要使用反斜杠（\）进行转义。例如星号（*），在 magic 和 very magic 模式下视为特殊修饰符；而在 no magic 和 very nomagic 模式下则被视为普通字符，必须使用 “*” 恢复其特殊作用。

可视模式

Vim 可视模式下允许选中一块文本区域，并对文本区域进行 复制 y、剪切 d、删除 d、替换 r、改变大小写 等操作。

v                   # 切换到面向字符的可视模式（v: visual）
V                   # 切换到面向行的可视模式
Ctrl+v              # 切换到面向列块的可视模式
V>                  # 向右增加缩进
V<                  # 向左减少缩进
v0                  # 选中当前位置到行首
v$                  # 选中当前位置到行末
viw                 # 选中当前单词
vib                 # 选中小括号内的内容
vi)                 # 选中小括号内的内容
vi]                 # 选中中括号内的内容
viB                 # 选中大括号内的内容
vi}                 # 选中大括号内的内容
vis                 # 选中句子中的内容
vab                 # 选中小括号内的内容，包含小括号本身
va)                 # 选中小括号内的内容，包含小括号本身
va]                 # 选中中括号内的内容，包含中括号本身
vaB                 # 选中大括号内的内容，包含大括号本身
va}                 # 选中大括号内的内容，包含大括号本身
v[N]wd              # 删除（剪切）选中的 N 个单词
v[N]wc              # 修改高亮选中的 N 个单词，并进入插入模式
v[N]w~              # 高亮选中的 N 个单词转换大小写
{visual}o           # 跳转到可视模式选中区域的另一端（o: other end）
{visual}O           # 跳转到可视模式选中区域的另一端
{visual}u           # 标记区转换为小写
{visual}U           # 标记区转换为大写
gv                  # 重选上次的高亮选区
g Ctrl+G            # 显示所选择区域的统计信息
ggVG                # 选择全文
<Esc>               # 按 <Esc> 退出键退出可视模式

Copied!

注释命令

Ctrl+v              # 多行注释 步骤1：进入命令行模式，按 Ctrl+v 进入可视模式，然后按 j 或者 k 字母键选中多行，把需要注释的行标记起来
I                   # 多行注释 步骤2：按大写字母 I 字母键，再插入注释符，例如 #、//
<Esc>               # 多行注释 步骤3：按 <Esc> 退出键就会全部注释了

Ctrl+v              # 取消多行注释 步骤1：进入命令模式，按 Ctrl+v 进入可视模式，按 l 字母键横向选中列的个数，例如 #、//，需要选中 2 列
j or k              # 取消多行注释 步骤2：按字母 j 或者 k 键移动选中注释符号
d                   # 取消多行注释 步骤3：按 d 字母键就可全部取消注释

Copied!

复杂注释。

:N,M s/^/ 注释符 /g        # 在指定行 N ~ M 的行首添加注释（注意冒号）
:N,M s/^ 注释符 //g        # 在指定行 N ~ M 的行首取消注释（注意冒号）

:3,5 s/^/#/g              # 注释第 3 ~ 5 行
:3,5 s/^#//g              # 解除 3 ~ 5 行的注释

:1,$ s/^/#/g              # 注释整个文档
:1,$ s/^#//g              # 取消注释整个文档

:%s/^/#/g                 # 注释整个文档，此法更快
:%s/^#//g                 # 取消注释整个文档

Copied!

打开文件

vim [options]             # 启动 Vim 并开启一个空白缓冲区
vim [options] {file} ..   # 启动并编辑一个或多个文件
vim [options] -           # 从标准输入读入文件
vim [options] -t {tag}    # 编辑与标签 tag 关联的文件
vim [options] -q [fname]  # 以快速修复模式开始编辑并显示首个错误。options 选项均参考以下

vim .                     # 打开文件管理器，显示目录文件，通过选中文件编辑
vim {file}                # 打开或新建文件，置于光标第一行首
vim + {file}              # 打开文件，置光标于最后一行首
vim +[N] {file}           # 打开文件，置光标于第 N 行首
vim -b {file}             # 以二进制模式打开文件，该模式某些特殊字符 如换行符 ^M 都可以显示出来
vim -v {file}             # Vi 模式，以普通模式启动 Ex
vim -e {file}             # Ex 模式，以 Ex 模式启动 vim  
vim -r {file}             # 恢复上次异常退出的文件
vim -R {file}             # 以只读的方式打开文件，但仍然可以使用 :wq! 写入
vim -M {file}             # 以只读的方式打开文件，不可以强制保存 :wq! 写入 
vim -x {file}             # 以加密方式打开文件
vim -p {files}            # 打开多个文件，每个文件占用一个标签页
vim -o {files}            # 在水平分割的多个窗口中编辑多个文件
vim -O {files}            # 在垂直分割的多个窗口中编辑多个文件
vim -c cmd {file}         # 在打开文件 file 前，先执行指定命令 cmd；vim file.txt -c "e ++enc=UTF-8"：以指定的编码打开 file.txt 文件
vim +{cmd} {file}         # 在打开文件 file 后，再执行命令 cmd
vim +/string {file}       # 打开文件 file，并将光标停留在第一个匹配的 string 上
vim -d {file1} {file2}    # 同时打开 file1 和 file2 文件并 diff 两个文件的差异

Copied!

保存退出

:w                  # 写入文件并保存，会修改文件的时间戳
:w[rite] {file}     # 按名称 file 保存文件
:w !sudo tee %      # 以超级用户权限保存文件，也可以这样 :w !sudo tee % > /dev/null
:wa                 # 保存所有文件
:wa[ll]             # 保存所有文件
:wqa[ll]            # 保存所有文件并退出
:[N]wn[ext]         # 保存当前文件，并编辑下 N 个文件
:[N]wp[revious]     # 保存当前文件，并编辑上 N 个文件
:q                  # 关闭光标所在的窗口并退出
:q[uit]             # 关闭光标所在的窗口并退出
:q!                 # 不保存文件并强制退出
:qa[ll]             # 放弃所有文件操作并退出
:qa[ll]!            # 放弃所有文件操作并强制退出
:x                  # 保存文件并退出，不会修改文件的时间戳
ZZ                  # 保存已改动的文件，并关闭退出窗口，等价于 :x
ZQ                  # 不保存文件关闭窗口，等价于 :q!

Copied!

文件比较

Vim 的 diff 模式是依赖于 diff 命令的，所以首先保证系统中的 diff 命令是可用的。

vimdiff lfile rfile       # 纵向分割窗口比较文件
vim -d lfile  rfile       # 纵向分割窗口比较文件
vim -d -o lfile rfile     # 横向分割窗口比较文件

:diffs[plit] {file}       # 在当前窗口分割，载入另一个文件 file 进行文件比较 
:vert diffs {file}        # 在载入文件时要使用纵向分割
:difft[his]               # 将当前文件加入 diff
:diffp[atch] {patchfile}  # 将 buffer 中的文件载入当前窗口进行文件比较

:diffu[pdate]             # 文件改动后，刷新 diff
:diffu[pdate]!            # 对所有文件更新 diff

:[range]diffpu[t]         # 指定范围的合并，当前文件的指定范围内容复制到另一个文件里
:[range]diffg[et]         # 指定范围的合并，把另一个文件的指定范围内容复制到当前行中

]c                        # 在 diff 中的跳转到下一个不同
[c                        # 在 diff 中的跳转到上一个不同

:diffo[ff]                # 将目前文件退出 diff 模式
:diffo[ff]!               # 将目前窗口中的所有文件退出 diff 模式
:qa[ll]                   # 不保存文件修改并退出
:wa[ll]                   # 保存全部文件
:wqa[ll]                  # 修改合并后，保存全部文件并退出

Copied!

文件操作

:e[dit] {file}      # 打开文件并编辑，通过文件的绝对或相对路径打开文件，Tab 制表键补全路径
:e[dit] .           # 打开文件管理器，浏览当前目录下的文件，选中并编辑 
:e[dit]             # 重新载入当前文件
:e[dit]!            # 放弃修改，重新回到文件打开时的状态  
:E[xplore]          # 打开文件管理器，并显示活动缓冲区所在的目录
:sav[eas] {file}    # 另存为指定文件 file
:o {file}           # 在当前窗口打开另一个文件（o: open）
:r {file}           # 读取文件并将内容插入到光标后
:r !dir             # 将 dir 命令的输出捕获并插入到光标后
:on[ly]             # 关闭除光标所在的窗口之外的其他窗口，等价于 Ctrl+W o
:clo[se]            # 关闭光标所在窗口的文件，等价于 Ctrl+W c
:cd {path}          # 切换 Vim 当前路径至 path
:cd -               # 回到上一次当前目录
:pwd                # 显示 Vim 当前路径
:n[ew] {file}       # 打开一个新的窗口编辑新文件 file 
:[N]new             # 打开 N 个新的窗口编辑新文件，N 为任意正整数
:ene[w]             # 在当前窗口创建新文件
:[N]vne[w]          # 纵向切分 N 个新窗口编辑新文件，N 为任意正整数
:tabnew             # 在新的标签页中编辑新文件
:fin[d] {file}      # 在 path 当中查找文件 file 并编辑
:f[ile]             # 显示当前文件名及光标位置
:f[ile] {name}      # 置当前文件名为 name
:files              # 查看缓冲区列表

Copied!

缓冲区

缓冲区（Buffer）是一块内存区域，用于存储着正在编辑的文件。在保存缓冲区并退出时，内容也随之被写回原始文件。切换缓冲区可以在多个文件中来回编辑，提高编辑效率。

:ls                 # 查看缓冲区列表
:files              # 查看缓冲区列表，同上
:buffers            # 查看缓冲区列表，同上
:ls [flags]         # 查看指定状态的缓冲区，其中 [flags] 参考下面列表取值

:ball               # 为每个缓冲区打开一个窗口
:bad[d] {name}      # 将名称为 name 的文件添加到缓冲区列表
:b[uffer] [N]       # 打开指定缓存编号的缓冲区
:b[uffer] {name}    # 打开名称为 name 的缓冲区
:sb[uffer] [N]      # 纵向分割打开指定缓存编号的缓冲区
:sb[uffer] {name}   # 纵向分割打开名称为 name 的缓冲区

:bn[ext]            # 切换到下一个缓冲区
:bN[ext]            # 切换到上一个缓冲区
:bp[revious]        # 切换到上一个缓冲区，同上
:bf[irst]           # 切换到第一个缓冲区
:bl[ast]            # 切换到最后一个缓冲区

:bd[elete] [N]      # 删除指定 N 编号的缓冲区
:N,Mbdelete         # 删除指定范围的缓冲区，例如 :3,5bdelete 表示删除缓存编号在 3~5 范围的缓冲区
:bun[load][!] [N]   # 卸载缓冲区，! 代表是否强制卸载缓冲区
N Ctrl+^            # 切换缓冲区，先输入缓存编号，再按 Ctrl+^

Copied!

查看缓冲区列表时，缓冲区状态包含以下几种：

缓冲区状态	说明
+	modified buffers，已更改的缓冲区
-	buffers with ‘modifiable’ off，禁用了 modifiable 选项，只读缓冲区
=	readonly buffers，只读缓冲区
a	active buffers，活动缓冲区，显示在当前屏幕上
u	unlisted buffers (overrides the “!”)
h	hidden buffers，隐藏缓冲区，已载入但没显示在屏幕上
x	buffers with a read error，读入时报错的缓冲区
%	current buffer，当前缓冲区
#	alternate buffer，交换缓冲区
R	terminal buffers with a running job
F	terminal buffers with a finished job
?	terminal buffers without a job: `:terminal NONE`
t	show time last used and sort buffers

分屏窗口

分屏窗口是基于 Ctrl+W 快捷键的，Ctrl 是控制功能键，W 是代表 Windom，Ctrl+W 代表控制窗口的意思。

" :sp[file] 上下分屏   :vsp[file] 左右分屏
" vim -o file1 file2 file3   上下分屏
" vim -O file1 file2 file3   左右分屏
" <C-w>h/j/k/l/w             在窗口间移动光标
" <C-w>H/J/K/L/r/R 移动窗口; <C-w>o 关闭其他窗口只保留当前的(:only); <C-w>T 将当前窗口移到新的标签页中
" <C-w>+-<> 增/减 窗口 高度/宽度 ; <C-w>= 设置所有窗口同宽同高


:sp[lit] {file}     # 横向切分窗口并在新窗口打开文件 file
:[N]sp[lit]         # 横向切分 N 个当前窗口出来，内容同步，游标可以不同
:[N]new             # 横向切分出一个 N 行高的窗口，并编辑一个新文件
:[N]sv[iew] {file}  # 横向切分窗口并在新窗口打开文件 file，等价于 :split，区别在于当前窗口的内容 只读
:[N]sf[ind] {file}  # 横向切分窗口，从 path 中找到文件 file 并编辑之
Ctrl+W s            # 横向切分当前窗口（s: split）
Ctrl+W f            # 横向切分出一个窗口，并在新窗口打开名称为光标所在词的文件

:vs[plit] {file}    # 纵向切分窗口并在新窗口打开文件 file（vs: vertical split）
:[N]vsp[lit]        # 纵向切分 N 个当前窗口出来，内容同步，游标可以不同
:[N]vne[w]          # 纵向切分出一个新窗口     
Ctrl+W v            # 纵向切分当前窗口（v:vertical split）
Ctrl+W n            # 新建一个无文件窗口

Ctrl+W c            # 关闭当前窗口，但不能关闭最后一个窗口，等价于 :clo[se]
Ctrl+W o            # 关闭其他窗口，只保留当前活动窗口，等价于 :on[ly]
Ctrl+W q            # 退出当前窗口，如果是最后一个窗口，则退出 Vim，等价于 :q[uit]

Ctrl+W h            # 跳转到左边的窗口（h 键位于左边，按该键光标左移）
Ctrl+W j            # 跳转到下边的窗口（j 键有向下的突起，按该键光标下移）
Ctrl+W k            # 跳转到上边的窗口（k 键与 j 键相反，按该键光标上移）
Ctrl+W l            # 跳转到右边的窗口（l 键位于右边，按下该键光标向右移动）
Ctrl+W H            # 移动当前窗口到最左边
Ctrl+W J            # 移动当前窗口到最下边
Ctrl+W K            # 移动当前窗口到最上边
Ctrl+W L            # 移动当前窗口到最右边
Ctrl+W              # 切换到下一个窗口（W: Window） 
Ctrl+W w            # 循环切换到下一个窗口 
Ctrl+W W            # 循环切换到上一个窗口 
Ctrl+W p            # 切换至上个访问过的窗口 
Ctrl+W r            # 反转互换窗口（r: reverse）
Ctrl+W T            # 将当前窗口移到新的标签页中
ctrl+W t            # 切换到最上面的窗口
ctrl+W b            # 切换到最下面的窗口
Ctrl+W P            # 跳转到预览窗口
Ctrl+W z            # 关闭预览窗口

Ctrl+W =                     # 设置所有窗口同宽同高
Ctrl+W _                     # 纵向最大化当前窗口
Ctrl+W |                     # 横向最大化当前窗口
Ctrl+W +                     # 增加当前窗口的行高，前面可以加数字
Ctrl+W -                     # 减少当前窗口的行高，前面可以加数字
Ctrl+W <                     # 减少当前窗口的列宽，前面可以加数字
Ctrl+W >                     # 增加当前窗口的列宽，前面可以加数字
:res[ize] <N>                # 调整当前窗口的高度，增加 N 行
:res[ize] +<N>               # 调整当前窗口的高度，增加 N 行
:res[ize] -<N>               # 调整当前窗口的高度，减小 N 行
:vert[ical] res[ize] <N>     # 调整当前窗口的宽度，增加 N 列
:vert[ical] res[ize] +<N>    # 调整当前窗口的宽度，增加 N 列
:vert[ical] res[ize] -<N>    # 调整当前窗口的宽度，减小 N 列

Copied!

标签页

:tabs               # 显示所有标签页
:tabnew {file}      # 在新标签页中编辑新的文件 file
:tabe[dit] {file}   # 在新标签页中打开并编辑文件 file
:tabf[ind] {file}   # 在当前目录搜索 file，并在新标签页中打开。请注意，此命令只能打开一个文件
:tab split          # 在新的标签页中打开当前窗口里的文件
:tab ball           # 将缓存中所有文件用标签页打开
:tab drop {file}    # 如果文件已被其他标签页和窗口打开则跳过去，否则新标签打开

:tabc[lose]         # 关闭当前标签页
:tabo[nly]          # 关闭其他标签页

:tabn N             # 切换到第 N 个标签页，例如：tabn 3 切换到第 3 个标签页
:tabm[ove] N        # 将当前标签页移动到第 N 个标签页之后，标签页编号是从 0 开始计数的
:tabm[ove] +N       # 标签页往右移 N 个位置
:tabm[ove] -N       # 标签页往左移 N 个位置
:tabr[ewind]        # 切换到第一个标签页，等价于 :tabfirst 命令
:tabfir[st]         # 切换到第一个标签页
:tabl[ast]          # 切换到最后一个标签页
:tabn[ext]          # 切换到下一个标签页，等价于 gt
:tabp[revious]      # 切换到上一个标签页，等价于 gT
gt                  # 切换到下一个标签页
gT                  # 切换到上一个标签页
[N]gt               # 切换到第 N 个标签页，例如 2gt 将会切换到第 2 个标签页
:tabd[o] {cmd}      # 同时在多个标签页中执行命令，例如 :tabdo %s/food/drink/g，一次完成对所有文件的替换操作
:tab help           # 在标签页打开帮助
:h tabpage          # 查看标签页帮助文档

Copied!

vim书签

Vim 书签可以在文件内容及文件之间快速定位到指定位置。

m{mark-name}                 # 创建名称为 mark-name 的书签
:marks                       # 查看并列出所有书签
:marks {mark-name}           # 查看名称为 mark-name 书签的详情信息
`{mark-name}                 # 跳转到书签的确切位置。请注意，此字符是后退引号
'{mark-name}                 # 跳转到书签行的开头。请注意，此字符是单引号
:delm[arks] {mark-name}      # 删除书签，可以批量删除
:delm[arks]!                 # 删除所有当前缓冲区的书签，但不包括 A-Z 和 0-9 的书签
:h marks                     # 查看书签帮助文档

Copied!

例如：

:marks              # 查看所有书签
m{a-zA-Z}           # 创建书签，小写的是文件书签，大写的是全局书签，可以用 a-zA-Z 中的任何字母标记
ma                  # 保存当前位置到书签 a
:marks a            # 显示名称为 a 书签的详细信息
'a                  # 跳转到书签 a 所在的行
`a                  # 跳转到书签 a 所在位置
``                  # 回到上次跳转的位置
''                  # 回到上次跳转的位置
`.                  # 回到上次编辑的位置
'.                  # 回到上次编辑的位置
'A                  # 跳转到全局书签 A
['                  # 跳转到上一个书签
]'                  # 跳转到下一个书签
'<                  # 跳转到上次可视模式选择区域的开始
'>                  # 跳转到上次可视模式选择区域的结束
:delm a b           # 删除书签 a 和 b
:delmarks p-z       # 删除范围在 p ~ z 的书签

Copied!

文件浏览器

Vim 7.0 之后内置 Netrw 插件，提供文件浏览器功能，相比与 NERDTree 第三方插件来说速度更快，体量更轻，设计更简洁。

:[N]E[xplore][!] [dir]    # 当前窗口中打开文件浏览器
:[N]Hex[plore][!] [dir]   # 水平分割窗口打开文件浏览器
:[N]Lex[plore][!] [dir]   # 左边窗口打开文件浏览器
:[N]Sex[plore][!] [dir]   # 水平分割窗口打开文件浏览器
:[N]Vex[plore][!] [dir]   # 垂直分割窗口打开文件浏览器
:Tex[plore] [dir]         # 新标签页打开文件浏览器
:Rex[plore]               # 返回文件浏览器
:Nexplore                 # 定位到下一个匹配文件
:Pexplore                 # 定位到上一个匹配文件
:h[elp] netrw             # 查看更多 Netrw 插件的帮助信息

Copied!

拼写检查

:set spell          # 打开拼写检查
:set nospell        # 关闭拼写检查
]s                  # 下一处错误拼写的单词
[s                  # 上一处错误拼写的单词
zg                  # 加入单词到拼写词表中
zug                 # 撤销上一次加入的单词
z=                  # 拼写建议

Copied!

代码折叠

"""""""""""""""""" 代码折叠命令： ( close==创建折叠 )!= (open==展开折叠)
"       za         切换当前光标下的折叠的状态(open或close) == zc+zo
"       zA         递归切换当前折叠及其嵌套折叠的状态 == zC+zO
"       zr         减少折叠级别
"       zm         增加折叠级别
"       zj         定位到下一个折叠处
"       zk         定位到上一个折叠处
"
"       zc         创建一个光标下的折叠(close)(从内向外)
"       zC         递归创建折叠及嵌套折叠(从内向外)
"       zo         展开一个光标下的折叠(open)(从外向内)
"       zO         递归打开当前折叠及其嵌套折叠,大写的字母O (从外向内)
"       zf         对所指定的文本范围进行折叠,只支持manual和marker

Copied!

:h[elp] z           # 查看 折叠 帮助文档
zf{motion}          # 手动定义一个折叠（f:fold）
:{range}fold        # 将范围 {range} 包括的行定义为一个折叠
z=                  # 给出拼写建议
zf                  # 创建代码折叠
zF                  # 指定行数 N 创建折叠
za                  # 打开或关闭当前折叠
zA                  # 递归切换折叠，即递归打开一个关闭的折叠或关闭一个打开的折叠
zi                  # 切换折叠，切换 foldenable（i: invert）
zc                  # 关闭光标下的一个折叠（c: close）
zC                  # 递归关闭折叠（C: Close）
zj                  # 定位到下一个折叠处
zk                  # 定位到上一个折叠处
zd                  # 删除光标下折叠（d: delete）
zD                  # 递归删除折叠（D: Delete）
zE                  # 删除所有折叠
zm                  # 收起嵌套的折行，减少 foldlevel（m: more）
zM                  # 关闭所有折叠，置 foldlevel 为 0，设置 foldenable
zn                  # 不折叠，重置 foldenable 并打开所有代码（n: none）
zN                  # 正常折叠，重置 foldenable 并恢复所有折叠（N: Normal）
zr                  # 打开嵌套的折行，增加 foldlevel（r: reduce）
zR                  # 打开所有折叠，置 foldlevel 为最大值
zo                  # 打开光标下的折叠（o: open）
zO                  # 递归打开折叠（O: Open）

Copied!

文档加解密

vim -x {file}       # 文档加密，输入加密密码并再次确认密码。注意：不修改内容也要保存，否则密码设定不会生效
:X                  # 文档加密，命令模式下输入加密密码并再次确认密码。注意：不修改内容也要保存，否则密码设定不会生效
:set key={password} # 文档加密，命令模式下输入加密密码并再次确认密码。注意：不修改内容也要保存，否则密码设定不会生效

:X                  # 文档解密，命令模式下直接按 <Enter> 回车键，表示密码为空。注意：不修改内容也要保存，否则解密设定不会生效
:set key=           # 文档解密，命令模式下设置 key 的密码为空。注意：不修改内容也要保存，否则密码设定不会生效

Copied!

宏录制

宏是录制和播放功能，是一系列 Vim 命令操作的集成，利用宏可以减少很多重复的复杂操作。

q{0-9a-zA-Z"}       # 开始录制名字为 {0-9a-zA-Z"} 的宏，例如 qa 表示录制名字为 a 的宏
q                   # 结束录制宏
@{0-9a-z".=*+}      # 播放名字为 {0-9a-z".=*+} 的宏，例如 @a 表示播放名字为 a 的宏
@@                  # 播放上一个宏
@:                  # 重复上一个 Ex 命令，即冒号命令

Copied!

宏举例：需要将以下多行文本的行首键入一个 Tab 制表键进行 行首缩进。

set nu
set tabstop=4
set shiftwidth=4
set softtabstop=4
set autoindent
set wrap
syntax on

Copied!

录制宏

先将光标移动到第一行。
在 Normal 模式下，按 q 字母键加一个字母开始录制。例如按下 qa，将该宏注册为 a。
按下 I 字母键在行首插入，在编辑模式按下 Tab 制表键。按退出键返回到 Normal 模式。
按下 j 字母键将光标移动到下一行。
按下 q 字母键完成录制。

使用宏

使用上面录制的宏 a，按下 @a，播放名字为 a 的宏。
Normal 模式下将光标移动到第二行，按下 @a，再使用了一次宏 a。
多次操作按下 N@a，其中 N 为正整数，代表执行 N 次宏。例如将光标移动到第 3 行，对余下的 5 行操作宏 a，按下 5@a。

以上 录制宏、使用宏 两个共同操作，完成多行文本的行首键入一个 Tab 制表键进行行首缩进！

其它命令

ga                  # 显示光标下字符的 ASCII 码或者 Unicode 编码
g8                  # 显示光标下字符的 UTF-8 编码字节序
gi                  # 回到上次进入插入的地方，并切换到插入模式
gH                  # 启动选择行模式
K                   # 查询光标下单词的帮助
Ctrl+G              # 显示正在编辑的文件名、文件大小和位置信息等信息
g Ctrl+G            # 显示文件的大小、字符数、单词数和行数，可视模式下也可用
Ctrl+PgUp           # 上个标签页，GVim OK，部分终端软件需设置对应键盘码
Ctrl+PgDown         # 下个标签页，GVim OK，部分终端软件需设置对应键盘码
Ctrl+R Ctrl+W       # 命令模式下插入光标下单词
Ctrl+Insert         # 复制到系统剪贴板（GVim）
Shift+Insert        # 粘贴系统剪贴板的内容（GVim）
Ctrl+X Ctrl+E       # 插入模式下向上滚屏
Ctrl+X Ctrl+Y       # 插入模式下向下滚屏
:.!date             # 在当前窗口插入时间
:%!xxd              # 开始二进制编辑
:%!xxd -r           # 保存二进制编辑
:r !curl -sL {URL}  # 读取 URL 内容添加到光标后
:v/./,/./-j         # 压缩空行
:Man bash           # 在 Vim 中查看 man，先调用 :runtime! ftplugin/man.vim 激活
/fred\|joe          # 搜索 fred 或者 joe
/\<\d\d\d\d\>       # 精确搜索四个数字
/^\n\{3}            # 搜索连续三个空行

Copied!

历史命令

历史命令格式。

`1`	`:his[tory] [{name}] [{first}][, [{last}]]`

Copied!

参数说明：

{name}：指定历史记录类型。
{first}：指定命令历史的起始位置，默认为第一条记录。
{last}：指定命令历史的终止位置，默认为最后一条记录。

在命令行模式下。

:his[tory]                # 查看所有命令行模式下输入的命令历史
:his[tory] all            # 查看所有类型的历史记录
:history c 1,5            # 查看第一到第五条命令行历史
:history search 或 / 或 ? # 查看搜索历史
:call histdel("")         # 删除历史记录
:help :history            # 查看 :history 命令的帮助信息

Copied!

在普通模式下。

1
2
3

q/                        # 查看使用 q/ 输入的搜索历史
q?                        # 查看使用 q? 输入的搜索历史
q:                        # 查看命令行历史

Copied!

寄存器

Vim 寄存器是用于保存临时数据的地方。Vim 有多个寄存器，可当作多个剪贴板，在使用多个文件时，此功能非常有用，且活用多个寄存器可以显著提高数据的安全和可操作性。

:reg[isters]              # 查看所有寄存器的值
:reg[isters] {args}       # 查看指定 {args} 中提到的寄存器值
"{register}               # 普通模式下调取寄存器值
:Ctrl+r "{reg-name}       # 命令模式下输入 Ctrl+r 后 Vim 会自动打出 " 寄存器引用符号
Ctrl+r {reg-name}         # 插入模式下无需输入寄存器引用符号 "

Copied!

例如：

"?yy                # 复制当前行到寄存器 ? ，问号代表 0 ~ 9 的寄存器名称
"?d3j               # 删除光标下三行内容，并放到寄存器 ? ，问号代表 0 ~ 9 的寄存器名称
"?p                 # 将寄存器 ? 的内容粘贴到光标后
"?P                 # 将寄存器 ? 的内容粘贴到光标前

Copied!

Vim 寄存器分类。

寄存器名称	引用方式	说明
无名寄存器	""	默认寄存器，所有的复制和修改操作（x、s、d、c、y）都会将该数据复制到无名寄存器
字母寄存器	“a-zA-Z	{register} 只能是一位的 26 个英文字母，从 a-z，A-Z 寄存器内容将会合并到对应小写字母内容后边
复制专用寄存器	“0	仅当使用复制操作(y)时，该数据将会同时被复制到无名寄存器和复制专用寄存器
逐级临时缓存寄存器	“1 - “9	所有不带范围（‘(’，‘)’，‘{’，‘}’）、操作涉及 1 行以上的删除修改操作（x、s、d、c）的数据都会复制到逐级临时缓存寄存器，并在新的数据加入时，逐级先后推移。1 的数据复制到 2，2 到 3，最后的 9 寄存器内容将会被删除
黑洞寄存器	“_	几乎所有的操作涉及的数据都会被复制到寄存器，如果想让操作的数据不经过寄存器，可以指定黑洞寄存器，数据到该寄存器就会消失掉，不能显示，也不存在
系统剪切板	“+ 或 “*	与 Vim 外部的 GUI 交互数据时，需要使用专用的系统剪切板
表达式寄存器	“=	所有寄存器里最特殊的一个，用于计算表达式。输入完该寄存器应用后，会在命令行里提示“=”，按需输入表达式，结果将会显示到光标处
其他寄存器	-	-

配置文件

Vim 配置文件有全局和用户两种版本，且用户配置文件优先于全局系统配置文件。

:ve[rsion]          # 查看 Vim 版本，同时也查看 Vim 载入配置文件的优先顺序及所在位置
:echo $MYVIMRC      # Vim 命令模式下使用该命令输出 Vim 配置文件的位置
:edit $MYVIMRC      # Vim 命令模式下使用该命令打开 Vim 配置文件
:so[urce] $MYVIMRC  # Vim 配置文件改动后，使用该命令加载新的配置选项，命令缩写为 :so %
:echo $VIM          # 输出全局 vimrc 配置文件位置，存放在 Vim 的安装目录中
:echo $HOME         # 输出用户 vimrc 配置文件位置，存放在用户主目录中

Copied!

在命令行模式下单个设置选项，且选项只在当前窗口生效（命令前记得加上 “:” ，在 vimrc 配置文件 中则不需要）。

:se[t][!]                    # 显示出所有与其默认值不同的选项，当 [!] 出现时，每个选项都显示在单独的行上
:se[t][!] all                # 显示所有选项列表，当 [!] 出现时，每个选项都显示在单独的行上
:se[t] all&                  # 将所有的选项都重置为默认值
:se[t] {option}&             # 将选项设置为默认值
:se[t] {option}?             # 查看某个选项的当前值，屏幕底部将显示其返回值
:se[t] {option}              # 打开某个设置选项， 选项大致可分为三种：布尔值选项、数值选项和字符串选项
:se[t] no{option}            # 关闭某个设置选项
:se[t] {option}!             # 反转设置选项
:se[t] inv{option}           # 反转设置选项，同上
:se[t] {option}:{valus}      # 设置选项的值
:se[t] {option}={valus}      # 设置选项的值，同上
:se[t] {option}+={valus}     # 在选项中增加数值或增加字符串
:se[t] {option}-={valus}     # 在选项中减去数值或移除字符串
:se[t] {option}^={valus}     # 将选项乘以数值或在选项开头增加字符串
:setl[ocal]                  # 等价于 :set，但对局部选项设定其局部值
:setg[lobal]                 # 等价于 :set，但对局部选项设定其全局值
:h[elp] se[t]                # 查看命令的帮助信息
:map                         # 查看当前 Vim 配置的 map 映射快捷键
:inoremap                    # 查看当前 Vim 配置的 inoremap 映射快捷键
:nnoremap                    # 查看当前 Vim 配置的 nnoremap 映射快捷键
:unm[ap] {lhs}               # 取消 {lhs} 选项的映射，例如 :unmap <F10> 表示取消 F10 的映射
:mapclear                    # 取消所有映射；请注意，该命令将会移除所有用户定义和系统默认的键盘映射，慎用
:mapc[lear]!                 # 清除插入及命令行模式下的映射
:imapc[lear]                 # 清除插入模式下的映射
:vmapc[lear]                 # 清除可视模式下的映射
:omapc[lear]                 # 清除操作符等待模式下的映射
:nmapc[lear]                 # 清除普通模式下的映射
:cmapc[lear]                 # 清除命令行模式下的映射
:scr[iptnames]               # 查看 Vim 加载时加载了那些插件和脚本

Copied!

按键映射命令格式：

`1`	`[prefix]map {lhs} {rhs} # 将键 {lhs} 映射为 {rhs}，{rhs} 可进行映射扫描，也可递归映射`

Copied!

参数说明：

{lhs}：lhs 代表 left-hand-side，即左边参数。
{rhs}：rhs 代表 right-hand-side，即右边参数。
[prefix]：作用模式前缀，有以下取值。

前缀	作用模式	命令格式	命令缩写
<Space>	普通、可视、选择和操作符等待	:map {lhs} {rhs}	无
n	普通模式	:nmap {lhs} {rhs}	:nm {lhs} {rhs}
v	可视和选择模式	:vmap {lhs} {rhs}	:vm {lhs} {rhs}
s	选择模式	:smap {lhs} {rhs}	无
x	可视模式	:xmap {lhs} {rhs}	:xm {lhs} {rhs}
o	操作符等待	:omap {lhs} {rhs}	:om {lhs} {rhs}
!	插入和命令行模式	:map! {lhs} {rhs}	无
i	插入模式	:imap {lhs} {rhs}	:im {lhs} {rhs}
I	插入、命令行和 Lang-Arg 模式	:lmap {lhs} {rhs}	:lm {lhs} {rhs}
c	命令行模式	:cmap {lhs} {rhs}	:lm {lhs} {rhs}
nore	不递归（no rerecursion）映射，和以上前缀自由搭配使用	:noremap {lhs} {rhs}	:nor {lhs} {rhs}
un	取消 :map 绑定的 {lhs}	:unmap {lhs}	无

{rhs} 之前可能显示的特殊字符：

特殊字符	意义
*	不可重映射
&	仅脚本的局部映射可以被重映射
@	缓冲区的局部映射

特殊参数说明（特殊参数必须在映射命令的后边，{lhs} 参数的前面）：

参数	说明
<buffer>	如果映射命令的第一个参数是，映射将只局限于当前缓冲区（即此时正在编辑的文件）内
<silent>	执行绑定键时不在命令行上回显按键映射的命令内容
<special>	一般用于定义特殊键怕有副作用的场合
`<script>`	该映射只使用通过以 “” 开头来定义的脚本局部映射来重映射 {rhs} 中的字符
<expr>	如果定义新映射的第一个参数是，那么参数会作为表达式来进行计算，计算结果作为实际使用的
<unique>	用于定义新的键映射或者缩写命令时检查是否该键已经被映射，如果该映射或者缩写已经存在，则该命令会失败

映射快捷键时常用的键表：

键	键说明	组合键
<F1> ~ <F12>	功能键 F1 ～ F12
<K0> ~ <K9>	数值 0 到 9
<Shift>	Shift 键	<S-…> <s-…> <Shift-…>
<Ctrl>	Ctrl 键	<C-…> <c-…> <Ctrl-…>
<Alt>	Alt 键	<A-…> <a-…> <Alt-…>
<Up>/<Down>/<Right>/<Left>	方向键
<Esc>	Esc 键
<Leader>	\ 前缀键
<Tab>	Tab 制表键
<CR>	Enter 回车键

在 vimrc 配置文件 中可以批量设置选项，例如：

syntax              # 列出已经定义的语法项
syntax clear        # 清除已定义的语法规则
syntax on           # 允许语法高亮
syntax off          # 禁止语法高亮
set nu              # 设置显示行号，禁止显示行号可以用 :set nonu
set number          # 设置显示行号，禁止显示行号可以用 :set nonumber
set list            # 设置显示制表符和换行符
set history=200     # 记录 200 条历史命令
set bs=?            # 设置 <Backspace> 退格键模式，现代编辑器为 :set bs=eol, start, indent
set sw=4            # 设置缩进宽度为 4
set ts=4            # 设置制表符宽度为 4
set noet            # 设置不展开 Tab 制表键成空格
set et              # 设置展开 Tab 制表键成空格
set winaltkeys=no   # 设置 GVim 下正常捕获 <Alt> 换挡键
set nowrap          # 关闭自动换行
set ttimeout        # 允许终端按键检测超时（终端下功能键为一串 Esc 开头的扫描码）
set ttm=100         # 设置终端按键检测超时为 100 毫秒
set term=?          # 设置终端类型，例如常见的 xterm
set ignorecase      # 设置搜索是否忽略大小写
set smartcase       # 智能大小写，默认忽略大小写，除非搜索内容里包含大写字母
set relativenumber  # 设置显示相对行号（其他行与当前行的距离）
set paste           # 打开粘贴模式（粘贴时禁用缩进等影响格式的内容）
set nopaste         # 关闭粘贴模式
set spell           # 允许拼写检查
set hlsearch        # 开启高亮查找
set nohlsearch      # 关闭高亮查找
set termguicolors   # Vim 开启真彩色
set ruler           # 总是显示光标位置
set nocompatible    # 设置不兼容原始 vi 模式，该设置必须在最开头
set incsearch       # 查找输入时动态增量显示查找结果
set insertmode      # Vim 始终处于插入模式下，使用 Ctrl+o 临时执行命令
set ff=unix         # 设置换行为 unix
set ff=dos          # 设置换行为 dos
set ff?             # 查看换行设置
set hidden          # 打开隐藏模式，未保存的缓存可以被切换走，或者关闭
set nohidden        # 关闭隐藏模式，未保存的缓存不能被切换走，或者关闭
set termcap         # 查看会从终端接收什么以及会发送给终端什么命令
set guicursor=      # 解决 SecureCRT/PenguiNet 中 NeoVim 局部奇怪字符问题
set t_RS= t_SH=     # 解决 SecureCRT/PenguiNet 中 Vim8.0 终端功能奇怪字符
set fo+=a           # 开启文本段的实时自动格式化
set showtabline=?   # 标签页显示方式，? 为 0 时隐藏标签页，1 会按需显示，2 会永久显示
inoremap vv <Esc>   # 插入模式下的 vv 键为 Esc 退出键，退出插入模式
nnoremap gh ^       # 普通模式下按 gh 键进行行首跳转，代替数字 0 进行行首跳转
nnoremap gl $       # 普通模式下按 gl 键进行行尾跳转，代替数字 $ 进行行尾跳转

Copied!

常用插件

vim-commentary ：批量注释工具，可以注释多行和去除多行注释。
NERDTree ：插件用于列出当前路径的目录树。
asyncrun.vim ：插件使用 Vim 8、NeoVim 的异步机制，让你在后台运行 Shell 命令，并将结果实时显示到 Vim 的 Quickfix 窗口中。

vim模式

普通模式             # 按 <Esc> 退出键或 Ctrl+[ 进入普通模式，左下角显示文件名或为空
插入模式             # 按 i 字母键进入插入模式，左下角显示 --INSERT--
可视模式             # 按 v 字母键进入可视模式，左下角显示 --VISUAL--
选择模式             # 按 {visual}+Ctrl+g 组合键进入选择模式，左下角显示 --SELECT-- 
替换模式             # 按 r 或 R 字母键开始替换模式，左下角显示 --REPLACE--
命令行模式           # 按 : 或者 / 或者 ? 开始命令行模式，左下角无明显信息
Ex 模式             # 按 Q 字母键进入 Ex 模式，与命令行模式类似，执行完命令后，会继续停留在 Ex 模式，按 :vi[sual] 退出 Ex 模式

Copied!

外部命令

:!{command}         # 执行一次性 Shell 命令，例如 :!pwd，输出当前 Vim 模式下所处目录路径
:!!                 # 重新执行最近一次运行过的命令
:sh[ell]            # 启动一个交互的 Shell 执行多个命令，不需要退出Vim。exit 命令退出并返回 Vim
:!ls                # 运行外部命令 ls，并等待返回
:r !ls              # 将外部命令 ls 的输出捕获，并插入到光标后
:w !sudo tee %      # sudo 以后保存当前文件，也可以这样 :w !sudo tee % > /dev/null
:call system('ls')  # 调用 ls 命令，但是不显示返回内容
:!start notepad     # Windows 下启动 Notepad，最前面可以加 silent
:sil !start cmd     # Windows 下当前目录打开 cmd
:%!prog             # 运行文字过滤程序，如整理 JSON 格式 :%!python -m json.tool

Copied!

gui命令

:gui                         # UNIX 启动 GUI
:gui {fname}                 # 同上，并编辑 fname
:menu                        # 列出所有菜单
:menu {mpath}                # 列出 mpath 下的所有菜单
:menu {mpath} {rhs}          # 把 rhs 加入菜单 mpath
:menu {pri} {mpath} {rhs}    # 同上，并带有优先权 pri
:menu ToolBar.{name} {rhs}   # 把 rhs 加入工具栏
:tmenu {mpath} {text}        # 为菜单 mpath 加入工具提示
:unmenu {mpath}              # 删除菜单 mpath

Copied!

自动命令

自动命令，是在指定事件发生时自动执行的命令。利用自动命令可以将重复的手工操作自动化，以提高编辑效率并减少人为操作的差错。

自动命令语法格式。

`1`	`:au[tocmd] [group] {event} {aupat} [++once] [++nested] {command}`

Copied!

参数说明：

group：组名是可选项，用于分组管理多条自动命令。
event：事件参数，用于指明触发命令的一个或多个事件。
pattern：限定针对符合匹配模式的文件执行命令。
nested：嵌套标记是可选项，用于允许嵌套自动命令。
command：指明需要执行的命令、函数或脚本。

:au[tocmd]                   # 查看所有自动命令，既包括 vimrc 文件中自定义的自动命令，也包括了各种插件定义的自动命令
:au[tocmd]!                  # 删除所有自动命令；此操作也将删除插件所定义的自动命令，请谨慎操作
:help autocommand-events     # 查看 自动命令事件 帮助文档
:help autocmd-patterns       # 查看匹配模式帮助文档

Copied!

自动命令组

`1`	`:h[elp] aug[roup] # 查看自动命令组的帮助文档`

Copied!

通过 :augroup 命令，可以将多个相关联的自动命令分组管理，以便于按组来查看或删除自动命令。例如以下命令，将 C 语言开发的相关自动命令，组织在 “cprogram” 组内。详情亦见 vimrc 配置文件 中的自动代码折叠。

:augroup cprograms
:    autocmd!
:    autocmd FileReadPost *.c :set cindent
:    autocmd FileReadPost *.cpp :set cindent
:augroup END

Copied!

如果我们针对同样的文件和同样的事件定义了多条自动命令，那么当满足触发条件时将分别执行多条自动命令。因此，建议在自动命令组的开头增加 :autocmd! 命令，以确保没有重复的自动命令存在。

快速修复窗口

Quickfix 插件提供的功能，对编译调试程序非常有用。

:cope[n] [height]   # 打开 Quickfix 窗口以显示当前的错误列表，height 表示高度，单位为行
:lop[en] [height]   # 打开 Quickfix 窗口以显示当前窗口的位置列表
:ccl[ose]           # 关闭 Qiuckfix 窗口
:lcl[ose]           # 关闭显示当前窗口位置列表的窗口
:cw[indow] [height] # 出现识别错误时打开 Quickfix 窗口；否则什么也不做
:lw[indow] [height] # 等价于 :cwindow，除了使用显示当前窗口的位置列表
:cbo[ttom]          # 将光标放在 Quickfix 窗口的最后一行并滚动以使其可见
:lbo[ttom]          # 等价于 :cbottom，除了使用显示当前位置列表的窗口
:copen 10           # 打开 Quickfix 窗口，并且设置高度为 10
:cfir[st]           # 跳转到 Quickfix 窗口中第 1 个错误
:cla[st]            # 跳转到 Quickfix 窗口中最后 1 个错误
:cl[ist]            # 在 Quickfix 窗口中列出所有错误
:cc [N]             # 显示第 N 个错误的详细信息
:cn[ext]            # 定位到 Quickfix 窗口中下一个错误
:cp[rev]            # 定位到 Quickfix 窗口中上一个错误
:cold[er]           # 到前一个旧列表
:cnew               # 到后一个新列表

Copied!

文件编码

:e ++enc=utf8 {file}         # UTF-8 编码打开 file 文件。
:w ++enc=gbk                 # 不管当前文件什么编码，把它转存成 GBK 编码。
:set encoding                # Vim 内部编码查看          
:set encoding=UTF-8          # Vim 内部编码修改
:set fileencoding            # 当前编辑的文件字符编码查看          
:set fileencoding=UTF-8      # 当前编辑的文件字符编码修改
:set fileencodings           # 查看 Vim 自动探测 fileencoding 的顺序列表          
:set fileencodings=UTF-8     # 修改 Vim 自动探测 fileencoding 的顺序列表
:h[elp] mbyte-options        # 查看 文件编码 帮助文档

Copied!

文件编码说明。

encoding（缩写：enc）: Vim 内部使用的字符编码方式，包括 Vim 的缓冲区、菜单文本、消息文本等。这个值一般用户不要设置，另外打开 Vim 之后再设置这个值也是没有意义的。大家可以将这个值看作是 Vim 程序自己的变量，如果在工作中遇到文件的编码问题，和 encoding 这个变量是万万没有关系的。
fileencoding（缩写：fenc）: Vim 中当前编辑的文件的字符编码方式，Vim 保存文件时也会将文件保存为这种字符编码方式。
fileencodings（缩写：fencs）: Vim 自动探测 fileencodings 的顺序列表，启动时会按照它所列出的字符编码方式从前到后，逐一探测即将打开的文件的字符编码方式，并且将 fileencoding 设置为最终探测到的字符编码方式。因此最好将 Unicode 编码方式放到这个列表的最前面，将拉丁语系编码方式 latin1 放到最后面。
termencoding（缩写：tenc）: Vim 所工作的终端字符编码方式。如果在终端环境下使用 Vim，需要设置 termencoding 和终端所使用的编码一致。

文件编码种类。

ucs-bom：非常严格的编码，非该编码的文件几乎没有可能被误判为 ucs-bom，因此一般放在第一位。
utf-8：相当严格的编码，除了很短的文件之外也是几乎不可能被误判的，因此一般放在第二位。
chinese：相对宽松的编码，在 Unix 里表示 GB2312，在 Windows 里表示 cp936，也就是 GBK 的别名。
cp936：相对宽松的编码，cp936 是 GBK 的别名，是 GB2312 的超集，可以支持繁体汉字，也避免出现删除半个汉字的情况。
latin1：最为宽松的编码，则放在列表的最后。

如果编码被误判了，解码后的结果就会显示为无法识别的乱码了。此时，如果你知道这个文件的正确编码，可以把 fileencodings 改成只有这一种编码，阻止任何 fall-back 发生，然后重新打开这个文件。

帮助信息

:h[elp] {command}   # 显示相关命令的帮助，也可以就输入 :help 而不跟命令，退出帮助需要输入 :q
:h tutor            # 入门文档
:h quickref         # 快速帮助
:h index            # 查询 Vim 所有键盘命令定义
:h summary          # 帮助你更好的使用内置帮助系统
:h Ctrl+H           # 查询普通模式下 Ctrl+H 是干什么的
:h i_Ctrl+H         # 查询插入模式下 Ctrl+H 是干什么的
:h i_<Up>           # 查询插入模式下方向键上是干什么的
:h pattern.txt      # 正则表达式帮助
:h eval             # 脚本编写帮助
:h function-list    # 查看 VimScript 的函数列表 
:h windows.txt      # 窗口使用帮助
:h tabpage.txt      # 标签页使用帮助
:h +timers          # 显示对 +timers 特性的帮助
:h :!               # 查看如何运行外部命令
:h tips             # 查看 Vim 内置的常用技巧文档
:h set-termcap      # 查看如何设置按键扫描码
:viu[sage]          # 显示普通命令的帮助。目的是为了模拟对应的 Nvi 命令
:exu[sage]          # 显示 Ex 命令的帮助。目的是为了模拟对应的 Nvi 命令
:ve[rsion]          # 查看 Vim 版本，同时也查看 Vim 载入配置文件的优先顺序及所在位置
                        # -------------------- 常用帮助信息 --------------------
:h aug[roup]            # 查看自动命令组的帮助文档
:h internal-variables   # 获取更多变量作用域的帮助信息

Copied!

有点意思

xp                  # 交换两个字符
ddp                 # 交换两行
bi                  # 单词前加入字符
ea                  # 单词后加入字符
[N]r<Enter>         # 用一个换行符替换 N 个字符
g Ctrl+G            # 单词统计，按 g 再同时按 Ctrl+g 组合键

Copied!

约定规范

本文档使用的各种特定字符，按照以下内容进行约定规范。

[]                  # 表示方括号里的字符可选，可达到减少键盘输入及重复操作的目的
[count]             # 可选的数值，可用在命令前以倍数或重复该命令
["x]                # 可选的用于存储文本的寄存器。参见 registers，x 代表从 'a-zA-z' 的英文字母
{}                  # 花括号里的内容是命令中必须出现的，但是可以取不同的值
{char1-char2}       # 在 char1 到 char2 区间内的 1 个字符，例如 {a-z} 是一个小写字母
{motion}            # 表示动作，移动光标的命令或动作
{operator}          # 表示操作符，用于对文本进行删除或修改操作的命令
{visual}            # 选中的文本区域，先用 v、V 或者 Ctrl+v 设定开始位置，然后用移动光标的命令来选定选择文本的另一端
Ctrl+{char}         # 作为控制字符输入的 {char}；即按住 Ctrl 键再按 {char}，{char} 是大写字母还是小写字母都一样

Copied!

按键说明

下面这些按键的名称文档里会用到。它们也可以用在 :map 映射命令里，详情参见 vimrc 配置文件 。

标识符               # 含义

<Nul>               # 数字 0 
<BS>                # 退格键 <Backspace>
<Tab>               # 制表符 <Tab>
<NL>                # 换行符
<FF>                # 换页符
<CR>                # 回车符 <Enter>
<Return>            # 同 <CR> 即 <Return> 
<Enter>             # 同 <CR> 即 <Enter> 
<Esc>               # 转义 
<Space>             # 空格键
<lt>                # 小于号 <
<Bslash>            # 反斜杠 \
<Bar>               # 竖杠 |
<Del>               # 删除键
<CSI>               # 命令序列引入
<xCSI>              # 图形界面的 CSI
<EOL>               # 行尾 (可以是 <CR>、<NL> 或 <CR><NL>，根据不同的系统和 fileformat 而定)

<Up>                # 光标上移键
<Down>              # 光标下移键
<Left>              # 光标左移键
<Right>             # 光标右移键
<S-Up>              # Shift ＋ 光标上移键
<S-Down>            # Shift ＋ 光标下移键
<S-Left>            # Shift ＋ 光标左移键
<S-Right>           # Shift ＋ 光标右移键
<C-Left>            # Ctrl ＋ 光标左移键
<C-Right>           # Ctrl ＋ 光标右移键
<F1>-<F12>          # 功能键 1 到 12
<S-F1>-<S-F12>      # Shift ＋ 功能键 1 到 12 
<Help>              # 帮助键
<Undo>              # 撤销键
<Insert>            # Insert 键
<Home>              # Home
<End>               # End
<PageUp>            # Page-up
<PageDown>          # Page-down

<kHome>             # 小键盘 Home (左上)
<kEnd>              # 小键盘 End (左下)
<kPageUp>           # 小键盘 Page-up (右上)
<kPageDown>         # 小键盘 Page-down (右下)
<kPlus>             # 小键盘 +
<kMinus>            # 小键盘 -
<kMultiply>         # 小键盘 *
<kDivide>           # 小键盘 /
<kEnter>            # 小键盘 Enter
<kPoint>            # 小键盘 小数点
<k0>-<k9>           # 小键盘 0 到 9

<S-...>             # Shift ＋ 其它键
<C-...>             # Ctr ＋ 其它键
<M-...>             # Alt ＋ 键 或 Meta ＋ 键
<A-...>             # 同 <M-...>

Copied!

使用建议

多使用 :h[elp] {command} 获取显示相关命令的帮助文档，提高相关命令的认识水平。
永远不要用 Ctrl+C 代替完全不同的含义，容易错误中断运行的后台脚本。
很多人使用 Ctrl+[ 代替，左手小指 Ctrl，右手小指 [ 熟练后很方便。
某些终端中使用 Vim 8 内嵌终端如看到奇怪字符，使用 :set t_RS= t_SH= 解决。
某些终端中使用 NeoVim 如看到奇怪字符，使用 :set guicursor= 解决。
多使用 ciw, ci[, ci”, ci( 以及 diw, di[, di”, di( 命令来快速改写/删除文本。
在行内左右移动光标时，多使用 w b e 或 W B E，而不是 h l 或方向键，这样会快很多。
Shift 上档键相当于移动加速键， w b e 移动光标很慢，但是 W B E 走的很快。
自己要善于总结新技巧，例如移动到行首非空字符时用 0w 命令比 ^ 命令更容易输入。
在空白行使用 dip 命令可以删除所有临近的空白行，viw 可以选择连续空白。
缩进时使用 >8j >} ap =i} == 会方便很多；文档以常规、6、9 个空格间隔缩进。
插入模式下，当你发现一个单词写错了，应该多用 Ctrl+W 这比退格键快。
y d c 命令可以很好结合 f t 和 /X 例如 dt) 和 y/End。
c d x 命令会自动填充寄存器 “1 到 “9 ，y 命令会自动填充 “0 寄存器。
用 v 命令选择文本时，可以用 0 掉头选择，有时很有用。
写文章时，可以写一段代码块，然后选中后执行 :!python 代码块就会被替换成结果。
搜索后经常使用 :nohl 来消除高亮，使用很频繁，可以 map 到上。
搜索时可以用 Ctrl+R Ctrl+W 插入光标下的单词，命令模式也能这么用。
映射按键时，应该默认使用 noremap ，只有特别需要的时候使用 map。
用 y 复制文本后，命令模式中 Ctrl+R 然后按双引号 0 可以插入之前复制内容。
Windows 下的 GVim 可以设置 set rop=type:directx, renmode:5 增强显示。
当你觉得做某事很低效时，你应该停下来，然后思考正确的高效方式来完成。

网络资源

最新版本 Vim：https://github.com/vim/vim
Windows 版：https://github.com/vim/vim-win32-installer/releases
插件浏览：http://vimawesome.com
正确设置 Alt 换挡键：http://www.skywind.me/blog/archives/2021
视频教程：http://vimcasts.org/
中文帮助：http://vimcdoc.sourceforge.net/doc/help.html
中文版入门到精通：https://github.com/wsdjeg/vim-galore-zh_cn
五分钟脚本入门：http://www.skywind.me/blog/archives/2193
脚本精通：http://learnvimscriptthehardway.stevelosh.com/
十六年使用经验：http://zzapper.co.uk/vimtips.html
配色方案：http://vimcolors.com/

vim键盘图

其他图

正则表达式的模式

默认是 magic,正则表达式元字符如 .、*、? 等是有效的
nomagic 模式下，只有 ^ 和 $ 仍作为元字符，其它的元字符需要转义才能使用
very magic 模式下，几乎所有字符都被视为元字符，不需要转义
very nomagic 模式下，几乎所有字符都被视为普通字符，必须显式转义

Ctrl按键

`CtrlKey`	Normal	Insert	Visual	Command
`C-a`	将光标下的数字加1	插入上一次插入的文本(i文本`esc`a`C-a`)	将光标下的数字加1
`C-b`	向上滚动一页	光标左移一个字符（终端中的行为）
`C-c`		退出插入模式		中断当前命令
`C-d`	向下滚动半页	减少缩进
`C-e`	向下滚动一行	插入一个来自插入点以下的字符(若光标所在列在下一行存在字符)（终端中的行为）
`C-f`	向下滚动一页	光标右移一个字符（终端中的行为）
`C-g`	显示文件信息
`C-h`	无功能	删除前一个字符（等同于退格键）
`C-i`	跳转到下一个位置(前进)	插入一个制表符（等同于 `Tab`）
`C-j`	无功能	插入新行（等同于 `CR`和`C-m`）
`C-k`	无功能	无功能
`C-l`	无功能(清除并重绘屏幕)	无功能
`C-m`		插入新行（等同于 `CR`和`C-j`）
`C-n`		选择补全菜单中的下一项
`C-o`	光标跳转后,回到原来的位置(后退)	插入模式中的单命令执行：在插入模式下按 `Ctrl-O`，你可以临时执行一个普通模式命令，然后自动返回插入模式
`C-p`		选择补全菜单中的上一项
`C-q`	进入可视块模式(等同于`C-v`)（在某些终端中）
`C-r`	按下`u`撤销输入后, 重做	插入寄存器内容		插入寄存器内容
`C-s`	无默认行为（在某些终端中暂停输出）
`C-t`		增加缩进
`C-u`	向上滚动半页	删除当前行之前的所有字符		删除当前行之前的所有字符
`C-v`	进入可视块模式
`C-w`	窗口命令前缀	删除光标前一个单词
`C-x`		进入 `Ctrl-X 模式`（用于补全）
`C-y`	向上滚动一行	从上一行复制字符到光标处
`C-z`	挂起 Vim（在 Unix 系统中）

`C-[`		退出插入模式（等同于 `Esc`）
`C-\`	进入插入模式的 `Ctrl-\ 模式`
`C-]`	跳转到光标下标签定义处
`C-^`	切换到上一个缓冲区
`C-@`		插入 `NUL` 字符
`C-0`到 `C-9`	无默认行为	无默认行为	无默认行为	无默认行为

Ctrl-X模式

在 Vim 中，Ctrl-X 模式是插入模式下的一组补全命令，可以提供多种类型的补全。以下是常用的 Ctrl-X 模式补全类型及其作用：

常见的 `Ctrl-X` 模式补全类型

文件名补全（Ctrl-X Ctrl-F）
- 快捷键：Ctrl-X Ctrl-F
- 功能：补全文件名。
- 用法：输入文件路径的部分内容，然后按 Ctrl-X Ctrl-F 来补全文件名。
关键字补全（Ctrl-N 和 Ctrl-P）
- 快捷键：Ctrl-N（下一个）、Ctrl-P（上一个）
- 功能：补全当前缓冲区中出现的关键字。
- 用法：输入关键字的部分内容，然后按 Ctrl-N 或 Ctrl-P 来补全。
字典补全（Ctrl-X Ctrl-K）
- 快捷键：Ctrl-X Ctrl-K
- 功能：根据字典文件补全单词。
- 用法：输入单词的部分内容，然后按 Ctrl-X Ctrl-K 来补全。
标签补全（Ctrl-X Ctrl-]）
- 快捷键：Ctrl-X Ctrl-]
- 功能：根据标签补全。
- 用法：输入标签的部分内容，然后按 Ctrl-X Ctrl-] 来补全。
文件中的定义补全（Ctrl-X Ctrl-I）
- 快捷键：Ctrl-X Ctrl-I
- 功能：补全当前文件中所有包含的定义。
- 用法：输入单词的部分内容，然后按 Ctrl-X Ctrl-I 来补全。
用户定义补全（Ctrl-X Ctrl-U）
- 快捷键：Ctrl-X Ctrl-U
- 功能：使用用户定义的补全方法。
- 用法：输入单词的部分内容，然后按 Ctrl-X Ctrl-U 来补全。
拼写建议补全（Ctrl-X Ctrl-S）
- 快捷键：Ctrl-X Ctrl-S
- 功能：提供拼写建议。
- 用法：输入单词的部分内容，然后按 Ctrl-X Ctrl-S 来补全。
完整的 Ctrl-X 补全菜单
- Ctrl-X Ctrl-L：整行补全。
- Ctrl-X Ctrl-V：补全 Vim 选项。
- Ctrl-X Ctrl-D：宏定义补全。
- Ctrl-X Ctrl-O：补全 Omni 语法（如 LSP 补全）。

示例操作

文件名补全

输入部分文件路径，例如 ~/do。
按 Ctrl-X Ctrl-F，Vim 会尝试补全文件名，例如补全为 ~/documents/。

关键字补全

输入部分单词，例如 var.
按 Ctrl-N 或 Ctrl-P，Vim 会在当前缓冲区中搜索关键字并补全，例如补全为 various。

标签补全(代码中的标识符，如函数名、变量名、类名等)

输入部分标签名，例如 fea。
按 Ctrl-X Ctrl-]，Vim 会根据标签补全，例如补全为 features。

hugo博客-配置baseUrl的坑

Wed, 10 Apr 2024 00:00:00 +0800

hugo博客配置baseUrl的坑

本地启动

不管配置文件怎么改，默认的baseUrl都为localhost，bind的ip为127.0.0.1;
生成的public里的html中的url都不会是你配置文件里的baseUrl
-D包含草稿

`1`	`hugo server -D`

Copied!

除非在后面加上 –baseURL

`1`	`hugo server -D --baseURL http://www.xxx.com/`

Copied!

启动局域网连接

`1`	`hugo server -D --bind=0.0.0.0 --port=1313`

Copied!

所以本地开发测试时，不需要关心baseUrl，server启动时就一定是localhost

本地或服务器打包

打包时，hugo会严格按照配置文件中的baseUrl创建静态页面，与--environment无关
--gc构建站点时会自动执行垃圾回收;--minify对输出的 HTML、CSS 和 JavaScript 进行压缩和优化

`1`	`hugo -D --gc --minify`

Copied!

服务器多环境打包

我的博客，同一套代码在github pages和vercel上都有部署,分别是不同的域名，所以就需要区分两个环境的baseUrl,我是这样做的：

把原本的hugo.yaml当作是vercel 的配置，复制原本的配置为hugo-git.yaml当作github pages的配置
两个文件只有baseUrl不同
在启动Hugo打包的时候，需要加具体的配置文件名参数

1
2

hugo -D --gc --minify --config hugo.yaml # 在vercel上使用，默认为vercel
hugo -D --gc --minify --config hugo-git.yaml #在github action中使用

Copied!

图片相关模板

Sat, 20 Apr 2024 00:00:00 +0800

放在同一个目录下的图片，支持PhotoSwipe图册

图片自动在一个图册里,默认需要 回车 或者其他元素，改动gallery.ts，注释if (!isNewLineImage) continue; Photo by mymind and Luke Chesser on Unsplash

网络链接支持PhotoSwipe图册

static目录支持PhotoSwipe图册

assets目录支持PhotoSwipe图册

svg不支持PhotoSwipe图册

使用figure短代码引入图片

vh为相对于窗口高度的百分比短代码的页绑定图片和全局图片都可以使用PhotoSwipe图册，网络链接不可以

页绑定图片

全局图片

网络链接

可以写markdown

图片轮播引入全局资源

图片轮播引入网络链接

img标签引入图片

使用imgproc，不能使用网络链接

这是本地图片

用gallery短代码引入网络图片

其他模板

Wed, 10 Apr 2024 00:00:00 +0800

原生代码块

window.addEventListener("onColorSchemeChange", (colorScheme) => {
  yzhanweather.clear() // Stop and clear all animations
  //yzhanweather.destory() // Destory the instance and free up memory
  yzhanweather_fun();
});

Copied!

highlight shortcode 高亮代码

42{{ range .Pages }}
43<h2><a href="{{ .RelPermalink }}">{{ .LinkTitle }}</a></h2>
44{{ end }}

md高亮代码

`1`	`echo "hello"`

Copied!

Gitlab Snippets Shortcode

Github Card

`1`	`\{\{< github title="gohugoio/hugo" >\}\}`

Copied!

Quote Shortcode

Stack adds a quote shortcode. For example:

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
― A famous person, The book they wrote

bilibilibi Shortcode,1为自动播放，0为手动播放

网易云,1为自动播放，0为手动播放

获取电影数据，打包时需要魔法；把\去掉

{{< neodb “https://neodb.social/book/5SJvkuHNGL4XhBddW2J4EJ" >}} {{< neodb “https://neodb.social/movie/1bgVODaWCBKlCQ1AuGlLzC" >}} {{< neodb “https://neodb.social/tv/season/5es8Us1HHOhVz3UlLmTspr" >}} {{< neodb “https://neodb.social/game/5pvs201VxbkldH4LOEtDVt" >}} {{< neodb “https://neodb.social/podcast/5tlY7lSI0WfXcoHstz7u4S" >}}

测试标题，一级(顶级)

奥斯特洛夫斯基曾经说过，共同的事业，共同的斗争，可以使人们产生忍受一切的力量。而这些并不是完全重要，更加重要的问题是，带着这些问题，我们来审视一下学生会退会

二级

三级

四级

五级

六级

####### 七级没有处理，没有样式奥斯特洛夫斯基曾经说过，共同的事业，共同的斗争，可以使人们产生忍受一切的力量。而这些并不是完全重要，更加重要的问题是，带着这些问题，我们来审视一下学生会退会

时间轴

2023-09-10

聊天气泡

John Doe 2023-09-12 14:30

这是左边的消息内容。

2023-09-12 14:45 Alice

这是右边的消息内容，测试长长长长长长长长长长长长长长长长长长长长长长长长度。

文字渐变色

我挑的配色很好看吧！
好喜欢蓝色（再次）（再次）
但总之换行的话就加个空标签。

文字高斯模糊

一些手动打码效果！
但总之换行的话就加个空标签。

github卡片

内容折叠

用法

在markdown里写下

键盘标签

在 Windows 操作系统中，「复制」功能的快捷键是：CTRL + C

总星数实际星数

卡片

可以在这里插入链接假装是卡片式链接。
好像不能插入图片？
换行需要空标签。实际使用需要双括号。

代码折叠

package com.logan;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import io.lettuce.core.ReadFrom;
import org.springframework.boot.autoconfigure.data.redis.LettuceClientConfigurationBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;

/**
 * @author logan
 * @version 1.0
 * @date 2022/5/24
 */
@Configuration
public class RedisConfig {

    /**
     * 配置redis集群的读写分离
     */
    @Bean
    public LettuceClientConfigurationBuilderCustomizer clientConfigurationBuilderCustomizer() {
        return clientConfigurationBuilder -> clientConfigurationBuilder.readFrom(ReadFrom.REPLICA_PREFERRED);
    }

    /**
     * 集群客户端是不支持多数据库db的，只有一个数据库默认是SELECT 0;
     */
    @Bean
    public RedisTemplate customRedisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        //创建新的redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //设置key序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        //设置value序列化
        redisTemplate.setValueSerializer(new GenericFastJsonRedisSerializer());
//        redisTemplate.setValueSerializer(RedisSerializer.json());
        redisTemplate.setHashValueSerializer(RedisSerializer.json());
        //设置连接工厂
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        return redisTemplate;
    }
}

Copied!

卡片链接

hugo-theme-luna

A simple, performance-first, SEO-friendly Hugo theme hugo-theme-luna.

https://github.com/Ice-Hazymoon/hugo-theme-luna

Markdown语法指南

Fri, 10 May 2024 00:00:00 +0800

Markdown语法指南

概述

Markdown 由 Daring Fireball 创建，原始指南在这里。但是，它的语法因不同的解析器或编辑器而异。Typora
正在使用 [GitHub Flavored Markdown][GFM]。

块元素

段落和换行符

在普通文本中/普通段落/引用(quote) 中遵循以下规律;
在代码块或者有序或者无序列表中,一个回车就是换行

语法层面：
1. 使用两个以上空格加上回车
  - 注意某些非markdown的编辑器会自动删除行尾空格，比如使用了 EditorConfig 的, 需要设置:
    1 2
    
    [*.md] # 对所有 md 文件生效 trim_trailing_whitespace = false # 保留行末的空格
    Copied!
2. 也可以在段落后面使用一个空行来表示重新开始一个段落
在Typora中
- 编辑->空格与换行->取消‘保留单换行符’，即严格换行模式
- 您只需按下 Return 即可创建新段落。
- 按 Shift + Return 可创建单个换行符。但是，大多数 markdown 解析器将忽略单行中断，要使其他 markdown 解析器识别您的换行符，可以在行尾留下两个空格，或者插入  .
在Obsidian中
- 使用easy-typing-obsidian 插件，可以保证在普通段落编辑时，每次按回车换行时，生成两个换行符
- 也可以使用在行尾留下两个空格，然后按回车，来手动换行
- 按 Shift + Return 可创建单个换行符，渲染时会变成同一行

标题

标题在行的开头使用1-6个＃字符，对应于标题级别1-6。例如：

# 这是一级标题

## 这是二级标题

###### 这是六级标题

Copied!

在typora中，输入＃后跟标题内容，按下 Return 键将创建标题。

引用文字

Markdown 使用 > 字符进行块引用。在typora中，只需输入’>‘后跟引用内容即可生成块引用。Typora将为您插入正确的“>”或换行符。通过添加额外级别的“>”允许在块引用内嵌入另一个块引用。它们表示为：

> 这是一级缩进  
>> 这是二级缩进  
>>> 这是三级缩进  
> 
>> 再来一个二级缩进  
>>> 再来一个三级缩进  

>> 这是新的块引用

Copied!

效果如下：

这是一级缩进

这是二级缩进

这是三级缩进

再来一个二级缩进

再来一个三级缩进

这是新的块引用

列表

输入 - list item 1 将创建一个无序列表，该 - 符号可以替换为 + 或 *.

输入 1. list item 1 将创建一个有序列表，有序和无序列表都可以缩进, 其 markdown 源代码如下：

#### 无序列表
- 红色
  - 绿色
- 蓝色

#### 有序列表
1. 红色
   1. 绿色
2. 蓝色

Copied!

效果：

无序列表

红色
- 绿色
蓝色

有序列表

红色
1. 绿色
蓝色

任务列表

任务列表是标记为[ ]或[x]（未完成或完成）的项目的列表。例如：

- [ ] 这是一个任务列表项
- [ ] 需要在前面使用列表的语法
- [ ] normal **formatting**, @mentions, #1234 refs
- [ ] 未完成
- [x] 完成

Copied!

效果：

这是一个任务列表项
需要在前面使用列表的语法
normal formatting, @mentions, #1234 refs
未完成
完成

您可以通过单击项目前面的复选框来更改完成/未完成状态。

（栅栏式）代码块

Typora仅支持 Github Flavored Markdown 中的栅栏式代码块。不支持 markdown 中的原始代码块。

使用栅栏式代码块很简单：输入```之后输入一个可选的语言标识符，然后按return键后输入代码，我们将通过语法高亮显示它：

这是一个例子：

```
function test() {
  console.log("notice the blank line before this function?");
}
```

语法高亮：
```javascript
function test() {
  console.log("notice the blank line before this function?");
}
```

Copied!

还可以给代码块设置额外的class、行号是否显示、缩进等

```javascript{class="md-reference-block" lineNos=false tabWidth=2}
function test() {
  console.log("notice the blank line before this function?");
}
```

Copied!

数学公式块

您可以使用 MathJax 渲染 LaTeX 数学表达式。

typora中输入 $$, 然后按“return”键将触发一个接受Tex / LaTex源代码的输入区域。
在 markdown 源文件中，数学公式块是由$$标记包装的 LaTeX 表达式：

$$
\mathbf{V}_1 \times \mathbf{V}_2 =  \begin{vmatrix} 
\mathbf{i} & \mathbf{j} & \mathbf{k} \\
\frac{\partial X}{\partial u} &  \frac{\partial Y}{\partial u} & 0 \\
\frac{\partial X}{\partial v} &  \frac{\partial Y}{\partial v} & 0 \\
\end{vmatrix}
$$

Copied!

表格

输入 | First Header | Second Header | 并按下 return 键将创建一个包含两列的表。

创建表后，焦点在该表上将弹出一个表格工具栏，您可以在其中调整表格，对齐或删除表格。您还可以使用上下文菜单来复制和添加/删除列/行。

可以跳过以下描述，因为表格的 markdown 源代码是由typora自动生成的。

在 markdown 源代码中，它们看起来像这样：

| First Header  | Second Header |
| ------------- | ------------- |
| Content Cell  | Content Cell  |
| Content Cell  | Content Cell  |

Copied!

效果：

First Header	Second Header
Content Cell	Content Cell
Content Cell	Content Cell

您还可以在表格中包括内联 Markdown 语法，例如链接，粗体，斜体或删除线。

最后，通过在标题行中包含冒号：您可以将文本定义为左对齐，右对齐或居中对齐：

| Left-Aligned  | Center Aligned  | Right Aligned |
| :------------ |:---------------:| -----:|
| col 3 is      | some wordy text | $1600 |
| col 2 is      | centered        |   $12 |
| zebra stripes | are neat        |    $1 |

Copied!

效果：

Left-Aligned	Center Aligned	Right Aligned
col 3 is	some wordy text	$1600
col 2 is	centered	$12
zebra stripes	are neat	$1

最左侧的冒号表示左对齐的列; 最右侧的冒号表示右对齐的列; 两侧的冒号表示中心对齐的列。

脚注

您可以在任何位置像这样创建脚注，他会显示在文章结尾处：

[^1]: 这是脚注的内容

Copied!

使用脚注：

这是一个需要添加脚注的文本[^1]。

Copied!

效果：
这是一个需要添加脚注的文本¹。

鼠标移动到‘1’上标中查看脚注的内容。

水平线

输入 *** 或 --- 或<hr/>在空行上按 return 键将绘制一条水平线。
效果：

目录 (TOC)

typora中输入 [toc] 然后按 Return 键将创建一个“目录”部分，自动从文档内容中提取所有标题，其内容会自动更新。

缩进

1、图片缩进

1.1 在列表中

列表中某个层级按下回车后，继续按回车直到光标在无缩进的行首，再粘贴图片语句，移动光标到行首，按下tab键调整缩进，经渲染后图片会配合列表自动缩进；
如果是有序列表，直接按回车到行首会影响后面的前标，要不影响的话，可以使用shift+return，然后删除缩进到行首，然后再回车换行，插入语句，回车换行
但是在普通段落中，用tab键调整图片的缩进，是不可行的，必须要和列表配合;
图片的上下必须用空行与列表隔开；

如：

aaaaaa
1. bbbbbb
2. cccccc
3. dddddd
4. eeeeee

1.2 使用css

但是在某些渲染环境中不能正常显示（如github的渲染）

这是图片的标题

2、代码块缩进

2.1 在列表中

列表中某个层级按下回车后，继续按回车直到光标在无缩进的行首，再粘贴代码块语句，选中整个代码块语句，按下tab键调整缩进，经渲染后代码块会配合列表自动缩进；
如果是有序列表，直接按回车到行首会影响后面的前标，要不影响的话，可以使用shift+return，然后删除缩进到行首，然后再回车换行，插入语句，回车换行
但是在普通段落中，用tab键调整代码块的缩进，是不可行的，必须要和列表配合;
代码块的上下必须用空行与列表隔开；

如：

aaaaaa

bbbbbb

cccccc

1
2
3

function calculate(t, i) {  
  return Math.random() * (i - t) + t  
}

Copied!

dddddd
eeeeee

2.2 使用css

与图片用css缩进类似，在某些渲染环境中不能正常显示（如github的渲染）


function calculate(t, i) {  
  return Math.random() * (i - t) + t  
}

行元素

在您输入后行元素会被立即解析并呈现。在这些span元素上移动光标会将这些元素扩展为markdown源代码。以下将解释这些span元素的语法。

链接

Markdown 支持两种类型的链接：内联和引用。

在这两种样式中，链接文本都写在[方括号]内。

要创建内联链接，请在链接文本的结束方括号后立即使用一组常规括号。在常规括号内，输入URL地址，以及可选的用引号括起来的链接标题。例如：

This is [an example](http://example.com/ "Title") inline link.

[This link](http://example.net/) has no title attribute.

Copied!

效果：

This is an example inline link.

This link has no title attribute.

内部链接

您可以将常规括号内的 href 设置为文档内的某一个标题，这将创建一个书签，允许您在单击后跳转到该部分。
typora中需要Command(在Windows上：Ctrl) + 单击将跳转到标题 块元素处。

[内部跳转](#脚注)
[外部跳转](/articles/with-hugo/page-a#title_a)

Copied!

效果：
内部跳转
 外部跳转

链接引用

这种方法使得你可以在文档中的多个地方引用同一个链接，而不需要重复输入链接的地址和标题。
在文档中的任何位置,创建一个链接引用：

[bd]: https://www.baidu.com	"百度搜索"

Copied!

使用方式：

这是一个[百度][bd]链接。

Copied!

效果：
这是一个百度链接。

隐式链接名称快捷方式允许您省略链接的名称，在这种情况下，链接文本本身将用作名称：

创建：

[Google]: https://www.google.com

效果：

这是一个[Google][]链接。

Copied!

效果：

这是一个Google 链接。

URL网址

Typora允许您将 URL 作为链接插入，用 <括号括起来>。

<i@typora.io> 成为 i@typora.io .

Typora也将自动链接标准URL。例如： www.google.com .

图片

图像与链接类似，但在链接语法之前需要添加额外的 ! 字符。图像语法如下所示：

![替代文字](/path/to/img.jpg)

![替代文字](/path/to/img.jpg "可选标题")

Copied!

在typora中您可以使用拖放操作从图像文件或浏览器来插入图像。并通过单击图像修改 markdown 源代码。如果图像在拖放时与当前编辑文档位于同一目录或子目录中，则将使用相对路径。

强调（斜体）

Markdown 将星号 (*) 和下划线(_) 视为强调的指示。用一个 * or _ 包裹文本将使用HTML  标签包裹文本。用两个 * or _ 包裹文本将使用HTML  标签包裹文本。

1
2
3

<em> 元素用于表示强调文本，通常以斜体样式显示。它的语义意义是“强调”或“重点”，而不是特定的样式。浏览器默认会以斜体显示 <em> 元素的内容，但是它的确切样式取决于 CSS 样式表中的定义。

<strong> 元素用于表示重要文本，通常以加粗样式显示。它的语义意义是“重要”，而不是特定的样式。浏览器默认会以加粗显示 <strong> 元素的内容，但是它的确切样式同样取决于 CSS 样式表中的定义。

Copied!

例如：

*一个星号*

_一个下划线_

**两个星号**

__两个下划线__

Copied!

效果：

一个星号

一个下划线

两个星号

两个下划线

块引用中将忽略单词中的下划线，这通常用在代码和名称中，如下所示：

wow__great__stuff

do__this__and_do__that__and_another_thing.

要在用作强调分隔符的位置生成文字星号或下划线，可以用反斜杠转义：

**这个文字被文字星号包围**

推荐使用*

代码

要指示代码范围，请使用反引号（`）进行包裹。与预格式化的代码块不同，代码跨度表示正常段落中的代码。例如：

aa`bb`cc

Copied!

效果：

aabbcc

删除线

GFM通过添加语法来创建删除线文本，标准的Markdown中缺少该功能。

~~错误的文字。~~ 变成 ~~错误的文字。~~

下划线

下划线由原始HTML提供支持。

下划线 变成下划线

表情符号 :smile:

输入表情符号的语法是 :smile:
在typora中，用户可以通过 ESC 按键触发表情符号的自动完成建议，或者在偏好设置面板里启用后自动触发表情符号。此外，还支持直接从 Edit -> Emoji & Symbols 菜单栏输入UTF8表情符号字符。

内联数学公式

在typora中，要使用此功能，首先，请在 偏好设置 面板 -> Markdown扩展语法 选项卡中启用它。然后使用 $ 来包裹TeX命令，例如： $\lim_{x \to \infty} \exp(-x) = 0$ 将呈现为LaTeX命令。

要触发内联公式的预览提示功能：输入“$”, 然后按 ESC 键, 然后输入TeX命令, 预览工具提示将如下所示：

下标

在typora中，要使用此功能，首先，请在 偏好设置 面板 -> Markdown扩展语法 选项卡中启用它。然后用 ~ 来包裹下标内容，例如： H~2~O, X~long\ text~Y

效果:

H2O X~~long\ text~~Y

上标

在typora中，要使用此功能，首先，请在 偏好设置 面板 -> Markdown扩展语法 选项卡中启用它。然后用 ^ 来包裹上标内容，例如： X^2^。

效果:

X^2^

高亮

在typora中，要使用此功能，首先，请在 偏好设置 面板 -> Markdown扩展语法 选项卡中启用它。然后用 == 来包裹高亮内容，例如： ==highlight==。

效果:

==highlight==

HTML

您可以使用HTML来设置纯 Markdown 不支持的内容，例如， this text is red 用于添加红色文本。

嵌入内容

有些网站提供基于iframe的嵌入代码，您也可以将其粘贴到Markdown中，例如：

<iframe height='265' scrolling='no' title='Fancy Animated SVG Menu' src='http://codepen.io/jeangontijo/embed/OxVywj/?height=265&theme-id=0&default-tab=css,result&embed-version=2' frameborder='no' allowtransparency='true' allowfullscreen='true' style='width: 100%;'></iframe>

Copied!

视频

您可以使用 <video> HTML标记嵌入视频，例如：

<video src="xxx.mp4" />

Copied!

其他 HTML 支持

你可以在这里找到细节。

这是脚注的内容 ↩︎

maven概述

Sun, 03 Mar 2024 12:49:51 +0800

http://heavy_code_industry.gitee.io/code_heavy_industry/

https://maven.apache.org/index.html

https://mvnrepository.com/

https://www.bilibili.com/video/BV12q4y147e4?spm_id_from=333.337.search-card.all.click

1、maven介绍

①、概述

Maven 是一款『构建管理』和『依赖管理』的工具。但事实上这只是 Maven 的一部分功能。Maven 本身的产品定位是一款『项目管理工具』

②、maven工作机制

maven仓库里有：自己项目打包成的jar、第三方jar、maven核心程序需要用到的插件jar（clean、test、package）

③、功能

从『项目管理』的角度来看，Maven 提供了如下这些功能：

项目对象模型（POM）：将整个项目本身抽象、封装为应用程序中的一个对象，以便于管理和操作。
全局性构建逻辑重用：Maven 对整个构建过程进行封装之后，程序员只需要指定配置信息即可完成构建。让构建过程从 Ant 的『编程式』升级到了 Maven 的『声明式』。
构件的标准集合：在 Maven 提供的标准框架体系内，所有的构件都可以按照统一的规范生成和使用。
构件关系定义：Maven 定义了构件之间的三种基本关系，让大型应用系统可以使用 Maven 来进行管理
- 继承关系：通过从上到下的继承关系，将各个子构件中的重复信息提取到父构件中统一管理
- 聚合关系：将多个构件聚合为一个整体，便于统一操作
- 依赖关系：Maven 定义了依赖的范围、依赖的传递、依赖的排除、版本仲裁机制等一系列规范和标准，让大型项目可以有序容纳数百甚至更多依赖
插件目标系统：Maven 核心程序定义抽象的生命周期，然后将插件的目标绑定到生命周期中的特定阶段，实现了标准和具体实现解耦合，让 Maven 程序极具扩展性
项目描述信息的维护：我们不仅可以在 POM 中声明项目描述信息，更可以将整个项目相关信息收集起来生成 HTML 页面组成的一个可以直接访问的站点。这些项目描述信息包括：
- 公司或组织信息 organization
- 项目许可证 licenses
- 开发成员信息 developers
- issue 管理信息 issueManagement
- SCM 信息 scm 远程仓库支持

④、maven坐标

使用三个**『向量』在『Maven的仓库』中唯一的定位到一个『jar』**包。

groupId：公司或组织的 id
artifactId：一个项目或者是项目中的一个模块的 id
version：版本号

三个向量的取值方式

groupId：公司或组织域名的倒序，通常也会加上项目名称
- 例如：com.atguigu.maven
artifactId：模块的名称，将来作为 Maven 工程的工程名
version：模块的版本号，根据自己的需要设定
- 例如：SNAPSHOT 表示快照版本，正在迭代过程中，不稳定的版本
- 例如：RELEASE 表示正式版本

2、POM介绍

①、含义

POM：Project Object Model，项目对象模型。和 POM 类似的是：DOM（Document Object Model），文档对象模型。它们都是模型化思想的具体体现。

②、模型化思想

POM 表示将工程抽象为一个模型，再用程序中的对象来描述这个模型。这样我们就可以用程序来管理项目了。我们在开发过程中，最基本的做法就是将现实生活中的事物抽象为模型，然后封装模型相关的数据作为一个对象，这样就可以在程序中计算与现实事物相关的数据。

③、pom标签

POM 理念集中体现在 Maven 工程根目录下 pom.xml 这个配置文件中。所以这个 pom.xml 配置文件就是 Maven 工程的核心配置文件。其实学习 Maven 就是学这个文件怎么配置，各个配置有什么用。

下面是 spring-boot-starter 的 POM 文件，可以看到：除了我们熟悉的坐标标签、dependencies 标签，还有 description、url、organization、licenses、developers、scm、issueManagement 等这些描述项目信息的标签。

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.5.6</version>
  <name>spring-boot-starter</name>
  <description>Core starter, including auto-configuration support, logging and YAML</description>
  <url>https://spring.io/projects/spring-boot</url>
  <organization>
    <name>Pivotal Software, Inc.</name>
    <url>https://spring.io</url>
  </organization>
  <licenses>
    <license>
      <name>Apache License, Version 2.0</name>
      <url>https://www.apache.org/licenses/LICENSE-2.0</url>
    </license>
  </licenses>
  <developers>
    <developer>
      <name>Pivotal</name>
      <email>info@pivotal.io</email>
      <organization>Pivotal Software, Inc.</organization>
      <organizationUrl>https://www.spring.io</organizationUrl>
    </developer>
  </developers>
  <scm>
    <connection>scm:git:git://github.com/spring-projects/spring-boot.git</connection>
    <developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-boot.git</developerConnection>
    <url>https://github.com/spring-projects/spring-boot</url>
  </scm>
  <issueManagement>
    <system>GitHub</system>
    <url>https://github.com/spring-projects/spring-boot/issues</url>
  </issueManagement>

  <dependencies>
    <dependency>
      ……
    </dependency>
  </dependencies>
</project>

Copied!

3、POM的四个层次

①、超级pom

经过我们前面的学习，我们看到 Maven 在构建过程中有很多默认的设定。例如：源文件存放的目录、测试源文件存放的目录、构建输出的目录……等等。但是其实这些要素也都是被 Maven 定义过的。定义的位置就是：超级 POM。
关于超级 POM，Maven 官网是这样介绍的：

The Super POM is Maven’s default POM. All POMs extend the Super POM unless explicitly set, meaning the configuration specified in the Super POM is inherited by the POMs you created for your projects.

译文：Super POM 是 Maven 的默认 POM。除非明确设置，否则所有 POM 都扩展 Super POM，这意味着 Super POM 中指定的配置由您为项目创建的 POM 继承。

所以我们自己的 POM 即使没有明确指定一个父工程（父 POM），其实也默认继承了超级 POM。
就好比一个 Java 类默认继承了 Object 类。
位置：${MAVEN_HOME}/lib/maven-model-builder-3.5.0.jar里面 org\apache\maven\model\pom-4.0.0.xml

<?xml version="1.0" encoding="UTF-8"?>

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!-- START SNIPPET: superpom -->
<project>
  <modelVersion>4.0.0</modelVersion>

  <repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
      <releases>
        <updatePolicy>never</updatePolicy>
      </releases>
    </pluginRepository>
  </pluginRepositories>

  <build>
    <directory>${project.basedir}/target</directory>
    <outputDirectory>${project.build.directory}/classes</outputDirectory>
    <finalName>${project.artifactId}-${project.version}</finalName>
    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
    <scriptSourceDirectory>${project.basedir}/src/main/scripts</scriptSourceDirectory>
    <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
    <resources>
      <resource>
        <directory>${project.basedir}/src/main/resources</directory>
      </resource>
    </resources>
    <testResources>
      <testResource>
        <directory>${project.basedir}/src/test/resources</directory>
      </testResource>
    </testResources>
    <pluginManagement>
      <!-- NOTE: These plugins will be removed from future versions of the super POM -->
      <!-- They are kept for the moment as they are very unlikely to conflict with lifecycle mappings (MNG-4453) -->
      <plugins>
        <plugin>
          <artifactId>maven-antrun-plugin</artifactId>
          <version>1.3</version>
        </plugin>
        <plugin>
          <artifactId>maven-assembly-plugin</artifactId>
          <version>2.2-beta-5</version>
        </plugin>
        <plugin>
          <artifactId>maven-dependency-plugin</artifactId>
          <version>2.8</version>
        </plugin>
        <plugin>
          <artifactId>maven-release-plugin</artifactId>
          <version>2.5.3</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

  <reporting>
    <outputDirectory>${project.build.directory}/site</outputDirectory>
  </reporting>

  <profiles>
    <!-- NOTE: The release profile will be removed from future versions of the super POM -->
    <profile>
      <id>release-profile</id>

      <activation>
        <property>
          <name>performRelease</name>
          <value>true</value>
        </property>
      </activation>

      <build>
        <plugins>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-source-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-sources</id>
                <goals>
                  <goal>jar-no-fork</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-javadoc-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-javadocs</id>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-deploy-plugin</artifactId>
            <configuration>
              <updateReleaseInfo>true</updateReleaseInfo>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>

</project>
<!-- END SNIPPET: superpom -->

Copied!

②、父POM

和 Java 类一样，POM 之间其实也是单继承的。如果我们给一个 POM 指定了父 POM，那么继承关系如下图所示：

③、有效 POM

概念

有效 POM 英文翻译为 effective POM，它的概念是这样的——在 POM 的继承关系中，子 POM 可以覆盖父 POM 中的配置；如果子 POM 没有覆盖，那么父 POM 中的配置将会被继承。按照这个规则，继承关系中的所有 POM 叠加到一起，就得到了一个最终生效的 POM。显然 Maven 实际运行过程中，执行构建操作就是按照这个最终生效的 POM 来运行的。这个最终生效的 POM 就是有效 POM，英文叫effective POM。
查看有效 POM

mvn help:effective-pom

控制台会打印出来有效pom

④、小结

综上所述，平时我们使用和配置的 POM 其实大致是由四个层次组成的：

超级 POM：所有 POM 默认继承，只是有直接和间接之分。
父 POM：这一层可能没有，可能有一层，也可能有很多层。
当前 pom.xml 配置的 POM：我们最多关注和最多使用的一层。
有效 POM：隐含的一层，但是实际上真正生效的一层。

4、生命周期

①、构建过程

构建过程包含的主要的环节：

清理：删除上一次构建的结果，为下一次构建做好准备
编译：Java 源程序编译成 *.class 字节码文件
测试：运行提前准备好的测试程序
报告：针对刚才测试的结果生成一个全面的信息
打包
- Java工程：jar包
- Web工程：war包
安装：把一个 Maven 工程经过打包操作生成的 jar 包或 war 包存入 Maven 仓库
部署
- 部署 jar 包：把一个 jar 包部署到 Nexus 私服服务器上
- 部署 war 包：借助相关 Maven 插件（例如 cargo），将 war 包部署到 Tomcat 服务器上

为了让构建过程自动化完成，Maven 设定了三个生命周期，生命周期中的每一个环节对应构建过程中的一个操作。

②、三个生命周期

生命周期名称	作用	各个环节
Clean	清理操作相关	pre-clean clean post-clean
Site	生成站点相关	pre-site site post-site deploy-site
Default	主要构建过程	validate generate-sources process-sources generate-resources process-resources 复制并处理资源文件，至目标目录，准备打包。 compile 编译项目 main 目录下的源代码。 process-classes generate-test-sources process-test-sources generate-test-resources process-test-resources 复制并处理资源文件，至目标测试目录。 test-compile 编译测试源代码。 process-test-classes test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。 prepare-package package 接受编译好的代码，打包成可发布的格式，如JAR。 pre-integration-test integration-test post-integration-test verify install将包安装至本地仓库，以让其它项目依赖。 deploy将最终的包复制到远程的仓库，以让其它开发人员共享；或者部署到服务器上运行（需借助插件，例如：cargo）。

③、特点

前面三个生命周期彼此是独立的。
在任何一个生命周期内部，执行任何一个具体环节的操作，都是从本周期最初的位置开始执行，直到指定的地方。（本节记住这句话就行了，其他的都不需要记）

Maven 之所以这么设计其实就是为了提高构建过程的自动化程度：让使用者只关心最终要干的即可，过程中的各个环节是自动执行的。

5、仓库和镜像

①、仓库

本地仓库：在当前电脑上，为电脑上所有 Maven 工程服务
远程仓库：需要联网
- 局域网：我们自己搭建的 Maven 私服，例如使用 Nexus 技术。
- Internet
  - 中央仓库
  - 镜像仓库：内容和中央仓库保持一致，但是能够分担中央仓库的负载，同时让用户能够就近访问提高下载速度，例如：Nexus aliyun

建议：不要中央仓库和阿里云镜像混用，否则 jar 包来源不纯，彼此冲突。

专门搜索 Maven 依赖信息的网站：https://mvnrepository.com/

②、镜像

Maven 下载 jar 包默认访问境外的中央仓库，而国外网站速度很慢。改成阿里云提供的镜像仓库，访问国内网站，可以让 Maven 下载 jar 包的时候速度更快。配置的方式是：

将下面 mirror 标签整体复制到 settings.xml 文件的 mirrors 标签的内部。

	<mirror>
		<id>nexus-aliyun</id>
		<mirrorOf>central</mirrorOf>
		<name>Nexus aliyun</name>
		<url>http://maven.aliyun.com/nexus/content/groups/public</url>
	</mirror>

Copied!

6、约定的目录结构

①、各个目录的作用

另外还有一个 target 目录专门存放构建操作输出的结果。

②、约定目录结构的意义

Maven 为了让构建过程能够尽可能自动化完成，所以必须约定目录结构的作用。例如：Maven 执行编译操作，必须先去 Java 源程序目录读取 Java 源代码，然后执行编译，最后把编译结果存放在 target 目录。

③、约定大于配置

Maven 对于目录结构这个问题，没有采用配置的方式，而是基于约定。这样会让我们在开发过程中非常方便。如果每次创建 Maven 工程后，还需要针对各个目录的位置进行详细的配置，那肯定非常麻烦。

目前开发领域的技术发展趋势就是：约定大于配置，配置大于编码。

7、依赖的配置

①、依赖的范围scope

标签的位置：dependencies/dependency/scope

标签的可选值：compile/test/provided/system/runtime/import

compile 和 test 对比

	main目录（空间）	test目录（空间）	开发过程（时间）	部署到服务器（时间）
compile	有效	有效	有效	有效
test	无效	有效	有效	无效

compile 和 provided 对比

	main目录（空间）	test目录（空间）	开发过程（时间）	部署到服务器（时间）
compile	有效	有效	有效	有效
provided	有效	有效	有效	无效

结论

compile：通常使用的第三方框架的 jar 包这样在项目实际运行时真正要用到的 jar 包都是以 compile 范围进行依赖的。比如 SSM 框架所需jar包。

test：测试过程中使用的 jar 包，以 test 范围依赖进来。比如 junit。

provided：在开发过程中需要用到的“服务器上的 jar 包”通常以 provided 范围依赖进来。比如 servlet-api、jsp-api。而这个范围的 jar 包之所以不参与部署、不放进 war 包，就是避免和服务器上已有的同类 jar 包产生冲突，同时减轻服务器的负担。说白了就是：“服务器上已经有了，你就别带啦！”

test scope 在springboot里不会参与打包，runtime provided会打进包里

②、依赖的传递性

概念

A 依赖 B，B 依赖 C，那么在 A 没有配置对 C 的依赖的情况下，A 里面能不能直接使用 C？
传递的原则：

在 A 依赖 B，B 依赖 C 的前提下，C 是否能够传递到 A，取决于 B 依赖 C 时使用的依赖范围。

B 依赖 C 时使用 compile 范围：可以传递

B 依赖 C 时使用 test 或 provided 范围：不能传递，所以需要这样的 jar 包时，就必须在需要的地方明确配置依赖才可以。

③、依赖的排除

概念

当 A 依赖 B，B 依赖 C 而且 C 可以传递到 A 的时候，A 不想要 C，需要在 A 里面把 C 排除掉。而往往这种情况都是为了避免 jar 包之间的冲突。

所以配置依赖的排除其实就是阻止某些 jar 包的传递。因为这样的 jar 包传递过来会和其他 jar 包冲突。

配置方式

<dependency>
	<groupId>com.atguigu.maven</groupId>
	<artifactId>pro01-maven-java</artifactId>
	<version>1.0-SNAPSHOT</version>
	<scope>compile</scope>
	<!-- 使用excludes标签配置依赖的排除	-->
	<exclusions>
		<!-- 在exclude标签中配置一个具体的排除 -->
		<exclusion>
			<!-- 指定要排除的依赖的坐标（不需要写version） -->
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
		</exclusion>
	</exclusions>
</dependency>

Copied!

④、scope-import

管理依赖最基本的办法是继承父工程，但是和 Java 类一样，Maven 也是单继承的。如果不同体系的依赖信息封装在不同 POM 中了，没办法继承多个父工程怎么办？这时就可以使用 import 依赖范围。

典型案例当然是在项目中引入 SpringBoot、SpringCloud 依赖：

<dependencyManagement>
    <dependencies>

        <!-- SpringCloud 依赖导入 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR9</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- SpringCloud Alibaba 依赖导入 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.2.6.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- SpringBoot 依赖导入 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.3.6.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Copied!

import 依赖范围使用要求：

打包类型必须是 pom
必须放在 dependencyManagement 中

官网说明如下：

This scope is only supported on a dependency of type pom in the <dependencyManagement>section. It indicates the dependency is to be replaced with the effective list of dependencies in the specified POM’s <dependencyManagement> section. Since they are replaced, dependencies with a scope of import do not actually participate in limiting the transitivity of a dependency.

⑤、scope-system

以 Windows 系统环境下开发为例，假设现在 D:\tempare\atguigu-maven-test-aaa-1.0-SNAPSHOT.jar 想要引入到我们的项目中，此时我们就可以将依赖配置为 system 范围：

<dependency>
    <groupId>com.atguigu.maven</groupId>
    <artifactId>atguigu-maven-test-aaa</artifactId>
    <version>1.0-SNAPSHOT</version>
    <systemPath>D:\tempare\atguigu-maven-test-aaa-1.0-SNAPSHOT.jar</systemPath>
    <scope>system</scope>
</dependency>

Copied!

但是很明显：这样引入依赖完全不具有可移植性，所以不要使用。如果需要引入体系外 jar 包我们后面会讲专门的办法。

⑥、scope-runtime

专门用于编译时不需要，但是运行时需要的 jar 包。比如：编译时我们根据接口调用方法，但是实际运行时需要的是接口的实现类。典型案例是：

<!--热部署 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

Copied!

会参与依赖传递

⑦、optional

配置

<!--热部署 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

Copied!

runtime true

正常一个依赖加上这两个配置之后不影响springboot打包，但是springboot打包时没有包括spring-boot-devtools

应该是springboot自己做了处理

optional本质含义

可选其实就是『可有可无』。官网的解释是：

其核心含义是：Project X 依赖 Project A，A 中一部分 X 用不到的代码依赖了 B，那么对 X 来说 B 就是『可有可无』的。

optional不会参与依赖传递

⑧、依赖的版本仲裁

最短路径优先

在下图的例子中，对模块 pro25-module-a 来说，Maven 会采纳 1.2.12 版本。

路径相同时先声明者优先

此时 Maven 采纳哪个版本，取决于在 pro29-module-x 中，对 pro30-module-y 和 pro31-module-z 两个模块的依赖哪一个先声明。

其实 Maven 的版本仲裁机制只是在没有人为干预的情况下，自主决定 jar 包版本的一个办法。而实际上我们要使用具体的哪一个版本，还要取决于项目中的实际情况。所以在项目正常运行的情况下，jar 包版本可以由 Maven 仲裁，不必我们操心；而发生冲突时 Maven 仲裁决定的版本无法满足要求，此时就应该由程序员明确指定 jar 包版本。

8、继承

①、概念

Maven工程之间，A 工程继承 B 工程

B 工程：父工程
A 工程：子工程

本质上是 A 工程的 pom.xml 中的配置继承了 B 工程中 pom.xml 的配置。

只有打包方式为pom的工程才能作为父工程

②、作用

在父工程中统一管理项目中的依赖信息，具体来说是管理依赖信息的版本。

它的背景是：

对一个比较大型的项目进行了模块拆分。
一个 project 下面，创建了很多个 module。
每一个 module 都需要配置自己的依赖信息。

它背后的需求是：

在每一个 module 中各自维护各自的依赖信息很容易发生出入，不易统一管理。
使用同一个框架内的不同 jar 包，它们应该是同一个版本，所以整个项目中使用的框架版本需要统一。
使用框架时所需要的 jar 包组合（或者说依赖信息组合）需要经过长期摸索和反复调试，最终确定一个可用组合。这个耗费很大精力总结出来的方案不应该在新的项目中重新摸索。

通过在父工程中为整个项目维护依赖信息的组合既保证了整个项目使用规范、准确的 jar 包；又能够将以往的经验沉淀下来，节约时间和精力。

9、聚合

①、聚合本身的含义

部分组成整体

动画片《战神金刚》中的经典台词：“我来组成头部！我来组成手臂！”就是聚合关系最生动的体现。

②、Maven 中的聚合

使用一个“总工程”将各个“模块工程”汇集起来，作为一个整体对应完整的项目。

项目：整体
模块：部分

TIP

概念的对应关系：

从继承关系角度来看：

父工程

子工程

从聚合关系角度来看：

总工程

模块工程

③、好处

一键执行 Maven 命令：很多构建命令都可以在“总工程”中一键执行。

以 mvn install 命令为例：Maven 要求有父工程时先安装父工程；有依赖的工程时，先安装被依赖的工程。我们自己考虑这些规则会很麻烦。但是工程聚合之后，在总工程执行 mvn install 可以一键完成安装，而且会自动按照正确的顺序执行。
配置聚合之后，各个模块工程会在总工程中展示一个列表，让项目中的各个模块一目了然。

④、聚合的配置

在总工程中配置 modules 即可：

<modules>  
		<module>pro04-maven-module</module>
		<module>pro05-maven-module</module>
		<module>pro06-maven-module</module>
	</modules>

Copied!

⑤、依赖循环问题

如果 A 工程依赖 B 工程，B 工程依赖 C 工程，C 工程又反过来依赖 A 工程，那么在执行构建操作时会报下面的错误：

DANGER

[ERROR] [ERROR] The projects in the reactor contain a cyclic reference:

这个错误的含义是：循环引用。

10、定义jdk版本和编码

①、直接使用默认取值

<properties>
      	<!-- maven-resources-plugin和maven-compiler-plugin插件的默认取值 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  
  			<!-- maven-site-plugin等插件的默认取值 -->
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      
      	<!-- maven-compiler-plugin插件的默认取值 -->
      	<maven.compiler.source>1.8</maven.compiler.source>
    		<maven.compiler.target>1.8</maven.compiler.target>
      
      	<!-- spring-boot-starter-parent里定义的的默认取值 -->
        <java.version>1.8</java.version>
      
</properties>

Copied!

②、或者在插件中定义

<project>
  [...]
  <build>
    [...]
    <plugins>
      
      <!-- JDK版本 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.10.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    
    	<!-- 编码 -->
   		<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>3.2.0</version>
        <configuration>
          ...
          <encoding>UTF-8</encoding>
          ...
        </configuration>
      </plugin>
      
      
      
    </plugins>
    [...]
  </build>
  [...]
</project>

Copied!

③、或写在超级pom里，全局设定

配置的方式是：将 profile 标签整个复制到 settings.xml 文件的 profiles 标签内。

<profile>
	  <id>jdk-1.8</id>
	  <activation>
		<activeByDefault>true</activeByDefault>
		<jdk>1.8</jdk>
	  </activation>
	  <properties>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
	  </properties>
</profile>

Copied!

不推荐,仅在本地生效，如果脱离当前的settings.xml能够覆盖的范围，则无法生效

11、属性的声明与引用

①、help 插件的各个目标

官网说明地址：https://maven.apache.org/plugins/maven-help-plugin

目标	说明
help:active-profiles	列出当前已激活的 profile
help:all-profiles	列出当前工程所有可用 profile
help:describe	描述一个插件和/或 Mojo 的属性
help:effective-pom	以 XML 格式展示有效 POM
help:effective-settings	为当前工程以 XML 格式展示计算得到的 settings 配置
help:evaluate	计算用户在交互模式下给出的 Maven 表达式
help:system	显示平台详细信息列表，如系统属性和环境变量

②、使用help:evaluate查看属性值

定义属性

1
2
3

<properties>
    <com.atguigu.hello>good morning maven</com.atguigu.hello>
</properties>

Copied!

运行 mvn help:evaluate

③、通过 Maven 访问系统属性

java属性一览

Properties properties = System.getProperties();
Set<Object> propNameSet = properties.keySet();
for (Object propName : propNameSet) {
    String propValue = properties.getProperty((String) propName);
    System.out.println(propName + " = " + propValue);
}

Copied!

java.runtime.name = Java(TM) SE Runtime Environment sun.boot.library.path = D:\software\Java\jre\bin java.vm.version = 25.141-b15 java.vm.vendor = Oracle Corporation java.vendor.url = http://java.oracle.com/

…………

使用 Maven 访问系统属性

访问系统环境变量

访问 project 属性

使用表达式 ${project.xxx} 可以访问当前 POM 中的元素值。

访问一级标签:

${project.标签名}

访问子标签:

${project.标签名.子标签名}

访问列表标签:

${project.标签名[下标]}

访问 settings 全局配置

${settings.标签名} 可以访问 settings.xml 中配置的元素值。

④、用途

在当前 pom.xml 文件中引用属性
资源过滤功能：在非 Maven 配置文件中引用属性，由 Maven 在处理资源时将引用属性的表达式替换为属性值

创建待处理的资源文件

dev.user=${dev.jdbc.user}
dev.password=${dev.jdbc.password}
dev.url=${dev.jdbc.url}
dev.driver=${dev.jdbc.driver}

Copied!

配置 profile

<profiles>
    <profile>
        <id>devJDBCProfile</id>
        <properties>
            <dev.jdbc.user>root</dev.jdbc.user>
            <dev.jdbc.password>atguigu</dev.jdbc.password>
            <dev.jdbc.url>http://localhost:3306/db_good</dev.jdbc.url>
            <dev.jdbc.driver>com.mysql.jdbc.Driver</dev.jdbc.driver>
        </properties>
        <build>
            <resources>
                <resource>
                    <!-- 表示为这里指定的目录开启资源过滤功能 -->
                    <directory>src/main/resources</directory>

                    <!-- 将资源过滤功能打开 -->
                    <filtering>true</filtering>
                </resource>
            </resources>
        </build>
    </profile>
</profiles>

Copied!

执行处理资源命令

`1`	`mvn clean resources:resources -PdevJDBCProfile`

Copied!

12、profile详解

①、profile 概述

[1] 单词释义

这里我们可以对接 profile 这个单词中『侧面』这个含义：项目的每一个运行环境，相当于是项目整体的一个侧面。

[2] 项目的不同运行环境

通常情况下，我们至少有三种运行环境：

开发环境：供不同开发工程师开发的各个模块之间互相调用、访问；内部使用
测试环境：供测试工程师对项目的各个模块进行功能测试；内部使用
生产环境：供最终用户访问——所以这是正式的运行环境，对外提供服务

而我们这里的『环境』仍然只是一个笼统的说法，实际工作中一整套运行环境会包含很多种不同服务器：

MySQL
Redis
ElasticSearch
RabbitMQ
FastDFS
Nginx
Tomcat
……

就拿其中的 MySQL 来说，不同环境下的访问参数肯定完全不同：

开发环境	测试环境	生产环境
dev.driver=com.mysql.jdbc.Driver dev.url=jdbc:mysql://124.71.36.17:3306/db-sys dev.username=root dev.password=atguigu	test.driver=com.mysql.jdbc.Driver test.url=jdbc:mysql://124.71.36.89:3306/db-sys test.username=dev-team test.password=atguigu	product.driver=com.mysql.jdbc.Driver product.url=jdbc:mysql://39.107.88.164:3306/prod-db-sys product.username=root product.password=atguigu

可是代码只有一套。如果在 jdbc.properties 里面来回改，那就太麻烦了，而且很容易遗漏或写错，增加调试的难度和工作量。所以最好的办法就是把适用于各种不同环境的配置信息分别准备好，部署哪个环境就激活哪个配置。

在 Maven 中，使用 profile 机制来管理不同环境下的配置信息。但是解决同类问题的类似机制在其他框架中也有，而且从模块划分的角度来说，持久化层的信息放在构建工具中配置也违反了『高内聚，低耦合』的原则。

所以 Maven 的 profile 我们了解一下即可，不必深究。

[3] profile 声明和使用的基本逻辑

首先为每一个环境声明一个 profile
- 环境 A：profile A
- 环境 B：profile B
- 环境 C：profile C
- ……
然后激活某一个 profile

[4] 默认 profile

其实即使我们在 pom.xml 中不配置 profile 标签，也已经用到 profile了。为什么呢？因为根标签 project 下所有标签相当于都是在设定默认的 profile。这样一来我们也就很容易理解下面这句话：project 标签下除了 modelVersion 和坐标标签之外，其它标签都可以配置到 profile 中。

②、profile 配置

[1] 外部视角：配置文件

从外部视角来看，profile 可以在下面两种配置文件中配置：

settings.xml：全局生效。其中我们最熟悉的就是配置 JDK 1.8。

<profile>
	  <id>jdk-1.8</id>
	  <activation>
		<activeByDefault>true</activeByDefault>
		<jdk>1.8</jdk>
	  </activation>
	  <properties>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
	  </properties>
</profile>

Copied!

pom.xml：当前 POM 生效

[2] 内部实现：具体标签

从内部视角来看，配置 profile 有如下语法要求：

profiles/profile 标签

由于 profile 天然代表众多可选配置中的一个所以由复数形式的 profiles 标签统一管理。

由于 profile 标签覆盖了 pom.xml 中的默认配置，所以 profiles 标签通常是 pom.xml 中的最后一个标签。
id 标签

每个 profile 都必须有一个 id 标签，指定该 profile 的唯一标识。这个 id 标签的值会在命令行调用 profile 时被用到。这个命令格式是：-D。
其它允许出现的标签

一个 profile 可以覆盖项目的最终名称、项目依赖、插件配置等各个方面以影响构建行为。

build

defaultGoal

finalName

resources

testResources

plugins

reporting

modules

dependencies

dependencyManagement

repositories

pluginRepositories

properties

③、激活 profile

[1] 默认配置默认被激活

前面提到了，POM 中没有在 profile 标签里的就是默认的 profile，当然默认被激活。

[2] 基于环境信息激活

环境信息包含：JDK 版本、操作系统参数、文件、属性等各个方面。一个 profile 一旦被激活，那么它定义的所有配置都会覆盖原来 POM 中对应层次的元素。可以参考下面的标签结构：

<profile>
	<id>dev</id>
    <activation>
        <!-- 配置是否默认激活 -->
    		<activeByDefault>false</activeByDefault>
      
      	<!-- 配置激活条件 -->
        <jdk>1.5</jdk>
        <os>
        	<name>Windows XP</name>
            <family>Windows</family>
            <arch>x86</arch>
            <version>5.1.2600</version>
        </os>
        <property>
        	<name>mavenVersion</name>
            <value>2.0.5</value>
        </property>
        <file>
        	<exists>file2.properties</exists>
            <missing>file1.properties</missing>
        </file>
    </activation>
</profile>

Copied!

这里有个问题是：多个激活条件之间是什么关系呢？

Maven 3.2.2 之前：遇到第一个满足的条件即可激活——或的关系。
Maven 3.2.2 开始：各条件均需满足——且的关系。

下面我们来看一个具体例子。假设有如下 profile 配置，在 JDK 版本为 1.6 时被激活：

<profiles>
	<profile>
    	<id>JDK1.6</id>
        <activation>
            <!-- 指定激活条件为：JDK 1.6 -->
        	<jdk>1.6</jdk>
        </activation>
        ……
    </profile>
</profiles>

Copied!

这里需要指出的是：Maven 会自动检测当前环境安装的 JDK 版本，只要 JDK 版本是以 1.6 开头都算符合条件。下面几个例子都符合：

1.6.0_03
1.6.0_02
……

[3] 命令行激活

列出活动的 profile

1
2

# 列出所有激活的 profile，以及它们在哪里定义
mvn help:active-profiles

Copied!

指定某个具体 profile

`1`	`mvn compile -P<profile id>`

Copied!

④、操作举例

[1] 编写 Lambda 表达式代码

Lambda 表达式代码要求 JDK 版本必须是 1.8，我们可以以此来判断某个指定更低 JDK 版本的 profile 是否被激活生效。

@Test
public void test() {
    new Thread(()->{
        System.out.println(Thread.currentThread().getName() + " is working");
    }).start();
}

Copied!

以目前配置运行这个测试方法：

[2] 配置 profile

<profiles>
    <profile>
        <id>myJDKProfile</id>
        <!-- build 标签：意思是告诉 Maven，你的构建行为，我要开始定制了！ -->
        <build>
            <!-- plugins 标签：Maven 你给我听好了，你给我构建的时候要用到这些插件！ -->
            <plugins>
                <!-- plugin 标签：这是我要指定的一个具体的插件 -->
                <plugin>
                    <!-- 插件的坐标。此处引用的 maven-compiler-plugin 插件不是第三方的，是一个 Maven 自带的插件。 -->
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.1</version>

                    <!-- configuration 标签：配置 maven-compiler-plugin 插件 -->
                    <configuration>
                        <!-- 具体配置信息会因为插件不同、需求不同而有所差异 -->
                        <source>1.6</source>
                        <target>1.6</target>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

Copied!

[3] 执行构建命令

`1`	`mvn clean test -PmyJDKProfile`

Copied!

⑤、资源属性过滤

[1] 简介

Maven 为了能够通过 profile 实现各不同运行环境切换，提供了一种『资源属性过滤』的机制。通过属性替换实现不同环境使用不同的参数。

[2] 操作演示

配置 profile

<profiles>
    <profile>
        <id>devJDBCProfile</id>
        <properties>
            <dev.jdbc.user>root</dev.jdbc.user>
            <dev.jdbc.password>atguigu</dev.jdbc.password>
            <dev.jdbc.url>http://localhost:3306/db_good</dev.jdbc.url>
            <dev.jdbc.driver>com.mysql.jdbc.Driver</dev.jdbc.driver>
        </properties>
        <build>
            <resources>
                <resource>
                    <!-- 表示为这里指定的目录开启资源过滤功能 -->
                    <directory>src/main/resources</directory>

                    <!-- 将资源过滤功能打开 -->
                    <filtering>true</filtering>
                </resource>
            </resources>
        </build>
    </profile>
</profiles>

Copied!

创建待处理的资源文件

dev.user=${dev.jdbc.user}
dev.password=${dev.jdbc.password}
dev.url=${dev.jdbc.url}
dev.driver=${dev.jdbc.driver}

Copied!

执行处理资源命令

`1`	`mvn clean resources:resources -PdevJDBCProfile`

Copied!

找到处理得到的资源文件

延伸

我们时不时会在 resource 标签下看到 includes 和 excludes 标签。它们的作用是：

includes：指定执行 resource 阶段时要包含到目标位置的资源
excludes：指定执行 resource 阶段时要排除的资源

情看下面的例子：

<build>
    <resources>
        <resource>
            <!-- 表示为这里指定的目录开启资源过滤功能 -->
            <directory>src/main/resources</directory>

            <!-- 将资源过滤功能打开 -->
            <filtering>true</filtering>

            <includes>
                <include>*.properties</include>
            </includes>

            <excludes>
                <exclude>happy.properties</exclude>
            </excludes>
        </resource>
    </resources>
</build>

Copied!

执行处理资源命令：

`1`	`mvn clean resources:resources -PdevJDBCProfile`

Copied!

执行效果如下：

当然我们这里只是以 properties 文件为例，并不是只能处理 properties 文件。

1普通工程-命令行

Sun, 03 Mar 2024 13:49:51 +0800

一、创建 Maven 工程

1、使用命令生成Maven工程

在工作目录打开命令行

运行 mvn archetype:generate 命令

下面根据提示操作

TIP

Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 7:【直接回车，使用默认值】

Define value for property ‘groupId’: com.atguigu.maven

Define value for property ‘artifactId’: pro01-maven-java

Define value for property ‘version’ 1.0-SNAPSHOT: :【直接回车，使用默认值】

Define value for property ‘package’ com.atguigu.maven: :【直接回车，使用默认值】

Confirm properties configuration: groupId: com.atguigu.maven artifactId: pro01-maven-java version: 1.0-SNAPSHOT package: com.atguigu.maven Y: :【直接回车，表示确认。如果前面有输入错误，想要重新输入，则输入 N 再回车。】

2、调整

Maven 默认生成的工程，对 junit 依赖的是较低的 3.8.1 版本，我们可以改成较适合的 4.12 版本。

自动生成的 App.java 和 AppTest.java 可以删除。

<!-- 依赖信息配置 -->
<!-- dependencies复数标签：里面包含dependency单数标签 -->
<dependencies>
	<!-- dependency单数标签：配置一个具体的依赖 -->
	<dependency>
		<!-- 通过坐标来依赖其他jar包 -->
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		
		<!-- 依赖的范围 -->
		<scope>test</scope>
	</dependency>
</dependencies>

Copied!

3、自动生成的 pom.xml 解读

	<!-- modelVersion 标签：从maven2 开始就是固定为 4.0.0，代表当前pom.xml所采用的标签结构 -->  
	<modelVersion>4.0.0</modelVersion>
  <!-- 当前Maven工程的坐标 -->
  <groupId>com.atguigu.maven</groupId>
  <artifactId>pro01-maven-java</artifactId>
  <version>1.0-SNAPSHOT</version>
  
  <!-- 当前Maven工程的打包方式，可选值有下面三种： -->
  <!-- jar：表示这个工程是一个Java工程  -->
  <!-- war：表示这个工程是一个Web工程 -->
  <!-- pom：表示这个工程是“管理其他工程”的工程 -->
  <packaging>jar</packaging>

  <name>pro01-maven-java</name>
  <url>http://maven.apache.org</url>

  <properties>
	<!-- 工程构建过程中读取源码时使用的字符集 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <!-- 当前工程所依赖的jar包 -->
  <dependencies>
	<!-- 使用dependency配置一个具体的依赖 -->
    <dependency>
	
	  <!-- 在dependency标签内使用具体的坐标依赖我们需要的一个jar包 -->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
	  
	  <!-- scope标签配置依赖的范围 -->
      <scope>test</scope>
    </dependency>
  </dependencies>

Copied!

二、编写代码

1、主体程序

主体程序指的是被测试的程序，同时也是将来在项目中真正要使用的程序。

package com.atguigu.maven;
	
public class Calculator {
	
	public int sum(int i, int j){
		return i + j;
	}
	
}

Copied!

2、测试程序

package com.atguigu.maven;
	
import org.junit.Test;
import com.atguigu.maven.Calculator;
	
// 静态导入的效果是将Assert类中的静态资源导入当前类
// 这样一来，在当前类中就可以直接使用Assert类中的静态资源，不需要写类名
import static org.junit.Assert.*;
	
public class CalculatorTest{
	
	@Test
	public void testSum(){
		
		// 1.创建Calculator对象
		Calculator calculator = new Calculator();
		
		// 2.调用Calculator对象的方法，获取到程序运行实际的结果
		int actualResult = calculator.sum(5, 3);
		
		// 3.声明一个变量，表示程序运行期待的结果
		int expectedResult = 8;
		
		// 4.使用断言来判断实际结果和期待结果是否一致
		// 如果一致：测试通过，不会抛出异常
		// 如果不一致：抛出异常，测试失败
		assertEquals(expectedResult, actualResult);
		
	}
	
}

Copied!

三、执行maven构建

1、要求

运行 Maven 中和构建操作相关的命令时，必须进入到 pom.xml 所在的目录。如果没有在 pom.xml 所在的目录运行 Maven 的构建命令，那么会看到下面的错误信息：

The goal you specified requires a project to execute but there is no POM in this directory

TIP mvn -v 命令和构建操作无关，只要正确配置了 PATH，在任何目录下执行都可以。而构建相关的命令要在 pom.xml 所在目录下运行——操作哪个工程，就进入这个工程的 pom.xml 目录。

2、清理操作

mvn clean

效果：删除 target 目录

3、编译操作

主程序编译：mvn compile

测试程序编译：mvn test-compile

主体程序编译结果存放的目录：target/classes

测试程序编译结果存放的目录：target/test-classes

4、测试操作

mvn test

测试的报告存放的目录：target/surefire-reports

5、打包操作

mvn package

打包的结果——jar 包，存放的目录：target

并没有把依赖的包（maven dependency）一起打在生成的jar包里，这里的打jar包，实际maven认为是一个工具包，是一个后面被项目继续依赖的包，所以没必要把依赖的包打进去。

如果需要生成一个可执行的包，则需要用maven插件：

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <archive>
                        <manifest>
                            <useUniqueVersions>false</useUniqueVersions>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>com.wyz.Main</mainClass>
                        </manifest>
                    </archive>
                </configuration>
</plugin>

Copied!

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <!-- 拷贝项目依赖包到lib/目录下 -->
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <!-- 间接依赖也拷贝 -->
                            <excludeTransitive>false</excludeTransitive>
                            <!-- 带上版本号 -->
                            <stripVersion>false</stripVersion>
                        </configuration>
                    </execution>
                </executions>
</plugin>

Copied!

把依赖也打进jar包：mainClass是jar包的main方法入口:

<build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.wyz.Main</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
            </plugin>
        </plugins>
    </build>

Copied!

6、安装操作

mvn install

1
2

[INFO] Installing D:\maven-workspace\space201026\pro01-maven-java\target\pro01-maven-java-1.0-SNAPSHOT.jar to D:\maven-rep1026\com\atguigu\maven\pro01-maven-java\1.0-SNAPSHOT\pro01-maven-java-1.0-SNAPSHOT.jar
[INFO] Installing D:\maven-workspace\space201026\pro01-maven-java\pom.xml to D:\maven-rep1026\com\atguigu\maven\pro01-maven-java\1.0-SNAPSHOT\pro01-maven-java-1.0-SNAPSHOT.pom

Copied!

安装的效果是将本地构建过程中生成的 jar 包存入 Maven 本地仓库。这个 jar 包在 Maven 仓库中的路径是根据它的坐标生成的。

坐标信息如下：

1
2
3

 <groupId>com.atguigu.maven</groupId>
  <artifactId>pro01-maven-java</artifactId>
  <version>1.0-SNAPSHOT</version>

Copied!

在 Maven 仓库中生成的路径如下：

maven\repository\com\atguigu\maven\pro01-maven-java\1.0-SNAPSHOT\pro01-maven-java-1.0-SNAPSHOT.jar

另外，安装操作还会将 pom.xml 文件转换为 XXX.pom 文件一起存入本地仓库。所以我们在 Maven 的本地仓库中想看一个 jar 包原始的 pom.xml 文件时，查看对应 XXX.pom 文件即可，它们是名字发生了改变，本质上是同一个文件。

2 web工程-命令行

Sun, 03 Mar 2024 14:49:51 +0800

一、创建web工程

1、说明

使用 mvn archetype:generate 命令生成 Web 工程时，需要使用一个专门的 archetype。这个专门生成 Web 工程骨架的 archetype 可以参照官网看到它的用法：

参数 archetypeGroupId、archetypeArtifactId、archetypeVersion 用来指定现在使用的 maven-archetype-webapp 的坐标。

2、操作

注意：如果在上一个工程的目录下执行 mvn archetype:generate 命令，那么 Maven 会报错：不能在一个非 pom 的工程下再创建其他工程。所以不要再刚才创建的工程里再创建新的工程，请回到工作空间根目录来操作。

然后运行生成工程的命令：

`1`	`mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-webapp -DarchetypeVersion=1.4`

Copied!

下面的操作按照提示执行：

TIP Define value for property ‘groupId’: com.atguigu.maven Define value for property ‘artifactId’: pro02-maven-web Define value for property ‘version’ 1.0-SNAPSHOT: :【直接回车，使用默认值】

Define value for property ‘package’ com.atguigu.maven: :【直接回车，使用默认值】 Confirm properties configuration: groupId: com.atguigu.maven artifactId: pro02-maven-web version: 1.0-SNAPSHOT package: com.atguigu.maven Y: :【直接回车，表示确认】

3、生成的pom.xml

确认打包的方式是war包形式

war

4、生成的Web工程的目录结构

webapp 目录下有 index.jsp

WEB-INF 目录下有 web.xml

5、创建 Servlet

①在 main 目录下创建 java 目录

②在 java 目录下创建 Servlet 类所在的包的目录

③在包下创建 Servlet 类

package com.atguigu.maven;
	
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;
	
public class HelloServlet extends HttpServlet{
	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		response.getWriter().write("hello maven web");
		
	}
	
}

Copied!

④在 web.xml 中注册 Servlet

<servlet>
	<servlet-name>helloServlet</servlet-name>
	<servlet-class>com.atguigu.maven.HelloServlet</servlet-class>
 </servlet>
 <servlet-mapping>
	<servlet-name>helloServlet</servlet-name>
	<url-pattern>/helloServlet</url-pattern>
 </servlet-mapping>

Copied!

6、在 index.jsp 页面编写超链接

<html>
<body>
<h2>Hello World!</h2>
<a href="helloServlet">Access Servlet</a>
</body>
</html>

Copied!

TIP JSP全称是 Java Server Page，和 Thymeleaf 一样，是服务器端页面渲染技术。这里我们不必关心 JSP 语法细节，编写一个超链接标签即可。

7、编译

此时直接执行 mvn compile 命令出错：

DANGER
程序包 javax.servlet.http 不存在

程序包 javax.servlet 不存在

找不到符号

符号: 类 HttpServlet

……

Copied!

上面的错误信息说明：我们的 Web 工程用到了 HttpServlet 这个类，而 HttpServlet 这个类属于 servlet-api.jar 这个 jar 包。此时我们说，Web 工程需要依赖 servlet-api.jar 包。

8、配置对 servlet-api.jar 包的依赖

对于不知道详细信息的依赖可以到https://mvnrepository.com/网站查询。使用关键词搜索，然后在搜索结果列表中选择适合的使用。

比如，我们找到的 servlet-api 的依赖信息：

<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

Copied!

这样就可以把上面的信息加入 pom.xml。重新执行 mvn compile 命令。

9、将 Web 工程打包为 war 包

运行 mvn package 命令，生成 war 包的位置如下图所示：

这个打包就会把所有的第三方依赖一起打进war包里，和普通工程就不一样了

10、将 war 包部署到 Tomcat 上运行

将 war 包复制到 Tomcat/webapps 目录下

启动 Tomcat：

通过浏览器尝试访问：http://localhost:8080/pro02-maven-web/index.jsp

二、依赖一个jar包

1、观念

明确一个意识：从来只有 Web 工程依赖 Java 工程，没有反过来 Java 工程依赖 Web 工程。本质上来说，Web 工程依赖的 Java 工程其实就是 Web 工程里导入的 jar 包。最终 Java 工程会变成 jar 包，放在 Web 工程的 WEB-INF/lib 目录下

2、操作

在 pro02-maven-web 工程的 pom.xml 中，找到 dependencies 标签，在 dependencies 标签中做如下配置：

<!-- 配置对Java工程pro01-maven-java的依赖 -->
<!-- 具体的配置方式：在dependency标签内使用坐标实现依赖 -->
<dependency>
	<groupId>com.atguigu.maven</groupId>
	<artifactId>pro01-maven-java</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>

Copied!

3、执行maven命令

①测试命令

mvn test

说明：测试操作中会提前自动执行编译操作，测试成功就说明编译也是成功的。

②打包命令

mvn package

通过查看 war 包内的结构，我们看到被 Web 工程依赖的 Java 工程确实是会变成 Web 工程的 WEB-INF/lib 目录下的 jar 包。

③查看当前 Web 工程所依赖的 jar 包的列表

mvn dependency:list

TIP

[INFO] The following files have been resolved: [INFO] org.hamcrest:hamcrest-core:jar:1.3:test [INFO] javax.servlet:javax.servlet-api:jar:3.1.0:provided [INFO] com.atguigu.maven:pro01-maven-java:jar:1.0-SNAPSHOT:compile [INFO] junit:junit:jar:4.12:test

说明：javax.servlet:javax.servlet-api:jar:3.1.0:provided 格式显示的是一个 jar 包的坐标信息。格式是：

groupId:artifactId:打包方式:version:依赖的范围

这样的格式虽然和我们 XML 配置文件中坐标的格式不同，但是本质上还是坐标信息，大家需要能够认识这样的格式，将来从 Maven 命令的日志或错误信息中看到这样格式的信息，就能够识别出来这是坐标。进而根据坐标到Maven 仓库找到对应的jar包，用这样的方式解决我们遇到的报错的情况。

④以树形结构查看当前 Web 工程的依赖信息

mvn dependency:tree

TIP

[INFO] com.atguigu.maven:pro02-maven-web:war:1.0-SNAPSHOT [INFO] +- junit:junit:jar:4.12:test [INFO] | - org.hamcrest:hamcrest-core:jar:1.3:test [INFO] +- javax.servlet:javax.servlet-api:jar:3.1.0:provided [INFO] - com.atguigu.maven:pro01-maven-java:jar:1.0-SNAPSHOT:compile

我们在 pom.xml 中并没有依赖 hamcrest-core，但是它却被加入了我们依赖的列表。原因是：junit 依赖了hamcrest-core，然后基于依赖的传递性，hamcrest-core 被传递到我们的工程了。

3 父子工程-命令行

Sun, 03 Mar 2024 15:49:51 +0800

一、创建父工程

创建的过程和前面创建普通工程一样。

工程名称：pro03-maven-parent

工程创建好之后，要修改它的打包方式：

<groupId>com.atguigu.maven</groupId>
  <artifactId>pro03-maven-parent</artifactId>
  <version>1.0-SNAPSHOT</version>

  <!-- 当前工程作为父工程，它要去管理子工程，所以打包方式必须是 pom -->
  <packaging>pom</packaging>

Copied!

有打包方式为 pom 的 Maven 工程能够管理其他 Maven 工程。打包方式为 pom 的 Maven 工程中不写业务代码，它是专门管理其他 Maven 工程的工程。

二、创建模块工程

模块工程类似于 IDEA 中的 module，所以需要进入 pro03-maven-parent 工程的根目录，然后运行 mvn archetype:generate 命令来创建模块工程。

假设，我们创建三个模块工程：

三、查看被添加新内容的父工程 pom.xml

下面 modules 和 module 标签是聚合功能的配置

<modules>  
	<module>pro04-maven-module</module>
	<module>pro05-maven-module</module>
	<module>pro06-maven-module</module>
</modules>

Copied!

四、解读子工程的pom.xml

<!-- 使用parent标签指定当前工程的父工程 -->
<parent>
	<!-- 父工程的坐标 -->
	<groupId>com.atguigu.maven</groupId>
	<artifactId>pro03-maven-parent</artifactId>
	<version>1.0-SNAPSHOT</version>
</parent>

<!-- 子工程的坐标 -->
<!-- 如果子工程坐标中的groupId和version与父工程一致，那么可以省略 -->
<!-- <groupId>com.atguigu.maven</groupId> -->
<artifactId>pro04-maven-module</artifactId>
<!-- <version>1.0-SNAPSHOT</version> -->

Copied!

五、在父工程中配置依赖的统一管理

<!-- 使用dependencyManagement标签配置对依赖的管理 -->
<!-- 被管理的依赖并没有真正被引入到工程 -->
<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-expression</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>4.0.0.RELEASE</version>
		</dependency>
	</dependencies>
</dependencyManagement>

Copied!

六、子工程中引用那些被父工程管理的依赖

关键点：省略版本号

<!-- 把版本号去掉就表示子工程中这个依赖的版本由父工程决定。 -->
<!-- 具体来说是由父工程的dependencyManagement来决定。 -->
<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-beans</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-expression</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
	</dependency>
</dependencies>

Copied!

七、在父工程中声明自定义属性

<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	
	<!-- 自定义标签，维护Spring版本数据 -->
  <!-- 通过自定义属性，统一指定Spring的版本 -->
	<atguigu.spring.version>4.3.6.RELEASE</atguigu.spring.version>
</properties>

Copied!

在需要的地方使用${}的形式来引用自定义的属性名：

			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-core</artifactId>
				<version>${atguigu.spring.version}</version>
			</dependency>

Copied!

真正实现“一处修改，处处生效”。

八、实际意义

编写一套符合要求、开发各种功能都能正常工作的依赖组合并不容易。如果公司里已经有人总结了成熟的组合方案，那么再开发新项目时，如果不使用原有的积累，而是重新摸索，会浪费大量的时间。为了提高效率，我们可以使用工程继承的机制，让成熟的依赖组合方案能够保留下来。

如上图所示，公司级的父工程中管理的就是成熟的依赖组合方案，各个新项目、子系统各取所需即可。

实验多重继承：

1、aaa项目：

		<groupId>org.example</groupId>
    <artifactId>aaa</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.javassist</groupId>
                <artifactId>javassist</artifactId>
                <version>3.24.1-GA</version>
            </dependency>
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>24.0-jre</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

Copied!

2、bbb项目继承aaa项目：

重新定义 javassist的版本

		<parent>
        <groupId>org.example</groupId>
        <artifactId>aaa</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
		<modelVersion>4.0.0</modelVersion>
    <artifactId>bbb</artifactId>
    <packaging>pom</packaging>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.javassist</groupId>
                <artifactId>javassist</artifactId>
                <version>3.28.0-GA</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

Copied!

3、ccc项目继承bbb项目：

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

    <modelVersion>4.0.0</modelVersion>
    <artifactId>ccc</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
        </dependency>
    </dependencies>

Copied!

4、发现

这时执行 mvn dependency:tree 发现：

1、javassist的版本是bbb项目定义的版本，被覆盖了；

2、guava的版本还是aaa项目的版本；

3、并且当修改aaa项目的guava版本，aaa项目内 mvn install 后，在ccc项目中重新加载后，发现guava版本也随之更改，这时就跟bbb项目的状态无关。

tip:

在bbb项目虽然是pom的打包格式，但是也可以写dependencies，直接依赖jar包，和dependencyManagement分别做两件事，不会出错

4 springboot项目

Sun, 03 Mar 2024 16:49:51 +0800

一、模块划分

一个父工程，一个子工程微服务，一个普通maven子工程

二、建父工程

1、github建仓库

2、idea新建maven项目（父工程）

3、idea工程和github建立联系

选中 scr和pom.xml ，git add
git commit
git fetch
命令行输入：

1
2

git branch --set-upstream-to=origin/master
git merge origin/master --allow-unrelated-histories

Copied!

commit + push 推送远程仓库
接下来就可以直接开发了

三、建子工程

另一个子工程以同样方式创建

四、父子关系

三个工程的pom文件内容是这样的：

springboot-parent-child

<?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>springboot-parent-child</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>user-service</module>
        <module>base-entity</module>
    </modules>

    <properties>
      	<!-- maven-resources-plugin插件的默认取值 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- maven-site-plugin等插件的默认取值 -->
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      
      	<!-- maven-compiler-plugin插件的默认取值 -->
      	<maven.compiler.source>1.8</maven.compiler.source>
    		<maven.compiler.target>1.8</maven.compiler.target>
      
      	<!-- spring-boot-starter-parent里定义的的默认取值 -->
        <java.version>1.8</java.version>
      
        <spring-boot-version>2.6.3</spring-boot-version>
    </properties>
<!-- 
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.6.3</version>
</parent>
-->
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot 依赖导入 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot-version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- SpringCloud 依赖导入 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2021.0.1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- SpringCloud Alibaba 依赖导入 -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2021.0.1.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

  	<!-- 
    1、这里显式指定插件版本，其实版本在springboot的pom中有，但这种引入方式会对插件不友好
 		2、maven打包时会出现找不到版本的警告，为了规避，所以在这里指定版本，
						后面继承的子工程就可以直接依赖这个插件了
		3、用spring-boot-starter-parent引入的，插件可以直接使用，没有警告			
		-->
    <!-- build 标签：用来配置对构建过程的定制 -->
    <build>
        <pluginManagement>
            <!-- plugins 标签：定制化构建过程中所使用到的插件 -->
            <plugins>
                <!-- plugin 标签：一个具体插件 -->
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>${spring-boot-version}</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

Copied!

user-service

<?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">
    <parent>
        <artifactId>springboot-parent-child</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>user-service</artifactId>

    <dependencies>
        <!-- Nacos 服务注册发现启动器 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!-- web启动器依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.example</groupId>
            <artifactId>base-entity</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

    <!-- build 标签：用来配置对构建过程的定制 -->
    <build>
        <!-- plugins 标签：定制化构建过程中所使用到的插件 -->
        <plugins>
            <!-- plugin 标签：一个具体插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
              <!-- 
							1、对于用import引入的springboot，这里要指定这个目标，否则执行mvn package时，不会自动执行springboot:repackage
							2、如果不这样指定的话，那打包命令需要显式指定插件，命令为：
							mvn clean package spring-boot:repackage -Dmaven.test.skip=true
							3、repackage前面必须有已经存在的包，否则会出错，所以前面跟着一个package原生命令
 							-->
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

Copied!

base-entity

<?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">
    <parent>
        <artifactId>springboot-parent-child</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>base-entity</artifactId>

    <dependencies>
        <!-- OpenFeign 专用依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

Copied!

部署

`1`	`nohup java -jar user-service-1.0-SNAPSHOT.jar>demo06.log 2>&1 &`

Copied!

注意

1、引入springboot的方式

不是每个人都喜欢从 spring-boot-starter-parent 继承 POM。您可能需要使用自己公司标准的父 POM，或者您可能只是希望明确地声明所有 Maven 配置。
如果您不想使用 spring-boot-starter-parent，则仍然可以通过使用 scope=import 依赖来获得依赖管理（但不是插件管理）的好处：
假如 A工程这样配置，这种方式只能在后面继承这个A工程的的子工程中去覆盖依赖的版本：

<packaging>pom</packaging>
...
...
<dependencyManagement>
        <dependencies>
            <!-- SpringBoot 依赖导入 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.6.3</version>
                <type>pom</type>
                <scope>import</scope>
           </dependency>
        </dependencies>
</dependencyManagement>

Copied!

如果这样，是覆盖不了的：

<packaging>pom</packaging>
...
...
<dependencyManagement>
        <dependencies>
            <!-- SpringBoot 依赖导入 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.6.3</version>
                <type>pom</type>
                <scope>import</scope>
           </dependency>
        </dependencies>
</dependencyManagement>

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.6.4</version>
        </dependency>
</dependencies>

Copied!

但是这样，可以覆盖某个依赖的版本：

<packaging>pom</packaging>
...
...
<dependencyManagement>
        <dependencies>
            <!-- SpringBoot 依赖导入 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.6.3</version>
                <type>pom</type>
                <scope>import</scope>
           </dependency>
          
          <!-- 覆盖web的版本 -->
          <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>2.6.4</version>
          </dependency>
          
        </dependencies>
</dependencyManagement>

Copied!

这种方式引入，也会使spring-boot-maven-plugin 引入进来，但是打包时有warning

5 build标签和插件

Sun, 03 Mar 2024 17:49:51 +0800

一、插件和目标

1、插件

Maven 的核心程序仅仅负责宏观调度，不做具体工作。具体工作都是由 Maven 插件完成的。例如：编译就是由 maven-compiler-plugin-3.1.jar 插件来执行的。

2、目标

一个插件可以对应多个目标，而每一个目标都和生命周期中的某一个环节对应。

Default 生命周期中有 compile 和 test-compile 两个和编译相关的环节，这两个环节对应 compile 和 test-compile 两个目标，而这两个目标都是由 maven-compiler-plugin-3.1.jar 插件来执行的。

3、调用插件的方法

方式一：通过生命周期映射的方式，将插件的goal绑定到生命周期中的phase上，然后调用phase。例如：maven-jar-plugin插件提供了一个叫jar的goal，默认会绑定到生命周期的package阶段(phase)。调用mvn package就会自动调用maven-jar-plugin:jar。生命周期中所有前置的phase会先自动执行。

`1`	`package <==> maven-jar-plugin:jar`

Copied!

方式二：直接调用插件的某个功能(goal)。如mvn maven-jar-plugin:jar。maven有一个约定，如果插件的名字叫maven-xxxx-plugin或xxxx-maven-plugin的话。可以直接用mvn xxxx:goal的方式调用其提供的功能。所以前面这个命令就可以简写成：mvn jar:jar。这种方式只会执行指定的goal。

调用goal完整的命令格式为：

1
2

　　mvn <plugin-prefix>:<goal>
　　mvn [<plugin-group-id>:]<plugin-artifact-id>[:<plugin-version>]:<goal>

Copied!

可以通过命令查看插件的详细信息：

`1`	`mvn help:describe -Dplugin=org.apache.maven.plugins:maven-compile-plugin –Ddetail`

Copied!

二、build标签

1、介绍

在实际使用 Maven 的过程中，我们会发现 build 标签有时候有，有时候没，这是怎么回事呢？其实通过有效 POM 我们能够看到，build 标签的相关配置其实一直都在，只是在我们需要定制构建过程的时候才会通过配置 build 标签覆盖默认值或补充配置。这一点我们可以通过打印有效 POM 来看到。

所以本质上来说：我们配置的 build 标签都是对超级 POM 配置的叠加。那我们又为什么要在默认配置的基础上叠加呢？很简单，在默认配置无法满足需求的时候定制构建过程。

2、build标签组成

①、定义约定的目录结构

参考示例中的如下部分：

<sourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\java</sourceDirectory>
<scriptSourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\scripts</scriptSourceDirectory>
<testSourceDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\src\test\java</testSourceDirectory>
<outputDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\target\classes</outputDirectory>
<testOutputDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\target\test-classes</testOutputDirectory>
<resources>
    <resource>
        <directory>D:\idea2019workspace\atguigu-maven-test-prepare\src\main\resources</directory>
    </resource>
</resources>
<testResources>
    <testResource>
        <directory>D:\idea2019workspace\atguigu-maven-test-prepare\src\test\resources</directory>
    </testResource>
</testResources>
<directory>D:\idea2019workspace\atguigu-maven-test-prepare\target</directory>

Copied!

我们能看到各个目录的作用如下：

目录名	作用
sourceDirectory	主体源程序存放目录
scriptSourceDirectory	脚本源程序存放目录
testSourceDirectory	测试源程序存放目录
outputDirectory	主体源程序编译结果输出目录
testOutputDirectory	测试源程序编译结果输出目录
resources	主体资源文件存放目录
testResources	测试资源文件存放目录
directory	构建结果输出目录

②、备用插件管理

pluginManagement 标签存放着几个极少用到的插件：

maven-antrun-plugin
maven-assembly-plugin
maven-dependency-plugin
maven-release-plugin

通过 pluginManagement 标签管理起来的插件就像 dependencyManagement 一样，子工程使用时可以省略版本号，起到在父工程中统一管理版本的效果。情看下面例子：

被 spring-boot-dependencies 管理的插件信息：

<pluginManagement>
      <plugins>
          <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.6.2</version>
          </plugin>
  		</plugins>
</pluginManagement>

Copied!

子工程使用的插件信息：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Copied!

③、插件结构

plugins 标签存放的是默认生命周期中实际会用到的插件，这些插件想必大家都不陌生，所以抛开插件本身不谈，我们来看看 plugin 标签的结构：

<plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.1</version>
    <executions>
        <execution>
            <id>default-compile</id>
            <phase>compile</phase>
            <goals>
                <goal>compile</goal>
            </goals>
        </execution>
        <execution>
            <id>default-testCompile</id>
            <phase>test-compile</phase>
            <goals>
                <goal>testCompile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Copied!

[1] 坐标部分

artifactId 和 version 标签定义了插件的坐标，作为 Maven 的自带插件这里省略了 groupId。

[2] 执行部分

executions 标签内可以配置多个 execution 标签，execution 标签内：

id：指定唯一标识
phase：关联的生命周期阶段
goals/goal：关联指定生命周期的目标
- goals 标签中可以配置多个 goal 标签，表示一个生命周期环节可以对应当前插件的多个目标。

另外，插件目标的执行过程可以进行配置，例如 maven-site-plugin 插件的 site 目标：

<execution>
    <id>default-site</id>
    <phase>site</phase>
    <goals>
        <goal>site</goal>
    </goals>
    <configuration>
        <outputDirectory>D:\idea2019workspace\atguigu-maven-test-prepare\target\site</outputDirectory>
        <reportPlugins>
            <reportPlugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
            </reportPlugin>
        </reportPlugins>
    </configuration>
</execution>

Copied!

configuration 标签内进行配置时使用的标签是插件本身定义的。就以 maven-site-plugin 插件为例，它的核心类是 org.apache.maven.plugins.site.render.SiteMojo，在这个类中我们看到了 outputDirectory 属性：

SiteMojo 的父类是：AbstractSiteRenderingMojo，在父类中我们看到 reportPlugins 属性：

结论：每个插件能够做哪些设置都是各个插件自己规定的，无法一概而论。

三、定义jdk版本和编码

1、直接使用默认取值

<properties>
      	<!-- maven-resources-plugin和maven-compiler-plugin插件的默认取值 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  
  			<!-- maven-site-plugin等插件的默认取值 -->
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      
      	<!-- maven-compiler-plugin插件的默认取值 -->
      	<maven.compiler.source>1.8</maven.compiler.source>
    		<maven.compiler.target>1.8</maven.compiler.target>
      
      	<!-- spring-boot-starter-parent里定义的的默认取值 -->
        <java.version>1.8</java.version>
      
</properties>

Copied!

2、或者在插件中定义

<project>
  [...]
  <!-- build 标签：意思是告诉 Maven，你的构建行为，我要开始定制了！ -->
  <build>
    [...]
    <!-- plugins 标签：Maven 你给我听好了，你给我构建的时候要用到这些插件！ -->
    <plugins>
      
      <!-- JDK版本 -->
      <plugin>
        <!-- 插件的坐标。此处引用的 maven-compiler-plugin 插件不是第三方的，是一个 Maven 自带的插件。 -->
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.10.1</version>
        <!-- configuration 标签：配置 maven-compiler-plugin 插件 -->
        <configuration>
          <!-- 具体配置信息会因为插件不同、需求不同而有所差异 -->
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    
    	<!-- 编码 -->
   		<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>3.2.0</version>
        <configuration>
          ...
          <encoding>UTF-8</encoding>
          ...
        </configuration>
      </plugin>
      
      
      
    </plugins>
    [...]
  </build>
  [...]
</project>

Copied!

source 标签含义

翻译过来就是：调用 Java 编译器命令时传入的 -source 参数。那对编译器来说，-source 参数是啥意思呢？

『提供与指定发行版的源兼容性』这句话我的理解是：

我们写代码是按 JDK 1.8 写的——这就是『源兼容性』里的『源』。
指定发行版就是我们指定的 JDK 1.8。
『兼容性』是谁和谁兼容呢？现在源代码是既定的，所以就是要求编译器使用指定的 JDK 版本来兼容我们的源代码。

target 标签含义

调用 Java 编译器命令时传入的 -target 参数

『生成特定 VM 版本的类文件』这句话我的理解是：

VM 指 JVM
类文件指 *.class 字节码文件
整体意思就是源文件编译后，生成的 *.class 字节码文件要符合指定的 JVM 版本

3、或写在超级pom里，全局设定

配置的方式是：将 profile 标签整个复制到 settings.xml 文件的 profiles 标签内。

<profile>
	  <id>jdk-1.8</id>
	  <activation>
		<activeByDefault>true</activeByDefault>
		<jdk>1.8</jdk>
	  </activation>
	  <properties>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
	  </properties>
</profile>

Copied!

不推荐,仅在本地生效，如果脱离当前的settings.xml能够覆盖的范围，则无法生效

四、help 插件的各个目标

官网说明地址：https://maven.apache.org/plugins/maven-help-plugin

目标	说明
help:active-profiles	列出当前已激活的 profile
help:all-profiles	列出当前工程所有可用 profile
help:describe	描述一个插件和/或 Mojo 的属性
help:effective-pom	以 XML 格式展示有效 POM
help:effective-settings	为当前工程以 XML 格式展示计算得到的 settings 配置
help:evaluate	计算用户在交互模式下给出的 Maven 表达式
help:system	显示平台详细信息列表，如系统属性和环境变量

五、springboot打包插件

1、打包

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
			<version>2.5.5</version>
		</plugin>
	</plugins>
</build>

Copied!

很显然 spring-boot-maven-plugin 并不是 Maven 自带的插件，而是 SpringBoot 提供的，用来改变 Maven 默认的构建行为。具体来说是改变打包的行为。默认情况下 Maven 调用 maven-jar-plugin 插件的 jar 目标，生成普通的 jar 包。

普通 jar 包没法使用 java -jar xxx.jar 这样的命令来启动、运行，但是 SpringBoot 的设计理念就是每一个『微服务』导出为一个 jar 包，这个 jar 包可以使用 java -jar xxx.jar 这样的命令直接启动运行。

这样一来，打包的方式肯定要进行调整。所以 SpringBoot 提供了 spring-boot-maven-plugin 这个插件来定制打包行为。

2、插件的七个目标

目标名称	作用
spring-boot:build-image	Package an application into a OCI image using a buildpack.
spring-boot:build-info	Generate a build-info.properties file based on the content of the current MavenProject.
spring-boot:help	Display help information on spring-boot-maven-plugin. Call mvn spring-boot:help -Ddetail=true -Dgoal= to display parameter details.
spring-boot:repackage	Repackage existing JAR and WAR archives so that they can be executed from the command line using java -jar. With layout=NONE can also be used simply to package a JAR with nested dependencies (and no main class, so not executable).
spring-boot:run	Run an application in place.
spring-boot:start	Start a spring application. Contrary to the run goal, this does not block and allows other goals to operate on the application. This goal is typically used in integration test scenario where the application is started before a test suite and stopped after.
spring-boot:stop	Stop an application that has been started by the ‘start’ goal. Typically invoked once a test suite has completed.

六、自定义插件

1、创建工程

创建一个常规的maven工程
然后修改打包方式：
1

<packaging>maven-plugin</packaging>
Copied!

引入依赖（二选一）：

[1] 将来在文档注释中使用注解

<dependency>
    <groupId>org.apache.maven</groupId>
    <artifactId>maven-plugin-api</artifactId>
    <version>3.5.2</version>
</dependency>

Copied!

[2] 将来直接使用注解

<dependency>
    <groupId>org.apache.maven.plugin-tools</groupId>
    <artifactId>maven-plugin-annotations</artifactId>
    <version>3.5.2</version>
</dependency>

Copied!

创建 Mojo 类

Mojo 类是一个 Maven 插件的核心类。

Mojo 这个单词的意思是：Maven Old Java Object，其实 mojo 这个单词本身包含魔力;符咒(袋);护身符;(人的)魅力的含义，Maven 用 Mojo 是因为它是对 POJO 开的一个小玩笑。

[1] Mojo 接口

每一个 Mojo 都需要实现 org.apache.maven.plugin.Mojo 接口

**[2] AbstractMojo 抽象

我们实现 Mojo 接口比较困难，幸好可以继承 AbstractMojo，此时我们只要实现 execute() 这一个方法即可。

public class MyHelloPlugin extends AbstractMojo {
    @Override
    public void execute() throws MojoExecutionException, MojoFailureException {
        getLog().info("---> This is my first maven plugin. <---");
    }
}

Copied!

2、插件配置

①、Mojo 类中的配置

[1]文档注释中用注解

对应的 pom.xml 中的依赖： maven-plugin-api

[2]直接在类上标记注解

对应 pom.xml 中的依赖：maven-plugin-annotations

// name 属性：指定目标名称
@Mojo(name = "firstBlood")
public class MyPluginOfFistBlood extends AbstractMojo {
    @Override
    public void execute() throws MojoExecutionException, MojoFailureException {
        getLog().info("---> first blood <---");
    }
}

Copied!

②、安装插件

要在后续使用插件，就必须至少将插件安装到本地仓库。 mvn install

③、注册插件

我们需要将插件坐标中的 groupId 部分注册到 settings.xml 中。

<pluginGroups>
	<!-- pluginGroup
	 | Specifies a further group identifier to use for plugin lookup.
	<pluginGroup>com.your.plugins</pluginGroup>
	-->
	<pluginGroup>com.atguigu.maven</pluginGroup>
</pluginGroups>

Copied!

3、使用插件

①、识别插件前缀

Maven 根据插件的 artifactId 来识别插件前缀。例如下面两种情况：

[1]前置匹配

匹配规则：${prefix}-maven-plugin
artifactId：hello-maven-plugin
前缀：hello

[2]中间匹配

匹配规则：maven-${prefix}-plugin
artifactId：maven-good-plugin
前缀：good

②在命令行直接用

命令：

`1`	`mvn hello:sayHello`

Copied!

效果：

③、配置到 build 标签里用

<build>
	<plugins>
		<plugin>
			<groupId>com.atguigu.maven</groupId>
			<artifactId>hello-maven-plugin</artifactId>
			<version>1.0-SNAPSHOT</version>
			<executions>
				<execution>
                    <id>hello</id>
                    <!-- 指定和目标关联的生命周期阶段 -->
					<phase>clean</phase>
					<goals>
						<goal>sayHello</goal>
					</goals>
				</execution>
                <execution>
                    <id>blood</id>
                    <phase>validate</phase>
                    <goals>
                        <goal>firstBlood</goal>
                    </goals>
                </execution>
			</executions>
		</plugin>
	</plugins>
</build>

Copied!

执行已和插件目标绑定的生命周期：

七、maven常用插件

1、maven-compiler-plugin

默认绑定到comile phase。用于编译项目源代码。 compile目标会编译src/main/java目录下的源代码。 testCompile目标会编译src/test/java目录下的测试代码。

maven compile编译源代码。 maven testCompile编译源代码+测试代码。

配置：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.6.0</version>
    <configuration>
        <source>1.8</source> <!-- 源代码使用jdk1.8支持的特性 -->
        <target>1.8</target> <!-- 使用jvm1.8编译目标代码 -->
      	<encoding>utf-8</encoding> <!-- 编码 -->
      	<skipTests>true</skipTests>  <!-- 是否跳过测试 -->
  			<showWarnings>true</showWarnings>
      	<meminitial>128m</meminitial> <!-- 编译器使用的初始内存 -->
      	<maxmem>512m</maxmem>  <!-- 编译器使用的最大内存 -->
      	<compilerArgs> <!-- 传递参数 --> 
          <compilerArgs> <!-- 传递参数 -->
                        <arg>-Xlint:unchecked</arg><!--启用对未经检查的转换的警告   Map map = new HashMap();
                                                         map.put("a", new A());-->
                        <arg>-Xlint:deprecation</arg><!--显示关于使用了过时的 API 的详细信息-->
        </compilerArgs>
    </configuration>
</plugin>

Copied!

用户可以通过两种方式调用Maven插件目标。

第一种方式是将插件目标与生命周期阶段（lifecycle phase）绑定，这样用户在命令行只是输入生命周期阶段而已，例如Maven默认将maven-compiler-plugin的compile目标与compile生命周期阶段绑定，因此命令mvn compile实际上是先定位到compile这一生命周期阶段，然后再根据绑定关系调用maven-compiler-plugin的compile目标。

第二种方式是直接在命令行指定要执行的插件目标，例如mvn archetype:generate 就表示调用maven-archetype-plugin的generate目标，这种带冒号的调用方式与生命周期无关。

2、maven-resources-plugin

①、分环境配置

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>2.5</version>
    <configuration>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <!-- 先把所有环境的配置全部排除 -->
                <excludes>
                    <exclude>dev/**</exclude>
                    <exclude>prod/**</exclude>
                </excludes>
            </resource>
            <resource>
                <directory>src/main/resources/${active.profile}</directory>
                <!-- 再把当前环境的配置引入 -->
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </configuration>
</plugin>
<!-- 或者 -->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <!-- 先把所有环境的配置全部排除 -->
            <excludes>
                <exclude>dev/**</exclude>
                <exclude>prod/**</exclude>
            </excludes>
        </resource>
        <resource>
            <directory>src/main/resources/${active.profile}</directory>
            <!-- 再把当前环境的配置引入 -->
            <includes>
                <include>**/*.xml</include>
                <include>**/*.properties</include>
            </includes>
        </resource>
    </resources>
</build>

Copied!

配置profile

<profiles>
    <profile>
        <id>dev</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <active.profile>dev</active.profile>
        </properties>
    </profile>
    <profile>
        <id>prod</id>
        <properties>
            <active.profile>prod</active.profile>
        </properties>
    </profile>
</profiles>

Copied!

②、打源码包

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>3.0.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>jar-no-fork</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
</build>

Copied!

3、maven-surefire-plugin

用于跑测试用例

此插件可以不在pom.xml里面声明，maven运行命令时，会自动调用该插件。一些有用的配置：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
      	<testFailureIgnore>true</testFailureIgnore>  <!--测试有失败用例时，是否继续构建-->
      	<skipTests>true</skipTests>                  <!--是否跳过测试阶段，方式1-->
　　　   <skip>true</skip>                            <!--是否跳过测试阶段，方式2-->
        <skipAfterFailureCount>1</skipAfterFailureCount>  <!-- 只要有一个用例测试失败，就立即停止。默认情况下会跑完所有测试用例 -->
        <rerunFailingTestsCount>2</rerunFailingTestsCount>  <!-- 失败重试次数 -->
        <parallel>methods</parallel>  <!-- 并发执行测试用例 -->
        <threadCount>10</threadCount>  <!-- 并发执行时的线程数量 -->
    </configuration>
</plugin>

Copied!

4、spring-boot-maven-plugin

spring-boot开发必备插件。它能将spring-boot项目代码及其依赖jar打包成一个完整的可执行的jar包（fat jar）作用和插件maven-shade-plugin差不多。 repackage的goal绑定在生命周期的package阶段。使用方式：

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Copied!

如果指定了spring-boot作为parent，可以不指定版本和repackage goal：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.3.8.RELEASE</version>
    <configuration>
        <mainClass>${start-class}</mainClass>
   </configuration>
</parent>

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

Copied!

spring-boot查找main文件的流程是：

1、首先查看<mainClass>是否有值，如果有，直接拿标签内的类名作为入口。

1
2
3

<properties>
    <start-class>com.example.Application</start-class>
</properties>

Copied!

2、如果没找到<start-class>标签，会遍历所有文件，找到注解了@SpringBootApplication并含有main方法的类，将其作为入口。实践证明，如果没有定义<start-class>，查找入口类的方法也是非常快的。在实际开发中，推荐手动定义<start-class>。这样在一个项目工程中可以有多个@SpringBootApplication注解的类，修改一下pom里的配置就能灵活切换入口了。

5、maven-jar-plugin

这个是普通java项目（非java web项目和其他特殊类型的java项目）package阶段默认绑定的插件，能够将编译好的class和资源打成jar包。

常用配置：打出可以运行的有主类的jar包

<plugin>  
    <groupId>org.apache.maven.plugins</groupId>  
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.0.2</version>
    <configuration>  
        <archive>  
          	<!--加描述-->
            <addMavenDescriptor>false</addMavenDescriptor>  
            <manifest>  
              	<!--是否要把第三方jar放到manifest的classpath中-->
                <addClasspath>true</addClasspath>  
              	<!--生成的manifest中classpath的前缀，因为要把第三方jar放到lib目录下，不是代码里的目录-->
                <classpathPrefix>lib/</classpathPrefix>  
              <!-- 执行的主程序路径 -->
                <mainClass>com.meix.boot.Application</mainClass>  
            </manifest>
        </archive>  
         <!-- 过滤掉不希望包含在jar中的文件  -->  
        <excludes>  
            <exclude>*.xml</exclude>  
            <exclude>spring/**</exclude>  
            <exclude>config/**</exclude>  
        </excludes> 
        <!-- 把配置的这个目录下的部分资源打包，其他目录的java类不打 -->
        <includes>
            <include>**/api/*</include>
        </includes>         
    </configuration>  
</plugin>

Copied!

把maven依赖的jar复制到lib目录下

<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-dependency-plugin</artifactId>
			<version>2.10</version>
			<executions>
				<execution>
					<id>copy-dependencies</id>
					<phase>package</phase>
					<goals>
						<goal>copy-dependencies</goal>
					</goals>
					<configuration>
						<outputDirectory>${project.build.directory}/lib</outputDirectory>
					</configuration>
				</execution>
			</executions>
</plugin>

Copied!

打开 MENIFEST.MF 文件可以看到如下内容：

Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Built-By: sandy
//表示依赖的第三方jar包在哪里，显然需要放在和 当前jar包同级目录下的 lib文件夹下
Class-Path: lib/gson-2.8.5.jar lib/guava-19.0.jar lib/slf4j-api-1.7.25
 .jar lib/logback-core-1.2.3.jar lib/logback-access-1.2.3.jar lib/logb
 ack-classic-1.2.3.jar lib/lombok-1.18.2.jar lib/commons-lang3-3.8.1.j
 ar lib/commons-io-2.2.jar     
Created-By: Apache Maven 3.5.2
Build-Jdk: 1.8.0_121
Main-Class: com.example.demo.test.App  //表示运行的主程序

Copied!

所以安装包的路径结构应该是：

为此需要通过 maven-assembly-plugin 插件来组装出安装包。

针对本示例对应的 maven-assembly-plugin 配置如下：

<plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-assembly-plugin</artifactId>
      <executions>
        <execution>
          <id>make-assembly</id>
          <phase>package</phase>
          <goals>
            <goal>single</goal>
          </goals>
        </execution>
      </executions>
      <configuration>
        <descriptors>  
          <!-- 和 pom.xml 同级目录下 -->
          <descriptor>assembly.xml</descriptor>
        </descriptors>
        <!-- assembly 组装出来的包会被放置在和 pom.xml同级目录下的output目录下 -->
        <outputDirectory>output</outputDirectory>
        <!-- true：会在生成的zip包名后面加上 id-->
        <appendAssemblyId>false</appendAssemblyId>
      </configuration>
</plugin>

Copied!

assembly.xml 内容如下：

<?xml version='1.0' encoding='UTF-8'?>
<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.1.0 http://maven.apache.org/xsd/assembly-2.1.0.xsd">
    <id>test-maven</id>
    <formats>
        <format>zip</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <fileSets>
        <fileSet>
            <!-- ${project.build.directory} 指 target目录 -->
            <directory>${project.build.directory}</directory>
            <!-- 表示输出到 pom 中配置的 output目录下 -->
            <outputDirectory>/</outputDirectory>
            <includes>
                <!-- 把jar放入zip包根目录 -->
                <include>test-maven*.jar</include>
                <!-- dependency插件复制的依赖jar放入zip -->
                <include>lib/*</include>
            </includes>
        </fileSet>
        <fileSet>
            <directory>${project.build.directory}/classes</directory>
            <!-- 表示输出到 pom 中配置的 output/config 目录下 -->
            <outputDirectory>/config</outputDirectory>
            <includes>
                <include>application.properties</include>
            </includes>
        </fileSet>
        <fileSet>
            <!-- ${project.basedir} 指 工程根目录 -->
            <directory>${project.basedir}</directory>
            <outputDirectory>/</outputDirectory>
            <includes>
                <include>doc/*.*</include>
            </includes>
        </fileSet>
    </fileSets>
</assembly>

Copied!

要自定义 jar 包名称，可以直接在 pom.xml 中 build 结点下设置 finalName，如：

1
2
3

<build>
      <finalName>p-test-tool</finalName>
</build>

Copied!

6、maven-assembly-plugin

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <descriptorRefs>
                        <!-- 使用官方的打包策略 -->
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>a.App</mainClass>
                        </manifest>
                    </archive>
                    <!-- assembly 组装出来的包会被放置在和 pom.xml同级目录下的output目录下 -->
                    <outputDirectory>output</outputDirectory>
                    <!-- true：会在生成的zip包名后面加上 id-->
                    <appendAssemblyId>false</appendAssemblyId>
                </configuration>
            </plugin>
        </plugins>
    </build>

Copied!

7、maven-shade-plugin

<build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>3.3.0</version>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>shade</goal>
            </goals>
            <configuration>
              <transformers>
                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                  <mainClass>org.sonatype.haven.HavenCli</mainClass>
                </transformer>
              </transformers>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

Copied!

6 生产实践

Sun, 03 Mar 2024 18:49:51 +0800

一、jar包冲突问题

1、谁需要面对 jar 包冲突？

先给结论：编订依赖列表的程序员。初次设定一组依赖，因为尚未经过验证，所以确实有可能存在各种问题，需要做有针对性的调整。那么谁来做这件事呢？我们最不希望看到的就是：团队中每个程序员都需要自己去找依赖，即使是做同一个项目，每个模块也各加各的依赖，没有统一管理。那前人踩过的坑，后人还要再踩一遍。而且大家用的依赖有很多细节都不一样，版本更是五花八门，这就让事情变得更加复杂。

所以虽然初期需要根据项目开发和实际运行情况对依赖配置不断调整，最终确定一个各方面都 OK 的版本。但是一旦确定下来，放在父工程中做依赖管理，各个子模块各取所需，这样基本上就能很好的避免问题的扩散。

即使开发中遇到了新问题，也可以回到源头检查、调整 dependencyManagement 配置的列表——而不是每个模块都要改。所以学完这一节你应该就会对前面讲过的『继承』有了更深的理解。

2、表现形式

由于实际开发时我们往往都会整合使用很多大型框架，所以一个项目中哪怕只是一个模块也会涉及到大量 jar 包。数以百计的 jar 包要彼此协调、精密配合才能保证程序正常运行。而规模如此庞大的 jar 包组合在一起难免会有磕磕碰碰。最关键的是由于 jar 包冲突所导致的问题非常诡异，这里我们只能罗列较为典型的问题，而没法保证穷举。

但是我们仍然能够指出一点：一般来说，由于我们自己编写代码、配置文件写错所导致的问题通常能够在异常信息中看到我们自己类的全类名或配置文件的所在路径。如果整个错误信息中完全没有我们负责的部分，全部是框架、第三方工具包里面的类报错，这往往就是 jar 包的问题所引起的。

而具体的表现形式中，主要体现为找不到类或找不到方法。

①抛异常：找不到类

此时抛出的常见的异常类型：

java.lang.ClassNotFoundException：编译过程中找不到类
java.lang.NoClassDefFoundError：运行过程中找不到类
java.lang.LinkageError：不同类加载器分别加载的多个类有相同的全限定名

我们来举个例子：

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.x.x</version>
</dependency>

Copied!

httpclient 这个 jar 包中有一个类：org.apache.http.conn.ssl.NoopHostnameVerifier。这个类在较低版本中没有，但在较高版本存在。比如：

jar 包版本	是否存在
4.3.6	否
4.4	是

那当我们确实需要用到 NoopHostnameVerifier 这个类，我们看到 Maven 通过依赖传递机制引入了这个 jar 包，所以没有明确地显式声明对这个 jar 包的依赖。可是 Maven 传递过来的 jar 包是 4.3.6 版本，里面没有包含我们需要的类，就会抛出异常。

而『冲突』体现在：4.3.6 和 4.4 这两个版本的 jar 包都被框架所依赖的 jar 包给传递进来了，但是假设 Maven 根据**『版本仲裁』**规则实际采纳的是 4.3.6。

②抛异常：找不到方法

程序找不到符合预期的方法。这种情况多见于通过反射调用方法，所以经常会导致：java.lang.NoSuchMethodError。比如 antlr:antlr:x.x.x 这个包中有一个接口：antlr.collections.AST

版本	getLine()方法
2.7.2	无
2.7.6	有

③没报错但结果不对

发生这种情况比较典型的原因是：两个 jar 包中的类分别实现了同一个接口，这本来是很正常的。但是问题在于：由于没有注意命名规范，两个不同实现类恰巧是同一个名字。

具体例子是有的同学在实际工作中遇到过：项目中部分模块使用 log4j 打印日志；其它模块使用 logback，编译运行都不会冲突，但是会引起日志服务降级，让你的 log 配置文件失效。比如：你指定了 error 级别输出，但是冲突就会导致 info、debug 都在输出。

3、本质

以上表现形式归根到底是两种基本情况导致的：

①同一jar包的不同版本

②不同jar包中包含同名类

这里我们拿 netty 来举个例子，netty 是一个类似 Tomcat 的 Servlet 容器。通常我们不会直接依赖它，所以基本上都是框架传递进来的。那么当我们用到的框架很多时，就会有不同的框架用不同的坐标导入 netty。大家可以参照下表对比一下两组坐标：

截止到3.2.10.Final版本以前的坐标形式：	从3.3.0.Final版本开始以后的坐标形式：
org.jboss.netty netty 3.2.10.Final	io.netty netty 3.9.2.Final

但是偏偏这两个**『不同的包』里面又有很多『全限定名相同』**的类。例如：

org.jboss.netty.channel.socket.ServerSocketChannelConfig.class org.jboss.netty.channel.socket.nio.NioSocketChannelConfig.class org.jboss.netty.util.internal.jzlib.Deflate.class org.jboss.netty.handler.codec.serialization.ObjectDecoder.class org.jboss.netty.util.internal.ConcurrentHashMap$HashIterator.class org.jboss.netty.util.internal.jzlib.Tree.class org.jboss.netty.util.internal.ConcurrentIdentityWeakKeyHashMap$Segment.class org.jboss.netty.handler.logging.LoggingHandler.class org.jboss.netty.channel.ChannelHandlerLifeCycleException.class org.jboss.netty.util.internal.ConcurrentIdentityHashMap$ValueIterator.class org.jboss.netty.util.internal.ConcurrentIdentityWeakKeyHashMap$Values.class org.jboss.netty.util.internal.UnterminatableExecutor.class org.jboss.netty.handler.codec.compression.ZlibDecoder.class org.jboss.netty.handler.codec.rtsp.RtspHeaders$Values.class org.jboss.netty.handler.codec.replay.ReplayError.class org.jboss.netty.buffer.HeapChannelBufferFactory.class

……

其实还有很多，这里列出的只是冰山一角。

当然，如果全限定名相同，类中的代码也完全相同，那么用着也行。问题是如果**『全限定名相同』，但是『代码不同』**，那可太坑了。我们随便找一个来看看：

坐标信息：org.jboss.netty:netty:jar:3.2.10.Final
代码截图：

坐标信息：io.netty:netty:jar:3.9.2.Final
代码截图：

4、解决办法

①概述

很多情况下常用框架之间的整合容易出现的冲突问题都有人总结过了，拿抛出的异常搜索一下基本上就可以直接找到对应的 jar 包。我们接下来要说的是通用方法。

不管具体使用的是什么工具，基本思路无非是这么两步：

第一步：把彼此冲突的 jar 包找到
第二步：在冲突的 jar 包中选定一个。具体做法无非是通过 exclusions 排除依赖，或是明确声明依赖。

②IDEA 的 Maven Helper 插件

这个插件是 IDEA 中安装的插件，不是 Maven 插件。它能够给我们罗列出来同一个 jar 包的不同版本，以及它们的来源。但是对不同 jar 包中同名的类没有办法。

基于 pom.xml 的依赖冲突分析

③Maven 的 enforcer 插件

使用 Maven 的 enforcer 插件既可以检测同一个 jar 包的不同版本，又可以检测不同 jar 包中同名的类。

引入 netty 依赖

这里我们引入两个对 netty 的依赖，展示不同 jar 包中有同名类的情况。

<dependencies>
    <dependency>
        <groupId>org.jboss.netty</groupId>
        <artifactId>netty</artifactId>
        <version>3.2.10.Final</version>
    </dependency>

    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty</artifactId>
        <version>3.9.2.Final</version>
    </dependency>
</dependencies>

Copied!

配置 enforcer 插件

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>1.4.1</version>
                <executions>
                    <execution>
                        <id>enforce-dependencies</id>
                        <phase>validate</phase>
                        <goals>
                            <goal>display-info</goal>
                            <goal>enforce</goal>
                        </goals>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>extra-enforcer-rules</artifactId>
                        <version>1.0-beta-4</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <rules>
                        <banDuplicateClasses>
                            <findAllDuplicates>true</findAllDuplicates>
                        </banDuplicateClasses>
                    </rules>
                </configuration>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

Copied!

测试

执行如下 Maven 命令：

`1`	`mvn clean package enforcer:enforce`

Copied!

部分运行结果：

[INFO] — maven-enforcer-plugin:1.4.1:enforce (default-cli) @ pro32-duplicate-class — [WARNING] Rule 0: org.apache.maven.plugins.enforcer.BanDuplicateClasses failed with message: Duplicate classes found:

Found in: io.netty:netty:jar:3.9.2.Final:compile org.jboss.netty:netty:jar:3.2.10.Final:compile Duplicate classes: org/jboss/netty/channel/socket/ServerSocketChannelConfig.class org/jboss/netty/channel/socket/nio/NioSocketChannelConfig.class org/jboss/netty/util/internal/jzlib/Deflate.class org/jboss/netty/handler/codec/serialization/ObjectDecoder.class org/jboss/netty/util/internal/ConcurrentHashMap$HashIterator.class

……

二、体系外jar包导入

1、提出问题

目前来说我们在 Maven 工程中用到的 jar 包都是通过 Maven 本身的机制导入进来的。

而实际开发中确实有可能用到一些 jar 包并非是用 Maven 的方式发布，那自然也没法通过 Maven 导入。

此时如果我们能够拿到该 jar 包的源码那还可以自己建一个 Maven 工程，自己打包。可是如果连源码都没有呢？

这方面的例子包括一些人脸识别用的 jar 包、海康视频监控 jar 包等等。

2、解决办法

①准备一个体系外 jar 包

通过学 Maven 以前的方式创建一个 Java 工程，然后导出 jar 包即可用来测试。

②将该 jar 包安装到 Maven 仓库

这里我们使用 install 插件的 install-file 目标：

mvn install:install-file -Dfile=[体系外 jar 包路径] \
-DgroupId=[给体系外 jar 包强行设定坐标] \
-DartifactId=[给体系外 jar 包强行设定坐标] \
-Dversion=1 \
-Dpackage=jar

Copied!

例如（Windows 系统下使用 ^ 符号换行；Linux 系统用 \）：

mvn install:install-file -Dfile=D:\idea2019workspace\atguigu-maven-outer\out\artifacts\atguigu_maven_outer\atguigu-maven-outer.jar ^
-DgroupId=com.atguigu.maven ^
-DartifactId=atguigu-maven-outer ^
-Dversion=1 ^
-Dpackaging=jar

Copied!

执行结果：

再看本地仓库中确实有：

我们打开 POM 文件看看：

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.atguigu.maven</groupId>
  <artifactId>atguigu-maven-outer</artifactId>
  <version>1</version>
  <description>POM was created from install:install-file</description>
</project>

Copied!

③测试

在其它地方依赖这个 jar 包：

<dependency>
    <groupId>com.atguigu.maven</groupId>
    <artifactId>atguigu-maven-outer</artifactId>
    <version>1</version>
</dependency>

Copied!

创建对象、调用方法：

三、Nexus私服

http://c.biancheng.net/nexus/

1、安装

下载

https://sonatype-download.global.ssl.fastly.net/repository/downloads-prod-group/3/nexus-3.38.1-01-unix.tar.gz

https://download.sonatype.com/nexus/3/latest-unix.tar.gz

上传到linux

上传到 Linux 系统，解压后即可使用，不需要安装。但是需要注意：必须提前安装 JDK

java环境

yum install -y java-1.8.0-openjdk*
java -version
which java
ls -lr /usr/bin/java
ls -lr /etc/alternatives/java
vi /etc/profile
source /etc/profile
echo $JAVA_HOME

# /etc/profile
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.322.b06-1.el7_9.x86_64
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH

Copied!

开放端口或者禁用防火墙

1
2
3

systemctl status firewalld.service
systemctl stop firewalld.service
systemctl disable firewalld.service

Copied!

2、启动nexus

1
2
3

./nexus start
./nexus status
 cat /usr/local/opt/sonatype-work/nexus3/admin.password

Copied!

[root@x ~]# /opt/nexus-3.37.0-01/bin/nexus start WARNING: ************************************************************ WARNING: Detected execution as “root” user. This is NOT recommended! WARNING: ************************************************************ Starting nexus [root@x ~]# /opt/nexus-3.37.0-01/bin/nexus status WARNING: ************************************************************ WARNING: Detected execution as “root” user. This is NOT recommended! WARNING: ************************************************************ nexus is running.

查看端口

[root@x ~]# netstat -anp | grep java tcp 0 0 127.0.0.1:45614 0.0.0.0:* LISTEN 9872/java tcp 0 0 0.0.0.0:8081 0.0.0.0:* LISTEN 9872/java

上面 45614 这个每次都不一样，不用管它。我们要访问的是 8081 这个端口。但是需要注意：8081 端口的这个进程要在启动 /opt/nexus-3.37.0-01/bin/nexus 这个主体程序一、两分钟后才会启动，请耐心等待。

问题

解决：

vi /etc/security/limits.conf
# 末尾加
@root - nofile 65536
# 重启nexus

Copied!

root为系统用户，前面要加上@

3、访问 Nexus 首页

首页地址：http://[Linux 服务器地址]:8081/

这里参考提示：

用户名：admin
密码：查看 /opt/sonatype-work/nexus3/admin.password 文件

[root@hello ~]# cat /opt/sonatype-work/nexus3/admin.password ed5e96a8-67aa-4dca-9ee8-1930b1dd5415

给 admin 用户指定新密码：

匿名登录，启用还是禁用？由于启用匿名登录后，后续操作比较简单，这里我们演示禁用匿名登录的操作方式：

4、nexus各种库

在仓库列表中，每个仓库都具有一系列属性：

Type：仓库的类型，Nexus 中有 4 中仓库类型：group（仓库组）、hosted（宿主仓库）、proxy（代理仓库）以及 virtual（虚拟仓库）。
Format：仓库的格式。
Policy：仓库的策略，表示该仓库是发布（Release）版本仓库还是快照（Snapshot）版本仓库。
Repository Status：仓库的状态。
Repository Path：仓库的路径。

仓库类型	说明

proxy	用来代理远程公共仓库，如 Maven 中央仓库、JBoss 远程仓库。
group	用来聚合代理仓库和宿主仓库，为这些仓库提供统一的服务地址，以便 Maven 可以更加方便地获得这些仓库中的构件。
hosted	存放：本团队其他开发人员部署到 Nexus 的 jar 包

仓库名称	说明
maven-central	该仓库用来代理 Maven 中央仓库，其策略为 Release，只会下载和缓存中央仓库中的发布版本的构件
maven-public	该仓库组将上述所有存储策略为 Release 的仓库聚合并通过统一的地址提供服务
maven-releasse	策略为 Release 的宿主仓库，用来部署公司或组织内部的发布版本构件。
maven-snapshots	策略为 Snapshot 的宿主仓库，用来部署公司或组织内部的快照版本构件。

初始状态下，这几个仓库都没有内容

由上图可知：

Maven 可以直接从宿主仓库中下载构件。
Maven 也可以从代理仓库中下载构件，代理仓库会从远程仓库下载并缓存构件。
Maven 还可以从仓库组中下载构件，仓库组会从其包含的宿主仓库和代理仓库中获取构件。

5、开启索引

Nexus 作为一款成熟的仓库管理工具，它通过维护仓库的索引提供了构件搜索功能，以便帮助用户方便快速地找到所需构件。

Nexus 索引下载功能默认是关闭的，如果想在 Nexus 中搜索远程仓库中的构件，就需要先开启索引下载功能。

Nexus 能够遍历仓库的所有内容，搜集它们的坐标，校验和以及所包含的 Java 类等信息，然后以索引（ nexus-indexer）的形式保存起来。Nexus 索引保存在 Nexus 安装目录下 \sonatype-work\nexus\indexer 目录中，该目录下每个子目录都代表 Nexus 中的一个仓库，用来存放各个仓库的索引，大多数的远程公共仓库（例如，中央仓库）都维护了一个这样的索引，因此本地的 Nexus 在下载到这个索引后，就能在此基础上为用户提供构件搜索和浏览等服务。需要注意的是，并不是所有的公共仓库都提供了索引，对于那些没有提供索引的仓库来说，我们是无法对其进行搜索的。

搜索：

6、新建阿里云代理

修改maven-public

7、下载构件

两种方式：pom.xml 和 setting.xml

①、在 pom.xml 中配置

<!--声明一个或多个远程仓库  -->
<repositories>
    <!-- 声明一个 Nexus 私服上的仓库  -->
    <repository>
        <!--仓库id  -->
        <id>nexus</id>
        <!-- 仓库的名称 -->
        <name>nexus</name>
        <!--仓库的地址  -->
        <url>http://10.211.55.4:8081/repository/maven-public/</url>
        <!-- 是否开启该仓库的 release 版本下载支持 -->
        <releases>
            <enabled>true</enabled>
        </releases>
        <!-- 是否开启该仓库的 snapshot 版本下载支持 -->
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>
<!-- 声明一个或多个远程插件仓库 -->
<pluginRepositories>
    <!--声明一个 Nexus 私服上的插件仓库  -->
    <pluginRepository>
        <!--插件仓库 id -->
        <id>nexus</id>
        <!--插件仓库 名称 -->
        <name>nexus</name>
        <!-- 配置的插件仓库的地址 -->
        <url>http://10.211.55.4:8081/repository/maven-public/</url>
        <!-- 是否开启该插件仓库的 release 版本下载支持 -->
        <releases>
            <enabled>true</enabled>
        </releases>
        <!-- 是否开启该插件仓库的 snapshot 版本下载支持 -->
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </pluginRepository>
</pluginRepositories>

Copied!

②、在 setting.xml 中配置

Nexus 私服通常会与镜像（mirror）结合使用，使 Nexus 成为所有远程仓库的私服，这样不仅可以从 Nexus 中获取所有所需构件，还能将配置集中到 Nexus 私服中，简化 Maven 本身的配置。

我们可以创建一个匹配任何仓库的镜像，镜像的地址为 Nexus 中仓库的地址，这样 Maven 对于任何构件的下载请求都会被拦截跳转到 Nexus 私服中，其具体配置如下。

<mirrors>
    <mirror>
        <id>nexus-mine</id>
        <name>nexus name</name>
        <mirrorOf>*</mirrorOf>
        <url>http://localhost:8082/nexus/content/groups/bianchengbang_repository_group/</url>
    </mirror>
</mirrors>

<profiles>
    <profile>
        <id>nexus</id>
        <repositories>
            <repository>
                <id>central</id>
                <url>http://localhost:8082/nexus/content/repositories/bianchengbang_central_proxy/</url>
                <releases>
                    <enabled>true</enabled>
                </releases>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </repository>
        </repositories>
        <pluginRepositories>
            <pluginRepository>
                <id>central</id>
                <url>http://localhost:8082/nexus/content/repositories/bianchengbang_central_proxy/</url>
                <releases>
                    <enabled>true</enabled>
                </releases>
                <snapshots>
                    <enabled>true</enabled>
                </snapshots>
            </pluginRepository>
        </pluginRepositories>
    </profile>
</profiles>

<activeProfiles>
    <activeProfile>nexus</activeProfile>
</activeProfiles>
<servers>
        <server>
            <id>nexus-mine</id>
            <username>admin</username>
            <password>password</password>
        </server>
</servers>

Copied!

8、上传构件

首先pom.xml ：

<project>
    ...
    <distributionManagement>
        <repository>
            <id>my_releases</id>
            <url>http://10.211.55.4:8081/repository/maven-releases/</url>
        </repository>
        <snapshotRepository>
            <id>my_snapshots</id>
            <url>http://10.211.55.4:8081/repository/maven-snapshots/</url>
        </snapshotRepository>
    </distributionManagement>
</project>

Copied!

并且settings.xml ：

<servers>
    <server>
      <id>my_releases</id>
      <username>admin</username>
      <password>password</password>
    </server>
    <server>
      <id>my_snapshots</id>
      <username>admin</username>
      <password>password</password>
    </server>
</servers>

Copied!

四、复制仓库

复制仓库，jar包的mirrorId不一样，所以不会用到本地包

_remote.repositories: mine和central是mirrorId

#NOTE: This is a Maven Resolver internal implementation file, its format can be changed without prior notice.
#Mon Apr 11 19:18:31 CST 2022
hutool-all-4.5.4.jar>mine=
hutool-all-4.5.4.pom>central=
hutool-all-4.5.4.pom>mine=
hutool-all-4.5.4.jar>central=

Copied!

需要执行脚本删除lastUpdated 和 _remote.repositories

1
2
3

#!/bin/bash
find $(cd $(dirname $0); pwd) -name "*.lastUpdated" -type f -print -exec rm -rf {} \;
find $(cd $(dirname $0); pwd) -name "_remote.repositories" -type f -print -exec rm -rf {} \;

Copied!

JUC

Sun, 03 Mar 2024 12:49:51 +0800

1.准备

pom.xml 依赖如下：

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.22</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.22</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.2.3</version>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

Copied!

logback.xml 配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date{HH:mm:ss} [%t] %logger - %m%n</pattern>
        </encoder>
    </appender>
    <logger name="c" level="debug" additivity="false">
        <appender-ref ref="STDOUT"/>
    </logger>
    <root level="ERROR">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

Copied!

2.进程与线程

2.1 进程与线程

进程

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。
当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

线程

一个进程之内可以分为一到多个线程。
一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行
Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。在 windows 中进程是不活动的，只是作为线程的容器

二者对比

进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
进程拥有共享的资源，如内存空间等，供其内部的线程共享
进程间通信较为复杂
- 同一台计算机的进程通信称为 IPC（Inter-process communication）
- 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP
线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量
线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

2.2 并行与并发

单核cpu下，线程实际还是串行执行的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是同时运行的。总结为一句话就是： 微观串行，宏观并行 。

一般会将这种线程轮流使用 CPU 的做法称为并发， concurrent

CPU	时间片 1	时间片 2	时间片 3	时间片 4
core	线程 1	线程 2	线程 3	线程 4

多核 cpu下，每个核（core）都可以调度运行线程，这时候线程可以是并行的。

CPU	时间片 1	时间片 2	时间片 3	时间片 4
core1	线程 1	线程 2	线程 3	线程 4
core2	线程 4	线程 4	线程 2	线程 2

引用 Rob Pike 的一段描述：

并发（concurrent）是同一时间应对（dealing with）多件事情的能力。

并行（parallel）是同一时间动手做（doing）多件事情的能力。

2.3 应用

$\textcolor{Green}{*应用之异步调用（案例1）} $

需要等待结果

这时既可以使用同步处理，也可以使用异步来处理

join 实现（同步）

static int result = 0;
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        result = 10;
    }, "t1");
    t1.start();
    t1.join();
    log.debug("结果为:{}", result);
}

Copied!

输出

20:30:40.453 [main] c.TestJoin - 开始
20:30:40.541 [Thread-0] c.TestJoin - 开始
20:30:41.543 [Thread-0] c.TestJoin - 结束
20:30:41.551 [main] c.TestJoin - 结果为:10

Copied!

评价

需要外部共享变量，不符合面向对象封装的思想
必须等待线程结束，不能配合线程池使用

Future 实现（同步）

private static void test2() throws InterruptedException, ExecutionException {
    log.debug("开始");
    FutureTask<Integer> result = new FutureTask<>(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        return 10;
    });
    new Thread(result, "t1").start();
    log.debug("结果为:{}", result.get());
}

Copied!

输出

10:11:57.880 c.TestSync [main] - 开始
10:11:57.942 c.TestSync [t1] - 开始
10:11:58.943 c.TestSync [t1] - 结束
10:11:58.943 c.TestSync [main] - 结果为:10

Copied!

评价

规避了使用 join 之前的缺点
可以方便配合线程池使用

private static void test3() throws InterruptedException, ExecutionException {
    ExecutorService service = Executors.newFixedThreadPool(1);
    log.debug("开始");
    Future<Integer> result = service.submit(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        return 10;
    });
    log.debug("结果为:{}, result 的类型:{}", result.get(), result.getClass());
    service.shutdown();
}

Copied!

输出

10:17:40.090 c.TestSync [main] - 开始
10:17:40.150 c.TestSync [pool-1-thread-1] - 开始
10:17:41.151 c.TestSync [pool-1-thread-1] - 结束
10:17:41.151 c.TestSync [main] - 结果为:10, result 的类型:class java.util.concurrent.FutureTask

Copied!

评价

仍然是 main 线程接收结果
get 方法是让调用线程同步等待

自定义实现（同步）

见模式篇：保护性暂停模式

CompletableFuture 实现（异步）

private static void test4() {
    // 进行计算的线程池
    ExecutorService computeService = Executors.newFixedThreadPool(1);
    // 接收结果的线程池
    ExecutorService resultService = Executors.newFixedThreadPool(1);
    log.debug("开始");
    CompletableFuture.supplyAsync(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        return 10;
    }, computeService).thenAcceptAsync((result) -> {
        log.debug("结果为:{}", result);
    }, resultService);
}

Copied!

输出

10:36:28.114 c.TestSync [main] - 开始
10:36:28.164 c.TestSync [pool-1-thread-1] - 开始
10:36:29.165 c.TestSync [pool-1-thread-1] - 结束
10:36:29.165 c.TestSync [pool-2-thread-1] - 结果为:10

Copied!

评价

可以让调用线程异步处理结果，实际是其他线程去同步等待
可以方便地分离不同职责的线程池
以任务为中心，而不是以线程为中心

BlockingQueue 实现（异步）

private static void test6() {
    ExecutorService consumer = Executors.newFixedThreadPool(1);
    ExecutorService producer = Executors.newFixedThreadPool(1);
    BlockingQueue<Integer> queue = new SynchronousQueue<>();
    log.debug("开始");
    producer.submit(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        try {
            queue.put(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    consumer.submit(() -> {
        try {
            Integer result = queue.take();
            log.debug("结果为:{}", result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

Copied!

不需等待结果

这时最好是使用异步来处理

普通线程实现

@Slf4j(topic = "c.FileReader")
public class FileReader {
    public static void read(String filename) {
        int idx = filename.lastIndexOf(File.separator);
        String shortName = filename.substring(idx + 1);
        try (FileInputStream in = new FileInputStream(filename)) {
            long start = System.currentTimeMillis();
            log.debug("read [{}] start ...", shortName);
            byte[] buf = new byte[1024];
            int n = -1;
            do {
                n = in.read(buf);
            } while (n != -1);
            long end = System.currentTimeMillis();
            log.debug("read [{}] end ... cost: {} ms", shortName, end - start);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Copied!

没有用线程时，方法的调用是同步的：

@Slf4j(topic = "c.Sync")
public class Sync {
    public static void main(String[] args) {
        String fullPath = "E:\\1.mp4";
        FileReader.read(fullPath);
        log.debug("do other things ...");
    }
}

Copied!

输出

1
2
3

18:39:15 [main] c.FileReader - read [1.mp4] start ...
18:39:19 [main] c.FileReader - read [1.mp4] end ... cost: 4090 ms
18:39:19 [main] c.Sync - do other things ...

Copied!

使用了线程后，方法的调用时异步的：

private static void test1() {
    new Thread(() -> FileReader.read(Constants.MP4_FULL_PATH)).start();
    log.debug("do other things ...");
}

Copied!

输出

1
2
3

18:41:53 [main] c.Async - do other things ...
18:41:53 [Thread-0] c.FileReader - read [1.mp4] start ...
18:41:57 [Thread-0] c.FileReader - read [1.mp4] end ... cost: 4197 ms

Copied!

线程池实现

private static void test2() {
    ExecutorService service = Executors.newFixedThreadPool(1);
    service.execute(() -> FileReader.read(Constants.MP4_FULL_PATH));
    log.debug("do other things ...");
    service.shutdown();
}

Copied!

输出

1
2
3

11:03:31.245 c.TestAsyc [main] - do other things ... 
11:03:31.245 c.FileReader [pool-1-thread-1] - read [1.mp4] start ... 
11:03:33.479 c.FileReader [pool-1-thread-1] - read [1.mp4] end ... cost: 2235 ms

Copied!

CompletableFuture 实现

private static void test3() throws IOException {
    CompletableFuture.runAsync(() -> FileReader.read(Constants.MP4_FULL_PATH));
    log.debug("do other things ...");
    System.in.read();
}

Copied!

输出

1
2
3

11:09:38.145 c.TestAsyc [main] - do other things ... 
11:09:38.145 c.FileReader [ForkJoinPool.commonPool-worker-1] - read [1.mp4] start ... 
11:09:40.514 c.FileReader [ForkJoinPool.commonPool-worker-1] - read [1.mp4] end ... cost: 2369 ms

Copied!

以调用方角度来讲，

如果需要等待结果返回，才能继续运行就是同步
不需要等待结果返回，就能继续运行就是异步

1.设计

多线程可以让方法执行变为异步的（即不要巴巴干等着）、比如说读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 cpu 什么都做不了，其它代码都得暂停…

2.结论

比如在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程
tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程
ui 程序中，开线程进行其他操作，避免阻塞 ui 线程

$\textcolor{Green}{*应用之提高效率（案例1） }$

充分利用多核 cpu 的优势，提高运行效率。想象下面的场景，执行 3 个计算，最后将计算结果汇总。

计算 1 花费 10 ms
计算 2 花费 11 ms
计算 3 花费 9 ms
汇总需要 1 ms

Copied!

如果是串行执行，那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms
但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms

注意：

需要在多核 cpu 才能提高效率，单核仍然时是轮流执行

1.设计

代码见【应用之效率-案例1】

2.结论

单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu ，不至于一个线程总占用 cpu，别的线程没法干活
多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的
- 有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任务都能拆分（参考后文的【阿姆达尔定律】）
- 也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义
IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一直等待 IO 结束，没能充分利用线程。所以才有后面的【非阻塞 IO】和【异步 IO】优化。

3.Java 线程

3.1 创建和运行线程

方法一，直接使用 Thread

// 创建线程对象
Thread t = new Thread() {
    public void run() {
        // 要执行的任务
    }
};
// 启动线程
t.start();

Copied!

例如：

// 构造方法的参数是给线程指定名字，推荐
Thread t1 = new Thread("t1") {
    @Override
    // run 方法内实现了要执行的任务
    public void run() {
        log.debug("hello");
    }
};
t1.start();

Copied!

输出：

`1`	`19:19:00 [t1] c.ThreadStarter - hello`

Copied!

方法二，使用 Runnable 配合 Thread

把【线程】和【任务】（要执行的代码）分开

Thread 代表线程
Runnable 可运行的任务（线程要执行的代码）

Runnable runnable = new Runnable() {
    public void run(){
        // 要执行的任务
    }
};
// 创建线程对象
Thread t = new Thread( runnable );
// 启动线程
t.start();

Copied!

例如：

// 创建任务对象
Runnable task2 = new Runnable() {
    @Override
    public void run() {
        log.debug("hello");
    }
};
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

Copied!

输出：

`1`	`9:19:00 [t2] c.ThreadStarter - hello`

Copied!

Java 8 以后可以使用 lambda 精简代码

// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

Copied!

Thread 与 Runnable 的关系

分析 Thread 的源码，理清它与 Runnable 的关系

//Runnable源码
public interface Runnable {
    public abstract void run();
}

Copied!

//Thread源码（部分）
public class Thread implements Runnable {
    /* What will be run. */
    private Runnable target;
    
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        //...
        this.target = target;
       //...
    }
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

Copied!

小结

方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了
用 Runnable 更容易与线程池等高级API 配合
用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

方法三，FutureTask 配合 Thread

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

// 创建任务对象
FutureTask<Integer> task3 = new FutureTask<>(() -> {
 log.debug("hello");
 return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

Copied!

输出

1
2

19:22:27 [t3] c.ThreadStarter - hello
19:22:27 [main] c.ThreadStarter - 结果是:100

Copied!

源码分析

//FutureTask源码（部分）
public class FutureTask<V> implements RunnableFuture<V> {
    /** The underlying callable; nulled out after running */
    private Callable<V> callable;
    
    /** The result to return or exception to throw from get() */
    private Object outcome; // non-volatile, protected by state reads/writes
    
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    
    public void run() {
       //...
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        }
        //...
    }
    
    protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }
    
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }
    
    private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }
}

Copied!

//Callable源码
@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

Copied!

说明：

FutureTask内置了一个Callable对象，初始化方法将指定的Callable赋给这个对象。
FutureTask实现了Runnable接口，并重写了Run方法，在Run方法中调用了Callable中的call方法，并将返回值赋值给outcome变量
get方法就是取出outcome的值。

3.2 观察多个线程同时运行

主要是理解

交替执行
谁先谁后，不由我们控制

示例代码

@Slf4j(topic = "c.TestMultiThread")
public class TestMultiThread {

    public static void main(String[] args) {
        new Thread(() -> {
            while(true) {
                log.debug("running");
            }
        },"t1").start();
        new Thread(() -> {
            while(true) {
                log.debug("running");
            }
        },"t2").start();
    }
}

Copied!

运行结果：

23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running

Copied!

3.3 查看进程线程的方法

windows

任务管理器可以查看进程和线程数，也可以用来杀死进程
tasklist 查看进程
- tasklist | findstr (查找关键字)
taskkill 杀死进程
- taskkill /F(彻底杀死）/PID(进程PID)

Linux

ps -fe 查看所有进程
ps -fT -p 查看某个进程（PID）的所有线程
kill 杀死进程 top 按大写 H 切换是否显示线程
top -H -p 查看某个进程（PID）的所有线程

Java

jps 命令查看所有 Java 进程
jstack 查看某个 Java 进程（PID）的所有线程状态
jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

jconsole 远程监控配置

需要以如下方式运行你的 java 类

1
2
3

java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote -
Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 -
Dcom.sun.management.jmxremote.authenticate=是否认证 java类

Copied!

关闭防火墙，允许端口
修改 /etc/hosts 文件将 127.0.0.1 映射至主机名

如果要认证访问，还需要做如下步骤

复制 jmxremote.password 文件
修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写
连接时填入 controlRole（用户名），R&D（密码）

$\textcolor{Blue}{3.4 * 原理之线程运行} $

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）

我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。

每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换（Thread Context Switch）

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

线程的 cpu 时间片用完
垃圾回收
有更高优先级的线程需要运行
线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
Context Switch 频繁发生会影响性能

3.5常见方法

方法	功能	说明
public void start()	启动一个新线程；Java虚拟机调用此线程的run方法	start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的 start方法只能调用一次，如果调用了多次会出现 IllegalThreadStateException
public void run()	线程启动后调用该方法	如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为
public void setName(String name)	给当前线程取名字
public void getName()	获取当前线程的名字。线程存在默认名称：子线程是Thread-索引，主线程是main
public static Thread currentThread()	获取当前线程对象，代码在哪个线程中执行
public static void sleep(long time)	让当前线程休眠多少毫秒再继续执行。Thread.sleep(0) : 让操作系统立刻重新进行一次cpu竞争
public static native void yield()	提示线程调度器让出当前线程对CPU的使用	主要是为了测试和调试
public final int getPriority()	返回此线程的优先级
public final void setPriority(int priority)	更改此线程的优先级，常用1 5 10	java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率
public void interrupt()	中断这个线程，异常处理机制
public static boolean interrupted()	判断当前线程是否被打断，清除打断标记
public boolean isInterrupted()	判断当前线程是否被打断，不清除打断标记
public final void join()	等待这个线程结束
public final void join(long millis)	等待这个线程死亡millis毫秒，0意味着永远等待
public final native boolean isAlive()	线程是否存活（还没有运行完毕）
public final void setDaemon(boolean on)	将此线程标记为守护线程或用户线程
public long getId()	获取线程长整型的 id	id 唯一
public state getState()	获取线程状态	Java 中线程状态是用 6 个 enum 表示，分别为： NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
public boolean isInterrupted()	判断是否被打断	不会清除打断标记

3.6 start 与 run

调用 run

public static void main(String[] args) {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug(Thread.currentThread().getName());
            FileReader.read(Constants.MP4_FULL_PATH);
        }
    };
    t1.run();
    log.debug("do other things ...");
}

Copied!

输出

19:39:14 [main] c.TestStart - main
19:39:14 [main] c.FileReader - read [1.mp4] start ...
19:39:18 [main] c.FileReader - read [1.mp4] end ... cost: 4227 ms
19:39:18 [main] c.TestStart - do other things ...

Copied!

程序仍在 main 线程运行， FileReader.read() 方法调用还是同步的

调用start

将上述代码的 t1.run() 改为

`1`	`t1.start();`

Copied!

输出

19:41:30 [main] c.TestStart - do other things ...
19:41:30 [t1] c.TestStart - t1
19:41:30 [t1] c.FileReader - read [1.mp4] start ...
19:41:35 [t1] c.FileReader - read [1.mp4] end ... cost: 4542 ms

Copied!

程序在 t1 线程运行， FileReader.read() 方法调用是异步的

小结

直接调用 run 是在主线程中执行了 run，没有启动新的线程

使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

public static void main(String[] args) {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug("running...");
        }
    };
    System.out.println(t1.getState());
    t1.start();
    System.out.println(t1.getState());
}

Copied!

可以看见，start方法创建了一个新线程，将线程从就绪状态切换为Runnable

1
2
3

NEW
RUNNABLE
03:45:12.255 c.Test5 [t1] - running...

Copied!

3.7 sleep 与 yield

sleep

调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug("enter sleep...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                log.debug("wake up...");
                e.printStackTrace();
            }
        }
    };
    t1.start();

    Thread.sleep(1000);
    log.debug("interrupt...");
    t1.interrupt();
}

Copied!

输出结果：

03:47:18.141 c.Test7 [t1] - enter sleep...
03:47:19.132 c.Test7 [main] - interrupt...
03:47:19.132 c.Test7 [t1] - wake up...
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at cn.itcast.test.Test7$1.run(Test7.java:14)

Copied!

睡眠结束后的线程未必会立刻得到执行
建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性。其底层还是sleep方法。

@Slf4j(topic = "c.Test8")
public class Test8 {

    public static void main(String[] args) throws InterruptedException {
        log.debug("enter");
        TimeUnit.SECONDS.sleep(1);
        log.debug("end");
//        Thread.sleep(1000);
    }
}

Copied!

在循环访问锁的过程中，可以加入sleep让线程阻塞时间，防止大量占用cpu资源。

yield

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
具体的实现依赖于操作系统的任务调度器

线程优先级

线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

测试优先级和yield

@Slf4j(topic = "c.TestYield")
public class TestYield {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
//                Thread.yield();
                System.out.println("              ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

Copied!

测试结果：

#优先级
---->1 283500
---->2 374389
#yield
---->1 119199
---->2 101074

Copied!

可以看出，线程优先级和yield会对线程获取cpu时间片产生一定影响，但不会影响太大。

$\textcolor{Green}{* 应用之限制（案例1） } $

sleep 实现

在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu，这时可以使用 yield 或 sleep 来让出 cpu 的使用权给其他程序

while(true) {
    try {
        Thread.sleep(50);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

Copied!

可以用 wait 或条件变量达到类似的效果
不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
sleep 适用于无需锁同步的场景

wait 实现

synchronized(锁对象) {
    while(条件不满足) { 
        try {
            锁对象.wait();
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
    // do sth...
}

Copied!

条件变量实现

lock.lock();
try {
    while(条件不满足) {
        try {
            条件变量.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // do sth...
} finally {
    lock.unlock();
}

Copied!

3.8 join 方法详解

为什么需要 join

下面的代码执行，打印 r 是什么？

static int r = 0;
public static void main(String[] args) throws InterruptedException {
    test1();
}
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    });
    t1.start();
    log.debug("结果为:{}", r);
    log.debug("结束");
}

Copied!

分析

因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

解决方法

用 sleep 行不行？为什么？
用 join，加在 t1.start() 之后即可

$\textcolor{green}{* 应用之同步（案例1）}$

以调用方角度来讲，如果

需要等待结果返回，才能继续运行就是同步
不需要等待结果返回，就能继续运行就是异步

等待多个结果

问，下面代码 cost 大约多少秒？

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
    test2();
}
private static void test2() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(1);
        r1 = 10;
    });
    Thread t2 = new Thread(() -> {
        sleep(2);
        r2 = 20;
    });
    long start = System.currentTimeMillis();
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

Copied!

分析如下

第一个 join：等待 t1 时, t2 并没有停止, 而在运行
第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s

如果颠倒两个 join 呢？

最终都是输出

`1`	`20:45:43.239 [main] c.TestJoin - r1: 10 r2: 20 cost: 2005`

Copied!

有时效的join

当线程执行时间没有超过join设定时间

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
    test3();
}
public static void test3() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(1);
        r1 = 10;
    });
    long start = System.currentTimeMillis();
    t1.start();
    // 线程执行结束会导致 join 结束
    t1.join(1500);
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

Copied!

输出

`1`	`20:48:01.320 [main] c.TestJoin - r1: 10 r2: 0 cost: 1010`

Copied!

当执行时间超时

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
    test3();
}
public static void test3() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(2);
        r1 = 10;
    });
    long start = System.currentTimeMillis();
    t1.start();
    // 线程执行结束会导致 join 结束
    t1.join(1500);
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

Copied!

输出

`1`	`20:52:15.623 [main] c.TestJoin - r1: 0 r2: 0 cost: 1502`

Copied!

3.9 interrupt方法详解

`Interrupt`说明

interrupt的本质是将线程的打断标记设为true，并调用线程的三个parker对象（C++实现级别）unpark该线程。

基于以上本质，有如下说明：

打断线程不等于中断线程，有以下两种情况：
- 打断正在运行中的线程并不会影响线程的运行，但如果线程监测到了打断标记为true，可以自行决定后续处理。
- 打断阻塞中的线程会让此线程产生一个InterruptedException异常，结束线程的运行。但如果该异常被线程捕获住，该线程依然可以自行决定后续处理（终止运行，继续运行，做一些善后工作等等）

打断 sleep，wait，join 的线程

这几个方法都会让线程进入阻塞状态

打断 sleep 的线程, 会清空打断状态，以 sleep 为例

private static void test1() throws InterruptedException {
    Thread t1 = new Thread(()->{
        sleep(1);
    }, "t1");
    t1.start();
    sleep(0.5);
    t1.interrupt();
    log.debug(" 打断状态: {}", t1.isInterrupted());
}

Copied!

输出

java.lang.InterruptedException: sleep interrupted
 at java.lang.Thread.sleep(Native Method)
 at java.lang.Thread.sleep(Thread.java:340)
 at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
 at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)
 at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)
 at java.lang.Thread.run(Thread.java:745)
21:18:10.374 [main] c.TestInterrupt - 打断状态: false

Copied!

打断正常运行的线程

打断正常运行的线程, 不会清空打断状态

private static void test2() throws InterruptedException {
    Thread t2 = new Thread(()->{
        while(true) {
            Thread current = Thread.currentThread();
            boolean interrupted = current.isInterrupted();
            if(interrupted) {
                log.debug(" 打断状态: {}", interrupted);
                break;
            }
        }
    }, "t2");
    t2.start();
    sleep(0.5);
    t2.interrupt();
}

Copied!

输出

`1`	`20:57:37.964 [t2] c.TestInterrupt - 打断状态: true`

Copied!

* 模式之两阶段终止

Two Phase Termination 在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。

错误思路

使用线程对象的 stop() 方法停止线程
- stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
使用 System.exit(int) 方法停止线程
- 目的仅是停止一个线程，但这种做法会让整个程序都停止

两阶段终止模式

利用 isInterrupted

interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

class TPTInterrupt {
    private Thread thread;
    public void start(){
        thread = new Thread(() -> {
            while(true) {
                Thread current = Thread.currentThread();
                if(current.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                    current.interrupt();
                }
                // 执行监控操作 
            }
        },"监控线程");
        thread.start();
    }
    public void stop() {
        thread.interrupt();
    }
}

Copied!

调用

TPTInterrupt t = new TPTInterrupt();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

Copied!

结果

11:49:42.915 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:43.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:44.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:45.413 c.TestTwoPhaseTermination [main] - stop 
11:49:45.413 c.TwoPhaseTermination [监控线程] - 料理后事

Copied!

利用停止标记

// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
// 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
class TPTVolatile {
    private Thread thread;
    private volatile boolean stop = false;
    public void start(){
        thread = new Thread(() -> {
            while(true) {
                Thread current = Thread.currentThread();
                if(stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                }
                // 执行监控操作
            }
        },"监控线程");
        thread.start();
    }
    public void stop() {
        stop = true;
        thread.interrupt();
    }
}

Copied!

调用

TPTVolatile t = new TPTVolatile();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

Copied!

结果

11:54:52.003 c.TPTVolatile [监控线程] - 将结果保存
11:54:53.006 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.007 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.502 c.TestTwoPhaseTermination [main] - stop 
11:54:54.502 c.TPTVolatile [监控线程] - 料理后事

Copied!

打断 park 线程

打断 park 线程, 不会清空打断状态

private static void test3() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        log.debug("park...");
        LockSupport.park();
        log.debug("unpark...");
        log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
    }, "t1");
    t1.start();
    sleep(0.5);
    t1.interrupt();
}

Copied!

输出

1
2
3

21:11:52.795 [t1] c.TestInterrupt - park... 
21:11:53.295 [t1] c.TestInterrupt - unpark... 
21:11:53.295 [t1] c.TestInterrupt - 打断状态：true

Copied!

如果打断标记已经是 true, 则 park 会失效

private static void test4() {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            log.debug("park...");
            LockSupport.park();
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }
    });
    t1.start();
    sleep(1);
    t1.interrupt();
}

Copied!

输出

21:13:48.783 [Thread-0] c.TestInterrupt - park... 
21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.812 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 
21:13:49.813 [Thread-0] c.TestInterrupt - park... 
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true

Copied!

提示

可以使用 Thread.interrupted() 清除打断状态

3.10 不推荐的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁

方法名	static	功能说明
stop()		停止线程运行
suspend()		挂起（暂停）线程运行
resume()		恢复线程运行

3.11 主线程与守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

例:

log.debug("开始运行...");
Thread t1 = new Thread(() -> {
     log.debug("开始运行...");
     sleep(2);
     log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");

Copied!

输出：

1
2
3

08:26:38.123 [main] c.TestDaemon - 开始运行... 
08:26:38.213 [daemon] c.TestDaemon - 开始运行... 
08:26:39.215 [main] c.TestDaemon - 运行结束...

Copied!

注意

垃圾回收器线程就是一种守护线程

Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

3.12 五种状态

这是从 操作系统 层面来描述的

【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
【运行状态】指获取了 CPU 时间片运行中的状态
- 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
【阻塞状态】
- 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
- 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
- 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

3.13 六种状态

这是从 Java API 层面来描述的

根据 Thread.State 枚举，分为六种状态

NEW 线程刚被创建，但是还没有调用 start() 方法
RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节详述
TERMINATED 当线程代码运行结束

3.14 习题

阅读华罗庚《统筹方法》，给出烧水泡茶的多线程解决方案，提示

参考图二，用两个线程（两个人协作）模拟烧水泡茶过程
- 文中办法乙、丙都相当于任务串行
- 而图一相当于启动了 4 个线程，有点浪费
用 sleep(n) 模拟洗茶壶、洗水壶等耗费的时间

$\textcolor{green}{* 应用之统筹（烧水泡茶）}$

解法1：join

Thread t1 = new Thread(() -> {
    log.debug("洗水壶");
    sleep(1);
    log.debug("烧开水");
    sleep(15);
}, "老王");
Thread t2 = new Thread(() -> {
    log.debug("洗茶壶");
    sleep(1);
    log.debug("洗茶杯");
    sleep(2);
    log.debug("拿茶叶");
    sleep(1);
    try {
        t1.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.debug("泡茶");
}, "小王");
t1.start();
t2.start();

Copied!

输出

19:19:37.547 [小王] c.TestMakeTea - 洗茶壶
19:19:37.547 [老王] c.TestMakeTea - 洗水壶
19:19:38.552 [小王] c.TestMakeTea - 洗茶杯
19:19:38.552 [老王] c.TestMakeTea - 烧开水
19:19:40.553 [小王] c.TestMakeTea - 拿茶叶
19:19:53.553 [小王] c.TestMakeTea - 泡茶

Copied!

解法1 的缺陷：

上面模拟的是小王等老王的水烧开了，小王泡茶，如果反过来要实现老王等小王的茶叶拿来了，老王泡茶呢？代码最好能适应两种情况
上面的两个线程其实是各执行各的，如果要模拟老王把水壶交给小王泡茶，或模拟小王把茶叶交给老王泡茶呢

解法2：wait/notify

class S2 {
    static String kettle = "冷水";
    static String tea = null;
    static final Object lock = new Object();
    static boolean maked = false;
    public static void makeTea() {
        new Thread(() -> {
            log.debug("洗水壶");
            sleep(1);
            log.debug("烧开水");
            sleep(5);
            synchronized (lock) {
                kettle = "开水";
                lock.notifyAll();
                while (tea == null) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (!maked) {
                    log.debug("拿({})泡({})", kettle, tea);
                    maked = true;
                }
            }
        }, "老王").start();
        new Thread(() -> {
            log.debug("洗茶壶");
            sleep(1);
            log.debug("洗茶杯");
            sleep(2);
            log.debug("拿茶叶");
            sleep(1);
            synchronized (lock) {
                tea = "花茶";
                lock.notifyAll();
                while (kettle.equals("冷水")) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (!maked) {
                    log.debug("拿({})泡({})", kettle, tea);
                    maked = true;
                }
            }
        }, "小王").start();
    }
}

Copied!

输出

20:04:48.179 c.S2 [小王] - 洗茶壶
20:04:48.179 c.S2 [老王] - 洗水壶
20:04:49.185 c.S2 [老王] - 烧开水
20:04:49.185 c.S2 [小王] - 洗茶杯
20:04:51.185 c.S2 [小王] - 拿茶叶
20:04:54.185 c.S2 [老王] - 拿(开水)泡(花茶)

Copied!

解法2 解决了解法1 的问题，不过老王和小王需要相互等待，不如他们只负责各自的任务，泡茶交给第三人来做

class S3 {
    static String kettle = "冷水";
    static String tea = null;
    static final Object lock = new Object();
    public static void makeTea() {
        new Thread(() -> {
            log.debug("洗水壶");
            sleep(1);
            log.debug("烧开水");
            sleep(5);
            synchronized (lock) {
                kettle = "开水";
                lock.notifyAll();
            }
        }, "老王").start();
        new Thread(() -> {
            log.debug("洗茶壶");
            sleep(1);
            log.debug("洗茶杯");
            sleep(2);
            log.debug("拿茶叶");
            sleep(1);
            synchronized (lock) {
                tea = "花茶";
                lock.notifyAll();
            }
        }, "小王").start();
        new Thread(() -> {
            synchronized (lock) {
                while (kettle.equals("冷水") || tea == null) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("拿({})泡({})", kettle, tea);
            }
        }, "王夫人").start();
    }
}

Copied!

输出

20:13:18.202 c.S3 [小王] - 洗茶壶
20:13:18.202 c.S3 [老王] - 洗水壶
20:13:19.206 c.S3 [小王] - 洗茶杯
20:13:19.206 c.S3 [老王] - 烧开水
20:13:21.206 c.S3 [小王] - 拿茶叶
20:13:24.207 c.S3 [王夫人] - 拿(开水)泡(花茶)

Copied!

解法3：第三者协调

本章小结

本章的重点在于掌握

线程创建
线程重要 api，如 start，run，sleep，join，interrupt 等
线程状态
应用方面
- 异步调用：主线程执行期间，其它线程异步执行耗时操作
- 提高效率：并行计算，缩短运算时间
- 同步等待：join
- 统筹规划：合理使用线程，得到最优效果
原理方面
- 线程运行流程：栈、栈帧、上下文切换、程序计数器
- Thread 两种创建方式的源码
模式方面
- 终止模式之两阶段终止

4.共享模型之管程

4.1共享带来的问题

Java代码示例

两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？

static int counter = 0;
public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            counter++;
        }
    }, "t1");
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            counter--;
        }
    }, "t2");
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    log.debug("{}",counter);
}

Copied!

问题分析

以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析

例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i

Copied!

而对应 i– 也是类似：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

Copied!

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：

如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：

但多线程下这 8 行代码可能交错运行：出现负数的情况：

出现正数的情况：

临界区 Critical Section

一个程序运行多个线程本身是没有问题的
问题出在多个线程访问共享资源
- 多个线程读共享资源其实也没有问题
- 在多个线程对共享资源读写操作时发生指令交错，就会出现问题
一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

static int counter = 0;
static void increment()
    // 临界区
{
    counter++;
}
static void decrement()
    // 临界区
{
    counter--;
}

Copied!

竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

4.2 synchronized 解决方案

$\textcolor{green}{应用之互斥}$*

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

阻塞式的解决方案：synchronized，Lock
非阻塞式的解决方案：原子变量

本次课使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

注意

虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：

互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码

同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点

synchronized

语法

synchronized(对象) // 线程1， 线程2(blocked)
{
    临界区
}

Copied!

解决

static int counter = 0;
static final Object room = new Object();
public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            synchronized (room) {
                counter++;
            }
        }
    }, "t1");
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            synchronized (room) {
                counter--;
            }
        }
    }, "t2");
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    log.debug("{}",counter);
}

Copied!

图示流程

思考

synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。

为了加深理解，请思考下面的问题

如果把 synchronized(obj) 放在 for 循环的外面，如何理解？– 原子性
如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？– 锁对象
如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？– 锁对象

面向对象改进

把需要保护的共享变量放入一个类

class Room {
    int value = 0;
    public void increment() {
        synchronized (this) {
            value++;
        }
    }
    public void decrement() {
        synchronized (this) {
            value--;
        }
    }
    public int get() {
        synchronized (this) {
            return value;
        }
    }
}

@Slf4j
public class Test1 {

    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                room.increment();
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                room.decrement();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("count: {}" , room.get());
    }
}

Copied!

4.3 方法上的 synchronized

class Test{
    public synchronized void test() {

    }
}
//等价于
class Test{
    public void test() {
        synchronized(this) {

        }
    }
}

Copied!

class Test{
    public synchronized static void test() {
    }
}
等价于
class Test{
    public static void test() {
        synchronized(Test.class) {

        }
    }
}

Copied!

不加 synchronized 的方法

不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）

所谓的“线程八锁”

其实就是考察 synchronized 锁住的是哪个对象

情况1：12 或 21

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

Copied!

情况2：1s后12，或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

Copied!

情况3：3 1s 12 或 23 1s 1 或 32 1s 1

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
    public void c() {
        log.debug("3");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
    new Thread(()->{ n1.c(); }).start();
}

Copied!

情况4：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

Copied!

情况5：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

Copied!

情况6：1s 后12，或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

Copied!

情况7：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

Copied!

情况8：1s 后12，或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

Copied!

4.4 变量的线程安全分析

成员变量和静态变量是否线程安全？

如果它们没有共享，则线程安全
如果它们被共享了，根据它们的状态是否能够改变，又分两种情况
- 如果只有读操作，则线程安全
- 如果有读写操作，则这段代码是临界区，需要考虑线程安全

局部变量是否线程安全？

局部变量是线程安全的
但局部变量引用的对象则未必
- 如果该对象没有逃离方法的作用访问，它是线程安全的
- 如果该对象逃离方法的作用范围，需要考虑线程安全

局部变量线程安全分析

public static void test1() {
    int i = 10;
    i++;
}

Copied!

每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享

public static void test1();
 descriptor: ()V 
 flags: ACC_PUBLIC, ACC_STATIC
 Code:
 stack=1, locals=1, args_size=0
 0: bipush 10
 2: istore_0
 3: iinc 0, 1
 6: return
 LineNumberTable:
 line 10: 0
 line 11: 3
 line 12: 6
 LocalVariableTable:
 Start Length Slot Name Signature
 3        4     0   i      I

Copied!

如图

局部变量的引用稍有不同

先看一个成员变量的例子

class ThreadUnsafe {
    ArrayList<String> list = new ArrayList<>();
    public void method1(int loopNumber) {
        for (int i = 0; i < loopNumber; i++) {
            // { 临界区, 会产生竞态条件
            method2();
            method3();
            // } 临界区
        }
    }
    private void method2() {
        list.add("1");
    }
    private void method3() {
        list.remove(0);
    }
}

Copied!

执行

static final int THREAD_NUMBER = 2;
static final int LOOP_NUMBER = 200;
public static void main(String[] args) {
    ThreadUnsafe test = new ThreadUnsafe();
    for (int i = 0; i < THREAD_NUMBER; i++) {
        new Thread(() -> {
            test.method1(LOOP_NUMBER);
        }, "Thread" + i).start();
    }
}

Copied!

其中一种情况是，如果线程2 还未 add，线程1 remove 就会报错：

Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 
 at java.util.ArrayList.rangeCheck(ArrayList.java:657) 
 at java.util.ArrayList.remove(ArrayList.java:496) 
 at cn.itcast.n6.ThreadUnsafe.method3(TestThreadSafe.java:35) 
 at cn.itcast.n6.ThreadUnsafe.method1(TestThreadSafe.java:26) 
 at cn.itcast.n6.TestThreadSafe.lambda$main$0(TestThreadSafe.java:14) 
 at java.lang.Thread.run(Thread.java:748)

Copied!

分析：

无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量
method3 与 method2 分析相同

将 list 修改为局部变量

class ThreadSafe {
    public final void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }
    private void method2(ArrayList<String> list) {
        list.add("1");
    }
    private void method3(ArrayList<String> list) {
        list.remove(0);
    }
}

Copied!

那么就不会有上述问题了

分析：

list 是局部变量，每个线程调用时会创建其不同实例，没有共享
而 method2 的参数是从 method1 中传递过来的，与 method1 中引用同一个对象
method3 的参数分析与 method2 相同

方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题？

情况1：有其它线程调用 method2 和 method3
情况2：在情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，

class ThreadSafe {
    public final void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }
    private void method2(ArrayList<String> list) {
        list.add("1");
    }
    private void method3(ArrayList<String> list) {
        list.remove(0);
    }
}
class ThreadSafeSubClass extends ThreadSafe{
    @Override
    public void method3(ArrayList<String> list) {
        new Thread(() -> {
            list.remove(0);
        }).start();
    }
}

Copied!

从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】

常见线程安全类

String
Integer
StringBuffer
Random
Vector
Hashtable
java.util.concurrent 包下的类

这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为

Hashtable table = new Hashtable();
new Thread(()->{
    table.put("key", "value1");
}).start();
new Thread(()->{
    table.put("key", "value2");
}).start();

Copied!

它们的每个方法是原子的
但注意它们多个方法的组合不是原子的，见后面分析

线程安全类方法的组合

分析下面代码是否线程安全？

Hashtable table = new Hashtable();
// 线程1，线程2
if( table.get("key") == null) {
	table.put("key", value);
}

Copied!

不可变类线程安全性

String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的有同学或许有疑问，String 有 replace，substring 等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢？

public class Immutable{
    private int value = 0;
    public Immutable(int value){
        this.value = value;
    }
    public int getValue(){
        return this.value;
    }
}

Copied!

如果想增加一个增加的方法呢？

public class Immutable{
    private int value = 0;
    public Immutable(int value){
        this.value = value;
    }
    public int getValue(){
        return this.value;
    }

    public Immutable add(int v){
        return new Immutable(this.value + v);
    }
}

Copied!

实例分析

例1：

public class MyServlet extends HttpServlet {
    // 是否安全？
    Map<String,Object> map = new HashMap<>();
    // 是否安全？
    String S1 = "...";
    // 是否安全？
    final String S2 = "...";
    // 是否安全？
    Date D1 = new Date();
    // 是否安全？
    final Date D2 = new Date();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        // 使用上述变量
    }
}

Copied!

例2：

public class MyServlet extends HttpServlet {
    // 是否安全？
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 记录调用次数
    private int count = 0;

    public void update() {
        // ...
        count++;
    }
}

Copied!

例3：

@Aspect
@Component
public class MyAspect {
    // 是否安全？
    private long start = 0L;

    @Before("execution(* *(..))")
    public void before() {
        start = System.nanoTime();
    }

    @After("execution(* *(..))")
    public void after() {
        long end = System.nanoTime();
        System.out.println("cost time:" + (end-start));
    }
}

Copied!

例4:

public class MyServlet extends HttpServlet {
    // 是否安全
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 是否安全
    private UserDao userDao = new UserDaoImpl();

    public void update() {
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    public void update() {
        String sql = "update user set password = ? where username = ?";
        // 是否安全
        try (Connection conn = DriverManager.getConnection("","","")){
            // ...
        } catch (Exception e) {
            // ...
        }
    }
}

Copied!

例5:

public class MyServlet extends HttpServlet {
    // 是否安全
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 是否安全
    private UserDao userDao = new UserDaoImpl();

    public void update() {
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    // 是否安全
    private Connection conn = null;
    public void update() throws SQLException {
        String sql = "update user set password = ? where username = ?";
        conn = DriverManager.getConnection("","","");
        // ...
        conn.close();
    }
}

Copied!

例6：

public class MyServlet extends HttpServlet {
    // 是否安全
    private UserService userService = new UserServiceImpl();

    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    public void update() {
        UserDao userDao = new UserDaoImpl();
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    // 是否安全
    private Connection = null;
    public void update() throws SQLException {
        String sql = "update user set password = ? where username = ?";
        conn = DriverManager.getConnection("","","");
        // ...
        conn.close();
    }
}

Copied!

例7:

public abstract class Test {

    public void bar() {
        // 是否安全
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        foo(sdf);
    }

    public abstract foo(SimpleDateFormat sdf);


    public static void main(String[] args) {
        new Test().bar();
    }
}

Copied!

其中 foo 的行为是不确定的，可能导致不安全的发生，被称之为外星方法

public void foo(SimpleDateFormat sdf) {
    String dateStr = "1999-10-11 00:00:00";
    for (int i = 0; i < 20; i++) {
        new Thread(() -> {
            try {
                sdf.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

Copied!

请比较 JDK 中 String 类的实现

例8：

private static Integer i = 0;
public static void main(String[] args) throws InterruptedException {
    List<Thread> list = new ArrayList<>();
    for (int j = 0; j < 2; j++) {
        Thread thread = new Thread(() -> {
            for (int k = 0; k < 5000; k++) {
                synchronized (i) {
                    i++;
                }
            }
        }, "" + j);
        list.add(thread);
    }
    list.stream().forEach(t -> t.start());
    list.stream().forEach(t -> {
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    log.debug("{}", i);
}

Copied!

4.5 习题

卖票练习

测试下面代码是否存在线程安全问题，并尝试改正

将sell方法声明为synchronized即可
注意只将对count进行修改的一行代码用synchronized括起来也不行。对count大小的判断也必须是为原子操作的一部分，否则也会导致count值异常。

public class ExerciseSell {
    public static void main(String[] args) {
        TicketWindow ticketWindow = new TicketWindow(2000);
        List<Thread> list = new ArrayList<>();
        // 用来存储买出去多少张票
        List<Integer> sellCount = new Vector<>();
        for (int i = 0; i < 2000; i++) {
            Thread t = new Thread(() -> {
                // 分析这里的竞态条件
                int count = ticketWindow.sell(randomAmount());
                sellCount.add(count);
            });
            list.add(t);
            t.start();
        }
        list.forEach((t) -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 买出去的票求和
        log.debug("selled count:{}",sellCount.stream().mapToInt(c -> c).sum());
        // 剩余票数
        log.debug("remainder count:{}", ticketWindow.getCount());
    }
    // Random 为线程安全
    static Random random = new Random();
    // 随机 1~5
    public static int randomAmount() {
        return random.nextInt(5) + 1;
    }
}
class TicketWindow {
    private int count;
    public TicketWindow(int count) {
        this.count = count;
    }
    public int getCount() {
        return count;
    }
    //在方法上加一个synchronized即可
    public int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }
}

Copied!

另外，用下面的代码行不行，为什么？

不行，因为sellCount会被多个线程共享，必须使用线程安全的实现类。

`1`	`List<Integer> sellCount = new ArrayList<>();`

Copied!

测试脚本

for /L %n in (1,1,10) do java -cp ".;C:\Users\manyh\.m2\repository\ch\qos\logback\logbackclassic\1.2.3\logback-classic-1.2.3.jar;C:\Users\manyh\.m2\repository\ch\qos\logback\logbackcore\1.2.3\logback-core-1.2.3.jar;C:\Users\manyh\.m2\repository\org\slf4j\slf4japi\1.7.25\slf4j-api-1.7.25.jar" cn.itcast.n4.exercise.ExerciseSell

Copied!

说明：

两段没有前后因果关系的临界区代码，只需要保证各自的原子性即可，不需要括起来。

转账练习

测试下面代码是否存在线程安全问题，并尝试改正

将transfer方法的方法体用同步代码块包裹，将当Account.class设为锁对象。

public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount());
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount());
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        // 查看转账2000次后的总金额
        log.debug("total:{}",(a.getMoney() + b.getMoney()));
    }
    // Random 为线程安全
    static Random random = new Random();
    // 随机 1~100
    public static int randomAmount() {
        return random.nextInt(100) +1;
    }
}
class Account {
    private int money;
    public Account(int money) {
        this.money = money;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public void transfer(Account target, int amount) {
        if (this.money > amount) {
            this.setMoney(this.getMoney() - amount);
            target.setMoney(target.getMoney() + amount);
        }
    }
}

Copied!

这样改正行不行，为什么？

不行，因为不同线程调用此方法，将会锁住不同的对象

public synchronized void transfer(Account target, int amount) {
    if (this.money > amount) {
        this.setMoney(this.getMoney() - amount);
        target.setMoney(target.getMoney() + amount);
    }
}

Copied!

4.6 Monitor 概念

Java 对象头

以 32 位虚拟机为例

普通对象

|--------------------------------------------------------------|
|                    Object Header (64 bits)                   |
|------------------------------------|-------------------------|
|       Mark Word (32 bits)          |   Klass Word (32 bits)  |
|------------------------------------|-------------------------|

Copied!

数组对象

|---------------------------------------------------------------------------------|
|                             Object Header (96 bits)                             |
|--------------------------------|-----------------------|------------------------|
|        Mark Word(32bits)       |   Klass Word(32bits)  |  array length(32bits)  |
|--------------------------------|-----------------------|------------------------|

Copied!

其中 Mark Word 结构为

|-------------------------------------------------------|--------------------|
|                  Mark Word (32 bits)                  |        State       |
|-------------------------------------------------------|--------------------|
|    hashcode:25  | age:4 |   biased_lock:0   |   01    |       Normal       |
|-------------------------------------------------------|--------------------|
|thread:23|epoch:2| age:4 |   biased_lock:1   |   01    |       Biased       |
|-------------------------------------------------------|--------------------|
|          ptr_to_lock_record:30              |   00    | Lightweight Locked |
|-------------------------------------------------------|--------------------|
|          ptr_to_heavyweight_monitor:30      |   10    | Heavyweight Locked |
|-------------------------------------------------------|--------------------|
|                                             |   11    |    Marked for GC   |
|-------------------------------------------------------|--------------------|

Copied!

64 位虚拟机 Mark Word

|--------------------------------------------------------------------|--------------------|
|                          Mark Word (64 bits)                       |        State       |
|--------------------------------------------------------------------|--------------------|
| unused:25 | hashcode:31 | unused:1 | age:4 | biased_lock:0 |  01   |        Normal      |
|--------------------------------------------------------------------|--------------------|
| thread:54 |   epoch:2   | unused:1 | age:4 | biased_lock:1 |  01   |        Biased      |
|--------------------------------------------------------------------|--------------------|
|                    ptr_to_lock_record:62                   |  00   | Lightweight Locked |
|--------------------------------------------------------------------|--------------------|
|                 ptr_to_heavyweight_monitor:62              |  10   | Heavyweight Locked |
|--------------------------------------------------------------------|--------------------|
|                                                            |  11   |    Marked for GC   |
|--------------------------------------------------------------------|--------------------|

Copied!

参考资料

https://stackoverflow.com/questions/26357186/what-is-in-java-object-header

* 原理之Monitor(锁)

Monitor 被翻译为监视器或管程

每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的 Mark Word 中就被设置指向 Monitor 对象的指针

Monitor 结构如下

刚开始 Monitor 中 Owner 为 null
当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者 Owner 置为 Thread-2，Monitor中只能有一个 Owner
在 Thread-2 上锁的过程中，如果 Thread-3，Thread-4，Thread-5 也来执行 synchronized(obj)，就会进入 EntryList BLOCKED
Thread-2 执行完同步代码块的内容，然后唤醒 EntryList 中等待的线程来竞争锁，竞争的时是非公平的
图中 WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，但条件不满足进入 WAITING 状态的线程，后面讲 wait-notify 时会分析

注意：

synchronized 必须是进入同一个对象的 monitor 才有上述的效果

不加 synchronized 的对象不会关联监视器，不遵从以上规则

* 原理之 synchronized

static final Object lock = new Object();
static int counter = 0;
public static void main(String[] args) {
    synchronized (lock) {
        counter++;
    }
}

Copied!

对应的字节码为

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
              flags: ACC_PUBLIC, ACC_STATIC
              Code:
              stack=2, locals=3, args_size=1
              0: getstatic #2 // <- lock引用 （synchronized开始）
              3: dup
              4: astore_1 // lock引用 -> slot 1
              5: monitorenter // 将 lock对象 MarkWord 置为 Monitor 指针
              6: getstatic #3 // <- i
              9: iconst_1 // 准备常数 1
              10: iadd // +1
              11: putstatic #3 // -> i
              14: aload_1 // <- lock引用
              15: monitorexit // 将 lock对象 MarkWord 重置, 唤醒 EntryList
              16: goto 24
              19: astore_2 // e -> slot 2 
              20: aload_1 // <- lock引用
              21: monitorexit // 将 lock对象 MarkWord 重置, 唤醒 EntryList
              22: aload_2 // <- slot 2 (e)
              23: athrow // throw e
              24: return
              Exception table:
              from to target type
              6    16  19    any
              19   22  19    any
              LineNumberTable:
              line 8: 0
              line 9: 6
              line 10: 14
              line 11: 24
              LocalVariableTable:
              Start Length Slot Name Signature
              0     25     0    args [Ljava/lang/String;
              StackMapTable: number_of_entries = 2
              frame_type = 255 /* full_frame */
              offset_delta = 19
              locals = [ class "[Ljava/lang/String;", class java/lang/Object ]
              stack = [ class java/lang/Throwable ]
              frame_type = 250 /* chop */
              offset_delta = 4

Copied!

注意

方法级别的 synchronized 不会在字节码指令中有所体现

* 原理之 synchronized 进阶

轻量级锁

轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。

轻量级锁对使用者是透明的，即语法仍然是 synchronized

假设有两个方法同步块，利用同一个对象加锁

static final Object obj = new Object();
public static void method1() {
    synchronized( obj ) {
        // 同步块 A
        method2();
    }
}
public static void method2() {
    synchronized( obj ) {
        // 同步块 B
    }
}

Copied!

创建锁记录（Lock Record）对象，每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的 Mark Word
让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录
如果 cas 替换成功，对象头中存储了锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下
如果 cas 失败，有两种情况
- 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
- 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数
当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用cas将Mark Word的值恢复给对象头
- 成功，则解锁成功
- 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

static Object obj = new Object();
public static void method1() {
    synchronized( obj ) {
        // 同步块
    }
}

Copied!

当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁

这时 Thread-1 加轻量级锁失败，进入锁膨胀流程
- 即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址
- 然后自己进入 Monitor 的 EntryList BLOCKED

当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程

自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。

自旋重试成功的情况

线程1 ( core 1上)	对象Mark	线程2 ( core 2上)
-	10（重量锁）	-
访问同步块，获取monitor	10（重量锁）重量锁指针	-
成功（加锁）	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	-
执行同步块	10(重量锁）重量锁指针	访问同步块，获取 monitor
执行同步块	10（重量锁）重量锁指针	自旋重试
执行完毕	10（重量锁）重量锁指针	自旋重试
成功（解锁）	01（无锁）	自旋重试
-	10（重量锁）重量锁指针	成功（加锁)
-	10（重量锁）重量锁指针	执行同步块
-	…	…

自旋重试失败的情况

线程1 ( core 1上)	对象Mark	线程2( core 2上)
-	10（重量锁）	-
访问同步块，获取monitor	10（重量锁）重量锁指针	-
成功（加锁)	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	-
执行同步块	10（重量锁）重量锁指针	访问同步块，获取monitor
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	阻塞
-	…	…

自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。
Java 7 之后不能控制是否开启自旋功能

偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。

Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有

例如：

static final Object obj = new Object();
public static void m1() {
    synchronized( obj ) {
        // 同步块 A
        m2();
    }
}
public static void m2() {
    synchronized( obj ) {
        // 同步块 B
        m3();
    }
}
public static void m3() {
    synchronized( obj ) {
        // 同步块 C
    }
}

Copied!

graph LR
subgraph 偏向锁
t5("m1内调用synchronized(obj)")
t6("m2内调用synchronized(obj)")
t7("m2内调用synchronized(obj)")
t8(对象)
t5 -.用ThreadID替换MarkWord.-> t8
t6 -.检查ThreadID是否是自己.-> t8
t7 -.检查ThreadID是否是自己.-> t8
end
subgraph 轻量级锁
t1("m1内调用synchronized(obj)")
t2("m2内调用synchronized(obj)")
t3("m2内调用synchronized(obj)")
t1 -.生成锁记录.-> t1
t2 -.生成锁记录.-> t2
t3 -.生成锁记录.-> t3
t4(对象)
t1 -.用锁记录替换markword.-> t4
t2 -.用锁记录替换markword.-> t4
t3 -.用锁记录替换markword.-> t4
end

Copied!

偏向状态

回忆一下对象头格式

|--------------------------------------------------------------------|--------------------|
|                          Mark Word (64 bits)                       |        State       |
|--------------------------------------------------------------------|--------------------|
| unused:25 | hashcode:31 | unused:1 | age:4 | biased_lock:0 |  01   |        Normal      |
|--------------------------------------------------------------------|--------------------|
| thread:54 |   epoch:2   | unused:1 | age:4 | biased_lock:1 |  01   |        Biased      |
|--------------------------------------------------------------------|--------------------|
|                    ptr_to_lock_record:62                   |  00   | Lightweight Locked |
|--------------------------------------------------------------------|--------------------|
|                 ptr_to_heavyweight_monitor:62              |  10   | Heavyweight Locked |
|--------------------------------------------------------------------|--------------------|
|                                                            |  11   |    Marked for GC   |
|--------------------------------------------------------------------|--------------------|

Copied!

一个对象创建时：

如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的 thread、epoch、age 都为 0
偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数- XX:BiasedLockingStartupDelay=0来禁用延迟
如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、 age 都为 0，第一次用到 hashcode 时才会赋值

1）测试延迟特性

2）测试偏向锁

`1`	`class Dog {}`

Copied!

利用 jol 第三方工具来查看对象头信息（注意这里我扩展了 jol 让它输出更为简洁）

// 添加虚拟机参数 -XX:BiasedLockingStartupDelay=0 
public static void main(String[] args) throws IOException {
    Dog d = new Dog();
    ClassLayout classLayout = ClassLayout.parseInstance(d);
    new Thread(() -> {
        log.debug("synchronized 前");
        System.out.println(classLayout.toPrintableSimple(true));
        synchronized (d) {
            log.debug("synchronized 中");
            System.out.println(classLayout.toPrintableSimple(true));
        }
        log.debug("synchronized 后");
        System.out.println(classLayout.toPrintableSimple(true));
    }, "t1").start();
}

Copied!

11:08:58.117 c.TestBiased [t1] - synchronized 前
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 
11:08:58.121 c.TestBiased [t1] - synchronized 中
00000000 00000000 00000000 00000000 00011111 11101011 11010000 00000101 
11:08:58.121 c.TestBiased [t1] - synchronized 后
00000000 00000000 00000000 00000000 00011111 11101011 11010000 00000101

Copied!

注意

处于偏向锁的对象解锁后，线程 id 仍存储于对象头中

3）测试禁用

在上面测试代码运行时在添加 VM 参数 -XX:-UseBiasedLocking 禁用偏向锁

输出

11:13:10.018 c.TestBiased [t1] - synchronized 前
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
11:13:10.021 c.TestBiased [t1] - synchronized 中
00000000 00000000 00000000 00000000 00100000 00010100 11110011 10001000 
11:13:10.021 c.TestBiased [t1] - synchronized 后
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

Copied!

4)测试 hashCode

正常状态对象一开始是没有 hashCode 的，第一次调用才生成

撤销 - 调用对象 hashCode

调用了对象的 hashCode，但偏向锁的对象 MarkWord 中存储的是线程 id，如果调用 hashCode 会导致偏向锁被撤销

轻量级锁会在锁记录中记录 hashCode
重量级锁会在 Monitor 中记录 hashCode

在调用 hashCode 后使用偏向锁，记得去掉-XX:-UseBiasedLocking

输出

11:22:10.386 c.TestBiased [main] - 调用 hashCode:1778535015 
11:22:10.391 c.TestBiased [t1] - synchronized 前
00000000 00000000 00000000 01101010 00000010 01001010 01100111 00000001 
11:22:10.393 c.TestBiased [t1] - synchronized 中
00000000 00000000 00000000 00000000 00100000 11000011 11110011 01101000 
11:22:10.393 c.TestBiased [t1] - synchronized 后
00000000 00000000 00000000 01101010 00000010 01001010 01100111 00000001

Copied!

撤销 - 其它线程使用对象

当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁

private static void test2() throws InterruptedException {
    Dog d = new Dog();
    Thread t1 = new Thread(() -> {
        synchronized (d) {
            log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
        }
        synchronized (TestBiased.class) {
            TestBiased.class.notify();
        }
        // 如果不用 wait/notify 使用 join 必须打开下面的注释
        // 因为：t1 线程不能结束，否则底层线程可能被 jvm 重用作为 t2 线程，底层线程 id 是一样的
        /*try {
 System.in.read();
 } catch (IOException e) {
 e.printStackTrace();
 }*/
    }, "t1");
    t1.start();
    Thread t2 = new Thread(() -> {
        synchronized (TestBiased.class) {
            try {
                TestBiased.class.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
        synchronized (d) {
            log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
        }
        log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
    }, "t2");
    t2.start();
}

Copied!

输出

[t1] - 00000000 00000000 00000000 00000000 00011111 01000001 00010000 00000101 
[t2] - 00000000 00000000 00000000 00000000 00011111 01000001 00010000 00000101 
[t2] - 00000000 00000000 00000000 00000000 00011111 10110101 11110000 01000000 
[t2] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

Copied!

撤销 - 调用 wait/notify

public static void main(String[] args) throws InterruptedException {
    Dog d = new Dog();
    Thread t1 = new Thread(() -> {
        log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
        synchronized (d) {
            log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
            try {
                d.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
        }
    }, "t1");
    t1.start();
    new Thread(() -> {
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (d) {
            log.debug("notify");
            d.notify();
        }
    }, "t2").start();
}

Copied!

输出

[t1] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 
[t1] - 00000000 00000000 00000000 00000000 00011111 10110011 11111000 00000101 
[t2] - notify 
[t1] - 00000000 00000000 00000000 00000000 00011100 11010100 00001101 11001010

Copied!

批量重偏向

如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象的 Thread ID

当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至加锁线程

private static void test3() throws InterruptedException {
    Vector<Dog> list = new Vector<>();
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 30; i++) {
            Dog d = new Dog();
            list.add(d);
            synchronized (d) {
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
        }
        synchronized (list) {
            list.notify();
        } 
    }, "t1");
    t1.start();

    Thread t2 = new Thread(() -> {
        synchronized (list) {
            try {
                list.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        log.debug("===============> ");
        for (int i = 0; i < 30; i++) {
            Dog d = list.get(i);
            log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            synchronized (d) {
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
            log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
        }
    }, "t2");
    t2.start();
}

Copied!

输出

[t1] - 0 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 1 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 2 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 3 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 4 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 5 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 6 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 7 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 8 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 9 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 10 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 11 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 12 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 13 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 14 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 15 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 16 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 17 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 18 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t1] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - ===============> 
[t2] - 0 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 0 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 0 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 1 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 1 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 1 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 2 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 2 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 2 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 3 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 3 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 3 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 4 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 4 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 4 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 5 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 5 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 5 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 6 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 6 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 6 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 7 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 7 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 7 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 8 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 8 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 8 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 9 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 9 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 9 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 10 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 10 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 10 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 11 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 11 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 11 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 12 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 12 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 12 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 13 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 13 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 13 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 14 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 14 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 14 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 15 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 15 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 15 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 16 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 16 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 16 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 17 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 17 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 17 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 18 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 18 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000 
[t2] - 18 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101 
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101 
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101

Copied!

批量撤销

当撤销偏向锁阈值超过 40 次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的

static Thread t1,t2,t3;
private static void test4() throws InterruptedException {
    Vector<Dog> list = new Vector<>();
    int loopNumber = 39;
    t1 = new Thread(() -> {
        for (int i = 0; i < loopNumber; i++) {
            Dog d = new Dog();
            list.add(d);
            synchronized (d) {
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
        }
        LockSupport.unpark(t2);
    }, "t1");
    t1.start();
    t2 = new Thread(() -> {
        LockSupport.park();
        log.debug("===============> ");
        for (int i = 0; i < loopNumber; i++) {
            Dog d = list.get(i);
            log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            synchronized (d) {
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
            log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
        }
        LockSupport.unpark(t3);
    }, "t2");
    t2.start();
    t3 = new Thread(() -> {
        LockSupport.park();
        log.debug("===============> ");
        for (int i = 0; i < loopNumber; i++) {
            Dog d = list.get(i);
            log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            synchronized (d) {
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
            log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
        }
    }, "t3");
    t3.start();
    t3.join();
    log.debug(ClassLayout.parseInstance(new Dog()).toPrintableSimple(true));
}

Copied!

参考资料

https://github.com/farmerjohngit/myblog/issues/12

https://www.cnblogs.com/LemonFive/p/11246086.html

https://www.cnblogs.com/LemonFive/p/11248248.html

[偏向锁论文](Eliminating Synchronization-Related Atomic Operations with Biased Locking and Bulk Rebiasing (oracle.com) )

锁消除

@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations=3)
@Measurement(iterations=5)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark {
    static int x = 0;
    @Benchmark
    public void a() throws Exception {
        x++;
    }
    @Benchmark
    public void b() throws Exception {
        Object o = new Object();
        synchronized (o) {
            x++;
        }
    }
}

Copied!

java -jar benchmarks.jar

1
2
3

Benchmark 			Mode 		Samples 	Score 		Score error 	Units 
c.i.MyBenchmark.a 	avgt 		5 			1.542 			0.056 		ns/op 
c.i.MyBenchmark.b 	avgt 		5 			1.518 			0.091 		ns/op

Copied!

java -XX:-EliminateLocks -jar benchmarks.jar

1
2
3

Benchmark 			Mode 		Samples 		Score 		Score error 	Units 
c.i.MyBenchmark.a 	avgt 		5 				1.507 		0.108 			ns/op 
c.i.MyBenchmark.b 	avgt 		5 				16.976 		1.572 			ns/op

Copied!

锁粗化

对相同对象多次加锁，导致线程发生多次重入，可以使用锁粗化方式来优化，这不同于之前讲的细分锁的粒度。

4.7 wait notify

* 原理之 wait / notify

Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片
BLOCKED 线程会在 Owner 线程释放锁时唤醒
WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入 EntryList 重新竞争

API 介绍

obj.wait() 让进入 object 监视器的线程到 waitSet 等待
obj.notify() 在 object 上正在 waitSet 等待的线程中挑一个唤醒
obj.notifyAll() 让 object 上正在 waitSet 等待的线程全部唤醒

它们都是线程之间进行协作的手段，都属于 Object 对象的方法。必须获得此对象的锁，才能调用这几个方法

final static Object obj = new Object();
public static void main(String[] args) {
    new Thread(() -> {
        synchronized (obj) {
            log.debug("执行....");
            try {
                obj.wait(); // 让线程在obj上一直等待下去
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("其它代码....");
        }
    }).start();
    new Thread(() -> {
        synchronized (obj) {
            log.debug("执行....");
            try {
                obj.wait(); // 让线程在obj上一直等待下去
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("其它代码....");
        }
    }).start();
    // 主线程两秒后执行
    sleep(2);
    log.debug("唤醒 obj 上其它线程");
    synchronized (obj) {
        obj.notify(); // 唤醒obj上一个线程
        // obj.notifyAll(); // 唤醒obj上所有等待线程
    }
}

Copied!

notify 的一种结果

20:00:53.096 [Thread-0] c.TestWaitNotify - 执行.... 
20:00:53.099 [Thread-1] c.TestWaitNotify - 执行.... 
20:00:55.096 [main] c.TestWaitNotify - 唤醒 obj 上其它线程
20:00:55.096 [Thread-0] c.TestWaitNotify - 其它代码....

Copied!

notifyAll 的结果

19:58:15.457 [Thread-0] c.TestWaitNotify - 执行.... 
19:58:15.460 [Thread-1] c.TestWaitNotify - 执行.... 
19:58:17.456 [main] c.TestWaitNotify - 唤醒 obj 上其它线程
19:58:17.456 [Thread-1] c.TestWaitNotify - 其它代码.... 
19:58:17.456 [Thread-0] c.TestWaitNotify - 其它代码....

Copied!

wait() 方法会释放对象的锁，进入 WaitSet 等待区，从而让其他线程就机会获取对象的锁。无限制等待，直到 notify 为止

wait(long n) 有时限的等待, 到 n 毫秒后结束等待，或是被 notify

4.8 wait notify 的正确姿势

开始之前先看看

`sleep(long n)` 和 `wait(long n)` 的区别

sleep 是 Thread 方法，而 wait 是 Object 的方法
sleep 不需要强制和 synchronized 配合使用，但 wait 需要和 synchronized 一起用
sleep 在睡眠的同时，不会释放对象锁的，但 wait 在等待的时候会释放对象锁
它们状态 TIMED_WAITING

step 1

1
2
3

static final Object room = new Object();
static boolean hasCigarette = false;
static boolean hasTakeout = false;

Copied!

思考下面的解决方案好不好，为什么？

new Thread(() -> {
    synchronized (room) {
        log.debug("有烟没？[{}]", hasCigarette);
        if (!hasCigarette) {
            log.debug("没烟，先歇会！");
            sleep(2);
        }
        log.debug("有烟没？[{}]", hasCigarette);
        if (hasCigarette) {
            log.debug("可以开始干活了");
        }
    }
}, "小南").start();
for (int i = 0; i < 5; i++) {
    new Thread(() -> {
        synchronized (room) {
            log.debug("可以开始干活了");
        }
    }, "其它人").start();
}
sleep(1);
new Thread(() -> {
    // 这里能不能加 synchronized (room)？
    hasCigarette = true;
    log.debug("烟到了噢！");
}, "送烟的").start();

Copied!

输出

20:49:49.883 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:49:49.887 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:49:50.882 [送烟的] c.TestCorrectPosture - 烟到了噢！
20:49:51.887 [小南] c.TestCorrectPosture - 有烟没？[true] 
20:49:51.887 [小南] c.TestCorrectPosture - 可以开始干活了
20:49:51.887 [其它人] c.TestCorrectPosture - 可以开始干活了
20:49:51.887 [其它人] c.TestCorrectPosture - 可以开始干活了
20:49:51.888 [其它人] c.TestCorrectPosture - 可以开始干活了
20:49:51.888 [其它人] c.TestCorrectPosture - 可以开始干活了
20:49:51.888 [其它人] c.TestCorrectPosture - 可以开始干活了

Copied!

其它干活的线程，都要一直阻塞，效率太低
小南线程必须睡足 2s 后才能醒来，就算烟提前送到，也无法立刻醒来
加了 synchronized (room) 后，就好比小南在里面反锁了门睡觉，烟根本没法送进门，main 没加 synchronized 就好像 main 线程是翻窗户进来的
解决方法，使用 wait - notify 机制

step 2

思考下面的实现行吗，为什么？

new Thread(() -> {
    synchronized (room) {
        log.debug("有烟没？[{}]", hasCigarette);
        if (!hasCigarette) {
            log.debug("没烟，先歇会！");
            try {
                room.wait(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        log.debug("有烟没？[{}]", hasCigarette);
        if (hasCigarette) {
            log.debug("可以开始干活了");
        }
    }
}, "小南").start();
for (int i = 0; i < 5; i++) {
    new Thread(() -> {
        synchronized (room) {
            log.debug("可以开始干活了");
        }
    }, "其它人").start();
}
sleep(1);
new Thread(() -> {
    synchronized (room) {
        hasCigarette = true;
        log.debug("烟到了噢！");
        room.notify();
    }
}, "送烟的").start();

Copied!

解决了其它干活的线程阻塞的问题
但如果有其它线程也在等待条件呢？

step 3

new Thread(() -> {
    synchronized (room) {
        log.debug("有烟没？[{}]", hasCigarette);
        if (!hasCigarette) {
            log.debug("没烟，先歇会！");
            try {
                room.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        log.debug("有烟没？[{}]", hasCigarette);
        if (hasCigarette) {
            log.debug("可以开始干活了");
        } else {
            log.debug("没干成活...");
        }
    }
}, "小南").start();
new Thread(() -> {
    synchronized (room) {
        Thread thread = Thread.currentThread();
        log.debug("外卖送到没？[{}]", hasTakeout);
        if (!hasTakeout) {
            log.debug("没外卖，先歇会！");
            try {
                room.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        log.debug("外卖送到没？[{}]", hasTakeout);
        if (hasTakeout) {
            log.debug("可以开始干活了");
        } else {
            log.debug("没干成活...");
        }
    }
}, "小女").start();
sleep(1);
new Thread(() -> {
    synchronized (room) {
        hasTakeout = true;
        log.debug("外卖到了噢！");
        room.notify();
    }
}, "送外卖的").start();

Copied!

输出

20:53:12.173 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:53:12.176 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:53:12.176 [小女] c.TestCorrectPosture - 外卖送到没？[false] 
20:53:12.176 [小女] c.TestCorrectPosture - 没外卖，先歇会！
20:53:13.174 [送外卖的] c.TestCorrectPosture - 外卖到了噢！
20:53:13.174 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:53:13.174 [小南] c.TestCorrectPosture - 没干成活...

Copied!

notify 只能随机唤醒一个 WaitSet 中的线程，这时如果有其它线程也在等待，那么就可能唤醒不了正确的线程，称之为【虚假唤醒】
解决方法，改为 notifyAll

step 4

new Thread(() -> {
    synchronized (room) {
        hasTakeout = true;
        log.debug("外卖到了噢！");
        room.notifyAll();
    }
}, "送外卖的").start();

Copied!

输出

20:55:23.978 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:55:23.982 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:55:23.982 [小女] c.TestCorrectPosture - 外卖送到没？[false] 
20:55:23.982 [小女] c.TestCorrectPosture - 没外卖，先歇会！
20:55:24.979 [送外卖的] c.TestCorrectPosture - 外卖到了噢！
20:55:24.979 [小女] c.TestCorrectPosture - 外卖送到没？[true] 
20:55:24.980 [小女] c.TestCorrectPosture - 可以开始干活了
20:55:24.980 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:55:24.980 [小南] c.TestCorrectPosture - 没干成活...

Copied!

用 notifyAll 仅解决某个线程的唤醒问题，但使用 if + wait 判断仅有一次机会，一旦条件不成立，就没有重新判断的机会了
解决方法，用 while + wait，当条件不成立，再次 wait

step 5

将 if 改为 while

if (!hasCigarette) {
    log.debug("没烟，先歇会！");
    try {
        room.wait();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

Copied!

改动后

while (!hasCigarette) {
    log.debug("没烟，先歇会！");
    try {
        room.wait();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

Copied!

输出

20:58:34.322 [小南] c.TestCorrectPosture - 有烟没？[false] 
20:58:34.326 [小南] c.TestCorrectPosture - 没烟，先歇会！
20:58:34.326 [小女] c.TestCorrectPosture - 外卖送到没？[false] 
20:58:34.326 [小女] c.TestCorrectPosture - 没外卖，先歇会！
20:58:35.323 [送外卖的] c.TestCorrectPosture - 外卖到了噢！
20:58:35.324 [小女] c.TestCorrectPosture - 外卖送到没？[true] 
20:58:35.324 [小女] c.TestCorrectPosture - 可以开始干活了
20:58:35.324 [小南] c.TestCorrectPosture - 没烟，先歇会！

Copied!

synchronized(lock) {
    while(条件不成立) {
        lock.wait();
    }
    // 干活
}
//另一个线程
synchronized(lock) {
    lock.notifyAll();
}

Copied!

$\textcolor{orange}{*模式之保护性暂停}$

1.定义

即 Guarded Suspension，用在一个线程等待另一个线程的执行结果

要点

有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject
如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
JDK 中，join 的实现、Future 的实现，采用的就是此模式
因为要等待另一方的结果，因此归类到同步模式

2.实现

class GuardedObject {
    private Object response;
    private final Object lock = new Object();
    public Object get() {
        synchronized (lock) {
// 条件不满足则等待
            while (response == null) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return response;
        }
    }
    public void complete(Object response) {
        synchronized (lock) {
// 条件满足，通知等待线程
            this.response = response;
            lock.notifyAll();
        }
    }
}

Copied!

测试

一个线程等待另一个线程的执行结果

@Override
public void run() {
    GuardedObject guardedObject = MailBoxes.getGuardedObject(id);
    guardedObject.set(mail);
    log.debug("送信成功,id={},内容：{}",id,mail);
}
public static void main(String[] args) {
    GuardedObject guardedObject = new GuardedObject();
    new Thread(() -> {
        try {
            // 子线程执行下载
            List<String> response = download();
            log.debug("download complete...");
            guardedObject.complete(response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
    log.debug("waiting...");
    // 主线程阻塞等待
    Object response = guardedObject.get();
    log.debug("get response: [{}] lines", ((List<String>) response).size());
}

Copied!

执行结果

1
2
3

08:42:18.568 [main] c.TestGuardedObject - waiting...
08:42:23.312 [Thread-0] c.TestGuardedObject - download complete...
08:42:23.312 [main] c.TestGuardedObject - get response: [3] lines

Copied!

3.带超时版 GuardedObject

如果要控制超时时间呢

class GuardedObjectV2 {
    private Object response;
    private final Object lock = new Object();
    public Object get(long millis) {
        synchronized (lock) {
            // 1) 记录最初时间
            long begin = System.currentTimeMillis();
			// 2) 已经经历的时间
            long timePassed = 0;
            while (response == null) {
				// 4) 假设 millis 是 1000，结果在 400 时唤醒了，那么还有 600 要等
                long waitTime = millis - timePassed;
                log.debug("waitTime: {}", waitTime);
                if (waitTime <= 0) {
                    log.debug("break...");
                    break;
                }
                try {
                    lock.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
				// 3) 如果提前被唤醒，这时已经经历的时间假设为 400
                timePassed = System.currentTimeMillis() - begin;
                log.debug("timePassed: {}, object is null {}",
                        timePassed, response == null);
            }
            return response;
        }
    }
    public void complete(Object response) {
        synchronized (lock) {
			// 条件满足，通知等待线程
            this.response = response;
            log.debug("notify...");
            lock.notifyAll();
        }
    }
}

Copied!

测试，没有超时

public static void main(String[] args) {
    GuardedObjectV2 v2 = new GuardedObjectV2();
    new Thread(() -> {
        sleep(1);
        v2.complete(null);
        sleep(1);
        v2.complete(Arrays.asList("a", "b", "c"));
    }).start();
    Object response = v2.get(2500);
    if (response != null) {
        log.debug("get response: [{}] lines", ((List<String>) response).size());
    } else {
        log.debug("can't get response");
    }
}

Copied!

输出

08:49:39.917 [main] c.GuardedObjectV2 - waitTime: 2500
08:49:40.917 [Thread-0] c.GuardedObjectV2 - notify...
08:49:40.917 [main] c.GuardedObjectV2 - timePassed: 1003, object is null true
08:49:40.917 [main] c.GuardedObjectV2 - waitTime: 1497
08:49:41.918 [Thread-0] c.GuardedObjectV2 - notify...
08:49:41.918 [main] c.GuardedObjectV2 - timePassed: 2004, object is null false
08:49:41.918 [main] c.TestGuardedObjectV2 - get response: [3] lines

Copied!

测试超时

1
2

// 等待时间不足
List<String> lines = v2.get(1500);

Copied!

输出

08:47:54.963 [main] c.GuardedObjectV2 - waitTime: 1500
08:47:55.963 [Thread-0] c.GuardedObjectV2 - notify...
08:47:55.963 [main] c.GuardedObjectV2 - timePassed: 1002, object is null true
08:47:55.963 [main] c.GuardedObjectV2 - waitTime: 498
08:47:56.461 [main] c.GuardedObjectV2 - timePassed: 1500, object is null true
08:47:56.461 [main] c.GuardedObjectV2 - waitTime: 0
08:47:56.461 [main] c.GuardedObjectV2 - break...
08:47:56.461 [main] c.TestGuardedObjectV2 - can't get response
08:47:56.963 [Thread-0] c.GuardedObjectV2 - notify...

Copied!

$\textcolor{blue}{* 原理之 join}$

是调用者轮询检查线程 alive 状态

`1`	`t1.join();`

Copied!

等价于下面的代码

synchronized (t1) {
    // 调用者线程进入 t1 的 waitSet 等待, 直到 t1 运行结束
    while (t1.isAlive()) {
        t1.wait(0);
    }
}

Copied!

注意

join 体现的是【保护性暂停】模式，请参考之

源码：

//不带参
public final void join() throws InterruptedException {
    join(0);
}
//带参
//等待时长的实现类似于之前的保护性暂停
public final synchronized void join(long millis)
    throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

Copied!

4.多任务版GuardedObject

图中 Futures 就好比居民楼一层的信箱（每个信箱有房间编号），左侧的 t0，t2，t4 就好比等待邮件的居民，右侧的 t1，t3，t5 就好比邮递员。

如果需要在多个类之间使用 GuardedObject 对象，作为参数传递不是很方便，因此设计一个用来解耦的中间类，这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理。

新增 id 用来标识 Guarded Object

class GuardedObject {
    // 标识 Guarded Object
    private int id;
    public GuardedObject(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
    // 结果
    private Object response;
    // 获取结果
    // timeout 表示要等待多久 2000
    public Object get(long timeout) {
        synchronized (this) {
            // 开始时间 15:00:00
            long begin = System.currentTimeMillis();
            // 经历的时间
            long passedTime = 0;
            while (response == null) {
                // 这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过了最大等待时间时，退出循环
                if (timeout - passedTime <= 0) {
                    break;
                }
                try {
                    this.wait(waitTime); // 虚假唤醒 15:00:01
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 求得经历时间
                passedTime = System.currentTimeMillis() - begin; // 15:00:02 1s
            }
            return response;
        }
    }
    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            // 给结果成员变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}

Copied!

中间解耦类

class Mailboxes {
    
    private static Map<Integer, GuardedObject> boxes = new Hashtable<>();
    
    private static int id = 1;
    // 产生唯一 id，方法必须声明为synchronized
    private static synchronized int generateId() {
        return id++;
    }
    
    public static GuardedObject getGuardedObject(int id) {
        return boxes.remove(id);
    }
    
    public static GuardedObject createGuardedObject() {
        GuardedObject go = new GuardedObject(generateId());
        boxes.put(go.getId(), go);
        return go;
    }
    
    public static Set<Integer> getIds() {
        return boxes.keySet();
    }
}

Copied!

业务相关类

class People extends Thread{
    @Override
    public void run() {
        // 收信
        GuardedObject guardedObject = Mailboxes.createGuardedObject();
        log.debug("开始收信 id:{}", guardedObject.getId());
        Object mail = guardedObject.get(5000);
        log.debug("收到信 id:{}, 内容:{}", guardedObject.getId(), mail);
    }
}

Copied!

class Postman extends Thread {
    private int id;
    private String mail;
    public Postman(int id, String mail) {
        this.id = id;
        this.mail = mail;
    }
    @Override
    public void run() {
        GuardedObject guardedObject = Mailboxes.getGuardedObject(id);
        log.debug("送信 id:{}, 内容:{}", id, mail);
        guardedObject.complete(mail);
    }
}

Copied!

测试

public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 3; i++) {
        new People().start();
    }
    Sleeper.sleep(1);
    for (Integer id : Mailboxes.getIds()) {
        new Postman(id, "内容" + id).start();
    }
}

Copied!

某次运行结果

10:35:05.689 c.People [Thread-1] - 开始收信 id:3
10:35:05.689 c.People [Thread-2] - 开始收信 id:1
10:35:05.689 c.People [Thread-0] - 开始收信 id:2
10:35:06.688 c.Postman [Thread-4] - 送信 id:2, 内容:内容2
10:35:06.688 c.Postman [Thread-5] - 送信 id:1, 内容:内容1
10:35:06.688 c.People [Thread-0] - 收到信 id:2, 内容:内容2
10:35:06.688 c.People [Thread-2] - 收到信 id:1, 内容:内容1
10:35:06.688 c.Postman [Thread-3] - 送信 id:3, 内容:内容3
10:35:06.689 c.People [Thread-1] - 收到信 id:3, 内容:内容3

Copied!

$\textcolor{orange}{* 模式之生产者消费者}$

1.定义

要点

与前面的保护性暂停中的 GuardObject 不同，不需要产生结果和消费结果的线程一一对应
消费队列可以用来平衡生产和消费的线程资源
生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
JDK 中各种阻塞队列，采用的就是这种模式

2.实现

class Message {
    private int id;
    private Object message;
    public Message(int id, Object message) {
        this.id = id;
        this.message = message;
    }
    public int getId() {
        return id;
    }
    public Object getMessage() {
        return message;
    }
}
class MessageQueue {
    private LinkedList<Message> queue;
    private int capacity;
    public MessageQueue(int capacity) {
        this.capacity = capacity;
        queue = new LinkedList<>();
    }
    public Message take() {
        synchronized (queue) {
            while (queue.isEmpty()) {
                log.debug("没货了, wait");
                try {
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Message message = queue.removeFirst();
            queue.notifyAll();
            return message;
        }
    }
    public void put(Message message) {
        synchronized (queue) {
            while (queue.size() == capacity) {
                log.debug("库存已达上限, wait");
                try {
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.addLast(message);
            queue.notifyAll();
        }
    }
}

Copied!

测试

MessageQueue messageQueue = new MessageQueue(2);
// 4 个生产者线程, 下载任务
for (int i = 0; i < 4; i++) {
    int id = i;
    new Thread(() -> {
        try {
            log.debug("download...");
            List<String> response = Downloader.download();
            log.debug("try put message({})", id);
            messageQueue.put(new Message(id, response));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }, "生产者" + i).start();
}
// 1 个消费者线程, 处理结果
new Thread(() -> {
    while (true) {
        Message message = messageQueue.take();
        List<String> response = (List<String>) message.getMessage();
        log.debug("take message({}): [{}] lines", message.getId(), response.size());
    }
}, "消费者").start();

Copied!

某次运行结果

10:48:38.070 [生产者3] c.TestProducerConsumer - download...
10:48:38.070 [生产者0] c.TestProducerConsumer - download...
10:48:38.070 [消费者] c.MessageQueue - 没货了, wait
10:48:38.070 [生产者1] c.TestProducerConsumer - download...
10:48:38.070 [生产者2] c.TestProducerConsumer - download...
10:48:41.236 [生产者1] c.TestProducerConsumer - try put message(1)
10:48:41.237 [生产者2] c.TestProducerConsumer - try put message(2)
10:48:41.236 [生产者0] c.TestProducerConsumer - try put message(0)
10:48:41.237 [生产者3] c.TestProducerConsumer - try put message(3)
10:48:41.239 [生产者2] c.MessageQueue - 库存已达上限, wait
10:48:41.240 [生产者1] c.MessageQueue - 库存已达上限, wait
10:48:41.240 [消费者] c.TestProducerConsumer - take message(0): [3] lines
10:48:41.240 [生产者2] c.MessageQueue - 库存已达上限, wait
10:48:41.240 [消费者] c.TestProducerConsumer - take message(3): [3] lines
10:48:41.240 [消费者] c.TestProducerConsumer - take message(1): [3] lines
10:48:41.240 [消费者] c.TestProducerConsumer - take message(2): [3] lines
10:48:41.240 [消费者] c.MessageQueue - 没货了, wait

Copied!

结果解读

4.9 Park & Unpark

基本使用

它们是 LockSupport 类中的方法

// 暂停当前线程
LockSupport.park(); 
// 恢复某个线程的运行
LockSupport.unpark(暂停线程对象)

Copied!

先 park 再 unpark

Thread t1 = new Thread(() -> {
    log.debug("start...");
    sleep(1);
    log.debug("park...");
    LockSupport.park();
    log.debug("resume...");
},"t1");
t1.start();
sleep(2);
log.debug("unpark...");
LockSupport.unpark(t1);

Copied!

输出

18:42:52.585 c.TestParkUnpark [t1] - start... 
18:42:53.589 c.TestParkUnpark [t1] - park... 
18:42:54.583 c.TestParkUnpark [main] - unpark... 
18:42:54.583 c.TestParkUnpark [t1] - resume...

Copied!

先 unpark 再 park

Thread t1 = new Thread(() -> {
    log.debug("start...");
    sleep(2);
    log.debug("park...");
    LockSupport.park();
    log.debug("resume...");
}, "t1");
t1.start();
sleep(1);
log.debug("unpark...");
LockSupport.unpark(t1);

Copied!

输出

18:43:50.765 c.TestParkUnpark [t1] - start... 
18:43:51.764 c.TestParkUnpark [main] - unpark... 
18:43:52.769 c.TestParkUnpark [t1] - park... 
18:43:52.769 c.TestParkUnpark [t1] - resume...

Copied!

特点

与 Object 的 wait & notify 相比

wait，notify 和 notifyAll 必须配合 Object Monitor 一起使用，而 park，unpark 不必
park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而 notify 只能随机唤醒一个等待线程，notifyAll 是唤醒所有等待线程，就不那么【精确】
park & unpark 可以先 unpark，而 wait & notify 不能先 notify

$\textcolor{blue}{* 原理之park和unpark}$

每个线程都有自己的一个 Parker 对象(由C++编写，java中不可见)，由三部分组成 _counter ， _cond 和 _mutex 打个比喻

线程就像一个旅人，Parker 就像他随身携带的背包，条件变量就好比背包中的帐篷。_counter 就好比背包中的备用干粮（0 为耗尽，1 为充足）
调用 park 就是要看需不需要停下来歇息
- 如果备用干粮耗尽，那么钻进帐篷歇息
- 如果备用干粮充足，那么不需停留，继续前进
调用 unpark，就好比令干粮充足
- 如果这时线程还在帐篷，就唤醒让他继续前进
- 如果这时线程还在运行，那么下次他调用 park 时，仅是消耗掉备用干粮，不需停留继续前进
  - 因为背包空间有限，多次调用 unpark 仅会补充一份备用干粮

当前线程调用 Unsafe.park() 方法
检查 _counter ，本情况为 0，这时，获得 _mutex 互斥锁
线程进入 _cond 条件变量阻塞
设置 _counter = 0

调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1
唤醒 _cond 条件变量中的 Thread_0
Thread_0 恢复运行
设置 _counter 为 0

调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1
当前线程调用 Unsafe.park() 方法
检查 _counter ，本情况为 1，这时线程无需阻塞，继续运行
设置 _counter 为 0

4.10 重新理解线程状态转换

假设有线程 Thread t

情况 1 `NEW --> RUNNABLE`

当调用 t.start() 方法时，由 NEW –> RUNNABLE

情况 2 `RUNNABLE <--> WAITING`

t 线程用 synchronized(obj) 获取了对象锁后

调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING
调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
- 竞争锁成功，t 线程从 WAITING --> RUNNABLE
- 竞争锁失败，t 线程从 WAITING --> BLOCKED

public class TestWaitNotify {
    final static Object obj = new Object();
    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行....");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其它代码...."); // 断点
            }
        },"t1").start();
        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行....");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其它代码...."); // 断点
            }
        },"t2").start();

        sleep(0.5);
        log.debug("唤醒 obj 上其它线程");
        synchronized (obj) {
            obj.notifyAll(); // 唤醒obj上所有等待线程 断点
        }
    }
}

Copied!

情况 3 `RUNNABLE <--> WAITING`

当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING 注意是当前线程在t 线程对象的监视器上等待
t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE

情况 4 `RUNNABLE <--> WAITING`

当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING
调用 LockSupport.unpark(目标线程) 或调用了线程的 interrupt() ，会让目标线程从 WAITING --> RUNNABLE

情况 5 `RUNNABLE <--> TIMED_WAITING`

t 线程用 synchronized(obj) 获取了对象锁后

调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING
t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ，t.interrupt()时
- 竞争锁成功，t 线程从 TIMED_WAITING --> RUNNABLE
- 竞争锁失败，t 线程从 TIMED_WAITING --> BLOCKED

情况 6 `RUNNABLE <--> TIMED_WAITING`

当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING 注意是当前线程在t 线程对象的监视器上等待
当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 TIMED_WAITING --> RUNNABLE

情况 7 `RUNNABLE <--> TIMED_WAITING`

当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED_WAITING
当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE

情况 8 `RUNNABLE <--> TIMED_WAITING`

当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线程从 RUNNABLE --> TIMED_WAITING
调用 LockSupport.unpark(目标线程) 或调用了线程的 interrupt() ，或是等待超时，会让目标线程从 TIMED_WAITING--> RUNNABLE

情况 9 `RUNNABLE <--> BLOCKED`

t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED
持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED

情况 10 `RUNNABLE <--> TERMINATED`

当前线程所有代码运行完毕，进入 TERMINATED

4.11 多把锁

多把不相干的锁

一间大屋子有两个功能：睡觉、学习，互不相干。

现在小南要学习，小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低

解决方法是准备多个房间（多个对象锁）

例如

class BigRoom {
    public void sleep() {
        synchronized (this) {
            log.debug("sleeping 2 小时");
            Sleeper.sleep(2);
        }
    }
    public void study() {
        synchronized (this) {
            log.debug("study 1 小时");
            Sleeper.sleep(1);
        }
    }
}

Copied!

执行

BigRoom bigRoom = new BigRoom();
new Thread(() -> {
    bigRoom.compute();
},"小南").start();
new Thread(() -> {
    bigRoom.sleep();
},"小女").start();

Copied!

结果

1
2

12:13:54.471 [小南] c.BigRoom - study 1 小时
12:13:55.476 [小女] c.BigRoom - sleeping 2 小时

Copied!

改进

class BigRoom {
    private final Object studyRoom = new Object();
    private final Object bedRoom = new Object();
    public void sleep() {
        synchronized (bedRoom) {
            log.debug("sleeping 2 小时");
            Sleeper.sleep(2);
        }
    }
    public void study() {
        synchronized (studyRoom) {
            log.debug("study 1 小时");
            Sleeper.sleep(1);
        }
    }
}

Copied!

某次执行结果

1
2

12:15:35.069 [小南] c.BigRoom - study 1 小时
12:15:35.069 [小女] c.BigRoom - sleeping 2 小时

Copied!

将锁的粒度细分

好处，是可以增强并发度
坏处，如果一个线程需要同时获得多把锁，就容易发生死锁
前提：两把锁锁住的两段代码互不相关

4.12 活跃性

死锁

有这样的情况：一个线程需要同时获取多把锁，这时就容易发生死锁

t1 线程 获得 A对象 锁，接下来想获取 B对象 的锁 t2 线程 获得 B对象 锁，接下来想获取 A对象 的锁例：

Object A = new Object();
Object B = new Object();
Thread t1 = new Thread(() -> {
    synchronized (A) {
        log.debug("lock A");
        sleep(1);
        synchronized (B) {
            log.debug("lock B");
            log.debug("操作...");
        }
    }
}, "t1");
Thread t2 = new Thread(() -> {
    synchronized (B) {
        log.debug("lock B");
        sleep(0.5);
        synchronized (A) {
            log.debug("lock A");
            log.debug("操作...");
        }
    }
}, "t2");
t1.start();
t2.start();

Copied!

结果

1
2

12:22:06.962 [t2] c.TestDeadLock - lock B 
12:22:06.962 [t1] c.TestDeadLock - lock A

Copied!

解决方式：

ReentrantLock

定位死锁

检测死锁可以使用 jconsole工具，或者使用 jps 定位进程 id，再用 jstack 定位死锁：

cmd > jps
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
12320 Jps
22816 KotlinCompileDaemon
33200 TestDeadLock // JVM 进程
11508 Main
28468 Launcher

Copied!

cmd > jstack 33200
Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
2018-12-29 05:51:40
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.91-b14 mixed mode):

"DestroyJavaVM" #13 prio=5 os_prio=0 tid=0x0000000003525000 nid=0x2f60 waiting on condition 
[0x0000000000000000]
	java.lang.Thread.State: RUNNABLE

"Thread-1" #12 prio=5 os_prio=0 tid=0x000000001eb69000 nid=0xd40 waiting for monitor entry 
[0x000000001f54f000]
	java.lang.Thread.State: BLOCKED (on object monitor)
        at thread.TestDeadLock.lambda$main$1(TestDeadLock.java:28)
        - waiting to lock <0x000000076b5bf1c0> (a java.lang.Object)
        - locked <0x000000076b5bf1d0> (a java.lang.Object)
        at thread.TestDeadLock$$Lambda$2/883049899.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)

"Thread-0" #11 prio=5 os_prio=0 tid=0x000000001eb68800 nid=0x1b28 waiting for monitor entry 
[0x000000001f44f000]
	java.lang.Thread.State: BLOCKED (on object monitor)
        at thread.TestDeadLock.lambda$main$0(TestDeadLock.java:15)
        - waiting to lock <0x000000076b5bf1d0> (a java.lang.Object)
         - locked <0x000000076b5bf1c0> (a java.lang.Object)
 		at thread.TestDeadLock$$Lambda$1/495053715.run(Unknown Source)
 		at java.lang.Thread.run(Thread.java:745)
 
// 略去部分输出

Found one Java-level deadlock:
=============================
"Thread-1":
 	waiting to lock monitor 0x000000000361d378 (object 0x000000076b5bf1c0, a java.lang.Object),
 	which is held by "Thread-0"
"Thread-0":
	 waiting to lock monitor 0x000000000361e768 (object 0x000000076b5bf1d0, a java.lang.Object),
 	which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
         at thread.TestDeadLock.lambda$main$1(TestDeadLock.java:28)
         - waiting to lock <0x000000076b5bf1c0> (a java.lang.Object)
         - locked <0x000000076b5bf1d0> (a java.lang.Object)
         at thread.TestDeadLock$$Lambda$2/883049899.run(Unknown Source)
         at java.lang.Thread.run(Thread.java:745)
"Thread-0":
         at thread.TestDeadLock.lambda$main$0(TestDeadLock.java:15)
         - waiting to lock <0x000000076b5bf1d0> (a java.lang.Object)
         - locked <0x000000076b5bf1c0> (a java.lang.Object)
         at thread.TestDeadLock$$Lambda$1/495053715.run(Unknown Source)
         at java.lang.Thread.run(Thread.java:745)
Found 1 deadlock.

Copied!

避免死锁要注意加锁顺序
另外如果由于某个线程进入了死循环，导致其它线程一直等待，对于这种情况 linux 下可以通过 top 先定位到 CPU 占用高的 Java 进程，再利用 top -Hp 进程id 来定位是哪个线程，最后再用 jstack 排查

活锁

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束，例如

public class TestLiveLock {
    static volatile int count = 10;
    static final Object lock = new Object();
    public static void main(String[] args) {
        new Thread(() -> {
            // 期望减到 0 退出循环
            while (count > 0) {
                sleep(0.2);
                count--;
                log.debug("count: {}", count);
            }
        }, "t1").start();
        new Thread(() -> {
            // 期望超过 20 退出循环
            while (count < 20) {
                sleep(0.2);
                count++;
                log.debug("count: {}", count);
            }
        }, "t2").start();
    }
}

Copied!

解决方式：

错开线程的运行时间，使得一方不能改变另一方的结束条件。
将睡眠时间调整为随机数。

饥饿

很多教程中把饥饿定义为，一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束，饥饿的情况不易演示，讲读写锁时会涉及饥饿问题

下面我讲一下我遇到的一个线程饥饿的例子，先来看看使用顺序加锁的方式解决之前的死锁问题

顺序加锁的解决方案

说明：

顺序加锁可以解决死锁问题，但也会导致一些线程一直得不到锁，产生饥饿现象。
解决方式：ReentrantLock

4.13 ReentrantLock

相对于 synchronized 它具备如下特点

可中断
可以设置超时时间
可以设置为公平锁
支持多个条件变量

与 synchronized 一样，都支持可重入

基本语法

// 获取锁
reentrantLock.lock();
try {
 // 临界区
} finally {
 // 释放锁
 reentrantLock.unlock();
}

Copied!

可重入

可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住。

static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
    method1();
}
public static void method1() {
    lock.lock();
    try {
        log.debug("execute method1");
        method2();
    } finally {
        lock.unlock();
    }
}
public static void method2() {
    lock.lock();
    try {
        log.debug("execute method2");
        method3();
    } finally {
        lock.unlock();
    }
}
public static void method3() {
    lock.lock();
    try {
        log.debug("execute method3");
    } finally {
        lock.unlock();
    }
}

Copied!

输出

1
2
3

17:59:11.862 [main] c.TestReentrant - execute method1 
17:59:11.865 [main] c.TestReentrant - execute method2 
17:59:11.865 [main] c.TestReentrant - execute method3

Copied!

可打断

可打断指的是处于阻塞状态等待锁的线程可以被打断等待。注意lock.lockInterruptibly()和lock.trylock()方法是可打断的,lock.lock()不是。可打断的意义在于避免得不到锁的线程无限制地等待下去，防止死锁的一种方式。

示例

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
    log.debug("启动...");
    try {
        lock.lockInterruptibly();
    } catch (InterruptedException e) {
        e.printStackTrace();
        log.debug("等锁的过程中被打断");
        return;
    }
    try {
        log.debug("获得了锁");
    } finally {
        lock.unlock();
    }
}, "t1");
lock.lock();
log.debug("获得了锁");
t1.start();
try {
    sleep(1);
    t1.interrupt();
    log.debug("执行打断");
} finally {
    lock.unlock();
}

Copied!

输出

18:02:40.520 [main] c.TestInterrupt - 获得了锁
18:02:40.524 [t1] c.TestInterrupt - 启动... 
18:02:41.530 [main] c.TestInterrupt - 执行打断
java.lang.InterruptedException 
 		at 
java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchr
onizer.java:898) 
 		at 
java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchron
izer.java:1222) 
 		at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335) 
 		at cn.itcast.n4.reentrant.TestInterrupt.lambda$main$0(TestInterrupt.java:17) 
 		at java.lang.Thread.run(Thread.java:748) 
18:02:41.532 [t1] c.TestInterrupt - 等锁的过程中被打断

Copied!

注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
    log.debug("启动...");
    lock.lock();
    try {
        log.debug("获得了锁");
    } finally {
        lock.unlock();
    }
}, "t1");
lock.lock();
log.debug("获得了锁");
t1.start();
try {
    sleep(1);
    t1.interrupt();
    log.debug("执行打断");
    sleep(1);
} finally {
    log.debug("释放了锁");
    lock.unlock();
}

Copied!

输出

18:06:56.261 [main] c.TestInterrupt - 获得了锁
18:06:56.265 [t1] c.TestInterrupt - 启动... 
18:06:57.266 [main] c.TestInterrupt - 执行打断 // 这时 t1 并没有被真正打断, 而是仍继续等待锁
18:06:58.267 [main] c.TestInterrupt - 释放了锁
18:06:58.267 [t1] c.TestInterrupt - 获得了锁

Copied!

锁超时

立刻失败

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
    log.debug("启动...");
    if (!lock.tryLock()) {
        log.debug("获取立刻失败，返回");
        return;
    }
    try {
        log.debug("获得了锁");
    } finally {
        lock.unlock();
    }
}, "t1");
lock.lock();
log.debug("获得了锁");
t1.start();
try {
    sleep(2);
} finally {
    lock.unlock();
}

Copied!

输出

1
2
3

18:15:02.918 [main] c.TestTimeout - 获得了锁
18:15:02.921 [t1] c.TestTimeout - 启动... 
18:15:02.921 [t1] c.TestTimeout - 获取立刻失败，返回

Copied!

超时失败

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
    log.debug("启动...");
    try {
        if (!lock.tryLock(1, TimeUnit.SECONDS)) {
            log.debug("获取等待 1s 后失败，返回");
            return;
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    try {
        log.debug("获得了锁");
    } finally {
        lock.unlock();
    }
}, "t1");
lock.lock();
log.debug("获得了锁");
t1.start();
try {
    sleep(2);
} finally {
    lock.unlock();
}

Copied!

输出

1
2
3

18:19:40.537 [main] c.TestTimeout - 获得了锁
18:19:40.544 [t1] c.TestTimeout - 启动... 
18:19:41.547 [t1] c.TestTimeout - 获取等待 1s 后失败，返回

Copied!

使用 tryLock 解决哲学家就餐问题

class Chopstick extends ReentrantLock {
    String name;
    public Chopstick(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "筷子{" + name + '}';
    }
}

Copied!

class Philosopher extends Thread {
    Chopstick left;
    Chopstick right;
    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }
    @Override
    public void run() {
        while (true) {
            // 尝试获得左手筷子
            if (left.tryLock()) {
                try {
                    // 尝试获得右手筷子
                    if (right.tryLock()) {
                        try {
                            eat();
                        } finally {
                            right.unlock();
                        }
                    }
                } finally {
                    left.unlock();
                }
            }
        }
    }
    private void eat() {
        log.debug("eating...");
        Sleeper.sleep(1);
    }
}

Copied!

公平锁

ReentrantLock 默认是不公平的

ReentrantLock lock = new ReentrantLock(false);
lock.lock();
for (int i = 0; i < 500; i++) {
    new Thread(() -> {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " running...");
        } finally {
            lock.unlock();
        }
    }, "t" + i).start();
}
// 1s 之后去争抢锁
Thread.sleep(1000);
new Thread(() -> {
    System.out.println(Thread.currentThread().getName() + " start...");
    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + " running...");
    } finally {
        lock.unlock();
    }
}, "强行插入").start();
lock.unlock();

Copied!

强行插入，有机会在中间输出

注意：该实验不一定总能复现

t39 running... 
t40 running... 
t41 running... 
t42 running... 
t43 running... 
强行插入 start... 
强行插入 running... 
t44 running... 
t45 running... 
t46 running... 
t47 running... 
t49 running...

Copied!

改为公平锁后

`1`	`ReentrantLock lock = new ReentrantLock(true);`

Copied!

强行插入，总是在最后输出

t465 running... 
t464 running... 
t477 running... 
t442 running... 
t468 running... 
t493 running... 
t482 running... 
t485 running... 
t481 running... 
强行插入 running...

Copied!

公平锁一般没有必要，会降低并发度，后面分析原理时会讲解

条件变量

synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待

ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比

synchronized 是那些不满足条件的线程都在一间休息室等消息
而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒

使用要点

await 前需要获得锁
await 执行后，会释放锁，进入 conditionObject 等待
await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
竞争 lock 锁成功后，从 await 后继续执行

详细API

public interface Condition {

    void await() throws InterruptedException;

    void awaitUninterruptibly();

	/*
     *  <pre> {@code
     * boolean aMethod(long timeout, TimeUnit unit) {
     *   long nanos = unit.toNanos(timeout);
     *   lock.lock();
     *   try {
     *     while (!conditionBeingWaitedFor()) {
     *       if (nanos <= 0L)
     *         return false;
     *       nanos = theCondition.awaitNanos(nanos);
     *     }
     *     // ...
     *   } finally {
     *     lock.unlock();
     *   }
     * }}</pre>
     *
     * @param nanosTimeout the maximum time to wait, in nanoseconds
     * @return an estimate of the {@code nanosTimeout} value minus
     *         the time spent waiting upon return from this method.
     *         A positive value may be used as the argument to a
     *         subsequent call to this method to finish waiting out
     *         the desired time.  A value less than or equal to zero
     *         indicates that no time remains.
     * @throws InterruptedException if the current thread is interrupted
     *         (and interruption of thread suspension is supported)
     */
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    /**
     * Causes the current thread to wait until it is signalled or interrupted,
     * or the specified waiting time elapses. This method is behaviorally
     * equivalent to:
     *  <pre> {@code awaitNanos(unit.toNanos(time)) > 0}</pre>
     *
     * @param time the maximum time to wait
     * @param unit the time unit of the {@code time} argument
     * @return {@code false} if the waiting time detectably elapsed
     *         before return from the method, else {@code true}
     * @throws InterruptedException if the current thread is interrupted
     *         (and interruption of thread suspension is supported)
     */
    boolean await(long time, TimeUnit unit) throws InterruptedException;

    /**
     * Causes the current thread to wait until it is signalled or interrupted,
     * or the specified deadline elapses.
     *
     *  <pre> {@code
     * boolean aMethod(Date deadline) {
     *   boolean stillWaiting = true;
     *   lock.lock();
     *   try {
     *     while (!conditionBeingWaitedFor()) {
     *       if (!stillWaiting)
     *         return false;
     *       stillWaiting = theCondition.awaitUntil(deadline);
     *     }
     *     // ...
     *   } finally {
     *     lock.unlock();
     *   }
     * }}</pre>
     * @param deadline the absolute time to wait until
     * @return {@code false} if the deadline has elapsed upon return, else
     *         {@code true}
     * @throws InterruptedException if the current thread is interrupted
     *         (and interruption of thread suspension is supported)
     */
    boolean awaitUntil(Date deadline) throws InterruptedException;

    /**
     * Wakes up one waiting thread.
     */
    void signal();

    /**
     * Wakes up all waiting threads.
     */
    void signalAll();
}

Copied!

例子：

static ReentrantLock lock = new ReentrantLock();
static Condition waitCigaretteQueue = lock.newCondition();
static Condition waitbreakfastQueue = lock.newCondition();
static volatile boolean hasCigrette = false;
static volatile boolean hasBreakfast = false;
public static void main(String[] args) {
    new Thread(() -> {
        try {
            lock.lock();
            while (!hasCigrette) {
                try {
                    waitCigaretteQueue.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.debug("等到了它的烟");
        } finally {
            lock.unlock();
        }
    }).start();
    new Thread(() -> {
        try {
            lock.lock();
            while (!hasBreakfast) {
                try {
                    waitbreakfastQueue.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.debug("等到了它的早餐");
        } finally {
            lock.unlock();
        }
    }).start();
    sleep(1);
    sendBreakfast();
    sleep(1);
    sendCigarette();
}
private static void sendCigarette() {
    lock.lock();
    try {
        log.debug("送烟来了");
        hasCigrette = true;
        waitCigaretteQueue.signal();
    } finally {
        lock.unlock();
    }
}
private static void sendBreakfast() {
    lock.lock();
    try {
        log.debug("送早餐来了");
        hasBreakfast = true;
        waitbreakfastQueue.signal();
    } finally {
        lock.unlock();
    }
}

Copied!

输出

18:52:27.680 [main] c.TestCondition - 送早餐来了
18:52:27.682 [Thread-1] c.TestCondition - 等到了它的早餐
18:52:28.683 [main] c.TestCondition - 送烟来了
18:52:28.683 [Thread-0] c.TestCondition - 等到了它的烟

Copied!

* 同步模式之顺序控制

固定运行顺序

比如，必须先 2 后 1 打印

wait notify 版

// 用来同步的对象
static Object obj = new Object();
// t2 运行标记， 代表 t2 是否执行过
static boolean t2runed = false;
public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        synchronized (obj) {
            // 如果 t2 没有执行过
            while (!t2runed) { 
                try {
                    // t1 先等一会
                    obj.wait(); 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(1);
    });
    Thread t2 = new Thread(() -> {
        System.out.println(2);
        synchronized (obj) {
            // 修改运行标记
            t2runed = true;
            // 通知 obj 上等待的线程（可能有多个，因此需要用 notifyAll）
            obj.notifyAll();
        }
    });
    t1.start();
    t2.start();
}

Copied!

Park Unpark 版

可以看到，实现上很麻烦：

首先，需要保证先 wait 再 notify，否则 wait 线程永远得不到唤醒。因此使用了『运行标记』来判断该不该 wait
第二，如果有些干扰线程错误地 notify 了 wait 线程，条件不满足时还要重新等待，使用了 while 循环来解决此问题
最后，唤醒对象上的 wait 线程需要使用 notifyAll，因为『同步对象』上的等待线程可能不止一个

可以使用 LockSupport 类的 park 和 unpark 来简化上面的题目：

Thread t1 = new Thread(() -> {
    try { Thread.sleep(1000); } catch (InterruptedException e) { }
    // 当没有『许可』时，当前线程暂停运行；有『许可』时，用掉这个『许可』，当前线程恢复运行
    LockSupport.park();
    System.out.println("1");
});
Thread t2 = new Thread(() -> {
    System.out.println("2");
    // 给线程 t1 发放『许可』（多次连续调用 unpark 只会发放一个『许可』）
    LockSupport.unpark(t1);
});
t1.start();
t2.start();

Copied!

park 和 unpark 方法比较灵活，他俩谁先调用，谁后调用无所谓。并且是以线程为单位进行『暂停』和『恢复』，不需要『同步对象』和『运行标记』

交替输出

线程 1 输出 a 5 次，线程 2 输出 b 5 次，线程 3 输出 c 5 次。现在要求输出 abcabcabcabcabc 怎么实现

wait notify 版

class SyncWaitNotify {
    private int flag;
    private int loopNumber;
    public SyncWaitNotify(int flag, int loopNumber) {
        this.flag = flag;
        this.loopNumber = loopNumber;
    }
    public void print(int waitFlag, int nextFlag, String str) {
        for (int i = 0; i < loopNumber; i++) {
            synchronized (this) {
                while (this.flag != waitFlag) {
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.print(str);
                flag = nextFlag;
                this.notifyAll();
            }
        }
    }
}

Copied!

SyncWaitNotify syncWaitNotify = new SyncWaitNotify(1, 5);
new Thread(() -> {
    syncWaitNotify.print(1, 2, "a");
}).start();
new Thread(() -> {
    syncWaitNotify.print(2, 3, "b");
}).start();
new Thread(() -> {
    syncWaitNotify.print(3, 1, "c");
}).start();

Copied!

Lock 条件变量版

class AwaitSignal extends ReentrantLock {
    public void start(Condition first) {
        this.lock();
        try {
            log.debug("start");
            first.signal();
        } finally {
            this.unlock();
        }
    }
    public void print(String str, Condition current, Condition next) {
        for (int i = 0; i < loopNumber; i++) {
            this.lock();
            try {
                current.await();
                log.debug(str);
                next.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                this.unlock();
            }
        }
    }
    // 循环次数
    private int loopNumber;
    public AwaitSignal(int loopNumber) {
        this.loopNumber = loopNumber;
    }
}

Copied!

AwaitSignal as = new AwaitSignal(5);
Condition aWaitSet = as.newCondition();
Condition bWaitSet = as.newCondition();
Condition cWaitSet = as.newCondition();
new Thread(() -> {
    as.print("a", aWaitSet, bWaitSet);
}).start();
new Thread(() -> {
    as.print("b", bWaitSet, cWaitSet);
}).start();
new Thread(() -> {
    as.print("c", cWaitSet, aWaitSet);
}).start();
as.start(aWaitSet);

Copied!

注意

该实现没有考虑 a，b，c 线程都就绪再开始

Park Unpark 版

class SyncPark {
    private int loopNumber;
    private Thread[] threads;
    public SyncPark(int loopNumber) {
        this.loopNumber = loopNumber;
    }
    public void setThreads(Thread... threads) {
        this.threads = threads;
    }
    public void print(String str) {
        for (int i = 0; i < loopNumber; i++) {
            LockSupport.park();
            System.out.print(str);
            LockSupport.unpark(nextThread());
        }
    }
    private Thread nextThread() {
        Thread current = Thread.currentThread();
        int index = 0;
        for (int i = 0; i < threads.length; i++) {
            if(threads[i] == current) {
                index = i;
                break;
            }
        }
        if(index < threads.length - 1) {
            return threads[index+1];
        } else {
            return threads[0];
        }
    }
    public void start() {
        for (Thread thread : threads) {
            thread.start();
        }
        LockSupport.unpark(threads[0]);
    }
}
SyncPark syncPark = new SyncPark(5);
Thread t1 = new Thread(() -> {
    syncPark.print("a");
});
Thread t2 = new Thread(() -> {
    syncPark.print("b");
});
Thread t3 = new Thread(() -> {
    syncPark.print("c\n");
});
syncPark.setThreads(t1, t2, t3);
syncPark.start();

Copied!

本章小结

本章我们需要重点掌握的是

分析多线程访问共享资源时，哪些代码片段属于临界区
使用 synchronized 互斥解决临界区的线程安全问题
- 掌握 synchronized 锁对象语法
- 掌握 synchronzied 加载成员方法和静态方法语法
- 掌握 wait/notify 同步方法
使用 lock 互斥解决临界区的线程安全问题
- 掌握 lock 的使用细节：可打断、锁超时、公平锁、条件变量
学会分析变量的线程安全性、掌握常见线程安全类的使用
- 线程安全类的方法是原子性的，但方法之间的组合要具体分析。
了解线程活跃性问题：死锁、活锁、饥饿。
- 解决死锁、饥饿的方式：ReentranLock
应用方面
- 互斥：使用 synchronized 或 Lock 达到共享资源互斥效果
- 同步：使用 wait/notify 或 Lock 的条件变量来达到线程间通信效果
原理方面
- monitor、synchronized 、wait/notify 原理
- synchronized 进阶原理
- park & unpark 原理
模式方面
- 同步模式之保护性暂停
- 异步模式之生产者消费者
- 同步模式之顺序控制

5.共享模型之内存

5.1 Java 内存模型

JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、 CPU 指令优化等。

JMM的意义

计算机硬件底层的内存结构过于复杂，JMM的意义在于避免程序员直接管理计算机底层内存，用一些关键字synchronized、volatile等可以方便的管理内存。

JMM 体现在以下几个方面

原子性 - 保证指令不会受到线程上下文切换的影响
可见性 - 保证指令不会受 cpu 缓存的影响
有序性 - 保证指令不会受 cpu 指令并行优化的影响

5.2 可见性

退不出的循环

先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：

static boolean run = true;
public static void main(String[] args) throws InterruptedException {
    Thread t = new Thread(()->{
        while(run){
            // ....
        }
    });
    t.start();
    sleep(1);
    run = false; // 线程t不会如预想的停下来
}

Copied!

为什么呢？分析一下：

初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。

因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率

1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值

解决方法

volatile（易变关键字）

它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存

可见性 vs 原子性

前面例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见，不能保证原子性，仅用在一个写线程，多个读线程的情况：上例从字节码理解是这样的：

getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
putstatic run // 线程 main 修改 run 为 false， 仅此一次
getstatic run // 线程 t 获取 run false

Copied!

比较一下之前我们将线程安全时举的例子：两个线程一个 i++ 一个 i– ，只能保证看到最新值，不能解决指令交错

// 假设i的初始值为0 
getstatic i // 线程2-获取静态变量i的值 线程内i=0 
getstatic i // 线程1-获取静态变量i的值 线程内i=0 
iconst_1 // 线程1-准备常量1 
iadd // 线程1-自增 线程内i=1 
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1 
iconst_1 // 线程2-准备常量1 
isub // 线程2-自减 线程内i=-1 
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

Copied!

注意

synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是 synchronized 是属于重量级操作，性能相对更低。

JMM关于synchronized的两条规定：

　　1）线程解锁前，必须把共享变量的最新值刷新到主内存中

　　2）线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新获取最新的值

　　　（注意：加锁与解锁需要是同一把锁）

通过以上两点，可以看到synchronized能够实现可见性。同时，由于synchronized具有同步锁，所以它也具有原子性

如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到对 run 变量的修改了，想一想为什么？(println方法中有synchronized代码块保证了可见性)

synchronized关键字不能阻止指令重排，但在一定程度上能保证有序性（如果共享变量没有逃逸出同步代码块的话）。因为在单线程的情况下指令重排不影响结果，相当于保障了有序性。

* 模式之两阶段终止

Two Phase Termination

在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。

1.错误思路

使用线程对象的 stop() 方法停止线程
- stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
使用 System.exit(int) 方法停止线程
- 目的仅是停止一个线程，但这种做法会让整个程序都停止

2.两阶段终止模式

利用 isInterrupted

interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

class TPTInterrupt {
    private Thread thread;
    public void start(){
        thread = new Thread(() -> {
            while(true) {
                Thread current = Thread.currentThread();
                if(current.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                    //打断sleep线程会清除打断标记，所以要添加标记
                    current.interrupt();
                }
                // 执行监控操作 
            }
        },"监控线程");
        thread.start();
    }
    public void stop() {
        thread.interrupt();
    }
}

Copied!

调用

TPTInterrupt t = new TPTInterrupt();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

Copied!

结果

11:49:42.915 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:43.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:44.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:45.413 c.TestTwoPhaseTermination [main] - stop 
11:49:45.413 c.TwoPhaseTermination [监控线程] - 料理后事

Copied!

利用volatile修饰的停止标记

// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
// 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
class TPTVolatile {
    private Thread thread;
    private volatile boolean stop = false;
    public void start(){
        thread = new Thread(() -> {
            while(true) {
                Thread current = Thread.currentThread();
                if(stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                     }
                // 执行监控操作
            }
        },"监控线程");
        thread.start();
    }
    public void stop() {
        stop = true;
        //让线程立即停止而不是等待sleep结束
        thread.interrupt();
    }
}

Copied!

调用

TPTVolatile t = new TPTVolatile();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

Copied!

结果

11:54:52.003 c.TPTVolatile [监控线程] - 将结果保存
11:54:53.006 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.007 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.502 c.TestTwoPhaseTermination [main] - stop 
11:54:54.502 c.TPTVolatile [监控线程] - 料理后事

Copied!

* 模式之 Balking

1.定义

Balking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回

2.实现

例如：

public class MonitorService {
    // 用来表示是否已经有线程已经在执行启动了
    private volatile boolean starting;
    public void start() {
        log.info("尝试启动监控线程...");
        synchronized (this) {
            if (starting) {
                return;
            }
            starting = true;
        }
		//其实synchronized外面还可以再套一层if，或者改为if(!starting)，if框后直接return
        // 真正启动监控线程...
    }
}

Copied!

当前端页面多次点击按钮调用 start 时

输出

[http-nio-8080-exec-1] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(false)
[http-nio-8080-exec-1] cn.itcast.monitor.service.MonitorService - 监控线程已启动...
[http-nio-8080-exec-2] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)
[http-nio-8080-exec-3] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)
[http-nio-8080-exec-4] cn.itcast.monitor.service.MonitorService - 该监控线程已启动?(true)

Copied!

它还经常用来实现线程安全的单例

public final class Singleton {
    
    private Singleton() {
    }
    
    private static Singleton INSTANCE = null;
    
    public static synchronized Singleton getInstance() {
        if (INSTANCE != null) {
            return INSTANCE;
        }
        INSTANCE = new Singleton();
        return INSTANCE;
    }
}

Copied!

对比一下保护性暂停模式：保护性暂停模式用在一个线程等待另一个线程的执行结果，当条件不满足时线程等待。

5.3 有序性

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码

static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...; 
j = ...;

Copied!

可以看到，至于是先执行 i 还是先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是

1
2

i = ...; 
j = ...;

Copied!

也可以是

1
2

j = ...;
i = ...;

Copied!

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。为什么要有重排指令这项优化呢？从 CPU 执行指令的原理来理解一下吧

* 原理之指令级并行

名词

Clock Cycle Time

主频的概念大家接触的比较多，而 CPU 的 Clock Cycle Time（时钟周期时间），等于主频的倒数，意思是 CPU 能够识别的最小时间单位，比如说 4G 主频的 CPU 的 Clock Cycle Time 就是 0.25 ns，作为对比，我们墙上挂钟的 Cycle Time 是 1s

例如，运行一条加法指令一般需要一个时钟周期时间

CPI

有的指令需要更多的时钟周期时间，所以引出了 CPI （Cycles Per Instruction）指令平均时钟周期数

IPC

IPC（Instruction Per Clock Cycle）即 CPI 的倒数，表示每个时钟周期能够运行的指令数

CPU 执行时间

程序的 CPU 执行时间，即我们前面提到的 user + system 时间，可以用下面的公式来表示

`1`	`程序 CPU 执行时间 = 指令数 * CPI * Clock Cycle Time`

Copied!

指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令还可以再划分成一个个更小的阶段，例如，每条指令都可以分为： 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 这 5 个阶段

术语参考：

instruction fetch (IF)

instruction decode (ID)

execute (EX)

memory access (MEM)

register write back (WB)

在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行，这一技术在 80’s 中叶到 90’s 中叶占据了计算架构的重要地位。

提示：

分阶段，分工是提升效率的关键！

指令重排的前提是，重排指令不能影响结果，例如

// 可以重排的例子
int a = 10; // 指令1
int b = 20; // 指令2
System.out.println( a + b );
// 不能重排的例子
int a = 10; // 指令1
int b = a - 5; // 指令2

Copied!

参考：

Scoreboarding and the Tomasulo algorithm (which is similar to scoreboarding but makes use of register renaming )are two of the most common techniques for implementing out-of-order execution and instruction-level parallelism.

支持流水线的处理器

现代 CPU 支持多级指令流水线，例如支持同时执行 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 的处理器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了指令地吞吐率。

提示：

奔腾四（Pentium 4）支持高达 35 级流水线，但由于功耗太高被废弃

SuperScalar 处理器

大多数处理器包含多个执行单元，并不是所有计算功能都集中在一起，可以再细分为整数运算单元、浮点数运算单元等，这样可以把多条指令也可以做到并行获取、译码等，CPU 可以在一个时钟周期内，执行多于一条指令，IPC > 1

诡异的结果

int num = 0;
boolean ready = false;
// 线程1 执行此方法
public void actor1(I_Result r) {
    if(ready) {
        r.r1 = num + num;
    } else {
        r.r1 = 1;
    }
}
// 线程2 执行此方法
public void actor2(I_Result r) { 
    num = 2;
    ready = true; 
}

Copied!

I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？

有同学这么分析

情况1：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1

情况2：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为1

情况3：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了）

但我告诉你，结果还有可能是 0 😁😁😁，信不信吧！

这种情况下是：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2

相信很多人已经晕了 😵😵😵

这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现：

借助 java 并发压测工具 jcstress https://wiki.openjdk.java.net/display/CodeTools/jcstress

1
2
3

mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -
DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.5 -DgroupId=cn.itcast -
DartifactId=ordering -Dversion=1.0

Copied!

创建 maven 项目，提供如下测试类

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {
    int num = 0;
    boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

Copied!

执行

1
2

mvn clean install 
java -jar target/jcstress.jar

Copied!

会输出我们感兴趣的结果，摘录其中一次结果：

*** INTERESTING tests 
 Some interesting behaviors observed. This is for the plain curiosity. 
 
 2 matching test results. 
 	[OK] test.ConcurrencyTest 
 	(JVM args: [-XX:-TieredCompilation]) 
    Observed state 	Occurrences 	Expectation Interpretation 
    0 				1,729 			ACCEPTABLE_INTERESTING !!!! 
 	1 				42,617,915 		ACCEPTABLE ok 
 	4 				5,146,627 		ACCEPTABLE ok 
 
 	[OK] test.ConcurrencyTest 
 	(JVM args: []) 
 	Observed state 	Occurrences 	Expectation Interpretation 
 	0 				1,652 			ACCEPTABLE_INTERESTING !!!! 
 	1 				46,460,657 		ACCEPTABLE ok 
 	4 				4,571,072 		ACCEPTABLE ok

Copied!

可以看到，出现结果为 0 的情况有 638 次，虽然次数相对很少，但毕竟是出现了。

解决方法

volatile 修饰的变量，可以禁用指令重排

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {
    int num = 0;
    volatile boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

Copied!

结果为：

1
2
3

*** INTERESTING tests 
 Some interesting behaviors observed. This is for the plain curiosity. 
 0 matching test results.

Copied!

* 原理之 volatile

volatile 的底层实现原理是内存屏障，Memory Barrier（Memory Fence）

对 volatile 变量的写指令后会加入写屏障
对 volatile 变量的读指令前会加入读屏障

如何保证可见性

写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中

public void actor2(I_Result r) {
    num = 2;
    ready = true; // ready 是 volatile 赋值带写屏障
    // 写屏障
}

Copied!

而读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据

public void actor1(I_Result r) {
    // 读屏障
    // ready 是 volatile 读取值带读屏障
    if(ready) {
        r.r1 = num + num;
    } else {
        r.r1 = 1;
    }
}

Copied!

如何保证有序性

写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后

public void actor2(I_Result r) {
    num = 2;
    ready = true; // ready 是 volatile 赋值带写屏障
    // 写屏障
}

Copied!

读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

public void actor1(I_Result r) {
    // 读屏障
    // ready 是 volatile 读取值带读屏障
    if(ready) {
        r.r1 = num + num;
    } else {
        r.r1 = 1;
    }
}

Copied!

还是那句话，不能解决指令交错：

写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证读跑到它前面去
而有序性的保证也只是保证了本线程内相关代码不被重排序

double-checked locking 问题

以著名的 double-checked locking 单例模式为例

public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() { 
        if(INSTANCE == null) { // t2
            // 首次访问会同步，而之后的使用没有 synchronized
            synchronized(Singleton.class) {
                if (INSTANCE == null) { // t1
                    INSTANCE = new Singleton();
                } 
            }
        }
        return INSTANCE;
    }
}

Copied!

以上的实现特点是：

懒惰实例化
首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁
有隐含的，但很关键的一点：第一个 if 使用了 INSTANCE 变量，是在同步块之外

但在多线程环境下，上面的代码是有问题的，getInstance 方法对应的字节码为：

0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
27: aload_0
28: monitorexit
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn

Copied!

其中

17 表示创建对象，将对象引用入栈 // new Singleton
20 表示复制一份对象引用 // 引用地址
21 表示利用一个对象引用，调用构造方法
24 表示利用一个对象引用，赋值给 static INSTANCE

也许 jvm 会优化为：先执行 24，再执行 21。如果两个线程 t1，t2 按如下时间序列执行：

关键在于 0: getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人，可以越过 monitor 读取 INSTANCE 变量的值

这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将是一个未初始化完毕的单例

对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才会真正有效

double-checked locking 解决

public final class Singleton {
    private Singleton() { }
    private static volatile Singleton INSTANCE = null;
    public static Singleton getInstance() {
        // 实例没创建，才会进入内部的 synchronized代码块
        if (INSTANCE == null) { 
            synchronized (Singleton.class) { // t2
                // 也许有其它线程已经创建实例，所以再判断一次
                if (INSTANCE == null) { // t1
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

Copied!

字节码上看不出来 volatile 指令的效果

// -------------------------------------> 加入对 INSTANCE 变量的读屏障
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter -----------------------> 保证原子性、可见性
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
// -------------------------------------> 加入对 INSTANCE 变量的写屏障
27: aload_0
28: monitorexit ------------------------> 保证原子性、可见性
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn

Copied!

如上面的注释内容所示，读写 volatile 变量时会加入内存屏障（Memory Barrier（Memory Fence）），保证下面两点：

可见性
- 写屏障（sfence）保证在该屏障之前的 t1 对共享变量的改动，都同步到主存当中
- 而读屏障（lfence）保证在该屏障之后 t2 对共享变量的读取，加载的是主存中最新数据
有序性
- 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
- 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前
更底层是读写变量时使用 lock 指令来多核 CPU 之间的可见性与有序性

happens-before

happens-before 规定了对共享变量的写操作对其它线程的读操作可见，它是可见性与有序性的一套规则总结，抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变量的读可见

线程解锁 m 之前对变量的写，对于接下来对 m 加锁的其它线程对该变量的读可见(synchronized关键字的可见性、监视器规则)

static int x;
static Object m = new Object();
new Thread(()->{
    synchronized(m) {
        x = 10;
    }
},"t1").start();
new Thread(()->{
    synchronized(m) {
        System.out.println(x);
    }
},"t2").start();

Copied!

线程对 volatile 变量的写，对接下来其它线程对该变量的读可见(volatile关键字的可见性、volatile规则)

volatile static int x;
new Thread(()->{
    x = 10;
},"t1").start();
new Thread(()->{
    System.out.println(x);
},"t2").start();

Copied!

线程 start 前对变量的写，对该线程开始后对该变量的读可见(程序顺序规则+线程启动规则)
1 2 3 4 5

static int x; x = 10; new Thread(()->{ System.out.println(x); },"t2").start();
Copied!
线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或 t1.join()等待它结束）(线程终止规则)
1 2 3 4 5 6 7

static int x; Thread t1 = new Thread(()->{ x = 10; },"t1"); t1.start(); t1.join(); System.out.println(x);
Copied!

线程 t1 打断 t2（interrupt）前对变量的写，对于其他线程得知 t2 被打断后对变量的读可见（通过 t2.interrupted 或 t2.isInterrupted）（线程中断机制）

static int x;
public static void main(String[] args) {
    Thread t2 = new Thread(()->{
        while(true) {
            if(Thread.currentThread().isInterrupted()) {
                System.out.println(x);
                break;
            }
        }
    },"t2");
    t2.start();
    new Thread(()->{
        sleep(1);
        x = 10;
        t2.interrupt();
    },"t1").start();
    while(!t2.isInterrupted()) {
        Thread.yield();
    }
    System.out.println(x);
}

Copied!

对变量默认值（0，false，null）的写，对其它线程对该变量的读可见

具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z ，配合 volatile 的防指令重排，有下面的例子

volatile static int x;
static int y;
new Thread(()->{ 
    y = 10;
    x = 20;
},"t1").start();
new Thread(()->{
    // x=20 对 t2 可见, 同时 y=10 也对 t2 可见
    System.out.println(x); 
},"t2").start();

Copied!

变量都是指成员变量或静态成员变量

参考：第17页

在JMM中有一个很重要的概念对于我们了解JMM有很大的帮助，那就是happens-before规则。happens-before规则非常重要，它是判断数据是否存在竞争、线程是否安全的主要依据。JSR-133S使用happens-before概念阐述了两个操作之间的内存可见性。在JMM中，如果一个操作的结果需要对另一个操作可见，那么这两个操作则存在happens-before关系。

那什么是happens-before呢？在JSR-133中，happens-before关系定义如下：

如果一个操作happens-before另一个操作，那么意味着第一个操作的结果对第二个操作可见，而且第一个操作的执行顺序将排在第二个操作的前面。

两个操作之间存在happens-before关系，并不意味着Java平台的具体实现必须按照happens-before关系指定的顺序来执行。如果重排序之后的结果，与按照happens-before关系来执行的结果一致，那么这种重排序并不非法（也就是说，JMM允许这种重排序）

happens-before规则如下：

程序顺序规则：一个线程中的每一个操作，happens-before于该线程中的任意后续操作。

监视器规则：对一个锁的解锁，happens-before于随后对这个锁的加锁。

volatile规则：对一个volatile变量的写，happens-before于任意后续对一个volatile变量的读。

传递性：若果A happens-before B，B happens-before C，那么A happens-before C。

线程启动规则：Thread对象的start()方法，happens-before于这个线程的任意后续操作。

线程终止规则：线程中的任意操作，happens-before于该线程的终止监测。我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测到线程已经终止执行。

线程中断操作：对线程interrupt()方法的调用，happens-before于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测到线程是否有中断发生。

对象终结规则：一个对象的初始化完成，happens-before于这个对象的finalize()方法的开始。

参考链接：happens-before规则解析 - 知乎 (zhihu.com)

习题

balking 模式习题

希望 doInit() 方法仅被调用一次，下面的实现是否有问题，为什么？

public class TestVolatile {
    volatile boolean initialized = false;
    void init() {
        if (initialized) { 
            return;
        } 
        doInit();
        initialized = true;
    }
    private void doInit() {
    }
}

Copied!

线程安全单例习题

单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类，试分析每种实现下获取单例对象（即调用 getInstance）时的线程安全，并思考注释中的问题

饿汉式：类加载就会导致该单实例对象被创建

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

实现1(饿汉式)：

// 问题1：为什么加 final(防止被子类继承从而重写方法改写单例)
// 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例(重写readResolve方法)
public final class Singleton implements Serializable {
    // 问题3：为什么设置为私有? 是否能防止反射创建新的实例?(防止外部调用构造方法创建多个实例；不能)
    private Singleton() {}
    // 问题4：这样初始化是否能保证单例对象创建时的线程安全?(能，线程安全性由类加载器保障)
    private static final Singleton INSTANCE = new Singleton();
    // 问题5：为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由(可以保证instance的安全性，也能方便实现一些附加逻辑)
    public static Singleton getInstance() {
        return INSTANCE;
    }
    public Object readResolve() {
        return INSTANCE;
    }
}

Copied!

实现2(枚举类)：

// 问题1：枚举单例是如何限制实例个数的 (枚举类会按照声明的个数在类加载时实例化对象)
// 问题2：枚举单例在创建时是否有并发问题(没有，由类加载器保障安全性)
// 问题3：枚举单例能否被反射破坏单例(不能)
// 问题4：枚举单例能否被反序列化破坏单例(不能)
// 问题5：枚举单例属于懒汉式还是饿汉式(饿汉)
// 问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做(写构造方法)
enum Singleton { 
    INSTANCE; 
}

Copied!

实现3(synchronized方法)：

public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    // 分析这里的线程安全, 并说明有什么缺点(没有线程安全问题，同步代码块粒度太大，性能差)
    public static synchronized Singleton getInstance() {
        if( INSTANCE != null ){
            return INSTANCE;
        } 
        INSTANCE = new Singleton();
        return INSTANCE;
    }
}

Copied!

实现4：DCL+volatile

public final class Singleton {
    private Singleton() { }
    // 问题1：解释为什么要加 volatile ?(防止putstatic和invokespecial重排导致的异常)
    private static volatile Singleton INSTANCE = null;

    // 问题2：对比实现3, 说出这样做的意义 (缩小了锁的粒度，提高了性能)
    public static Singleton getInstance() {
        if (INSTANCE != null) { 
            return INSTANCE;
        }
        synchronized (Singleton.class) { 
            // 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗
            if (INSTANCE != null) { // t2 
                return INSTANCE;
            }
            INSTANCE = new Singleton(); 
            return INSTANCE;
        } 
    }
}

Copied!

实现5(内部类初始化)：

public final class Singleton {
    private Singleton() { }
    // 问题1：属于懒汉式还是饿汉式
    private static class LazyHolder {
        static final Singleton INSTANCE = new Singleton();
    }
    // 问题2：在创建时是否有并发问题
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

Copied!

本章小结

本章重点讲解了 JMM 中的

可见性 - 由 JVM 缓存优化引起
有序性 - 由 JVM 指令重排序优化引起
happens-before 规则
原理方面
- CPU 指令并行
- volatile
模式方面
- 两阶段终止模式的 volatile 改进
- 同步模式之 balking

6.共享模型之无锁

6.1 问题提出 (应用之互斥)

有如下需求，保证 account.withdraw 取款方法的线程安全

package cn.itcast;
import java.util.ArrayList;
import java.util.List;
interface Account {
    // 获取余额
    Integer getBalance();
    // 取款
    void withdraw(Integer amount);
    /**
 * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
 * 如果初始余额为 10000 那么正确的结果应当是 0
 */
    static void demo(Account account) {
        List<Thread> ts = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(account.getBalance() 
                           + " cost: " + (end-start)/1000_000 + " ms");
    }
}

Copied!

原有实现并不是线程安全的

class AccountUnsafe implements Account {
    private Integer balance;
    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }
    @Override
    public Integer getBalance() {
        return balance;
    }
    @Override
    public void withdraw(Integer amount) {
        balance -= amount;
    }
}

Copied!

执行测试代码

1
2
3

public static void main(String[] args) {
    Account.demo(new AccountUnsafe(10000));
}

Copied!

某次的执行结果

`1`	`330 cost: 306 ms`

Copied!

为什么不安全

withdraw 方法

1
2
3

public void withdraw(Integer amount) {
    balance -= amount;
}

Copied!

对应的字节码

ALOAD 0 // <- this
ALOAD 0
GETFIELD cn/itcast/AccountUnsafe.balance : Ljava/lang/Integer; // <- this.balance
INVOKEVIRTUAL java/lang/Integer.intValue ()I // 拆箱
ALOAD 1 // <- amount
INVOKEVIRTUAL java/lang/Integer.intValue ()I // 拆箱
ISUB // 减法
INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer; // 结果装箱
PUTFIELD cn/itcast/AccountUnsafe.balance : Ljava/lang/Integer; // -> this.balance

Copied!

多线程执行

ALOAD 0 // thread-0 <- this 
ALOAD 0 
GETFIELD cn/itcast/AccountUnsafe.balance // thread-0 <- this.balance 
INVOKEVIRTUAL java/lang/Integer.intValue // thread-0 拆箱
ALOAD 1 // thread-0 <- amount 
INVOKEVIRTUAL java/lang/Integer.intValue // thread-0 拆箱
    ISUB // thread-0 减法
INVOKESTATIC java/lang/Integer.valueOf // thread-0 结果装箱
PUTFIELD cn/itcast/AccountUnsafe.balance // thread-0 -> this.balance 
 
 
ALOAD 0 // thread-1 <- this 
ALOAD 0 
GETFIELD cn/itcast/AccountUnsafe.balance // thread-1 <- this.balance 
INVOKEVIRTUAL java/lang/Integer.intValue // thread-1 拆箱
ALOAD 1 // thread-1 <- amount 
INVOKEVIRTUAL java/lang/Integer.intValue // thread-1 拆箱
ISUB // thread-1 减法
INVOKESTATIC java/lang/Integer.valueOf // thread-1 结果装箱
PUTFIELD cn/itcast/AccountUnsafe.balance // thread-1 -> this.balance

Copied!

原因：Integer虽然是不可变类，其方法是线程安全的，但是以上操作涉及到了多个方法的组合，等价于以下代码：

balance = new Integer(Integer.valueOf(balance) - amount);

前一个方法(valueOf)的结果决定后一个方法(构造方法)，这种组合在多线程环境下线程不安全。

解决思路-锁（悲观互斥）

首先想到的是给 Account 对象加锁

class AccountUnsafe implements Account {
    private Integer balance;
    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }
    @Override
    public synchronized Integer getBalance() {
        return balance;
    }
    @Override
    public synchronized void withdraw(Integer amount) {
        balance -= amount;
    }
}

Copied!

结果为

`1`	`0 cost: 399 ms`

Copied!

解决思路-无锁（乐观重试）

class AccountSafe implements Account {
    private AtomicInteger balance;
    public AccountSafe(Integer balance) {
        this.balance = new AtomicInteger(balance);
    }
    @Override
    public Integer getBalance() {
        return balance.get();
    }
    @Override
    public void withdraw(Integer amount) {
        while (true) {
            int prev = balance.get();
            int next = prev - amount;
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
        // 可以简化为下面的方法
        // balance.addAndGet(-1 * amount);
    }
}

Copied!

执行测试代码

1
2
3

public static void main(String[] args) {
    Account.demo(new AccountSafe(10000));
}

Copied!

某次的执行结果

`1`	`0 cost: 302 ms`

Copied!

6.2 CAS 与 volatile

前面看到的 AtomicInteger 的解决方法，内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢？

public void withdraw(Integer amount) {
    while(true) {
        // 需要不断尝试，直到成功为止
        while (true) {
            // 比如拿到了旧值 1000
            int prev = balance.get();
            // 在这个基础上 1000-10 = 990
            int next = prev - amount;
            /*
             compareAndSet 正是做这个检查，在 set 前，先比较 prev 与当前值
             - 不一致了，next 作废，返回 false 表示失败
             比如，别的线程已经做了减法，当前值已经被减成了 990
             那么本线程的这次 990 就作废了，进入 while 下次循环重试
             - 一致，以 next 设置为新值，返回 true 表示成功
             */
            if (balance.compareAndSet(prev, next)) {
                break;
            }
            //或者简洁一点：
            //balance.getAndAdd(-1 * amount);
        }
    }
}

Copied!

其中的关键是 compareAndSet，它的简称就是 CAS （也有 Compare And Swap 的说法），它必须是原子操作。

注意

其实 CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的原子性。

在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再开启总线。这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子的。

慢动作分析

@Slf4j
public class SlowMotion {
    public static void main(String[] args) {
        AtomicInteger balance = new AtomicInteger(10000);
        int mainPrev = balance.get();
        log.debug("try get {}", mainPrev);
        new Thread(() -> {
            sleep(1000);
            int prev = balance.get();
            balance.compareAndSet(prev, 9000);
            log.debug(balance.toString());
        }, "t1").start();
        sleep(2000);
        log.debug("try set 8000...");
        boolean isSuccess = balance.compareAndSet(mainPrev, 8000);
        log.debug("is success ? {}", isSuccess);
        if(!isSuccess){
            mainPrev = balance.get();
            log.debug("try set 8000...");
            isSuccess = balance.compareAndSet(mainPrev, 8000);
            log.debug("is success ? {}", isSuccess);
        }
    }
    private static void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Copied!

输出结果

2019-10-13 11:28:37.134 [main] try get 10000 
2019-10-13 11:28:38.154 [t1] 9000 
2019-10-13 11:28:39.154 [main] try set 8000... 
2019-10-13 11:28:39.154 [main] is success ? false 
2019-10-13 11:28:39.154 [main] try set 8000... 
2019-10-13 11:28:39.154 [main] is success ? true

Copied!

volatile

获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰。

它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改，对另一个线程可见。

注意

volatile 仅仅保证了共享变量的可见性，让其它线程能够看到最新值，但不能解决指令交错问题（不能保证原子性）

CAS 必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果。

为什么无锁效率高

无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，类似于自旋。而 synchronized 会让线程在没有获得锁的时候，发生上下文切换，进入阻塞。线程的上下文切换是费时的，在重试次数不是太多时，无锁的效率高于有锁。
线程就好像高速跑道上的赛车，高速运行时，速度超快，一旦发生上下文切换，就好比赛车要减速、熄火，等被唤醒又得重新打火、启动、加速… 恢复到高速运行，代价比较大
但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。所以总的来说，当线程数小于等于cpu核心数时，使用无锁方案是很合适的，因为有足够多的cpu让线程运行。当线程数远多于cpu核心数时，无锁效率相比于有锁就没有太大优势，因为依旧会发生上下文切换。

CAS 的特点

结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下。

CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。
synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。
CAS 体现的是无锁并发、无阻塞并发，请仔细体会这两句话的意思
- 因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
- 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响

6.3 原子整数

J.U.C 并发包提供了：

AtomicBoolean
AtomicInteger
AtomicLong

以 AtomicInteger 为例

AtomicInteger i = new AtomicInteger(0);
// 获取并自增（i = 0, 结果 i = 1, 返回 0），类似于 i++
System.out.println(i.getAndIncrement());
// 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i
System.out.println(i.incrementAndGet());
// 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i
System.out.println(i.decrementAndGet());
// 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
System.out.println(i.getAndDecrement());
// 获取并加值（i = 0, 结果 i = 5, 返回 0）
System.out.println(i.getAndAdd(5));
// 加值并获取（i = 5, 结果 i = 0, 返回 0）
System.out.println(i.addAndGet(-5));
// 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
// 其中函数中的操作能保证原子，但函数需要无副作用
System.out.println(i.getAndUpdate(p -> p - 2));
// 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
// 其中函数中的操作能保证原子，但函数需要无副作用
System.out.println(i.updateAndGet(p -> p + 2));
// 获取并计算（i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0）
// 其中函数中的操作能保证原子，但函数需要无副作用
// getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的
// getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 final
System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
// 计算并获取（i = 10, p 为 i 的当前值, x 为参数1, 结果 i = 0, 返回 0）
// 其中函数中的操作能保证原子，但函数需要无副作用
System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));

Copied!

说明：

以上方法都是以CAS为基础进行了封装，保证了方法的原子性和变量的可见性。

updateAndGet方法的手动实现：

public static int updateAndGet(AtomicInteger i, IntUnaryOperator operator){
    while (true){
        int prev = i.get();
        int next = operator.applyAsInt(prev);
        if(i.compareAndSet(prev,next)){
            return next;
        }
    }
}

Copied!

6.4 原子引用

为什么需要原子引用类型？

AtomicReference
AtomicMarkableReference
AtomicStampedReference

实际开发的过程中我们使用的不一定是int、long等基本数据类型，也有可能时BigDecimal这样的类型，这时就需要用到原子引用作为容器。原子引用设置值使用的是unsafe.compareAndSwapObject()方法。原子引用中表示数据的类型需要重写equals()方法。

有如下方法

public interface DecimalAccount {
    // 获取余额
    BigDecimal getBalance();
    // 取款
    void withdraw(BigDecimal amount);
    /**
 * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
 * 如果初始余额为 10000 那么正确的结果应当是 0
 */
    static void demo(DecimalAccount account) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(BigDecimal.TEN);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(account.getBalance());
    }
}

Copied!

试着提供不同的 DecimalAccount 实现，实现安全的取款操作

不安全实现

class DecimalAccountUnsafe implements DecimalAccount {
    BigDecimal balance;
    public DecimalAccountUnsafe(BigDecimal balance) {
        this.balance = balance;
    }
    @Override
    public BigDecimal getBalance() {
        return balance;
    }
    @Override
    public void withdraw(BigDecimal amount) {
        BigDecimal balance = this.getBalance();
        this.balance = balance.subtract(amount);
    }
}

Copied!

安全实现-使用锁

class DecimalAccountSafeLock implements DecimalAccount {
    private final Object lock = new Object();
    BigDecimal balance;
    public DecimalAccountSafeLock(BigDecimal balance) {
        this.balance = balance;
    }
    @Override
    public BigDecimal getBalance() {
        return balance;
    }
    @Override
    public void withdraw(BigDecimal amount) {
        synchronized (lock) {
            BigDecimal balance = this.getBalance();
            this.balance = balance.subtract(amount);
        }
    }
}

Copied!

安全实现-使用 CAS

class DecimalAccountSafeCas implements DecimalAccount {
    AtomicReference<BigDecimal> ref;
    public DecimalAccountSafeCas(BigDecimal balance) {
        ref = new AtomicReference<>(balance);
    }
    @Override
    public BigDecimal getBalance() {
        return ref.get();
    }
    @Override
    public void withdraw(BigDecimal amount) {
        while (true) {
            BigDecimal prev = ref.get();
            BigDecimal next = prev.subtract(amount);
            if (ref.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

Copied!

测试代码

1
2
3

DecimalAccount.demo(new DecimalAccountUnsafe(new BigDecimal("10000")));
DecimalAccount.demo(new DecimalAccountSafeLock(new BigDecimal("10000")));
DecimalAccount.demo(new DecimalAccountSafeCas(new BigDecimal("10000")));

Copied!

运行结果

1
2
3

4310 cost: 425 ms 
0 cost: 285 ms 
0 cost: 274 ms

Copied!

ABA 问题及解决

ABA 问题

static AtomicReference<String> ref = new AtomicReference<>("A");
public static void main(String[] args) throws InterruptedException {
    log.debug("main start...");
    // 获取值 A
    // 这个共享变量被它线程修改过？
    String prev = ref.get();
    other();
    sleep(1);
    // 尝试改为 C
    log.debug("change A->C {}", ref.compareAndSet(prev, "C"));
}
private static void other() {
    new Thread(() -> {
        log.debug("change A->B {}", ref.compareAndSet(ref.get(), "B"));
    }, "t1").start();
    sleep(0.5);
    new Thread(() -> {
        log.debug("change B->A {}", ref.compareAndSet(ref.get(), "A"));
    }, "t2").start();
}

Copied!

输出

11:29:52.325 c.Test36 [main] - main start... 
11:29:52.379 c.Test36 [t1] - change A->B true 
11:29:52.879 c.Test36 [t2] - change B->A true 
11:29:53.880 c.Test36 [main] - change A->C true

Copied!

主线程仅能判断出共享变量的值与最初值 A 是否相同，不能感知到这种从 A 改为 B 又改回 A 的情况，如果主线程希望：

只要有其它线程【动过了】共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再加一个版本号

AtomicStampedReference

static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
public static void main(String[] args) throws InterruptedException {
    log.debug("main start...");
    // 获取值 A
    String prev = ref.getReference();
    // 获取版本号
    int stamp = ref.getStamp();
    log.debug("版本 {}", stamp);
    // 如果中间有其它线程干扰，发生了 ABA 现象
    other();
    sleep(1);
    // 尝试改为 C
    log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
}
private static void other() {
    new Thread(() -> {
        log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B", 
                                                      ref.getStamp(), ref.getStamp() + 1));
        log.debug("更新版本为 {}", ref.getStamp());
    }, "t1").start();
    sleep(0.5);
    new Thread(() -> {
        log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A", 
                                                      ref.getStamp(), ref.getStamp() + 1));
        log.debug("更新版本为 {}", ref.getStamp());
    }, "t2").start();
}

Copied!

输出为

15:41:34.891 c.Test36 [main] - main start... 
15:41:34.894 c.Test36 [main] - 版本 0 
15:41:34.956 c.Test36 [t1] - change A->B true 
15:41:34.956 c.Test36 [t1] - 更新版本为 1 
15:41:35.457 c.Test36 [t2] - change B->A true 
15:41:35.457 c.Test36 [t2] - 更新版本为 2 
15:41:36.457 c.Test36 [main] - change A->C false

Copied!

AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，如： A -> B -> A -> C ，通过AtomicStampedReference，我们可以知道，引用变量中途被更改了几次。

但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过，所以就有了 AtomicMarkableReference

graph TD
s(保洁阿姨)
m(主人)
g1(垃圾袋)
g2(新垃圾袋)

s -. 倒空 .-> g1
m -- 检查 --> g1
g1 -- 已满 --> g2
g1 -- 还空 --> g1

Copied!

AtomicMarkableReference

class GarbageBag {
    String desc;
    public GarbageBag(String desc) {
        this.desc = desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    @Override
    public String toString() {
        return super.toString() + " " + desc;
    }
}

Copied!

@Slf4j
public class TestABAAtomicMarkableReference {
    public static void main(String[] args) throws InterruptedException {
        GarbageBag bag = new GarbageBag("装满了垃圾");
        // 参数2 mark 可以看作一个标记，表示垃圾袋满了
        AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);
        log.debug("主线程 start...");
        GarbageBag prev = ref.getReference();
        log.debug(prev.toString());
        new Thread(() -> {
            log.debug("打扫卫生的线程 start...");
            bag.setDesc("空垃圾袋");
            while (!ref.compareAndSet(bag, bag, true, false)) {}
            log.debug(bag.toString());
        }).start();
        Thread.sleep(1000);
        log.debug("主线程想换一只新垃圾袋？");
        boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
        log.debug("换了么？" + success);
        log.debug(ref.getReference().toString());
    }
}

Copied!

输出

2019-10-13 15:30:09.264 [main] 主线程 start... 
2019-10-13 15:30:09.270 [main] cn.itcast.GarbageBag@5f0fd5a0 装满了垃圾
2019-10-13 15:30:09.293 [Thread-1] 打扫卫生的线程 start... 
2019-10-13 15:30:09.294 [Thread-1] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋
2019-10-13 15:30:10.294 [main] 主线程想换一只新垃圾袋？
2019-10-13 15:30:10.294 [main] 换了么？false 
2019-10-13 15:30:10.294 [main] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋

Copied!

可以注释掉打扫卫生线程代码，再观察输出

6.5 原子数组

AtomicIntegerArray
AtomicLongArray
AtomicReferenceArray

有如下方法

/**
 参数1，提供数组、可以是线程不安全数组或线程安全数组
 参数2，获取数组长度的方法
 参数3，自增方法，回传 array, index
 参数4，打印数组的方法
*/
// supplier 提供者 无中生有 ()->结果
// function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
// consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->
private static <T> void demo(
    Supplier<T> arraySupplier,
    Function<T, Integer> lengthFun,
    BiConsumer<T, Integer> putConsumer,
    Consumer<T> printConsumer ) {
    List<Thread> ts = new ArrayList<>();
    T array = arraySupplier.get();
    int length = lengthFun.apply(array);
    for (int i = 0; i < length; i++) {
        // 每个线程对数组作 10000 次操作
        ts.add(new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                putConsumer.accept(array, j%length);
            }
        }));
    }
    ts.forEach(t -> t.start()); // 启动所有线程
    ts.forEach(t -> {
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }); // 等所有线程结束
    printConsumer.accept(array);
}

Copied!

不安全的数组

demo(
    ()->new int[10],
    (array)->array.length,
    (array, index) -> array[index]++,
    array-> System.out.println(Arrays.toString(array))
);

Copied!

结果

`1`	`[9870, 9862, 9774, 9697, 9683, 9678, 9679, 9668, 9680, 9698]`

Copied!

安全的数组

demo(
    ()-> new AtomicIntegerArray(10),
    (array) -> array.length(),
    (array, index) -> array.getAndIncrement(index),
    array -> System.out.println(array)
);

Copied!

结果

`1`	`[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]`

Copied!

6.6 字段更新器

AtomicReferenceFieldUpdater // 域字段
AtomicIntegerFieldUpdater
AtomicLongFieldUpdater 利用字段更新器，可以针对对象的某个域（Field）进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现异常

`1`	`Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type`

Copied!

public class Test5 {
    private volatile int field;
    public static void main(String[] args) {
        AtomicIntegerFieldUpdater fieldUpdater =
            AtomicIntegerFieldUpdater.newUpdater(Test5.class, "field");
        Test5 test5 = new Test5();
        fieldUpdater.compareAndSet(test5, 0, 10);
        // 修改成功 field = 10
        System.out.println(test5.field);
        // 修改成功 field = 20
        fieldUpdater.compareAndSet(test5, 10, 20);
        System.out.println(test5.field);
        // 修改失败 field = 20
        fieldUpdater.compareAndSet(test5, 10, 30);
        System.out.println(test5.field);
    }
}

Copied!

输出

1
2
3

10 
20 
20

Copied!

6.7 原子累加器

累加器性能比较

private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
    T adder = adderSupplier.get();
    long start = System.nanoTime();
    List<Thread> ts = new ArrayList<>();
    // 4 个线程，每人累加 50 万
    for (int i = 0; i < 40; i++) {
        ts.add(new Thread(() -> {
            for (int j = 0; j < 500000; j++) {
                action.accept(adder);
            }
        }));
    }
    ts.forEach(t -> t.start());
    ts.forEach(t -> {
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    long end = System.nanoTime();
    System.out.println(adder + " cost:" + (end - start)/1000_000);
}

Copied!

比较 AtomicLong 与 LongAdder

for (int i = 0; i < 5; i++) {
    demo(() -> new LongAdder(), adder -> adder.increment());
}
for (int i = 0; i < 5; i++) {
    demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());
}

Copied!

输出

1000000 cost:43 
1000000 cost:9 
1000000 cost:7 
1000000 cost:7 
1000000 cost:7 
1000000 cost:31 
1000000 cost:27 
1000000 cost:28 
1000000 cost:24 
1000000 cost:22

Copied!

性能提升的原因很简单，就是在有竞争时，设置多个累加单元，Therad-0 累加 Cell[0]，而 Thread-1 累加 Cell[1]… 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量，因此减少了 CAS 重试失败，从而提高性能。

* 原理之伪共享(CPU 缓存结构)

CPU 缓存结构

查看 cpu 缓存

⚡ root@yihang01 ~ lscpu
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 1
On-line CPU(s) list: 0
Thread(s) per core: 1
Core(s) per socket: 1
Socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 142
Model name: Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
Stepping: 11
CPU MHz: 1992.002
BogoMIPS: 3984.00
Hypervisor vendor: VMware
Virtualization type: full
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 8192K
NUMA node0 CPU(s): 0

Copied!

速度比较

从cpu到	大约需要的时钟周期
寄存器	1 cycle
L1	3~4 cycle
L2	10~20 cycle
L3	40~45 cycle
内存	120~240 cycle

查看 cpu 缓存行

1
2

⚡ root@yihang01 ~ cat /sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size
64

Copied!

cpu 拿到的内存地址格式是这样的

`1`	`[高位组标记][低位索引][偏移量]`

Copied!

CPU 缓存读

读取数据流程如下

根据低位，计算在缓存中的索引
判断是否有效
- 0 去内存读取新数据更新缓存行
- 1 再对比高位组标记是否一致
  - 一致，根据偏移量返回缓存数据
  - 不一致，去内存读取新数据更新缓存行

CPU 缓存一致性

MESI 协议

E、S、M 状态的缓存行都可以满足 CPU 的读请求
E 状态的缓存行，有写请求，会将状态改为 M，这时并不触发向主存的写
E 状态的缓存行，必须监听该缓存行的读操作，如果有，要变为 S 状态

4. M 状态的缓存行，必须监听该缓存行的读操作，如果有，先将其它缓存（S 状态）中该缓存行变成 I 状态（即 6. 的流程），写入主存，自己变为 S 状态 
5. S 状态的缓存行，有写请求，走 4. 的流程 
6. S 状态的缓存行，必须监听该缓存行的失效操作，如果有，自己变为 I 状态 
7. I 状态的缓存行，有读请求，必须从主存读取

内存屏障

Memory Barrier（Memory Fence）

可见性

写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中
而读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据

有序性

写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

* 源码之 LongAdder

LongAdder 是并发大师 @author Doug Lea （大哥李）的作品，设计的非常精巧

LongAdder 类有几个关键域

// 累加单元数组, 懒惰初始化
transient volatile Cell[] cells;
// 基础值, 如果没有竞争, 则用 cas 累加这个域
transient volatile long base;
// 在 cells 创建或扩容时, 置为 1, 表示加锁
transient volatile int cellsBusy;

Copied!

其中 Cell 即为累加单元

// 防止缓存行伪共享
@sun.misc.Contended
static final class Cell {
    volatile long value;
    Cell(long x) { value = x; }

    // 最重要的方法, 用来 cas 方式进行累加, prev 表示旧值, next 表示新值
    final boolean cas(long prev, long next) {
        return UNSAFE.compareAndSwapLong(this, valueOffset, prev, next);
    }
    // 省略不重要代码
}

Copied!

得从缓存说起

缓存与内存的速度比较

因为 CPU 与内存的速度差异很大，需要靠预读数据至缓存来提升效率。

而缓存以缓存行为单位，每个缓存行对应着一块内存，一般是 64 byte（8 个 long）

缓存的加入会造成数据副本的产生，即同一份数据会缓存在不同核心的缓存行中

CPU 要保证数据的一致性，如果某个 CPU 核心更改了数据，其它 CPU 核心对应的整个缓存行必须失效

因为 Cell 是数组形式，在内存中是连续存储的，一个 Cell 为 24 字节（16 字节的对象头和 8 字节的 value），因此缓存行可以存下 2 个的 Cell 对象。这样问题来了：

Core-0 要修改 Cell[0]
Core-1 要修改 Cell[1]

无论谁修改成功，都会导致对方 Core 的缓存行失效，比如Core-0 中Cell[0]=6000, Cell[1]=8000要累加Cell[0]=6001, Cell[1]=8000 ，这时会让 Core-1 的缓存行失效

@sun.misc.Contended 用来解决这个问题，它的原理是在使用此注解的对象或字段的前后各增加 128 字节大小的 padding，从而让 CPU 将对象预读至缓存时占用不同的缓存行，这样，不会造成对方缓存行的失效

累加主要调用下面的方法

public void add(long x) {
    // as 为累加单元数组
    // b 为基础值
    // x 为累加值
    Cell[] as; long b, v; int m; Cell a;
    // 进入 if 的两个条件
    // 1. as 有值, 表示已经发生过竞争, 进入 if
    // 2. cas 给 base 累加时失败了, 表示 base 发生了竞争, 进入 if
    if ((as = cells) != null || !casBase(b = base, b + x)) {
        // uncontended 表示 cell 没有竞争
        boolean uncontended = true;
        if (
            // as 还没有创建
            as == null || (m = as.length - 1) < 0 ||
            // 当前线程对应的 cell 还没有
            // getProbe()方法返回的是线程中的threadLocalRandomProbe字段
            // 它是通过随机数生成的一个值，对于一个确定的线程这个值是固定的
            // 除非刻意修改它
            (a = as[getProbe() & m]) == null ||
            // cas 给当前线程的 cell 累加失败 uncontended=false ( a 为当前线程的 cell )
            !(uncontended = a.cas(v = a.value, v + x))
        ) {
            // 进入 cell 数组创建、cell 创建的流程
            longAccumulate(x, null, uncontended);
        }
    }
}

Copied!

总结：

如果已经有了累加数组或给base累加发生了竞争导致失败
- 如果累加数组没有创建或者累加数组长度为1或者当前线程还没有对应的cell或者累加cell失败
  - 进入累加数组的创建流程
- 否者说明累加成功，退出。
否则累加成功

add 流程图

final void longAccumulate(long x, LongBinaryOperator fn,
                          boolean wasUncontended) {
    int h;
    // 当前线程还没有对应的 cell, 需要随机生成一个 h 值用来将当前线程绑定到 cell
    if ((h = getProbe()) == 0) {
        // 初始化 probe
        ThreadLocalRandom.current();
        // h 对应新的 probe 值, 用来对应 cell
        h = getProbe();
        wasUncontended = true;
    }
    // collide 为 true 表示最后一个槽非空，需要扩容
    boolean collide = false; 
    for (;;) {
        Cell[] as; Cell a; int n; long v;
        // 已经有了 cells
        if ((as = cells) != null && (n = as.length) > 0) {
            // 还没有 cell
            if ((a = as[(n - 1) & h]) == null) {
                // 为 cellsBusy 加锁, 创建 cell, cell 的初始累加值为 x
                // 成功则 break, 否则继续 continue 循环
                if (cellsBusy == 0) {       // Try to attach new Cell
                    Cell r = new Cell(x);   // Optimistically create
                    if (cellsBusy == 0 && casCellsBusy()) {
                        boolean created = false;
                        try {               // Recheck under lock
                            Cell[] rs; int m, j;
                            if ((rs = cells) != null &&
                                (m = rs.length) > 0 &&
                                rs[j = (m - 1) & h] == null) {
                                rs[j] = r;
                                created = true;
                            }
                        } finally {
                            cellsBusy = 0;
                        }
                        if (created)
                            break;
                        continue;           // Slot is now non-empty
                    }
                }
                collide = false;
            }
            // 有竞争, 改变线程对应的 cell 来重试 cas
            else if (!wasUncontended)
                wasUncontended = true;
            // cas 尝试累加, fn 配合 LongAccumulator 不为 null, 配合 LongAdder 为 null
            else if (a.cas(v = a.value, ((fn == null) ? v + x : fn.applyAsLong(v, x))))
                break;
            // 如果 cells 长度已经超过了最大长度, 或者已经扩容, 改变线程对应的 cell 来重试 cas
            else if (n >= NCPU || cells != as)
                collide = false;
            // 确保 collide 为 false 进入此分支, 就不会进入下面的 else if 进行扩容了
            else if (!collide)
                collide = true;
            // 加锁
            else if (cellsBusy == 0 && casCellsBusy()) {
                // 加锁成功, 扩容
                continue;
            }
            // 改变线程对应的 cell
            h = advanceProbe(h);
        }
        // 还没有 cells, 尝试给 cellsBusy 加锁
        else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
            // 加锁成功, 初始化 cells, 最开始长度为 2, 并填充一个 cell
            // 成功则 break;
            boolean init = false;
            try {                           // Initialize table
                if (cells == as) {
                    Cell[] rs = new Cell[2];
                    rs[h & 1] = new Cell(x);
                    cells = rs;
                    init = true;
                }
            } finally {
                cellsBusy = 0;
            }
            if (init)
                break;
        }
        // 上两种情况失败, 尝试给 base 累加
        else if (casBase(v = base, ((fn == null) ? v + x : fn.applyAsLong(v, x))))
            break;
    }
}

Copied!

总结：

先判断当前线程有没有对应的Cell
- 如果没有，随机生成一个值，这个值与当前线程绑定，通过这个值的取模运算定位当前线程Cell的位置。
进入for循环
- if 有Cells累加数组且长度大于0
  - if 如果当前线程没有cell
    - 准备扩容，如果前累加数组不繁忙（正在扩容之类）
      - 将新建的cell放入对应的槽位中，新建Cell成功，进入下一次循环，尝试cas累加。
    - 将collide置为false，表示无需扩容。
  - else if 有竞争
    - 将wasUncontended置为tue，进入分支底部，改变线程对应的cell来cas重试
  - else if cas重试累加成功
    - 退出循环。
  - else if cells 长度已经超过了最大长度, 或者已经扩容,
    - collide置为false，进入分支底部，改变线程对应的 cell 来重试 cas
  - else if collide为false
    - 将collide置为true（确保 collide 为 false 进入此分支, 就不会进入下面的 else if 进行扩容了）
  - else if 累加数组不繁忙且加锁成功
    - 退出本次循环，进入下一次循环（扩容）
  - 改变线程对应的 cell 来重试 cas
- else if 数组不繁忙且数组为null且加锁成功
  - 新建数组，在槽位处新建cell，释放锁，退出循环。
- else if 尝试给base累加成功
  - 退出循环

longAccumulate 流程图

每个线程刚进入 longAccumulate 时，会尝试对应一个 cell 对象（找到一个坑位）

获取最终结果通过 sum 方法

public long sum() {
    Cell[] as = cells; Cell a;
    long sum = base;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

Copied!

与运算和取模的关系

参考链接：https://www.cnblogs.com/thrillerz/p/4530108.html

6.8 Unsafe

概述

Unsafe 对象提供了非常底层的，操作内存、线程的方法，Unsafe 对象不能直接调用，只能通过反射获得。jdk8直接调用Unsafe.getUnsafe()获得的unsafe不能用。

public class UnsafeAccessor {
    static Unsafe unsafe;
    static {
        try { 
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            unsafe = (Unsafe) theUnsafe.get(null);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new Error(e);
        }
    }
    static Unsafe getUnsafe() {
        return unsafe;
    }
}

Copied!

方法：

//以下三个方法只执行一次，成功返回true，不成功返回false
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
//以下方法都是在以上三个方法的基础上进行封装，会循环直到成功为止。
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

public final long getAndAddLong(Object var1, long var2, long var4) {
    long var6;
    do {
        var6 = this.getLongVolatile(var1, var2);
    } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

    return var6;
}

public final int getAndSetInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var4));

    return var5;
}

public final long getAndSetLong(Object var1, long var2, long var4) {
    long var6;
    do {
        var6 = this.getLongVolatile(var1, var2);
    } while(!this.compareAndSwapLong(var1, var2, var6, var4));

    return var6;
}

public final Object getAndSetObject(Object var1, long var2, Object var4) {
    Object var5;
    do {
        var5 = this.getObjectVolatile(var1, var2);
    } while(!this.compareAndSwapObject(var1, var2, var5, var4));

Copied!

Unsafe CAS 操作

unsafe实现字段更新

@Data
class Student {
    volatile int id;
    volatile String name;
}

Copied!

Unsafe unsafe = UnsafeAccessor.getUnsafe();
Field id = Student.class.getDeclaredField("id");
Field name = Student.class.getDeclaredField("name");
// 获得成员变量的偏移量
long idOffset = UnsafeAccessor.unsafe.objectFieldOffset(id);
long nameOffset = UnsafeAccessor.unsafe.objectFieldOffset(name);
Student student = new Student();
// 使用 cas 方法替换成员变量的值
UnsafeAccessor.unsafe.compareAndSwapInt(student, idOffset, 0, 20); // 返回 true
UnsafeAccessor.unsafe.compareAndSwapObject(student, nameOffset, null, "张三"); // 返回 true
System.out.println(student);

Copied!

输出

`1`	`Student(id=20, name=张三)`

Copied!

unsafe实现原子整数

class AtomicData {
    private volatile int data;
    static final Unsafe unsafe;
    static final long DATA_OFFSET;
    static {
        unsafe = UnsafeAccessor.getUnsafe();
        try {
            // data 属性在 DataContainer 对象中的偏移量，用于 Unsafe 直接访问该属性
            DATA_OFFSET = unsafe.objectFieldOffset(AtomicData.class.getDeclaredField("data"));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }
    public AtomicData(int data) {
        this.data = data;
    }
    public void decrease(int amount) {
        int oldValue;
        while(true) {
            // 获取共享变量旧值，可以在这一行加入断点，修改 data 调试来加深理解
            oldValue = data;
            // cas 尝试修改 data 为 旧值 + amount，如果期间旧值被别的线程改了，返回 false
            if (unsafe.compareAndSwapInt(this, DATA_OFFSET, oldValue, oldValue - amount)) {
                return;
            }
        }
    }
    public int getData() {
        return data;
    }
}

Copied!

Account 实现

Account.demo(new Account() {
    AtomicData atomicData = new AtomicData(10000);
    @Override
    public Integer getBalance() {
        return atomicData.getData();
    }
    @Override
    public void withdraw(Integer amount) {
        atomicData.decrease(amount);
    }
});

Copied!

手动实现原子整数完整版+测试


public class UnsafeAtomicTest{
    public static void main(String[] args) {
        //赋初始值10000，调用demo后正确的输出结果为0
        AccountImpl account = new AccountImpl(10000);
        //结果正确地输出0
        account.demo();
    }
}

interface Account{
    //获取balance的方法
    int getBalance();
    //取款的方法
    void decrease(int amount);
    //演示多线程取款，检查安全性。
    default void demo(){
        ArrayList<Thread> ts = new ArrayList<>(1000);
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                decrease(10);
            }));
        }
        for (Thread t:ts) {
            t.start();
        }
        for (Thread t:ts) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(getBalance());
    }
}
//实现账户类，使用手动实现的原子整数作为余额类型
class AccountImpl implements Account{

    UnsafeAtomicInteger balance;

    public AccountImpl(int balance){
        this.balance = new UnsafeAtomicInteger(balance);
    }

    @Override
    public int getBalance() {
        return balance.get();
    }

    @Override
    public void decrease(int amount) {
        balance.getAndAccumulate(amount,(x,y) -> y - x);
    }

}
//手动实现原子整数类
class UnsafeAtomicInteger {
    //将value声明为volatile，因为乐观锁需要可见性。
    private volatile int value;
    //需要Unsafe的cas本地方法实现操作。
    private static final Unsafe unsafe;
    //偏移量，这两个变量很重要且通用、不可变，所以均声明为private static final
    private static final long offset;

    static{
        //静态代码块初始化unsafe
        unsafe = UnsafeAccessor.getUnsafe();

        try {
            //获取value在当前类中的偏移量
            offset = unsafe.objectFieldOffset(UnsafeAtomicInteger.class.getDeclaredField("value"));
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
            //待研究
            throw new Error(e);
        }
    }

    public UnsafeAtomicInteger(){

    }

    public UnsafeAtomicInteger(int value){
        this.value = value;
    }

    public final int get(){
        return value;
    }

    public final boolean compareAndSet(int expext,int update){
        return unsafe.compareAndSwapInt(this, offset, expext, update);
    }

    public final int getAndIncrement(){
        //局部变量是必须的，因为多次从主存中读取value的值不可靠。
        int oldValue;
        while (true){
            oldValue = value;
            if(unsafe.compareAndSwapInt(this,offset,oldValue,oldValue + 1)){
                return oldValue;
            }
        }
    }

    public final int incrementAndGet(){
        int oldValue;
        while (true){
            oldValue = value;
            if (unsafe.compareAndSwapInt(this, offset, oldValue, oldValue + 1)) {
                return oldValue + 1;
            }
        }
    }

    public final int getAndDecrement(){
        int oldValue;
        while (true){
            oldValue = value;
            if (unsafe.compareAndSwapInt(this, offset, oldValue, oldValue - 1)) {
                return oldValue;
            }
        }
    }

    public final int decrementAndGet(){
        int oldValue;
        while (true){
            oldValue = value;
            if (unsafe.compareAndSwapInt(this, offset, oldValue, oldValue - 1)) {
                return oldValue - 1;
            }
        }
    }

    public final int getAndUpdate(IntUnaryOperator operator){
        int oldValue;
        int newValue;
        while (true){
            oldValue = value;
            newValue = operator.applyAsInt(oldValue);
            if (unsafe.compareAndSwapInt(this, offset, oldValue, newValue)) {
                return oldValue;
            }
        }
    }

    public final int updateAndGet(IntUnaryOperator operator){
        int oldValue;
        int newValue;
        while (true){
            oldValue = value;
            newValue = operator.applyAsInt(oldValue);
            if (unsafe.compareAndSwapInt(this, offset, oldValue, newValue)) {
                return newValue;
            }
        }
    }

    public final int getAndAccumulate(int x, IntBinaryOperator operator){
        int oldValue;
        int newValue;
        while (true){
            oldValue = value;
            newValue = operator.applyAsInt(x,oldValue);
            if (unsafe.compareAndSwapInt(this, offset, oldValue, newValue)) {
                return newValue;
            }
        }
    }

    public final int accumulateAndGet(int x, IntBinaryOperator operator){
        int oldValue;
        int newValue;
        while (true){
            oldValue = value;
            newValue = operator.applyAsInt(x,oldValue);
            if (unsafe.compareAndSwapInt(this, offset, oldValue, newValue)) {
                return oldValue;
            }
        }
    }
}

class UnsafeAccessor{
    public static Unsafe getUnsafe(){
        Field field;
        Unsafe unsafe = null;
        try {
            field  = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe)field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return unsafe;
    }
}

Copied!

6.9 自定义cas锁

// 不要用于实践！！！
public class LockCas {
    private AtomicInteger state = new AtomicInteger(0);
    public void lock() {
        while (true) {
            if (state.compareAndSet(0, 1)) {
                break;
            }
        }
    }
    public void unlock() {
        log.debug("unlock...");
        state.set(0);
    }
}

Copied!

测试

LockCas lock = new LockCas();
new Thread(() -> {
    log.debug("begin...");
    lock.lock();
    try {
        log.debug("lock...");
        sleep(1);
    } finally {
        lock.unlock();
    }
}).start();
new Thread(() -> {
    log.debug("begin...");
    lock.lock();
    try {
        log.debug("lock...");
    } finally {
        lock.unlock();
    }
}).start();

Copied!

18:27:07.198 c.Test42 [Thread-0] - begin... 
18:27:07.202 c.Test42 [Thread-0] - lock... 
18:27:07.198 c.Test42 [Thread-1] - begin... 
18:27:08.204 c.Test42 [Thread-0] - unlock... 
18:27:08.204 c.Test42 [Thread-1] - lock... 
18:27:08.204 c.Test42 [Thread-1] - unlock...

Copied!

本章小结

CAS 与 volatile
API
- 原子整数
- 原子引用
- 原子数组
- 字段更新器
- 原子累加器
Unsafe
*原理方面
- LongAdder 源码
- 伪共享

7.共享模型之不可变

7.1 日期转换的问题

问题提出

下面的代码在运行时，由于 SimpleDateFormat 不是线程安全的

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        try {
            log.debug("{}", sdf.parse("1951-04-21"));
        } catch (Exception e) {
            log.error("{}", e);
        }
    }).start();
}

Copied!

有很大几率出现 java.lang.NumberFormatException 或者出现不正确的日期解析结果，例如：

19:10:40.859 [Thread-2] c.TestDateParse - {} 
java.lang.NumberFormatException: For input string: "" 
 at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65) 
 at java.lang.Long.parseLong(Long.java:601) 
 at java.lang.Long.parseLong(Long.java:631) 
 at java.text.DigitList.getLong(DigitList.java:195) 
 at java.text.DecimalFormat.parse(DecimalFormat.java:2084) 
 at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2162) 
 at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514) 
 at java.text.DateFormat.parse(DateFormat.java:364) 
 at cn.itcast.n7.TestDateParse.lambda$test1$0(TestDateParse.java:18) 
 at java.lang.Thread.run(Thread.java:748) 
19:10:40.859 [Thread-1] c.TestDateParse - {} 
java.lang.NumberFormatException: empty String 
 at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1842) 
 at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110) 
 at java.lang.Double.parseDouble(Double.java:538) 
 at java.text.DigitList.getDouble(DigitList.java:169) 
 at java.text.DecimalFormat.parse(DecimalFormat.java:2089) 
 at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2162) 
 at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514) 
 at java.text.DateFormat.parse(DateFormat.java:364) 
 at cn.itcast.n7.TestDateParse.lambda$test1$0(TestDateParse.java:18) 
 at java.lang.Thread.run(Thread.java:748) 
19:10:40.857 [Thread-8] c.TestDateParse - Sat Apr 21 00:00:00 CST 1951 
19:10:40.857 [Thread-9] c.TestDateParse - Sat Apr 21 00:00:00 CST 1951 
19:10:40.857 [Thread-6] c.TestDateParse - Sat Apr 21 00:00:00 CST 1951 
19:10:40.857 [Thread-4] c.TestDateParse - Sat Apr 21 00:00:00 CST 1951 
19:10:40.857 [Thread-5] c.TestDateParse - Mon Apr 21 00:00:00 CST 178960645 
19:10:40.857 [Thread-0] c.TestDateParse - Sat Apr 21 00:00:00 CST 1951 
19:10:40.857 [Thread-7] c.TestDateParse - Sat Apr 21 00:00:00 CST 1951 
19:10:40.857 [Thread-3] c.TestDateParse - Sat Apr 21 00:00:00 CST 1951

Copied!

思路 - 同步锁

这样虽能解决问题，但带来的是性能上的损失，并不算很好：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < 50; i++) {
    new Thread(() -> {
        synchronized (sdf) {
            try {
                log.debug("{}", sdf.parse("1951-04-21"));
            } catch (Exception e) {
                log.error("{}", e);
            }
        }
    }).start();
}

Copied!

思路 - 不可变

如果一个对象在不能够修改其内部状态（属性），那么它就是线程安全的，因为不存在并发修改啊！这样的对象在 Java 中有很多，例如在 Java 8 后，提供了一个新的日期格式化类：

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        LocalDate date = dtf.parse("2018-10-01", LocalDate::from);
        log.debug("{}", date);
    }).start();
}

Copied!

可以看 DateTimeFormatter 的文档：

1
2

@implSpec
//This class is immutable and thread-safe.

Copied!

不可变对象，实际是另一种避免竞争的方式。

7.2 不可变设计

String类的设计

另一个大家更为熟悉的 String 类也是不可变的，以它为例，说明一下不可变设计的要素

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    /** Cache the hash code for the string */
    private int hash; // Default to 0

    // ...

}

Copied!

说明：

将类声明为final，避免被带外星方法的子类继承，从而破坏了不可变性。
将字符数组声明为final，避免被修改
hash虽然不是final的，但是其只有在调用hash()方法的时候才被赋值，除此之外再无别的方法修改。

final 的使用

发现该类、类中所有属性都是 final 的

属性用 final 修饰保证了该属性是只读的，不能修改
类用 final 修饰保证了该类中的方法不能被覆盖，防止子类无意间破坏不可变性

保护性拷贝

但有同学会说，使用字符串时，也有一些跟修改相关的方法啊，比如 substring 等，那么下面就看一看这些方法是如何实现的，就以 substring 为例：

public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

Copied!

发现其内部是调用 String 的构造方法创建了一个新字符串，再进入这个构造看看，是否对 final char[] value 做出了修改：

public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

Copied!

结果发现也没有，构造新字符串对象时，会生成新的 char[] value，对内容进行复制。这种通过创建副本对象来避免共享的手段称之为【保护性拷贝（defensive copy）】

*模式之享元

简介

定义英文名称：Flyweight pattern. 当需要重用数量有限的同一类对象时

wikipedia： A flyweight is an object that minimizes memory usage by sharing as much data as possible with other similar objects

出自 “Gang of Four” design patterns

归类 Structual patterns

体现

包装类

在JDK中 Boolean，Byte，Short，Integer，Long，Character 等包装类提供了 valueOf 方法，例如 Long 的 valueOf 会缓存 -128~127 之间的 Long 对象，在这个范围之间会重用对象，大于这个范围，才会新建 Long 对象：

public static Long valueOf(long l) {
    final int offset = 128;
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
    return new Long(l);
}

Copied!

注意：

Byte, Short, Long 缓存的范围都是 -128~127

Character 缓存的范围是 0~127

Integer的默认范围是 -128~127

最小值不能变

但最大值可以通过调整虚拟机参数 -Djava.lang.Integer.IntegerCache.high 来改变

Boolean 缓存了 TRUE 和 FALSE

String 串池（不可变、线程安全）

详见jvm

BigDecimal BigInteger(不可变、线程安全)

一部分数字使用了享元模式进行了缓存。

手动实现一个连接池

例如：一个线上商城应用，QPS 达到数千，如果每次都重新创建和关闭数据库连接，性能会受到极大影响。这时预先创建好一批连接，放入连接池。一次请求到达后，从连接池获取连接，使用完毕后再还回连接池，这样既节约了连接的创建和关闭时间，也实现了连接的重用，不至于让庞大的连接数压垮数据库。

class Pool {
    // 1. 连接池大小
    private final int poolSize;
    // 2. 连接对象数组
    private Connection[] connections;
    // 3. 连接状态数组 0 表示空闲， 1 表示繁忙
    private AtomicIntegerArray states;
    // 4. 构造方法初始化
    public Pool(int poolSize) {
        this.poolSize = poolSize;
        this.connections = new Connection[poolSize];
        this.states = new AtomicIntegerArray(new int[poolSize]);
        for (int i = 0; i < poolSize; i++) {
            connections[i] = new MockConnection("连接" + (i+1));
        }
    }
    // 5. 借连接
    public Connection borrow() {
        while(true) {
            for (int i = 0; i < poolSize; i++) {
                // 获取空闲连接
                if(states.get(i) == 0) {
                    if (states.compareAndSet(i, 0, 1)) {
                        log.debug("borrow {}", connections[i]);
                        return connections[i];
                    }
                }
            }
            // 如果没有空闲连接，当前线程进入等待
            synchronized (this) {
                try {
                    log.debug("wait...");
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    // 6. 归还连接
    public void free(Connection conn) {
        for (int i = 0; i < poolSize; i++) {
            if (connections[i] == conn) {
                states.set(i, 0);
                synchronized (this) {
                    log.debug("free {}", conn);
                    this.notifyAll();
                }
                break;
            }
        }
    }
}
class MockConnection implements Connection {
    // 实现略
}

Copied!

使用连接池：

Pool pool = new Pool(2);
for (int i = 0; i < 5; i++) {
    new Thread(() -> {
        Connection conn = pool.borrow();
        try {
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        pool.free(conn);
    }).start();
}

Copied!

以上实现没有考虑：

连接的动态增长与收缩
连接保活（可用性检测）
等待超时处理
分布式 hash

对于关系型数据库，有比较成熟的连接池实现，例如c3p0, druid等对于更通用的对象池，可以考虑使用apache commons pool，例如redis连接池可以参考jedis中关于连接池的实现

* 原理之 final

设置 final 变量的原理

理解了 volatile 原理，再对比 final 的实现就比较简单了

1
2
3

public class TestFinal {
    final int a = 20;
}

Copied!

字节码

0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush 20
7: putfield #2 // Field a:I
 <-- 写屏障
10: return

Copied!

发现 final 变量的赋值也会通过 putfield 指令来完成，同样在这条指令之后也会加入写屏障，这样对final变量的写入不会重排序到构造方法之外，保证在其它线程读到它的值时不会出现为 0 的情况。普通变量不能保证这一点了。

读取final变量原理

有以下代码：

public class TestFinal {
    final static int A = 10;
    final static int B = Short.MAX_VALUE+1;

    final int a = 20;
    final int b = Integer.MAX_VALUE;

    final void test1() {
        final int c = 30;
        new Thread(()->{
            System.out.println(c);
        }).start();

        final int d = 30;
        class Task implements Runnable {

            @Override
            public void run() {
                System.out.println(d);
            }
        }
        new Thread(new Task()).start();
    }

}

class UseFinal1 {
    public void test() {
        System.out.println(TestFinal.A);
        System.out.println(TestFinal.B);
        System.out.println(new TestFinal().a);
        System.out.println(new TestFinal().b);
        new TestFinal().test1();
    }
}

class UseFinal2 {
    public void test() {
        System.out.println(TestFinal.A);
    }
}

Copied!

反编译UseFinal1中的test方法：

  public test()V
   L0
    LINENUMBER 31 L0
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    BIPUSH 10
    INVOKEVIRTUAL java/io/PrintStream.println (I)V
   L1
    LINENUMBER 32 L1
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC 32768
    INVOKEVIRTUAL java/io/PrintStream.println (I)V
   L2
    LINENUMBER 33 L2
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    NEW cn/itcast/n5/TestFinal
    DUP
    INVOKESPECIAL cn/itcast/n5/TestFinal.<init> ()V
    INVOKEVIRTUAL java/lang/Object.getClass ()Ljava/lang/Class;
    POP
    BIPUSH 20
    INVOKEVIRTUAL java/io/PrintStream.println (I)V
   L3
    LINENUMBER 34 L3
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    NEW cn/itcast/n5/TestFinal
    DUP
    INVOKESPECIAL cn/itcast/n5/TestFinal.<init> ()V
    INVOKEVIRTUAL java/lang/Object.getClass ()Ljava/lang/Class;
    POP
    LDC 2147483647
    INVOKEVIRTUAL java/io/PrintStream.println (I)V
   L4
    LINENUMBER 35 L4
    NEW cn/itcast/n5/TestFinal
    DUP
    INVOKESPECIAL cn/itcast/n5/TestFinal.<init> ()V
    INVOKEVIRTUAL cn/itcast/n5/TestFinal.test1 ()V
   L5
    LINENUMBER 36 L5
    RETURN
   L6
    LOCALVARIABLE this Lcn/itcast/n5/UseFinal1; L0 L6 0
    MAXSTACK = 3
    MAXLOCALS = 1
}

Copied!

可以看见，jvm对final变量的访问做出了优化：另一个类中的方法调用final变量是，不是从final变量所在类中获取（共享内存），而是直接复制一份到方法栈栈帧中的操作数栈中（工作内存），这样可以提升效率，是一种优化。

总结：

对于较小的static final变量：复制一份到操作数栈中
对于较大的static final变量：复制一份到当前类的常量池中
对于非静态final变量，优化同上。

final总结

final关键字的好处：

（1）final关键字提高了性能。JVM和Java应用都会缓存final变量。

（2）final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。

（3）使用final关键字，JVM会对方法、变量及类进行优化。

关于final的重要知识点

1、final关键字可以用于成员变量、本地变量、方法以及类。

2、final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。

3、你不能够对final变量再次赋值。

4、本地变量必须在声明时赋值。

5、在匿名类中所有变量都必须是final变量。

6、final方法不能被重写。

7、final类不能被继承。

8、final关键字不同于finally关键字，后者用于异常处理。

9、final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。

10、接口中声明的所有变量本身是final的。

11、final和abstract这两个关键字是反相关的，final类就不可能是abstract的。

12、final方法在编译阶段绑定，称为静态绑定(static binding)。

13、没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。

14、将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。

15、按照Java代码惯例，final变量就是常量，而且通常常量名要大写。

16、对于集合对象声明为final指的是引用不能被更改，但是你可以向其中增加，删除或者改变内容。

参考链接：Java中final实现原理的深入分析（附示例）-java教程-PHP中文网

7.3 无状态

在 web 阶段学习时，设计 Servlet 时为了保证其线程安全，都会有这样的建议，不要为 Servlet 设置成员变量，这种没有任何成员变量的类是线程安全的。

因为成员变量保存的数据也可以称为状态信息，因此没有成员变量就称之为【无状态】

8.共享模型之工具

线程池

自定义线程池

步骤1：自定义拒绝策略接口

@FunctionalInterface //拒绝策略
interface RejectPolicy<T>{
    void reject(BlockingQueue<T> queue,T task);
}

Copied!

步骤2：自定义任务队列

class BlockingQueue<T>{
    //阻塞队列，存放任务
    private Deque<T> queue = new ArrayDeque<>();
    //队列的最大容量
    private int capacity;
    //锁
    private ReentrantLock lock = new ReentrantLock();
    //生产者条件变量
    private Condition fullWaitSet = lock.newCondition();
    //消费者条件变量
    private Condition emptyWaitSet = lock.newCondition();
    //构造方法
    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }
    //超时阻塞获取
    public T poll(long timeout, TimeUnit unit){
        lock.lock();
        //将时间转换为纳秒
        long nanoTime = unit.toNanos(timeout);
        try{
            while(queue.size() == 0){
                try {
                    //等待超时依旧没有获取，返回null
                    if(nanoTime <= 0){
                        return null;
                    }
                    //该方法返回的是剩余时间
                    nanoTime = emptyWaitSet.awaitNanos(nanoTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.pollFirst();
            fullWaitSet.signal();
            return t;
        }finally {
            lock.unlock();
        }
    }
    //阻塞获取
    public T take(){
        lock.lock();
        try{
            while(queue.size() == 0){
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.pollFirst();
            fullWaitSet.signal();
            return t;
        }finally {
            lock.unlock();
        }
    }
    //阻塞添加
    public void put(T t){
        lock.lock();
        try{
            while (queue.size() == capacity){
                try {
                    System.out.println(Thread.currentThread().toString() + "等待加入任务队列:" + t.toString());
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().toString() + "加入任务队列:" + t.toString());
            queue.addLast(t);
            emptyWaitSet.signal();
        }finally {
            lock.unlock();
        }
    }
    //超时阻塞添加
    public boolean offer(T t,long timeout,TimeUnit timeUnit){
        lock.lock();
        try{
            long nanoTime = timeUnit.toNanos(timeout);
            while (queue.size() == capacity){
                try {
                    if(nanoTime <= 0){
                        System.out.println("等待超时，加入失败：" + t);
                        return false;
                    }
                    System.out.println(Thread.currentThread().toString() + "等待加入任务队列:" + t.toString());
                    nanoTime = fullWaitSet.awaitNanos(nanoTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().toString() + "加入任务队列:" + t.toString());
            queue.addLast(t);
            emptyWaitSet.signal();
            return true;
        }finally {
            lock.unlock();
        }
    }
    public int size(){
        lock.lock();
        try{
            return queue.size();
        }finally{
            lock.unlock();
        }
    }
    //从形参接收拒绝策略的put方法
    public void tryPut(RejectPolicy<T> rejectPolicy,T task){
        lock.lock();
        try{
            if(queue.size() == capacity){
                rejectPolicy.reject(this,task);
            }else{
                System.out.println("加入任务队列：" + task);
                queue.addLast(task);
                emptyWaitSet.signal();
            }
        }finally {
            lock.unlock();
        }
    }
}

Copied!

步骤3：自定义线程池

class ThreadPool{
    //阻塞队列
    BlockingQueue<Runnable> taskQue;
    //线程集合
    HashSet<Worker> workers = new HashSet<>();
    //拒绝策略
    private RejectPolicy<Runnable> rejectPolicy;
    //构造方法
    public ThreadPool(int coreSize,long timeout,TimeUnit timeUnit,int queueCapacity,RejectPolicy<Runnable> rejectPolicy){
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeUnit = timeUnit;
        this.rejectPolicy = rejectPolicy;
        taskQue = new BlockingQueue<Runnable>(queueCapacity);
    }
    //线程数
    private int coreSize;
    //任务超时时间
    private long timeout;
    //时间单元
    private TimeUnit timeUnit;
    //线程池的执行方法
    public void execute(Runnable task){
        //当线程数大于等于coreSize的时候，将任务放入阻塞队列
        //当线程数小于coreSize的时候，新建一个Worker放入workers
        //注意workers类不是线程安全的， 需要加锁
        synchronized (workers){
            if(workers.size() >= coreSize){
//                taskQue.put(task);
                //死等
                //带超时等待
                //让调用者放弃执行任务
                //让调用者抛出异常
                //让调用者自己执行任务
                taskQue.tryPut(rejectPolicy,task);
            }else {
                Worker worker = new Worker(task);
                System.out.println(Thread.currentThread().toString() + "新增worker:" + worker + ",task:" + task);
                workers.add(worker);
                worker.start();
            }
        }
    }

    //工作类
    class Worker extends Thread{

        private Runnable task;

        public Worker(Runnable task){
            this.task = task;
        }

        @Override
        public void run() {
            //巧妙的判断
            while(task != null || (task = taskQue.poll(timeout,timeUnit)) != null){
                try{
                    System.out.println(Thread.currentThread().toString() + "正在执行:" + task);
                    task.run();
                }catch (Exception e){

                }finally {
                    task = null;
                }
            }
            synchronized (workers){
                System.out.println(Thread.currentThread().toString() + "worker被移除:" + this.toString());
                workers.remove(this);
            }
        }
    }
}

Copied!

步骤4：编写测试类

public class ThreadPoolTest {
    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(1, 1000, TimeUnit.MILLISECONDS, 1, (queue,task)->{
                    //死等
//                    queue.put(task);
            //带超时等待
//            queue.offer(task, 1500, TimeUnit.MILLISECONDS);
            //让调用者放弃任务执行
//            System.out.println("放弃：" + task);
            //让调用者抛出异常
//            throw new RuntimeException("任务执行失败" + task);
            //让调用者自己执行任务
            task.run();
                });
        for (int i = 0; i <3; i++) {
            int j = i;
            threadPool.execute(()->{
                try {
                    System.out.println(Thread.currentThread().toString() + "执行任务：" + j);
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

Copied!

ThreadPoolExecutor

说明：

ScheduledThreadPoolExecutor是带调度的线程池
ThreadPoolExecutor是不带调度的线程池

线程池状态

ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量

状态名	高3位	接收新任务	处理阻塞队列任务	说明
RUNNING	111	Y	Y
SHUTDOWN	000	N	Y	不会接收新任务，但会处理阻塞队列剩余任务
STOP	001	N	N	会中断正在执行的任务，并抛弃阻塞队列任务
TIDYING	010			任务全执行完毕，活动线程为 0 即将进入终结
TERMINATED	011			终结状态

从数字上比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING

这些信息存储在一个原子变量 ctl 中，目的是将线程池状态与线程个数合二为一，这样就可以用一次 cas 原子操作进行赋值

// c 为旧值， ctlOf 返回结果为新值
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))));
// rs 为高 3 位代表线程池状态， wc 为低 29 位代表线程个数，ctl 是合并它们
private static int ctlOf(int rs, int wc) { return rs | wc; }

Copied!

构造方法

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

Copied!

corePoolSize 核心线程数目 (最多保留的线程数)
maximumPoolSize 最大线程数目
keepAliveTime 生存时间 - 针对救急线程
unit 时间单位 - 针对救急线程
workQueue 阻塞队列
threadFactory 线程工厂 - 可以为线程创建时起个好名字
handler 拒绝策略

工作方式

graph LR

subgraph 阻塞队列
size=2
t3(任务3)
t4(任务4)
end

subgraph 线程池c-2,m=3
ct1(核心线程1)
ct2(核心线程2)
mt1(救急线程1)
ct1 --> t1(任务1)
ct2 --> t2(任务2)
end
t1(任务1)

style ct1 fill:#ccf,stroke:#f66,stroke-width:2px
style ct2 fill:#ccf,stroke:#f66,stroke-width:2px
style mt1 fill:#ccf,stroke:#f66,stroke-width:2px,stroke-dasharray:5,5

Copied!

线程池中刚开始没有线程，当一个任务提交给线程池后，线程池会创建一个新线程来执行任务。
当线程数达到 corePoolSize 并没有线程空闲，这时再加入任务，新加的任务会被加入workQueue 队列排队，直到有空闲的线程。
如果队列选择了有界队列，那么任务超过了队列大小时，会创建 maximumPoolSize - corePoolSize 数目的线程来救急。
如果线程到达 maximumPoolSize 仍然有新任务这时会执行拒绝策略。拒绝策略 jdk 提供了 4 种实现，其它著名框架也提供了实现
- AbortPolicy 让调用者抛出 RejectedExecutionException 异常，这是默认策略
- CallerRunsPolicy 让调用者运行任务
- DiscardPolicy 放弃本次任务
- DiscardOldestPolicy 放弃队列中最早的任务，本任务取而代之
- Dubbo 的实现，在抛出 RejectedExecutionException 异常之前会记录日志，并 dump 线程栈信息，方便定位问题
- Netty 的实现，是创建一个新线程来执行任务
- ActiveMQ 的实现，带超时等待（60s）尝试放入队列，类似我们之前自定义的拒绝策略
- PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略
当高峰过去后，超过corePoolSize 的救急线程如果一段时间没有任务做，需要结束节省资源，这个时间由 keepAliveTime 和 unit 来控制。

根据这个构造方法，JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池。

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

Copied!

内部调用了：ThreadPoolExecutor的一个构造方法

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

Copied!

默认工厂以及默认构造线程的方法：

DefaultThreadFactory() {
    SecurityManager s = System.getSecurityManager();
    group = (s != null) ? s.getThreadGroup() :
    Thread.currentThread().getThreadGroup();
    namePrefix = "pool-" +
        poolNumber.getAndIncrement() +
        "-thread-";
}

public Thread newThread(Runnable r) {
    Thread t = new Thread(group, r,
                          namePrefix + threadNumber.getAndIncrement(),
                          0);
    if (t.isDaemon())
        t.setDaemon(false);
    if (t.getPriority() != Thread.NORM_PRIORITY)
        t.setPriority(Thread.NORM_PRIORITY);
    return t;
}

Copied!

默认拒绝策略：抛出异常

`1`	`private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();`

Copied!

特点

核心线程数 == 最大线程数（没有救急线程被创建），因此也无需超时时间
阻塞队列是无界的，可以放任意数量的任务

评价适用于任务量已知，相对耗时的任务

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

Copied!

特点

核心线程数是 0，最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，
- 意味着全部都是救急线程（60s 后可以回收）
- 救急线程可以无限创建
队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱、一手交货）

SynchronousQueue<Integer> integers = new SynchronousQueue<>();
new Thread(() -> {
    try {
        log.debug("putting {} ", 1);
        integers.put(1);
        log.debug("{} putted...", 1);
        log.debug("putting...{} ", 2);
        integers.put(2);
        log.debug("{} putted...", 2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
},"t1").start();
sleep(1);
new Thread(() -> {
    try {
        log.debug("taking {}", 1);
        integers.take();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
},"t2").start();
sleep(1);
new Thread(() -> {
    try {
        log.debug("taking {}", 2);
        integers.take();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
},"t3").start();

Copied!

输出

11:48:15.500 c.TestSynchronousQueue [t1] - putting 1 
11:48:16.500 c.TestSynchronousQueue [t2] - taking 1 
11:48:16.500 c.TestSynchronousQueue [t1] - 1 putted... 
11:48:16.500 c.TestSynchronousQueue [t1] - putting...2 
11:48:17.502 c.TestSynchronousQueue [t3] - taking 2 
11:48:17.503 c.TestSynchronousQueue [t1] - 2 putted...

Copied!

评价整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲 1分钟后释放线程。适合任务数比较密集，但每个任务执行时间较短的情况

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

Copied!

使用场景：

希望多个任务排队执行。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。

区别：

自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池还会新建一个线程，保证池的正常工作
Executors.newSingleThreadExecutor() 线程个数始终为1，不能修改
- FinalizableDelegatedExecutorService 应用的是装饰器模式，在调用构造方法时将ThreadPoolExecutor对象传给了内部的ExecutorService接口。只对外暴露了 ExecutorService 接口，因此不能调用 ThreadPoolExecutor 中特有的方法，也不能重新设置线程池的大小。
Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改
- 对外暴露的是 ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize 等方法进行修改

提交任务

// 执行任务
void execute(Runnable command);
// 提交任务 task，用返回值 Future 获得任务执行结果
<T> Future<T> submit(Callable<T> task);
// 提交 tasks 中所有任务
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
    throws InterruptedException;
// 提交 tasks 中所有任务，带超时时间，时间超时后，会放弃执行后面的任务
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                              long timeout, TimeUnit unit)
    throws InterruptedException;
// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
    throws InterruptedException, ExecutionException;
// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
                long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException;

Copied!

测试submit

private static void method1(ExecutorService pool) throws InterruptedException, ExecutionException {
    Future<String> future = pool.submit(() -> {
        log.debug("running");
        Thread.sleep(1000);
        return "ok";
    });

    log.debug("{}", future.get());
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService pool = Executors.newFixedThreadPool(1);
    method1(pool);
}

Copied!

测试结果

1
2

18:36:58.033 c.TestSubmit [pool-1-thread-1] - running
18:36:59.034 c.TestSubmit [main] - ok

Copied!

测试invokeAll

private static void method2(ExecutorService pool) throws InterruptedException {
    List<Future<String>> futures = pool.invokeAll(Arrays.asList(
        () -> {
            log.debug("begin");
            Thread.sleep(1000);
            return "1";
        },
        () -> {
            log.debug("begin");
            Thread.sleep(500);
            return "2";
        },
        () -> {
            log.debug("begin");
            Thread.sleep(2000);
            return "3";
        }
    ));

    futures.forEach( f ->  {
        try {
            log.debug("{}", f.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    });
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService pool = Executors.newFixedThreadPool(1);
    method2(pool);
}

Copied!

测试结果

19:33:16.530 c.TestSubmit [pool-1-thread-1] - begin
19:33:17.530 c.TestSubmit [pool-1-thread-1] - begin
19:33:18.040 c.TestSubmit [pool-1-thread-1] - begin
19:33:20.051 c.TestSubmit [main] - 1
19:33:20.051 c.TestSubmit [main] - 2
19:33:20.051 c.TestSubmit [main] - 3

Copied!

测试invokeAny

private static void method3(ExecutorService pool) throws InterruptedException, ExecutionException {
    String result = pool.invokeAny(Arrays.asList(
        () -> {
            log.debug("begin 1");
            Thread.sleep(1000);
            log.debug("end 1");
            return "1";
        },
        () -> {
            log.debug("begin 2");
            Thread.sleep(500);
            log.debug("end 2");
            return "2";
        },
        () -> {
            log.debug("begin 3");
            Thread.sleep(2000);
            log.debug("end 3");
            return "3";
        }
    ));
    log.debug("{}", result);
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService pool = Executors.newFixedThreadPool(3);
    //ExecutorService pool = Executors.newFixedThreadPool(1);
    method3(pool);
}

Copied!

测试结果

19:44:46.314 c.TestSubmit [pool-1-thread-1] - begin 1
19:44:46.314 c.TestSubmit [pool-1-thread-3] - begin 3
19:44:46.314 c.TestSubmit [pool-1-thread-2] - begin 2
19:44:46.817 c.TestSubmit [pool-1-thread-2] - end 2
19:44:46.817 c.TestSubmit [main] - 2

19:47:16.063 c.TestSubmit [pool-1-thread-1] - begin 1
19:47:17.063 c.TestSubmit [pool-1-thread-1] - end 1
19:47:17.063 c.TestSubmit [pool-1-thread-1] - begin 2
19:47:17.063 c.TestSubmit [main] - 1

Copied!

关闭线程池

shutdown

/*
线程池状态变为 SHUTDOWN
- 不会接收新任务
- 但已提交任务会执行完
- 此方法不会阻塞调用线程的执行
*/
void shutdown();

Copied!

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改线程池状态
        advanceRunState(SHUTDOWN);
        // 仅会打断空闲线程
        interruptIdleWorkers();
        onShutdown(); // 扩展点 ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    // 尝试终结(没有运行的线程可以立刻终结，如果还有运行的线程也不会等)
    tryTerminate();
}

Copied!

shutdownNow

/*
线程池状态变为 STOP
- 不会接收新任务
- 会将队列中的任务返回
- 并用 interrupt 的方式中断正在执行的任务
*/
List<Runnable> shutdownNow();

Copied!

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改线程池状态
        advanceRunState(STOP);
        // 打断所有线程
        interruptWorkers();
        // 获取队列中剩余任务
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    // 尝试终结
    tryTerminate();
    return tasks;
}

Copied!

其他方法

// 不在 RUNNING 状态的线程池，此方法就返回 true
boolean isShutdown();
// 线程池状态是否是 TERMINATED
boolean isTerminated();
// 调用 shutdown 后，由于调用线程并不会等待所有任务运行结束，因此如果它想在线程池 TERMINATED 后做些事情，可以利用此方法等待
// 一般task是Callable类型的时候不用此方法，因为futureTask.get方法自带等待功能。
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

Copied!

测试shutdown、shutdownNow、awaitTermination

@Slf4j(topic = "c.TestShutDown")
public class TestShutDown {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(2);

        Future<Integer> result1 = pool.submit(() -> {
            log.debug("task 1 running...");
            Thread.sleep(1000);
            log.debug("task 1 finish...");
            return 1;
        });

        Future<Integer> result2 = pool.submit(() -> {
            log.debug("task 2 running...");
            Thread.sleep(1000);
            log.debug("task 2 finish...");
            return 2;
        });

        Future<Integer> result3 = pool.submit(() -> {
            log.debug("task 3 running...");
            Thread.sleep(1000);
            log.debug("task 3 finish...");
            return 3;
        });

        log.debug("shutdown");
        pool.shutdown();
        //        pool.awaitTermination(3, TimeUnit.SECONDS);
        //        List<Runnable> runnables = pool.shutdownNow();
        //        log.debug("other.... {}" , runnables);
    }
}

Copied!

测试结果

#shutdown依旧会执行剩下的任务
20:09:13.285 c.TestShutDown [main] - shutdown
20:09:13.285 c.TestShutDown [pool-1-thread-1] - task 1 running...
20:09:13.285 c.TestShutDown [pool-1-thread-2] - task 2 running...
20:09:14.293 c.TestShutDown [pool-1-thread-2] - task 2 finish...
20:09:14.293 c.TestShutDown [pool-1-thread-1] - task 1 finish...
20:09:14.293 c.TestShutDown [pool-1-thread-2] - task 3 running...
20:09:15.303 c.TestShutDown [pool-1-thread-2] - task 3 finish...
#shutdownNow立刻停止所有任务
20:11:11.750 c.TestShutDown [main] - shutdown
20:11:11.750 c.TestShutDown [pool-1-thread-1] - task 1 running...
20:11:11.750 c.TestShutDown [pool-1-thread-2] - task 2 running...
20:11:11.750 c.TestShutDown [main] - other.... [java.util.concurrent.FutureTask@66d33a]

Copied!

*模式之 Worker Thread

定义

让有限的工作线程（Worker Thread）来轮流异步处理无限多的任务。也可以将其归类为分工模式，它的典型实现就是线程池，也体现了经典设计模式中的享元模式。

例如，海底捞的服务员（线程），轮流处理每位客人的点餐（任务），如果为每位客人都配一名专属的服务员，那么成本就太高了（对比另一种多线程设计模式：Thread-Per-Message）

注意，不同任务类型应该使用不同的线程池，这样能够避免饥饿，并能提升效率

例如，如果一个餐馆的工人既要招呼客人（任务类型A），又要到后厨做菜（任务类型B）显然效率不咋地，分成服务员（线程池A）与厨师（线程池B）更为合理，当然你能想到更细致的分工

饥饿

固定大小线程池会有饥饿现象

两个工人是同一个线程池中的两个线程
他们要做的事情是：为客人点餐和到后厨做菜，这是两个阶段的工作
- 客人点餐：必须先点完餐，等菜做好，上菜，在此期间处理点餐的工人必须等待
- 后厨做菜：没啥说的，做就是了
比如工人A 处理了点餐任务，接下来它要等着工人B 把菜做好，然后上菜，他俩也配合的蛮好
但现在同时来了两个客人，这个时候工人A 和工人B 都去处理点餐了，这时没人做饭了，饥饿

public class TestDeadLock {
    static final List<String> MENU = Arrays.asList("地三鲜", "宫保鸡丁", "辣子鸡丁", "烤鸡翅");
    static Random RANDOM = new Random();
    static String cooking() {
        return MENU.get(RANDOM.nextInt(MENU.size()));
    }
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(() -> {
            log.debug("处理点餐...");
            Future<String> f = executorService.submit(() -> {
                log.debug("做菜");
                return cooking();
            });
            try {
                log.debug("上菜: {}", f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
        /*
        executorService.execute(() -> {
            log.debug("处理点餐...");
            Future<String> f = executorService.submit(() -> {
                log.debug("做菜");
                return cooking();
            });
            try {
                log.debug("上菜: {}", f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
        */
    }
}

Copied!

输出

1
2
3

17:21:27.883 c.TestDeadLock [pool-1-thread-1] - 处理点餐...
17:21:27.891 c.TestDeadLock [pool-1-thread-2] - 做菜
17:21:27.891 c.TestDeadLock [pool-1-thread-1] - 上菜: 烤鸡翅

Copied!

当注释取消后，可能的输出

1
2

17:08:41.339 c.TestDeadLock [pool-1-thread-2] - 处理点餐...  
17:08:41.339 c.TestDeadLock [pool-1-thread-1] - 处理点餐...

Copied!

解决方法可以增加线程池的大小，不过不是根本解决方案，还是前面提到的，不同的任务类型，采用不同的线程池，例如：

public class TestDeadLock {
    static final List<String> MENU = Arrays.asList("地三鲜", "宫保鸡丁", "辣子鸡丁", "烤鸡翅");
    static Random RANDOM = new Random();
    static String cooking() {
        return MENU.get(RANDOM.nextInt(MENU.size()));
    }
    public static void main(String[] args) {
        ExecutorService waiterPool = Executors.newFixedThreadPool(1);
        ExecutorService cookPool = Executors.newFixedThreadPool(1);
        waiterPool.execute(() -> {
            log.debug("处理点餐...");
            Future<String> f = cookPool.submit(() -> {
                log.debug("做菜");
                return cooking();
            });
            try {
                log.debug("上菜: {}", f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
        waiterPool.execute(() -> {
            log.debug("处理点餐...");
            Future<String> f = cookPool.submit(() -> {
                log.debug("做菜");
                return cooking();
            });
            try {
                log.debug("上菜: {}", f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
    }
}

Copied!

输出

17:25:14.626 c.TestDeadLock [pool-1-thread-1] - 处理点餐... 
17:25:14.630 c.TestDeadLock [pool-2-thread-1] - 做菜
17:25:14.631 c.TestDeadLock [pool-1-thread-1] - 上菜: 地三鲜
17:25:14.632 c.TestDeadLock [pool-1-thread-1] - 处理点餐... 
17:25:14.632 c.TestDeadLock [pool-2-thread-1] - 做菜
17:25:14.632 c.TestDeadLock [pool-1-thread-1] - 上菜: 辣子鸡丁

Copied!

创建多少线程池合适

过小会导致程序不能充分地利用系统资源、容易导致饥饿
过大会导致更多的线程上下文切换，占用更多内存

CPU 密集型运算

通常采用 cpu 核数 + 1 能够实现最优的 CPU 利用率，+1 是保证当线程由于页缺失故障（操作系统）或其它原因导致暂停时，额外的这个线程就能顶上去，保证 CPU 时钟周期不被浪费

I/O 密集型运算

CPU 不总是处于繁忙状态，例如，当你执行业务计算时，这时候会使用 CPU 资源，但当你执行 I/O 操作时、远程 RPC 调用时，包括进行数据库操作时，这时候 CPU 就闲下来了，你可以利用多线程提高它的利用率。

经验公式如下

线程数 = 核数 * 期望 CPU 利用率 * 总时间(CPU计算时间+等待时间) / CPU 计算时间

例如 4 核 CPU 计算时间是 50% ，其它等待时间是 50%，期望 cpu 被 100% 利用，套用公式

4 * 100% * 100% / 50% = 8

例如 4 核 CPU 计算时间是 10% ，其它等待时间是 90%，期望 cpu 被 100% 利用，套用公式

4 * 100% * 100% / 10% = 40

任务调度线程池

在『任务调度线程池』功能加入之前(JDK1.3)，可以使用 java.util.Timer 来实现定时功能，Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。

public static void main(String[] args) {
    Timer timer = new Timer();
    TimerTask task1 = new TimerTask() {
        @Override
        public void run() {
            log.debug("task 1");
            sleep(2);
        }
    };
    TimerTask task2 = new TimerTask() {
        @Override
        public void run() {
            log.debug("task 2");
        }
    };
    // 使用 timer 添加两个任务，希望它们都在 1s 后执行
    // 但由于 timer 内只有一个线程来顺序执行队列中的任务，因此『任务1』的延时，影响了『任务2』的执行
    timer.schedule(task1, 1000);
    timer.schedule(task2, 1000);
}

Copied!

输出

1
2
3

20:46:09.444 c.TestTimer [main] - start... 
20:46:10.447 c.TestTimer [Timer-0] - task 1 
20:46:12.448 c.TestTimer [Timer-0] - task 2

Copied!

使用 ScheduledExecutorService 改写：

ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
// 添加两个任务，希望它们都在 1s 后执行
executor.schedule(() -> {
    System.out.println("任务1，执行时间：" + new Date());
    try { Thread.sleep(2000); } catch (InterruptedException e) { }
}, 1000, TimeUnit.MILLISECONDS);
executor.schedule(() -> {
    System.out.println("任务2，执行时间：" + new Date());
}, 1000, TimeUnit.MILLISECONDS);

Copied!

输出

1
2

任务1，执行时间：Thu Jan 03 12:45:17 CST 2019 
任务2，执行时间：Thu Jan 03 12:45:17 CST 2019

Copied!

scheduleAtFixedRate 例子：

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
log.debug("start...");
pool.scheduleAtFixedRate(() -> {
    log.debug("running...");
}, 1, 1, TimeUnit.SECONDS);

Copied!

输出

21:45:43.167 c.TestTimer [main] - start... 
21:45:44.215 c.TestTimer [pool-1-thread-1] - running... 
21:45:45.215 c.TestTimer [pool-1-thread-1] - running... 
21:45:46.215 c.TestTimer [pool-1-thread-1] - running... 
21:45:47.215 c.TestTimer [pool-1-thread-1] - running...

Copied!

scheduleAtFixedRate 例子（任务执行时间超过了间隔时间）：

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
log.debug("start...");
pool.scheduleAtFixedRate(() -> {
    log.debug("running...");
    sleep(2);
}, 1, 1, TimeUnit.SECONDS);

Copied!

输出分析：一开始，延时 1s，接下来，由于任务执行时间 > 间隔时间，间隔被『撑』到了 2s

21:44:30.311 c.TestTimer [main] - start... 
21:44:31.360 c.TestTimer [pool-1-thread-1] - running... 
21:44:33.361 c.TestTimer [pool-1-thread-1] - running... 
21:44:35.362 c.TestTimer [pool-1-thread-1] - running... 
21:44:37.362 c.TestTimer [pool-1-thread-1] - running...

Copied!

scheduleWithFixedDelay 例子：

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
log.debug("start...");
pool.scheduleWithFixedDelay(()-> {
    log.debug("running...");
    sleep(2);
}, 1, 1, TimeUnit.SECONDS);

Copied!

输出分析：一开始，延时 1s，scheduleWithFixedDelay 的间隔是上一个任务结束 <-> 延时 <-> 下一个任务开始所以间隔都是 3s

21:40:55.078 c.TestTimer [main] - start... 
21:40:56.140 c.TestTimer [pool-1-thread-1] - running... 
21:40:59.143 c.TestTimer [pool-1-thread-1] - running... 
21:41:02.145 c.TestTimer [pool-1-thread-1] - running... 
21:41:05.147 c.TestTimer [pool-1-thread-1] - running...

Copied!

评价整个线程池表现为：线程数固定，任务数多于线程数时，会放入无界队列排队。任务执行完毕，这些线程也不会被释放。用来执行延迟或反复执行的任务

正确处理执行任务异常

不论是哪个线程池，在线程执行的任务发生异常后既不会抛出，也不会捕获，这时就需要我们做一定的处理。

方法1：主动捉异常

ExecutorService pool = Executors.newFixedThreadPool(1);
pool.submit(() -> {
    try {
        log.debug("task1");
        int i = 1 / 0;
    } catch (Exception e) {
        log.error("error:", e);
    }
});

Copied!

输出

21:59:04.558 c.TestTimer [pool-1-thread-1] - task1 
21:59:04.562 c.TestTimer [pool-1-thread-1] - error: 
java.lang.ArithmeticException: / by zero 
 at cn.itcast.n8.TestTimer.lambda$main$0(TestTimer.java:28) 
 at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) 
 at java.util.concurrent.FutureTask.run(FutureTask.java:266) 
 at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) 
 at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
 at java.lang.Thread.run(Thread.java:748)

Copied!

方法2：使用 Future

说明：

lambda表达式内要有返回值，编译器才能将其识别为Callable，否则将识别为Runnable，也就不能用FutureTask
方法中如果出异常，futuretask.get会返回这个异常，否者正常返回。

ExecutorService pool = Executors.newFixedThreadPool(1);
Future<Boolean> f = pool.submit(() -> {
    log.debug("task1");
    int i = 1 / 0;
    return true;
});
log.debug("result:{}", f.get());

Copied!

输出

21:54:58.208 c.TestTimer [pool-1-thread-1] - task1 
Exception in thread "main" java.util.concurrent.ExecutionException: 
java.lang.ArithmeticException: / by zero 
 at java.util.concurrent.FutureTask.report(FutureTask.java:122) 
 at java.util.concurrent.FutureTask.get(FutureTask.java:192) 
 at cn.itcast.n8.TestTimer.main(TestTimer.java:31) 
Caused by: java.lang.ArithmeticException: / by zero 
 at cn.itcast.n8.TestTimer.lambda$main$0(TestTimer.java:28) 
 at java.util.concurrent.FutureTask.run(FutureTask.java:266) 
 at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) 
 at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
 at java.lang.Thread.run(Thread.java:748)

Copied!

* 应用之定时任务

如何让每周四 18:00:00 定时执行任务？

// 获得当前时间
LocalDateTime now = LocalDateTime.now();
// 获取本周四 18:00:00.000
LocalDateTime thursday = 
    now.with(DayOfWeek.THURSDAY).withHour(18).withMinute(0).withSecond(0).withNano(0);
// 如果当前时间已经超过 本周四 18:00:00.000， 那么找下周四 18:00:00.000
if(now.compareTo(thursday) >= 0) {
    thursday = thursday.plusWeeks(1);
}
// 计算时间差，即延时执行时间
long initialDelay = Duration.between(now, thursday).toMillis();
// 计算间隔时间，即 1 周的毫秒值
long oneWeek = 7 * 24 * 3600 * 1000;
ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
System.out.println("开始时间：" + new Date());
executor.scheduleAtFixedRate(() -> {
    System.out.println("执行时间：" + new Date());
}, initialDelay, oneWeek, TimeUnit.MILLISECONDS);

Copied!

Tomcat 线程池

Tomcat 在哪里用到了线程池呢

graph LR

subgraph Connector->NIO EndPoint
t1(LimitLatch)
t2(Acceptor)
t3(SocketChannel 1)
t4(SocketChannel 2)
t5(Poller)
subgraph Executor
t7(worker1)
t8(worker2)
end
t1 --> t2
t2 --> t3
t2 --> t4
t3 --有读--> t5
t4 --有读--> t5
t5 --socketProcessor--> t7
t5 --socketProcessor--> t8
end

Copied!

LimitLatch 用来限流，可以控制最大连接个数，类似 J.U.C 中的 Semaphore 后面再讲
Acceptor 只负责【接收新的 socket 连接】
Poller 只负责监听 socket channel 是否有【可读的 I/O 事件】
一旦可读，封装一个任务对象（socketProcessor），提交给 Executor 线程池处理
Executor 线程池中的工作线程最终负责【处理请求】

Tomcat 线程池扩展了 ThreadPoolExecutor，行为稍有不同

如果总线程数达到 maximumPoolSize
- 这时不会立刻抛 RejectedExecutionException 异常
- 而是再次尝试将任务放入队列，如果还失败，才抛出 RejectedExecutionException 异常

源码 tomcat-7.0.42

public void execute(Runnable command, long timeout, TimeUnit unit) {
    submittedCount.incrementAndGet();
    try {
        super.execute(command);
    } catch (RejectedExecutionException rx) {
        if (super.getQueue() instanceof TaskQueue) {
            final TaskQueue queue = (TaskQueue)super.getQueue();
            try {
                if (!queue.force(command, timeout, unit)) {
                    submittedCount.decrementAndGet();
                    throw new RejectedExecutionException("Queue capacity is full.");
                }
            } catch (InterruptedException x) {
                submittedCount.decrementAndGet();
                Thread.interrupted();
                throw new RejectedExecutionException(x);
            }
        } else {
            submittedCount.decrementAndGet();
            throw rx;
        }
    }
}

Copied!

TaskQueue.java

public boolean force(Runnable o, long timeout, TimeUnit unit) throws InterruptedException {
    if ( parent.isShutdown() ) 
        throw new RejectedExecutionException(
        "Executor not running, can't force a command into the queue"
    );
    return super.offer(o,timeout,unit); //forces the item onto the queue, to be used if the task 
    is rejected
}

Copied!

Connector 配置

配置项	默认值	说明
`acceptorThreadCount`	1	acceptor 线程数量
`pollerThreadCount`	1	poller 线程数量
`minSpareThreads`	10	核心线程数，即 corePoolSize
`maxThreads`	200	最大线程数，即 maximumPoolSize
`executor`	-	Executor 名称，用来引用下面的 Executor

Executor 线程配置

配置项	默认值	说明
`threadPriority`	5	线程优先级
`deamon`	true	是否守护线程
`minSpareThreads`	25	核心线程数，即corePoolSize
`maxThreads`	200	最大线程数，即 maximumPoolSize
`maxIdleTime`	60000	线程生存时间，单位是毫秒，默认值即 1 分钟
`maxQueueSize`	Integer.MAX_VALUE	队列长度
`prestartminSpareThreads`	false	核心线程是否在服务器启动时启动

Fork/Join

概念

Fork/Join 是 JDK 1.7 加入的新的线程池实现，它体现的是一种分治思想，适用于能够进行任务拆分的 cpu 密集型运算

所谓的任务拆分，是将一个大任务拆分为算法上相同的小任务，直至不能拆分可以直接求解。跟递归相关的一些计算，如归并排序、斐波那契数列、都可以用分治思想进行求解

Fork/Join 在分治的基础上加入了多线程，可以把每个任务的分解和合并交给不同的线程来完成，进一步提升了运算效率

Fork/Join 默认会创建与 cpu 核心数大小相同的线程池

应用之求和

提交给 Fork/Join 线程池的任务需要继承 RecursiveTask（有返回值）或 RecursiveAction（没有返回值），例如下面定义了一个对 1~n 之间的整数求和的任务

@Slf4j(topic = "c.AddTask")
class AddTask1 extends RecursiveTask<Integer> {
    int n;
    public AddTask1(int n) {
        this.n = n;
    }
    @Override
    public String toString() {
        return "{" + n + '}';
    }
    @Override
    protected Integer compute() {
        // 如果 n 已经为 1，可以求得结果了
        if (n == 1) {
            log.debug("join() {}", n);
            return n;
        }

        // 将任务进行拆分(fork)
        AddTask1 t1 = new AddTask1(n - 1);
        t1.fork();
        log.debug("fork() {} + {}", n, t1);

        // 合并(join)结果
        int result = n + t1.join();
        log.debug("join() {} + {} = {}", n, t1, result);
        return result;
    }
}

Copied!

然后提交给 ForkJoinPool 来执行

public static void main(String[] args) {
    ForkJoinPool pool = new ForkJoinPool(4);
    System.out.println(pool.invoke(new AddTask1(5)));
}

Copied!

结果

[ForkJoinPool-1-worker-0] - fork() 2 + {1} 
[ForkJoinPool-1-worker-1] - fork() 5 + {4} 
[ForkJoinPool-1-worker-0] - join() 1 
[ForkJoinPool-1-worker-0] - join() 2 + {1} = 3 
[ForkJoinPool-1-worker-2] - fork() 4 + {3} 
[ForkJoinPool-1-worker-3] - fork() 3 + {2} 
[ForkJoinPool-1-worker-3] - join() 3 + {2} = 6 
[ForkJoinPool-1-worker-2] - join() 4 + {3} = 10 
[ForkJoinPool-1-worker-1] - join() 5 + {4} = 15 
15

Copied!

用图来表示

改进

class AddTask3 extends RecursiveTask<Integer> {

    int begin;
    int end;
    public AddTask3(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }
    @Override
    public String toString() {
        return "{" + begin + "," + end + '}';
    }
    @Override
    protected Integer compute() {
        // 5, 5
        if (begin == end) {
            log.debug("join() {}", begin);
            return begin;
        }
        // 4, 5
        if (end - begin == 1) {
            log.debug("join() {} + {} = {}", begin, end, end + begin);
            return end + begin;
        }

        // 1 5
        int mid = (end + begin) / 2; // 3
        AddTask3 t1 = new AddTask3(begin, mid); // 1,3
        t1.fork();
        AddTask3 t2 = new AddTask3(mid + 1, end); // 4,5
        t2.fork();
        log.debug("fork() {} + {} = ?", t1, t2);
        int result = t1.join() + t2.join();
        log.debug("join() {} + {} = {}", t1, t2, result);
        return result;
    }
}

Copied!

然后提交给 ForkJoinPool 来执行

public static void main(String[] args) {
    ForkJoinPool pool = new ForkJoinPool(4);
    System.out.println(pool.invoke(new AddTask3(1, 10)));
}

Copied!

结果

[ForkJoinPool-1-worker-0] - join() 1 + 2 = 3 
[ForkJoinPool-1-worker-3] - join() 4 + 5 = 9 
[ForkJoinPool-1-worker-0] - join() 3 
[ForkJoinPool-1-worker-1] - fork() {1,3} + {4,5} = ? 
[ForkJoinPool-1-worker-2] - fork() {1,2} + {3,3} = ? 
[ForkJoinPool-1-worker-2] - join() {1,2} + {3,3} = 6 
[ForkJoinPool-1-worker-1] - join() {1,3} + {4,5} = 15 
15

Copied!

用图来表示

*AQS 原理

概述

全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架

特点：

用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁
- getState - 获取 state 状态
- setState - 设置 state 状态
- compareAndSetState - cas 机制设置 state 状态
- 独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源
提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList
条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet

子类主要实现这样一些方法（默认抛出 UnsupportedOperationException）

tryAcquire
tryRelease
tryAcquireShared
tryReleaseShared
isHeldExclusively

获取锁的姿势

// 如果获取锁失败
if (!tryAcquire(arg)) {
    // 入队, 可以选择阻塞当前线程 park unpark
}

Copied!

释放锁的姿势

// 如果释放锁成功
if (tryRelease(arg)) {
    // 让阻塞线程恢复运行
}

Copied!

实现不可重入锁

自定义同步器

final class MySync extends AbstractQueuedSynchronizer {
    @Override
    protected boolean tryAcquire(int acquires) {
        if (acquires == 1){
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
        }
        return false;
    }
    @Override
    protected boolean tryRelease(int acquires) {
        if(acquires == 1) {
            if(getState() == 0) {
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        return false;
    }
    protected Condition newCondition() {
        return new ConditionObject();
    }
    @Override
    protected boolean isHeldExclusively() {
        return getState() == 1;
    }
}

Copied!

自定义锁

有了自定义同步器，很容易复用 AQS ，实现一个功能完备的自定义锁

class MyLock implements Lock {
    static MySync sync = new MySync();
    @Override
    // 尝试，不成功，进入等待队列
    public void lock() {
        sync.acquire(1);
    }
    @Override
    // 尝试，不成功，进入等待队列，可打断
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
    @Override
    // 尝试一次，不成功返回，不进入队列
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }
    @Override
    // 尝试，不成功，进入等待队列，有时限
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }
    @Override
    // 释放锁
    public void unlock() {
        sync.release(1);
    }
    @Override
    // 生成条件变量
    public Condition newCondition() {
        return sync.newCondition();
    }
}

Copied!

测试一下

MyLock lock = new MyLock();
new Thread(() -> {
    lock.lock();
    try {
        log.debug("locking...");
        sleep(1);
    } finally {
        log.debug("unlocking...");
        lock.unlock();
    }
},"t1").start();
new Thread(() -> {
    lock.lock();
    try {
        log.debug("locking...");
    } finally {
        log.debug("unlocking...");
        lock.unlock();
    }
},"t2").start();

Copied!

输出

22:29:28.727 c.TestAqs [t1] - locking... 
22:29:29.732 c.TestAqs [t1] - unlocking... 
22:29:29.732 c.TestAqs [t2] - locking... 
22:29:29.732 c.TestAqs [t2] - unlocking...

Copied!

不可重入测试

如果改为下面代码，会发现自己也会被挡住（只会打印一次 locking）

lock.lock();
log.debug("locking...");
lock.lock();
log.debug("locking...");

Copied!

心得

起源

早期程序员会自己通过一种同步器去实现另一种相近的同步器，例如用可重入锁去实现信号量，或反之。这显然不够优雅，于是在 JSR166（java 规范提案）中创建了 AQS，提供了这种通用的同步器机制。

目标

AQS 要实现的功能目标

阻塞版本获取锁 acquire 和非阻塞的版本尝试获取锁 tryAcquire
获取锁超时机制
通过打断取消机制
独占机制及共享机制
条件不满足时的等待机制

要实现的性能目标

Instead, the primary performance goal here is scalability: to predictably maintain efficiency even, or especially, when synchronizers are contended.

设计

AQS 的基本思想其实很简单

获取锁的逻辑

while(state 状态不允许获取) {
    if(队列中还没有此线程) {
        入队并阻塞
    }
}
当前线程出队

Copied!

释放锁的逻辑

1
2
3

if(state 状态允许了) {
    恢复阻塞的线程(s)
}

Copied!

要点

原子维护 state 状态
阻塞及恢复线程
维护队列

state 设计
- state 使用 volatile 配合 cas 保证其修改时的原子性
- state 使用了 32bit int 来维护同步状态，因为当时使用 long 在很多平台下测试的结果并不理想

阻塞恢复设计
- 早期的控制线程暂停和恢复的 api 有 suspend 和 resume，但它们是不可用的，因为如果先调用的 resume 那么 suspend 将感知不到
- 解决方法是使用 park & unpark 来实现线程的暂停和恢复，具体原理在之前讲过了，先 unpark 再 park 也没问题
- park & unpark 是针对线程的，而不是针对同步器的，因此控制粒度更为精细
- park 线程还可以通过 interrupt 打断
队列设计
- 使用了 FIFO 先入先出队列，并不支持优先级队列
- 设计时借鉴了 CLH 队列，它是一种单向无锁队列

队列中有 head 和 tail 两个指针节点，都用 volatile 修饰配合 cas 使用，每个节点有 state 维护节点状态入队伪代码，只需要考虑 tail 赋值的原子性

do {
    // 原来的 tail
    Node prev = tail;
    // 用 cas 在原来 tail 的基础上改为 node
} while(tail.compareAndSet(prev, node))

Copied!

出队伪代码

// prev 是上一个节点
while((Node prev=node.prev).state != 唤醒状态) {
}
// 设置头节点
head = node;

Copied!

CLH 好处：

无锁，使用自旋
快速，无阻塞

AQS 在一些方面改进了 CLH

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        // 队列中还没有元素 tail 为 null
        if (t == null) {
            // 将 head 从 null -> dummy
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 将 node 的 prev 设置为原来的 tail
            node.prev = t;
            // 将 tail 从原来的 tail 设置为 node
            if (compareAndSetTail(t, node)) {
                // 原来 tail 的 next 设置为 node
                t.next = node;
                return t;
            }
        }
    }
}

Copied!

主要用到 AQS 的并发工具类

ReentrantLock 原理

非公平锁实现原理

加锁解锁流程

先从构造器开始看，默认为非公平锁实现

1
2
3

public ReentrantLock() {
    sync = new NonfairSync();
}

Copied!

NonfairSync 继承自 AQS 没有竞争时

第一个竞争出现时

Thread-1 执行了

CAS 尝试将 state 由 0 改为 1，结果失败
进入 tryAcquire 逻辑，这时 state 已经是1，结果仍然失败
接下来进入 addWaiter 逻辑，构造 Node 队列
- 图中黄色三角表示该 Node 的 waitStatus 状态，其中 0 为默认正常状态
- Node 的创建是懒惰的
- 其中第一个 Node 称为 Dummy（哑元）或哨兵，用来占位，并不关联线程

当前线程进入 acquireQueued 逻辑

acquireQueued 会在一个死循环中不断尝试获得锁，失败后进入 park 阻塞
如果自己是紧邻着 head（排第二位），那么再次 tryAcquire 尝试获取锁，当然这时 state 仍为 1，失败
进入 shouldParkAfterFailedAcquire 逻辑，将前驱 node，即 head 的 waitStatus 改为 -1，这次返回 false
shouldParkAfterFailedAcquire 执行完毕回到 acquireQueued ，再次 tryAcquire 尝试获取锁，当然这时 state 仍为 1，失败
当再次进入 shouldParkAfterFailedAcquire 时，这时因为其前驱 node 的 waitStatus 已经是 -1，这次返回 true
进入 parkAndCheckInterrupt， Thread-1 park（灰色表示）

再次有多个线程经历上述过程竞争失败，变成这个样子

Thread-0 释放锁，进入 tryRelease 流程，如果成功

设置 exclusiveOwnerThread 为 null
state = 0

当前队列不为 null，并且 head 的 waitStatus = -1，进入 unparkSuccessor 流程

找到队列中离 head 最近的一个 Node（没取消的），unpark 恢复其运行，本例中即为 Thread-1

回到 Thread-1 的 acquireQueued 流程

如果加锁成功（没有竞争），会设置

exclusiveOwnerThread 为 Thread-1，state = 1
head 指向刚刚 Thread-1 所在的 Node，该 Node 清空 Thread
原本的 head 因为从链表断开，而可被垃圾回收

如果这时候有其它线程来竞争（非公平的体现），例如这时有 Thread-4 来了

如果不巧又被 Thread-4 占了先

Thread-4 被设置为 exclusiveOwnerThread，state = 1
Thread-1 再次进入 acquireQueued 流程，获取锁失败，重新进入 park 阻塞

加锁源码

// Sync 继承自 AQS
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    // 加锁实现
    final void lock() {
        // 首先用 cas 尝试（仅尝试一次）将 state 从 0 改为 1, 如果成功表示获得了独占锁
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            // 如果尝试失败，进入 ㈠
            acquire(1);
    }

    // ㈠ AQS 继承过来的方法, 方便阅读, 放在此处
    public final void acquire(int arg) {
        // ㈡ tryAcquire 
        if (
            !tryAcquire(arg) &&
            // 当 tryAcquire 返回为 false 时, 先调用 addWaiter ㈣, 接着 acquireQueued ㈤
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
        ) {
            selfInterrupt();
        }
    }

    // ㈡ 进入 ㈢
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }

    // ㈢ Sync 继承过来的方法, 方便阅读, 放在此处
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        // 如果还没有获得锁
        if (c == 0) {
            // 尝试用 cas 获得, 这里体现了非公平性: 不去检查 AQS 队列
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
        else if (current == getExclusiveOwnerThread()) {
            // state++
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        // 获取失败, 回到调用处
        return false;
    }

    // ㈣ AQS 继承过来的方法, 方便阅读, 放在此处
    //将当前node加入等待队列末尾等待，并返回当前node
    private Node addWaiter(Node mode) {
        // 将当前线程关联到一个 Node 对象上, 模式为独占模式
        Node node = new Node(Thread.currentThread(), mode);
        //非公平同步器中有head和tail两个引用分别指向了等待队列的第一个和最后一个节点
        //pred指的是node的前驱，从队尾插入，所以pred为tail
        Node pred = tail;
        // 如果 tail 不为 null, 说明已经有了等待队列了，cas 尝试将 Node 对象加入 AQS 队列尾部
        if (pred != null) {
            //将node的前驱节点设置为pred
            node.prev = pred;
            //尝试将队列的tial从当前的pred修改为node
            if (compareAndSetTail(pred, node)) {
                // 双向链表
                pred.next = node;
                return node;
            }
        }
        //如果pred为null，说明等待队列还未创建，调用enq方法创建队列
        // 尝试将 Node 加入 AQS, 进入 ㈥
        enq(node);
        return node;
    }

    // ㈥ AQS 继承过来的方法, 方便阅读, 放在此处
    //该方法就是创建等待队列，并将node插入队列的尾部。
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) {
                // 还没有, 设置 head 为哨兵节点（不对应线程，状态为 0）
                if (compareAndSetHead(new Node())) {
                    //将head赋值给tail，head和tail同时指向哨兵节点
                    tail = head;
                }
            } else {
                // cas 尝试将 Node 对象加入 AQS 队列尾部
                //设置node的前驱节点为队列的最后一个节点
                node.prev = t;
                //尝试将队列的尾部从当前的tail设置为node
                if (compareAndSetTail(t, node)) {
                    //将node设为上一个tail的后继节点
                    t.next = node;
                    return t;
                }
            }
        }
    }

    // ㈤ AQS 继承过来的方法, 方便阅读, 放在此处
    //在队列中循环等待，只有当排队排到第一名并且获得了锁才能出队并从方法中退出。
    //返回打断状态
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                //找到当前node的前驱节点
                final Node p = node.predecessor();
                // 上一个节点是 head, 表示轮到自己（当前线程对应的 node）了, 尝试获取
                if (p == head && tryAcquire(arg)) {
                    // 获取成功, 设置自己（当前线程对应的 node）为 head
                    setHead(node);
                    // 上一个节点 help GC
                    p.next = null;
                    failed = false;
                    // 返回中断标记 false
                    return interrupted;
                }
                if (
                    // 判断是否应当 park, 进入 ㈦
                    shouldParkAfterFailedAcquire(p, node) &&
                    // park 等待, 此时 Node 的状态被置为 Node.SIGNAL ㈧
                    parkAndCheckInterrupt()
                ) {
                    interrupted = true;
                }
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    // ㈦ AQS 继承过来的方法, 方便阅读, 放在此处
    //判断acquire失败以后是否应该阻塞等待。从规则上来讲：
    //1.如果前驱节点都阻塞了，那么当前节点也应该阻塞
    //2.如果前驱节点取消，那么应该将前驱节点前移，直到其状态不为取消为止。
    //3.如果前两种情况都不是，尝试将前驱节点状态设为SIGNAL，返回false（不用阻塞，等到下次在阻塞）
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        // 获取上一个节点的状态
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL) {
            // 上一个节点都在阻塞, 那么自己也阻塞好了
            return true;
        }
        // > 0 表示取消状态
        if (ws > 0) {
            // 上一个节点取消, 那么重构删除前面所有取消的节点, 返回到外层循环重试
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            // 这次还没有阻塞
            // 但下次如果重试不成功, 则需要阻塞，这时需要设置上一个节点状态为 Node.SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

    // ㈧ 阻塞当前线程
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }
}

Copied!

注意

是否需要 unpark 是由当前节点的前驱节点的 waitStatus == Node.SIGNAL 来决定，而不是本节点的 waitStatus 决定

总结：

调用lock，尝试将state从0修改为1
- 成功：将owner设为当前线程
- 失败：调用acquire->tryAcquire->nonfairTryAcquire，判断state=0则获得锁，或者state不为0但当前线程持有锁则重入锁，以上两种情况tryAcquire返回true，剩余情况返回false。
  - true：获得锁
  - false：调用acquireQueued(addWaiter(Node.EXCLUSIVE), arg),其中addwiter将关联线程的节点插入AQS队列尾部，进入acquireQueued中的for循环:
    - 如果当前节点是头节点，并尝试获得锁成功，将当前节点设为头节点，清除此节点信息，返回打断标记。
    - 调用shoudParkAfterFailure,第一次调用返回false，并将前驱节点改为-1，第二次循环如果再进入此方法，会进入阻塞并检查打断的方法。

解锁源码

// Sync 继承自 AQS
static final class NonfairSync extends Sync {
    // 解锁实现
    public void unlock() {
        sync.release(1);
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final boolean release(int arg) {
        // 尝试释放锁, 进入 ㈠
        if (tryRelease(arg)) {
            // 队列头节点 unpark
            Node h = head; 
            if (
                // 队列不为 null
                h != null &&
                // waitStatus == Node.SIGNAL 才需要 unpark
                h.waitStatus != 0
            ) {
                // unpark AQS 中等待的线程, 进入 ㈡
                unparkSuccessor(h);
            }
            return true;
        }
        return false;
    }

    // ㈠ Sync 继承过来的方法, 方便阅读, 放在此处
    protected final boolean tryRelease(int releases) {
        // state--
        int c = getState() - releases;
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        // 支持锁重入, 只有 state 减为 0, 才释放成功
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }

    // ㈡ AQS 继承过来的方法, 方便阅读, 放在此处
    private void unparkSuccessor(Node node) {
        // 如果状态为 Node.SIGNAL 尝试重置状态为 0
        // 不成功也可以
        int ws = node.waitStatus;
        if (ws < 0) {
            compareAndSetWaitStatus(node, ws, 0);
        }
        // 找到需要 unpark 的节点, 但本节点从 AQS 队列中脱离, 是由唤醒节点完成的
        Node s = node.next;
        // 不考虑已取消的节点, 从 AQS 队列从后至前找到队列最前面需要 unpark 的节点
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }
}

Copied!

总结：

unlock->syn.release(1)->tryRelease(1),如果当前线程并不持有锁，抛异常。state减去1,如果之后state为0，解锁成功，返回true；如果仍大于0，表示解锁不完全，当前线程依旧持有锁，返回false。
返回true：检查AQS队列第一个节点状态图是否为SIGNAL(意味着有责任唤醒其后记节点)，如果有，调用unparkSuccessor。
- 再unparkSuccessor中，不考虑已取消的节点, 从 AQS 队列从后至前找到队列最前面需要 unpark 的节点，如果有，将其唤醒。
返回false：

可重入原理

当持有锁的线程再次尝试获取锁时，会将state的值加1，state表示锁的重入量。

static final class NonfairSync extends Sync {
    // ...

    // Sync 继承过来的方法, 方便阅读, 放在此处
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
        else if (current == getExclusiveOwnerThread()) {
            // state++
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    protected final boolean tryRelease(int releases) {
        // state-- 
        int c = getState() - releases;
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        // 支持锁重入, 只有 state 减为 0, 才释放成功
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }
}

Copied!

可打断原理

不可打断模式

在此模式下，即使它被打断，仍会驻留在 AQS 队列中，并将打断信号存储在一个interrupt变量中。一直要等到获得锁后方能得知自己被打断了,并且调用selfInterrupt方法打断自己。

// Sync 继承自 AQS
static final class NonfairSync extends Sync {
    // ...

    private final boolean parkAndCheckInterrupt() {
        // 如果打断标记已经是 true, 则 park 会失效
        LockSupport.park(this);
        // interrupted 会清除打断标记
        return Thread.interrupted();
    }

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null;
                    failed = false;
                    // 还是需要获得锁后, 才能返回打断状态
                    return interrupted;
                }
                if (
                    shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()
                ) {
                    // 如果是因为 interrupt 被唤醒, 返回打断状态为 true
                    interrupted = true;
                }
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    public final void acquire(int arg) {
        if (
            !tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
        ) {
            // 如果打断状态为 true
            selfInterrupt();
        }
    }
	
    //响应打断标记，打断自己
    static void selfInterrupt() {
        // 重新产生一次中断
        Thread.currentThread().interrupt();
    }
}

Copied!

可打断模式

此模式下即使线程在等待队列中等待，一旦被打断，就会立刻抛出打断异常。

static final class NonfairSync extends Sync {
    public final void acquireInterruptibly(int arg) throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        // 如果没有获得到锁, 进入 ㈠
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }

    // ㈠ 可打断的获取锁流程
    private void doAcquireInterruptibly(int arg) throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()) {
                    // 在 park 过程中如果被 interrupt 会进入此
                    // 这时候抛出异常, 而不会再次进入 for (;;)
                    throw new InterruptedException();
                }
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
}

Copied!

公平锁实现原理

简而言之，公平与非公平的区别在于，公平锁中的tryAcquire方法被重写了，新来的线程即便得知了锁的state为0，也要先判断等待队列中是否还有线程等待，只有当队列没有线程等待式，才获得锁。

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;
    final void lock() {
        acquire(1);
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final void acquire(int arg) {
        if (
            !tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
        ) {
            selfInterrupt();
        }
    }
    // 与非公平锁主要区别在于 tryAcquire 方法的实现
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            // 先检查 AQS 队列中是否有前驱节点, 没有才去竞争
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

    // ㈠ AQS 继承过来的方法, 方便阅读, 放在此处
    //存疑
    public final boolean hasQueuedPredecessors() {
        Node t = tail;
        Node h = head;
        Node s;
        // h != t 时表示队列中有 Node
        return h != t &&
            (
            // (s = h.next) == null 表示队列中还有没有老二
            (s = h.next) == null ||
            // 或者队列中老二线程不是此线程
            s.thread != Thread.currentThread()
        );
    }
}

Copied!

条件变量实现原理

每个条件变量其实就对应着一个等待队列，其实现类是 ConditionObject

await 流程

开始 Thread-0 持有锁，调用 await，进入 ConditionObject 的 addConditionWaiter 流程

创建新的 Node 状态为 -2（Node.CONDITION），关联 Thread-0，加入等待队列尾部

接下来进入 AQS 的 fullyRelease 流程，释放同步器上的锁

unpark AQS 队列中的下一个节点，竞争锁，假设没有其他竞争线程，那么 Thread-1 竞争成功

park 阻塞 Thread-0

总结：

创建一个节点，关联当前线程，并插入到当前Condition队列的尾部
调用fullRelease，完全释放同步器中的锁，并记录当前线程的锁重入数
唤醒(park)AQS队列中的第一个线程
调用park方法，阻塞当前线程。

signal 流程

假设 Thread-1 要来唤醒 Thread-0

进入 ConditionObject 的 doSignal 流程，取得等待队列中第一个 Node，即 Thread-0 所在 Node

执行 transferForSignal 流程，将该 Node 加入 AQS 队列尾部，将 Thread-0 的 waitStatus 改为 0，Thread-3 的 waitStatus 改为 -1

Thread-1 释放锁，进入 unlock 流程，略

总结：

当前持有锁的线程唤醒等待队列中的线程，调用doSignal或doSignalAll方法，将等待队列中的第一个（或全部）节点插入到AQS队列中的尾部。
将插入的节点的状态从Condition设置为0，将插入节点的前一个节点的状态设置为-1（意味着要承担唤醒后一个节点的责任）
当前线程释放锁，parkAQS队列中的第一个节点线程。

源码

public class ConditionObject implements Condition, java.io.Serializable {
    private static final long serialVersionUID = 1173984872572414699L;

    // 第一个等待节点
    private transient Node firstWaiter;

    // 最后一个等待节点
    private transient Node lastWaiter;
    public ConditionObject() { }
    // ㈠ 添加一个 Node 至等待队列
    private Node addConditionWaiter() {
        Node t = lastWaiter;
        // 所有已取消的 Node 从队列链表删除, 见 ㈡
        if (t != null && t.waitStatus != Node.CONDITION) {
            unlinkCancelledWaiters();
            t = lastWaiter;
        }
        // 创建一个关联当前线程的新 Node, 添加至队列尾部
        Node node = new Node(Thread.currentThread(), Node.CONDITION);
        if (t == null)
            firstWaiter = node;
        else
            t.nextWaiter = node;
        lastWaiter = node;
        return node;
    }
    // 唤醒 - 将没取消的第一个节点转移至 AQS 队列
    private void doSignal(Node first) {
        do {
            // 已经是尾节点了
            if ( (firstWaiter = first.nextWaiter) == null) {
                lastWaiter = null;
            }
            first.nextWaiter = null;
        } while (
            // 将等待队列中的 Node 转移至 AQS 队列, 不成功且还有节点则继续循环 ㈢
            !transferForSignal(first) &&
            // 队列还有节点
            (first = firstWaiter) != null
        );
    }

    // 外部类方法, 方便阅读, 放在此处
    // ㈢ 如果节点状态是取消, 返回 false 表示转移失败, 否则转移成功
    final boolean transferForSignal(Node node) {
        // 如果状态已经不是 Node.CONDITION, 说明被取消了
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
        // 加入 AQS 队列尾部
        Node p = enq(node);
        int ws = p.waitStatus;
        if (
            // 上一个节点被取消
            ws > 0 ||
            // 上一个节点不能设置状态为 Node.SIGNAL
            !compareAndSetWaitStatus(p, ws, Node.SIGNAL) 
        ) {
            // unpark 取消阻塞, 让线程重新同步状态
            LockSupport.unpark(node.thread);
        }
        return true;
    }
    // 全部唤醒 - 等待队列的所有节点转移至 AQS 队列
    private void doSignalAll(Node first) {
        lastWaiter = firstWaiter = null;
        do {
            Node next = first.nextWaiter;
            first.nextWaiter = null;
            transferForSignal(first);
            first = next;
        } while (first != null);
    }

    // ㈡
    private void unlinkCancelledWaiters() {
        // ...
    }
    // 唤醒 - 必须持有锁才能唤醒, 因此 doSignal 内无需考虑加锁
    public final void signal() {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
        if (first != null)
            doSignal(first);
    }
    // 全部唤醒 - 必须持有锁才能唤醒, 因此 doSignalAll 内无需考虑加锁
    public final void signalAll() {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
        if (first != null)
            doSignalAll(first);
    }
    // 不可打断等待 - 直到被唤醒
    public final void awaitUninterruptibly() {
        // 添加一个 Node 至等待队列, 见 ㈠
        Node node = addConditionWaiter();
        // 释放节点持有的锁, 见 ㈣
        int savedState = fullyRelease(node);
        boolean interrupted = false;
        // 如果该节点还没有转移至 AQS 队列, 阻塞
        while (!isOnSyncQueue(node)) {
            // park 阻塞
            LockSupport.park(this);
            // 如果被打断, 仅设置打断状态
            if (Thread.interrupted())
                interrupted = true;
        }
        // 唤醒后, 尝试竞争锁, 如果失败进入 AQS 队列
        if (acquireQueued(node, savedState) || interrupted)
            selfInterrupt();
    }
    private void doSignalAll(Node first) {
        lastWaiter = firstWaiter = null;
        do {
            Node next = first.nextWaiter;
            first.nextWaiter = null;
            transferForSignal(first);
            first = next;
        } while (first != null);
    }

    // ㈡
    private void unlinkCancelledWaiters() {
        // ...
    }
    // 唤醒 - 必须持有锁才能唤醒, 因此 doSignal 内无需考虑加锁
    public final void signal() {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
        if (first != null)
            doSignal(first);
    }
    // 全部唤醒 - 必须持有锁才能唤醒, 因此 doSignalAll 内无需考虑加锁
    public final void signalAll() {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        Node first = firstWaiter;
        if (first != null)
            doSignalAll(first);
    }
    // 不可打断等待 - 直到被唤醒
    public final void awaitUninterruptibly() {
        // 添加一个 Node 至等待队列, 见 ㈠
        Node node = addConditionWaiter();
        // 释放节点持有的锁, 见 ㈣
        int savedState = fullyRelease(node);
        boolean interrupted = false;
        // 如果该节点还没有转移至 AQS 队列, 阻塞
        while (!isOnSyncQueue(node)) {
            // park 阻塞
            LockSupport.park(this);
            // 如果被打断, 仅设置打断状态
            if (Thread.interrupted())
                interrupted = true;
        }
        // 唤醒后, 尝试竞争锁, 如果失败进入 AQS 队列
        if (acquireQueued(node, savedState) || interrupted)
            selfInterrupt();
    }

    // 外部类方法, 方便阅读, 放在此处
    // ㈣ 因为某线程可能重入，需要将 state 全部释放
    final int fullyRelease(Node node) {
        boolean failed = true;
        try {
            int savedState = getState();
            if (release(savedState)) {
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                node.waitStatus = Node.CANCELLED;
        }
    }
    // 打断模式 - 在退出等待时重新设置打断状态
    private static final int REINTERRUPT = 1;
    // 打断模式 - 在退出等待时抛出异常
    private static final int THROW_IE = -1;
    // 判断打断模式
    private int checkInterruptWhileWaiting(Node node) {
        return Thread.interrupted() ?
            (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
        0;
    }
    // ㈤ 应用打断模式
    private void reportInterruptAfterWait(int interruptMode)
        throws InterruptedException {
        if (interruptMode == THROW_IE)
            throw new InterruptedException();
        else if (interruptMode == REINTERRUPT)
            selfInterrupt();
    }
    // 等待 - 直到被唤醒或打断
    public final void await() throws InterruptedException {
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
        // 添加一个 Node 至等待队列, 见 ㈠
        Node node = addConditionWaiter();
        // 释放节点持有的锁
        int savedState = fullyRelease(node);
        int interruptMode = 0;
        // 如果该节点还没有转移至 AQS 队列, 阻塞
        while (!isOnSyncQueue(node)) {
            // park 阻塞
            LockSupport.park(this);
            // 如果被打断, 退出等待队列
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
        }
        // 退出等待队列后, 还需要获得 AQS 队列的锁
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        // 所有已取消的 Node 从队列链表删除, 见 ㈡
        if (node.nextWaiter != null) 
            unlinkCancelledWaiters();
        // 应用打断模式, 见 ㈤
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
    }
    //向Condition中的等待队列中新增节点，并将此节点返回
    private Node addConditionWaiter() {
        Node t = lastWaiter;
        // If lastWaiter is cancelled, clean out.
        if (t != null && t.waitStatus != Node.CONDITION) {
            unlinkCancelledWaiters();
            t = lastWaiter;
        }
        Node node = new Node(Thread.currentThread(), Node.CONDITION);
        if (t == null)
            firstWaiter = node;
        else
            t.nextWaiter = node;
        lastWaiter = node;
        return node;
    }
    
    //判断当前节点是否在同步器中的队列中等待锁
    final boolean isOnSyncQueue(Node node) {
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        if (node.next != null) // If has successor, it must be on queue
            return true;
        /*
         * node.prev can be non-null, but not yet on queue because
         * the CAS to place it on queue can fail. So we have to
         * traverse from tail to make sure it actually made it.  It
         * will always be near the tail in calls to this method, and
         * unless the CAS failed (which is unlikely), it will be
         * there, so we hardly ever traverse much.
         */
        return findNodeFromTail(node);
    }
    // 等待 - 直到被唤醒或打断或超时
    public final long awaitNanos(long nanosTimeout) throws InterruptedException {
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
        // 添加一个 Node 至等待队列, 见 ㈠
        Node node = addConditionWaiter();
        // 释放节点持有的锁
        int savedState = fullyRelease(node);
        // 获得最后期限
        final long deadline = System.nanoTime() + nanosTimeout;
        int interruptMode = 0;
        // 如果该节点还没有转移至 AQS 队列, 阻塞
        while (!isOnSyncQueue(node)) {
            // 已超时, 退出等待队列
            if (nanosTimeout <= 0L) {
                transferAfterCancelledWait(node);
                break;
            }
            // park 阻塞一定时间, spinForTimeoutThreshold 为 1000 ns
            if (nanosTimeout >= spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            // 如果被打断, 退出等待队列
            if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                break;
            nanosTimeout = deadline - System.nanoTime();
        }
        // 退出等待队列后, 还需要获得 AQS 队列的锁
        if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
            interruptMode = REINTERRUPT;
        // 所有已取消的 Node 从队列链表删除, 见 ㈡
        if (node.nextWaiter != null)
            unlinkCancelledWaiters();
        // 应用打断模式, 见 ㈤
        if (interruptMode != 0)
            reportInterruptAfterWait(interruptMode);
        return deadline - System.nanoTime();
    }
    // 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
    public final boolean awaitUntil(Date deadline) throws InterruptedException {
        // ...
    }
    // 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
    public final boolean await(long time, TimeUnit unit) throws InterruptedException {
        // ...
    }
    // 工具方法 省略 ...
}

Copied!

读写锁

ReentrantReadWriteLock

当读操作远远高于写操作时，这时候使用读写锁让读-读可以并发，提高性能。类似于数据库中的select ... from ... lock in share mode

提供一个数据容器类内部分别使用读锁保护数据的 read() 方法，写锁保护数据的 write() 方法

测试

class DataContainer {
    private Object data;
    private ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock r = rw.readLock();
    private ReentrantReadWriteLock.WriteLock w = rw.writeLock();
    public Object read() {
        log.debug("获取读锁...");
        r.lock();
        try {
            log.debug("读取");
            sleep(1);
            return data;
        } finally {
            log.debug("释放读锁...");
            r.unlock();
        }
    }
    public void write() {
        log.debug("获取写锁...");
        w.lock();
        try {
            log.debug("写入");
            sleep(1);
        } finally {
            log.debug("释放写锁...");
            w.unlock();
        }
    }
}

Copied!

测试读锁-读锁可以并发

DataContainer dataContainer = new DataContainer();
new Thread(() -> {
    dataContainer.read();
}, "t1").start();
new Thread(() -> {
    dataContainer.read();
}, "t2").start();

Copied!

输出结果，从这里可以看到 Thread-0 锁定期间，Thread-1 的读操作不受影响

14:05:14.341 c.DataContainer [t2] - 获取读锁... 
14:05:14.341 c.DataContainer [t1] - 获取读锁... 
14:05:14.345 c.DataContainer [t1] - 读取
14:05:14.345 c.DataContainer [t2] - 读取
14:05:15.365 c.DataContainer [t2] - 释放读锁... 
14:05:15.386 c.DataContainer [t1] - 释放读锁...

Copied!

测试读锁-写锁相互阻塞

DataContainer dataContainer = new DataContainer();
new Thread(() -> {
    dataContainer.read();
}, "t1").start();
Thread.sleep(100);
new Thread(() -> {
    dataContainer.write();
}, "t2").start();

Copied!

输出结果

14:04:21.838 c.DataContainer [t1] - 获取读锁... 
14:04:21.838 c.DataContainer [t2] - 获取写锁... 
14:04:21.841 c.DataContainer [t2] - 写入
14:04:22.843 c.DataContainer [t2] - 释放写锁... 
14:04:22.843 c.DataContainer [t1] - 读取
14:04:23.843 c.DataContainer [t1] - 释放读锁...

Copied!

写锁-写锁也是相互阻塞的，这里就不测试了

注意事项

读锁不支持条件变量
重入时升级不支持：即持有读锁的情况下去获取写锁，会导致获取写锁永久等待

r.lock();
try {
    // ...
    w.lock();
    try {
        // ...
    } finally{
        w.unlock();
    }
} finally{
    r.unlock();
}

Copied!

重入时降级支持：即持有写锁的情况下去获取读锁

class CachedData {
    Object data;
    // 是否有效，如果失效，需要重新计算 data
    volatile boolean cacheValid;
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    void processCachedData() {
        rwl.readLock().lock();
        if (!cacheValid) {
            // 获取写锁前必须释放读锁
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            try {
                // 判断是否有其它线程已经获取了写锁、更新了缓存, 避免重复更新
                if (!cacheValid) {
                    data = ...
                        cacheValid = true;
                }
                // 降级为读锁, 释放写锁, 这样能够让其它线程读取缓存
                rwl.readLock().lock();
            } finally {
                rwl.writeLock().unlock();
            }
        }
        // 自己用完数据, 释放读锁 
        try {
            use(data);
        } finally {
            rwl.readLock().unlock();
        }
    }
}

Copied!

* 应用之缓存

缓存更新策略

更新时，是先清缓存还是先更新数据库

先清缓存

先更新数据库

补充一种情况，假设查询线程 A 查询数据时恰好缓存数据由于时间到期失效，或是第一次查询

这种情况的出现几率非常小，见 facebook 论文

读写锁实现一致性缓存

使用读写锁实现一个简单的按需加载缓存

class GenericCachedDao<T> {
    // HashMap 作为缓存非线程安全, 需要保护
    HashMap<SqlPair, T> map = new HashMap<>();
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); 
    GenericDao genericDao = new GenericDao();
    public int update(String sql, Object... params) {
        SqlPair key = new SqlPair(sql, params);
        // 加写锁, 防止其它线程对缓存读取和更改
        lock.writeLock().lock();
        try {
            int rows = genericDao.update(sql, params);
            map.clear();
            return rows;
        } finally {
            lock.writeLock().unlock();
        }
    }
    public T queryOne(Class<T> beanClass, String sql, Object... params) {
        SqlPair key = new SqlPair(sql, params);
        // 加读锁, 防止其它线程对缓存更改
        lock.readLock().lock();
        try {
            T value = map.get(key);
            if (value != null) {
                return value;
            }
        } finally {
            lock.readLock().unlock();
        }
        // 加写锁, 防止其它线程对缓存读取和更改
        lock.writeLock().lock();
        try {
            // get 方法上面部分是可能多个线程进来的, 可能已经向缓存填充了数据
            // 为防止重复查询数据库, 再次验证
            T value = map.get(key);
            if (value == null) {
                // 如果没有, 查询数据库
                value = genericDao.queryOne(beanClass, sql, params);
                map.put(key, value);
            }
            return value;
        } finally {
            lock.writeLock().unlock();
        }
    }
    // 作为 key 保证其是不可变的
    class SqlPair {
        private String sql;
        private Object[] params;
        public SqlPair(String sql, Object[] params) {
            this.sql = sql;
            this.params = params;
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            SqlPair sqlPair = (SqlPair) o;
            return sql.equals(sqlPair.sql) &&
                Arrays.equals(params, sqlPair.params);
        }
        @Override
        public int hashCode() {
            int result = Objects.hash(sql);
            result = 31 * result + Arrays.hashCode(params);
            return result;
        }
    }
}

Copied!

注意

以上实现体现的是读写锁的应用，保证缓存和数据库的一致性，但有下面的问题没有考虑

适合读多写少，如果写操作比较频繁，以上实现性能低

没有考虑缓存容量

没有考虑缓存过期

只适合单机

并发性还是低，目前只会用一把锁

更新方法太过简单粗暴，清空了所有 key（考虑按类型分区或重新设计 key）

乐观锁实现：用 CAS 去更新

* 读写锁原理

图解流程

读写锁用的是同一个 Sycn 同步器，因此等待队列、state 等也是同一个

t1 w.lock，t2 r.lock

1） t1 成功上锁，流程与 ReentrantLock 加锁相比没有特殊之处，不同是写锁状态占了 state 的低 16 位，而读锁使用的是 state 的高 16 位

2）t2 执行 r.lock，这时进入读锁的 sync.acquireShared(1) 流程，首先会进入 tryAcquireShared 流程。如果有写锁占据，那么 tryAcquireShared 返回 -1 表示失败

tryAcquireShared 返回值表示

-1 表示失败

0 表示成功，但后继节点不会继续唤醒

正数表示成功，而且数值是还有几个后继节点需要唤醒，读写锁返回 1

3）这时会进入 sync.doAcquireShared(1) 流程，首先也是调用 addWaiter 添加节点，不同之处在于节点被设置为 Node.SHARED 模式而非 Node.EXCLUSIVE 模式，注意此时 t2 仍处于活跃状态

4）t2 会看看自己的节点是不是老二，如果是，还会再次调用 tryAcquireShared(1) 来尝试获取锁

5）如果没有成功，在 doAcquireShared 内 for (;;) 循环一次，把前驱节点的 waitStatus 改为 -1，再 for (;;) 循环一次尝试 tryAcquireShared(1) 如果还不成功，那么在 parkAndCheckInterrupt() 处 park

t3 r.lock，t4 w.lock

这种状态下，假设又有 t3 加读锁和 t4 加写锁，这期间 t1 仍然持有锁，就变成了下面的样子

t1 w.unlock

这时会走到写锁的 sync.release(1) 流程，调用 sync.tryRelease(1) 成功，变成下面的样子

接下来执行唤醒流程 sync.unparkSuccessor，即让老二恢复运行，这时 t2 在 doAcquireShared 内 parkAndCheckInterrupt() 处恢复运行

这回再来一次 for (;;) 执行 tryAcquireShared 成功则让读锁计数加一

这时 t2 已经恢复运行，接下来 t2 调用 setHeadAndPropagate(node, 1)，它原本所在节点被置为头节点

事情还没完，在 setHeadAndPropagate 方法内还会检查下一个节点是否是 shared，如果是则调用 doReleaseShared() 将 head 的状态从 -1 改为 0 并唤醒老二，这时 t3 在 doAcquireShared 内 parkAndCheckInterrupt() 处恢复运行

这回再来一次 for (;;) 执行 tryAcquireShared 成功则让读锁计数加一

这时 t3 已经恢复运行，接下来 t3 调用 setHeadAndPropagate(node, 1)，它原本所在节点被置为头节点

下一个节点不是 shared 了，因此不会继续唤醒 t4 所在节点

t2 r.unlock，t3 r.unlock

t2 进入 sync.releaseShared(1) 中，调用 tryReleaseShared(1) 让计数减一，但由于计数还不为零

t3 进入 sync.releaseShared(1) 中，调用 tryReleaseShared(1) 让计数减一，这回计数为零了，进入 doReleaseShared() 将头节点从 -1 改为 0 并唤醒老二，即

之后 t4 在 acquireQueued 中 parkAndCheckInterrupt 处恢复运行，再次 for (;;) 这次自己是老二，并且没有其他竞争，tryAcquire(1) 成功，修改头结点，流程结束

源码分析

写锁上锁流程

static final class NonfairSync extends Sync {
    // ... 省略无关代码

    // 外部类 WriteLock 方法, 方便阅读, 放在此处
    public void lock() {
        sync.acquire(1);
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final void acquire(int arg) {
        if (
            // 尝试获得写锁失败
            !tryAcquire(arg) &&
            // 将当前线程关联到一个 Node 对象上, 模式为独占模式
            // 进入 AQS 队列阻塞
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
        ) {
            selfInterrupt();
        }
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    protected final boolean tryAcquire(int acquires) {
        
        Thread current = Thread.currentThread();
        int c = getState();
        // 获得低 16 位, 代表写锁的 state 计数
        int w = exclusiveCount(c);
		//表示有写锁或者有读锁
        if (c != 0) {
            if (
                // c != 0 and w == 0 表示有读锁, 或者
                w == 0 ||
                // 如果 exclusiveOwnerThread 不是自己
                current != getExclusiveOwnerThread()
            ) {
                // 获得锁失败
                return false;
            }
            // 写锁计数超过低 16 位, 报异常
            if (w + exclusiveCount(acquires) > MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            // 写锁重入, 获得锁成功
            setState(c + acquires);
            return true;
        } 
        if (
            // 判断写锁是否该阻塞, 或者
            //非公平锁下，总是返回false
            writerShouldBlock() ||
            // 尝试更改计数失败
            !compareAndSetState(c, c + acquires)
        ) {
            // 获得锁失败
            return false;
        }
        // 获得锁成功
        setExclusiveOwnerThread(current);
        return true;
    }

    // 非公平锁 writerShouldBlock 总是返回 false, 无需阻塞
    final boolean writerShouldBlock() {
        return false;
    }
}

Copied!

总结：

lock -> syn.acquire ->tryAquire
- 如果有锁：
  - 如果是写锁或者锁持有者不为自己，返回false
  - 如果时写锁且为自己持有，则重入
- 如果无锁：
  - 判断无序阻塞并设置state成功后，将owner设为自己，返回true
成功，则获得了锁
失败：
- 调用acquireQueued(addWaiter(Node.EXCLUSIVE), arg)进入阻塞队列，将节点状态设置为EXCLUSIVE，之后的逻辑与之前的aquireQueued类似。

写锁释放流程

static final class NonfairSync extends Sync {
    // ... 省略无关代码

    // WriteLock 方法, 方便阅读, 放在此处
    public void unlock() {
        sync.release(1);
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final boolean release(int arg) {
        // 尝试释放写锁成功
        if (tryRelease(arg)) {
            // unpark AQS 中等待的线程
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    protected final boolean tryRelease(int releases) {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        int nextc = getState() - releases;
        // 因为可重入的原因, 写锁计数为 0, 才算释放成功
        boolean free = exclusiveCount(nextc) == 0;
        if (free) {
            setExclusiveOwnerThread(null);
        }
        setState(nextc);
        return free;
    }
}

Copied!

总结：

unlock->syn.release->tryRelease
- state状态减少
  - 如果减为零，表示解锁成功，返回true
  - 没有减为0，当前线程依旧持有锁
成功：解锁成功
- 如果ASQ队列不为空，则唤醒第一个节点。
失败：解锁失败。

读锁上锁流程

static final class NonfairSync extends Sync {

    // ReadLock 方法, 方便阅读, 放在此处
    public void lock() {
        sync.acquireShared(1);
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final void acquireShared(int arg) {
        // tryAcquireShared 返回负数, 表示获取读锁失败
        //大于0的情况在读写锁这里无区别，后面信号量会做进一步处理。
        if (tryAcquireShared(arg) < 0) {
            doAcquireShared(arg);
        }
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    protected final int tryAcquireShared(int unused) {
        Thread current = Thread.currentThread();
        int c = getState();
        // 如果是其它线程持有写锁, 获取读锁失败
        if ( 
            exclusiveCount(c) != 0 &&
            getExclusiveOwnerThread() != current
        ) {
            return -1;
        }
        int r = sharedCount(c);
        if (
            // 读锁不该阻塞(如果老二是写锁，读锁该阻塞), 并且
            !readerShouldBlock() &&
            // 小于读锁计数, 并且
            r < MAX_COUNT &&
            // 尝试增加计数成功
            compareAndSetState(c, c + SHARED_UNIT)
        ) {
            // ... 省略不重要的代码
            return 1;
        }
        return fullTryAcquireShared(current);
    }

    // 非公平锁 readerShouldBlock 看 AQS 队列中第一个节点是否是写锁
    // true 则该阻塞, false 则不阻塞
    final boolean readerShouldBlock() {
        return apparentlyFirstQueuedIsExclusive();
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    // 与 tryAcquireShared 功能类似, 但会不断尝试 for (;;) 获取读锁, 执行过程中无阻塞
    final int fullTryAcquireShared(Thread current) {
        HoldCounter rh = null;
        for (;;) {
            int c = getState();
            if (exclusiveCount(c) != 0) {
                if (getExclusiveOwnerThread() != current)
                    return -1;
            } else if (readerShouldBlock()) {
                // ... 省略不重要的代码
            }
            if (sharedCount(c) == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            if (compareAndSetState(c, c + SHARED_UNIT)) {
                // ... 省略不重要的代码
                return 1;
            }
        }
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    private void doAcquireShared(int arg) {
        // 将当前线程关联到一个 Node 对象上, 模式为共享模式
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    // 再一次尝试获取读锁
                    int r = tryAcquireShared(arg);
                    // 成功
                    if (r >= 0) {
                        // ㈠
                        // r 表示可用资源数, 在这里总是 1 允许传播
                        //（唤醒 AQS 中下一个 Share 节点）
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                if (
                    // 是否在获取读锁失败时阻塞（前一个阶段 waitStatus == Node.SIGNAL）
                    shouldParkAfterFailedAcquire(p, node) &&
                    // park 当前线程
                    parkAndCheckInterrupt()
                ) {
                    interrupted = true;
                }
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    // ㈠ AQS 继承过来的方法, 方便阅读, 放在此处
    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        // 设置自己为 head
        setHead(node);

        // propagate 表示有共享资源（例如共享读锁或信号量）
        // 原 head waitStatus == Node.SIGNAL 或 Node.PROPAGATE
        // 现在 head waitStatus == Node.SIGNAL 或 Node.PROPAGATE
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            // 如果是最后一个节点或者是等待共享读锁的节点
            if (s == null || s.isShared()) {
                // 进入 ㈡
                doReleaseShared();
            }
        }
    }

    // ㈡ AQS 继承过来的方法, 方便阅读, 放在此处
    private void doReleaseShared() {
        // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一个节点 unpark
        // 如果 head.waitStatus == 0 ==> Node.PROPAGATE, 为了解决 bug, 见后面分析
        for (;;) {
            Node h = head;
            // 队列还有节点
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue; // loop to recheck cases
                    // 下一个节点 unpark 如果成功获取读锁
                    // 并且下下个节点还是 shared, 继续 doReleaseShared
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue; // loop on failed CAS
            }
            if (h == head) // loop if head changed
                break;
        }
    }
}

Copied!

总结：

lock->syn.acquireShare->tryAcquireShare
- 如果其他线程持有写锁：则失败，返回-1
- 否则：判断无需等待后，将state加上一个写锁的单位，返回1
返回值大于等于0：成功
返回值小于0：
- 调用doAcquireShare，类似之前的aquireQueued,将当前线程关联节点，状态设置为SHARE，插入AQS队列尾部。在for循环中判断当前节点的前驱节点是否为头节点
  - 是：调用tryAcquireShare
    - 如果返回值大于等于0，则获取锁成功，并调用setHeadAndPropagate，出队，并不断唤醒AQS队列中的状态为SHARE的节点，直到下一个节点为EXCLUSIVE。记录打断标记，之后退出方法（不返回打断标记）
- 判断是否在失败后阻塞
  - 是：阻塞住，并监测打断信号。
  - 否则：将前驱节点状态设为-1。（下一次循环就又要阻塞了）

读锁释放流程

static final class NonfairSync extends Sync {

    // ReadLock 方法, 方便阅读, 放在此处
    public void unlock() {
        sync.releaseShared(1);
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    protected final boolean tryReleaseShared(int unused) {
        // ... 省略不重要的代码
        for (;;) {
            int c = getState();
            int nextc = c - SHARED_UNIT;
            if (compareAndSetState(c, nextc)) {
                // 读锁的计数不会影响其它获取读锁线程, 但会影响其它获取写锁线程
                // 计数为 0 才是真正释放
                return nextc == 0;
            }
        }
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    private void doReleaseShared() {
        // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一个节点 unpark
        // 如果 head.waitStatus == 0 ==> Node.PROPAGATE 
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                // 如果有其它线程也在释放读锁，那么需要将 waitStatus 先改为 0
                // 防止 unparkSuccessor 被多次执行
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue; // loop to recheck cases
                    unparkSuccessor(h);
                }
                // 如果已经是 0 了，改为 -3，用来解决传播性，见后文信号量 bug 分析
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue; // loop on failed CAS
            }
            if (h == head) // loop if head changed
                break;
        }
    } 
}

Copied!

总结：

unlock->releaseShared->tryReleaseShared,将state减去一个share单元，最后state为0则返回true，不然返回false。
返回tue：调用doReleaseShare,唤醒队列中的节点。
返回false：解锁不完全。

StampedLock

该类自 JDK 8 加入，是为了进一步优化读性能，它的特点是在使用读锁、写锁时都必须配合【戳】使用加解读锁

1
2

long stamp = lock.readLock();
lock.unlockRead(stamp);

Copied!

加解写锁

1
2

long stamp = lock.writeLock();
lock.unlockWrite(stamp);

Copied!

乐观读，StampedLock 支持 tryOptimisticRead() 方法（乐观读），读取完毕后需要做一次戳校验如果校验通过，表示这期间确实没有写操作，数据可以安全使用，如果校验没通过，需要重新获取读锁，保证数据安全。

long stamp = lock.tryOptimisticRead();
// 验戳
if(!lock.validate(stamp)){
    // 锁升级
}

Copied!

提供一个数据容器类内部分别使用读锁保护数据的read()方法，写锁保护数据的write()方法

class DataContainerStamped {
    private int data;
    private final StampedLock lock = new StampedLock();
    public DataContainerStamped(int data) {
        this.data = data;
    }
    public int read(int readTime) {
        //获取戳
        long stamp = lock.tryOptimisticRead();
        log.debug("optimistic read locking...{}", stamp);
        //读取数据
        sleep(readTime);
        //读取数据之后再验戳
        if (lock.validate(stamp)) {
            log.debug("read finish...{}, data:{}", stamp, data);
            return data;
        }
        //如果验戳失败，说明已经数据已经被修改，需要升级锁重新读。
        // 锁升级 - 读锁
        log.debug("updating to read lock... {}", stamp);
        try {
            stamp = lock.readLock();
            log.debug("read lock {}", stamp);
            sleep(readTime);
            log.debug("read finish...{}, data:{}", stamp, data);
            return data;
        } finally {
            log.debug("read unlock {}", stamp);
            lock.unlockRead(stamp);
        }
    }
    public void write(int newData) {
        long stamp = lock.writeLock();
        log.debug("write lock {}", stamp);
        try {
            sleep(2);
            this.data = newData;
        } finally {
            log.debug("write unlock {}", stamp);
            lock.unlockWrite(stamp);
        }
    }
}

Copied!

测试读-读可以优化

public static void main(String[] args) {
    DataContainerStamped dataContainer = new DataContainerStamped(1);
    new Thread(() -> {
        dataContainer.read(1);
    }, "t1").start();
    sleep(0.5);
    new Thread(() -> {
        dataContainer.read(0);
    }, "t2").start();
}

Copied!

输出结果，可以看到实际没有加读锁

15:58:50.217 c.DataContainerStamped [t1] - optimistic read locking...256 
15:58:50.717 c.DataContainerStamped [t2] - optimistic read locking...256 
15:58:50.717 c.DataContainerStamped [t2] - read finish...256, data:1 
15:58:51.220 c.DataContainerStamped [t1] - read finish...256, data:1

Copied!

测试读-写时优化读补加读锁

public static void main(String[] args) {
    DataContainerStamped dataContainer = new DataContainerStamped(1);
    new Thread(() -> {
        dataContainer.read(1);
    }, "t1").start();
    sleep(0.5);
    new Thread(() -> {
        dataContainer.write(100);
    }, "t2").start();
}

Copied!

输出结果

15:57:00.219 c.DataContainerStamped [t1] - optimistic read locking...256 
15:57:00.717 c.DataContainerStamped [t2] - write lock 384 
15:57:01.225 c.DataContainerStamped [t1] - updating to read lock... 256 
15:57:02.719 c.DataContainerStamped [t2] - write unlock 384 
15:57:02.719 c.DataContainerStamped [t1] - read lock 513 
15:57:03.719 c.DataContainerStamped [t1] - read finish...513, data:1000 
15:57:03.719 c.DataContainerStamped [t1] - read unlock 513

Copied!

注意

StampedLock 不支持条件变量

StampedLock 不支持可重入

Semaphore

基本使用

[ˈsɛməˌfɔr] 信号量，用来限制能同时访问共享资源的线程上限。

public static void main(String[] args) {
    // 1. 创建 semaphore 对象
    Semaphore semaphore = new Semaphore(3);
    // 2. 10个线程同时运行
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            // 3. 获取许可
            try {
                semaphore.acquire();
            //对于非打断式获取，如果此过程中被打断，线程依旧会等到获取了信号量之后才进入catch块。
            //catch块中的线程依旧持有信号量，捕获该异常后catch块可以不做任何处理。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                log.debug("running...");
                sleep(1);
                log.debug("end...");
            } finally {
                // 4. 释放许可
                semaphore.release();
            }
        }).start();
    }
}

Copied!

输出

07:35:15.485 c.TestSemaphore [Thread-2] - running... 
07:35:15.485 c.TestSemaphore [Thread-1] - running... 
07:35:15.485 c.TestSemaphore [Thread-0] - running... 
07:35:16.490 c.TestSemaphore [Thread-2] - end... 
07:35:16.490 c.TestSemaphore [Thread-0] - end... 
07:35:16.490 c.TestSemaphore [Thread-1] - end... 
07:35:16.490 c.TestSemaphore [Thread-3] - running... 
07:35:16.490 c.TestSemaphore [Thread-5] - running... 
07:35:16.490 c.TestSemaphore [Thread-4] - running... 
07:35:17.490 c.TestSemaphore [Thread-5] - end... 
07:35:17.490 c.TestSemaphore [Thread-4] - end... 
07:35:17.490 c.TestSemaphore [Thread-3] - end... 
07:35:17.490 c.TestSemaphore [Thread-6] - running... 
07:35:17.490 c.TestSemaphore [Thread-7] - running... 
07:35:17.490 c.TestSemaphore [Thread-9] - running... 
07:35:18.491 c.TestSemaphore [Thread-6] - end... 
07:35:18.491 c.TestSemaphore [Thread-7] - end... 
07:35:18.491 c.TestSemaphore [Thread-9] - end... 
07:35:18.491 c.TestSemaphore [Thread-8] - running... 
07:35:19.492 c.TestSemaphore [Thread-8] - end...

Copied!

说明：

Semaphore有两个构造器：Semaphore(int permits)和Semaphore(int permits,boolean fair)
permits表示允许同时访问共享资源的线程数。
fair表示公平与否，与之前的ReentrantLock一样。

* Semaphore 应用

semaphore 限制对共享资源的使用

使用 Semaphore 限流，在访问高峰期时，让请求线程阻塞，高峰期过去再释放许可，当然它只适合限制单机线程数量，并且仅是限制线程数，而不是限制资源数（例如连接数，请对比 Tomcat LimitLatch 的实现）
用 Semaphore 实现简单连接池，对比『享元模式』下的实现（用wait notify），性能和可读性显然更好，注意下面的实现中线程数和数据库连接数是相等的

@Slf4j(topic = "c.Pool")
class Pool {
    // 1. 连接池大小
    private final int poolSize;
    // 2. 连接对象数组
    private Connection[] connections;
    // 3. 连接状态数组 0 表示空闲， 1 表示繁忙
    private AtomicIntegerArray states;
    private Semaphore semaphore;
    // 4. 构造方法初始化
    public Pool(int poolSize) {
        this.poolSize = poolSize;
        // 让许可数与资源数一致
        this.semaphore = new Semaphore(poolSize);
        this.connections = new Connection[poolSize];
        this.states = new AtomicIntegerArray(new int[poolSize]);
        for (int i = 0; i < poolSize; i++) {
            connections[i] = new MockConnection("连接" + (i+1));
        }
    }
    // 5. 借连接
    public Connection borrow() {// t1, t2, t3
        // 获取许可
        try {
            semaphore.acquire(); // 没有许可的线程，在此等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < poolSize; i++) {
            // 获取空闲连接
            if(states.get(i) == 0) {
                if (states.compareAndSet(i, 0, 1)) {
                    log.debug("borrow {}", connections[i]);
                    return connections[i];
                }
            }
        }
        // 不会执行到这里
        return null;
    }
    // 6. 归还连接
    public void free(Connection conn) {
        for (int i = 0; i < poolSize; i++) {
            if (connections[i] == conn) {
                states.set(i, 0);
                log.debug("free {}", conn);
                semaphore.release();
                break;
            }
        }
    }
}

Copied!

* Semaphore 原理

加锁解锁流程

Semaphore有点像一个停车场，permits就好像停车位数量，当线程获得了permits就像是获得了停车位，然后停车场显示空余车位减一。

刚开始，permits（state）为 3，这时 5 个线程来获取资源

假设其中 Thread-1，Thread-2，Thread-4 cas 竞争成功，而 Thread-0 和 Thread-3 竞争失败，进入 AQS 队列 park 阻塞

这时 Thread-4 释放了 permits，状态如下

接下来 Thread-0 竞争成功，permits 再次设置为 0，设置自己为 head 节点，断开原来的 head 节点，unpark 接下来的 Thread-3 节点，但由于 permits 是 0，因此 Thread-3 在尝试不成功后再次进入 park 状态

源码分析

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = -2694183684443567898L;
    NonfairSync(int permits) {
        // permits 即 state
        super(permits);
    }

    // Semaphore 方法, 方便阅读, 放在此处
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

    // 尝试获得共享锁
    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires);
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    final int nonfairTryAcquireShared(int acquires) {
        for (;;) {
            int available = getState();
            int remaining = available - acquires; 
            if (
                // 如果许可已经用完, 返回负数, 表示获取失败, 进入 doAcquireSharedInterruptibly
                remaining < 0 ||
                // 如果 cas 重试成功, 返回正数, 表示获取成功
                compareAndSetState(available, remaining)
            ) {
                return remaining;
            }
        }
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    // 再次尝试获取许可
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 成功后本线程出队（AQS）, 所在 Node设置为 head
                        // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一个节点 unpark
                        // 如果 head.waitStatus == 0 ==> Node.PROPAGATE 
                        // r 表示可用资源数, 为 0 则不会继续传播
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                // 不成功, 设置上一个节点 waitStatus = Node.SIGNAL, 下轮进入 park 阻塞
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    // Semaphore 方法, 方便阅读, 放在此处
    public void release() {
        sync.releaseShared(1);
    }

    // AQS 继承过来的方法, 方便阅读, 放在此处
    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

    // Sync 继承过来的方法, 方便阅读, 放在此处
    protected final boolean tryReleaseShared(int releases) {
        for (;;) {
            int current = getState();
            int next = current + releases;
            if (next < current) // overflow
                throw new Error("Maximum permit count exceeded");
            if (compareAndSetState(current, next))
                return true;
        }
    }
}
private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    // 设置自己为 head
    setHead(node);
    // propagate 表示有共享资源（例如共享读锁或信号量）
    // 原 head waitStatus == Node.SIGNAL 或 Node.PROPAGATE
    // 现在 head waitStatus == Node.SIGNAL 或 Node.PROPAGATE
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        // 如果是最后一个节点或者是等待共享读锁的节点
        if (s == null || s.isShared()) {
            doReleaseShared();
        }
    }
}
private void doReleaseShared() {
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

Copied!

加锁流程总结：

acquire->acquireSharedInterruptibly(1)->tryAcquireShared(1)->nonfairTryAcquireShared(1),如果资源用完了，返回负数，tryAcquireShared返回负数，表示失败。否则返回正数，tryAcquireShared返回正数,表示成功。
- 如果成功，获取信号量成功。
- 如果失败，调用doAcquireSharedInterruptibly,进入for循环：
  - 如果当前驱节点为头节点，调用tryAcquireShared尝试获取锁
    - 如果结果大于等于0，表明获取锁成功，调用setHeadAndPropagate，将当前节点设为头节点，之后又调用doReleaseShared，唤醒后继节点。
  - 调用shoudParkAfterFailure,第一次调用返回false，并将前驱节点改为-1，第二次循环如果再进入此方法，会进入阻塞并检查打断的方法。

解锁流程总结：

release->sync.releaseShared(1)->tryReleaseShared(1),只要不发生整数溢出，就返回true
- 如果返回true，调用doReleaseShared，唤醒后继节点。
- 如果返回false，解锁失败。

为什么要有 PROPAGATE

CountdownLatch

用来进行线程同步协作，等待所有线程完成倒计时。

其中构造参数用来初始化等待计数值，await() 用来等待计数归零，countDown() 用来让计数减一

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(3);
    new Thread(() -> {
        log.debug("begin...");
        sleep(1);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    new Thread(() -> {
        log.debug("begin...");
        sleep(2);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    new Thread(() -> {
        log.debug("begin...");
        sleep(1.5);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    log.debug("waiting...");
    latch.await();
    log.debug("wait end...");
}

Copied!

输出

18:44:00.778 c.TestCountDownLatch [main] - waiting... 
18:44:00.778 c.TestCountDownLatch [Thread-2] - begin... 
18:44:00.778 c.TestCountDownLatch [Thread-0] - begin... 
18:44:00.778 c.TestCountDownLatch [Thread-1] - begin... 
18:44:01.782 c.TestCountDownLatch [Thread-0] - end...2 
18:44:02.283 c.TestCountDownLatch [Thread-2] - end...1 
18:44:02.782 c.TestCountDownLatch [Thread-1] - end...0 
18:44:02.782 c.TestCountDownLatch [main] - wait end...

Copied!

相比于join，CountDownLatch能配合线程池使用。

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(3);
    ExecutorService service = Executors.newFixedThreadPool(4);
    service.submit(() -> {
        log.debug("begin...");
        sleep(1);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    });
    service.submit(() -> {
        log.debug("begin...");
        sleep(1.5);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    });
    service.submit(() -> {
        log.debug("begin...");
        sleep(2);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    });
    service.submit(()->{
        try {
            log.debug("waiting...");
            latch.await();
            log.debug("wait end...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

Copied!

* 应用之同步等待多线程准备完毕

AtomicInteger num = new AtomicInteger(0);
ExecutorService service = Executors.newFixedThreadPool(10, (r) -> {
    return new Thread(r, "t" + num.getAndIncrement());
});
CountDownLatch latch = new CountDownLatch(10);
String[] all = new String[10];
Random r = new Random();
for (int j = 0; j < 10; j++) {
    int x = j;
    service.submit(() -> {
        for (int i = 0; i <= 100; i++) {
            try {
                //随机休眠，模拟网络延迟
                Thread.sleep(r.nextInt(100));
            } catch (InterruptedException e) {
            }
            all[x] = Thread.currentThread().getName() + "(" + (i + "%") + ")";
            //\r可以让当前输出覆盖上一次的输出。
            System.out.print("\r" + Arrays.toString(all));
        }
        latch.countDown();
    });
}
latch.await();
System.out.println("\n游戏开始...");
service.shutdown();

Copied!

中间输出

`1`	`[t0(52%), t1(47%), t2(51%), t3(40%), t4(49%), t5(44%), t6(49%), t7(52%), t8(46%), t9(46%)]`

Copied!

最后输出

1
2
3

[t0(100%), t1(100%), t2(100%), t3(100%), t4(100%), t5(100%), t6(100%), t7(100%), t8(100%), 
t9(100%)] 
游戏开始...

Copied!

* 应用之同步等待多个远程调用结束

@RestController
public class TestCountDownlatchController {
    @GetMapping("/order/{id}")
    public Map<String, Object> order(@PathVariable int id) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("id", id);
        map.put("total", "2300.00");
        sleep(2000);
        return map;
    }
    @GetMapping("/product/{id}")
    public Map<String, Object> product(@PathVariable int id) {
        HashMap<String, Object> map = new HashMap<>();
        if (id == 1) {
            map.put("name", "小爱音箱");
            map.put("price", 300);
        } else if (id == 2) {
            map.put("name", "小米手机");
            map.put("price", 2000);
        }
        map.put("id", id);
        sleep(1000);
        return map;
    }
    @GetMapping("/logistics/{id}")
    public Map<String, Object> logistics(@PathVariable int id) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("id", id);
        map.put("name", "中通快递");
        sleep(2500);
        return map;
    }
    private void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Copied!

rest远程调用

RestTemplate restTemplate = new RestTemplate();
log.debug("begin");
ExecutorService service = Executors.newCachedThreadPool();
CountDownLatch latch = new CountDownLatch(4);
Future<Map<String,Object>> f1 = service.submit(() -> {
    Map<String, Object> r =
        restTemplate.getForObject("http://localhost:8080/order/{1}", Map.class, 1);
    return r;
});
Future<Map<String, Object>> f2 = service.submit(() -> {
    Map<String, Object> r =
        restTemplate.getForObject("http://localhost:8080/product/{1}", Map.class, 1);
    return r;
});
Future<Map<String, Object>> f3 = service.submit(() -> {
    Map<String, Object> r =
        restTemplate.getForObject("http://localhost:8080/product/{1}", Map.class, 2);
    return r;
});
Future<Map<String, Object>> f4 = service.submit(() -> {
    Map<String, Object> r =
        restTemplate.getForObject("http://localhost:8080/logistics/{1}", Map.class, 1);
    return r;
});
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
log.debug("执行完毕");
service.shutdown();

Copied!

执行结果

19:51:39.711 c.TestCountDownLatch [main] - begin 
{total=2300.00, id=1} 
{price=300, name=小爱音箱, id=1} 
{price=2000, name=小米手机, id=2} 
{name=中通快递, id=1} 
19:51:42.407 c.TestCountDownLatch [main] - 执行完毕

Copied!

说明：

这种等待多个带有返回值的任务的场景，还是用future比较合适，CountdownLatch适合任务没有返回值的场景。

CyclicBarrier

CountdownLatch的缺点在于不能重用，见下：

private static void test1() {
    ExecutorService service = Executors.newFixedThreadPool(5);
    for (int i = 0; i < 3; i++) {
        CountDownLatch latch = new CountDownLatch(2);
        service.submit(() -> {
            log.debug("task1 start...");
            sleep(1);
            latch.countDown();
        });
        service.submit(() -> {
            log.debug("task2 start...");
            sleep(2);
            latch.countDown();
        });
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("task1 task2 finish...");
    }
    service.shutdown();
}

Copied!

想要重复使用CountdownLatch进行同步，必须创建多个CountDownLatch对象。

[ˈsaɪklɪk ˈbæriɚ] 循环栅栏，用来进行线程协作，等待线程满足某个计数。构造时设置『计数个数』，每个线程执行到某个需要“同步”的时刻调用 await() 方法进行等待，当等待的线程数满足『计数个数』时，继续执行

CyclicBarrier cb = new CyclicBarrier(2); // 个数为2时才会继续执行
new Thread(()->{
    System.out.println("线程1开始.."+new Date());
    try {
        cb.await(); // 当个数不足时，等待
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程1继续向下运行..."+new Date());
}).start();
new Thread(()->{
    System.out.println("线程2开始.."+new Date());
    try { Thread.sleep(2000); } catch (InterruptedException e) { }
    try {
        cb.await(); // 2 秒后，线程个数够2，继续运行
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程2继续向下运行..."+new Date());
}).start();

Copied!

注意

CyclicBarrier 与 CountDownLatch 的主要区别在于 CyclicBarrier 是可以重用的 CyclicBarrier 可以被比喻为『人满发车』

CountDownLatch的计数和阻塞方法是分开的两个方法，而CyclicBarrier是一个方法。

CyclicBarrier的构造器还有一个Runnable类型的参数，在计数为0时会执行其中的run方法。

线程安全集合类概述

线程安全集合类可以分为三大类：

遗留的线程安全集合如Hashtable，Vector
使用Collections装饰的线程安全集合，如：
- Collections.synchronizedCollection
- Collections.synchronizedList
- Collections.synchronizedMap
- Collections.synchronizedSet
- Collections.synchronizedNavigableMap
- Collections.synchronizedNavigableSet
- Collections.synchronizedSortedMap
- Collections.synchronizedSortedSet
- 说明：以上集合均采用修饰模式设计，将非线程安全的集合包装后，在调用方法时包裹了一层synchronized代码块。其并发性并不比遗留的安全集合好。
java.util.concurrent.*

重点介绍java.util.concurrent.* 下的线程安全集合类，可以发现它们有规律，里面包含三类关键词： Blocking、CopyOnWrite、Concurrent

Blocking 大部分实现基于锁，并提供用来阻塞的方法
CopyOnWrite 之类容器修改开销相对较重
Concurrent 类型的容器
- 内部很多操作使用 cas 优化，一般可以提供较高吞吐量
- 弱一致性
  - 遍历时弱一致性，例如，当利用迭代器遍历时，如果容器发生修改，迭代器仍然可以继续进行遍历，这时内容是旧的
  - 求大小弱一致性，size 操作未必是 100% 准确
  - 读取弱一致性

遍历时如果发生了修改，对于非安全容器来讲，使用 fail-fast 机制也就是让遍历立刻失败，抛出 ConcurrentModificationException，不再继续遍历

ConcurrentHashMap

应用之单词计数

搭建练习环境：

public class Test {
    public static void main(String[] args){
        //在main方法中实现两个接口
    }
	
    //开启26个线程，每个线程调用get方法获取map，从对应的文件读取单词并存储到list中，最后调用accept方法进行统计。
    public static <V> void  calculate(Supplier<Map<String,V>> supplier, BiConsumer<Map<String,V>, List<String>> consumer) {
        Map<String, V> map = supplier.get();
        CountDownLatch count = new CountDownLatch(26);
        for (int i = 1; i < 27; i++) {
            int k = i;
            new Thread(()->{
                ArrayList<String> list = new ArrayList<>();
                read(list,k);
                consumer.accept(map,list);
                count.countDown();
            }).start();
        }
        try {
            count.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(map.toString());
    }
	//读单词方法的实现
    public static void read(List<String> list,int i){
        try{
            String element;
            BufferedReader reader = new BufferedReader(new FileReader(i + ".txt"));
            while((element = reader.readLine()) != null){
                list.add(element);
            }
        }catch (IOException e){

        }
    }
	//生成测试数据
    public void construct(){
        String str = "abcdefghijklmnopqrstuvwxyz";
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < str.length(); i++) {
            for (int j = 0; j < 200; j++) {
                list.add(String.valueOf(str.charAt(i)));
            }
        }
        Collections.shuffle(list);
        for (int i = 0; i < 26; i++) {
            try (PrintWriter out = new PrintWriter(new FileWriter(i + 1 + ".txt"))) {
                String collect = list.subList(i * 200, (i + 1) * 200).stream().collect(Collectors.joining("\n"));
                out.println(collect);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Copied!

实现一：

demo(
    // 创建 map 集合
    // 创建 ConcurrentHashMap 对不对？
    () -> new ConcurrentHashMap<String, Integer>(),
    // 进行计数
    (map, words) -> {
        for (String word : words) {
            Integer counter = map.get(word);
            int newValue = counter == null ? 1 : counter + 1;
            map.put(word, newValue);
        }
    }
);

Copied!

输出：

1
2

{a=186, b=192, c=187, d=184, e=185, f=185, g=176, h=185, i=193, j=189, k=187, l=157, m=189, n=181, o=180, p=178, q=185, r=188, s=181, t=183, u=177, v=186, w=188, x=178, y=189, z=186}
47

Copied!

错误原因：

ConcurrentHashMap虽然每个方法都是线程安全的，但是多个方法的组合并不是线程安全的。

正确答案一：

demo(
    () -> new ConcurrentHashMap<String, LongAdder>(),
    (map, words) -> {
        for (String word : words) {
            // 注意不能使用 putIfAbsent，此方法返回的是上一次的 value，首次调用返回 null
            map.computeIfAbsent(word, (key) -> new LongAdder()).increment();
        }
    }
);

Copied!

说明：

computIfAbsent方法的作用是：当map中不存在以参数1为key对应的value时，会将参数2函数式接口的返回值作为value，put进map中，然后返回该value。如果存在key，则直接返回value
以上两部均是线程安全的。

正确答案二：

demo(
    () -> new ConcurrentHashMap<String, Integer>(),
    (map, words) -> {
        for (String word : words) {
            // 函数式编程，无需原子变量
            map.merge(word, 1, Integer::sum);
        }
    }
);

Copied!

* ConcurrentHashMap 原理

JDK 7 HashMap 并发死链

测试代码

注意

要在 JDK 7 下运行，否则扩容机制和 hash 的计算方法都变了
以下测试代码是精心准备的，不要随便改动

public static void main(String[] args) {
    // 测试 java 7 中哪些数字的 hash 结果相等
    System.out.println("长度为16时，桶下标为1的key");
    for (int i = 0; i < 64; i++) {
        if (hash(i) % 16 == 1) {
            System.out.println(i);
        }
    }
    System.out.println("长度为32时，桶下标为1的key");
    for (int i = 0; i < 64; i++) {
        if (hash(i) % 32 == 1) {
            System.out.println(i);
        }
    }
    // 1, 35, 16, 50 当大小为16时，它们在一个桶内
    final HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    // 放 12 个元素
    map.put(2, null);
    map.put(3, null);
    map.put(4, null);
    map.put(5, null);
    map.put(6, null);
    map.put(7, null);
    map.put(8, null);
    map.put(9, null);
    map.put(10, null);
    map.put(16, null);
    map.put(35, null);
    map.put(1, null);
    System.out.println("扩容前大小[main]:"+map.size());
    new Thread() {
        @Override
        public void run() {
            // 放第 13 个元素, 发生扩容
            map.put(50, null);
            System.out.println("扩容后大小[Thread-0]:"+map.size());
        }
    }.start();
    new Thread() {
        @Override
        public void run() {
            // 放第 13 个元素, 发生扩容
            map.put(50, null);
            System.out.println("扩容后大小[Thread-1]:"+map.size());
        }
    }.start();
}
final static int hash(Object k) {
    int h = 0;
    if (0 != h && k instanceof String) {
        return sun.misc.Hashing.stringHash32((String) k);
    }
    h ^= k.hashCode();
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

Copied!

死链复现

调试工具使用 idea

在 HashMap 源码 590 行加断点

`1`	`int newCapacity = newTable.length;`

Copied!

断点的条件如下，目的是让 HashMap 在扩容为 32 时，并且线程为 Thread-0 或 Thread-1 时停下来

newTable.length==32 &&
 (
 Thread.currentThread().getName().equals("Thread-0")||
 Thread.currentThread().getName().equals("Thread-1")
 )

Copied!

断点暂停方式选择 Thread，否则在调试 Thread-0 时，Thread-1 无法恢复运行

运行代码，程序在预料的断点位置停了下来，输出

长度为16时，桶下标为1的key 
1 
16 
35 
50 
长度为32时，桶下标为1的key 
1 
35 
扩容前大小[main]:12

Copied!

接下来进入扩容流程调试

在 HashMap 源码 594 行加断点

1
2
3

Entry<K,V> next = e.next; // 593
if (rehash) // 594
// ...

Copied!

这是为了观察 e 节点和 next 节点的状态，Thread-0 单步执行到 594 行，再 594 处再添加一个断点（条件 Thread.currentThread().getName().equals(“Thread-0”)）

这时可以在 Variables 面板观察到 e 和 next 变量，使用view as -> Object查看节点状态

1
2

e (1)->(35)->(16)->null 
next (35)->(16)->null

Copied!

在 Threads 面板选中 Thread-1 恢复运行，可以看到控制台输出新的内容如下，Thread-1 扩容已完成

`1`	`newTable[1] (35)->(1)->null`

Copied!

`1`	`扩容后大小:13`

Copied!

这时 Thread-0 还停在 594 处， Variables 面板变量的状态已经变化为

1
2

e (1)->null 
next (35)->(1)->null

Copied!

为什么呢，因为 Thread-1 扩容时链表也是后加入的元素放入链表头，因此链表就倒过来了，但 Thread-1 虽然结果正确，但它结束后 Thread-0 还要继续运行

接下来就可以单步调试（F8）观察死链的产生了

下一轮循环到 594，将 e 搬迁到 newTable 链表头

1
2
3

newTable[1] (1)->null 
e (35)->(1)->null 
next (1)->null

Copied!

下一轮循环到 594，将 e 搬迁到 newTable 链表头

1
2
3

newTable[1] (35)->(1)->null 
e (1)->null 
next null

Copied!

再看看源码

e.next = newTable[1];
// 这时 e (1,35)
// 而 newTable[1] (35,1)->(1,35) 因为是同一个对象
newTable[1] = e; 
// 再尝试将 e 作为链表头, 死链已成
e = next;
// 虽然 next 是 null, 会进入下一个链表的复制, 但死链已经形成了

Copied!

源码分析

HashMap 的并发死链发生在扩容时

// 将 table 迁移至 newTable
void transfer(Entry[] newTable, boolean rehash) { 
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            // 1 处
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            // 2 处
            // 将新元素加入 newTable[i], 原 newTable[i] 作为新元素的 next
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

Copied!

假设 map 中初始元素是

原始链表，格式：[下标] (key,next)
[1] (1,35)->(35,16)->(16,null)
线程 a 执行到 1 处 ，此时局部变量 e 为 (1,35)，而局部变量 next 为 (35,16) 线程 a 挂起
线程 b 开始执行
第一次循环
[1] (1,null)
第二次循环
[1] (35,1)->(1,null)
第三次循环
[1] (35,1)->(1,null)
[17] (16,null)
切换回线程 a，此时局部变量 e 和 next 被恢复，引用没变但内容变了：e 的内容被改为 (1,null)，而 next 的内
容被改为 (35,1) 并链向 (1,null)
第一次循环
[1] (1,null)
第二次循环，注意这时 e 是 (35,1) 并链向 (1,null) 所以 next 又是 (1,null)
[1] (35,1)->(1,null)
第三次循环，e 是 (1,null)，而 next 是 null，但 e 被放入链表头，这样 e.next 变成了 35 （2 处）
[1] (1,35)->(35,1)->(1,35)
已经是死链了

Copied!

小结

究其原因，是因为在多线程环境下使用了非线程安全的 map 集合
JDK 8 虽然将扩容算法做了调整，不再将元素加入链表头（而是保持与扩容前一样的顺序），但仍不意味着能够在多线程环境下能够安全扩容，还会出现其它问题（如扩容丢数据）

JDK 8 ConcurrentHashMap

重要属性和内部类

// 默认为 0
// 当初始化时, 为 -1
// 当扩容时, 为 -(1 + 扩容线程数)
// 当初始化或扩容完成后，为 下一次的扩容的阈值大小
private transient volatile int sizeCtl;
// 整个 ConcurrentHashMap 就是一个 Node[]
static class Node<K,V> implements Map.Entry<K,V> {}
// hash 表
transient volatile Node<K,V>[] table;
// 扩容时的 新 hash 表
private transient volatile Node<K,V>[] nextTable;
// 扩容时如果某个 bin 迁移完毕, 用 ForwardingNode 作为旧 table bin 的头结点
static final class ForwardingNode<K,V> extends Node<K,V> {}
// 用在 compute 以及 computeIfAbsent 时, 用来占位, 计算完成后替换为普通 Node
static final class ReservationNode<K,V> extends Node<K,V> {}
// 作为 treebin 的头节点, 存储 root 和 first
static final class TreeBin<K,V> extends Node<K,V> {}
// 作为 treebin 的节点, 存储 parent, left, right
static final class TreeNode<K,V> extends Node<K,V> {}

Copied!

重要方法

// 获取 Node[] 中第 i 个 Node
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i)
 
// cas 修改 Node[] 中第 i 个 Node 的值, c 为旧值, v 为新值
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i, Node<K,V> c, Node<K,V> v)
 
// 直接修改 Node[] 中第 i 个 Node 的值, v 为新值
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v)

Copied!

构造器分析

可以看到实现了懒惰初始化，在构造方法中仅仅计算了 table 的大小，以后在第一次使用时才会真正创建

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (initialCapacity < concurrencyLevel) // Use at least as many bins
        initialCapacity = concurrencyLevel; // as estimated threads
    long size = (long)(1.0 + (long)initialCapacity / loadFactor);
    // tableSizeFor 仍然是保证计算的大小是 2^n, 即 16,32,64 ... 
    int cap = (size >= (long)MAXIMUM_CAPACITY) ?
        MAXIMUM_CAPACITY : tableSizeFor((int)size);
    this.sizeCtl = cap;
}

Copied!

get流程

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    // spread 方法能确保返回结果是正数
    int h = spread(key.hashCode());
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 如果头结点已经是要查找的 key
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // hash 为负数表示该 bin 在扩容中或是 treebin, 这时调用 find 方法来查找
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        // 正常遍历链表, 用 equals 比较
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

Copied!

总结：

如果table不为空且长度大于0且索引位置有元素
- if 头节点key的hash值相等
  - 头节点的key指向同一个地址或者equals
    - 返回value
- else if 头节点的hash为负数（bin在扩容或者是treebin）
  - 调用find方法查找
- 进入循环（e不为空）：
  - 节点key的hash值相等，且key指向同一个地址或equals
    - 返回value
返回null

put 流程

以下数组简称（table），链表简称（bin）

public V put(K key, V value) {
    return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    // 其中 spread 方法会综合高位低位, 具有更好的 hash 性
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        // f 是链表头节点
        // fh 是链表头结点的 hash
        // i 是链表在 table 中的下标
        Node<K,V> f; int n, i, fh;
        // 要创建 table
        if (tab == null || (n = tab.length) == 0)
            // 初始化 table 使用了 cas, 无需 synchronized 创建成功, 进入下一轮循环
            tab = initTable();
        // 要创建链表头节点
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 添加链表头使用了 cas, 无需 synchronized
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;
        }
        // 帮忙扩容
        else if ((fh = f.hash) == MOVED)
            // 帮忙之后, 进入下一轮循环
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 锁住链表头节点
            synchronized (f) {
                // 再次确认链表头节点没有被移动
                if (tabAt(tab, i) == f) {
                    // 链表
                    if (fh >= 0) {
                        binCount = 1;
                        // 遍历链表
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 找到相同的 key
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                // 更新
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            // 已经是最后的节点了, 新增 Node, 追加至链表尾
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    // 红黑树
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        // putTreeVal 会看 key 是否已经在树中, 是, 则返回对应的 TreeNode
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                              value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
                // 释放链表头节点的锁
            }

            if (binCount != 0) { 
                if (binCount >= TREEIFY_THRESHOLD)
                    // 如果链表长度 >= 树化阈值(8), 进行链表转为红黑树
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 增加 size 计数
    addCount(1L, binCount);
    return null;
}
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0)
            Thread.yield();
        // 尝试将 sizeCtl 设置为 -1（表示初始化 table）
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            // 获得锁, 创建 table, 这时其它线程会在 while() 循环中 yield 直至 table 创建
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    sc = n - (n >>> 2);
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}
// check 是之前 binCount 的个数
private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    if (
        // 已经有了 counterCells, 向 cell 累加
        (as = counterCells) != null ||
        // 还没有, 向 baseCount 累加
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)
    ) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        if (
            // 还没有 counterCells
            as == null || (m = as.length - 1) < 0 ||
            // 还没有 cell
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            // cell cas 增加计数失败
            !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
        ) {
            // 创建累加单元数组和cell, 累加重试
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        // 获取元素个数
        s = sumCount();
    }
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                // newtable 已经创建了，帮忙扩容
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // 需要扩容，这时 newtable 未创建
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

Copied!

总结：

进入for循环：
- if table为null或者长度为0
  - 初始化表
- else if 索引处无节点
  - 创建节点，填入key和value，放入table，退出循环
- else if 索引处节点的hash值为MOVE（ForwardingNode），表示正在扩容和迁移
  - 帮忙
- else
  - 锁住头节点
    - if 再次确认头节点没有被移动
      - if 头节点hash值大于0（表示这是一个链表）
        
        遍历链表找到对应key，如果没有，创建。
      - else if 节点为红黑树节点
        
        调用putTreeVal查看是否有对应key的数节点
        
        如果有且为覆盖模式，将值覆盖，返回旧值
        
        如果没有，创建并插入，返回null
    - 解锁
  - if binCount不为0
    - 如果binCount大于树化阈值8
      - 树化
    - 如果旧值不为null
      - 返回旧值
    - break
增加size计数
return null

size 计算流程

size 计算实际发生在 put，remove 改变集合元素的操作之中

没有竞争发生，向 baseCount 累加计数
有竞争发生，新建 counterCells，向其中的一个 cell 累加计
- counterCells 初始有两个 cell
- 如果计数竞争比较激烈，会创建新的 cell 来累加计数

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;
    // 将 baseCount 计数与所有 cell 计数累加
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

Copied!

总结

Java 8 数组（Node） +（链表 Node | 红黑树 TreeNode ）以下数组简称（table），链表简称（bin）

初始化，使用 cas 来保证并发安全，懒惰初始化 table
树化，当 table.length < 64 时，先尝试扩容，超过 64 时，并且 bin.length > 8 时，会将链表树化，树化过程会用 synchronized 锁住链表头
put，如果该 bin 尚未创建，只需要使用 cas 创建 bin；如果已经有了，锁住链表头进行后续 put 操作，元素添加至 bin 的尾部
get，无锁操作仅需要保证可见性，扩容过程中 get 操作拿到的是 ForwardingNode 它会让 get 操作在新 table 进行搜索
扩容，扩容时以 bin 为单位进行，需要对 bin 进行 synchronized，但这时妙的是其它竞争线程也不是无事可做，它们会帮助把其它 bin 进行扩容，扩容时平均只有 1/6 的节点会把复制到新 table 中
size，元素个数保存在 baseCount 中，并发时的个数变动保存在 CounterCell[] 当中。最后统计数量时累加即可

源码分析 http://www.importnew.com/28263.html

其它实现 Cliff Click’s high scale lib

JDK 7 ConcurrentHashMap

它维护了一个 segment 数组，每个 segment 对应一把锁

优点：如果多个线程访问不同的 segment，实际是没有冲突的，这与 jdk8 中是类似的
缺点：Segments 数组默认大小为16，这个容量初始化指定后就不能改变了，并且不是懒惰初始化

构造器分析

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    // ssize 必须是 2^n, 即 2, 4, 8, 16 ... 表示了 segments 数组的大小
    int sshift = 0;
    int ssize = 1;
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    // segmentShift 默认是 32 - 4 = 28
    this.segmentShift = 32 - sshift;
    // segmentMask 默认是 15 即 0000 0000 0000 1111
    this.segmentMask = ssize - 1;
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    while (cap < c)
        cap <<= 1;
    // 创建 segments and segments[0]
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                         (HashEntry<K,V>[])new HashEntry[cap]);
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

Copied!

构造完成，如下图所示

可以看到 ConcurrentHashMap 没有实现懒惰初始化，空间占用不友好

其中 this.segmentShift 和 this.segmentMask 的作用是决定将 key 的 hash 结果匹配到哪个 segment

例如，根据某一 hash 值求 segment 位置，先将高位向低位移动 this.segmentShift 位

结果再与 this.segmentMask 做位于运算，最终得到 1010 即下标为 10 的 segment

put 流程

public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null)
        throw new NullPointerException();
    int hash = hash(key);
    // 计算出 segment 下标
    int j = (hash >>> segmentShift) & segmentMask;

    // 获得 segment 对象, 判断是否为 null, 是则创建该 segment
    if ((s = (Segment<K,V>)UNSAFE.getObject 
         (segments, (j << SSHIFT) + SBASE)) == null) {
        // 这时不能确定是否真的为 null, 因为其它线程也发现该 segment 为 null,
        // 因此在 ensureSegment 里用 cas 方式保证该 segment 安全性
        s = ensureSegment(j);
    }
    // 进入 segment 的put 流程
    return s.put(key, hash, value, false);
}

Copied!

segment 继承了可重入锁（ReentrantLock），它的 put 方法为

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    // 尝试加锁
    HashEntry<K,V> node = tryLock() ? null :
    // 如果不成功, 进入 scanAndLockForPut 流程
    // 如果是多核 cpu 最多 tryLock 64 次, 进入 lock 流程
    // 在尝试期间, 还可以顺便看该节点在链表中有没有, 如果没有顺便创建出来
    scanAndLockForPut(key, hash, value);

    // 执行到这里 segment 已经被成功加锁, 可以安全执行
    V oldValue;
    try {
        HashEntry<K,V>[] tab = table;
        int index = (tab.length - 1) & hash;
        HashEntry<K,V> first = entryAt(tab, index);
        for (HashEntry<K,V> e = first;;) {
            if (e != null) {
                // 更新
                K k;
                if ((k = e.key) == key ||
                    (e.hash == hash && key.equals(k))) { 
                    oldValue = e.value;
                    if (!onlyIfAbsent) {
                        e.value = value;
                        ++modCount;
                    } break;
                }
                e = e.next;
            }
            else {
                // 新增
                // 1) 之前等待锁时, node 已经被创建, next 指向链表头
                if (node != null)
                    node.setNext(first);
                else
                    // 2) 创建新 node
                    node = new HashEntry<K,V>(hash, key, value, first);
                int c = count + 1; 
                // 3) 扩容
                if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                    rehash(node);
                else
                    // 将 node 作为链表头
                    setEntryAt(tab, index, node);
                ++modCount;
                count = c;
                oldValue = null;
                break;
            }
        }
    } finally {
        unlock();
    }
    return oldValue;
}

Copied!

rehash 流程

发生在 put 中，因为此时已经获得了锁，因此 rehash 时不需要考虑线程安全

private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    int newCapacity = oldCapacity << 1;
    threshold = (int)(newCapacity * loadFactor);
    HashEntry<K,V>[] newTable =
        (HashEntry<K,V>[]) new HashEntry[newCapacity];
    int sizeMask = newCapacity - 1;
    for (int i = 0; i < oldCapacity ; i++) {
        HashEntry<K,V> e = oldTable[i];
        if (e != null) {
            HashEntry<K,V> next = e.next;
            int idx = e.hash & sizeMask;
            if (next == null) // Single node on list
                newTable[idx] = e;
            else { // Reuse consecutive sequence at same slot
                HashEntry<K,V> lastRun = e;
                int lastIdx = idx;
                // 过一遍链表, 尽可能把 rehash 后 idx 不变的节点重用
                for (HashEntry<K,V> last = next;
                     last != null;
                     last = last.next) {
                    int k = last.hash & sizeMask;
                    if (k != lastIdx) {
                        lastIdx = k;
                        lastRun = last;
                    }
                }
                newTable[lastIdx] = lastRun;
                // 剩余节点需要新建
                for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                    V v = p.value;
                    int h = p.hash;
                    int k = h & sizeMask;
                    HashEntry<K,V> n = newTable[k];
                    newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                }
            }
        }
    }
    // 扩容完成, 才加入新的节点
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;

    // 替换为新的 HashEntry table
    table = newTable;
}

Copied!

附，调试代码

public static void main(String[] args) {
    ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
    for (int i = 0; i < 1000; i++) {
        int hash = hash(i);
        int segmentIndex = (hash >>> 28) & 15;
        if (segmentIndex == 4 && hash % 8 == 2) {
            System.out.println(i + "\t" + segmentIndex + "\t" + hash % 2 + "\t" + hash % 4 +
                               "\t" + hash % 8);
        }
    }
    map.put(1, "value");
    map.put(15, "value"); // 2 扩容为 4 15 的 hash%8 与其他不同
    map.put(169, "value");
    map.put(197, "value"); // 4 扩容为 8
    map.put(341, "value");
    map.put(484, "value");
    map.put(545, "value"); // 8 扩容为 16
    map.put(912, "value");
    map.put(941, "value");
    System.out.println("ok");
}
private static int hash(Object k) {
    int h = 0;
    if ((0 != h) && (k instanceof String)) {
        return sun.misc.Hashing.stringHash32((String) k);
    }
    h ^= k.hashCode();
    // Spread bits to regularize both segment and index locations,
    // using variant of single-word Wang/Jenkins hash.
    h += (h << 15) ^ 0xffffcd7d;
    h ^= (h >>> 10);
    h += (h << 3);
    h ^= (h >>> 6);
    h += (h << 2) + (h << 14);
    int v = h ^ (h >>> 16);
    return v;
}

Copied!

get 流程

get 时并未加锁，用了 UNSAFE 方法保证了可见性，扩容过程中，get 先发生就从旧表取内容，get 后发生就从新表取内容

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    int h = hash(key);
    // u 为 segment 对象在数组中的偏移量
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    // s 即为 segment
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
             (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    return null;
}

Copied!

size 计算流程

计算元素个数前，先不加锁计算两次，如果前后两次结果如一样，认为个数正确返回
如果不一样，进行重试，重试次数超过 3，将所有 segment 锁住，重新计算个数返回

public int size() {
    // Try a few times to get accurate count. On failure due to
    // continuous async changes in table, resort to locking.
    final Segment<K,V>[] segments = this.segments;
    int size;
    boolean overflow; // true if size overflows 32 bits
    long sum; // sum of modCounts
    long last = 0L; // previous sum
    int retries = -1; // first iteration isn't retry
    try {
        for (;;) {
            if (retries++ == RETRIES_BEFORE_LOCK) {
                // 超过重试次数, 需要创建所有 segment 并加锁
                for (int j = 0; j < segments.length; ++j)
                    ensureSegment(j).lock(); // force creation
            }
            sum = 0L;
            size = 0;
            overflow = false;
            for (int j = 0; j < segments.length; ++j) {
                Segment<K,V> seg = segmentAt(segments, j);
                if (seg != null) {
                    sum += seg.modCount;
                    int c = seg.count;
                    if (c < 0 || (size += c) < 0)
                        overflow = true;
                }
            }
            if (sum == last)
                break;
            last = sum;
        }
    } finally {
        if (retries > RETRIES_BEFORE_LOCK) {
            for (int j = 0; j < segments.length; ++j)
                segmentAt(segments, j).unlock();
        }
    }
    return overflow ? Integer.MAX_VALUE : size;
}

Copied!

BlockingQueue

* BlockingQueue 原理

基本的入队出队

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
    implements BlockingQueue<E>, java.io.Serializable {
    static class Node<E> {
        E item;
        /**
 		* 下列三种情况之一
 		* - 真正的后继节点
 		* - 自己, 发生在出队时
 		* - null, 表示是没有后继节点, 是最后了
 		*/
        Node<E> next;
        Node(E x) { item = x; }
    }
}

Copied!

初始化链表

last = head = new Node(null);Dummy 节点用来占位，item 为 null

当一个节点入队

last = last.next = node;

再来一个节点入队last = last.next = node;

出队

//临时变量h用来指向哨兵
Node<E> h = head;
//first用来指向第一个元素
Node<E> first = h.next;
h.next = h; // help GC
//head赋值为first，表示first节点就是下一个哨兵。
head = first;
E x = first.item;
//删除first节点中的数据，表示真正成为了哨兵，第一个元素出队。
first.item = null;
return x;

Copied!

h = head

first = h.next

h.next = h

head = first

1
2
3

E x = first.item;
first.item = null;
return x;

Copied!

加锁分析

高明之处在于用了两把锁和 dummy 节点

用一把锁，同一时刻，最多只允许有一个线程（生产者或消费者，二选一）执行
用两把锁，同一时刻，可以允许两个线程同时（一个生产者与一个消费者）执行
- 消费者与消费者线程仍然串行
- 生产者与生产者线程仍然串行

线程安全分析

当节点总数大于 2 时（包括 dummy 节点），putLock 保证的是 last 节点的线程安全，takeLock 保证的是 head 节点的线程安全。两把锁保证了入队和出队没有竞争
当节点总数等于 2 时（即一个 dummy 节点，一个正常节点）这时候，仍然是两把锁锁两个对象，不会竞争
当节点总数等于 1 时（就一个 dummy 节点）这时 take 线程会被 notEmpty 条件阻塞，有竞争，会阻塞

// 用于 put(阻塞) offer(非阻塞)
private final ReentrantLock putLock = new ReentrantLock();
// 用户 take(阻塞) poll(非阻塞)
private final ReentrantLock takeLock = new ReentrantLock();

Copied!

put 操作

public void put(E e) throws InterruptedException {
    //LinkedBlockingQueue不支持空元素
    if (e == null) throw new NullPointerException();
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    // count 用来维护元素计数
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        // 满了等待
        while (count.get() == capacity) {
            // 倒过来读就好: 等待 notFull
            notFull.await();
        }
        // 有空位, 入队且计数加一
        enqueue(node);
        c = count.getAndIncrement(); 
        // 除了自己 put 以外, 队列还有空位, 由自己叫醒其他 put 线程
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    // 如果队列中有一个元素, 叫醒 take 线程
    if (c == 0)
        // 这里调用的是 notEmpty.signal() 而不是 notEmpty.signalAll() 是为了减少竞争
        signalNotEmpty();
}

Copied!

take 操作

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        while (count.get() == 0) {
            notEmpty.await();
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    // 如果队列中只有一个空位时, 叫醒 put 线程
    // 如果有多个线程进行出队, 第一个线程满足 c == capacity, 但后续线程 c < capacity
    if (c == capacity)
        // 这里调用的是 notFull.signal() 而不是 notFull.signalAll() 是为了减少竞争
        signalNotFull()
        return x;
}

Copied!

由 put 唤醒 put 是为了避免信号不足

性能比较

主要列举 LinkedBlockingQueue 与 ArrayBlockingQueue 的性能比较

Linked 支持有界，Array 强制有界
Linked 实现是链表，Array 实现是数组
Linked 是懒惰的，而 Array 需要提前初始化 Node 数组
Linked 每次入队会生成新 Node，而 Array 的 Node 是提前创建好的
Linked 两把锁，Array 一把锁

ConcurrentLinkedQueue

ConcurrentLinkedQueue 的设计与 LinkedBlockingQueue 非常像，也是

两把【锁】，同一时刻，可以允许两个线程同时（一个生产者与一个消费者）执行
dummy 节点的引入让两把【锁】将来锁住的是不同对象，避免竞争
只是这【锁】使用了 cas 来实现

事实上，ConcurrentLinkedQueue 应用还是非常广泛的

例如之前讲的 Tomcat 的 Connector 结构时，Acceptor 作为生产者向 Poller 消费者传递事件信息时，正是采用了 ConcurrentLinkedQueue 将 SocketChannel 给 Poller 使用


graph LR

subgraph Connector->NIO EndPoint
t1(LimitLatch)
t2(Acceptor)
t3(SocketChannel 1)
t4(SocketChannel 2)
t5(Poller)
subgraph Executor
t7(worker1)
t8(worker2)
end
t1 --> t2
t2 --> t3
t2 --> t4
t3 --有读--> t5
t4 --有读--> t5
t5 --socketProcessor--> t7
t5 --socketProcessor--> t8
end

Copied!

*ConcurrentLinkedQueue 原理

模仿 ConcurrentLinkedQueue

初始代码

package cn.itcast.concurrent.thirdpart.test;
import java.util.Collection;
import java.util.Iterator;
import java.util.Queue;
import java.util.concurrent.atomic.AtomicReference;
public class Test3 {
    public static void main(String[] args) {
        MyQueue<String> queue = new MyQueue<>();
        queue.offer("1");
        queue.offer("2");
        queue.offer("3");
        System.out.println(queue);
    }
}
class MyQueue<E> implements Queue<E> {
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Node<E> p = head; p != null; p = p.next.get()) {
            E item = p.item;
            if (item != null) {
                sb.append(item).append("->");
            }
        }
        sb.append("null");
        return sb.toString();
    }
    @Override
    public int size() {
        return 0;
    }
    @Override
    public boolean isEmpty() {
        return false;
    }
    @Override
    public boolean contains(Object o) {
        return false;
    }
    @Override
    public Iterator<E> iterator() {
        return null;
    }
    @Override
    public Object[] toArray() {
        return new Object[0];
    }
    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }
    @Override
    public boolean add(E e) {
        return false;
    }
    @Override
    public boolean remove(Object o) {
        return false;
    }
    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }
    @Override
    public boolean addAll(Collection<? extends E> c) {
        return false;
    }
    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }
    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }
    @Override
    public void clear() {
    }
    @Override
    public E remove() {
        return null;
    }
    @Override
    public E element() {
        return null;
    }
    @Override
    public E peek() {
        return null;
    }
    public MyQueue() {
        head = last = new Node<>(null, null);
    }
    private volatile Node<E> last;
    private volatile Node<E> head;
    private E dequeue() {
        /*Node<E> h = head;
 		Node<E> first = h.next;
 		h.next = h;
 		head = first;
        E x = first.item;
 		first.item = null;
 		return x;*/
        return null;
    }
    @Override
    public E poll() {
        return null;
    }
    @Override
    public boolean offer(E e) {
        return true;
    }
    static class Node<E> {
        volatile E item;
        public Node(E item, Node<E> next) {
            this.item = item;
            this.next = new AtomicReference<>(next);
        }
        AtomicReference<Node<E>> next;
    }
}

Copied!

offer

public boolean offer(E e) {
    Node<E> n = new Node<>(e, null);
    while(true) {
        // 获取尾节点
        AtomicReference<Node<E>> next = last.next;
        // S1: 真正尾节点的 next 是 null, cas 从 null 到新节点
        if(next.compareAndSet(null, n)) {
            // 这时的 last 已经是倒数第二, next 不为空了, 其它线程的 cas 肯定失败
            // S2: 更新 last 为倒数第一的节点
            last = n;
            return true;
        }
    }
}

Copied!

CopyOnWriteArrayList

CopyOnWriteArraySet是它的马甲底层实现采用了写入时拷贝的思想，增删改操作会将底层数组拷贝一份，更改操作在新数组上执行，这时不影响其它线程的并发读，读写分离。以新增为例：

public boolean add(E e) {
    synchronized (lock) {
        // 获取旧的数组
        Object[] es = getArray();
        int len = es.length;
        // 拷贝新的数组（这里是比较耗时的操作，但不影响其它读线程）
        es = Arrays.copyOf(es, len + 1);
        // 添加新元素
        es[len] = e;
        // 替换旧的数组
        setArray(es);
        return true;
    }
}

Copied!

这里的源码版本是 Java 11，在 Java 1.8 中使用的是可重入锁而不是 synchronized

其它读操作并未加锁，例如：

public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    for (Object x : getArray()) {
        @SuppressWarnings("unchecked") E e = (E) x;
        action.accept(e);
    }
}

Copied!

适合『读多写少』的应用场景

get 弱一致性

时间点	操作
1	Thread-0 getArray()
2	Thread-1 getArray()
3	Thread-1 setArray(arrayCopy)
4	Thread-0 array[index]

不容易测试，但问题确实存在

迭代器弱一致性

CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
list.add(1);
list.add(2);
list.add(3);
Iterator<Integer> iter = list.iterator();
new Thread(() -> {
    list.remove(0);
    System.out.println(list);
}).start();
sleep1s();
//此时主线程的iterator依旧指向旧的数组。
while (iter.hasNext()) {
    System.out.println(iter.next());
}

Copied!

不要觉得弱一致性就不好

数据库的 MVCC 都是弱一致性的表现

并发高和一致性是矛盾的，需要权衡