为了提高快捷开发的能力，以及装杯效果，对idea的配置修改记录一下，防止换电脑、idea时迷路。



# IntelliJ IDEA 初始化配置

## 配置快捷键

我习惯使用 `Eclipse` 的快捷键，所以需要将默认的 `IDEA` 的快捷键配置成 `Eclipse` 的快捷键。

![image.png](/static/img/23be5d6979f3451e54d26c3b7ffa3365.image.webp)

## 全局配置
点击 All Settings 进入全局配置
![image.png](/static/img/9d96bf70202f90961ba3c6d84018d055.image.webp)

### 配置 Maven
定义全局的 Maven 信息，这样每次新建项目或导入项目时就不用再次配置了, 默认就使用这里的配置。
![image.png](/static/img/2bcfd96ccffd51f9729795da0ea8903c.image.webp)

### 开启类自动导入
在 Editor -> General -> Auto Import 勾选下列2项，以后代码类包路径会自动进行导入，你要体会过copy代码引入几十个包的痛苦，才会知道这个功能有多好用。

![image.png](/static/img/84fe68ee074a7c79fdc3d6fe97803bc5.image.webp)

### 自定义class模板
对于创建新的Class类，肯定有一些自定义的处理，比如作者，时间等，此步骤是对模板进行修改，在此我分别添加了class、enum、@interface的文档注释

```java
/**
 * @author Created by liuShiGong on ${YEAR}-${MONTH}-${DAY}
 */
```

![image.png](/static/img/feab79162d9ea06da88ae8e4c8bd1949.image.webp)

### 自定义快捷开发模板

在开发的时候，你是否使用过sout、psvm、main、if等快捷指令生成代码，你是否想定制自己的快捷开发指令呢

![image.png](/static/img/ecf830644ff0b1225b83950cf0a2e1d9.image.webp)

1、创建模板（此模板添加到Java分组下，也可以单独创建分组）

![image.png](/static/img/fcbc7bfb33224554954bd039fe047b36.image.webp)

2、编辑模板（创建公有不可变的字符串变量模板）
![image.png](/static/img/5fd6559dcf45bf4555bff570a24d59b7.image.webp)

3、选择在哪使用
选中 Java 的 Statement，点击 + 号，选择自定义的模板，点击 OK
![image.png](/static/img/234c40c555705b168e82ce525076aec5.image.webp)

4、使用
具体的演示效果就不截图了，跟psvm、main等命令一样，懂得都懂

### 自定义调整代码、注释的颜色

此处我是调整了单行注释展示的颜色

![image.png](/static/img/7bd3eeeb527ff5f498906f4581260d74.image.webp)

### 单行注释加空格

单行注释时，// 与 注释的文字中间加上空格

![image.png](/static/img/409e1f3605ee572ce1298afe5e18faa7.image.webp)

### 调整字体、行高

![image.png](/static/img/b145bc58adac134dc281b73393b01b60.image.webp)

### 设置文件字符集
如果有文件乱码，可以到此处调整字符集

![image.png](/static/img/e5737a3bd0857ad55e3d6f8119216ebb.image.webp)


### 设置Java编译默认版本
![image.png](/static/img/b2b6e636d32e680240a6bdc50e597525.image.webp)

以上配置是全局的配置，所有项目默认使用此配置，如果打开某个项目调整，那么此项目的配置会覆盖全局配置。

先写这些，以后想起来在补充。

IntelliJ IDEA 的初始化配置

为了减少 idea 下载与破解时的各种百度，还得不到有效结果的情况，我整理了 idea 各个版本的下载地址，以及破解方式，充当手册，方便查阅。




# IntelliJ IDEA 下载安装与破解

## 官网下载
> https://www.jetbrains.com/idea/download/other.html

![image.png](/static/img/53009903b8d76b9284de3eaa748d728f.image.webp)


选择想要下载的系统版本，点击即可（不推荐下载高版本，版本越高网上的破解方法越少），本人目前使用2022.3

![image.png](/static/img/20b448def31cde9db95a03303f17d876.image.webp)

具体的安装方式就不多说了，一路next即可，安装完成后开始破解

## 破解方式

### 激活码
目前从网上找到了2个 **正版激活码**，一个是激活到 **2024年3月26日**，先到先得：

![image.png](/static/img/e46f9a9996d63f0f67fa022f3f0bfc3a.image.webp)

```text
FDXL1Y2811-eyJsaWNlbnNlSWQiOiJGRFhMMVkyODExIiwibGljZW5zZWVOYW1lIjoiQmVub2l0IE1lbmVuZGV6IiwiYXNzaWduZWVOYW1lIjoiIiwiYXNzaWduZWVFbWFpbCI6IiIsImxpY2Vuc2VSZXN0cmljdGlvbiI6IiIsImNoZWNrQ29uY3VycmVudFVzZSI6ZmFsc2UsInByb2R1Y3RzIjpbeyJjb2RlIjoiRFBOIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiREIiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAzLTI3IiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOmZhbHNlfSx7ImNvZGUiOiJQUyIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDMtMjciLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IklJIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUlNDIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJHTyIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDMtMjciLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IkRNIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUlNGIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJEUyIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDMtMjciLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IlBDIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUkMiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAzLTI3IiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOmZhbHNlfSx7ImNvZGUiOiJDTCIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDMtMjciLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IldTIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUkQiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAzLTI3IiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOmZhbHNlfSx7ImNvZGUiOiJSUzAiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAzLTI3IiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOmZhbHNlfSx7ImNvZGUiOiJSTSIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDMtMjciLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IkFDIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0xMi0zMSIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUlNWIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJEQyIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDMtMjciLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IlJTVSIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDMtMjciLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6ZmFsc2V9LHsiY29kZSI6IkRQIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQREIiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAzLTI3IiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBXUyIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMTItMzEiLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUFNJIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0xMi0zMSIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQUFMiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAzLTI3IiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBDV01QIiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBHTyIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDMtMjciLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUFBDIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMy0yNyIsInBhaWRVcFRvIjoiMjAyNC0wMy0yNiIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQUkIiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAzLTI3IiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBTVyIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMTItMzEiLCJwYWlkVXBUbyI6IjIwMjQtMDMtMjYiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUlMiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAzLTI3IiwicGFpZFVwVG8iOiIyMDI0LTAzLTI2IiwiZXh0ZW5kZWQiOnRydWV9XSwibWV0YWRhdGEiOiIwMTIwMjMwMTAyUFBBQTAxMzAwOSIsImhhc2giOiI0MTQ3Mjk2MS8wOjE1NjM2MDk0NTEiLCJncmFjZVBlcmlvZERheXMiOjcsImF1dG9Qcm9sb25nYXRlZCI6dHJ1ZSwiaXNBdXRvUHJvbG9uZ2F0ZWQiOnRydWV9-a4JdkS6aDf0SLqGfwdeLBhEgrC81ZNj71lOi+4jkI5lclQmp+Y8wil+A0u7DGnVUA1GrJ2tu53XkcH5BVhD9TQGmyWIR34Rb+Hlc9BW2NgHjwQLhNSNbG/LEozMl92kFmwdRHTJb1JbIXiOsONIgQu6VCiCyWuffa/0+Noe9sIEBLIh3Z0ooOwVDYwr8Re2nKRNgnkagnS8MOe7a2VmPu58ikFtSsvebLKs613Yhq1EZ+IT9gpMwTGfpdLqvQ/EmHdfbY83HEOuHBAaBikgoANSYD7IxGe1pDpCTFYnyg0iCiEgeuvc46spka8m8lcK/TBpG/LxiT+Dx36a1a6jYiA==-MIIETDCCAjSgAwIBAgIBDzANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIyMTAxMDE2MDU0NFoXDTI0MTAxMTE2MDU0NFowHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMjEwMTAwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC/W3uCpU5M2y48rUR/3fFR6y4xj1nOm3rIuGp2brELVGzdgK2BezjnDXpAxVDw5657hBkAUMoyByiDs2MgmVi9IcqdAwpk988/Daaajq9xuU1of59jH9eQ9c3BmsEtdA4boN3VpenYKATwmpKYkJKVc07ZKoXL6kSyZuF7Jq7HoQZcclChbF75QJPGbri3cw9vDk/e46kuzfwpGftvl6+vKibpInO6Dv0ocwImDbOutyZC7E+BwpEm1TJZW4XovMBegHhWC04cJvpH1u98xoR94ichw0jKhdppywARe43rGU96163RckIuFmFDQKZV9SMUrwpQFu4Z2D5yTNqnlLRfAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQU5FZqQ4gnVc+inIeZF+o3ID+VhcEwSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBANLG1anEKid4W87vQkqWaQTkRtFKJ2GFtBeMhvLhIyM6Cg3FdQnMZr0qr9mlV0w289pf/+M14J7S7SgsfwxMJvFbw9gZlwHvhBl24N349GuthshGO9P9eKmNPgyTJzTtw6FedXrrHV99nC7spaY84e+DqfHGYOzMJDrg8xHDYLLHk5Q2z5TlrztXMbtLhjPKrc2+ZajFFshgE5eowfkutSYxeX8uA5czFNT1ZxmDwX1KIelbqhh6XkMQFJui8v8Eo396/sN3RAQSfvBd7Syhch2vlaMP4FAB11AlMKO2x/1hoKiHBU3oU3OKRTfoUTfy1uH3T+t03k1Qkr0dqgHLxiv6QU5WrarR9tx/dapqbsSmrYapmJ7S5+ghc4FTWxXJB1cjJRh3X+gwJIHjOVW+5ZVqXTG2s2Jwi2daDt6XYeigxgL2SlQpeL5kvXNCcuSJurJVcRZFYUkzVv85XfDauqGxYqaehPcK2TzmcXOUWPfxQxLJd2TrqSiO+mseqqkNTb3ZDiYS/ZqdQoGYIUwJqXo+EDgqlmuWUhkWwCkyo4rtTZeAj+nP00v3n8JmXtO30Fip+lxpfsVR3tO1hk4Vi2kmVjXyRkW2G7D7WAVt+91ahFoSeRWlKyb4KcvGvwUaa43fWLem2hyI4di2pZdr3fcYJ3xvL5ejL3m14bKsfoOv
```

另一个激活到 **2023年7月26日**，还可以白嫖2个月：

![image.png](/static/img/012164eecc27d91ea73b97f2cb268e07.image.webp)

```text
33MEHOB8W0-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-E7ppHYrn70k+bvr9Ebe2SjpDl52FfxyVUsrlO7wSSGRxULy/5MxRNNFESRC4MbMQDE8NL/f1zkgncW8FPRk3BbX5jXcZgSCLeTzCcstB+GE26/PJLc3nttTETN510bQYrlYbuCNRk6uxGDwjZN08VHF44xiUtrROXqPqpqJkhD5uZ8BVRSJxq+j1/xOfm3anz1sHq441RLVd2rLZ+dKmY4njwqbd9FfZlegta9KKQtd1XhWp4flLLAymqAE18NEFlKO/b9U0U6qD44504xjz9d/0/kyWO7ARq9uH2iU7SAW96PdugEj5luvj2j3WmkcoSjx8MqSwlGjgyUvEiJaeaA==-MIIETDCCAjSgAwIBAgIBDzANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIyMTAxMDE2MDU0NFoXDTI0MTAxMTE2MDU0NFowHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMjEwMTAwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC/W3uCpU5M2y48rUR/3fFR6y4xj1nOm3rIuGp2brELVGzdgK2BezjnDXpAxVDw5657hBkAUMoyByiDs2MgmVi9IcqdAwpk988/Daaajq9xuU1of59jH9eQ9c3BmsEtdA4boN3VpenYKATwmpKYkJKVc07ZKoXL6kSyZuF7Jq7HoQZcclChbF75QJPGbri3cw9vDk/e46kuzfwpGftvl6+vKibpInO6Dv0ocwImDbOutyZC7E+BwpEm1TJZW4XovMBegHhWC04cJvpH1u98xoR94ichw0jKhdppywARe43rGU96163RckIuFmFDQKZV9SMUrwpQFu4Z2D5yTNqnlLRfAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQU5FZqQ4gnVc+inIeZF+o3ID+VhcEwSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBANLG1anEKid4W87vQkqWaQTkRtFKJ2GFtBeMhvLhIyM6Cg3FdQnMZr0qr9mlV0w289pf/+M14J7S7SgsfwxMJvFbw9gZlwHvhBl24N349GuthshGO9P9eKmNPgyTJzTtw6FedXrrHV99nC7spaY84e+DqfHGYOzMJDrg8xHDYLLHk5Q2z5TlrztXMbtLhjPKrc2+ZajFFshgE5eowfkutSYxeX8uA5czFNT1ZxmDwX1KIelbqhh6XkMQFJui8v8Eo396/sN3RAQSfvBd7Syhch2vlaMP4FAB11AlMKO2x/1hoKiHBU3oU3OKRTfoUTfy1uH3T+t03k1Qkr0dqgHLxiv6QU5WrarR9tx/dapqbsSmrYapmJ7S5+ghc4FTWxXJB1cjJRh3X+gwJIHjOVW+5ZVqXTG2s2Jwi2daDt6XYeigxgL2SlQpeL5kvXNCcuSJurJVcRZFYUkzVv85XfDauqGxYqaehPcK2TzmcXOUWPfxQxLJd2TrqSiO+mseqqkNTb3ZDiYS/ZqdQoGYIUwJqXo+EDgqlmuWUhkWwCkyo4rtTZeAj+nP00v3n8JmXtO30Fip+lxpfsVR3tO1hk4Vi2kmVjXyRkW2G7D7WAVt+91ahFoSeRWlKyb4KcvGvwUaa43fWLem2hyI4di2pZdr3fcYJ3xvL5ejL3m14bKsfoOv
```

### 永久破解

**2022.3、2023版本的永久破解方式等正版激活码到期后再进行更新**

2023-07-28 已更新
> [Mac IntelliJ IDEA 2023.3破解激活](https://blog.liushigong.cn/post/12)

如果你是2021.3及以下版本，可以通过以下教程进行永久激活，亲测可用
> http://www.itmind.net/10705.html


如果你是2020.3及以下版本，可以通过教程进行无限重置激活，亲测可用

> https://www.jb51.net/article/198343.html

IntelliJ IDEA 下载安装与破解

RocketMQ是我们“家喻户晓”的消息中间件，本身是阿里开源、java语言实现的，它的官方文档对我们国人非常友好。除了基础的使用，对RocketMQ的源码以及实现原理的掌握是我们迈向高级开发必不可少的内容，此文是对RocketMQ深入了解的开篇之作，搭建一套自己的RocketMQ源码环境。



# RocketMQ

## 源码下载
到 [官方下载地址](https://rocketmq.apache.org/download/) 上找到需要下载的版本，此处我下载的是V5.1的版本，选择Source下载

![image.png](/static/img/e4248baa8c7d7c847b9f8796f199934c.image.webp)

这一步非常简单，将下载的压缩包解压到需要存放项目的目录上。

## Idea导入源码

从解压的目录中选择到源码包 rocketmq-all-5.1.0 -> 选中pom.xml -> open导入

![image.png](/static/img/52e4db8ee5babd225db0f04a39a70701.image.webp)

然后等待项目构建完成即可

![image.png](/static/img/396e8983c39fc2cd604ea06bd52eaed8.image.webp)

## NameServer的启动
由于是Java语言的实现，MQ的启动依赖JDK，需要JDK8以上的版本，查看当前系统JDK版本 `java -version`

![image.png](/static/img/f1f17388614dd516f912e23e870560a4.image.webp)

启动 namesrv 服务，找到 NameServerStartup 类，运行 main 方法

![image.png](/static/img/92e42e1f640515db7cd1ff0ca37d24e6.image.webp)

如果提示以下问题，不要慌，踩到坑就给他填上
![image.png](/static/img/920cc59a43351e7a14f050a2ad83f8c5.image.webp)

以上问题出现的原因是JDK版本太高了，JDK自带工具包没有匹配上的原因，切换为JDK8就解决了

![image.png](/static/img/5e8a385de54f8e0370a43bd6305186af.image.webp)

再次启动 NameServerStartup 类的 main 方法，提示了 `Please set the ROCKETMQ_HOME variable in your environment to match the location of the RocketMQ installation`

![image.png](/static/img/78c8ce3b17dde7ba47e19f77057a4f0f.image.webp)

这是因为需要在环境变量中查找 ROCKETMQ_HOME 为命名的 RocketMQ 的配置目录，在启动配置上指定对应的目录 `ROCKETMQ_HOME=./distribution` 即可

![image.png](/static/img/54cd083a1b7240aeeceeea0f8e0c5515.image.webp)

再次启动，提示 `The Name Server boot success. serializeType=JSON, address 0.0.0.0:9876` 即为启动成功

![image.png](/static/img/37a9c06f56b38777713df1182f35ed4b.image.webp)

## Broker的启动
启动 Broker 服务，先找到 broker 项目目录 BrokerStartup 类，运行 main 方法

![image.png](/static/img/a00dc50ebd816b60787b36802618b07b.image.webp)

同样的提示环境变量问题 `Please set the ROCKETMQ_HOME variable in your environment to match the location of the RocketMQ installation`

配置上与server一致，不同的是，Broker需要指定配置文件，在 Program arguments 中添加 `-c ./distribution/conf/broker.conf` 配置

![image.png](/static/img/8078204ba6f74b46435013132c9c286c.image.webp)

找到 `broker.conf` 配置文件，指定IP和添加server服务端地址
`brokerIP1=127.0.0.1 
namesrvAddr=127.0.0.1:9876`

![image.png](/static/img/e28f83dc4caea2cfd9ed167e27f85b28.image.webp)

再次启动 Broker，提示 `The broker[broker-a, 127.0.0.1:10911] boot success. serializeType=JSON and name server is 127.0.0.1:9876` 即为启动成功

![image.png](/static/img/8cf54ce6aa74f2f682cf2f18a490a6b1.image.webp)

你以为这就结束了吗？no no no，服务虽然启动了，也可以正常连接使用，但是我们还缺少了一个至关重要的组件，那就是 dashboard

## dashboard的启动
dashboard 的源码并不在上面下载的RocketMQ的源码当中，需要单独下载，下载地址 [dashboard](https://github.com/apache/rocketmq-dashboard/tree/rocketmq-dashboard-1.0.0)

![image.png](/static/img/7b02ca24d40ad1114bd3403b83655ca4.image.webp)

解压源码，Idea导入，编译使用JDK1.8，否则会出现一些Netty异常，此处不过多讲解，本身是SpringBoot项目，修改 application.properties 配置文件，指向本地启动的 NameServer 地址
```properties
rocketmq.config.namesrvAddr=localhost:9876
```
找到 App 类，运行 main 方法，启动成功，访问 http://localhost:8080/ 即可

![image.png](/static/img/7448e638f347c523f0370bade8224a31.image.webp)

查看控制台是否连接成功

![image.png](/static/img/6c789592785a21df8eb0d483da0dc36f.image.webp)

## 总结

总结一下，本文主要整理了RocketMQ源码部署的方式，可以更直观的观察消息发送与消费的执行流程。下一篇我会基于当前源码启动的服务，对功能特性进行总结，方便在开发中快捷开发。

RocketMQ 源码环境的构建

在[《JUC入门的知识体系梳理》](/post/5)中聊过volatile保证了变量的可见性与有序性，但是不保证变量的原子性，所以在并发下，volatile并不能保证变量的安全性，那怎么保证线程中变量的安全性呢？今天我们来聊下ThreadLocal，从源码的角度分析，看一看它是如何保证线程之间的变量安全的。



# ThreadLocal

## 什么是ThreadLocal

ThreadLocal意为线程本地变量，用于解决多线程并发时访问共享变量的问题

在JDK1.2中引入了ThreadLocal类，来修饰共享变量，使每个线程都单独拥有一份共享变量，这样就可以做到线程之间对于共享变量的隔离问题

**此时回想一下JMM内存模型，再想一下volatile的实现原理，是不是存在一定的相似性呢？**

> volatile 它的实现原理是将变量的值刷新到主内存中，每次读取都从主内存中读取，而不是从线程的工作内存中读取。而ThreadLocal是将主内存的变量copy一份到线程的工作内存中，每次操作的都是线程内工作内存中的变量，天然的隔离性，不需要加锁，也不需要刷新到主内存中，保证了变量的安全性，那么它究竟是如何实现的呢？待会源码分析中揭晓。

## ThreadLocal的使用

ThreadLocal的使用非常简单，只需要创建一个ThreadLocal对象，调用set()、get()、remove()方法即可。

```java
ThreadLocal<String> threadLocal = new ThreadLocal<>();
threadLocal.set("hello");
threadLocal.get();
threadLocal.remove();
```

ThreadLocal创建对象的方式有2种:

- 第一种是直接new一个ThreadLocal对象
```java
ThreadLocal<String> threadLocal = new ThreadLocal<>();
```

- 第二种是使用ThreadLocal的静态方法withInitial()，传入一个Supplier接口的实现类，在没有调用set()方法的情况下，ThreadLocal的初始值就是Supplier #get()方法返回的值
```java
ThreadLocal<String> threadLocal = ThreadLocal.withInitial(() -> "init");
```

ThreadLocal在我们平时的开发中使用的场景并不是太多，大多常用在组件开发上，许多源码中也包含了ThreadLocal，比如Mybatis中的SqlSession，Spring中的TransactionSynchronizationManager等等。

**举个实际使用的栗子：**
```java
public class Demo {
 /**
 * ThreadLocal 线程变量，每个线程都有一个副本，互不干扰
 */
 public final static ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();

 /**
 * 设置值
 * @param value 值
 */
 public static void set(String value) {
 THREAD_LOCAL.set(value);
 }

 /**
 * 测试new Thread()与main线程的ThreadLocal变量值
 */
 public static void main(String[] args) {
 String main = "Hello World!";
 new Thread(() -> {
 THREAD_LOCAL.set(main);
 System.out.println(Thread.currentThread().getName() + ":" + THREAD_LOCAL.get());
 THREAD_LOCAL.remove();
 }).start();
 System.out.println("main:" + THREAD_LOCAL.get());
 }
}

// 结果
main:null
Thread-0:Hello World!
```



## ThreadLocal的源码分析

ThreadLocal 是一个泛型类，泛型的类型即为存储的数据类型，从它的三个方法get()、set()、remove()开始分析

```java
public class ThreadLocal<T> {
 ...
 ThreadLocal.ThreadLocalMap threadLocals = null;
 
 public T get() {
 // 获取当前线程 - 联想到个线程都单独拥有一份共享变量，是不是通过当前线程来处理的呢？继续往下分析
 Thread t = Thread.currentThread();
 // 通过getMap()方法可以看出从当前线程中获取的ThreadLocalMap，此时猜测肯定这个对象存储了当前线程的共享变量
 ThreadLocalMap map = getMap(t);
 // map不为null，说明当前线程的ThreadLocalMap不为null
 if (map != null) {
 // 通过ThreadLocalMap的getEntry()方法获取当前ThreadLocal的Entry
 ThreadLocalMap.Entry e = map.getEntry(this);
 if (e != null) {
 // Entry 存储了变量的值，此处返回
 @SuppressWarnings("unchecked") 
 T result = (T)e.value;
 return result;
 }
 }
 // 设置初始化的值，猜测与ThreadLocal.withInitial()方法有关
 return setInitialValue();
 }

 ThreadLocalMap getMap(Thread t) {
 return t.threadLocals;
 }
 
 public void set(T value) {
 // 获取当前线程
 Thread t = Thread.currentThread();
 // 获取当前线程的ThreadLocalMap
 ThreadLocalMap map = getMap(t);
 // 如果ThreadLocalMap不为null，说明当前线程的ThreadLocalMap不为null
 if (map != null)
 // 将当前ThreadLocal作为key，value作为value存储到ThreadLocalMap中
 map.set(this, value);
 else
 // 如果ThreadLocalMap为null，说明当前线程的ThreadLocalMap为null，继续往下分析
 createMap(t, value);
 }
 
 void createMap(Thread t, T firstValue) {
 // 创建一个ThreadLocalMap，绑定到当前线程
 t.threadLocals = new ThreadLocalMap(this, firstValue);
 }
 ...
}
```

从上面的get/set源码中可以看出，当前的Thread中有一个ThreadLocalMap类型的成员变量threadLocals，在set的时候，如果有数据，用当前线程的ThreadLocalMap存储，如果没有数据，会指向一个新的new ThreadLocalMap()对象。

猜测此当前线程中的ThreadLocalMap变量就是实现线程隔离的关键，set的时候，实际的变量数据是添加到了当前的线程类中的ThreadLocalMap中存储，以下是Thread中的源码
```java
public class Thread implements Runnable {
 ...
 ThreadLocal.ThreadLocalMap threadLocals = null;
 ...
}
```

咦，在Thread源码中发现ThreadLocalMap居然是ThreadLocal的内部类，从之前的分析上，看名知意，这应该是个Map结构，那么ThreadLocalMap中存储结构是怎样呢？继续看源码
```java
static class ThreadLocalMap {
 ...
 // Entry 继承了弱引用 WeakReference，key 即为 ThreadLocal，value 为存储的数据
 static class Entry extends WeakReference<ThreadLocal<?>> {
 /** The value associated with this ThreadLocal. */
 Object value;
 
 // key 即为 ThreadLocal，value 为存储的数据
 Entry(ThreadLocal<?> k, Object v) {
 // 指定k变量也就是ThreadLocal为弱引用
 super(k);
 value = v;
 }
 ...
 }
 
 // Entry数组，用于存储数据
 private Entry[] table;
 
 private Entry getEntry(ThreadLocal<?> key) {
 // 计算key的hash值
 int i = key.threadLocalHashCode & (table.length - 1);
 // 通过hash计算的值定位取出数组中的Entry
 Entry e = table[i];
 if (e != null && e.get() == key)
 return e;
 else
 return getEntryAfterMiss(key, i, e);
 }
 ...
}
```

以上源码可以观察到ThreadLocalMap类中存储的是一个Entry数组，Entry是ThreadLocal的内部类，Entry继承了弱引用 `WeakReference`，key即为 `ThreadLocal`，value为线程存储的数据

:::tip{title="为什么一个线程可以绑定多个ThreadLocal呢？"}
Thread中存在一个ThreadLocalMap属性，ThreadLocalMap 本身就是基于 Entry[] 实现存储数据的，其中 ThreadLocal 作为key，ThreadLocal的值作为value，这种数据结构就是一个线程可以绑定多个ThreadLocal的原因

回想到set方法，直接是将值set到了当前Thread中的ThreadLocalMap中，线程与线程之间的变量都存储在自己当前线程中，保证了并发下变量的安全性，这也是隔离性实现的原理
:::

那么什么是引用呢？接下来我们聊下什么是引用，然后再来继续分析源码

## “强软弱虚”引用

看过JVM虚拟机的小伙伴都了解，在垃圾回收机制中，判断对象是否被回收的标准就是是判断对象是否引用链可达，而判断标准主要分为4种引用，分别是 **强、软、弱、虚**


### 什么是一个引用

`Object o = new Object()` 这就是一个引用了，一个变量指向new出来的对象，这就叫以个引用。当我们new出来一个象，在java语言里是不需要手动回收的，C和C++是需要的，在这种情况下，java的垃圾回收机制会自动的帮你回收这个对象。

再开始之前我们需要重写了一个方法叫 `finalize()`，在垃圾回收的过程中，各种引用它不同的表现，垃圾回收的时候，它是会调用finalize()，通过重写这个方法之后我们能观察到，它什么时候被垃圾回收了，什么时候被调用了。

```java
public class M {
 @Override
 protected void finalize() throws Throwable {
 System.out.println("finalize");
 }
}
```

:::warning{title="平常的工作中需要重写 finalize() 吗"}
这个方法为了让我们去观察结果用的，并不是说以后在什么情况下需要重写这个方法。可以在以后面试时遇到相关问题，可以进行阐述，让面试官了解到你造火箭的能力。
:::


### 强引用（Strongly Reference）

是最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“Object obj=new Object()”这种引用关系。无论任何情况下，**只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象**

### 软引用（Soft Reference）
 
软引用是用来描述一些还有用，但非必须的对象。**只被软引用关联着的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常**。 在JDK 1.2版之后提供了SoftReference类来实现软引用。
 
### 弱引用（Weak Reference）

弱引用也是用来描述那些非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生为止。**当垃圾收集器开始工作，无论当前内存是否足够，都会回收掉只被弱引用关联的对象**。 在JDK 1.2版之后提供了WeakReference类来实现弱引用

### 虚引用（Phantom Reference）

虚引用也称为“幽灵引用”或者“幻影引用”，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。**为一个对象设置虚引用关联的唯一目的只是为了能在这个对象被收集器回收时收到一个系统通知**。在JDK1.2版之后提供了PhantomReference类来实现虚引用


## 弱引用的问题


强软弱虚引用我们已经了解清楚了，那**此时回想一下，弱引用的特点是什么？结合我们的 ThreadLocal 源码，如果此时 ThreadLocalMap中的 key -> 也就是ThreadLocal对象被回收了，会怎么样？**


![image.png](https://blog.liushigong.cn/static/img/4b8fb3e45dc92b497e54e329a6b70c6b.image.webp)

此处就会引发了一个致命问题，如果ThreadLocal被回收了，那么ThreadLocalMap中的Entry的key就为null，那么value就无法获取了，但此时Entry对象还是存在的，这样就导致了内存泄漏

所以ThreadLocalMap中的Entry需要被回收，那么ThreadLocalMap中的Entry是如何被回收的呢？继续看源码

```java
// ThreadLocal #remove()
public void remove() {
 ThreadLocalMap m = getMap(Thread.currentThread());
 if (m != null)
 m.remove(this);
}

// ThreadLocalMap #remove()
private void remove(ThreadLocal<?> key) {
 Entry[] tab = table;
 int len = tab.length;
 int i = key.threadLocalHashCode & (len-1);
 for (Entry e = tab[i];
 e != null;
 e = tab[i = nextIndex(i, len)]) {
 if (e.get() == key) {
 // 调用 Reference #clear() 方法，清除弱引用
 e.clear();
 // 清除数组中的Entry
 expungeStaleEntry(i);
 return;
 }
 }
}

// ThreadLocalMap #expungeStaleEntry()
private int expungeStaleEntry(int staleSlot) {
 Entry[] tab = table;
 int len = tab.length;
 
 // 将Entry中的value值设置为null，将Entry对象设为null，方便GC回收
 // expunge entry at staleSlot
 tab[staleSlot].value = null;
 tab[staleSlot] = null;
 size--;
 
 // Rehash until we encounter null
 Entry e;
 int i;
 for (i = nextIndex(staleSlot, len);
 (e = tab[i]) != null;
 i = nextIndex(i, len)) {
 ThreadLocal<?> k = e.get();
 if (k == null) {
 e.value = null;
 tab[i] = null;
 size--;
 } else {
 int h = k.threadLocalHashCode & (len - 1);
 if (h != i) {
 tab[i] = null;
 
 // Unlike Knuth 6.4 Algorithm R, we must scan until
 // null because multiple entries could have been stale.
 while (tab[h] != null)
 h = nextIndex(h, len);
 tab[h] = e;
 }
 }
 }
 return i;
}


```

此时分析remove方法，从源码中可以看出，remove方法是通过当前线程获取ThreadLocalMap，然后调用ThreadLocalMap的remove方法

ThreadLocalMap #remove方法是通过key的hash值定位到数组中的Entry，调用 Reference #clear 清除引用

然后调用expungeStaleEntry方法，将Entry中的value值设置为null，将Entry对象设为null，方便GC回收

此时就完美解决了ThreadLocal内存泄漏的问题，这也是为什么我们在使用了ThreadLocal之后，必须调用remove方法的原因，**属于强制性的操作，可千万别埋坑啊。**

对于其他源码中的方法，就不一一分析了，有兴趣的小伙伴可以自行研究，比如hash计算的方法等，这里只是分析了ThreadLocal实现原理，以及存在的内存泄漏问题、解决方案的核心源码。

## 总结

总结一下，开篇聊了 ThreadLocal 是什么以及使用，通过源码分析了它是怎么做到线程的隔离，本质就是每个Thread中都有一份 ThreadLocal.ThreadLocalMap 的属性，key为ThreadLocal，value是变量值，通过ThreadLocal #get() 方法，拿 ThreadLocal 当前的this对象从Thread中获取值。

接着从源码观察到 ThreadLocal 的内部类 ThreadLocalMap 中，它的实现子类Entry继承了弱引用WeakReference，根据弱引用的特点，分析其存在的内存泄漏的风险。又通过源码中remove方法了解到它是怎么解决内存泄漏的问题得。

在我们平时 ThreadLocal 的使用中，做到了知其然，知其所以然，才能更好的使用它。

并发编程 - ThreadLocal 详解与源码分析

JUC 基础知识汇总，了解并发编程的全貌



# JUC 基础知识总结

## 线程

### 线程状态
NEW：
> Thread对象被创建出来了，但是还没有执行start方法。

```java
public static void main(String[] args) throws InterruptedException {
 Thread t1 = new Thread(() -> {
 
 });
 System.out.println(t1.getState());
}
```

RUNNABLE：
> Thread对象调用了start方法，就为RUNNABLE状态（CPU调度/没有调度）

```java
public static void main(String[] args) throws InterruptedException {
 Thread t1 = new Thread(() -> {
 while(true){

 }
 });
 t1.start();
 Thread.sleep(500);
 System.out.println(t1.getState());
}
```

BLOCKED：
> synchronized没有拿到同步锁，被阻塞的情况

```java
public static void main(String[] args) throws InterruptedException {
 Object obj = new Object();
 Thread t1 = new Thread(() -> {
 // t1线程拿不到锁资源，导致变为BLOCKED状态
 synchronized (obj){

 }
 });
 // main线程拿到obj的锁资源
 synchronized (obj) {
 t1.start();
 Thread.sleep(500);
 System.out.println(t1.getState());
 }
}
```

WAITING：
> 调用wait方法就会处于WAITING状态，需要被手动唤醒

```java
public static void main(String[] args) throws InterruptedException {
 Object obj = new Object();
 Thread t1 = new Thread(() -> {
 synchronized (obj){
 try {
 obj.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 });
 t1.start();
 Thread.sleep(500);
 System.out.println(t1.getState());
}
```

TIME_WAITING：
> 调用sleep方法或者join方法，会被自动唤醒，无需手动唤醒

```java
public static void main(String[] args) throws InterruptedException {
 Thread t1 = new Thread(() -> {
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 });
 t1.start();
 Thread.sleep(500);
 System.out.println(t1.getState());
}
```

BLOCKED、WAITING、TIME_WAITING：都可以理解为是阻塞、等待状态，因为处在这三种状态下，CPU不会调度当前线程

TERMINATED：
> run方法执行完毕，线程生命周期到头了

```java
public static void main(String[] args) throws InterruptedException {
 Thread t1 = new Thread(() -> {
 try {
 Thread.sleep(500);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 });
 t1.start();
 Thread.sleep(1000);
 System.out.println(t1.getState());
}
```

### 线程方法

获取当前线程
```java
Thread thread = Thread.currentThread();
```

获取栈帧
```java
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();

Map<Thread, StackTraceElement[]> allStackTraces = Thread.getAllStackTraces();
```

获取线程名称
```java
Thread.currentThread().getName();
```

设置线程调度优先级
> java中给线程设置的优先级别有10个级别，从1~10任取一个整数。
```java
Thread.currentThread().setPriority(1);
```

线程的让步
> 可以通过Thread的静态方法yield，让当前线程从运行状态转变为就绪状态。
```java
Thread.yield();
```

线程的等待和唤醒
> 可以让获取synchronized锁资源的线程通过wait方法进去到锁的等待池，并且会释放锁资源
> 
> 可以让获取synchronized锁资源的线程，通过notify或者notifyAll方法，将等待池中的线程唤醒，添加到锁池中
> 
> notify随机的唤醒等待池中的一个线程到锁池
> 
> notifyAll将等待池中的全部线程都唤醒，并且添加到锁池

在调用wait方法和notify以及norifyAll方法时，必须在synchronized修饰的代码块或者方法内部才可以，因为要操作基于某个对象的锁的信息维护。

```java
synchronized (MiTest.class) { 
 MiTest.class.wait();
 MiTest.class.notifyAll(); 
}
```

线程的结束方式
> interrupt方式

```java
public static void main(String[] args) throws InterruptedException {
 // 线程默认情况下， interrupt标记位：false
 System.out.println(Thread.currentThread().isInterrupted());
 // 执行interrupt之后，再次查看打断信息
 Thread.currentThread().interrupt();
 // interrupt标记位：ture
 System.out.println(Thread.currentThread().isInterrupted());
 // 返回当前线程，并归位为false interrupt标记位：ture
 System.out.println(Thread.interrupted());
 // 已经归位了
 System.out.println(Thread.interrupted());

 // =====================================================
 Thread t1 = new Thread(() -> {
 while(!Thread.currentThread().isInterrupted()){
 // 处理业务
 }
 System.out.println("t1结束");
 });
 t1.start();
 Thread.sleep(500);
 t1.interrupt();
}

```


## JMM
JMM (Java Memory Model) 即为Java内存模型

Java内存模型规定了所有的变量都存储在主内存中，每条线程都有自己的工作内存，线程的工作内存中保存了被该线程使用的变量的主内存副本，线程对该变量的所有读写操作都必须在工作内存中进行而不能直接读写主内存中的数据，不同的线程之间也无法访问对方工作内存中的变量，线程间变量值的传递都需要通过主内存来完成

### 特性：
原子性、可见性、有序性

### 内存间的交互

 1. lock：锁定
 > 作用于主内存的变量，它把一个变量标识为一条线程独占的状态

 2. unlock：解锁
 > 作用域主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

 3. read：读取
 > 作用域主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用

 4. load：载入
 > 作用于工作内存的变量，它把read操作从主内存中得到的变量值放入到工作内存的变量副本中

 5. usr：使用
 > 作用于工作内存的变量，它把工作内存中的一个变量的值传给存储引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时会执行这个操作

 6. assign：赋值
 > 作用于工作内存的变量，它把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令执行这个操作

 7. store：存储
 > 作用于工作内存的变量，它把工作内存中的一个变量的值传送到主内存中，以便write操作使用

 8. write：写入
 > 作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中 



## volatile
是Java提供的一种轻量级的同步机制，用来确保将变量的更新操作通知到其他线程

### 特性：
可见性
> 通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值的方式实现可见性的

有序性
> 禁止指令重排序优化
> 通过内存屏障指令保证处理器不会乱序

### 问题：
### volatile 是怎么保证可见性的？

volatile 是通过 **MESI 缓存一致性协议** 来保证可见性的

首先 cpu 会根据共享变量是否带有 volatile 字段，来决定是否使用MESI协议保证缓存一致性。
如果有volatile，汇编层面会对变量加上Lock前缀，当一个线程修改变量的值后，会马上经过store、write等原子操作修改主内存的值（如果不加Lock前缀不会马上同步），为什么监听到修改会马上同步呢？就是为了触发cpu的嗅探机制，及时失效其他线程变量副本。

##### MESI 缓存一致性协议
> 
* M 修改 (Modified) 当一个线程要修改便令
* E 独享、互斥 (Exclusive) 当一个线程拿到了共享变量，此时为独享状态！
* S 共享 (Shared) 当多个线程都拿到了共享变量，此时为共享状态！
* I 无效 (Invalid) 线程丢弃了自己工作内存中的变量，为无效状态！

##### cpu总线嗅探机制
cpu总线嗅探机制监听到这个变量被修改，就会把其他线程的变量副本由共享S置为无效I，当其他线程在使用变量副本时，发现其已经无效，就回去主内存中拿一个最新的值。

##### Lock前缀的作用
使CPU缓存数据立即写会主内存（Volatile修饰的变量会带lock前缀）
触发总线嗅探机制和缓存一致性协议MESI来失效其他线程的变量

### volatile 是怎么保证有序性的？

> 被 volatile 修饰的变量存在一个 lock 前缀的指令，lock 前缀指令实际上相当于一个内存屏障
>
* 确保指令重排序时不会将其后面的代码排到内存屏障之前
* 确保指令重排序时不会将其前面的代码排到内存屏障之后
* 确保在执行到内存屏障修饰的指令时前面的代码全部执行完成
* 强制将线程工作内存中的值的修改刷新至主内存中
* 如果是写操作，则会导致其他线程工作内存中的缓存数据失效


## 本地线程 ThreadLocal

ThreadLocal意为线程本地变量，用于解决多线程并发时访问共享变量的问题。

在多线程的场景下，当有多个线程对共享变量进行修改的时候，就会出现线程安全问题，即数据不一致问题。常用的解决方法是对访问共享变量的代码加锁（synchronized或者Lock）。但是这种方式对性能的耗费比较大。

在JDK1.2中引入了ThreadLocal类，来修饰共享变量，使每个线程都单独拥有一份共享变量，这样就可以做到线程之间对于共享变量的隔离问题。

### 实现原理
- ThreadLocal 有一个内部类 ThreadLocalMap 
- ThreadLocalMap 是一个自定义的哈希映射，仅适用于维护线程本地值。
- ThreadLocalMap 的内部类 Entry 继承了弱引用 WeakReference
- 每个 Thread 中都存储着一个成员变量 ThreadLocal.ThreadLocalMap
- ThreadLocalMap 本身就是基于 Entry[] 实现的，因为一个线程可以绑定多个ThreadLocal，其中 ThreadLocal 作为key，存储的值为value。
- ThreadLocalMap 的key是一个弱引用，弱引用的特点是，即便有弱引用，在GC时，也必须被回收。这里是为了在ThreadLocal对象失去引用后，如果key的引用是强引用，会导致ThreadLocal对象无法被回收
```java
public class ThreadLocal<T> {
 ...
 
 static class ThreadLocalMap {
 static class Entry extends WeakReference<ThreadLocal<?>> {
 /** The value associated with this ThreadLocal. */
 Object value;

 Entry(ThreadLocal<?> k, Object v) {
 super(k);
 value = v;
 }
 }
 
 /**
 * The initial capacity -- MUST be a power of two.
 */
 private static final int INITIAL_CAPACITY = 16;

 /**
 * The table, resized as necessary.
 * table.length MUST always be a power of two.
 */
 private Entry[] table;
}
```

### ThreadLocal内存泄漏问题
在使用的过程中，如果key的引用丢失，也就是 ThreadLocal 的引用丢失后，key会因为弱引用被GC回收，在当前线程内部的 ThreadLocalMap 中，就没有key在指向的value，value无法被获取，更无法被回收，导致value的值一直占用内存，造成内存泄漏。

:::warning{title="解决"}
只需要在使用完毕ThreadLocal对象之后，及时的调用remove方法，移除Entry即可
:::

# 原子变量类

### 什么是CAS
CAS （Compare-and-Swap）就是比较并交换（本质是 `乐观锁` ）

CAS指令需要三个操作数，分别是变量的内存地址，用V表示，旧值用A表示，新值用B表示。CAS指令在执行时，当且当V符合A时，处理器才会用B更新V的值，否则就不更新。不管是否更新了V值，都会返回V的旧值，这个处理过程是一个原子操作，执行期间不会被其他线程中断

### 什么是ABA问题
如果变量V初次读取的变量值是A值，在这段期间它的值曾经被改为B值，后来又被改为A值，那么CAS操作会误认为它从来没有被改变过，这个问题被称为 `ABA` 问题

### 怎么解决ABA问题
解决办法是在每一个线程对变量进行赋值操作时加上版本号信息。
原子类中提供了 AtomicStampedReference 类
通过控制变量值的版本来保证CAS的正确性，可解决CAS的 `ABA` 问题

### 自旋时间过长问题
可以指定CAS自旋次数，如果超过次数，直接挂失败/挂起线程。（自旋锁、自适应自旋锁）
可以在CAS失败之后，把这个操作暂存起来，后面等待获取结果，将暂存的操作全部执行，再返回最后的结果


### 原子类
原子类基于CAS算法实现线程安全，无需加锁，性能高效。

原子操作类可分为五种类型：
基本数据类型原子类、数组类型原子类、引用类型原子类、对象的属性修改类型、高性能原子类

#### 基本数据类型原子类
> AtomicInteger、AtomicLong、AtomicBoolean

#### 数组类型原子类
> AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

#### 引用类型原子类
> AtomicReference、、AtomicReferenceArray、AtomicStampedReference

#### 基本数据类型原子类
> AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdate

注意：对象的属性修改类型都是抽象类，所以在使用之前必须使用静态方法newUpdater创建一个新的更新器，然后参数传入需要更新的类和属性，属性名。同时待修改的属性必须用public volatile关键字修饰。

#### 高性能原子类
> DoubleAccumulator、DoubleAdder、LongAccumulator、LongAdder、Striped64

以LongAdder为例，引入的目的是解决高并发环境下AtomicLong的自旋瓶颈问题。
思想概述：采用分段的思想，将value值分散到一个数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行CAS操作，最后再把这些段的值相加得到最终的值


# AbstractQueuedSynchronizer

## 队列同步器的原理分析

### 概述
队列同步器AbstractQueuedSynchronizer（以下简称同步器），是用来构建锁或者其他同步组件的基础框架，它使用了一个volatile int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作，它是大部分同步需求的基础。

同步器的设计是基于模板方法模式的，也就是说，使用者需要继承同步器并重写指定的 方法，随后将同步器组合在自定义同步组件的实现中，并调用同步器提供的模板方法，而这些 模板方法将会调用使用者重写的方法。

重写同步器指定的方法时，需要使用同步器提供的如下3个方法来访问或修改同步状态。 
>* getState()：获取当前同步状态。
>* setState(int newState)：设置当前同步状态。 
>* compareAndSetState(int expect,int update)：使用CAS设置当前状态，该方法能够保证状态 设置的原子性。

![同步状态方法](https://img-blog.csdnimg.cn/f05d1f8fd4844a02832094703b853cea.png)

同步状态可以表示任意状态，例如：

 ReentrantLock 中用它来标识所有者线程已经重复获取该锁的次数
 Semaphore 用它来表示剩余的许可数量
 FutureTask 用它来表示任务的状态（尚未开始、正在运行、已完成以及已注销）

在同步器类中还可以自行管理一些额外的状态变量：

 ReentrantLock 保存了锁当前所有者的信息，能区分某个获取操作是重入的还是竞争的
 

同步器可重写的方法：
|方法名称 | 描述|
|--|--|
|protected boolean tryAcquire(int arg) | 独占式获取同步状态，实现该方法需要查询当前状态并判断同步状态是否符合预期，然后再进行CAS设置同步状态 |
|protected boolean tryRelease(int arg) | 独占式释放同步状态，等待获取同步状态的线程将有机会获取同步状态 |
|protected int tryAcquireShared(int arg) | 共享式获取同步状态，返回大于等于0的值，表示获取成功，反之，获取失败 |
|protected boolean tryReleaseShared(int arg) | 共享式释放同步状态 |
|protected boolean isHeldExclusively() | 当前同步器是否在独占模式下被线程占用，一般该方法标识是否被当前线程所独占 |

同步器提供的模板方法基本上分为3类：独占式获取与释放同步状态、共享式获取与释放同步状态和查询同步队列中的等待线程情况。自定义同步组件将使用同步器提供的模板方法来实现自己的同步语义。

### 个人理解
ReentrantLock、 ReentrantReadWriteLock和CountDownLatch等锁实际上是内部定义的类实现的，同步器是实现锁的关键，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。锁的实现又分为互斥锁与共享锁,分别对应同步器的独占式与共享式操作同步状态。

![AQS的实现](https://img-blog.csdnimg.cn/954a5039aaaa44139aa3b26f82e7a964.png)

## 队列同步器的实现分析

### 同步队列

同步器依赖内部的同步队列（一个FIFO双向队列）来完成同步状态的管理，当前线程获取 同步状态失败时，同步器会将当前线程以及等待状态等信息构造成为一个节点（Node）并将其 加入同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点中的线程唤醒，使其再 次尝试获取同步状态。

同步队列中的节点（Node）用来保存获取同步状态失败的线程引用、等待状态以及前驱和后继节点，节点的属性类型与名称以及描述。
![双向队列](https://img-blog.csdnimg.cn/6ab32d9bd02b454588391c8bef7c1d7a.png)




# ReentrantLock

### ReentrantLock 的实现原理
ReentrantLock底层是基于AQS实现的，通过AQS维护的 volatile 的 state 变量来实现锁操作的。
ReentrantLock实现了Lock接口，并提供了与synchronized相同的互斥性和内存可见性。
与synchronized一样，ReentrantLock也提供了可重入的加锁语义。

JUC 基础知识总结

baidu-site-verification

本人自己的博客，对工作与学习过程中的总结、一些场景设计的实现方案、遇到过的疑难问题与解决、以及面试总结等。