一、初识linux

1. linux系统组成

• linux系统内核
  • 内核提供系统最核心功能，如调度cpu、调度内存、调度文件系统、调度网络通讯、调度IO等
• 系统级应用程序
  • 可以理解为出厂自带程序，如文件管理器、任务管理器、图片查看、音乐播放等

linux系统发行版：ubantu、centos、debian

二、linux基础命令

1. 目录结构

树形结构，linux没有盘符概念，所有文件都在根目录/下。

windows中层级关系用 \ 表示；linux中层次关系用 / 表示，开头的 / 表示根目录

2. 命令入门

command [-option] [parameter]

• command 命令本身
• -option 控制命令的行为细节
• parameter 命令参数，多用于命令的指向目标

3. 目录切换

cd [linux路径]

• cd命令无需选项，只有参数，表示要切换到哪个目录下
• cd命令直接执行，不写参数，表示回到用户的HOME目录

4. 相对路径、绝对路径和特殊路径符

绝对路径：以根目录为起点，路径描述以 / 开头

相对路径：以当前目录为起点，路径描述无需以 / 开头

特殊路径符：. - 当前目录；.. - 上一级目录；~ HOME目录

5. 创建目录命令 mkdir

6. 文件操作命令（touch、cat、cp、mv）

7. 查找命令（which、find）

通过which命令，查看所使用的一系列命令的程序文件存放在哪里。语法：which 要查找的命令

通过fing命令去搜索指定的文件。语法：find 起始路径 -name "被查找文件名"，支持使用通配符 * 来做模糊查询。

8. grep、wc和管道符

可以通过grep命令，从文件中通过关键字过滤文件行。语法：grep [-n] 关键字 文件路径

可以通过wc命令统计文件的行数、单词数量等。语法：wc [-c -m -l -w] 文件路径

管道符 | 的含义是蒋管道符左边的命令结果，作为右边命令的输入

9.echo、tail和重定向符

可以使用echo命令在命令行内输出指定内容。语法：echo 输出的内容

可以通过将命令用反引号 ` 将其包围，被包围的内容会作为命令执行。pwd

重定向符：>和>>

• 1>，将左侧命令的结果覆盖写入符号右侧指定的文件中
• 2>>，将左侧命令的结果追加到符号右侧指定的文件中

可以通过tail命令查看文件尾部内容，跟踪文件的最新更改。语法：tail [-f -num] linux路径

10. vim编辑器

11. 三种工作模式

命令模式 Command mode

输入模式 Insert mode

底线命令模式 Last line mode

三、用户和权限

1. root用户

拥有最大权限的账户名：root 超级管理员

• 普通用户的权限，一般在其HOME目录内是不受限的
• 一旦出了HOME目录，大多数地方普通用户仅有只读和执行权限，无修改权限

可以通过su命令切换账户。语法：su [-] [用户名]

可以通过exit命令退回上一个用户。

可以通过sudo命令，为普通命令授权，临时以root身份执行。语法：sudo 其他命令

• 在其他命令之前带上sudo，即可为这一条命令临时赋予root授权
• 使用sudo之前需要为普通用户配置sudo认证

1.1 为普通用户配置sudo认证

• 切换到root用户，执行visudo命令，会自动通过vi编辑器打开 /etc/sudoers
• 在文件最后添加 user ALL=(ALL) NOPASSWD:ALL
  • 其中NOPASSWD:ALL表示使用sudo命令无需输入密码
• 最后通过wq保存

2. 用户、用户组管理

linux系统中可以：

• 配置多个用户
• 配置多个用户组
• 用户可以加入多个用户组

linux关于权限管控有2个级别：

• 针对用户的权限控制
• 针对用户组的权限控制

groupadd/groupdel 创建/删除用户组

useradd [-g -d]/userdel [-r] 创建/删除用户组

id [用户名] 查看用户所属组

usermod -aG 将指定用户加入指定用户组

3. 查看权限控制

可以通过ls -l 以列表形式查看内容并显示权限细节。

权限细节分为10个槽位：

-/d/l（-表示文件；d表示文件夹；l表示软链接） + 所属用户权限 + 所属用户组权限 + 其他用户权限（r/w/x 或 -）

r读 w写 x执行 -无

4. 修改权限控制 - chmod/chown

可以使用chmod命令修改文件、文件夹的权限信息。语法：chmod [-R] 权限 文件或文件夹

注意：只有文件、文件夹的所属用户或root用户才可以修改。

4.1 权限的数字序号

第一位表示用户权限，第二位表示用户组权限，第三位表示其他用户权限

细节：r 记为4，w 记为2，x 记为1

可以使用chown命令修改文件、文件夹的所属用户和用户组。chown [-R] [用户] [:] [用户组] 文件或文件夹

四、linux实用操作

1. 各类小技巧

• 强制停止

  ctrl + c 强制停止

• 退出、登出

  ctrl + d 退出或登出

• 历史命令搜索

  history 查看历史输入过的命令

  ! 命令前缀，自动执行上一次匹配前缀的命令

  ctrl + r 输入内容匹配历史命令

• 光标移动

  • ctrl + a，跳到命令开通
  • ctrl + e，跳到命令结尾
  • ctrl + 键盘左键，向左跳一个单词
  • ctrl + 键盘右键，向右跳一个单词

• 清屏 ctrl + l 或者 clear 命令

2. 软件安装

yum命令：RPM包软件管理器，用于自动化安装配置linux文件，并可以自动解决依赖问题。语法：yum [-y] [install | remove | search] 软件名称

apt命令- 扩展：CentOS使用yun管理器，Ubuntu使用apt管理器。语法：apt [-y] [install | remove | search] 软件名称

3. systemctl

命令控制：启动、停止、开机自启。能够被systemctl管理的软件，一般称之为服务。语法：systemctl start | stop | status | enable | disable 服务名

系统内置的服务包括:

• NetwordManager，主网络服务
• network，副网络服务
• firewalld，防火墙服务
• sshd，ssh服务（FinalShell远程登录linux使用的就是中国服务）

除了内置的服务以外，部分第三方软件安装后也可以以systemctl进行控制。

4. 软链接

ln命令创建软连接，可以将文件、文件夹链接到其他位置，类似windows系统中的快捷方式。语法：ln -s 参数1 参数2

5. 日期、时区

可以通过date命令在命令行中查看系统时间。语法：date [-d] [+格式化字符串 %Y %y %m %d %H %M %S %s]

5.1 data命令进行日期加减

支持的时间标记有：year / month / day / hour / minute / second

5.2 修改linux时区

rm -f /etc/localtime

sudo ln -s /usr/share/zoneinfo/Asia/Shagnhai /etc/localtime

可以通过ntp程序自动校准系统时间

6. IP地址、主机名

可以通过 ifconfig 命令查看本机ip地址

6.1 修改主机名

• 可以通过 hostname 命令查看系统主机名
• 可以通过 hostnamectl set-hostname 命令修改主机名

7. 网络传输

可以通过 ping 命令检查指定网络服务器释放可联通。语法ping [-c num] ip或主机名

可以通过 wget 在命令行内下载网络文件，非交互式的文件下载器。语法：wget [-b] url

可以通过 curl 返送http网络请求，可以用于下载文件、获取信息等。语法：curl [-O] url

7.1 端口

可以通过 netstat 命令查看端口占用情况。语法：netstat -anp | grep 端口号

8. 进程管理

每一个程序在运行的时候，便被操作系统注册为系统中的一个进程。并会为每一个进程分配一个独有的进程ID（进程号）。

可以通过 ps 命令查看系统中进程信息。语法：ps [-e -f]

可以通过 kill 命令关闭进程。语法：kill [-9] 进程ID

9. 主机状态

可以通过 top 命令查看CPU、内存使用情况，类似于任务管理器。

可以通过 df 命令 查看磁盘的使用情况。语法：df [-h]

可以使用 iostat 查看CPU、磁盘相关信息。语法：iostat [-x] [num1] [num2]

可以使用sar 命令查看网络的相关统计。语法：sar -n DEV num1 num2

10. 环境变量

环境变量史操作系统在运行时，记录的一些关键信息，用以辅助系统运行。可以通过 env 命令查看当前系统中记录的环境变量。环境变量是一种KeyValue型结构。

10.1 $符号

在linux系统中，$符号被用于取"变量"的值。语法：${PATH}

10.2 自行设置环境变量

语法：export 变量名=变量值

• 永久生效
  • 针对当前用户生效，配置在当前用户的~/.bashrc文件中
  • 针对所有用户生效，配置在系统的/etc/profile文件中
  • 通过语法：source 配置文件，进行立刻生效

11. 上传、下载

可以通过 rz、sz 命令进行文件上传下载。命令需要通过apt -y install lrzsz 安装。

12. 压缩、解压缩

12.1 tar命令压缩解压缩文件

linux和Mac系统常用有两种压缩格式，后缀分别是：

• .tar，称之为tarball，归档文件，即简单的将文件组装到一个.tar的文件内，并没有太多文件体积的减少，仅仅是简单封装。
• .gz，也常见为.tar.gz，gzip格式压缩文件，即使用gzip压缩算法将文件压缩到一个文件内，可以极大的减少压缩的体积。

使用 tar 命令均可以对这两种格式进行压缩和解压缩的操作。语法：tar [-c -v -x -f -z -C] 参数1 参数2 ... 参数N

12.2 zip/unzip命令压缩解压缩文件

可以使用 zip 命令压缩文件为zip压缩包。语法：zip [-r] 参数1 参数2 ... 参数N

• 被压缩的包包含文件夹时，需要使用-r选项

可以使用 unzip 命令解压zip压缩包。语法：unzip[-d] 参数

13. scp命令

scp 命令是cp命令的升级版，即ssh cp，通过SSH协议完成的文件复制。可以通过scp 命令，在不同的linux服务器中，通过SSH协议相互传输文件。

MyBatis

1. 什么是MyBatis

• 

  MyBatis是一款优秀的持久层框架，用于简化JDBC开发

• http://www.mybatis.cn/

1.1 持久层

• 负责将数据保存到数据库的一层代码
• JavaEE三层架构：表现层、业务层、持久层

1.2 框架

• 框架就是一个半成品软件，是一套可重用的、通用的、软件基础代码模型
• 在框架基础之上构架软件编写更加高效、规范、通用、可扩展

1.3 JDBC缺点

1. 硬编码
   • 注册驱动，获取连接
   • SQL语句
2. 操作繁琐
   • 手动设置参数
   • 手动封装结果集

1.4 MyBatis简化

2. MyBatis快速入门

查询user表中所有数据

1. 创建user表，添加数据

2. 创建模块，导入坐标

3. 编写MyBatis核心配置文件 --> 替换连接信息，解决硬编码问题

4. 编写SQL映射文件 --> 统一管理sql语句，解决硬编码问题

5. 编码

   // 1. 定义POJO类
   public class User{}
   // 2. 加载核心配置文件，获取SqlSeesionFactory对象
   String resource = "mybatis-config.xml";
   InputStream in = Resources.getResourceAsStream(resource);
   SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
   // 3. 获取SqlSession对象，执行SQL语句
   SqlSession session = factory.openSession();
   List<User> users = session.selectList("test.selectAll");
   // 4. 释放资源
   

2.1 解决SQL映射文件的警告提示

• 产生原因：Idea和数据库没有建立连接，不识别表信息
• 解决方式：在Idea中配置MySQL数据库连接

3. Mapper代理开发

• 解决原生方式中的硬编码
• 简化后期执行SQL

// 3. 获取接口代理对象
UserMppaer userMapper = sqlSession.getMapper(userMapper.class);
// 4. 执行方法，其实就是执行sql语句
List<User> users = userMapper.selectAll();

3.1 入门案例

1. 定义与SQL映射文件同名的Mapper接口，并且将Mapper接口与SQL映射文件放置同一目录下
2. 设置SQL映射文件的namespace属性为Mapper接口全限定名
3. 在Mapper接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型一致
4. 编码
   1. 通过SqlSession的getMapper()方法获取Mapper接口的代理对象
   2. 调用对应方法完成sql执行

细节：如果Mapper接口名称与SQL映射文件名称相同，并在同一目录下，则可以使用包扫描的方式简化SQL映射文件的加载。

4. MyBatis核心配置文件

https://mybatis.org/mybatis-3/zh/index.html

• configuration（配置）
  • properties（属性）
  • settings（设置）
  • typeAliases（类型别名）
  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • plugins（插件）
  • environments（环境配置）
    • environment（环境变量）
      • transactionManager（事务管理器）
      • dataSource（数据源）
  • databaseIdProvider（数据库厂商标识）
  • mappers（映射器）

细节：注意遵守各个标签的前后顺序

5. 配置文件完成增删改查

1. 编写接口方法：Mapper接口
2. 编写SQL语句：SQL映射文件
3. 执行方法，测试

数据库的字段名称和实体类的属性名称不一样导致不能自动封装：

1. 起别名：对不一样的列名起别名，让别名和实体类的属性名一样。

   • 缺点：每次查询都要定义一次别名

   • 解决：sql片段brand_column

     <sql id="xxx">
     id, brand_name as bradName
     </sql>
     

2. resultMap：

   <!--id：唯一标识；type：映射类型，支持别名-->
   <resultMap id="xxxResultMap" type="xxx">
   	<!--id：主键映射；result：一般自动映射；cilumn表的列名，property实体类的属性名-->
   	<result column="xxx_xxx" property="xxxXxx"/>
   </resultMap>
   

5.1 参数占位符

1. {}：会将其替换为？，防止SQL注入

2. ${}：拼sql，存在SQL诸如问题
3. 使用时机：
   • 参数传递时：#{}
   • 表名或列名不固定的情况下：${}

5.2 参数类型：parameterType（可省略）

SQL语句设置多个参数的几种方式？

1. 散装参数：需要使用@Param("SQL中参数占位符名称")
2. 实体类封装参数：只需要保证SQL中参数名与实体类属性名对应上
3. map集合：只需要保证SQL中参数名和map集合的键的名称对应上

5.3 查询 - 动态条件查询

SQL语句会随着用户输入或外部条件变化而变化。

• if 用于判断参数是否有值，使用test属性进行条件判断
  • 问题：第一个条件不需要逻辑运算符 and/or
  • 恒等式
  • 替换where关键字
• choose(when ptherwise)
• trim(where set)
• foreach

5.4 添加 - 主键返回

数据添加成功后，需要获取插入数据库数据的主键的值

<insert useGeneratedKeys="true" keyProperty="id">
</insert>

5.5 修改 - 动态字段修改

<update id="update">
    update xx from xx
	<set>
        <if test="name!=null and name!=''">
            name = #{name}
        </if>
	</set>
</update>

5.6 删除 - 批量删除

<!--mybtis会将数组参数封装为一个Map集合，默认：array=数组；使用@Param注解改变map集合的默认key名称-->
<delete id="deleteByIds">
    delete from xx
    where id in
    <foreach collection="ids" item="id" separator="," open="(" close=")">
        #{id}
    </foreach>
</delete>

5.7 MyBatis事务

• openSession()：默认开启事务，进行增删改的操作后使用sqlSession.commite()手动提交事务
• openSession(true)：可以设置为自动提交事务（关闭事务）

5.8 特殊字符处理：

1. 转义字符 &lt
2. CDATA区 <![CDATA[ 内容 ]]

5.9 参数传递

MyBatis接口方法中可以接收各种各样的参数，MyBatis底层会对这些参数进行不同的封装处理方式

单个参数：

1. POJO类型：直接使用，属性名和参数占位符名称一致

2. Map集合：直接使用，属性名和参数占位符名称一致

3. Collection：封装为Map集合

   map.put("agr0", collection集合);
   map.put("collection",colection集合);
   

4. List：封装为Map集合

   map.put("agr0",list集合);
   map.put("collection",list集合);
   map.put("list",list集合);
   

5. Array：封装为Map集合

   map.put("agr0",数组);
   map.put("collection",数组);
   map.put("list",数组);
   

6. 其他类型：直接使用

多个参数：可以使用@Param注解替换Map集合中arg键名

map.put("arg0"，参数1);
map.put("param1"，参数1);
map.put("param2"，参数2);
map.put("arg1"，参数2);

MyBatis提供了ParamNameResolveer类进行参数封装

建议：使用@Param注解替换Map集合中arg键名，并用修改后的名称获取值

6. 注解完成增删改查

注解完成简单功能，配置文件完成复杂功能

@Select("select * from tb_user where id=#{id}")
public User selectById(int id);

• 查询：@Select
• 添加：@Insert
• 修改：@Update
• 删除：@Delete

7. 动态SQL

见第五章节CRUD动态语句内容。

1. 内存结构

1.1 程序计数器

定义：Program Counter Register程序计数器（寄存器）
作用：记住下一条JVM指令的执行地址
特点：线程私有；不会内存溢出。

1.2 虚拟机栈

Java Virtual Machines Stacks（Java虚拟机栈）

• 栈-每个线程运行需要的内存空间，每个栈由多个栈帧（Frame）组成
• 栈帧-每个方法运行时需要的内存
• 每个线程只能有一个活动栈帧，对应当前正在执行的那个方法

问题辨析：

1. 垃圾回收是否涉及栈内存？不需要，方法调用结束就会弹出栈
2. 栈内存分配越大越好吗？-Xss size设置栈内存。物理内存一定，栈内存越大，线程数越少。
3. 方法内的局部变量是否线程安全？局部变量安全，引用的对象未必。

1.2.1 栈内存溢出StackOverFlow

• 栈帧过多导致栈内存溢出
• 栈帧过大导致栈内存溢出

1.2.2 线程运行诊断

cpu占用过多

• 用top定位哪个进程堆cpu占用高

• ps H -ef pid,tid,%cpu | grep 进程id（用ps命令进一步定位哪个线程引起cpu占用过高）
  

• jstack 进程id 可以根据线程id找到有问题的线程，进一步定位问题代码的源码行号

程序运行很长时间没有结果

1.3 本地方法栈

Native Method Stacks本地方法栈

1.4 堆

1.4.1 Heap堆

通过new关键字，创建对象都会使用堆内存
特点

• 线程共享，堆中对象都需要考虑线程安全问题
• 有垃圾回收机制

1.4.2 堆内存溢出

1.4.3 堆内存诊断

1. jps工具
   • 查看当前系统中有哪些java进程
2. jmap工具
   • 查看堆内存占用情况
3. jconsole工具
   • 图形界面的，多功能的检测工具，可以连续监测
4. jvisualvm工具

1.5 方法区

1.5.1 Meathod Area方法区定义：

• 线程共享
• JVM启动时创建，逻辑上是堆的一部分
• 存储类相关结构，如运行时常量池、成员变量、方法数据、成员&构造方法、特殊方法（类构造器）

1.5.2 方法区内存溢出

1.8以前的永久代内存溢出

演示永久代内存溢出 java.lang.OutOfMemoryError:PermGen space
-XX:MaxPermSize-8m

1.8以后的元空间内存溢出

演示元空间内存溢出 java.lang.OutOfMemoryError:Metaspace space
-XX:MaxMetaspaceSize-m

1.5.3 运行时常量池

• 常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息
• 运行时常量池，常量池是*.class文件中的，当类被加载，它的常量池信息就会被放入运行时常量，并把里面的符号地址变为真实地址。

1.5.4 StringTable

// javap -v xxx.class查看字节码
// StringTable["a","b","ab"]
// 常量池中的信息会被加载到运行时常量池中，这时a b ab都是常量池中的符号，还没有编程java字符串对象
// idc #2会把a符号变为"a"对象
// idc #3会把b符号变为"b"对象
// idc #4会把ab符号变为"ab"对象

public static void main(String[] args){
    String s1 = "a"; // 懒惰的
    String s2 = "b";
    // 字符串常量拼接，编译器优化为"ab"，入池
    String s3 = "ab";
    // 变量拼接，运行期间StringBuilder创建，堆中
    String s4 = s1 + s2; // new StringBuilder().append("a").append("b").toString(); 
    String s5 = "a" + "b"; // javac 在编译期间的优化，结果已经在编译期间确定为ab
    String s6 = s4.intern();
    
    System.out.println(s3 == s4); // false
    System.out.println(s3 == s5); // true
    System.out.println(s3 == s6); // true
    
    String x2 = new String("c") + new String("d");
    String x1 = "cd";
    String x3 = x2.intern();
    // 如果调换【最后两行代码】的位置，调换后为true
    System.out.println(x1 == x2);// false
    System.out.println(x1 == x3);// true
}

特性

• 常量池中字符串仅是符号，第一次用到时才变为对象
• 利用串池机制，来避免重复创建字符串对象
• 字符串变量拼接原理时StringBuilder(1.8)
• 字符串常量拼接的原理是编译期优化
• 可以使用intern方法，主动将串池中还没有的字符串放入串池
  • 1.8将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则会放入串池，会把串池中的对象返回
  • 1.6将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则会复制一份放入串池，会把串池中的对象返回

1.5.5 StringTable位置

1.5.6 StringTable垃圾回收

1.5.7 StringTable性能调优

• 调整-XX:StringTableSize=桶个数
• 考虑将字符串对象是否入池

1.6 直接内存

Direct Memory

• 常见于NIO操作，用于数据缓冲区
• 分配回收成本较高，但读写性能高
• 不受JVM内存回收管理

2. 垃圾回收

2.1 如何判断对象可以回收

2.1.1 引用计数法

2.2.2 可达性分析算法

• Java虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象
• 扫描堆中的对象，看是否能够沿着GC Root对象为起点的引用链找到该对象，找不到，表示可以回收
• 哪些对象可以作为GC Root？

2.2.3 四种引用

1. 强引用

   • 只有所有GC Root对象都不通过【强引用】该对象，该对象才能被垃圾回收

2. 软引用

   • 仅有软引用该对象时，在垃圾回收后，内存仍不足时会再次发出垃圾回收，回收软引用对象
   • 可以配合引用队列来释放引用自身

   private static final int _4MB = 4*1024*1024;
   public static void main(String[] args){
       List<SoftReference<byte[]>> list = new ArrayList<>();
       // 引用队列
       ReferenceQueue<byte[]> queue = new ReferenceQueue<>();
       for(int i=0;i<5;i++){
           // 关联了引用队列，当软引用所关联的byte[]被回收，时，软引用会自己加入引用队列
           SoftReference<byte[]> ref = new SoftRerence<>(new byte[_4MB],queue);
           System.out.println(ref.get());
           list.add(ref);
           System.out.println(list.size());
       }
       Reference<? extends byte[]> poll = queue.poll();
       while(poll != null){
           list.remove(poll);
           poll = queue.poll();
       }
       for(SoftReference<byte[] reference:list){
           System.out.println(reference.get());
       }
   }
   

3. 弱引用

   • 仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象
   • 可以配合引用队列来释放弱引用本身

4. 虚引用

   • 必须配合引用队列使用，主要配合ByteBuffer使用，被引用对象回收时，会将虚引用入队，由Reference Handler线程调用虚引用相关方法释放直接内存

5. 终结器引用

   • 无需手动编码，但内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由Finalizer线程通过终结器引用找到被引用对象并调用它的finalize方法，第二次GC才能回收被引用对象。

2.2 垃圾回收算法

2.2.1 标记清除Mark Sweep

• 速度快
• 会造成内存碎片

2.2.2 标记整理Mark Compact

• 速度慢
• 没有内存碎片

2.2.3 复制Copy

• 不会有内存碎片
• 可用内存空间减半

2.3 分代垃圾回收

• 对象首先分配在伊甸园区域
• 新生代空间不足时，触发minor gc，伊甸园和from存活的对象使用copy复制到to中，存活的年龄加1，并且交换from to
• minor gc会引发stop the world，暂停其他用户的线程，等待垃圾回收线程结束
• 当对象寿命超过阈值时，会晋升至老年代，最大寿命15次（4bit）
• 当老年代空间不足，会先尝试触发minor gc，如果之后空间仍不足，那么触发full gc，STW时间更长。

相关VM参数

2.4 垃圾回收器

1. 串行

   -XX:UseSerialGC=Serial+SeralOld
   

   • 单线程
   • 堆内存较小，适合个人电脑

2. 吞吐量优先

   -XX:+UserParallelGC~-XX:+UseParallelOldGC
   -XX:+UseAdaptiveSizePolicy
   -XX:GCTimeRatio=ratio
   -XX:MaxGCPauseMills=ms
   -XX:ParallelGCThreads=n
   

   • 多线程
   • 堆内存较大，多核cpu
   • 单位时间内STW时间最短

3. 响应时间优先

   -XX:+UseConcMarkSweepGC ~ -XX:+UseParNewGC ~ SerialOld
   -XX:ParallelGCThreads=n ~ -XX:ConcGCThreads=threads
   -XX:CMSInitiatingOccupancyFraction=percent
   -XX:+CMSScavengeBeforeRemark
   

   • 多线程
   • 堆内存较大，多核cpu
   • 尽可能让单次STW时间最短

4. G1

2.5 垃圾回收调优

3. 类加载与字节码计数

3.1 类文件结构

魔数 0-3字节，表示它是否是【class】类型的文件 ca fe ba be
版本 4-7字节，表示版本00 34（52），表示java8
常量池 8-9字节，表示常量池长度，00 35（35）表示常量池有#1~#34项。#0项不计入，也没有值
第#1项0a表示一个Method信息，00 06和00 15（21）表示引用常量池中#6和#21项来获得这个方法的【所属类】和【方法名】
ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

3.2 字节码指令

javap工具反编译class文件

3.2.1 图解方法执行流程

1. 原始java代码
2. 编译后的字节文件
3. 常量池载入运行时常量池
4. 方法字节码载入方法区
5. main线程开始运行，分配栈帧内存
6. 执行引擎开始执行字节码

多态的原理HSDB

3.3 编译期处理

3.4 类加载阶段

1. 加载
   • 将类的字节码载入方法区，内部采用C++的instanceKlass描述java类，它的重要field有：
     • _java_mirror 即java类镜像，例如对String来说，就算String.class，作用是把Klass暴露给java使用
     • _super 即父类
     • _fields 即成员变量
     • _methods 即方法
     • _constants 即常量池
     • _class_loader 即类加载器
     • _vtable 虚方法表
     • _itable 接口方法表
   • 如果这个类还有父类没有加载，先加载父类
   • 加载和链接可能是交替运行的
2. 链接
   • 验证：验证类是否符合JVM规范，安全性检查
   • 准备：为static变量分配空间，准备默认值
     • static变量在JDK7之前存储与instanceKlass末尾，JDK7后存储于_java_mirror末尾。
     • static变量分配空间和赋值是两个步骤，分配空间在准备阶段完成，赋值在初始化阶段完成
     • 如果static变量是final的基本类型以及字符串常量，你们编译阶段值就确定了，赋值在准备阶段完成
     • 如果static变量是final的，但属于引用类型，你们赋值也会在初始化阶段完成
   • 解析：将常量池中的符号引用解析为直接引用
3. 初始化
   初始化即()v方法，虚拟机会保证整个类的构造方法的线程安全。类初始化是懒惰的，发生时机：
   • main方法所在的类，总会被首先初始化
   • 首次访问这个类的静态变量或静态方法
   • 子类初始化，如果父类还没初始化，会引发父类初始化
   • Class.forName()
   • new会导致初始化
     不会导致类初始化情况：
   • 访问类的static final静态常量（基本类型和字符串）不会触发初始化
   • 类对象.class不会触发初始化
   • 拆给年间该类的数组
   • 类加载器的loadClass方法
   • Class.forName()的参数2为法拉瑟时

3.5 类加载器

1. 启动类加载器
2. 扩展类加载器
3. 双亲委派机制
   所谓双亲委派，就是指调用类加载器的loadClass方法，查找类的规则。优先委派上级类加载器进行加载，如果上级加载器：
   • 能找到这个类，由上级加载，加载后该类也对夏季加载器可见
   • 找不到这个类，则下级类加载器才有资格执行加载
4. 线程上下文类加载器
5. 自定义加载器

3.6 运行期优化

1. 即时编译

   1. 分层编译
      JVM将执行状态分成了5个层次
      • 0层，解释执行（Interpreter）
      • 1层，使用C1即时编译器编译执行（不带profiling）
      • 2层，使用C1即时编译器编译执行（带基本的profiling）
      • 3层，使用C1即时编译器编译执行（带完全的profiling）
      • 4层，使用C2即时编译器编译执行
      • profiling是指在运行过程中收集一些程序执行状态的数据，如【方法的调用次数】、【循环的回边次数】等
        JIT和解释器的区别：
      • 解释器是将字节码解释为机器码，下次即使遇到相同的字节码，仍会执行重复的解释
      • JIT是将一些字节码编译为针对字节码，并存入Code Cache，下次遇到相同的代码，直接执行，无需再编译
      • 解释器是将字节码解释为针对所有平台都通用的机器码
      • JIT会根据平台类型，生产平台特定的机器码
        对于占据大部分的不常用的代码，我们无需耗费时间将其编译成机器码，而是采用解释执行的方式运行。对于小部分发的热点代码，我们可以将其编译成机器码。执行效率Interpreter<C1<C2，目标是发现热点代码（hotspot名称由来）
        逃逸分析 ，C2编译器中会发现新建的对象是否逃逸，若无逃逸则优化字节码。使用-XX:-DoEscapeAnalysis关闭逃逸分析。
   2. 方法内联（Inlining）
      如果发现热点方法，并且长度不长时，会进行内联。即把方法内部代码拷贝粘贴到调用者位置。还能进行常量折叠（constant folding）的优化。
   3. 字段优化
      尽可能使用局部变量，而不是成员变量和静态变量。

2. 反射优化

4. java内存模型JMM

JMM(java memory model)定义了一套在多线程读写共享数据时（成员变量、数组）时，对数据的可见性、有序性和原子性的规则和保障。

4.1 原子性

4.2 可见性

4.3 有序性

详见并发编程

并发编程

线程与进程

进程和线程的概念

进程

• 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至CPU，数据加载至内存。进程就算用来加载指令、管理内存、管理IO的
• 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
• 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程。

线程

• 一个进程之内可以分为多个线程
• 一个线程就是一个指令流，将指令流的一条条指令以一定顺序交给CPU执行
• Java中，线程作为最小调度单位，进程作为资源分配的最小单位。在windows中进程是不活动的，只是作为线程的容器。

并发和并行的概念

并行（parallel）是同一时间动手做（doing）多件事情的能力。

并发（concurrent）是同一时间应对（dealing with）多见事情的能力。

线程基本应用

应用之异步调用

从方法调用的角度来讲，如果

• 需要等待结果返回，才能继续运行就是同步
• 不需要等待结果返回，就能继续运行就算异步

应用之提高效率

java线程

创建和运行线程

1. 直接使用Thread

2. 使用Runnable配合Thread

   lambda简化

   Runnable r = () -> log.debug("running");
   
   Thread t = new Thread(() -> {log.debug("running");}, t2);
   

   原理之Thread与Runnable的关系

   • 创建线程的方法1是把线程和任务合并在一起，方法2是把线程和任务分开
   • 用Runnable更容易与线程池等高级API配合
   • 用Runnable让任务类脱离了Thread继承体系，更灵活

3. FutureTask配合Thread

   FutureTask能够接受Callable类型的参数，用来处理有返回结果的情况

查看线程

观察多个线程同时运行

• 交替执行
• 先后顺序不受我们控制

查看进程方法

windows

• 任务管理器可以查看进程也可以杀死进程
• tasklist查看进程
• taskkill杀死进程

linux

• ps -fe查看所有进程
• ps -fT -p 查看某个进程（PID）的所有线程
• kill杀死进程
• top按大写H切换是否显示线程
• top -H -p 查看某个进程（PID)的所有线程

Java

• jps命令查看所有Java进程
• jstack 查看某个Java进程（PID）的所有线程
• jconsole查看某个Java进程中线程的运行情况（图形界面）

线程API

原理之线程运行

栈与栈帧

我们都知道JVM（Java虚拟机栈）中由堆、栈、方法区所组成，其中栈内存是给线程使用的，每个线程启动后，虚拟机都会为其分配一块栈内存。

• 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
• 每个线程只能由一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换（Thread Context Switch）

因为以下一些原因导致cpu不再执行当前的线程，转而执行另一个线程的代码

• 线程的cpu时间片用完
• 垃圾回收
• 有更高优先级的线程需要运行
• 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法

当上下文切换发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，java中对应的概念就算程序计数器（Program Counter Register），作用是记住下一条jvm指令的执行地址，是线程私有的。

• 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
• Context Switch频繁发生会影响性能

常见方法

sleep

1. 调用sleep会让当前线程从Running进入Timed Waiting状态
2. 其他线程可以使用interrupt方法打断正在睡眠的线程，这时sleep方法会抛出InterruptedException
3. 睡眠结束后的线程未必会立刻得到执行

yield

1. 调用yield会让当前线程Running进入Runnable状态，然后调度执行其他同优先级的线程。如果这时没有同优先级的线程，那么不能保证让当前线程暂停的效果。
2. 具体实现依赖于操作系统的任务调度器

join

interrupt

如果被打断线程正在sleep、wait、join，会导致被打断线程抛出InterruptedException，并清除打断标记；如果打断正在运行的线程，则会设置打断标记；park的线程被打断，不会设置打断标记

两阶段终止模式

Two Phase Termination

错误思路

• 使用线程对象的stop()方法停止线程
  • stop方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
• 使用System.exit(int)方法停止线程
  • 目的仅是停止一个线程，但这种做法会让整个程序停止

打断park线程不会清除打断状态

线程优先级

• 线程优先级会提示调度器优先调度该线程
• 如果cpu较忙，那么优先级高的线程会获取更多的时间片，但cpu闲时，优先级几乎没作用

主线程与守护线程

默认情况下，Java进程要等待所有线程都运行结束才会结束。有一种特殊的线程叫守护线程，只要其他非守护线程运行结束，即使守护线程代码没有执行完全，也会强制结束。

t1.setDaemon(true);

• 垃圾回收器线程就是一种守护线程
• Tomcat中Acceptor和Poller线程都是守护线程，所以Tomecat接收到shutdown命令后，不会等待它们处理完当前请求。

线程状态

新建new -> run() -> 就绪ready -> start() -> 运行running -> sleep()/wait() -> 阻塞waiting/time_waiting/blocked -> 销毁terminated

共享模型之管程

共享问题

问题分析

对于i++而言（i为静态变量），实际会产生如下的JVM字节码指令

getstatic	i// 获取静态变量i的值
iconst_1	// 准备常量i
iadd		// 自增
putstatic	i// 将修改后的值存入静态变量i

临界区 Critical Section

• 一个程序运行多个线程本身是没有问题的
• 问题在多个线程访问共享资源
  • 多个线程读共享资源也没问题
  • 多个线程对共享资源读写操作时发生指令交错，就会出现问题
• 一段代码块内存在对共享资源的多线程读写操作，称这段代码块为临界区

竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件。

synchronized 解决方案

应用之互斥

• 阻塞式的解决方案：synchronized, Lock
• 非阻塞式的解决方案：原子变量

java中互斥和同步都可以采用 synchronized 关键字完成，他们的区别：

• 互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
• 同步是由于线程执行的先后顺序不同，需要一个线程等待其他线程运行到某个点

sychronized(Object){
    临界区
}

synchronized 实际是用对象锁保证临界区代码的原子性

• 如果把synchronized(obj)放在for循环外面，如何理解？ --原子性
• 如果t1 synchronized(obj1)而t2 synchronized(obj2)会怎样运作？ --锁对象
• 如果t1 synchronized(obj)而t2没有加会怎么样？ --锁对象

方法上的synchronized

class Test{
    public synchronized void test(){      
    }
}
等价于
class Test{
    public void test(){
        synchronized(this){      
        }
    }
}

class Test{
    public synchronized static void test(){
        synchronized(Test.class){   
        }
    }
}
等价于
class Test{
    public static void test(){
        synchronized(Test.class){
        }
    }
}

不加synchronized的方法 不能保证线程安全

线程八锁

变量的线程安全分析

成员变量和静态变量是否线程安全？

• 如果它们没有共享，则线程安全
• 如果它们被共享了，根它们状态是否能改变，又分两种情况
  • 如果只有读操作，则线程安全
  • 如果有读写操作，则这段代码是临界区，需要考虑线程安全

局部变量是否线程安全？

• 局部变量是线程安全的
• 但局部变量引用的对象则未必
  • 如果该对象没有逃离方法的作用范围，它是线程安全的
  • 如果该对象逃离方法的作用范围，需要考虑线程安全

常见的线程安全类

• String
• Integer
• StringBuffer
• Random
• Vector
• HashTable
• JUC包下的类

这里说的线程安全是指，多个线程调用它们同一个实例的某个方法时，是线程安全的，可以理解为：

• 它们每个方法是原子的
• 但注意它们多个方法的组合不是原子的

线程安全类方法的组合

不可变类线程安全性

String、Integer等都是不可变类，因为其内部状态不可以改变，因此它们的方法都是线程安全的。

Monitor概念

Monitor 监视器/管程

java普通对象头Mark Word(32 bits)、Klass Word(32 bits)

每个java对象都可以关联一个Monitor对象，如果使用synchronized给对象上锁（重量级）之后，之后的Mark Word中就被设置指向Monitor对象的指针。结构如下：

• 刚开始Monitor中Owner为null

• 当Thread-2执行synchronized(obj)就会将Monitor的所有者Owner置为Thread-2，Monitor中只能有一个Owner

• 在Thread-2上锁的过程，如果Thread-3，Thread-4也来执行synchronized，就会进入EntryList BLOCKED

• Thread-2执行完同步代码块的内容，然后唤醒EntryList中等待的线程来竞争锁，竞争时是非公平的。

• 途中WaitSet中的Thread-0，Thread-1是之前获得过锁，但条件不满足进入WAITING状态的线程。

• Owner线程发现条件不满足，调用wait方法，即可进入WaitSet变为WAITING状态。

• BLOCKED和WAITING线程都处于阻塞状态，不占用CPU时间片

• BLOCKED线程会在Owner线程释放锁时唤醒

• WAITING线程会在Owner线程调用notify或notifyAll时唤醒，但唤醒后并不意味着立即获得锁，而是进入EntryList重新竞争。

  注意：

  • synchronized必须是进入同一个对象的Monitor才有上述的效果。
  • 不加synchronized的对象不会关联监视器，不遵从以上规则。

原理之synchronized

1、轻量级锁

使用场景：如果一个对象虽然有多线程访问，但多线程访问的时间是错开的（也就是没有竞争），那么可以使用轻量级锁优化。

• 创建锁记录（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的值恢复给对象头。

  • 成功，则解锁成功
  • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程。

2、锁膨胀

如何尝试加轻量级锁的过程中，CAS操作无法成功，这种情况就是其他线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

• 当Thread-1进行轻量级锁时，Thread-0已经对该对象加了轻量级锁

  

• 这时Thread-1加轻量级锁失败，进入锁膨胀流程

  • 即为Object对象申请Monitor锁，让Object指向重量级锁地址
  • 然后自己进入Monitor的EntryList BLOCKED

  

• Thread-0退出同步块解锁时，使用cas将Mark Word的值恢复给对象头，失败。这时会进入重量级锁解锁流程，即按照Monitor地址找到Monitor对象，设置Owner为null，唤醒EntryList中BLOCKED线程

3、自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时持锁线程退出了同步块，释放了锁），这时当前线程就可以避免阻塞。

• 在Java6之后自旋锁是自适应的，比如对象刚刚一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；繁殖就少自旋甚至不自旋
• 自旋会占用cpu时间，单核cpu自旋就是浪费，多喝cpu自旋才能发挥优势
• Java7之后不能控制是否开启自旋功能

4、偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要CAS操作。

Java6中引入了偏向锁来做进一步优化：只有第一次使用CAS将线程ID设置到对象的Mark Word头，之后发现这个线程ID时自己的就表示没有竞争，不用重新CAS。以后只要不发生竞争，这个对象就归线程所有。

偏向状态

一个对象创建时

如果开启了偏向锁，那么对象创建后，Mark Word值为0x05即最后三位为101，此时它的thread、epoch、age都为0。如果没有开启偏向锁，那么对象创建后，Mark Word值为0x01即最后3位为001.这是它的hashCode、age为0，第一次用到hashCode才会赋值。

撤销-其他线程使用对象：当有其他线程使用偏向锁对象时，会将偏向锁升级为轻量级锁。

撤销-调用对象hashCode：调用了对象的hashCode，但偏向锁的对象Mark Word中存储的是线程id，如果调用hashCode会导致偏向锁被撤销。

• 轻量级锁会在锁记录中记录hashCode
• 重量级锁会在Monitor中记录hashCode

撤销-调用wait/notify

批量重偏向

如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程t1的对象仍有机会重新偏向t2，重偏向会重置对象的ThreadID

当撤销偏向锁阈值超过20次后，jvm会认为偏向错对象，于是会在给这些对象加锁时重新偏向至加锁线程。

批量撤销

当撤销偏向锁阈值超过40次后，jvm会觉得偏向错了，不应该偏向。整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的。

5、锁消除

原理之wait/notify

• Owner线程发现条件不满足，调用wait方法，即可进入WaitSet变为WITING状态
• BLOCKED和WAITING的线程都处于阻塞状态，不占用CPU时间片
• BLOCKED线程会在Owner线程释放锁时唤醒
• WAITING线程会在Owner线程调用notify或notifyAll时唤醒，但唤醒后并不意味着立刻获取锁，仍需进入EntryList重新竞争

API介绍

• obj.wait()让进入object监视器的线程到waitSet等待
• obj.notify()在object上正在waitSet等待的线程中挑一个唤醒
• obj.notifyAll()让object上正在waitSet等待的线程全部唤醒

它们都是线程之间进行协作的手段，都属于Object对象的方法。必须获取此对象的锁才能调用方法。

wait/notify的正确姿势

sleep(long n)和wait(long n)的区别：

1. sleep是Thread方法，而wait是Object方法
2. sleep不需要强制和synchronized配合使用，但wait需要和synchronized一起用
3. sleep在睡眠的同事，不会释放对象锁，但wait在等待时候会释放对象锁
4. sleep进入状态TIMED_WAITING，wait进入状态WAITING。

sychronized(lock){
    while(条件不成立){
        lock.wait
    }
    // 干活
}
// 另一个线程
synchronized(lock){
    lock.notifyAll();
}

同步模式之保护性暂停

即Guarded Suspension，用在一个线程等待另一个线程执行结果。要点：

• 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个Guarded Object
• 如果有结果不断从一个线程到另一个线程那么可以使用消息队列
• JDK中，join、Future的实现就是采用此模式
• 因为要等待另一方的结果，因此归类到同步模式

原理之join

异步模式之生产者/消费者

要点：

• 与前面的保护性暂停中的GuardObject不同，不需要产生结果和消费结果的线程一一对应
• 消费队列可以用来平衡生产和消费的线程资源
• 生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
• 消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
• JDK中各种阻塞队列，采用的就算这种模式

Park & Unpark

它们是LockSupport类中的方法

// 暂停当前线程
LockSupport.park();
// 恢复某个线程的运行
LockSupport.unpark(暂停线程对象);

特点，与Object的wait & notify 相比

• wait、notify和notifyAll必须配合Object Monitor一起使用，而park & unpark不必
• park & unpark是以线程为单位来【阻塞】和【唤醒】线程，而notify只能随机唤醒一个等待线程，notifyAll是唤醒所有等待线程，就不那么【精确】
• park & unpark可以先unpark，而wait & notify不能先notify

原理：每个线程都有自己的Parker对象，由三部分组成_counter, _cond 和 _mutex

• 线程就像一个旅人，Parker就像他随身携带的背包，条件变量就好比背包中的帐篷。_counter就好比背包中的备用干粮（0为耗尽，1为充足）。
• 调用park就算要看需不需要停下来休息
  • 如果备用干粮耗尽，那么钻进帐篷歇息
  • 如果备用干粮充足，那么不需停留，继续前进
• 调用unpark，就好比令干粮充足
  • 如果这时线程还在帐篷，就唤醒让他继续
  • 如果线程还在运行，那么下次调用park时，仅时消耗掉备用干粮，不需停留
    • 因为背包空间有限，多次调用unpark仅会补充一份备用干粮

1. 当前线程调用Unsafe.park()方法
2. 检查_counter，本情况为0，这时获得_mutex互斥锁
3. 线程进入_cond条件变量阻塞
4. 设置_counter=0

1. 调用Unsafe.unpark(Thread_0)方法，设置_counter为1
2. 唤醒_cond条件变量中的Thread_0
3. Thread_0恢复运行
4. 设置_counter为0

1. 调用Unsafe.unpark(Thread_0)方法，设置_counter为1
2. 当前线程调用Unsafe.park()方法
3. 检查_counter，本情况为1，这时线程无需阻塞，继续运行
4. 设置_counter为0

线程状态转换

多把锁

多把不相干的锁

将锁粒度细分

• 好处是可以增加并发度
• 坏处是如果一个线程需要同时获得多把锁，容易发生死锁

活跃性

死锁 可以使用顺序加锁的方式解决，但是可能产生饥饿的问题。

定位死锁

检测死锁可以使用jconsole工具，或者使用jps定位进程id，再用jstack定位死锁

活锁 出现在两个线程互相改变对方的结束条件，最后谁也无法结束。

饥饿 一个线程由于优先级太低，始终得不到CPU调度执行，也不能够结束。

ReentrantLock

和synchronized一样支持可重入，相比synchronized有以下特点

• 可中断
• 可以设置超时时间
• 可以设置为公平锁
• 支持多个条件变量

可重入 指同一个线程如果首次获得这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁。

// 获取锁
reentrantLock.lock();
try{
    // 临界区
}finally{
    // 释放锁
    reentrantLock.unlock();
}

可打断

// 可被interrupt方法打断
lock.lockInterruptibly();

锁超时

lock.tryLock(1,Timeunit.SECONDS)

公平锁

// 公平锁
ReentrantLock lock = new ReentrantLock(true);

条件变量支持多个条件变量

• await前需要获取锁
• await执行后会释放锁进入conditionObject等待
• await的线程被唤醒（或打断或超时）去重新竞争lock锁
• 竞争lock锁成功后，从await后继续执行

小结

使用synchronized互斥解决临界区的线程安全问题

• 掌握synchronized锁对象语法
• 掌握synchronized加载成员方法和静态方法语法
• 掌握wait/notify同步方法

使用lock互斥解决临界区的线程安全问题：可打断、锁超时、公平锁、条件变量

学会分析变量的线程安全性、掌握常见线程安全类的使用

活跃性问题：死锁、活锁、饥饿

应用方面

• 互斥：使用synchronized或Lock达到共享资源互斥效果
• 同步：使用wait/notify或Lock的条件变量来达到线程间通信效果

原理方面

• monitor、synchronized、wait/notify原理
• synchronized进阶
• park & unpark原理

模式方面

• 同步模式至保护性暂停
• 异步模型之生产者消费者
• 同步模式之顺序控制

共享模型之内存

Java内存模型JMM，即Java Memory Model，定义了主存、工作内存抽象概念，底层对应着CPU寄存器、缓存、硬件内存、CPU指令优化等。JMM体现在以下几个方面

• 原子性-保证指令不会收到线程上下文切换的影响
• 可见性-保证指令不会受cpu缓存影响
• 有序性-保证指令不会受cpu指令并优化的影响

可见性

退不出的循环

static boolean run = true;
public static void main(String[] args) throws InterruptedException{
    Thread t = new Thread(() -> {
        whie(run){
            //...
        }
    });
    t.start();
    
    Thread.sleep(1000);
    log.debug("停止t");
    run = false;// 线程t不会如预想的停下来
}

1. 初始状态，t线程刚开始从主内存读取了run的值到工作内存。

   

2. 因为t线程要频繁从主内存中读取run的值，JIT编译器会将run的值缓存至自己工作内存中的告诉缓存中，减少堆贮存中run的访问，提高效率

   

3. 1秒后，main线程修改了run的值并同步至内存，而t是从自己工作内存中的告诉缓存中读取整个变量的值，结果永远是旧值

   

解决方法

volatile（易变关键字）它可以用来修饰成员变量和静态变量，可以避免线程从自己工作缓存中查找变量的值，必须从主内存中读取，线程操作volatile变量都是直接操作主存。

synchronized语句块既可以保证代码块的原子性，也可以保证代码块内变量的可见性。但是缺点是synchronized属于重量级操作，性能相对更低。

原子性

一个线程对volatile变量的修改对另一个线程可见，但不能保证原子性。

注意

synchronized语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是synchronized是属于重量级操作，性能相对更低。

有序性

JVM会在不影响正确性的前提下，调整语句的执行顺序。这种特性称之为【指令重排】，多线程下【指令重排】会影响正确性。

两阶段终止模式

使用共享变量的方式优雅的结束线程利用isInterrupt、利用停止标记

同步模式之犹豫模式

Balking 用在一个线程发现另一个线程已经做了某一件相同的事，那么本线程无需再做了，直接结束返回。

JVM会在不影响正确性的前提下，可以调整语句的执行顺序。

volatile原理

volatile的底层实现原理是内存屏障，Memory Barrier（Memory Fence）

• 对volatile变量的写指令后会加入写屏障
• 对volatile变量的读指令前会加入读屏障

保证可见性

• 写屏障(sfence)保证在该屏障之前的，对共享变量的改动都同步到主存中。

• 读屏障(lfence)保证在该屏障之后，读共享变量的读取，加载的是主存中最新数据。

  

保证有序性

• 写屏障会确保指令重排时，不会将写屏障之前的代码排在写屏障之后

• 读屏障会确保指令重排时，不会将读屏障之后的代码排在读屏障之前

  

但不能解决指令交错

• 写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证跑到它前面去

• 而有序性的保证也只是保证本线程内相关代码不被重排序

  

double-checked locking DCL问题

如果一个类始终只能创建一个实例，那么这个类被称为单例类，这种设计模式被称为单例模式。

public final class Singleton{
    private Singleton(){}
    private static /*volatile*/ Singleton INSTANCE = null;
    public static Singleton getInstance(){
        if(INISTANCE == null){
            synchronized(Singleton.class){
                if(INSTANCE == null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

• 懒惰实例化
• 首次使用getInstance()才使用synchronized加锁，后续使用无需加锁
• 有隐含的：第一个if使用了INSTANCE变量，是在同步代码块外面。
• 代码块内的字节码会根据JVM优化而自动重排。而外面的if语句不是加锁的，在多线程环境下，第一个线程执行INSTANCE=new Singleton()；有可能先赋值在调用Singleton对象的构造方法。而第二个线程在这时进入方法，判断INSTANCE不为null，直接范围对象，而实际上INSTANCE引用对象还没有初始化。

解决：volatile通过内存屏障可以解决指令重排的问题

happens-before

规定了对共享变量的写操作对其他线程的读操作可见，它是可见性与有序性的一套规则总结，抛开以下hasppens-before规则，JMM并不能保证一个线程对共享变量的写，对于其他线程对共享变量的读可见。

• 线程解锁m之前对变量的写，对于接下来对m加锁的其他线程对变量的读可见

  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();
  

• 线程对volatile变量的写，读接下来其他线程对改变了的读可见

  volatile static int x;
  new Thread(() -> {
      x = 10;
  },"t1").start();
  new Thread(() -> {
      System.out.println(x);
  },"t2").start();
  

• 线程start前对变量的写，对该线程开始后对该变量的读可见

  static int x;
  x = 10;
  new Thread(() -> {
      System.out.println(x);
  },"t2").start();
  

• 线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其他线程调用t1.isAlive()或t1.join()等待它结束）

  static int x;
  Thread t1 = new Thread(() -> {
      x = 10;
  },"t1");
  t1.start();
  t1.join();
  System.out.println(x);
  

• 线程t1打断t2（interrupt）前对变量的写，对于其他线程得知t2被打断后对变量的读可见

  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(() -> {
          Thread.sleep(1000);
          x = 10;
          t2.interrupt();
      }).start();
      
      while(!t2.isInterrupted()){
          Thread.yield();
      }
      System.out.println(x);
  }
  

• 对变量默认值（0，false，null）的写，对其他线程对该变量的读可见

• 具有传递性

  volatile static int x;
  static int y;
  new Thread(() -> {
      y = 10;
      x = 20;
  },"t1").start();
  new Thread(() -> {
      System.out.println(x);
  },"t2").start();
  

线程安全单例

// 问题1：为什么加final
// 问题2：如果实现了序列化接口，还要做什么来防止反序列化破坏单例
public final class Singleton implements Seriablizable{
    // 问题3：为什么设置为私有？是否能防止反射创建新的实例？
    private Singleton{}
    // 问题4：这样初始化是否能保证单例对象创建时的线程安全？
    private static final Singleton INSTANCE = new Singleton();
    // 问题5：为什么提供静态方法而不是直接将INSTANCE设置为public，说出你知道的理由
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

小结

可见性

有序性

happens-before原则

原理方面

• CPU指令并行
• volatile

模式方面

• 两阶段终止模式的volatile改进
• 同步模式之Balking

共享模型之无锁

CAS和volatile

AtomicInteger balance = new AtomicInteger();
public void withdraw(Integer amount){
    while(true){
        int prev = balance.get();
        int next = prev - amount;
        if(balance.compareAndSet(prev,next)){
            break;
        }
    }
}

CAS必须借助volatile才能读取到共享变量的最新值来实现【比较并交换】的效果

CAS特点：结合CAS和volatile可以实现无锁并发，适用于线程数少，多核CPU的场景。

• CAS时基于乐观锁的思想
• synchronized时基于悲观锁的思想
• CAS体现的时无锁并发，无阻塞并发，
  • 因为没有使用synchronized，所以线程不会陷入阻塞，这时效率提升的因素之一
  • 如果竞争激烈，重试必然频繁发生，效率反而受影响

原子整数

JUC并发包提供了AtomicBoolean、AtomicInteger、AtomicLong

updateAndGet & getAndUpdate

原子引用

• AtomicReference
• AtomicMarkableReference
• AtomicStampedReference

主线程仅能判断出共享变量的值与最初值A是否相同，不能感知到从A改为B又改为A的情况（ABA问题）。如果主线程希望：只要有其他线程【动过】共享变量，那么自己的CAS就失败。这时，比较值是不够的，还需要再加一个版本号。

AtomicStampedReference可以给原子引用加上版本号，追踪原子引用整个的变化过程，可以知道变量中途被更改了几次。如果不关心引用变量更改了几次，只是单纯的关系是否更改过，则可以使用AtomicMarkableReference。

原子数组

• AtomicIntegerArray
• AtomicLongArray
• AtomicReferenceArray

字段更新器

• AtomicReferenceFieldUpdater
• AtomicIntegerFieldUpdater
• AtomicLongFieldUpdater

原子累加器

• LongAdder
• LongAccumulator

// 累加单元数组，懒惰初始化
transient volatile Cells[] cells;
// 基础值，如果没有竞争，则用cas累加这个域
transient volatile long base;
// 在cells创建或扩容时，置为1，表示加锁
transient volatile int cellsBusy;

原理之伪共享

因为CPU与内存速度差异很大，需要靠预读数据至缓存来提升效率。

而缓存以缓存行为单位，每个缓存行对应一块内存，一般64个字节。

缓存的加入造成数据副本的产生，即同一份数据会缓存在不同核心的缓存行中。

CPU耀保证数据一致性，如果某个CPU核心更改了数据，其他CPU核心对应的整个缓存行必须失效。

因为Cell是数组形式，在内存中连续存储的，一个Cell为24字节（16字节的对象头，和8字节的value），因此缓存行可以存下2个cell对象。那么问题来了：

• Core-0要修改Cell[0]
• Core-1要修改Cell[1]

无论谁修改成功，都会导致对方Core的缓存行失效。

@sun.misc.Contended 为了解决缓存行伪共享的问题。原理是使用此注解的对象或字段的前后方各增加128字节大小的padding，从而CPU将对象预读至缓存时占用不同的缓存行。

Unsafe

Unsafe对象提供了非常底层的，操作内存、线程的方法，Unsafe对象不能直接调用，只能通过反射获得。

Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");

函数式编程

// supplier 提供者 无中生有 ()->结果
// function 函数 一个参数一个结果 (参数)->结果，BiFunction(参数1,参数2)->结果
// consumer 消费者 一个参数没结果(参数)->void，BiCosumer(参数1，参数2)->

小结

CAS和volatile

API

• 原子整数
• 原子引用
• 原子数组
• 字段更新器
• 原子累加器

Unsafe

原理

• LongAdder源码
• 伪共享

共享模型之不可变

日期转换的问题

SimpleDateFormat不是线程安全的，多线程时有很大几率出现java.lang.NumberFormatException或者出现不正确的日期解析结果。

不可变类的使用

DateTimeFormeatter对象是immutable、Thread-safe的。

不可变类设计

String类也是不可变的。

final的使用

String类、类中所有属性都是final的

• 属性用final修饰保证了该属性是只读的，不能修改
• 类用final修饰保证了该类中的方法不能被覆盖，防止子类无意间破坏不可变性

保护性拷贝

使用字符串时，有一些跟修改相关的方法，比如substring等，其内部是调用String的构造方法创建一个新字符串。构造方法构造新字符串对象时，会生成新的char[] value，对内容进行复制。这种通过创建副本对象来避免共享的手段称之为【保护性拷贝（defensive copy）】

模式之享元

享元模式Flyweight pattern，当需要重用数量有限的同一类对象时

包装类

在JDK中Boolean、Byte、Short、Integer、Long、Character等包装类提供了valueOf()方法，例如Long的valueOf会缓存-128~127之间的对象，在这个范围之间会重用对象，大于这个范围才会新建Long对象。

String串池

BigDecimal BigInteger

原理之final

设置final变量的原理：字节码发现final变量赋值也是通过putfield指令完成，指令之后加入写屏障，保证其他线程读它的时候不会出现0的情况

获取final变量的原理（结合字节码）

无状态

没有任何成员变量的类是线程安全的。因为成员变量保存的数据也可以称为状态信息，因此没有成员变量就称之为【无状态】

共享模型之并发工具

线程池

ThreadPoolExecutor

线程池状态

ThreadPoolExecutor使用int的高三位来表示线程池状态，低29位表示线程数量

数字上比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING

构造方法

• corePoolSize 核心线程数目（最多保留的线程数）

• maximumPoolSize 最大线程数目

• keepAliveTime 生存时间

• unit 时间单位

• workQueue 阻塞队列

• threadFactory 线程工厂

• handler 拒绝策略

• 线程池刚开始没有线程，当一个任务提交给线程池后， 线程池会创建一个新线程来执行任务

• 当线程数达到corePoolSize并没有线程空闲，这时再加入任务，新加的任务会被加入workQueue队列排队，直到有空闲的线程

• 如果队列选择了有界队列，那么任务超过了队列大小时，会创建maximumPoolSize-corePoolSize数目的线程来救急。

• 如果线程到达maximumPoolSize仍然有新任务这时执行拒绝策略。拒绝策略jdk提供了4中实现：

  • AbortPolicy抛出RejectedExecutionExeception异常，默认策略
  • CallerRunsPolicy让调用者自己选择如何运行任务
  • DiscardPolicy放弃本次任务
  • DiscardOldestPolicy放弃队列中最早的任务，本任务取代之

• 高峰过去后，超过corePoolSize的救济线程如果一段时间没有任务做，需要结果线程节省资源，这一时间keepAliveTime和unit控制

newFixedThreadPool

• 核心线程数 == 最大线程数（没有救急线程），无需超时时间
• 阻塞队列是无界的，可以放任意数量任务

newCachedThreadPool

• 核心线程数为0，最大线程数是Integer.MAX_VALUE，救急线程的空闲生存时间为60s
  • 全部都是救急线程（60s后可以回收）
  • 救急线程可以无线创建
• 队列采用synchronousQueue实现特点是，没有容量，没有线程来取是放不进去的（一手交钱一手交货）

newSingleThreadExecutor

• 多个任务排队执行，线程数固定为1，任务书多于1时放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放

提交任务

// 执行任务
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;

关闭线程池

/*
线程池状态变为SHUTDOWN
- 不会接受新任务
- 但已提交任务会执行完
- 此方法不会阻塞调用线程的执行
*/
void shutdown();
// 尝试终结
tryTerminate();
// 不在RUNNING状态的线程池，此方法返回true
boolean isShutdown();
// 线程池状态是否是TERMINATED
boolean isTerminated();
// 调用SHUTDOWN后，由于调用线程并不会等待所有任务运行结束，因此如果它像在线程池TERMINATED后做些事情，可以利用此方法等待
boolean awaitTerminated(long timeout, TimeUnit unnit) throws InterruptedException;

异步模式之工作线程

让有限的工作线程（Worker Thread）来轮流异步处理无限多的任务，也可以归类为分工模式。典型实现就算线程池。

对比另一个多线程设计模式（Thread-Per-Message）。

不同任务类型应该使用不同的线程池，这样能避免饥饿，并能提升效率。

饥饿

固定大小线程池会有饥饿现象

• 两个工人是同一线程池中的两个线程
• 他们要做的事情，点餐和做菜，这是两个阶段的工作
  • 点餐：必须先点餐，等菜做好再上菜，此期间点餐工人必须等待
  • 做菜
• 同时来了两个客人，工人A和工人B都处理点餐，没人做饭，饥饿现象。

创建多少线程池合适

• 过小回导致程序不能充分利用系统资源、容易导致饥饿
• 过大会导致更多的线程上下文切换，占用更多内存

CPU密集型运算

通常使用CPU核数+1能实现最优的CPU利用率，+1是保证当线程由于页缺失故障（操作系统）或其它原因导致暂停时，额外的这个线程就能顶上去，保证CPU时钟周期不被浪费

I/O密集型运算

线程数 = 核数 * 期望CPU利用率 * 总时间（CPU计算时间+等待时间） / CPU计算时间

任务调度线程池

java.util.Timer可以实现定时功能，Timer优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务执行，前一个任务的延迟或异常都将会影响到之后的任务。

ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
pool.schedule(() -> {},1,TimeUnit.SECONDS);

正确处理线程池异常

Future<boolean> f = pool.submit(() -> {
    int i = 1 / 0;
    return true;
});
System.out.println(f.get());

Tomcat线程池

• LimitLatch用来限流，用来控制最大连接个数，类似JUC中的Semaphore
• Acceptor只负责【接受新的socket连接】
• Poller只负责监听socket channel是否有【可读的I/O事件】
• 一旦可读，封装一个任务对象（socketProcessor），提交给Executor线程池处理
• Executor线程池中的工作线程最终负责【处理请求】

Tomcat线程池扩展了ThreadPoolExecutor

• 如果总线程达到maximumPoolSize
  • 这是不会立刻抛出RejectedExecutionException异常
  • 而是再次尝试放入队列，如果还失败，才抛出异常

Fork/Join

Fork/Join是1.7加入的新的线程池实现，体现了分治思想，使用与能够进行任务拆分的cpu密集型运算

使用

提交给Fork/Join线程池的任务需要继承RecursiveTask（有返回值）或RecursiveAction（无返回值）。

JUC

AQS原理

AbstractQueuedSynchronizer，是阻塞式锁和相关同步器工具的框架

• 用state属性表示资源状态（独占模式和共享模式），子类需要定义如何维护中国状态，控制如何获取锁和释放锁
  • getState-获取状态
  • setState-设置状态
  • compareAndSetState-CAS机制设置state状态
  • 独占模式只有一个线程能够访问资源，共享模式可以允许多个线程访问资源
• 提供了基于FIFO的等待队列，类似于Monitor的EntryList
• 条件变量来实现等待、唤醒机制，支持多个条件变量，类似于Monitor的WaitSet

ReentrantLock原理

非公平锁原理

可重入原理

可打断原理

不可打断模式

在此模式下，即使它被打断，仍会驻留在AQS队列中，等获得锁后方能继续运行（打断标记被设置为true）

可打断模式

在park过程中如果被interrupt会抛出异常不会再次进入死循环

公平锁原理

与非公平锁主要区别在于tryAcquire方法实现，公平锁会先检查AQS队列中是否有前驱节点，没有才竞争

条件变量实现原理

await流程

signal流程

读写锁

线程安全集合类

Semaphore

CountdownLatch

CyclicBarrier

ConcurrentHashMap原理

LongAdder value = map.computeIfAbsent(key,(key) -> new LongAdder());
value.increment;

JDK 7 HashMap并发死链复现

• 究其原因，是因为在多线程环境下使用非线程安全的map集合
• JDK8虽然将扩容算法做了调整，不再将元素加入链表头（而是保持与扩容前一样的顺序），但仍不意味着能够在多线程环境下能安全扩容，还会出现其他问题（如扩容丢数据）

CouncurrentLinkedQueue原理

BlockingQueue

CopyOnWriteArrayList

disruptor

guava

消息中间件

RabbitMQ

MQ基础

1.MQ基本概念

MQ 全程 Message Queue（消息队列），是在消息传输过程中保存消息的容器。多用于分布式系统之间进行通信。

优势：

• 应用解耦
• 异步提速
• 削峰填谷

劣势：

• 系统可用性降低
• 系统复制度提高
• 一致性问题

1.1小结

使用MQ需要满足什么条件：

1. 生产者不需要从消费者处获得反馈。引入消息队列之前的直接调用，其接口的返回值应该为空，这才让明明下层的动作还没做，上层却当动作做完了继续往后走，即所谓异步成为了可能。
2. 容许短暂的不一致性。
3. 收益超过加入MQ、管理MQ成本。

常见MQ产品：RabbitMQ、RocketMQ、kafka

AMQP，即Advanced Message Queueing Protocol（高级消息队列协议）是应用层协议的开放标准，为面向消息的中间件设计。

AMQP 架构如下：

RabbitMQ 基础架构如下：

1.2RabbitMQ 相关概念

• Broker：接受和分发消息的应用
• Virtual host：处于多租户和安全因素设计的，把AMQP的基本组件划分到一个虚拟的分组中，类似网络中namespace概念。当多个不同的用户使用同一个RabbitMQ server提供服务时，可以划分多个vhost，每个用户在自己的vhost创建exchange / queue等
• Connection：publisher / consumer和broker之间的TCP连接
• Channel：如果每一次访问RabbitMQ都建立一个Connectio，在消息量大的时候建立TCP Connection的开销将是巨大的，效率也较低。Channel是在Connection内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的channel进行通讯，AMQPmethod包含了channel id帮助客户端和message broker识别channel，所以channel之间是完全隔离的。Channel作为轻量级的Connection极大减少了操作系统建立TCP connection的开销。
• Exchange：message到达broker的第一站，根据分发规则，匹配查询表中的routing key，分发消息到queue中去。常用的类型有：direct（point-to-point），topic（publish-subscribe） and fanout（multicast）
• Queue：消息最终被送达这里等待consumer取走
• Binding：exchange和queue之间的虚拟连接，binding中可以包含routing key。Binding信息被保存到exchange中的查询表中，用于message的分发权限。

RabbitMQ的6中工作模式：简单模式、work queues、Publish/Subscribe 发布于订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式、Publisher Comfirm。

1.3JMS

即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件的API。

1.4小结

• RabbitMQ 是基于AMQP协议使用Erlang语言开发的一款消息队列产品
• RabbitMQ 提供了6中工作模式
• AMQP 是协议，类比HTTP
• JMS 是API规范接口，类比JDBC

2.RabbitMQ 的安装和配置

RabbitMQ官网下载安装指南

2.1RabbitMQ web UI

# 开启管理界面
rabbitmq-plugins enable rabbitmq_managemet
# 启动
service rabbitmq-server start # 启动服务 
service rabbitmq-server stop # 停止服务
service rabbitmq-server restart # 重启服务

1. 用户管理

   1. 新增用户

      rabbitmqctl add_user 用户名 密码

   2. 删除用户

      rabbitmqctl delete_user 用户名

   3. 修改密码

      rabbitmqctl change_password 用户名 新密码

   4. 查看当前用户列表

      rabbitmqctl list_users

2. 用户角色

   1. 角色可分类为五种：administrator、monitoring、policymaker、management、普通用户

   2. 设置用户角色

      rabbitmqctl set_user_tags [administrator]

3. 用户权限

   1. 权限有conf、write、read

   2. 设置用户权限

      rabbitmqctl set_permission [-p VHostPath] 用户名 权限

   3. 查看所有用户权限信息

      rabbitmqctl list_permissions [-p VHostPath]

   4. 清除用户的权限信息

      rabbitmqctl clear_permissions [-p VHostPath] 用户名

3.RabbitMQ 快速入门

3.1入门程序

需求：使用简单模式完成消息传递。

步骤：

1. 创建工程（生产者、消费者）

2. 分别添加依赖

   <dependencies>
           <!-- rabbitmq java 客户端 -->
           <dependency>
               <groupId>com.rabbitmq</groupId>
               <artifactId>amqp-client</artifactId>
               <version>5.6.0</version>
           </dependency>
       </dependencies>
   
       <build>
           <plugins>
               <plugin>
                   <groupId>org.apache.maven.plugins</groupId>
                   <artifactId>maven-compiler-plugin</artifactId>
                   <version>3.1</version>
                   <configuration>
                       <source>1.8</source>
                       <target>1.8</target>
                   </configuration>
               </plugin>
           </plugins>
       </build>
   

3. 编写生产者发送消息

   package person.kuntang.producer;
   
   import com.rabbitmq.client.Channel;
   import com.rabbitmq.client.Connection;
   import com.rabbitmq.client.ConnectionFactory;
   
   import java.io.IOException;
   import java.util.concurrent.TimeoutException;
   
   /**
    * @author kun tang
    * @date 2023/2/27
    */
   public class RabbitmqProducer {
       public static void main(String[] args) throws IOException, TimeoutException {
   
           // 1、创建连接工厂
           ConnectionFactory factory = new ConnectionFactory();
           // 2、设置参数
           factory.setHost("192.168.13.129");
           factory.setPort(5672);
           factory.setVirtualHost("demo");
           factory.setUsername("user");
           factory.setPassword("user");
           // 3、创建连接 Connection
           Connection connection = factory.newConnection();
           // 4、创建 Channel
           Channel channel = connection.createChannel();
           // 5、创建队列 Queue
           /*
           queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
           参数：
               1、queue：队列名称
               2、durable：是否持久化。当mq重启之后还在
               3、exclusive：
                       · 是否独占，只能有一个消费者监听这个队列
                       · 当Connection关闭，是否删除队列
                       ·
               4、autoDelete：当没有consumer时，是否自动删除
               5、argument：参数
            */
           // 如果没有一个名字叫hello_world的队列，则创建队列，如果有则不会创建
           channel.queueDeclare("hello_world",true,false,false,null);
           // 6、发送消息
           /*
           basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
           参数：
               1、exchange：交换机名称。简单模式下交换机会使用默认的""
               2、routingKey：路由名称
               3、props：配置信息
               4、body：发送消息数据
            */
           String body = "hello,rabbitmq...";
           channel.basicPublish("","hello_world",null,body.getBytes());
           // 7、释放资源
           channel.close();
           connection.close();
       }
   }
   

4. 编写消费者接受消息

   // 6、接收消息
           /*
           basicConsume(String queue, boolean autoAck, Consumer callback)
           参数：
               1、queue：队列名称
               2、autoAck：是否自动确认
               3、callback：回调对象
            */
           Consumer consumer = new DefaultConsumer(channel){
               /*
                   回调方法，当收到消息后，自动执行该方法
                   1、consumerTag：标识
                   2、envelope：获取信息，交换机、路由key...
                   3、properties：配置信息
                   4、body：数据
                */
               @Override
               public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                   System.out.println("consumeTag: " + consumerTag);
                   System.out.println("Exchange: " + envelope.getExchange());
                   System.out.println("RoutingKey: " + envelope.getRoutingKey());
                   System.out.println("properties: " + properties);
                   System.out.println("body: " + new String(body));
               }
           };
           channel.basicConsume("hello_world",true,consumer);
           // 7、不要关闭资源
   

4.RabbitMQ 的工作模式

1. Work queues 工作队列模式

   1. 模式说明

      与普通模式相比，多了一些消费端，多个消费端共同消费同一个队列中的消息。

   2. 应用场景

      对于任务过重或任务较多的情况使用工作队列可以提高任务处理速度。

2. Pub/Sub 订阅模式

   1. 模式说明

      多了一个Exchange角色，且过程略有变化：

      • P：生产者，不再发送到队列，而是发给X（交换机）
      • C：一直等待消息到来
      • Queue：接受、缓存消息
      • Exchange：一方面，接收生产者发送的消息。另一方面，知道如何处理消息。
        • Fanout：广播，将消息交给所有绑定到交换机的队列；
        • Direct：定向，把消息交给符合指定routing key的队列；
        • Topic：通配符，把消息交给符合routing pattern的队列。
        • Headers：参数匹配

      *Exchange只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，你消息会丢失。

3. Routing 路由模式

   1. 模式说明：
      • 队列与交换机绑定不能是任意绑定，而是指定RoutingKey
      • 消息发送方在向Exchange发送消息时，也必须指定消息的RoutingKey
      • Exchange不再把消息交给每一个绑定的队列，而是根据消息的RoutingKey进行判断，只有队列的RoutingKey与消息的RoutingKey一直，才会接收到消息

4. Topic 通配符模式

   Topic 主题模式可以实现Pub/Sub 模式与Routing 路由模式的功能，而且Topic在配置routing key的时候可以使用通配符，更灵活。

5.Spring 整合 RabbitMQ

SpringBoot整合RabbitMQ

5.1生产者

1. 创建生产者SpringBoot工程

2. 引入依赖坐标

   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-start-amqp</artifactId>
   </dependency>
   

3. 编写yml配置，基本信息配置

4. 定义交换机、队列及绑定关系的配置类

   @Configuration
   public class RabbitMQConfig{
       public static final String EXCHANGE_NAME = "boot_topic_exchange";
       public static final String QUEUE_NAME = "boot_queue";
       
       // 1、交换机
       @Bean("bootExchange")
       public Exchange bootExchange(){
           return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
       }
       // 2、Queue队列
       @Bean("bootQueue")
       public Queue bootQueue(){
           return QueueBulider.durable(QUEUE_NAME).build();
       }
       // 3、队列和交换机绑定关系Binding
       /*
       	1、知道哪个队列
       	2、知道哪个交换机
       	3、routing key
       */
       @Bean()
       public Bind bindQueueExchange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
           return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
       }
   }
   

5. 注入RabbitTemplate，调用方法，完成消息发送

   public class ProducerTest{
       // 1、注入RabbitTemplate
       @Autowired
       private RabbitTemplate rabbitTemplate;
       @Test
       public void testSend(){
           rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.log","boot mq hello");
       }
   }
   

5.2消费者

1. 创建消费者SpringBoot工程

2. 引入start，依赖坐标

3. 编写yml配置，基本信息配置

4. 定义监听类，使用@RabbitListener注解完成队列监听

   @Component
   public class RabbitMQListener{
       @RabbitListener(queues="boot_queue")
       public void ListenerQueue(Message message){
           System.out.println(new String(message.getBody()));
       }
   }
   

5.3小结

• SpinrgBoot提供了快速整合RabbitMQ的方式
• 基本信息在yml中配置，队列交换机以及绑定关系在配置类中使用Bean的方式配置
• 生产端直接注入RabbitTemplate完成消息发送
• 消费端直接使用@RabbitListener完成消息接收

MQ高级

1.RabbitMQ高级特性

1.1消息可靠性投递

使用RabbitMQ的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败的场景。RabbiMQ为我们提供了两种方式用来控制消息的投递可靠性模式：confirm 确认模式；return 退回模式。

rabbitmq整个消息投递的路径为：

producer ---> rabbitmq broker ---> exchange ---> queue ---> consumer

• 消息从producer到exchange会返回一个confirmCallback
• 消息从exchange到queue投递失败会返回一个returnCallback
• 通过这两个callback控制消息的可靠性投递

确认模式：

1. 开启：ConnectionFactory中开启publisher-confirms=
2. 在rabbitTemplate定义ConfirmCallback回调函数

回退模式：

1. 开启：publisher-returns=true

2. 设置RetrunCallback

   rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback(){});
   

3. 设置Exchange处理消息模式：如果消息没有路由到Queue，1、丢弃消息；2、返回消息发送方ReturnCallback

1.2Consumer ACK

消费端收到消息后的确认方式。三种确认方式（rabbit:listener-container标签中定义）：

• 自动确认：acknowledge="none"
• 手动确认：acknowledge="manual"
• 根据异常情况确认：ackowledge="auto"

自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应的message从rabbitmq的消息缓存中移除。实际业务处理中，可能出现消息收到但业务处理出现异常，那么消息就会丢失。设置手动确认，则需要在业务处理后，调用channel.basicAck(deliveryTag,false)，手动签收，如果出现异常，则调用channel.basicNack()或basicReject方法，让其自动重新发送消息。

可靠性总结

1. 持久化
   • exchange 持久化
   • queue 持久化
   • message 持久化
2. 生产方确认Confirm
3. 消费方确认Ack
4. Broker高可用

1.3消费端限流

Consumer 限流机制

1. 确保ack机制为手动确认acknowledge="manual"

2. listener-container配置属性

   ​ perfetch = 1，表示消费端每次从mq拉去一条消息来消费，知道手动确认消费完毕，才会继续拉取下一条消息。

1.4TTL

• 全程Time To Live（存活时间/过期时间）
• 当消息到达存活时间后，还没有被消费，会被自动清除
• RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间

小结

• 设置队列过期时间使用参数：x-message-ttl，单位：ms，火堆整个队列消息统一过期
• 设置消息过期时间使用参数：expiration。单位：ms，当该消息在队列头部时（消费时），会单独判断这一消息是否过期。
• 如果两者都进行了设置，以时间短的为准。

1.5死信队列

Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以被重新发送到另一个队列，这个交换机就算DLX。

消息成为死信的三种情况：

1. 队列消息长度到达限度
2. 消费者拒绝消费消息，basicNack/basicReject，并且不把消息重新放入原目标队列，request=false
3. 原队列存在消息过期设置，消息到达超时时间未被消费

队列绑定死信交换机：给队列设置参数：x-dead-letter-exchange和x-dead-letter-routing-key

1.6延迟队列

即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。

需求：1、下单后，30分钟未支付，取消订单，回滚库存。2、新用户注册成功7天后，发送短信问候。

实现方式：1、定时器。2、延迟队列。

RabbitMQ中未提供延迟队列功能，但可以使用：TTL+死信队列组合实现延迟队列的效果。

1.7日志与监控

RabbitMQ日志

默认存放路径：/var/log/rabbitmq/rabbit@xxx.log

web管控平台监控

rabbitmqctl管理和监控

1.8消息可靠性分析与追踪

在使用任何消息中间件的过程中，难免会出现某条消息异常丢失的情况。这个时候需要有一个较好的机制跟踪记录消息的投递过程，以此协助开发和运维人员进行问题的定位。在RabbitMQ中使用Firehose和rabbitmq_tracing插件功能来实现消息追踪。

注意：打开trace会影响消息写入功能，适当打开后请关闭。

​ rabbitctl trace_on：开启Firehose命令

​ rabbitctl trace_off：关闭Firehose命令

2.RabbitMQ应用问题

2.1消息可靠性保障

• 消息补偿机制

  

2.2消息幂等性处理

幂等性指一次和多次请求某一个资源，对于资源本身应该具有统一的结果。也就是说，任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

• 乐观锁解决方案

3.RabbitMQ集群搭建

Erlang语言天生具备分布式特性（同步Erlang集群各节点的magic cookie实现），因此RabbitMQ天然支持Clustring，不需要像kafka那样通过ZooKeeper实现HA方案和保存集群的元数据。集群是保证可靠性的一种方式，同时可以通过水平扩展以达到增加消息吞吐量能力的目的。

3.1RabbitMQ高可用集群

教学视频：【黑马程序员RabbitMQ全套教程，rabbitmq消息中间件到实战】

冒泡排序

选择排序

插入排序

希尔排序

快速排序

归并排序

计数排序

基数排序

冒泡排序

初步实现

两次完整遍历数组

1. 依次比较数组中相邻两个元素大小，若a[i]>a[i+1]则交换两个元素，两两都比较一遍称为冒泡，结果是让最大的元素排至最后。
2. 重复以上步骤，直到整个数组有序。

减少比较次数

两次循环，一个遍历length次，另一个遍历length - i次。

减少冒泡次数

一次遍历后未发生交换时说明数组有序。

进一步优化

最后一次交换的索引可以作为下一轮冒泡的比较次数。若为零，表示整个数组有序。

public static void main(String[] args){
    int n = a.length - 1;
        for(;;){
            int last = 0;
            for(int j = 0;j < n;j++){
                if(a[j] > a[j + 1]){
                    swap(a,j,j+1);
                    last = j;
                }
            }
            n = last;
            if(n == 0){
                return;
            }
            System.out.println(Arrays.toString(a));
        }
}

public static void swap(int[] a,int i,int j){
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

选择排序

实现

1. 将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集
2. 重复以上步骤，直到整个数组有序

优化方式

1. 为了减少交换次数，每一轮可以先找最小的索引，在每轮最后再交换元素

与冒泡排序相比

1. 平均时间复杂度都是O(n^2)
2. 选择排序一般快于冒泡，因为交换次数少
3. 但如果集合有序度高，冒泡优于选择
4. 冒泡属于稳定排序算法，而选择属于不稳定排序

public static void selection(int[] a){
    for (int i = 0; i < a.length - 1; i++){
        int s = i;
        for (int j = s + 1; j < a.length; j++){
            if(a[s] > a[j]){
                s = j;
            }
        }
        if(s != i){
            swap(a,s,i);
        }
        System.out.println(Arrays.toString(a));
    }
}

插入排序

实现

1. 将数组分为两个区域，排序区域和未排序区域，每一轮从未排序区域中取出第一个元素，插入到排序区域（需保证顺序）
2. 重复以上步骤，直到整个数组有序

优化方式

1. 待插入元素进行比较，遇到比自己小的元素，就代表找到了插入位置，无需进行后续比较
2. 插入时可以直接移动元素，而不是交换元素

与选择排序比较

1. 二者平均时间复杂度都是O(n^2)
2. 大部分情况下，插入都略优于选择
3. 有序集合插入的时间复杂度为O(n)
4. 插入属于稳定排序算法，选择属于不稳定排序

public static void insert(int[] a){
    for(int i = 1; i < a.length; i++){
        int temp = a[i];
        int j = i - 1;
        while(j >= 0){
            if(temp < a[j]){
                a[j + 1] = a[j];
            } else {
                break;
            }
            j--;
        }
        a[j + 1] = temp;
        System.out.println(Arrays.toString(a));
    }
}

希尔排序

快速排序

实现

1. 每一轮拍寻选择一个基准点(pivot)进行分区
   1. 让小于基准点的元素进入一个分区，大于基准的元素进入另一个分区
   2. 当分区完成时，基准点元素的位置就算其最终位置
2. 在子分区重复以上过程，直至子分区元素个数少于等于1，体现的是分而治之的思想(divide-and-conquer)
3. 单边循环快排（lomuto洛穆托分区方案）
   1. 选择最右元素作为基准点元素
   2. j指针负责找到比基准点小的元素，一旦找到则与i进行交换
   3. i指针维护小于基准点元素的边界，也就是每次交换的目标索引
   4. 最后基准点与i交换，i即为分区位置
4. 双边循环快排（并不完全等价于hoare霍尔分区方案）
   1. 选择最左元素作为基准点元素
   2. j指针负责从右向左找比基准点小的元素，i指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至i，j相交
   3. 最后基准点与i（此时i与j相等）交换，i即为分区位置

归并排序

计数排序

基数排序

DDL 数据定义语言

用来定义数据库对象（数据库、表、字段）

数据库操作

# 查询所有数据库
SHOW DATABASES;
# 查询当前数据库
SELECT DATABASE();
#创建
CREATE DATABASE [IF NOT EXISTS] 数据库名 [DEFAULT CHARSET 字符集] [COLLATE 排序规则];
# 删除
DROP DATABASE [IF EXISTS] 数据库名;
# 使用
USE 数据库名;

表操作

# 查询
# 查询当前数据库所有表
SHOW TABLES;
# 查询表结构
DESC 表名;
# 查询指定表的建表语句
SHOW CREATE TABLE 表名;

# 创建
CREATE TABLE 表名(
    字段1 字段1类型[COMMENT '字段1注释'],
    字段2 字段2类型[COMMENT '字段2注释'],
    ...
    字段3 字段3类型[COMMENT '字段3注释'],
)[COMMENT '表注释']

# 修改
# 添加字段
ALTER TABLE 表名 ADD 字段名 类型（长度） [COMMENT '注释'] [约束];
# 修改数据类型
ALTER TABLE 表名 MODIFY 字段名 新数据类型（长度）;
# 修改字段名和字段类型
ALTER TABLE 表名 CHANGE 旧字段名 新字段名 类型（长度） [COMMENT '注释'] [约束];
# 删除
ALTER TABLE 表名 DROP 字段名;
# 修改表名
ALTER TABLE 表名 RENAME TO 新表名;

# 删除
# 删除表
DROP TABLE [IF EXISTS] 表名;
# 删除指定表，并重新创建该表
TRUNCATE TABLE 表名;

数据库数据类型主要分为三种，数值、字符串、日期时间

DML 数据操作语言

用来对数据库表中数据进行增删改

# 添加数据
# 1、给指定字段添加数据
INSERT INTO 表名(字段名1,字段名2,...) VALUES (值1,值2,...);
# 2、给全部字段添加数据
INSERT INTO 表名 VALUES(值1,值2,...);
# 3、批量添加数据
INSERT INTO 表名(字段名1,字段名2,...) VALUES(值1,...)(值1,...)(值1,...);
INSERT INTO 表名 VALUES (...)(...)(...);

# 修改数据
UPDATE 表名 SET 字段名1=值1,字段名2=值2,...[WHERE 条件];

# 删除数据
DELETE FROM 表名 [WHERE 条件];

DQL 数据查询语言

用来查询数据库中表的记录

# 语法
SELECT 字段列表 FROM 表名列表 WHERE 条件列表 GROUP BY 分组字段列表 HAVING 分组后条件列表 ORDER BY 排序字段列表 LIMIT 分页参数;
# 基本查询
# 1、查询多个字段
SELECT 字段1,字段2,... FROM 表名;
SELECT * FROM 表名;
# 2、设置别名
SELECT 字段1 [AS 别名1],... FROM 表名;
# 3、去除重复记录
SELECT DISTINCT 字段列表 FROM 表名;

# 条件查询
# 范围之内BETWEEN...AND... 列表中的值IN(...) 占位符，模糊匹配LIKE 判断空IS NULL 并且AND && 或者OR || 非NOT !

# 聚合函数
# 统计COUNT 最大MAX 最小MIN 平均AVG 求和SUM

# 分组查询
SELECT 字段列表 FROM 表名 [WHERE 条件] GROUP BY 分组字段名 [HAVING 分组后过滤条件];

# 排序查询
SELECT 字段列表 FROM 表名 ORDER BY [字段1,排序方式1,...];

# 分页查询
SELECT 字段列表 FROM 表名 LIMIT 起始索引，查询记录数;

# 执行顺序
FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY -> LIMIT

DCL 数据控制语言

用来创建数据库用户，控制数据库的访问权限

# 管理用户
# 1、查询用户
USE mysql;
SELECT * FROM user;
# 2、创建用户
CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';
# 3、修改用户密码
ALTER USER '用户名'@'主机名' IDENTIFIED WITH mysql_native_password BY '新密码';
# 4、删除用户
DROP USER '用户名'@'主机名';

# 权限控制
# 1、查询权限
SHOW GRANTS FOR '用户名'@'主机名';
# 2、授予权限
GRANT 权限列表 ON 数据库名.表名 TO '用户名'@'主机名';
# 3、撤销权限
REVOKE 权限列表 ON 数据库名.表名 FROM '用户名'@'主机名';

函数

字符串函数

CONCAT(s1,s2,...sn)
LOWER(str)
UPPER(str)
LPAD(str,n,pad)
RPAD(str,n,pad)
TRIM(str)
SUBSTRING(str,start,len)

数值函数

CEIL(X)
FLOOR(X)
MOD(X)
RAND(X)
ROUND(X)

日期函数

CURDATE()
CURTIME()
NOW()
YEAR(date)
MONTH(date)
DAY(dat)
DATE_ADD(date,interval expr type)
DATEDIFF(date1,date2)

流程函数

IF(value,t,f)
IFNULL(value1,value2)
CASE WHEN [val1] THEN [res1] ... ELSE [default] END
CASE [expr] WHEN [val1] THEN[res1] ...ELSE [default] END

约束

约束是作用于表中字段上的规则，用于限制存储在表中的数据。

非空约束 NOT NULL

唯一约束 UNIQUE

主键约束 PRIMARY KEY/(自增：AUTO_INCREMENT)

默认约束 DEFAULT

检查约束 CHECK

外键约束 FOREIGN KEY

外键用来让两张表的数据之间建立连接，从而保证数据的一致性和完整性。

# 添加外键
CREATE TABLE(
    字段名 数据类型
    ...
    [CONSTRAINT] [外键名称] FOREIGN KEY (外键字段名) REFERENCES 主表(主表类名)
);
ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY (外键字段名) REFERENCES 主表(主表列名);

# 删除外键
ALTER TABLE 表名 DROP FOREIGN KEY 外键名称;

#删除/更新行为
# NO ACTION/RESTRICT 有对应外键时不允许
# CASCADE 有外键则删除/更新子表中记录
# SET NULL 设置为NULL
# SET DEFAULT 设置为默认值
ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY (外键字段) REFERENCES 主表名(主表字段名) ON UPDATE CASCADE ON DELETE CASCADE;

多表查询

一对多 在多的表中建立外键指向"一"的主键。

多对多 建立第三张中间表，中间表至少包含两个外键，分别关联两方主键。

一对一 多用于单表拆分，将一张表的基础字段放在一张表中，其他详情字段放在另一张表中。在任意一方加入外键，关联另一方的主键，并且设置外键为唯一（UNIQUE)。

SELECT 字段列表 FROM 表名 WHERE 表名.主键 = 表名.外键
# 连接查询：内连接（交集）、外连接（左外连接、右外连接）、自连接
# 隐式内连接
SELECT 字段列表 FROM 表1,表2 WHERE 条件...;
# 显式内连接
SELECT 字段列表 FROM 表1 [INNER] JOIN 表2 ON 连接条件;

# 左外连接
SELECT 字段列表 FROM 表1 LEFT [OUTER] JOIN 表2 ON 条件...;
# 右外连接
SELECT 字段列表 FROM 表1 RIGHT [OUTER] JOIN 表2 ON 条件...;

# 自连接
SELECT 字段列表 FROM 表A 别名A JOIN 表A 别名B ON 条件;

# 联合查询-union,union all
SELECT 字段列表 FROM 表A...
UNION [ALL]
SELECT 字段列表 FROM 表B...;
-- 联合查询的多表列数需保持一致，字段类型保持一致。union all会将全部数据直接合并，union会在合并后去重。

# 子查询（嵌套查询）
# 标量子查询、列子查询、行子查询、表子查询
SELECT 字段列表 FROM 表1 WHERE 字段 = (SELECT 字段列表 FROM 表2);

事务

是一组操作的集合，它是一个不可分割的工作单位，事务会把所有的操作作为一个整体向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。

# 开启事务
START TRANSACTION / BEGIN;
# 提交事务
COMMIT;
# 回滚事务
ROLLBACK;

事务四大特性ACID

原子性：事务是不可分割的最小操作单元。

一致性：事务完成时，必须使所有数据都保持一致。

隔离性：保证事务在不受外部并发操作影响的独立环境运行。

持久性：事务一旦提交或回滚，它对数据库中的数据的改变是永久的。

# 查看事务隔离级别
SELECT @@TRANSACTION_ISOLATION;
#  设置事务隔离级别
SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED|READ COMMITTED|REPEATABLE READ|SERIALIZABLE}

MySQL体系结构

连接层 最上层是一些客户端和链接服务，主要完成一些类似于连接处理、授权认证及相关的安全方案。服务器也会为安全接入的客户端验证它所具有的操作权限。

服务层 第二层架构主要完成大多数的核心服务功能，如SQL接口，并完成缓存的查询，SQL的分析和优化，部分内置函数的执行。所有跨存储引擎的功能也在这一层实现。

引擎层 存储引擎真正的负责了MySQL中数据的存储和提取，服务器通过API和存储引擎进行通信。

存储层 主要是将数据存储在文件系统上，并完成于存储引擎的交互。

存储引擎

存储引擎就是存储数据、建立索引、更新/查询数据等技术的实现方式。存储引擎是基于表的，而不是基于库的，所以存储引擎也被称为表类型。

# 1、创建表时指定存储引擎
CREATE TABLE 表名(
    ...
)ENGINE = INNODB [COMMENT 注释];
# 2、查看当前数据库支持的存储引擎
SHOW ENGINES;

InnoDB 支持事务、行级锁、外键，innoDB引擎的每张表都会对应表空间文件xxx.idb，存储表结构（frm、sdi）、数据和索引

MyISAM 如果应用以读操作和插入操作为主，只有很少的更新和删除操作，并且对事务的完整性、并发性要求没有那么高，那么很适合这个引擎。

MEMORY 将所有数据保存在内存中，访问速度快，通常用于临时表及缓存。缺陷是对表的大小有限制，而且无法保障数据的安全性。

索引

索引（index）是帮助MySQL高效获取数据的数据结构（有序）。常见索引结构B+Tree、Hash、R-tree（空间索引）、Full-text（全文索引）。

二叉树缺点：顺序插入时退化成链表，查询效率为O(N)。-> 红黑树缺点：大数据量情况下，层级较深，检索速度慢。

B-Tree(多路平衡查找树)

B+Tree：所有数据都会出现在叶子节点，叶子节点形成单向链表。

聚集索引选取规则：

• 如果存在主键，主键就是聚集索引。
• 如果不存在主键，使用第一个唯一 UNIQUE 索引作为聚集索引。
• 如果没有主键和唯一索引，InnoDB会自动生成一个rowid作为隐藏的聚集索引。

回表查询指的是先二级索引查到对应主键值，再回到聚集索引查到行数据。

# 创建索引
CREATE [UNIQUE|FULLTEXT] INDEX index_name ON table_name (index_col_name,...);
# 查看索引
SHOW INDEX FROM table_name;
# 删除索引
DROP INDEX index_name ON table_name;

SQL性能分析

SQL执行频率

# 查询服务器状态信息
SHOW [SESSION|GLOBAL] STATUS;
# 访问频率
SHOW [SESSION|GLOBAL] STATUS LIKE 'COM_______';

慢查询日志记录了所有执行时间超过指定参数(long_query_time)的所有SQL语句的日志。

# 查看慢日志查询设置
SHOW VARIABLES LIKE 'SLOW_QUERY_LOG';
# var/lib/mysql文件中
# 开启慢日志查询开关
slow_query_log = 1
# 设置慢日志的时间为2秒，SQL语句执行时间超过2秒，就视为慢查询。
long_query_time = 2

profile详情

show profiles能够在SQL优化时帮助我们了解时间耗费到哪里了。

# 是否支持profile操作
SELECT @@HAVE_PROFILING;
# 开启
SET PROFILING = 1;

# 查看每一条SQL耗时基本情况
SHOW PROFILES;
# 查看指定query_id的SQL语句各个阶段耗时情况
SHOW PROFILE FOR QUERY QUERY_ID;
# 查看指定query_id的SQL语句CPU使用情况
SHOW PROFILE CPU FOR QUERY QUERY_ID;

explain执行计划

explain或者desc命令获取MySQL如何执行SELECT语句的信息，包括在SELECT语句执行过程中表如何连接和连接顺序。

# 直接在执行语句前加关键字 EXPLAIN/DESC

id: select查询的序列号，表示执行select语句或者是操作表的顺序(id相同，顺序执行; id不同，值大的先执行)。

select_type: 表示SELECT类型，SIMPLE(简单表)、PRIMARY(主查询)、UNION(UNION中第二个或后面的查询语句)、SUBQUERY(SELECT/WHERE之后的子查询)。

type: 表示连接类型，性能好坏NULL>system>const>eq_ref>ref>range>index>all。

possible_key: 显示可能应用的索引，可以有多个。

Key: 实际使用的索引，NULL为未使用索引。

Key_len: 表示索引中使用的字节数，值为索引字段最大可能长度，长度越短越好。

rows: MySQL认为必须要执行查询的行数，估计值。

filtered: 表示返回结果的行数占需读取行数的百分比，值越大越好。

索引使用

最左前缀法则 如果索引了多列（联合索引），查询从索引最左列开始，并且不跳过索引中的列。如果跳跃某一列，索引将部分失效（后面的字段索引失效）。

范围查询 联合索引中出现范围查询(>,<)，范围查询右侧的列索引失效。

索引列运算 不要在索引列上进行运算操作，索引会失效。

字符串不加引号 字符串类型字段使用时，不加引号，索引将失效。

模糊查询 尾部模糊匹配，索引不会失效。头部模糊匹配，索引会失效。

or连接的条件 用or分割开的条件，如果or前的条件中的列有索引，后面的列没有索引，那么涉及的索引都不会被用到。

数据分布影响 如果MySQL评估使用索引比全表慢，则不适用索引。

SQL提示 在SQL语句中加入一些人为的提示来优化操作。

USE INDEX();
IGNORE INDEX();
FORCE INDEX();

覆盖索引 尽量使用覆盖索引（查询使用了索引，并且需要返回的列，在该索引中已经全部能够找到），减少select *。

前缀索引 字段类型为字符串（varchar，text等）时，有时候需要索引很长的字符串，此时可以只将字符串一部分前缀建立索引。

# 语法
CREATE INDEX idx_xxx ON table_name(COLUMN(n));
# 前缀长度根据索引选择性决定
# 选择行指不重复的索引值和数据表的记录总数的比值
SELECT COUNT(DISTINCT SUBSTRING(字段名,M,N)/COUNT(*) FROM table_name;

单列索引和联合索引

索引原则

1. 针对数据量较大且查询比较频繁的表建立索引。
2. 针对于常作为查询条件（WHERE）、排序（ORDER BY)、分组（GROUP BY）操作的字段建立索引。
3. 尽量选择区分度高的列作为索引，尽量建立唯一索引。区分度越高，使用索引效率就越高。
4. 如果是字符串类型的字段，字段长度较长，可以建立前缀索引。
5. 尽量使用联合索引，减少单列索引。查询时，联合索引很多时候可以覆盖索引，避免回表。
6. 要控制索引数量，索引越多维护索引结构代价越大，影响增删改的效率。
7. 如果索引不能存储NULL，在创建表时就使用NOT NULL约束。当优化器知道每列是否包含NULL，它可以更好的确定哪个索引最有效。

SQL优化

插入数据

# insert 优化
# 批量插入
# 手动提交事务
# 主键顺序插入

# 大批量插入数据可以使用 load 指令
# 客户端连接服务器时加上参数--local-infile
mysql --local-infile -u root -p
# 开启从本地加载文件导入数据的开关
set global local_infile = 1;
# 执行 load 指令将准备好的数据加载到表结构中
load data infile '/root/xxx.log' into table 表名 terminated by ';' lines terminated by '\n';

主键优化

数据组织方式 在InnoDB存储引擎中，表数据都是根据主键顺序组织存放的，又称为索引组织表（Index Organization Table IOT）。

页可以为空，也可以填充一半，也可以填充100%。每个页包含2-N行数据（如果一行数据过大，会行溢出），根据主键排列。

页分裂 乱序插入时可能会导致页分裂

页合并 当删除一行记录时，实际只是记录被标记（flagged）为删除并且它的空间允许被其他记录声明使用。当页中删除的记录达到MERGE_THRESHOLD（默认为页的50%），InnoDB会开始寻找最靠近的页，看看是否可以合并两页以优化空间使用。

主键设计原则

尽量降低主键长度；插入数据尽量顺序插入；尽量不要使用UUID或身份证号做主键；业务操作避免修改主键。

order by 优化

Using filesort: 通过表的索引或全表扫描，读取满足条件的数据行，然后在排序缓冲区 sort buffer 中完成排序。所有不是通过索引直接返回排序结果的排序都叫 Filesort 排序。

Using index: 通过有序索引顺序扫描直接返回有序数据。

group by 优化

• 分组操作时可以通过索引提高效率，且索引使用也是满足最左前缀法则的。

limit 优化

优化思路：一般分页查询时，通过创建覆盖索引加子查询形式优化。

count 优化

count()是一个聚合函数，对于返回的结果集，一行行判断，如果NOT NULL，计数加一，最后返回累计值。

用法：count(*) ≈ count(1) > count(主键) > count(字段)。

count(1) 遍历整张表但不取值，服务层对于每一行放数字"1"，直接按行累加。

count(*) 有专门优化，不取值服务层按行累加。

update 优化

InnoDB的行锁是针对索引加的锁，不是针对记录加的锁，并且该索引不能失效，否则会从行锁升级为表锁。

视图/存储过程/触发器

锁

全局锁：锁定数据库中所有表，典型使用场景是做全库的逻辑备份。

表级锁：每次操作锁住整张表

表共享读锁read lock/ 表独占写锁write lock

读锁不会阻塞其他客户端的读，但是会阻塞写。写锁既会阻塞其他客户端的读，又会阻塞其他客户端的写。

# 加锁
lock tables 表名... read/write;
# 释放锁
unlock tables;

元数据锁（meta data lock MDL）加锁是系统自动控制，无需显示使用，在访问一张表时候会自动加上。MDL锁主要是维护表元数据一致性，在表上有活动事务时候，不可以对元数据进行写入操作。避免DML与DDL冲突，保证读写正确性。

当对一张表进行CRUD的时候，加MDL读锁（共享）；当对表结构进行变更时，加MDL写锁（排他）。

意向锁使得表锁不用检查每行数据是否加锁。

意向共享锁（IS）：由语句select ... lock in share mode 添加。与 read lock 兼容，与 write lock 互斥。

意向排他锁（IX）：由insert、update、delete、select ... for update添加。与 read lock 及 write 都互斥。意向锁之间不会互斥。

行级锁：每次操作锁住对应行

InnoDB的数据是基于索引组织的，行锁是通过对索引上的索引项加锁来实现的。行锁主要分为三种：

1. 行锁（Record Lock）：锁定单个记录的锁，防止其他事务对此进行update和delete。在RC、RR隔离级别下都支持。

   SQL	行锁类型	说明
   INSERT/UPDATE/DELETE	排他锁	自动加锁
   SELECT	不加锁
   SELECT .. LOCK IN SHARE MODE	共享锁	手动加LOCK IN SHARE MODE
   SELECT ... FOR UPDATE	排他锁	手动加FOR UPDATE

2. 间隙锁（Gap Lock）：锁定索引记录间隙（不含该记录），防止其他事务在这个间隙进行insert，产生幻读。在RR隔离级别下支持。

3. 临键锁（Next-Key Lock）：行锁和间隙锁组合，同时锁住数据以及数据前面的间隙。在RR隔离级别下支持。

默认情况下，InnoDB在RR隔离级别运行，使用next-key锁进行搜索和索引扫描，以防止幻读。

1. 索引上的等值查询（唯一索引），给不存在的记录加锁时，优化为间隙锁。
2. 索引上的等值查询（普通索引），向右遍历时最后一个值不满足查询需求时，next-key lock退化为间隙锁。
3. 索引上的范围查询（唯一索引）会访问到不满足条件的第一个值为止。

共享锁（S）：允许一个事务读一行，阻止其他事务获得相同数据集的排他锁。

排他锁（X）：允许获取排他锁的事务更新数据，阻止其他事务获得相同数据集的共享锁和排他锁。

InnoDB引擎

逻辑存储结构

表空间（idb文件），一个mysql实例可以对应多个表空间，用于存储记录、索引等数据。

段，分为数据段（Leaf node segment）、索引段（Non-leaf node segment）、回滚段（Rollback segment），InnoDB是索引组织表，数据段就算B+树的叶子节点，索引段即为B+树的非叶子节点。段用来管理多个区。

区，表空间的单元结构，每个区的大小为1M。默认情况下InnoDB引擎页的大小为16k，即一个区中一共有64个连续的页。

页，是InnoDB存储引擎磁盘管理的最小单元，每个页大小默认为16KB。为了保证页的连续性，InnoDB每次向磁盘申请4-5个区。

行，InnoDB存储引擎数据是按行进行存放的。行头Trx_id事务id、Roll_pointer回滚指针。

架构

内存架构

Buffer Pool 缓冲池

Change Buffer 更改缓冲区

Adaptive Hash Index 自适应hash索引

Log Buffer 日志缓冲区

磁盘架构

事务原理

redo log 重做日志记录的是事务提交时数据页的物理修改，用来实现事务的持久性。文件由两部分组成：重做日志缓冲（redo log buffer）（内存中）以及重做日志文件（redo log file）（磁盘中）。事务提交后会把所有修改信息都存到该日志文件中，用于在刷新脏页到磁盘，发生错误时，进行数据恢复使用。

undo log 回滚日志用于记录数据被修改前的信息，用来保证事务的原子性，提供回滚和MVCC（多版本并发控制）。undo log 是逻辑日志。

MVCC

Multi-Version Concurrency Control，多版本并发控制，指维护一个数据的多个版本，使得读写操作没有冲突，快照读提供了一个非阻塞读功能。MVCC具体实现依赖于三个隐式字段、undo log 日志和readView。

当前读读取的是记录的最新版本，读取时还要保证其他并发事务不能修改当前记录，会对读取的记录进行加锁。

快照读就是简单的select（不加锁），读取的时记录数据的可见版本，有可能是历史数据，不加锁，是非阻塞读。

RC：每次select都生成一个快照读。

RR：开启事务后的第一个select语句才是快照读的地方。

Serializable：快照读会退化为当前读。

• 记录中的隐式字段

  DB_TRX_ID 最近修改事务ID，记录插入这条记录或最后一次修改该记录的事务ID。

  EB_ROLL_PTR 回滚指针，指向这条记录的上一个版本，配合undo log，指向上一个版本。

  DB_ROW_ID 隐藏主键，如果表结构没有指定主键，将会生成该隐藏字段。

• undo log

  insert时产生的undo log 日志只在回滚时需要，事务提交后可以被删除。

  update、delete时，产生的undo log 不仅在回滚时需要，快照读时也需要，不会立即被删除。

  undo log 版本链 不同事物或相同事务对同一条记录进行修改，会导致该记录的undolog生成一条记录版本链表，链表的头部是最新的旧记录，链表尾部是最早的旧记录。

• readView

  读视图是快照读SQL执行时MVCC提取数据的依据，记录并维护系统当前活跃的事务（未提交的）id。四个核心字段：

  字段	含义
  m_ids	当前活跃的事务ID集合
  min_trx_id	最小活跃事务ID
  max_trx_id	预分配事务ID，当前最大事务ID+1（事务ID是自增的）
  creator_trx_id	ReadView创建者事务ID

  1. trx_id==creator_trx_id 数据是当前事务更改的，可以访问该版本
  2. trx_id<min_trxx_id 数据已经提交了，可以访问该版本。
  3. trx_id>max_trx_id 当前事务在ReadView生成后才开启的。
  4. min<=trx_id<=max trx_id不在m_ids中，说明数据已经提交，可以访问该版本。

不同的隔离级别，生成ReadView的时机不同：

• RC：在事务中每一次执行快照读时生成ReadView。
• RR：仅在事务中第一次执行快照读时生成ReadView，后续复用该ReadView。

分库分表

介绍

单数据库数据存储存在性能瓶颈：

1. IO瓶颈：热点数据太多，数据库缓存不足，产生大量磁盘IO。请求数据太多，带宽不够，网络IO瓶颈
2. CPU瓶颈：排序、分组、连接查询、聚合统计等SQL会耗费大量COU资源，请求数太多，CPU瓶颈

分库分表的中心思想都是将数据分散存储，使得单一数据库/表的数据量变小来缓解单一数据库的性能问题，从而提升数据库的性能。

拆分策略

垂直拆分

垂直分库：以表为依据，根据业务将不同表拆分到不同库中。特点：

1. 每个库表结构都不一样
2. 每个库的数据也不一样
3. 所有库的并集是全量数据

垂直分表：以字段为依据，根据字段属性不同将不同字段拆分到不同表中。特点：

1. 每个表结构不一样
2. 每个表数据也不一样，一般通过一列（外键/主键）关联
3. 所有表的并集是全量数据

水平拆分

水平分库：以字段为依据，依照一定策略，将一个库的数据拆分到多个库中。特点：

1. 每个库的表结构都一样
2. 每个库的数据都不一样
3. 所有库的并集是全量数据

水平分表：以字段为依据，按照一定策略，将一个表的数据拆分到多个表中。

1. 每个表的表结构都一样
2. 每个表的数据都不一样
3. 所有表的并集是全量数据

实现技术

• shardingJDBC：基于AOP原理，在应用程序中对本地执行的SQL进行拦截、解析、改写、路由处理。需要自行编码配置实现，只支持java，性能较高
• Mycat：数据库分库分表中间件，不用调整代码即可实现分库分表，支持多种语言，性能不及前者

Mycat概述

概念介绍

Mycat入门

• 安装

• 环境准备

• Mycat配置（schema.xml、server.xml、rule.xml）

  

Mycat配置

schema.xml 涵盖了Mycat的逻辑库、逻辑表、分片规则、分片节点及数据源配置。

• schema标签用于定义Mycat实例中的逻辑库，一个Mycat实例中，可以有多个逻辑库，可以通过schema标签来划分不同的逻辑库。Mycat中逻辑库的概念等同于MySQL中的database概念。需要操作某个逻辑库下的表时，也需要切换逻辑库（use xxx）
• datanode标签中定义了Mycat中的数据节点，也就是我们通常说的数据分片。一个dataNode标签就是一个独立的数据分片。
• datahost标签在Mycat逻辑库中作为底层标签存在，直接定义了具体的数据库实例、读写分离、心跳语句。

server.xml配置文件包含Mycat的系统配置信息，主要有两个重要标签：system、user

rule.xml中定义所有拆分表的规则，在使用过程中可以灵活的使用分片算法，或者对同一个分片算法使用不同的参数，它让分片过程可配置化。主要包含两类标签：tableRule、Function

Mycat分片

• 分片规则-范围

  根据指定的字段及其配置的范围与数据节点的对应情况，来决定该数据属于哪一个分片

• 分片规则-取模

  根据指定字段与节点数量进行球磨运算，根据运算结果来决定该数据属于哪一个分片

Mycat管理及监控

Mycat原理

Mycat管理

Mycat默认开通2个端口，可以在server.xml中进行修改。

• 8066数据访问端口，即进行DML和DDL操作
• 9066数据库管理端口，即mycat服务管理控制功能，用于管理mycat的整个集群状态

读写分离

介绍

读写分离，简单地说就是把对数据库的读和写操作分开，以对应不同的数据库服务器。主数据库提供写操作，从数据库提供读操作，这样能有效的减轻单台数据库的压力。

一主一从

原理：MySQL的主从复制是基于binlog实现的。

一主一从读写分离

配置：Mycat控制后台数据库的读写分离和负责均衡由schema.xml文件datahost标签的balance属性控制

<writeHost></writeHost>
<readHost></readHost>

双主双从

两台主库，相互复制，互为主备，增强可用性

双主双从读写分离

<writeHost></writeHost>
balance\writeType\switchType

This is Geek & Tech, a brand new site by KUN TANG that's just getting started. Things will be up and running here shortly, but you can subscribe in the meantime if you'd like to stay up to date and receive emails when new content is published!