linzhi's Site

工作总结

2020-02-03T03:14:19.195000Z

工作总结

工作总结

TODO

spring拦截器过滤器

线程+线程池

文件系统

消息队列mq

activi 流程

maven

加入本地jar包
mvn install:install-file -DgroupId=cn.com.citycloud -DartifactId=authorization -Dversion=1.0 -Dpackaging=jar -Dfile=authorization.jar完整路径

mvn install:install-file -DgroupId=com.citycloud.qcloud -DartifactId=qcloud-oauth2-client -Dversion=2.2.0 -Dpackaging=jar -Dfile=qcloud-oauth2-resource-2.2.0.RELEASE.jar

本地的包放在本地文件夹，加入pom文件

<scope>systemscope>
<systemPath>${project.basedir}/lib/xxx.jarsystemPath>

## 这种方式引入的jar包在打包时不会被包含在war包中


<groupId>xxxgroupId> 通常使用全限定的包名区分该项目和其他项目。
<artifactId>xxxartifactId> 通常和项目名称保持统一
<packaging> jar packaging>

<repositories> 发现依赖和扩展的远程仓库列表
    <repository>
        <id>alimavenid>
        <name>aliyun mavenname>       
        <url>http://maven.aliyun.com/nexus/content/groups/public/url>
    repository>
repositories>

<dependencies>

    <scope>testscope>
    从依赖构件列表里，列出被排除的依赖构件集,此元素主要用于解决版本冲突问题       
    <exclusions>
        <exclusion>
            <artifactId>spring-coreartifactId>
            <groupId>org.springframeworkgroupId>
        exclusion>
    exclusions>
<dependencies/>

settings.xml

MIrrors

使用镜像的一些原因：互联网上有一个同步镜像，地理位置更近，速度更快
您希望将特定存储库替换为您可以更好地控制的内部存储库


<mirrors>
    <mirror>
    
      <id>planetmirror.comid>
      <name>PlanetMirror Australianame>
      
      <url>http://downloads.planetmirror.com/pub/maven2url>
      
      <mirrorOf>centralmirrorOf>
    mirror>
  mirrors>

Profiles
settings.xml中的profile元素是pom.xml profile元素的精简版本。
它由activation，repositories，pluginRepositories和properties元素组成.
如果profile在settings.xml中被激活，则其值将覆盖POM或profiles.xml文件中任何等效的ID配置。

 <profile>  
     <id>downloadSourcesid>  
    <properties>  
      <downloadSources>truedownloadSources>  
      <downloadJavadocs>truedownloadJavadocs>             
    properties>  
  profile>

Repositories
Repositories是Maven用于填充构建系统的本地存储库的项目的远程集合。它来自这个本地存储库，Maven称之为插件和依赖项。不同的远程存储库可能包含不同的项目，并且在启用的profile下，可以搜索它们以查找匹配的版本或快照工件。
Plugin Repositories
pluginRepositories元素块的结构类似于repositories元素。 pluginRepository元素指定Maven可以在哪里找到新插件的远程位置。

<profile>  
      <id>nexus_150id>  
      <repositories>  
        <repository>	
          <id>maven-releasesid>  
          <name>local private nexusname>  
          <url>http://115.231.97.150/nexus/repository/releases/url>  
          <releases>  
            <enabled>trueenabled>  
          releases>  
          <snapshots>  
            <enabled>falseenabled>  
          snapshots>  
        repository>  
        <repository>  
          <id>maven-snapshotsid>  
          <name>local private nexusname>  
          <url>http://115.231.97.150/nexus/repository/maven-snapshots/url>  
          <releases>  
            <enabled>falseenabled>  
          releases>  
          <snapshots>  
            <enabled>trueenabled>  
          snapshots>  
        repository>



      repositories>  
      
      <pluginRepositories>  
        <pluginRepository>  
          <id>maven-releasesid>  
          <name>local private nexusname>  
          <url>http://115.231.97.150/nexus/repository/releases/url>  
          <releases>  
            <enabled>trueenabled>  
          releases>  
          <snapshots>  
            <enabled>falseenabled>  
          snapshots>  
        pluginRepository>  
        <pluginRepository>  
          <id>maven-snapshotsid>  
          <name>local private nexusname>  
          <url>http://115.231.97.150/nexus/repository/maven-snapshots/url>  
          <releases>  
            <enabled>falseenabled>  
          releases>  
          <snapshots>  
            <enabled>trueenabled>  
          snapshots>  
        pluginRepository>  
      pluginRepositories> 
    profile>

启用Profiles

  <activeProfiles>  
  <activeProfile>nexus_150activeProfile>
      
  activeProfiles>

日志写法

使用alibab Java Coding Guidelinec插件规范代码

什么时候写？
--- 方法入口处(info)
---方法退出前(debug,info)
----流程分支(info,warn)
----异常分支(error)
写的内容
---入参(必选)
---方法调用(可选) debug
---返回值（可选）
---中间变量(可选)
写的时候在日志中加入可以查询的条件，以便分辨搜索，如

log.warn("[系统名 模块名] xxxxxx");

工具类

所有的变量和方法都是static
如果需要用到其他的service，通过spring容器去取

//需要强转类型
(xxxService)SpringContextUtils.getBean("xxxService");

业务写法

1. controller

接受多个对象时，必须把多个对象封装成一个VO类来接受

2. swagger注解：

作用范围	API	使用位置
对象属性	@ApiModelProperty	用在出入参数对象的字段上
协议集描述	@Api	用于controller类上
协议描述	@ApiOperation	用在controller的方法上
Response集	@ApiResponses	用在controller的方法上
Response	@ApiResponse	用在 @ApiResponses里边
非对象参数集	@ApiImplicitParams	用在controller的方法上
非对象参数描述	@ApiImplicitParam	用在@ApiImplicitParams的方法里边
描述返回对象的意义	@ApiModel	用在返回对象类上

@ApiImplicitParam

属性	取值	作用
paramType		查询参数类型
	path	以地址的形式提交数据
	query	直接跟参数完成自动映射赋值
	body	以流的形式提交仅支持POST
	header	参数在request headers 里边提交
	form	以form表单的形式提交仅支持POST
dataType	参数的数据类型	只作为标志说明，并没有实际验证
	Long
	String
name		接收参数名
value		接收参数的意义描述
required		参数是否必填
	true	必填
	false	非必填
defaultValue		默认值


@ApiImplicitParams({ @ApiImplicitParam(paramType = "body", dataType = "MessageParam", 
name = "param", value = "信息参数", required = true) })

在controller类上
@Api(value="用户controller",tags={"用户操作接口"})

在controller方法上
@ApiOperation(value="获取用户信息",tags={"获取用户信息copy"})

在实体类上
@ApiModel(value="user对象",description="用户对象user")

在实体方法上
@ApiModelProperty(value="用户名",name="username")

swagger依赖：

<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger2artifactId>
    <version>${springfox-swagger2.version}version>
dependency>
<dependency>
    <groupId>io.springfoxgroupId>
    <artifactId>springfox-swagger-uiartifactId>
    <version>${springfox-swagger-ui.version}version>
dependency>

Do类继承Model,不写其他通用的属性，注释属性中文注释lombak，主键注解@Id
Dto类继承BaseDto，可以写入其他的Do类作为属性(有其他属性，需注解lombak)
Vo类，在controller里作为参数使用注解@ApiModel，@ApiModelProperty，注解lombak
mapper接口，方法参数使用Do类，参数名为record，注解@Mapper
Service 接受参数为Dto,传给mapper的参数为Dto.getRecord(),返回类型为SWrapper
controller extends BaseController方法接受参数Vo，传给service的为Dto,需要把Vo转成Dto通过toDto(Vo,OperateType)方法返回类型RWrapper

打包

1. jar包：

<build>

    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
        plugin>
    plugins>
    <finalName>springbootdemofinalName>
build>

spring-boot 默认提供内嵌的tomcat，所以打包直接生成jar 包，用java -jar 命令就可以启动。
//nohup 意思是不挂断运行命令,当账户退出或终端关闭时,程序仍然运行
//当用 nohup 命令执行作业时，缺省情况下该作业的所有输出被重定向到nohup.out的文件中
nohup java -jar test.jar >temp.txt &

Spring程序会按优先级从下面这些路径来加载application.properties配置文件

nohup java -jar -Dspring.config.location=D:\config\config.properties xxx.jar> /xx/nohup.out 2>&1 &

2. war包：

有时候我们更希望一个tomcat 来管理多个项目，这种情况下就需要项目是war 格式的。

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-tomcatartifactId>
    <scope>providedscope>
dependency>

spring-boot-starter-tomcat 是原来被传递过来的依赖，默认会打到包里，所以我们再次引入此依赖，并指定依赖范围为provided，这样tomcat 相关的jar就不会打包到war 里了

添加ServletInitializer将项目打成war包，部署到外部的tomcat中，这个时候，不能直接访问spring boot 项目中配置文件配置的端口。

application.yml中配置的server.port配置的是spring boot内置的tomcat的端口号, 打成war包部署在独立的tomcat上之后, 你配置的server.port是不起作用的。

3. assembly插件

为什么需要Assembly插件呢？因为对于服务类型的后台程序，线上运行时一般通过脚本的方式启动和停止，而项目中的目录结构复杂且不够直观，且项目文件也需要合并和过滤，Assembly插件就可以帮助我们完成。

比如现在我们的项目目录如下：

+ src 
    + main 
        + java 
        + resources 
            + jdbc.properties 
        + bin 
            + start.sh 
            + stop.sh 
        + assembly 
            + assembly.xml

最终想要的目录：

+ bin 
    start.sh 
    stop.sh 
+ conf
    jdbc.properties 
+ lib(依赖jar包目录) 
    xxx.jar

分页

依赖

<dependency>
    <groupId>org.springframework.datagroupId>
    <artifactId>spring-data-commonsartifactId>
    <version>2.1.8.RELEASEversion>
dependency>
<dependency>
    <groupId>com.github.pagehelpergroupId>
    <artifactId>pagehelper-spring-boot-starterartifactId>
    <version>1.2.12version>
dependency>

2.分页封装工具类

public class PageInfoAdapter<T> extends PageImpl<T> {
public PageInfoAdapter(Page page) {
super(page.getResult(), PageRequest.of(page.getPageNum() - 1, page.getPageSize()), page.getTotal());
}
}

controller

public RWrapper listTaskPlan(Pageable pageable,TaskPlan taskPlan)
{
return new RWrapper(taskPlanService.listTaskPlan(pageable,taskPlan));
}

servicepublic

Page> listTaskPlan(Pageable pageable, TaskPlan taskPlan) 
{
    com.github.pagehelper.Page> pageInfo =  PageHelper.startPage(pageable.getPageNumber(),pageable.getPageSize())
.doSelectPage(() ->  taskPlanQueryMapper.listTaskPlan(taskPlan));
    return new PageInfoAdapter(pageInfo);
}

mybatis

mybatis逆向工程
generatorConfig.xml文件需要加上不生成注释
自定义的生成文件依赖

<plugin>
    <groupId>org.mybatis.generatorgroupId>
    <artifactId>mybatis-generator-maven-pluginartifactId>
    <version>1.3.5version>
    <configuration>     
  <configurationFile>src/main/resources/mybatis/generatorConfig.xml
  configurationFile>
    <verbose>trueverbose>
    <overwrite>trueoverwrite>
    configuration>
plugin>

<dependency>
    <groupId>org.mybatis.generatorgroupId>
    <artifactId>mybatis-generator-coreartifactId>
    <version>1.3.5version>
    <scope>providedscope>
dependency>

response/request

给前端返回json格式数据

String json = JsonUtil.bean2Json(object);

response.setCharacterEncoding("utf-8");

response.setContentType("application/json; charset=utf-8");

PrintWriter writer = response.getWriter();

writer.write(json);

取得request请求地址

referUri = request.getScheme() + "://" + request.getServerName() 
+ ":" + request.getServerPort() + request.getServletPath();

if (request.getQueryString() != null) 
{  
    referUri += "?" + request.getQueryString();
}

linux

2019-12-27T02:45:59.598000Z

linux

linux

权限

d rwx r-x r-x 3 root root
第 1 位为文件类型字段，后 9 位为文件权限字段

文件类型:

d：目录
-：文件
l：链接文件

权限字段
9 位的文件权限字段中，每 3 个为一组，共 3 组，每一组分别代表对文件拥有者u、所属群组g以及其它人o的文件权限。
文件的数量
第一个root: 文件拥有者
第二个root:所属群组
rwx：代表可读4，可写2，可执行1

修改文件/目录的权限的命令：chmod
chmod u=rwx,g=rw,o=r aaa.txt
chmod 764 aaa.txt
chmod +x aaa.txt

改变文件所属用户：chown 用户名文件名

命令

基本命令

ctrl-a 可以将光标移至行首
ctrl-e 可以将光标移至行尾
ctrl-k 可以删除光标至行尾的所有内容
ctrl-u 可以删除行内光标所在位置之前的内容
ctrl-w 删除你键入的最后一个单词
ctrl-l : 清屏

Tab：命令和文件名补全；
man:指令的基本用法与选项介绍。
-- help:指令的具体信息显示
pwd：显示当前所在位置

ls: 列出文件或者目录的信息 ls [-atl] file|dir

cd：切换目录
cd ..（或cd../）：切换到上一层目录
cd /：切换到系统根目录
cd ~：切换到用户主目录
cd -：切换到上一个操作所在目录

mkdir ：增加目录

mv [dir] [newdir]：修改目录/文件的名称，移动位置

cp [-r] ：复制文件/目录 -r 表示递归

rm [-rf] ：删除文件/目录

find

find ：查找目录下的文件及文件夹
find . ：列出当前目录及子目录下所有文件和文件夹
find /home -name "*.txt" ：在/home目录下查找以.txt结尾的文件名
find /home -iname "*.txt" ：同上，但忽略大小写:
find . $ -name "*.txt" -o -name "*.pdf" $ 或find . -name "*.txt" -o -name "*.pdf" ：当前目录及子目录下查找所有以.txt和.pdf结尾的文件

系统信息

ps和grep

ps -ef : 查看当前系统正在运行进程
gerp：搜索
ps -ef | grep xx：查看特定的进程
grep -v xx: 不包含
grep -w xx:只显示全字符符合的列
kill -9 [uid] : 杀死进程

查看当前系统的网卡信息：ifconfig
查看与某台机器的连接情况：ping
查看当前系统的端口使用：netstat -an

查看内存信息 cat /proc/meminfo
查看CPU信息 cat /proc/cpuinfo

用户管理

用户添加：
useradd :
-d 目录指定用户主目录
-g 用户组指定用户所属的用户组。
useradd -d usr/tlz -g root tlz
口令管理：passwd
用户修改: usermod 用户删除: userdel -r

链接

Linux具有为一个文件起多个名字的功能，称为链接。被链接的文件可以存放在相同的目录下，但是必须有不同的文件名，而不用在硬盘上为同样的数据重复备份。另外，被链接的文件也可以有相同的文件名，但是存放在不同的目录下，这样只要对一个目录下的该文件进行修改，就可以完成对所有目录下同名链接文件的修改。

ln -s /usr/mengqc/mub1 /usr/liu/abc

执行该命令后，/usr/mengqc/mub1代表的路径将存放在名为/usr/liu/abc的文件中。

文件操作

touch filename : 新建文件

tail [-f] 查看文件的尾部内容
tail -f : 显示文件最新追加的内容查看日志更新
tail -10 : 显示后10行
tail +20 : 显示20行至文件末尾

cat :
more [-cd] : 全屏方式显示文本 -c 先清屏 -d 显示百分比
回车：下一行
空格：下一屏
q : 退出

less : 分页显示文本
上下键翻页
q : 退出

打包

tar -zcvf 打包后的名.tar.gz 要打包的文件名：打包并压缩文件
z：调用gzip压缩命令进行压缩
c：打包文件
v：显示运行过程
f：指定文件名

tar [-xvf] 压缩文件
x : 解压

unzip ：解压zip包和war包

awk

awk '{print $2}' : 取出第二个字段输出

sed

vim

正常模式

复制一行：yy y$(当前到行尾)
粘贴：p
删除：s
上一行末尾：k
下一行末尾：j

编辑模式

正常模式进入编辑模式： i o a

命令模式

进入命令模式： :
查找：/ 查找后用 n 移动光标
查找：？从末尾开始查找
替换：

s/x/y/g 把当前行的所有的x替换成y
%s/x/y/g 把所有的x替换成y
10,15s/1/2 把10-15行所有1替换成2

shell

Shell 是一个程序，一般都是放在/bin或者/user/bin目录下，当前 Linux 系统可用的 Shell 都记录在/etc/shells文件中。
/etc/shells是一个纯文本文件，可以使用 cat 命令查看它。

查看当前 Linux 的默认 Shell，那么可以输出 SHELL 环境变量：echo $SHELL

对于普通用户，Base shell 默认的提示符是美元符号$；
对于超级用户（root 用户），Bash Shell 默认的提示符是井号#。该符号表示 Shell 等待输入命令。

Shell 通过PS1和PS2两个环境变量来控制提示符格式：

新建一个文件，扩展名为sh（sh代表shell），扩展名并不影响脚本执行
第一行 #!/bin/bash

#!/usr/bin/env bash是优先选择的，因为它提供了灵活性，特别是你想在不同的版本下运行这个脚本；
"#!" 是一个约定的标记，告诉系统脚本需要什么解释器来执行，使用哪一种Shell。
chmod +x 使脚本可执行

bash 命令

-c string 如果有 -c 选项，那么命令将从 string 中读取。如果 string 后面
有参数 (argument)，它们将用于给位置参数 (positional parameter
，以 $0 起始) 赋值。

特殊命令

变量	含义
$$	当前Shell进程ID。对于 Shell 脚本，就是这些脚本所在的进程ID。
$?	上个命令的退出状态，或函数的返回值。
$0	当前脚本的文件名
$n	传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个参数是$1，第二个参数是$2。
$#	传递给脚本或函数的参数个数。
$*	传递给脚本或函数的所有参数。
$@	传递给脚本或函数的所有参数。被双引号(" ")包含时，与 $* 稍有不同

命令替换

是指Shell可以先执行命令，将输出结果暂时保存，在适当的地方输出。


在 bash shell 中，$( ) 与` ` (反引号) 都是用来做命令替换用(commandsubstitution)的。
`command`

$(command)

变量替换

形式	说明
${var}	变量本来的值
${var:-word}	如果变量 var 为空或已被删除(unset)，那么返回 word，但不改变 var 的值。
${var:=word}	如果变量 var 为空或已被删除(unset)，那么返回 word，并将 var 的值设置为 word。
${var:?message}	如果变量 var 为空或已被删除(unset)，那么将消息 message 送到标准错误输出，可以用来检测变量 var 是否可以被正常赋值。若此替换出现在Shell脚本中，那么脚本将停止运行。
${var:+word}	如果变量 var 被定义，那么返回 word，但不改变 var 的值。

运算符

Bash 支持很多运算符，包括算数运算符、关系运算符、布尔运算符、字符串运算符和文件测试运算符。
原生bash不支持简单的数学运算，但是可以通过其他命令来实现，例如 awk 和 expr，expr 最常用。

条件表达式要放在方括号[]之间，并且要和括号有空格；
表达式和运算符之间也要有空格

运算符	说明	举例
+	加法	`expr $a + $b`
*	乘法	`expr $a \* $b` 乘号前边必须加反斜杠才能实现乘法运算；
==	相等	[ $a == $b ] 条件表达式要放在方括号之间，并且要和括号有空格；表达式和运算符之间也要有空格
-eq	检测两个数是否相等，相等返回 true	[ $a -eq $b ]
-o	或运算，有一个表达式为 true 则返回 true。	[ $a -lt 20 -o $b -gt 100 ]
-a	与运算，两个表达式都为 true 才返回 true。	[ $a -lt 20 -a $b -gt 100 ]
-z	检测字符串长度是否为0，为0返回 true。	[ -z $a ]
-n	检测字符串长度是否为0，不为0返回 true。	[ -n $a ]
-d	检测文件是否是目录，如果是，则返回 true。	[ -d $file ]
-f	检测文件是否是普通文件（既不是目录，也不是设备文件），如果是，则返回 true。	[ -f $file ]
-s	检测文件是否为空（文件大小是否大于0），不为空返回 true。	[ -s $file ]
-e	检测文件（包括目录）是否存在，如果是，则返回 true。	[ -e $file ]

if [ $a -lt 5 -o $b -gt 100 ]
then
    echo "$a -lt 100 -o $b -gt 100 : returns true"
else
    echo "$a -lt 100 -o $b -gt 100 : returns false"
fi


basename:
basename /usr/bin/sort          -> "sort"

dirname:
dirname /usr/bin/          -> "/usr"

-----------------------------------------------------------------

| 运算符：
command1 | command2
他的功能是把第一个命令command1 执行的结果 作为command2的 输入 传给command2
ls -s|sort -nr
该命令列出当前目录中的文档(含size)，并把输出送给sort命令作为输入，sort命令按数字递减的顺序把ls的输出排序。

---------------------------------------------------------------------
&& 运算符：
command1  && command2
&&左边的命令（命令1）返回真(即返回0，成功被执行）后，&&右边的命令（命令2）才能够被执行


|| 运算符：
command1 || command2
||左边的命令（command1）未执行成功，那么就执行||右边的命令（command2）


() 运算符：
(command1;command2;command3....)               多个命令之间用;分隔
把几个命令合在一起执行


(()) 运算符：
只要括号中的运算符、表达式符合C语言运算规则，都可用在$((exp))中
双括号中的变量可以不使用$符号前缀。括号内支持多个表达式用逗号分开。只要括号中的表达式符合C语言运算规则，比如可以直接使用for((i=0;i<5;i++))， 如果不使用双括号， 则为for i in `seq 0 4`或者for i in {0..4}。再如可以直接使用if (($i<5))， 如果不使用双括号， 则为if [ $i -lt 5 ]。


[[]] 运算符：
[[ ]] 结构比[ ]结构更加通用
比如，&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中
可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。


>/dev/null 2>&1

1：> 代表重定向到哪里，例如：echo "123" > /home/123.txt
2：/dev/null 代表空设备文件
3：2> 表示stderr标准错误
4：& 表示等同于的意思，2>&1，表示2的输出重定向等同于1
5：1 表示stdout标准输出，系统默认值是1，所以">/dev/null"等同于 "1>/dev/null"

字符串

# 获取字符串长度
string="abcd"
echo ${#string} #输出 4

# 截取字符串
string="alibaba is a great company"
echo ${string:1:4} #输出liba

数组


array_name=(value0 value1 value2 value3)

# 使用@ 或 * 可以获取数组中的所有元素
${array_name[*]}
${array_name[@]}


# 取得数组元素的个数
length=${#array_name[@]}

# 取得数组单个元素的长度
lengthn=${#array_name[n]}

case esac语句

    case ${ACTION} in
    war)
        deploy_war  # 函数的调用
        ;;
    min)
        deploy_min
        ;;
    web)
        deploy_web
        ;;
    restart)
        stop_tomcat
        start_tomcat
        ;;
    *)
        usage
        ;;
    esac

for

for loop in 1 2 3 4 5
do
    echo "The value is: $loop"
done

function

function test() {
    local pids = #命名变量
    
    sh startup.sh >/dev/null 2>&1  # 运行脚本
    
    log "stop tomcat success."  # 输出日志
}

test  # 调用函数

重定向

一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件：

标准输入文件(stdin)：stdin的文件描述符为0，Unix程序默认从stdin读取数据。
标准输出文件(stdout)：stdout 的文件描述符为1，Unix程序默认向stdout输出数据。
标准错误文件(stderr)：stderr的文件描述符为2，Unix程序会向stderr流中写入错误信息。

命令	说明
command > file	将输出重定向到 file。
command < file	将输入重定向到 file。
command >> file	将输出以追加的方式重定向到 file。

分支管理

2019-10-11T08:51:19.133000Z

分支管理

查看远程分支 git branch -a
查看本地分支 git branch
创建分支 git branch name
把分支推到远程库 git push orgin name
切换分支 git checkout name
删除本地分支 git branch -d name

本地项目上传到github

1. 在github上新建一个repository
1. 选择本地的一个目录进入，右键选择git bash here
1. 命令：

git clone 新建仓库的url

1. 完成3后，在目录下就会多一个仓库名的文件夹，将需要上传的项目的所有文件放到那个文件夹里
1. cd 仓库的文件夹名
1. 输入命令

git add .
git commit -m "提交的信息"
git push -u origin master

1. 需要github输入用户名和密码

提交修改的代码到新建分支（原来的分支代码不变）

git checkout -b newbrabch
git checkout oldbranch
git fetch origin
git reset --hard origin/oldbranch

暂时保存和恢复进度

正在dev分支开发新功能，做到一半时有人过来反馈一个bug，让马上解决，但是新功能做到了一半你又不想提交，这时就可以使用git stash命令先把当前进度保存起来，然后切换到另一个分支去修改bug，修改完提交后，再切回dev分支，使用git stash pop来恢复之前的进度继续开发新功能。

git stash save 'msg'

git stash list

数据结构总结

2019-04-01T07:48:42.142000Z

数据结构
数据结构详解

数据结构

基本概念

相互之间存在一种或多种特定关系的数据元素的集合。

按某种逻辑关系组织起来的一批数据（或称带结构的数据元素的集合）应用计算机语言并按一定的存储表示方式把它们存储在计算机的存储器中，并在其上定义了一个运算的集合。

数据逻辑结构，数据存储结构，数据的运算称为数据结构三要素。

逻辑结构

数据元素间抽象化的相互关系简称为逻辑结构。与数据的存储无关，独立于计算机，它是从具体问题抽象出来的数学模型。

1.线性结构：有且只有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前驱和一个直接后继。
2.非线性存储：每个结点可以有不止一个直接前驱和直接后继。

存储结构

存储结构是指数据结构在计算机中的表示（又称映像），也称物理结构。它包括数据元素的表示和关系的表示。数据的存储结构是逻辑结构用计算机语言的实现，它依赖于计算机语言。

顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元里，元素之间的关系由存储单元的邻接关系来体现。其优点是可以实现随机存取，每个元素占用最少的存储空间；缺点是只能使用相邻的一整块存储单元，因此可能产生较多的外部碎片。

链接存储：不要求逻辑上相邻的元素在物理位置上也相邻，借助指示元素存储地址的指针表示元素之间的逻辑关系。其优点是不会出现碎片现象，充分利用所有存储单元；缺点是每个元素因存储指针而占用额外的存储空间，并且只能实现顺序存取。

索引存储：在存储元素信息的同时，还建立附加的索引表。索引表中的每一项称为索引项，索引项的一般形式是：（关键字，地址）。其优点是检索速度快；缺点是增加了附加的索引表，会占用较多的存储空间。另外，在增加和删除数据时要修改索引表，因而会花费较多的时间。

散列存储：根据元素的关键字直接计算出该元素的存储地址，又称为Hash存储。其优点是检索、增加和删除结点的操作都很快；缺点是如果散列函数不好可能出现元素存储单元的冲突，而解决冲突会增加时间和空间开销。

判断

当一个结构，如数组、链表、树、图，在逻辑结构中只有一种定义，而在物理结构中却有两种选择，那么这个结构就属于逻辑结构；
相反，当此结构在原有基础上加上了某种限定，使得其在物理结构中只有一种定义，那么这个结构就属于物理（存储）结构；

数据的运算

施加在数据上的运算包括运算的定义和实现。
运算的定义是针对逻辑结构的，指出运算的功能；
运算的实现是针对存储结构的，指出运算的具体操作步骤。

数据结构详解

1.线性表

线性表是由n(n>=0)个类型相同的数据元素a0,a1,…,an-1组成的有限的序列，在数学中记作(a0,a1,…,an-1)，其中ai的数据类型可以是基本数据类型(int,float等)、字符或类。n代表线性表的元素个数，也称其为长度(Length)。若n=0，则为空表；若n > 0，则ai(0 < i < n-1)有且仅有一个前驱(Predecessor)元素ai-1和一个后继(Successor)元素ai+1，a0没有前驱元素，ai没有后继元素。

1.1 线性表的顺序存储（SeqList）

顺序存储结构底层是利用数组来实现的，而数组可以存储具有相同数据类型的元素集合，如int，float或者自定义类型等，当我们创建一个数组时，计算机操作系统会为该数组分配一块连续的内存块，这也就意味着数组中的每个存储单元的地址都是连续的，因此只要知道了数组的起始内存地址就可以通过简单的乘法和加法计算出数组中第n-1个存储单元的内存地址

线性表的顺序存储结构称之为顺序表(Sequential List),它使用一维数组依次存放从a0到an-1的数据元素(a0,a1,…,an-1)，将ai(0

1.2 线性表的链式存储

当创建顺序表时必须分配一块连续的内存存储空间，而当顺序表内部数组的容量不足时，则必须创建一个新的数组，然后把原数组的的元素复制到新的数组中，这将浪费大量的时间。而在插入或删除元素时，可能需要移动数组中的元素，这也将消耗一定的时间。
鉴于这种种原因，于是链表就出场了，链表在初始化时仅需要分配一个元素的存储空间，并且插入和删除新的元素也相当便捷，同时链表在内存分配上可以是不连续的内存，也不需要做任何内存复制和重新分配的操作。
线性链表的存储结构是用若干个地址分散的存储单元存放数据元素的，逻辑上相邻的数据元素在物理位置上不一定相邻，因此每个存储单元中都会有一个地址指向域，这个地址指向域指明其后继元素的位置。在链表中存储数据的单元称为结点(Node)，从图中可以看出一个结点至少包含了数据域和地址域，其中数据域用于存储数据，而地址域用于存储前驱或后继元素的地址。

1.2.1 单链表

单链表(SingleILinkedList)

带头结点的单链表(HeadSingleILinkedList)
头结点：一个没有值的结点

循环单链表(CircularHeadSILinkedList)
链表中的最后一个结点的next域指向了头结点head，形成环形的结构

详细讲解：顺序表与单链表详细讲解与实现

1.2.2 双链表

在单链表分析中，我们可以知道每个结点只有一个指向后继结点的next域，倘若此时已知当前结点p，需要查找其前驱结点，那么就必须从head头指针遍历至p的前驱结点，操作的效率很低，因此如果p有一个指向前驱结点的next域，那效率就高多了，对于这种一个结点中分别包含了前驱结点域pre和后继结点域next的链表，称之为双链表。
双链表的主要优点是对于任意给的结点，都可以很轻易的获取其前驱结点或者后继结点，而主要缺点是每个结点需要添加额外的next域，因此需要更多的空间开销，同时结点的插入与删除操作也将更加耗时，因为需要更多的指针指向操作。

双链表(HeadDoubleILinkedList)

循环双链表(LoopHeadDILinkedList)

排序循环双链表(SortLoopHeadDIlinkedList)
排序循环双链表指的是在插入元素时，不再根据index标志，而是根据值的大小寻找插入位置，但是有个插入值data必须是T或者T的父类而且实现了Comoarable接口。

异或高效存储双链表(XORNode)
双链表的实现中，都是需要一个指向后继结点的正向指针和一个指向前驱结点的反向指针，我们在构造一个结点类时需要一个数据域data、一个指向后继结点的指针next以及一个指向前驱结点的指针prev。但为了设计更高效节省存储空间，一种基于指针差运算存储高效的双向链表就诞生了。这种链表的每个结点仍然与单链表一样,仅使用一个指针域来设计双向链表。
结点中的ptrdiff字段存储了后继结点与前驱结点的地址差，指针的差通过异或运算来实现。
pridiff=后继结点的地址⊕前驱结点的地址
还未实现

详细讲解：双链表详细讲解与实现

1.3 改良顺序表与双链表(类似ArrayList和LinkedList)

改良顺序表与双链表类似ArrayList和LinkedList(Iterator迭代器与fast-fail机制)

2. 栈(Stack)

可以认为栈(Stack)是一种特殊的线性表，其插入和删除操作只允许在线性表的一端进行，一般而言，把允许操作的一端称为栈顶(Top)，不可操作的一端称为栈底(Bottom)，同时把插入元素的操作称为入栈(Push),删除元素的操作称为出栈(Pop)。若栈中没有任何元素，则称为空栈。
栈(Stack)是一种有序特殊的线性表，只能在表的一端(称为栈顶，top，总是指向栈顶元素)执行插入和删除操作，最后插入的元素将第一个被删除，因此栈也称为后进先出(Last In First Out,LIFO)或先进后出(First In Last Out FILO)的线性表。

2.1 顺序栈

顺序栈，顾名思义就是采用顺序表实现的的栈，顺序栈的内部以顺序表为基础，实现对元素的存取操作。当然我们还可以采用内部数组实现顺序栈。

顺序表实现(StackByArrayList)

内部数组实现(SeqStack)

2.2 链式栈

链式栈（Linked Stack），就是采用链式存储结构的栈，由于我们操作的是栈顶一端，因此这里采用单链表（不带头结点）作为基础即可。

单链表实现(LinkedStackBySingleLinkedList)

结点实现(LinkedStack)

2.3 栈的应用

符号匹配（CheckExpression）
在编写程序的过程中，我们经常会遇到诸如圆括号"()"与花括号"{}"，这些符号都必须是左右匹配的，这就是我们所说的符合匹配类型，当然符合不仅需要个数相等，而且需要先左后右的依次出现，否则就不符合匹配规则

中缀表达式转换为后缀表达式(CalculateExpression)

2.4 详细讲解

栈的详细详解与实现

3. 队列(Queue)

队列是一种特殊的线性表，其插入和删除的操作分别在表的两端进行，队列的特点就是先进先出(First In First Out)。我们把向队列中插入元素的过程称为入队(Enqueue)，删除元素的过程称为出队(Dequeue)并把允许入队的一端称为队尾，允许出的的一端称为队头，没有任何元素的队列则称为空队。

3.1 顺序队列

单队列
采用顺序表实现队列时，入队操作直接执行顺序表尾部插入操作，其时间复杂度为O(1)，出队操作直接执行顺序表头部删除操作，其时间复杂度为O(n)，主要用于移动元素，效率低，既然如此，我们就把出队的时间复杂度降为O(1)即可，为此在顺序表中添加一个头指向下标front和尾指向下标，出队和入队时只要改变front、rear的下标指向取值即可，此时无需移动元素，因此出队的时间复杂度也就变为O(1)。
通过给顺序表添加front和rear变量记录下标后使用得出队操作的时间复杂度降为O(1)，但是却出现了另外一个严重的问题，那就是空间浪费。
遗留下来的空间并没有被重新利用，反而是空着，出现队列已满的假现象，这种假现象我们称之为假溢出，之所以出现这样假溢出的现象是因为顺序表队列的存储单元没有重复利用机制，而解决该问题的最合适的方式就是将顺序队列设计为循环结构。

循环队列（SeqQueue）
顺序循环队列就是将顺序队列设计为在逻辑结构上收尾相接的循环结构，这样我们就可以重复利用存储单元。
循环队列有以下计算关系

//其中front、rear的下标的取值范围是0~size-1，不会造成假溢出。
front=(front+1)%size;//队头下标
rear=(rear+1)%size;  //下一个入队元素的下标

a. front为队头元素的下标，rear则指向下一个入队元素的下标
b. 当front=rear时，我们约定队列为空。
c. 出队操作改变front下标指向，入队操作改变rear下标指向，size代表队列容量。
d. 约定队列满的条件为front=(rear+1)%size,注意此时队列中仍有一个空的位置，此处留一个空位主要用于避免与队列空的条件front=rear相同。
e. 队列内部的数组可扩容，并按照原来队列的次序复制元素数组

3.2 链式队列（LinkedQueue）

链式队列，将使用带头指针front和尾指针rear的单链表实现，front直接指向队头的第一个元素，rear指向队尾的最后一个元素。
设计链式队列

a. 分别设置front和rear指向队头结点和队尾结点，使用单链表的头尾访问时间复杂度为O(1)
b. 设置初始化空队列，使用front=rear=null，并且约定条件front==null&&rear==null成立时，队列为空。
c. 当第一个元素入队或者最后一个元素出队时，同时更新front指针和rear指针的指向。
d. 入队操作时，使插入元素的结点在rear之后并更新rear指针指向新插入元素。
e. 出队操作时，若队列不为空获取队头结点元素，并删除队头结点元素，更新front指针的指向为front=front.next

3.3 优先队列(PriorityQueue)

优先级队列也是一种特殊的数据结构，队列中的每个元素都有一个优先级，若每次出队的是具有最高优先级的元素，则称为降序优先级队列(总是先删除最大的元素)。若每次出队的是值最小的元素，则称为升序优先级队列(总是先删除最小的元素)，通常情况下我们所说的优先队列，一般是指降序优先级队列。
使用之前分析过的MyLikedList作为基底，实现一个排序的SortLinkedList继承自MyLinkedList，这里需要注意的是排序链表中的T类型必须是实现了Comparable接口的类型，在SortLinkedList中主要重写添加的add方法，插入逻辑是，通过比较元素的大小加入，而非简单下标或尾部插入。
接着以SortMyLinkedList为基底实现优先队列PriorityQueue

3.4 详细讲解

队列的详细讲解与实现

4. 集合(Set)

集合，是由一堆无序的、相关联的，且不重复的内存结构【数学中称为元素】组成的组合；
集合分类
有序集合：集合里的元素可以根据 key 或 index 访问 (List、Map)
无序集合：集合里的元素只能遍历。(Set)

4.1 Hash

Hash（哈希），又称"散列"
在某种程度上，散列是与排序相反的一种操作，排序是将集合中的元素按照某种方式比如字典顺序排列在一起，而散列通过计算哈希值，打破元素之间原有的关系，使集合中的元素按照散列函数的分类进行排列。

为什么要有 Hash
我们通常使用数组或者链表来存储元素，一旦存储的内容数量特别多，需要占用很大的空间，而且在查找某个元素是否存在的过程中，数组和链表都需要挨个循环比较，而通过哈希计算，可以大大减少比较次数。

哈希函数
哈希的过程中需要使用哈希函数进行计算。哈希函数是一种映射关系，根据数据的关键词 key ，通过一定的函数关系，计算出该元素存储位置的函数。

几种常见的哈希函数（散列函数）构造方法

直接定址法
H(key) = key 或 H(key) = a*key + b

除留余数法
H(key) = key % p, p < m

数字分析法

平方取中法

折叠法（叠加法）

随机数法

哈希冲突的解决
选用哈希函数计算哈希值时，可能不同的 key 会得到相同的结果，一个地址怎么存放多个数据呢？这就是冲突。

链接法（拉链法）
将所有关键字为同义词的结点链接在同一个单链表中。

若选定的散列表长度为 m,则可将散列表定义为一个由m个头指针组成的指针数组 T[0..m-1] 。
凡是散列地址为 i 的结点，均插入到以 T[i] 为头指针的单链表中。 T 中各分量的初值均应为空指针。T 中各分量的初值均应为空指针。

开放定址法

4.2 哈希表（散列表）

哈希表是实现关联数组（associative array）的一种数据结构，广泛应用于实现数据的快速查找。

用哈希函数计算关键字的哈希值（hash value）,通过哈希值这个索引就可以找到关键字的存储位置，即桶（bucket）。在哈希表上的插入、查找、删除等操作的时间复杂度是 O(1)。

查找过程中，关键字的比较次数，取决于产生冲突的多少，产生的冲突少，查找效率就高，产生的冲突多，查找效率就低。因此，影响产生冲突多少的因素，也就是影响查找效率的因素。

影响产生冲突多少有以下三个因素：

哈希函数是否均匀；

处理冲突的方法；

哈希表的加载因子。

哈希表的加载因子和容量决定了在什么时候桶数（存储位置）不够，需要重新哈希。加载因子太大的话桶太多，遍历时效率变低；太小的话频繁 rehash，导致性能降低。所以加载因子的大小需要结合时间和空间效率考虑。

例子：
桶不是在扩容时产生的，而是一个新元素在通过哈希计算后得到的一个新位置。哈希函数合适的情况下，当然是使用哈希函数进行计算的元素越多桶就越多喽，举个极端的例子：HashMap 默认容量的情况下，如果加载因子为 0.1 ，只能放一个 16 * 0.1 = 1 个元素，哈希计算后一定就只有一个桶。那如果加载因子是 0.75，16 * 0.75 = 12 个元素，哈希计算后的桶基本上比加载因子为 0.1 的多喽，你看是不是。 2. 桶多了单链表长度是短一些，但是这是不发生冲突的前提，如果哈希函数选择的不够合适，太多元素经过哈希计算可能会多次冲突，这样即使桶多了，也不能避免某个链表过长的情况。

4.3 哈希表，哈希函数详细讲解

哈希表，哈希函数详细讲解

一. 二叉树

2019-10-11T06:05:10.595000Z

一. 二叉树

一. 二叉树

1. 二叉树的基本概念

二叉树是每个结点最多有两个子树的树结构。通常子树被称作"左子树"（left subtree）和"右子树"（right subtree）。

一棵深度为k，且有2^k-1个节点的二叉树，称为满二叉树，这种树的特点是每一层上的节点数都是最大节点数。

1.1 二叉树基本形态

二叉树是递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态：

(1)空二叉树——如图(a)；
(2)只有一个根结点的二叉树——如图(b)；
(3)只有左子树——如图(c)；
(4)只有右子树——如图(d)；
(5)完全二叉树——如图(e)。

注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。
树和二叉树有两个主要差别：

树中结点的最大度数没有限制，而二叉树结点的最大度数为2；

树的结点无左、右之分，而二叉树的结点有左、右之分。

1.2 二叉树类型

(1)完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。

(2)满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。

(3)平衡二叉树——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

1.3 树的相关术语

结点的度：结点子树的个数
树的度：树中最大的结点度。
叶子结点：也叫终端结点，是度为 0 的结点；
分枝结点：度不为0的结点；

1.4 二叉树性质

(1) 在非空二叉树中，第i层的结点总数不超过 2^(i-1)

(2) 深度为h的二叉树最多有 2^h - 1 个结点,最少有h个结点

(3) 对于任意一棵二叉树，如果其叶子结点数为N0，而度数为2的结点总数为N2，则N0=N2+1；

(4)给定N个节点，能构成h(N)种不同的二叉树。
h(N)为卡特兰数的第N项。h(n)=C(2*n，n)/(n+1)

1.5 二叉树遍历

先序遍历
首先访问根，再先序遍历左（右）子树，最后先序遍历右（左）子树
中序遍历
首先中序遍历左（右）子树，再访问根，最后中序遍历右（左）子树
后序遍历
首先后序遍历左（右）子树，再后序遍历右（左）子树，最后访问根
层次遍历
即按照层次访问，通常用队列来做。访问根，访问子女，再访问子女的子女（越往后的层次越低）（两个子女的级别相同）

2. 完全二叉树

2.1 完全二叉树定义

若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。
完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。

(1)所有的叶结点都出现在第k层或k-l层（层次最大的两层）
(2)对任一结点，如果其右子树的最大层次为L，则其左子树的最大层次为L或L+l。

2.2 完全二叉树性质

假设n0是度为0的结点总数（即叶子结点数），n1是度为1的结点总数， n2是度为2的结点总数， n是结点总数则：

n0=n/2，其中n为奇数时（n1=0）向上取整；n为偶数时（n1=1）。可根据完全二叉树的结点总数计算出叶子结点数。

2.3 完全二叉树特点

完全二叉树的特点是：
(1）只允许最后一层有空缺结点且空缺在右边，即叶子结点只能在层次最大的两层上出现；
(2）对任一结点，如果其右子树的深度为j，则其左子树的深度必为j或j+1。即度为1的点只有1个或0个

2.4 完全二叉树存储

出于简便起见,完全二叉树通常采用数组而不是链表存储
其存储结构如下:
var tree:array[1..n]of longint;{n:integer;n>=1}
对于tree[i]，有如下特点：
（1）若i为奇数且i>1，那么tree的左兄弟为tree[i-1]；
（2）若i为偶数且i （3）若i>1，tree的父亲节点为tree[i/2]；
（4）若2* i<=n，那么tree的左孩子为tree[2* i];若2* i+1<=n,那么tree的右孩子为tree[2* i+1]；
（5）若i>n/2,那么tree[i]为叶子结点（对应于（3））；
（6）若i<(n-1)/2.那么tree[i]必有两个孩子（对应于（4））。
（7）满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。

2.5 完全二叉树判定

判断一棵树是否是完全二叉树的思路
1>如果树为空，则直接返回错
2>如果树不为空：层序遍历二叉树
　　 2.1>如果一个结点左右孩子都不为空，则pop该节点，将其左右孩子入队列；
　　 2.1>如果遇到一个结点，左孩子为空，右孩子不为空，则该树一定不是完全二叉树；
　　 2.2>如果遇到一个结点，左孩子不为空，右孩子为空；或者左右孩子都为空；则该节点之后的队列中的结点都为叶子节点；该树才是完全二叉树，否则就不是完全二叉树；

3. 满二叉树

3.1 满二叉树定义

对于国内的满二叉树
1. 一个层数为k 的满二叉树总结点数为：2^k - 1,因此满二叉的结点树一定是奇数个。
2. 第i层上的结点数为：2^i -1 ;
3. 一个层数为k的满二叉树的叶子结点个数（也就是最后一层）:2^(k-1) ;
对于国外的满二叉树
满二叉树的任意节点，要么度为0，要么度为2.换个说法即要么为叶子结点，要么同时具有左右孩子。

4. 堆

4.1 堆的概念

堆是具有以下性质的完全二叉树：

每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；
或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

在一个堆有序的二叉树中，父节点的位置是K/2,它的两个子节点的位置是2k,2k+1。

4.2 堆的实现


//最大堆
public class MaxPQ {
    private List arr;      //定义一个数组
    private  int N;                   //定义队列中的元素个数

    public MaxPQ() {
        arr = new ArrayList();
        arr.add(1);
        N = 0;
    }

    public boolean isEmpty() {                   //方法，返回队列是否为空
        return N == 0;                                              
    }

    public int size() {                                 //方法，返回队列中元素的个数
        return N;
    }

    public void inSert(int number) {       //添加方法，添加元素到结合末尾，并且使用上浮方法到指定的位置
        arr.add(number);
        swim(++N);
    }

    public int deleteMax() {                //删除方法，删除最大元素并把最小的元素放到第一个，然后使用下浮方法
        int max = arr.get(1);
        int min  = arr.get(N);
        arr.set(1, min);
        arr.remove(N--);
        sink(1);
        return max;
    }
    //上浮
    public void swim(int N) {
        while(N > 1 && (arr.get(N/2) < arr.get(N))){
            int max = arr.get(N);
            int min = arr.get(N/2);
            arr.set(N,min );
            arr.set(N/2, max);
            N = N/2;
        }
    }
    //下沉
    public void sink(int number) {
        while(number*2 <= N) {
            int index = number*2;
            if(index < N && (arr.get(index) < arr.get(index + 1))) {
                index++;
            }
            if(!(arr.get(number) < arr.get(index))) {
                break;
            }
            int max = arr.get(index);
            int min = arr.get(number);
            arr.set(number, max);
            arr.set(index, min);
            number = index;
        }

    }

    @Override
    public String toString() {
        return "MaxPQ [arr=" + arr + ", N=" + N + "]";
    }
}

5. 二叉查找树(排序树)(Binary Search Tree，BST)

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于它的根节点点的值；
（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
（4）没有键值相等的节点。

例子：

二叉查找树例题

二叉树查找树的详细解析

6. 平衡二叉树(AVL树)

6.1 平衡二叉树定义

对于一般的二叉搜索树（Binary Search Tree），其期望高度（即为一棵平衡树时）为logN，其各操作的时间复杂度（O(logN)）同时也由此而决定。但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。
为了解决这个问题，要加上一个称为平衡的附加结构条件即：任何结点的深度不得过深
（子树高度相差不超过1），就是平衡二叉树（Balanced Binary Tree），它是G.M. Adelson-Velsky 和 E.M. Landis在1962年在论文中发表的，因此又叫AVL树。
AVL树只是实现平衡二叉树的一种方法，它还有很多的其他实现方法如红黑树、替罪羊树、Treap、伸展树等

6.2 平衡二叉树性质

它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这个差值也称为平衡因子（其取值可以是1，0，-1，平衡因子是某个结点左右子树层数的差值)

6.3 平衡二叉树的设计

理解了平衡二叉树的概念后，我们在思考一下，那些操作可能引起平衡发生变化呢？
显然只有那些引起结点数量变化的操作才可能导致平衡被改变，也就是删除和插入操作了。
实际上也总是可以通过对树进行简单的修复来让其重新恢复到平衡，而这样的简单操作我们就称之为旋转，当然旋转也有单旋转和双旋转之分。
无论是插入还是删除，只有那些从插入点或者删除点到根结点的路径上的结点的平衡才有可能被改变，因为只有这些结点的子树才可能发生变化，所以最终也只需针对这些点进行平衡修复操作即可。

如何通过旋转来修复一棵失衡的二叉树，这里假设结点X是失衡点，它必须重新恢复平衡，由于任意结点的孩子结点最多有两个，而且导致失衡的必要条件是X结点的两棵子树高度差为2(大于1)，因此一般只有以下4种情况可能导致X点失去平衡：
① 在结点X的左孩子结点的左子树中插入元素
② 在结点X的左孩子结点的右子树中插入元素
③ 在结点X的右孩子结点的左子树中插入元素
④ 在结点X的右孩子结点的右子树中插入元素
以上4种情况，其中第①情况和第④情况是对称的，可以通过单旋转来解决，而第②种情况和第③情况是对称的，需要双旋转来解决。

6.3.1 左左单旋转(LL)情景①分析

在结点X的左孩子结点的左子树中插入元素

6.3.2 右右单旋转(RR)情景④分析

在结点X的右孩子结点的右子树中插入元素

6.3.3 左右双旋转(LR)情景②分析

在结点X的左孩子结点的右子树中插入元素

6.3.4 右左双旋转(RL)情景③分析

在结点X的右孩子结点的左子树中插入元素

平衡二叉树详细解析

二 . 红黑树

2019-06-09T13:26:35.553000Z

二 . 红黑树

二 . 红黑树

1. 红黑树简介

红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求:

节点是红色或黑色。
根节点是黑色。
每个叶子节点都是黑色的空节点（NIL节点）。
每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

2. 红黑树的修正

变色、左旋、右旋是红黑树在二叉树上的扩展操作，同时也是基于这三个操作才能遵守红黑树的五个特性。

2.1 左旋

    /*
     * 左旋做了三件事：

     * 1. 将y的左子节点赋给x的右子节点,并将x赋给y左子节点的父节点(y左子节点非空时)

     * 2. 将x的父节点p(非空时)赋给y的父节点，同时更新p的子节点为y(左或右)

     * 3. 将y的左子节点设为x，将x的父节点设为y

     */
    public void leftRotate(RBNode x) {
        if (x == null) return;
        //1. 将y的左子节点赋给x的右子节点,并将x赋给y左子节点的父节点(y左子节点非空时)
        RBNode y = x.right;
        x.right = y.left;
        if (y.left != null) {
            y.left.parent = x;
        }
        //2. 将x的父节点p(非空时)赋给y的父节点，同时更新p的子节点为y(左或右)
        y.parent = x.parent;
        if (x.parent == null) {
            this.mRoot = y;
        } else {
            if (x == x.parent.left) {
                x.parent.left = y;
            } else {
                x.parent.right = y;
            }
        }
        //3. 将y的左子节点设为x，将x的父节点设为y
        y.left = x;
        x.parent = y;
    }

2.2 右旋

/*      右旋做了三件事：
     * 1. 将x的右子节点赋给y的左子节点,并将y赋给x右子节点的父节点(x右子节点非空时)
     * 2. 将y的父节点p(非空时)赋给x的父节点，同时更新p的子节点为x(左或右)
     * 3. 将x的右子节点设为y，将y的父节点设为x
     */
   public void rightRotate(RBNode y) {
        if (y == null) return;
        //1. 将x的右子节点赋给y的左子节点,并将y赋给x右子节点的父节点(x右子节点非空时)
        RBNode x = y.left;
        y.left = x.right;
        if (x.right != null) {
            x.right.parent = y;
        }
        //2. 将y的父节点p(非空时)赋给x的父节点，同时更新p的子节点为x(左或右)
        x.parent = y.parent;
        if (y.parent == null) {
            this.mRoot = x;
        } else {
            if (y == y.parent.left) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        }
        //3. 将x的右子节点设为y，将y的父节点设为x
        x.right = y;
        y.parent = x;
    }

3. 红黑树节点的添加

红黑树的第 5 条特征规定，任一节点到它子树的每个叶子节点的路径中都包含同样数量的黑节点。也就是说当我们往红黑树中插入一个黑色节点时，会违背这条特征。
同时第 4 条特征规定红色节点的左右孩子一定都是黑色节点，当我们给一个红色节点下插入一个红色节点时，会违背这条特征。
因此我们需要在插入黑色节点后进行结构调整，保证红黑树始终满足这 5 条特征。

3.1 红黑树插入后节点的调整思想:

插入黑色节点的时候担心违背第5条，插入红色节点时担心违背第4条，所以我们将将插入的节点改为红色，然后判断插入的节点的父亲是不是红色，是的话进行修改调整（变色、左旋、右旋）。同时在调整的过程中我们需要遵守5条特性。

新插入的节点是红色的，插入修复操作如果遇到父节点的颜色为黑则修复操作结束。也就是说，只有在父节点为红色节点的时候是需要插入修复操作的。
插入修复操作分为以下的三种情况，而且新插入的节点的父节点都是红色的：

叔叔节点也为红色。
叔叔节点为空，且祖父节点、父节点和新节点处于一条斜线上。
叔叔节点为空，且祖父节点、父节点和新节点不处于一条斜线上。

3.1.1 插入操作-case 1(叔叔节点也为红色)

叔叔节点也为红色。
case 1的操作是将 父节点和叔叔节点 与 祖父节点 的颜色互换，这样就符合了RBTRee的定义。即维持了高度的平衡，修复后颜色也符合RBTree定义的第三条和第四条。下图中，操作完成后A节点变成了新的节点。如果A节点的父节点不是黑色的话，则继续做修复操作。

3.1.2 插入操作-case 2

叔叔节点为空，且祖父节点、父节点和新节点处于一条斜线上。
case 2的操作是：

B和C都是左节点，将B节点进行右旋操作，并且和父节点A互换颜色。通过该修复操作RBTRee的高度和颜色都符合红黑树的定义。
如果B和C节点都是右节点的话，只要将操作变成B节点左旋就可以了。

3.1.3 插入操作-case 3

叔叔节点为空，且祖父节点、父节点和新节点不处于一条斜线上。
case 3的操作是：

C是右节点，将C节点进行左旋，这样就从case 3转换成case 2了，然后针对case 2进行操作处理就行了。case2操作C节点做了一个右旋操作和颜色互换来达到目的。
如果C是左节点，将C节点进行右旋，转换成case2，再左旋就可以了。

4. 红黑树节点的删除

如果删除节点的左孩子和右孩子不同时为null，那么只需要让其子树继承删除该节点的位置
如果删除的节点是叶子节点，我们直接进行调整；
假如删除节点的左右孩子都不是null，需要后继节点替换被删除的节点和值和颜色，这样才不会引起红黑树平衡的破坏，只需要对后继节点删除后进行调整，这样我们就回归处理情况 1 和 2 的状态；
1. 后继节点为左子树最右边的子叶节点
2. 后继节点为右子树最左边的叶子节点；
3. 如果需要删除的节点颜色为红色，那么红黑树的结构不被破坏，也就不需要进行调整。如果我们判断删除节点的颜色为黑色，那么就进行调整；

4.1 红黑树删除之节点调整

调整思想：
为了保证删除节点的父节点左右两边黑色节点数一致，需要重点关注父节点没删除的那一边节点是不是黑色。

如果删除后父亲节点另一边比删除的一边黑色多，就要想办法搞到平衡。
- 1、把父亲节点另一边（即删除节点的兄弟树）其中一个节点弄成红色，也少了一个黑色。
- 2、或者把另一边多的节点（染成黑色）转过来一个

删除修复操作是针对删除黑色节点才有的，当黑色节点被删除后会让整个树不符合RBTree的定义的第四条。

当前节点是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）；
当前节点是黑色的，且兄弟节点是黑色的，
1）、兄弟节点的两个子节点均为黑色的；
2）、兄弟节点的左子节点是红色，右子节点时黑色的；
3）、兄弟节点的右子节点是红色，左子节点任意颜色；

4.1.1 删除操作-case 1

待删除的节点的兄弟节点是红色的节点。

将父节点涂红，将兄弟节点涂黑，然后将当前节点的父节点进行支点左旋。
case 1这样转换之后就会变成后面的case 2，case 3，或者case 4进行处理了。

4.1.2 删除操作-case 2

待删除的节点的兄弟节点是黑色的节点，且兄弟节点的子节点都是黑色的。

将兄弟节点涂红，将当前节点指向其父节点，将其父节点指向当前节点的祖父节点，继续往树根递归判断以及调整；

4.1.3 删除操作-case 3

待调整的节点的兄弟节点是黑色的节点，且和兄弟节点在一条斜线上的子节点也是黑色，另一个子节点是红色。

把当前节点的兄弟节点涂红，把兄弟节点的左子节点涂黑，然后以兄弟节点作为支点做右旋操作。

case 3的删除操作是一个中间步骤，它的目的是将左边的红色节点借调过来，这样就可以转换成case 4

4.1.4 删除操作-case 4

待调整的节点的兄弟节点是黑色的节点，且和兄弟节点在一条斜线上的子节点是红色，另一个子节点任意

把兄弟节点涂成父节点的颜色，再把父节点涂黑，把兄弟节点的右子节点涂黑，然后以当前节点的父节点为支点做左旋操作。

三 . B树、B+树、B*树

2019-06-09T13:26:36.498000Z

三 . B树、B+树、B*树

三 . B树、B+树、B*树

3.1 B树(B-树)

3.1.1 B树简介

B-树是一种多路搜索树（并不一定是二叉的）
1970年，R.Bayer和E.mccreight提出了一种适用于外查找的树，它是一种平衡的多叉树，称为B树（或B-树、B_树）。

B-Tree的接点结构B-tree中，每个结点包含：

本结点所含关键字的个数；
指向父结点的指针；
关键字；
指向子结点的指针数组；

一棵m阶B树(balanced tree of order m)是一棵平衡的m路搜索树。它或者是空树，或者是满足下列性质的树：
1、根结点至少有两个子女；
2、每个非根节点所包含的关键字个数 j 满足：m/2 - 1 <= j <= m - 1；
3、除根结点以外的所有结点（不包括叶子结点）的度数正好是关键字总数加1，故内部子树个数 k 满足：m/2 <= k <= m ；
4、所有的叶子结点都位于同一层。

3.1.2 B树特点

是一种多路搜索树（并不是二叉的）：

定义任意非叶子结点最多只有M个儿子；且M>2；
根结点的儿子数为[2, M]；
除根结点以外的非叶子结点的儿子数为[M/2, M]；
每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）
非叶子结点的关键字个数=指向儿子的指针个数-1；
非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；
非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树；
所有叶子结点位于同一层；

3.1.3 B树的查找

在B-树中查找给定关键字的方法类似于二叉排序树上的查找。不同的是在每个结点上确定向下查找的路径不一定是二路而是keynum+1路的。
对结点内的存放有序关键字序列的向量key[l..keynum] 用顺序查找或折半查找方法查找。

若在某结点内找到待查的关键字K，则返回该结点的地址及K在key[1..keynum]中的位置；
否则，确定K在某个key[i]和key[i+1]之间结点后，从磁盘中读son[i]所指的结点继续查找。直到在某结点中查找成功；或直至找到叶结点且叶结点中的查找仍不成功时，查找过程失败。

查找操作的时间开销

B-树上的查找有两个基本步骤：

在B-树中查找结点，该查找涉及读盘DiskRead操作，属外查找；
在结点内查找，该查找属内查找。

查找操作的时间为：

外查找的读盘次数不超过树高h，故其时间是O(h)；
内查找中，每个结点内的关键字数目keynum

注意：

实际上外查找时间可能远远大于内查找时间。
B-树作为数据库文件时，打开文件之后就必须将根结点读人内存，而直至文件关闭之前，此根一直驻留在内存中，故查找时可以不计读入根结点的时间。

3.1.4 B树的插入

插入一个元素时：

首先判断在B树中是否存在，如果不存在，即在叶子结点处结束，然后在叶子结点中插入该新的元素

注意：
1.1 如果叶子结点空间足够，这里需要向右移动该叶子结点中大于新插入关键字的元素，

1.2 如果叶子节点空间满了以致没有足够的空间去添加新的元素，则将该结点进行"分裂"，将一半数量的关键字元素分裂到新的其相邻右结点中，中间关键字元素上移到父结点中（当然，如果父结点空间满了，也同样需要"分裂"操作），而且当结点中关键元素向右移动了，相关的指针也需要向右移。
1.3 如果在根结点插入新元素，空间满了，则进行分裂操作，这样原来的根结点中的中间关键字元素向上移动到新的根结点中，因此导致树的高度增加一层。

3.1.5 B树的删除

首先查找B树中需删除的元素,如果该元素在B树中存在，则将该元素在其结点中进行删除，
如果删除该元素后，首先判断该元素是否有左右孩子结点，如果有，则上移孩子结点中的某相近元素到父节点中，然后是移动之后的情况；如果没有，直接删除后，移动之后的情况。

3.2 B+树

3.2.1 B+树简介

B+ 树是一种树数据结构，是一个n叉树，每个节点通常有多个孩子。
一棵B+树包含根节点、内部节点和叶子节点。根节点可能是一个叶子节点，也可能是一个包含两个或两个以上孩子节点的节点。

B+树用途

B+ 树通常用于数据库和操作系统的文件系统中。NTFS, ReiserFS, NSS, XFS, JFS, ReFS 和BFS等文件系统都在使用B+树作为元数据索引。B+ 树的特点是能够保持数据稳定有序，其插入与修改拥有较稳定的对数时间复杂度。B+ 树元素自底向上插入。

3.2.2 B+树定义

B+树是应文件系统所需而出的一种B-树的变型树。

一棵m阶的B+树和m阶的B-树的差异在于：
1.有n棵子树的结点中含有n个关键字，每个关键字不保存数据，只用来索引，所有数据都保存在叶子节点。
2.所有的叶子结点中包含了全部关键字的信息，及指向含这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大顺序链接。
3.所有的非终端结点可以看成是索引部分，结点中仅含其子树（根结点）中的最大（或最小）关键字。
通常在B+树上有两个头指针，一个指向根结点，一个指向关键字最小的叶子结点。

B+树与B-树的不同

B+树是B-树的变体，也是一种多路搜索树：

定义基本与B-树同，除了：
叶子结点的子树指针与关键字个数相同；
叶子结点的子树指针P[i]，指向关键字值属于[K[i], K[i+1])的子树（B-树是开区间）；
为所有叶子结点增加一个链指针；
所有关键字都在叶子结点出现；

3.2.3 B+树的特性：

所有关键字都出现在叶子结点的链表中（稠密索引），且链表中的关键字恰好是有序的；
不可能在非叶子结点命中；
非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层；
更适合文件索引系统；

3.2.4 B+树 vs B树

为什么说B+-tree比B 树更适合实际应用中操作系统的文件索引和数据库索引？

B+-tree的磁盘读写代价更低
B+-tree的内部结点并没有指向关键字具体信息的指针。因此其内部结点相对B 树更小。如果把所有同一内部结点的关键字存放在同一盘块中，那么盘块所能容纳的关键字数量也越多。一次性读入内存中的需要查找的关键字也就越多。相对来说IO读写次数也就降低了。
举个例子，假设磁盘中的一个盘块容纳16bytes，而一个关键字2bytes，一个关键字具体信息指针2bytes。一棵9阶B-tree(一个结点最多8个关键字)的内部结点需要2个盘快。而B+ 树内部结点只需要1个盘快。当需要把内部结点读入内存中的时候，B 树就比B+ 树多一次盘块查找时间(在磁盘中就是盘片旋转的时间)。
B+-tree的查询效率更加稳定
由于非终结点并不是最终指向文件内容的结点，而只是叶子结点中关键字的索引。所以任何关键字的查找必须走一条从根结点到叶子结点的路。所有关键字查询的路径长度相同，导致每一个数据的查询效率相当。

3.3 B*树

3.3.1 B*树简介

是B+树的变体，在B+树的非根和非叶子结点再增加指向兄弟的指针；
B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为2/3（代替B+树的1/2）；

3.3.2 B*树 vs B+树

B+树的分裂：
当一个结点满时，分配一个新的结点，并将原结点中1/2的数据复制到新结点，最后在父结点中增加新结点的指针；B+树的分裂只影响原结点和父结点，而不会影响兄弟结点，所以它不需要指向兄弟的指针；
B*树的分裂：
当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字（因为兄弟结点的关键字范围改变了）；如果兄弟也满了，则在原结点与兄弟结点之间增加新结点，并各复制1/3的数据到新结点，最后在父结点增加新结点的指针；

所以，B*树分配新结点的概率比B+树要低，空间使用率更高；

3.4 小结：

B-树：
多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键字范围的子结点；
所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中；

B+树：在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点中出现，非叶子结点作为叶子结点的索引；
B+树总是到叶子结点才命中；

B*树：在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率从1/2提高到2/3；

JDK 并发容器总结

2019-06-09T13:07:26.799000Z

JDK 并发容器总结

JDK 并发容器总结

1. JDK 提供的并发容器

JDK提供的这些容器大部分在 java.util.concurrent 包中。

ConcurrentHashMap：线程安全的HashMap
CopyOnWriteArrayList: 线程安全的List，在读多写少的场合性能非常好，远远好于Vector.
ConcurrentLinkedQueue:高效的并发队列，使用链表实现。可以看做一个线程安全的 LinkedList，这是一个非阻塞队列。
BlockingQueue: 这是一个接口，JDK内部通过链表、数组等方式实现了这个接口。表示阻塞队列，非常适合用于作为数据共享的通道。
ConcurrentSkipListMap: 跳表的实现。这是一个Map，使用跳表的数据结构进行快速查找。

2. ConcurrentHashMap

在ConcurrentHashMap中，无论是读操作还是写操作都能保证很高的性能：在进行读操作时(几乎)不需要加锁，而在写操作时通过锁分段技术只对所操作的段加锁而不影响客户端对其它段的访问。
在Map集合中已经详细叙述

3. CopyOnWriteArrayList

3.1 CopyOnWriteArrayList 简介

在很多应用场景中，读操作可能会远远大于写操作。由于读操作根本不会修改原有的数据，因此对于每次读取都进行加锁其实是一种资源浪费。我们应该允许多个线程同时访问List的内部数据，毕竟读取操作是安全的。

这和我们之前在多线程章节讲过 ReentrantReadWriteLock 读写锁的思想非常类似，也就是读读共享、写写互斥、读写互斥、写读互斥。JDK中提供了 CopyOnWriteArravList 类比相比于在读写锁的思想又更进一步。为了将读取的性能发挥到极致，CopyOnWriteArravList 读取是完全不用加锁的，并且更厉害的是：写入也不会阻塞读取操作。只有写入和写入之间需要进行同步等待。这样一来，读操作的性能就会大幅度提升。那它是怎么做的呢？

3.2 CopyOnWriteArrayList 是如何做到的？

CopyOnWriteArravList 类的所有可变操作（add，set等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。写完之后，再将修改完的副本替换原来的数据，这样就可以保证写操作不会影响读操作了。

从 CopyOnWriteArrayList 的名字就能看出CopyOnWriteArravList 是满足CopyOnWrite 的ArrayList，所谓CopyOnWrite 也就是说：在计算机，如果你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉了。

3.3 CopyOnWriteArravList 读取和写入源码简单分析

3.3.1 CopyOnWriteArravList 读取操作的实现

读取操作没有任何同步控制和锁操作，理由就是内部数组 array 不会发生修改，只会被另外一个 array 替换，因此可以保证数据安全。

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;
    public E get(int index) {
        return get(getArray(), index);
    }
    @SuppressWarnings("unchecked")
    private E get(Object[] a, int index) {
        return (E) a[index];
    }
    final Object[] getArray() {
        return array;
    }

3.3.2 CopyOnWriteArravList 写入操作的实现

CopyOnWriteArravList 写入操作 add() 方法在添加集合的时候加了锁，保证了同步，避免了多线程写的时候会 copy 出多个副本出来。

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();//加锁
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);//拷贝新数组
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();//释放锁
        }
    }

4. ConcurrentLinkedQueue

Java提供的线程安全的 Queue 可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是 BlockingQueue，非阻塞队列的典型例子是ConcurrentLinkedQueue，在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。
阻塞队列可以通过加锁来实现，非阻塞队列可以通过 CAS 操作实现。

从名字可以看出，ConcurrentLinkedQueue这个队列使用链表作为其数据结构．ConcurrentLinkedQueue 应该算是在高并发环境中性能最好的队列了。它之所有能有很好的性能，是因为其内部复杂的实现。

ConcurrentLinkedQueue 内部代码我们就不分析了，大家知道ConcurrentLinkedQueue 主要使用 CAS 非阻塞算法来实现线程安全就好了。

ConcurrentLinkedQueue 适合在对性能要求相对较高，同时对队列的读写存在多个线程同时进行的场景，即如果对队列加锁的成本较高则适合使用无锁的ConcurrentLinkedQueue来替代。

5. BlockingQueue

5.1 BlockingQueue 简单介绍

阻塞队列（BlockingQueue）被广泛使用在"生产者-消费者"问题中，其原因是BlockingQueue提供了可阻塞的插入和移除的方法。当队列容器已满，生产者线程会被阻塞，直到队列未满；当队列容器为空时，消费者线程会被阻塞，直至队列非空时为止。

BlockingQueue 是一个接口，继承自 Queue，所以其实现类也可以作为 Queue 的实现来使用，而 Queue 又继承自 Collection 接口。

主要介绍一下:ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue，这三个 BlockingQueue 的实现类。

5.2 ArrayBlockingQueue

ArrayBlockingQueue 是 BlockingQueue 接口的有界队列实现类，底层采用数组来实现。ArrayBlockingQueue一旦创建，容量不能改变。其并发控制采用可重入锁来控制，不管是插入操作还是读取操作，都需要获取到锁才能进行操作。当队列容量满时，尝试将元素放入队列将导致操作阻塞;尝试从一个空队列中取一个元素也会同样阻塞。

ArrayBlockingQueue 默认情况下不能保证线程访问队列的公平性，所谓公平性是指严格按照线程等待的绝对时间顺序，即最先等待的线程能够最先访问到 ArrayBlockingQueue。而非公平性则是指访问 ArrayBlockingQueue 的顺序不是遵守严格的时间顺序，有可能存在，当 ArrayBlockingQueue 可以被访问时，长时间阻塞的线程依然无法访问到 ArrayBlockingQueue。如果保证公平性，通常会降低吞吐量。

可以通过构造函数来实现公平性。

5.3 LinkedBlockingQueue

LinkedBlockingQueue 底层基于单向链表实现的阻塞队列，可以当做无界队列也可以当做有界队列来使用，同样满足FIFO的特性，与ArrayBlockingQueue 相比起来具有更高的吞吐量，为了防止 LinkedBlockingQueue 容量迅速增，损耗大量内存。通常在创建LinkedBlockingQueue 对象时，会指定其大小，如果未指定，容量等于Integer.MAX_VALUE。

    /**
     *某种意义上的无界队列
     * Creates a {@code LinkedBlockingQueue} with a capacity of
     * {@link Integer#MAX_VALUE}.
     */
    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

    /**
     *有界队列
     * Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity.
     *
     * @param capacity the capacity of this queue
     * @throws IllegalArgumentException if {@code capacity} is not greater
     *         than zero
     */
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node(null);
    }

5.4 PriorityBlockingQueue

PriorityBlockingQueue 是一个支持优先级的无界阻塞队列。默认情况下元素采用自然顺序进行排序，也可以通过自定义类实现 compareTo() 方法来指定元素排序规则，或者初始化时通过构造器参数 Comparator 来指定排序规则。

PriorityBlockingQueue 并发控制采用的是 ReentrantLock，队列为无界队列（ArrayBlockingQueue 是有界队列，LinkedBlockingQueue 也可以通过在构造函数中传入 capacity 指定队列最大的容量，但是 PriorityBlockingQueue 只能指定初始的队列大小，后面插入元素的时候，如果空间不够的话会自动扩容）。

简单地说，它就是 PriorityQueue 的线程安全版本。不可以插入 null 值，同时，插入队列的对象必须是可比较大小的（comparable），否则报 ClassCastException 异常。它的插入操作 put 方法不会 block，因为它是无界队列（take 方法在队列为空的时候会阻塞）。

6. ConcurrentSkipListMap

为了引出ConcurrentSkipListMap，先带着大家简单理解一下跳表。

对于一个单链表，即使链表是有序的，如果我们想要在其中查找某个数据，也只能从头到尾遍历链表，这样效率自然就会很低，跳表就不一样了。跳表是一种可以用来快速查找的数据结构，有点类似于平衡树。它们都可以对元素进行快速的查找。但一个重要的区别是：对平衡树的插入和删除往往很可能导致平衡树进行一次全局的调整。而对跳表的插入和删除只需要对整个数据结构的局部进行操作即可。这样带来的好处是：在高并发的情况下，你会需要一个全局锁来保证整个平衡树的线程安全。而对于跳表，你只需要部分锁即可。这样，在高并发环境下，你就可以拥有更好的性能。而就查询的性能而言，跳表的时间复杂度也是 O(logn) 所以在并发数据结构中，JDK 使用跳表来实现一个 Map。

跳表的本质是同时维护了多个链表，并且链表是分层的，

最低层的链表维护了跳表内所有的元素，每上面一层链表都是下面一层的子集。跳表内的所有链表的元素都是排序的。查找时，可以从顶级链表开始找。一旦发现被查找的元素大于当前链表中的取值，就会转入下一层链表继续找。这也就是说在查找过程中，搜索是跳跃式的。

在跳表中查找元素18。查找18 的时候原来需要遍历 18 次，现在只需要 7 次即可。针对链表长度比较大的时候，构建索引查找效率的提升就会非常明显。

跳表是一种利用空间换时间的算法

使用跳表实现Map 和使用哈希算法实现Map的另外一个不同之处是：哈希并不会保存元素的顺序，而跳表内所有的元素都是排序的。因此在对跳表进行遍历时，你会得到一个有序的结果。所以，如果你的应用需要有序性，那么跳表就是你不二的选择。JDK 中实现这一数据结构的类是ConcurrentSkipListMap。

八. AQS 原理以及 AQS 同步组件总结

2019-06-09T13:07:31.108000Z

八. AQS 原理以及 AQS 同步组件总结

八. AQS 原理以及 AQS 同步组件总结

1. AQS 简单介绍

AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。
AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。

2. AQS 原理

2.1 AQS 原理概览

AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node）来实现锁的分配。

AQS(AbstractQueuedSynchronizer)原理图

AQS使用一个int成员变量state来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。

private volatile int state;//共享变量，使用volatile修饰保证线程可见性

状态信息通过procted类型的getState，setState，compareAndSetState进行操作

//返回同步状态的当前值
protected final int getState() {  
        return state;
}
 // 设置同步状态的值
protected final void setState(int newState) { 
        state = newState;
}
//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

2.2 AQS 对资源的共享方式

AQS定义两种资源共享方式

Exclusive（独占）：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁：
- 公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
- 非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的
Share（共享）：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。

ReentrantReadWriteLock 可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某一资源进行读。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在上层已经帮我们实现好了。

2.3 AQS底层使用了模板方法模式

同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：

使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放）
将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。

模板方法模式，模板方法模式是一个很容易理解的设计模式之一

模板方法模式是基于"继承"的，主要是为了在不改变模板结构的前提下在子类中重新定义模板中的内容以实现复用代码。
举个很简单的例子假如我们要去一个地方的步骤是：购票buyTicket()->安检securityCheck()->乘坐某某工具回家ride()->到达目的地arrive()。我们可能乘坐不同的交通工具回家比如飞机或者火车，所以除了ride()方法，其他方法的实现几乎相同。
我们可以定义一个包含了这些方法的抽象类，然后用户根据自己的需要继承该抽象类然后修改 ride()方法。

AQS使用了模板方法模式，自定义同步器时需要重写下面几个AQS提供的模板方法：

isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。

tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。

tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。

tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。

tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。

默认情况下，每个方法都抛出 UnsupportedOperationException。这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。

以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。

再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS(Compare and Swap)减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。

AQS源码解析

3. Semaphore(信号量)-允许多个线程同时访问

synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。

/**
 * 
 * @author Snailclimb
 * @date 2018年9月30日
 * @Description: 需要一次性拿一个许可的情况
 */
public class SemaphoreExample1 {
	// 请求的数量
	private static final int threadCount = 550;

	public static void main(String[] args) throws InterruptedException {
		// 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
		ExecutorService threadPool = Executors.newFixedThreadPool(300);
		// 一次只能允许执行的线程数量。
		final Semaphore semaphore = new Semaphore(20);

		for (int i = 0; i < threadCount; i++) {
			final int threadnum = i;
			threadPool.execute(() -> {// Lambda 表达式的运用
				try {
					semaphore.acquire();// 获取一个许可，所以可运行线程数量为20/1=20
					test(threadnum);
					semaphore.release();// 释放一个许可
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			});
		}
		threadPool.shutdown();
		System.out.println("finish");
	}

	public static void test(int threadnum) throws InterruptedException {
		Thread.sleep(1000);// 模拟请求的耗时操作
		System.out.println("threadnum:" + threadnum);
		Thread.sleep(1000);// 模拟请求的耗时操作
	}
}

执行 acquire 方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个 release 方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。 Semaphore经常用于限制获取某种资源的线程数量。

除了 acquire方法之外，另一个比较常用的与之对应的方法是tryAcquire方法，该方法如果获取不到许可就立即返回false。

Semaphore 有两种模式，公平模式和非公平模式。

公平模式：调用acquire的顺序就是获取许可证的顺序，遵循FIFO；
非公平模式：抢占式的。（默认）
构造函数可以指定模式。

4. CountDownLatch （倒计时器）

CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

4.1 CountDownLatch 的两种典型用法

某一线程在开始运行前等待n个线程执行完毕。将 CountDownLatch 的计数器初始化为n ：new CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await()的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。
实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 CountDownLatch 对象，将其计数器初始化为 1 ：new CountDownLatch(1)，多个线程在开始执行任务前首先 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。

4.2 CountDownLatch 的使用示例

/**
 * 
 * @author SnailClimb
 * @date 2018年10月1日
 * @Description: CountDownLatch 使用方法示例
 */
public class CountDownLatchExample1 {
	// 请求的数量
	private static final int threadCount = 550;

	public static void main(String[] args) throws InterruptedException {
		// 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
		ExecutorService threadPool = Executors.newFixedThreadPool(300);
		final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
		for (int i = 0; i < threadCount; i++) {
			final int threadnum = i;
			threadPool.execute(() -> {// Lambda 表达式的运用
				try {
					test(threadnum);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} finally {
					countDownLatch.countDown();// 表示一个请求已经被完成
				}

			});
		}
		countDownLatch.await();
		threadPool.shutdown();
		System.out.println("finish");
	}

	public static void test(int threadnum) throws InterruptedException {
		Thread.sleep(1000);// 模拟请求的耗时操作
		System.out.println("threadnum:" + threadnum);
		Thread.sleep(1000);// 模拟请求的耗时操作
	}
}

4.3 CountDownLatch 的不足

CountDownLatch是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

5. CyclicBarrier(循环栅栏)

CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。

CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。

5.1 CyclicBarrier 的应用场景

CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的应用场景。比如我们用一个Excel保存了用户所有银行流水，每个Sheet保存一个帐户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水。

5.2 CyclicBarrier 的使用示例

/**
 * 
 * @author Snailclimb
 * @date 2018年10月1日
 * @Description: 测试 CyclicBarrier 类中带参数的 await() 方法
 */
public class CyclicBarrierExample2 {
	// 请求的数量
	private static final int threadCount = 550;
	// 需要同步的线程数量
	private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

	public static void main(String[] args) throws InterruptedException {
		// 创建线程池
		ExecutorService threadPool = Executors.newFixedThreadPool(10);

		for (int i = 0; i < threadCount; i++) {
			final int threadNum = i;
			Thread.sleep(1000);
			threadPool.execute(() -> {
				try {
					test(threadNum);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			});
		}
		threadPool.shutdown();
	}

	public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
		System.out.println("threadnum:" + threadnum + "is ready");
		try {
			cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
		} catch (Exception e) {
			System.out.println("-----CyclicBarrierException------");
		}
		System.out.println("threadnum:" + threadnum + "is finish");
	}

}

5.3 CyclicBarrier和CountDownLatch的区别

对于CountDownLatch来说，重点是"一个线程（多个线程）等待"，而其他的N个线程在完成"某件事情"之后，可以终止，也可以等待。
而对于CyclicBarrier，重点是多个线程，在任意一个线程没有完成，所有的线程都必须等待。

CountDownLatch是计数器，线程完成一个记录一个，只不过计数不是递增而是递减，
而CyclicBarrier更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。

七. JUC 中的 Atomic 原子类总结

2019-06-09T13:07:37.105000Z

七. JUC 中的 Atomic 原子类总结

七. JUC 中的 Atomic 原子类总结

1. Atomic 原子类介绍

Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

所以，所谓原子类说简单点就是具有原子/原子操作特征的类。

并发包 java.util.concurrent 的原子类都存放在 java.util.concurrent.atomic 下

1.1 原子类类型

根据操作的数据类型，可以将JUC包中的原子类分为4类

基本类型

使用原子的方式更新基本类型

AtomicInteger：整形原子类

AtomicLong：长整型原子类

AtomicBoolean ：布尔型原子类

数组类型

使用原子的方式更新数组里的某个元素

AtomicIntegerArray：整形数组原子类

AtomicLongArray：长整形数组原子类

AtomicReferenceArray ：引用类型数组原子类

引用类型

AtomicReference：引用类型原子类

AtomicStampedRerence：原子更新引用类型里的字段原子类

AtomicMarkableReference ：原子更新带有标记位的引用类型

对象的属性修改类型

AtomicIntegerFieldUpdater:原子更新整形字段的更新器

AtomicLongFieldUpdater：原子更新长整形字段的更新器

AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

2. 基本类型原子类

2.1 基本类型原子类介绍

使用原子的方式更新基本类型

AtomicInteger：整形原子类
AtomicLong：长整型原子类
AtomicBoolean ：布尔型原子类

上面三个类提供的方法几乎相同，所以我们这里以 AtomicInteger 为例子来介绍。

AtomicInteger 类常用方法

public final int get() //获取当前的值

public final int getAndSet(int newValue)//获取当前的值，并设置新的值

public final int getAndIncrement()//获取当前的值，并自增

public final int getAndDecrement() //获取当前的值，并自减

public final int getAndAdd(int delta) //获取当前的值，并加上预期的值

boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）

public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

2.2 AtomicInteger 常见方法使用

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int temvalue = 0;
		AtomicInteger i = new AtomicInteger(0);
		temvalue = i.getAndSet(3);
		System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:0;  i:3
		temvalue = i.getAndIncrement();
		System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:3;  i:4
		temvalue = i.getAndAdd(5);
		System.out.println("temvalue:" + temvalue + ";  i:" + i);//temvalue:4;  i:9
	}

}

2.3 基本数据类型原子类的优势

多线程环境不使用原子类保证线程安全（基本数据类型）

class Test {
        private volatile int count = 0;
        //若要线程安全执行执行count++，需要加锁
        public synchronized void increment() {
                  count++; 
        }

        public int getCount() {
                  return count;
        }
}

多线程环境使用原子类保证线程安全（基本数据类型）

class Test2 {
        private AtomicInteger count = new AtomicInteger();

        public void increment() {
                  count.incrementAndGet();
        }
      //使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
       public int getCount() {
                return count.get();
        }
}

2.4 AtomicInteger 线程安全原理简单分析

AtomicInteger 类的部分源码：

    // setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供"比较并替换"的作用）
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到"原来的值"的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。

3. 数组类型原子类

3.1 数组类型原子类介绍

使用原子的方式更新数组里的某个元素

AtomicIntegerArray：整形数组原子类
AtomicLongArray：长整形数组原子类
AtomicReferenceArray ：引用类型数组原子类

上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍。

AtomicIntegerArray 类常用方法

public final int get(int i) //获取 index=i 位置元素的值

public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue

public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增

public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减

public final int getAndAdd(int delta) //获取 index=i 位置元素的值，并加上预期的值

boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）

public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

3.2 AtomicIntegerArray 常见方法使用


import java.util.concurrent.atomic.AtomicIntegerArray;

public class AtomicIntegerArrayTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int temvalue = 0;
		int[] nums = { 1, 2, 3, 4, 5, 6 };
		AtomicIntegerArray i = new AtomicIntegerArray(nums);
		for (int j = 0; j < nums.length; j++) {
			System.out.println(i.get(j));
		}
		temvalue = i.getAndSet(0, 2);
		System.out.println("temvalue:" + temvalue + ";  i:" + i);
		temvalue = i.getAndIncrement(0);
		System.out.println("temvalue:" + temvalue + ";  i:" + i);
		temvalue = i.getAndAdd(0, 5);
		System.out.println("temvalue:" + temvalue + ";  i:" + i);
	}

}

4. 引用类型原子类

4.1 引用类型原子类介绍

基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用引用类型原子类。

AtomicReference：引用类型原子类
AtomicStampedRerence：原子更新引用类型里的字段原子类
AtomicMarkableReference ：原子更新带有标记位的引用类型

上面三个类提供的方法几乎相同，所以我们这里以 AtomicReference 为例子来介绍。

4.2 AtomicReference 类使用示例

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceTest {

	public static void main(String[] args) {
		AtomicReference ar = new AtomicReference();
		Person person = new Person("SnailClimb", 22);
		ar.set(person);
		Person updatePerson = new Person("Daisy", 20);
		ar.compareAndSet(person, updatePerson);

		System.out.println(ar.get().getName());
		System.out.println(ar.get().getAge());
	}
}

class Person {
	private String name;
	private int age;

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}

首先创建了一个 Person 对象，然后把 Person 对象设置进 AtomicReference 对象中，然后调用 compareAndSet 方法，该方法就是通过通过 CAS 操作设置 ar。如果 ar 的值为 person 的话，则将其设置为 updatePerson。实现原理与 AtomicInteger 类中的 compareAndSet 方法相同。

5. 对象的属性修改类型原子类

5.1 对象的属性修改类型原子类介绍

如果需要原子更新某个类里的某个字段时，需要用到对象的属性修改类型原子类。

AtomicIntegerFieldUpdater:原子更新整形字段的更新器
AtomicLongFieldUpdater：原子更新长整形字段的更新器
AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

要想原子地更新对象的属性需要两步。第一步，因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法 newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第二步，更新的对象属性必须使用 public volatile 修饰符。

上面三个类提供的方法几乎相同，所以我们这里以AtomicIntegerFieldUpdater 为例子来介绍。

5.2 AtomicIntegerFieldUpdater 类使用示例

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class AtomicIntegerFieldUpdaterTest {
	public static void main(String[] args) {
		AtomicIntegerFieldUpdater a = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");

		User user = new User("Java", 22);
		System.out.println(a.getAndIncrement(user));// 22
		System.out.println(a.get(user));// 23
	}
}

class User {
	private String name;
	public volatile int age;

	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}

Synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及和ReenTrantLock 的对比

2019-06-09T13:07:41.490000Z

Synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及和ReenTrantLock 的对比

Synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及和ReenTrantLock 的对比

1. synchronized关键字最主要的三种使用方式的总结

修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份，所以对该类的所有对象都加了锁）。所以如果一个线程A调用一个实例对象的非静态 synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁。和 synchronized 方法一样，synchronized(this)代码块也是锁定当前对象的。synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。
这里再提一下：synchronized关键字加到非 static 静态方法上是给对象实例上锁。另外需要注意的是：尽量不要使用 synchronized(String a) 因为JVM中，字符串常量池具有缓冲功能！

面试中面试官经常会说："单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！"

1.1 双重校验锁实现对象单例（线程安全）

public class Singleton {

    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
       //先判断对象是否已经实例过，没有实例化过才进入加锁代码
        if (uniqueInstance == null) {
            //类对象加锁
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

需要注意 uniqueInstance 采用 static 关键字修饰也是很有必要。
uniqueInstance 采用 volatile 关键字修饰也是很有必要的，
uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：

为 uniqueInstance 分配内存空间

初始化 uniqueInstance

将 uniqueInstance 指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出先问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

2. synchronized 关键字底层原理总结

synchronized 关键字底层原理属于 JVM 层面。

2.1 synchronized 同步语句块的情况

public class SynchronizedDemo {
    public void method() { 
    synchronized (this) { 
        System.out.println("synchronized 代码块"); 
         }
    } 
}

通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 javac SynchronizedDemo.java 命令生成编译后的 .class 文件，然后执行javap -c -s -v -l SynchronizedDemo.class

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。
当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

2.2 synchronized 修饰方法的的情况


public class SynchronizedDemo2 { 
    public synchronized void method() { 
        System.out.println("synchronized 方法"); 
        } 
    }

synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

3. JDK1.6 之后的底层优化

3.1 JDK1.6之前

在 Java 早期版本中，synchronized 属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。
如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。
庆幸的是在 Java 6 之后 Java 官方对从 JVM 层面对synchronized 较大优化，所以现在的 synchronized 锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

3.2 JDK1.6 之后

JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。

锁的状态

锁主要存在四中状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

1. 偏向锁

引入偏向锁的目的和引入轻量级锁的目的很像，他们都是为了没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。
但是不同是：
轻量级锁在无竞争的情况下使用 CAS 操作去代替使用互斥量。
而偏向锁在无竞争的情况下会把整个同步都消除掉。
偏向锁的"偏"就是偏心的偏，它的意思是会偏向于第一个获得它的线程，如果在接下来的执行中，该锁没有被其他线程获取，那么持有偏向锁的线程就不需要进行同步！
关于偏向锁的原理可以查看《深入理解Java虚拟机：JVM高级特性与最佳实践》第二版的13章第三节锁优化。
但是对于锁竞争比较激烈的场合，偏向锁就失效了，因为这样场合极有可能每次申请锁的线程都是不相同的，因此这种场合下不应该使用偏向锁，否则会得不偿失，需要注意的是，偏向锁失败后，并不会立即膨胀为重量级锁，而是先升级为轻量级锁。

2. 轻量级锁

倘若偏向锁失败，虚拟机并不会立即升级为重量级锁，它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的)。轻量级锁不是为了代替重量级锁，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗，因为使用轻量级锁时，不需要申请互斥量。另外，轻量级锁的加锁和解锁都用到了CAS操作。
关于轻量级锁的加锁和解锁的原理可以查看《深入理解Java虚拟机：JVM高级特性与最佳实践》第二版的13章第三节锁优化。
轻量级锁能够提升程序同步性能的依据是"对于绝大部分锁，在整个同步周期内都是不存在竞争的"，这是一个经验数据。如果没有竞争，轻量级锁使用 CAS 操作避免了使用互斥操作的开销。但如果存在锁竞争，除了互斥量开销外，还会额外发生CAS操作，因此在有锁竞争的情况下，轻量级锁比传统的重量级锁更慢！如果锁竞争激烈，那么轻量级将很快膨胀为重量级锁！

3. 自旋锁和自适应自旋

轻量级锁失败后，虚拟机为了避免线程真实地在操作系统层面挂起，还会进行一项称为自旋锁的优化手段。
互斥同步对性能最大的影响就是阻塞的实现，因为挂起线程/恢复线程的操作都需要转入内核态中完成（用户态转换到内核态会耗费时间）。
一般线程持有锁的时间都不是太长，所以仅仅为了这一点时间去挂起线程/恢复线程是得不偿失的。所以，虚拟机的开发团队就这样去考虑："我们能不能让后面来的请求获取锁的线程等待一会而不被挂起呢？看看持有锁的线程是否很快就会释放锁"。为了让一个线程等待，我们只需要让线程执行一个忙循环（自旋），这项技术就叫做自旋。

何谓自旋锁？它是为实现保护共享资源而提出一种锁机制。其实，自旋锁与互斥锁比较类似，它们都是为了解决对某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，"自旋"一词就是因此而得名。

自旋锁在 JDK1.6 之前其实就已经引入了，不过是默认关闭的，需要通过--XX:+UseSpinning参数来开启。JDK1.6及1.6之后，就改为默认开启的了。
需要注意的是：自旋等待不能完全替代阻塞，因为它还是要占用处理器时间。如果锁被占用的时间短，那么效果当然就很好了！反之，相反！自旋等待的时间必须要有限度。如果自旋超过了限定次数任然没有获得锁，就应该挂起线程。自旋次数的默认值是10次，用户可以修改--XX:PreBlockSpin来更改。
另外,在 JDK1.6 中引入了自适应的自旋锁。自适应的自旋锁带来的改进就是：自旋的时间不在固定了，而是和前一次同一个锁上的自旋时间以及锁的拥有者的状态来决定，虚拟机变得越来越"聪明"了。

4. 锁消除

锁消除理解起来很简单，它指的就是虚拟机即使编译器在运行时，如果检测到那些共享数据不可能存在竞争，那么就执行锁消除。锁消除可以节省毫无意义的请求锁的时间。

5. 锁粗化

原则上，我们编写代码的时候，总是推荐将同步快的作用范围限制得尽量小——只在共享数据的实际作用域才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁竞争，那等待线程也能尽快拿到锁。

大部分情况下，上面的原则都是没有问题的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，那么会带来很多不必要的性能消耗。

4. Synchronized 和 ReenTrantLock 的对比

4.1 两者都是可重入锁

两者都是可重入锁。"可重入锁"概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

4.2 synchronized 依赖于 JVM 而 ReenTrantLock 依赖于 API

synchronized 是依赖于 JVM 实现的，前面我们也讲到了虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReenTrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。

4.3 ReenTrantLock 比 synchronized 增加了一些高级功能

相比synchronized，ReenTrantLock增加了一些高级功能。主要来说主要有三点：①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）

等待可中断

ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。

可实现公平锁

ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。 ReenTrantLock默认情况是非公平的，可以通过 ReenTrantLock类的ReentrantLock(boolean fair)构造方法来制定是否是公平的。

可实现选择性通知

synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。
Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。在使用notify/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现"选择性通知" ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法只会唤醒注册在该Condition实例中的所有等待线程。

4.4 性能已不是选择标准

在JDK1.6之前，synchronized 的性能是比 ReenTrantLock 差很多。具体表示为：synchronized 关键字吞吐量随线程数的增加，下降得非常严重。而ReenTrantLock 基本保持一个比较稳定的水平。我觉得这也侧面反映了， synchronized 关键字还有非常大的优化余地。后续的技术发展也证明了这一点，我们上面也讲了在 JDK1.6 之后 JVM 团队对 synchronized 关键字做了很多优化。
JDK1.6 之后，synchronized 和 ReenTrantLock 的性能基本是持平了。所以网上那些说因为性能才选择 ReenTrantLock 的文章都是错的！JDK1.6之后，性能已经不是选择synchronized和ReenTrantLock的影响因素了！而且虚拟机在未来的性能改进中会更偏向于原生的synchronized，所以还是提倡在synchronized能满足你的需求的情况下，优先考虑使用synchronized关键字来进行同步！优化后的synchronized和ReenTrantLock一样，在很多地方都是用到了CAS操作。

一. 线程入门

2019-06-09T13:07:38.587000Z

一. 线程入门

一. 线程入门

1. 进程和多线程简介

1.1 何为进程？

进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。

一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。

进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序

1.2 何为线程？

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。

与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

线程是在同一程序内几乎同时执行一个以上的程序段。

1.3 线程和进程的关系

基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。
从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

线程上下文的切换比进程上下文切换要快很多

进程切换时，涉及到当前进程的CPU环境的保存和新被调度运行进程的CPU环境的设置。

线程切换仅需要保存和设置少量的寄存器内容，不涉及存储管理方面的操作。

1.4 线程有哪些基本状态？这些状态是如何定义的?

新建(new)：新创建了一个线程对象。
可运行(runnable)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu的使用权。
运行(running)：可运行状态(runnable)的线程获得了cpu时间片（timeslice），执行程序代码。
阻塞(block)：阻塞状态是指线程因为某种原因放弃了cpu使用权，也即让出了cpu timeslice（时间片），暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice转到运行(running)状态。阻塞的情况分三种：

(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waiting queue)中。

(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

(三). 其他阻塞: 运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

死亡(dead)：线程run()、main()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

1.5 线程的优先级

每个线程都具有各自的优先级，线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。

线程优先级具有继承特性比如A线程启动B线程，则B线程的优先级和A是一样的。
线程优先级具有随机性也就是说线程优先级高的不一定每一次都先执行完。

Thread类中包含的成员变量代表了线程的某些优先级。

如Thread.MIN_PRIORITY（常数1），Thread.NORM_PRIORITY（常数5）,
Thread.MAX_PRIORITY（常数10）。
其中每个线程的优先级都在Thread.MIN_PRIORITY（常数1）到Thread.MAX_PRIORITY（常数10）之间。
在默认情况下优先级都是Thread.NORM_PRIORITY（常数5）。

1.6 何为多线程？

多线程就是多个线程同时运行或交替运行。单核CPU的话是顺序执行，也就是交替运行。多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行。

1.7 为什么多线程是必要的？

开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能

1.8 为什么提倡多线程而不是多进程？

线程就是轻量级进程，是程序执行的最小单位。使用多线程而不是用多进程去进行并发程序的设计，是因为线程间的切换和调度的成本远远小于进程。

2. 几个重要的概念

2.1 同步和异步

同步和异步通常用来形容一次方法调用。

同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。
异步方法调用更像一个消息传递，一旦开始，方法调用就会立即返回，调用者可以继续后续的操作。

2.2 并发(Concurrency)和并行(Parallelism)

它们都可以表示两个或者多个任务一起执行，但是偏重点有些不同。
并发偏重于多个任务交替执行，而多个任务之间有可能还是串行的。
而并行是真正意义上的"同时执行"。

多线程在单核CPU的话是顺序执行，也就是交替运行（并发）。
多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行（并行）。

2.3 高并发

高并发（High Concurrency）是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够同时并行处理很多请求。

高并发相关常用的一些指标有响应时间（Response Time），吞吐量（Throughput），每秒查询率QPS（Query Per Second），并发用户数等。

2.4 临界区

临界区用来表示一种公共资源或者说是共享数据，可以被多个线程使用。
但是每一次，只能有一个线程使用它，一旦临界区资源被占用，其他线程要想使用这个资源，就必须等待。在并行程序中，临界区资源是保护的对象。

2.5 阻塞和非阻塞

非阻塞指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回，而阻塞与之相反。

3. 多线程

3.1 使用多线程常见的三种方式

继承Thread类

实现Runnable接口

使用线程池

3.2 Java多线程分类

用户线程：运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程

守护线程：运行在后台，为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 "佣人"。
特点：一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作
应用：数据库连接池中的检测线程，JVM虚拟机启动后的检测线程
最常见的守护线程：垃圾回收线程

3.3 如何设置守护线程？

通过调用Thead类的setDaemon(true)方法设置当前的线程为守护线程

1. setDaemon(true)必须在start()方法前执行，否则会抛出IllegalThreadStateException异常 
2.  在守护线程中产生的新线程也是守护线程 
3.  不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑

4. 一些常用方法

4.1 currentThread()

返回对当前正在执行的线程对象的引用。

4.2 getId()

返回此线程的标识符

4.3 getName()

返回此线程的名称

4.4 getPriority()

返回此线程的优先级

4.5 isAlive()

测试这个线程是否还处于活动状态。
什么是活动状态呢？
活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备运行的状态。

4.6 sleep(long millis)

使当前正在执行的线程以指定的毫秒数"休眠"（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。

4.7 interrupt()

中断这个线程。

4.8 interrupted() 和isInterrupted()

interrupted()：测试当前线程是否已经是中断状态，执行后具有将状态标志清除为false的功能
isInterrupted()：测试线程Thread对相关是否已经是中断状态，但部清楚状态标志

4.9 setName(String name)

将此线程的名称更改为等于参数 name 。

4.10 isDaemon()

测试这个线程是否是守护线程。

4.11 setDaemon(boolean on)

将此线程标记为 daemon线程或用户线程。

4.12 join()

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

join()的作用是："等待该线程终止"，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行

4.13 yield()

yield()方法的作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU时间。注意：放弃的时间不确定，可能一会就会重新获得CPU时间片。

4.14 setPriority(int newPriority)

更改此线程的优先级

六. 线程池与Executor 框架

2019-06-09T13:07:46.989000Z

六. 线程池与Executor 框架

六. 线程池与Executor 框架

线程池与Executor框架

1. 使用线程池的好处

线程池提供了一种限制和管理资源（包括执行一个任务）。每个线程池还维护一些基本统计信息

使用线程池的好处

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

2. Executor 框架

2.1 Executor 简介

Executor 框架是Java5之后引进的，在Java 5之后，通过 Executor 来启动线程比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题。

this逃逸是指在构造函数返回之前其他线程就持有该对象的引用. 调用尚未构造完全的对象的方法可能引发令人疑惑的错误。

2.2 Executor 框架结构(主要由三大部分组成)

1 任务

执行任务需要实现的Runnable接口或Callable接口。Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。

两者的区别：

Runnable接口不会返回结果,但是Callable接口可以返回结果。后面介绍Executors类的一些方法的时候会介绍到两者的相互转换。

2 任务的执行

包括任务执行机制的核心接口Executor ，以及继承自Executor 接口的ExecutorService接口。
ScheduledThreadPoolExecutor和ThreadPoolExecutor这两个关键类实现了ExecutorService接口。

3 异步计算的结果

Future接口以及Future接口的实现类FutureTask类。
当我们把Runnable接口或Callable接口的实现类提交（调用submit方法）给ThreadPoolExecutor或ScheduledThreadPoolExecutor时，会返回一个FutureTask对象。

2.3 Executor 框架的使用示意图

主线程首先要创建实现Runnable或者Callable接口的任务对象。

备注：工具类Executors可以实现Runnable对象和Callable对象之间的相互转换。（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule））
然后可以把创建完成的Runnable对象直接交给ExecutorService执行（ExecutorService.execute（Runnable command））；或者也可以把Runnable对象或Callable对象提交给ExecutorService执行（ExecutorService.submit（Runnable task）或ExecutorService.submit（Callable task））

执行execute()方法和submit()方法的区别是什么呢？
1)execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
2)submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完
如果执行ExecutorService.submit（…），ExecutorService将返回一个实现Future接口的对象（我们刚刚也提到过了执行execute()方法和submit()方法的区别，到目前为止的JDK中，返回的是FutureTask对象）。由于FutureTask实现了Runnable，程序员也可以创建FutureTask，然后直接交给ExecutorService执行。
最后，主线程可以执行FutureTask.get()方法来等待任务执行完成。主线程也可以执行FutureTask.cancel（boolean mayInterruptIfRunning）来取消此任务的执行。

3. ThreadPoolExecutor详解

线程池实现类ThreadPoolExecutor是Executor 框架最核心的类

3.1 ThreadPoolExecutor类的四个比较重要的属性

3.2 ThreadPoolExecutor类中提供的四个构造方法

 /**
     * 用给定的初始参数创建一个新的ThreadPoolExecutor。
     
     * @param corePoolSize 核心线程池大小
     
     * @param maximumPoolSize 最大线程池的大小
     
     * @param keepAliveTime 当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，
     *核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime；
     
     * @param unit  keepAliveTime参数的时间单位
     
     * @param workQueue 等待队列，当任务提交时，如果线程池中的线程数量大于等于corePoolSize的时候，把该任务封装成一个Worker对象放入等待队列；
     * 
     * @param threadFactory 执行者创建新线程时使用的工厂
     
     * @param handler RejectedExecutionHandler类型的变量，表示线程池的饱和策略。
     * 如果阻塞队列满了并且没有空闲的线程，这时如果继续提交任务，就需要采取一种策略处理该任务。
     * 线程池提供了4种策略：
        1.AbortPolicy：直接抛出异常，这是默认策略；
        2.CallerRunsPolicy：用调用者所在的线程来执行任务；
        3.DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
        4.DiscardPolicy：直接丢弃任务；
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

3.3 如何创建ThreadPoolExecutor

在《阿里巴巴Java开发手册》"并发处理"这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。

为什么呢？

使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者"过度切换"的问题。

另外《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadExecutor ：允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致OOM。

CachedThreadPool 和 ScheduledThreadPool ：允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。

方式一：通过构造方法实现

方式二：通过Executor 框架的工具类Executors来实现

我们可以创建三种类型的ThreadPoolExecutor：

FixedThreadPool
SingleThreadExecutor
CachedThreadPool
底层都是调用的ThreadPoolExecutor的构造方法

3.4 FixedThreadPool详解

FixedThreadPool被称为可重用固定线程数的线程池。

 /**
     * 创建一个可重用固定数量线程的线程池
	 *在任何时候至多有n个线程处于活动状态
	 *如果在所有线程处于活动状态时提交其他任务，则它们将在队列中等待，
	 *直到线程可用。 如果任何线程在关闭之前的执行期间由于失败而终止，
	 *如果需要执行后续任务，则一个新的线程将取代它。池中的线程将一直存在
	 *知道调用shutdown方法
     
     * @param nThreads 线程池中的线程数
     * @param threadFactory 创建新线程时使用的factory
     * @return 新创建的线程池
     * @throws NullPointerException 如果threadFactory为null
     * @throws IllegalArgumentException if {@code nThreads <= 0}
     */
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue(),
                                      threadFactory);
    }

 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

新创建的FixedThreadPool的corePoolSize和maximumPoolSize都被设置为nThreads。

FixedThreadPool的execute()方法运行示意图

上图说明：

如果当前运行的线程数小于corePoolSize，则创建新的线程来执行任务；

当前运行的线程数等于corePoolSize后，将任务加入LinkedBlockingQueue；

线程执行完1中的任务后，会在循环中反复从LinkedBlockingQueue中获取任务来执行；

FixedThreadPool使用无界队列 LinkedBlockingQueue（队列的容量为Intger.MAX_VALUE）作为线程池的工作队列会对线程池带来如下影响：

当线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize；

由于1，使用无界队列时maximumPoolSize将是一个无效参数；

由于1和2，使用无界队列时keepAliveTime将是一个无效参数；

运行中的FixedThreadPool（未执行shutdown()或shutdownNow()方法）不会拒绝任务

3.5 SingleThreadExecutor详解

SingleThreadExecutor是使用单个worker线程的Executor。

/**
     *创建使用单个worker线程运行无界队列的Executor
	 *并使用提供的ThreadFactory在需要时创建新线程
     *
     * @param threadFactory 创建新线程时使用的factory
     *
     * @return 新创建的单线程Executor
     * @throws NullPointerException 如果ThreadFactory为空
     */
    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue(),
                                    threadFactory));
    }

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }

新创建的SingleThreadExecutor的corePoolSize和maximumPoolSize都被设置为1.
其他参数和FixedThreadPool相同。SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列（队列的容量为Intger.MAX_VALUE）

SingleThreadExecutor使用无界队列作为线程池的工作队列会对线程池带来的影响与FixedThreadPool相同。

SingleThreadExecutor的运行示意图

上图说明:

如果当前运行的线程数少于corePoolSize，则创建一个新的线程执行任务；

当前线程池中有一个运行的线程后，将任务加入LinkedBlockingQueue

线程执行完1中的任务后，会在循环中反复从LinkedBlockingQueue中获取任务来执行；

3.6 CachedThreadPool详解

CachedThreadPool是一个会根据需要创建新线程的线程池。

/**
     * 创建一个线程池，根据需要创建新线程，但会在先前构建的线程可用时重用它，
	 *并在需要时使用提供的ThreadFactory创建新线程。
     * @param threadFactory 创建新线程使用的factory
     * @return 新创建的线程池
     * @throws NullPointerException 如果threadFactory为空
     */
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue(),
                                      threadFactory);
    }

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }

CachedThreadPool的corePoolSize被设置为空（0），maximumPoolSize被设置为Integer.MAX.VALUE，即它是无界的，这也就意味着如果主线程提交任务的速度高于maximumPool中线程处理任务的速度时，CachedThreadPool会不断创建新的线程
极端情况下，这样会导致耗尽cpu和内存资源。

CachedThreadPool的execute()方法的执行示意图

上图说明：

首先执行SynchronousQueue.offer(Runnable task)。如果当前maximumPool中有闲线程正在执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)，那么主线程执行offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成，否则执行下面的步骤2；

当初始maximumPool为空，或者maximumPool中没有空闲线程时，将没有线程执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。这种情况下，步骤1将失败，此时CachedThreadPool会创建新线程执行任务，execute方法执行完成；

3.7 ThreadPoolExecutor使用示例

首先创建一个Runnable接口的实现类WorkerThread

public class ThreadPoolExecutorDemo {

   public static void main(String[] args) {
       //创建一个FixedThreadPool对象
       ExecutorService executor = Executors.newFixedThreadPool(5);
       for (int i = 0; i < 10; i++) {
           //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
           Runnable worker = new WorkerThread("" + i);
           //执行Runnable
           executor.execute(worker);
       }
       //终止线程池
       executor.shutdown();
       while (!executor.isTerminated()) {
       }
       System.out.println("Finished all threads");
   }
}

shutdown（）VS shutdownNow（）

shutdown（）方法表明关闭已在Executor上调用，因此不会再向DelayedPool添加任何其他任务（由ScheduledThreadPoolExecutor类在内部使用）, 但是，已经在队列中提交的任务将被允许完成。

shutdownNow（）方法试图终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的List。

isTerminated() Vs isShutdown()

isShutDown当调用shutdown()方法后返回为true。

isTerminated当调用shutdown()方法后，并且所有提交的任务完成后返回为true

4. ScheduledThreadPoolExecutor详解

4.1 ScheduledThreadPoolExecutor简介

ScheduledThreadPoolExecutor主要用来在给定的延迟后运行任务，或者定期执行任务。
ScheduledThreadPoolExecutor使用的任务队列DelayQueue封装了一个PriorityQueue，PriorityQueue会对队列中的任务进行排序，执行所需时间短的放在前面先被执行(ScheduledFutureTask的time变量小的先执行)，如果执行所需时间相同则先提交的任务将被先执行(ScheduledFutureTask的squenceNumber变量小的先执行)。

4.2 ScheduledThreadPoolExecutor运行机制

ScheduledThreadPoolExecutor的执行主要分为两大部分：

当调用ScheduledThreadPoolExecutor的 scheduleAtFixedRate() 方法或者scheduleWirhFixedDelay() 方法时，会向ScheduledThreadPoolExecutor的 DelayQueue 添加一个实现了 RunnableScheduledFutur 接口的 ScheduledFutureTask 。

线程池中的线程从DelayQueue中获取ScheduledFutureTask，然后执行任务。

ScheduledThreadPoolExecutor为了实现周期性的执行任务，对ThreadPoolExecutor做了如下修改：

使用 DelayQueue 作为任务队列；

获取任务的方不同

执行周期任务后，增加了额外的处理

4.3 ScheduledThreadPoolExecutor执行周期任务的步骤

线程1从DelayQueue中获取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任务是指ScheduledFutureTask的time大于等于当前系统的时间；

线程1执行这个ScheduledFutureTask；

线程1修改ScheduledFutureTask的time变量为下次将要被执行的时间；

线程1把这个修改time之后的ScheduledFutureTask放回DelayQueue中（DelayQueue.add())。

4.4 ScheduledThreadPoolExecutor使用示例

创建一个简单的实现Runnable接口的类
测试程序使用ScheduledExecutorService和Executors.newScheduledThreadPool实现的java调度

4.4.1 ScheduledExecutorService scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)方法

//可以使用ScheduledExecutorService scheduleAtFixedRate方法来安排任务在初始延迟后运行，然后在给定的时间段内运行。

scheduledThreadPool.scheduleAtFixedRate(worker, 0, 10, TimeUnit.SECONDS);

4.4.2 ScheduledExecutorService scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)方法

//ScheduledExecutorService scheduleWithFixedDelay方法可用于以初始延迟启动周期性执行，然后以给定延迟执行。 延迟时间是线程完成执行的时间。

scheduledThreadPool.scheduleWithFixedDelay(worker, 0, 1, TimeUnit.SECONDS);

4.4.3 scheduleWithFixedDelay() vs scheduleAtFixedRate()

scheduleAtFixedRate（…）将延迟视为两个任务开始之间的差异（即定期调用）
不管是否执行完
scheduleWithFixedDelay（…）将延迟视为一个任务结束与下一个任务开始之间的差异，执行完才开始下一个。

scheduleAtFixedRate(): 在给定的初始延迟之后创建并执行，随后以给定的时间段首先启用的周期性动作; 那就是执行将在initialDelay之后开始，然后initialDelay+period ，然后是initialDelay + 2 * period ，等等。如果任务的执行遇到异常，则后续的执行被抑制。否则，任务将仅通过取消或终止执行人终止。如果任务执行时间比其周期长，则后续执行可能会迟到，但不会同时执行。
scheduleWithFixedDelay() : 在给定的初始延迟之后创建并执行，首先启用的定期动作，随后在一个执行的终止和下一个执行的开始之间给定的延迟。如果任务的执行遇到异常，则后续的执行被抑制。否则，任务将仅通过取消或终止执行终止。

5. 各种线程池的适用场景介绍

FixedThreadPool：适用于为了满足资源管理需求，而需要限制当前线程数量的应用场景。它适用于负载比较重的服务器；

SingleThreadExecutor：适用于需要保证顺序地执行各个任务并且在任意时间点，不会有多个线程是活动的应用场景。

CachedThreadPool：适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器；

ScheduledThreadPoolExecutor：适用于需要多个后台执行周期任务，同时为了满足资源管理需求而需要限制后台线程的数量的应用场景，

SingleThreadScheduledExecutor：适用于需要单个后台线程执行周期任务，同时保证顺序地执行各个任务的应用场景。

五. 并发编程中一些问题

2019-06-09T13:07:45.590000Z

五. 并发编程中一些问题

五. 并发编程中一些问题

并发编程的问题

1. 多线程就一定好吗？快吗？？

并发编程的目的就是为了能提高程序的执行效率提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，
比如：内存泄漏、上下文切换、死锁还有受限于硬件和软件的资源闲置问题。
多线程就是几乎同时执行多个线程（一个处理器在某一个时间点上永远都只能是一个线程！即使这个处理器是多核的，除非有多个处理器才能实现多个线程同时运行）。CPU通过给每个线程分配CPU时间片来实现伪同时运行，因为CPU时间片一般很短很短，所以给人一种同时运行的感觉。

2. 上下文切换

当前任务在执行完CPU时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换会这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。

上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。

2.1 减少上下文切换

上下文切换又分为2种：

让步式上下文切换
指执行线程主动释放CPU，与锁竞争严重程度成正比，可通过减少锁竞争和使用CAS算法来避免；

抢占式上下文切换。
指线程因分配的时间片用尽而被迫放弃CPU或者被其他优先级更高的线程所抢占，一般由于线程数大于CPU可用核心数引起，可通过适当减少线程数和使用协程来避免。

总结一下：

减少锁的使用。因为多线程竞争锁时会引起上下文切换。
使用CAS算法。这种算法也是为了减少锁的使用。CAS算法是一种无锁算法。
减少线程的使用。人物很少的时候创建大量线程会导致大量线程都处于等待状态。
使用协程。

2.2 CAS算法

CAS（比较与交换，Compare and swap）是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。
实现非阻塞同步的方案称为"无锁编程算法"（ Non-blocking algorithm）。属于乐观锁。

CAS算法涉及到三个操作数

需要读写的内存值V

进行比较的值A

拟写入的新值B

当且仅当 V 的值等于 A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。

2.3 协程

协程也可以说是微线程或者说是轻量级的线程，它占用的内存更少并且更灵活。很多编程语言中都有协程。

3. 避免死锁

3.1 如何产生的死锁

在操作系统中，死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

在线程中，如果两个线程同时等待对方释放锁也会产生死锁。

3.2 避免死锁的常见方法

避免一个线程同时获得多个锁

避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源

尝试使用定时锁，使用lock.tryLock(timeout)来替代使用内部锁机制

对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况

3.3 解决资源限制

什么是资源限制？

所谓资源限制就是我们在进行并发编程时，程序的运行速度受限于计算机硬件资源比如CPU,内存等等或软件资源比如软件的质量、性能等等。举个例子：如果说服务器的带宽只有2MB/s，某个资源的下载速度是1MB/s，系统启动10个线程下载该资源并不会导致下载速度编程10MB/s，所以在并发编程时，需要考虑这些资源的限制。硬件资源限制有：带宽的上传和下载速度、硬盘读写速度和CPU处理速度；软件资源限制有数据库的连接数、socket连接数、软件质量和性能等等。

资源限制引发的问题

在并发编程中，程序运行加快的原因是运行方式从串行运行变为并发运行，但是如果某段程序的并发执行由于资源限制仍然在串行执行的话，这时候程序的运行不仅不会加快，反而会更慢，因为可能增加了上下文切换和资源调度的时间。

3.如何解决资源限制的问题

对于硬件资源限制，可以考虑使用集群并行执行程序。既然单机的资源有限制，那么就让程序在多机上运行。比如使用Hadoop或者自己搭建服务器集群。
对于软件资源的限制，可以考虑使用资源池将资源复用。比如使用连接池将数据库和Socket复用，或者在调用对方webservice接口获取数据时，只建立一个连接。另外还可以考虑使用良好的开源软件。

在资源限制的情况下如何进行并发编程

根据不同的资源限制调整程序的并发度，比如下载文件程序依赖于两个资源-带宽和硬盘读写速度。有数据库操作时，设计数据库练连接数，如果SQL语句执行非常快，而线程的数量比数据库连接数大很多，则某些线程会被阻塞，等待数据库连接。

三. 线程间通信知识点补充

2019-06-09T13:07:47.303000Z

三. 线程间通信知识点补充

三. 线程间通信知识点补充

线程通信知识补充

1. 管道输入/输出流

管道输入/输出流主要用于线程之间的数据传输，而且传输的媒介为内存。
管道输入/输出流主要包括下列两类的实现：

面向字节： PipedOutputStream、 PipedInputStream

面向字符: PipedWriter、 PipedReader

2. Thread.join()的使用

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。另外，一个线程需要等待另一个线程也需要用到join()方法。
Thread类除了提供join()方法之外，还提供了join(long millis)、join(long millis, int nanos)两个具有超时特性的方法。这两个超时方法表示，如果线程thread在指定的超时时间没有终止，那么将会从该超时方法中返回。
Thread.sleep(2000)不会释放锁，threadTest.join(2000)会释放锁。

3. ThreadLocal的使用

3.1 ThreadLocal介绍

变量值的共享可以使用public static变量的形式，所有线程都使用一个public static变量。如果想实现每一个线程都有自己的共享变量该如何解决呢？
JDK中提供的ThreadLocal类正是为了解决这样的问题。ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

3.2 ThreadLocal方法

方法名称	描述
get()	返回当前线程的此线程局部变量的副本中的值。
set(T value)	将当前线程的此线程局部变量的副本设置为指定的值
remove()	删除此线程局部变量的当前线程的值
initialValue()	返回此线程局部变量的当前线程的"初始值"

3.3 InheritableThreadLocal

ThreadLocal类固然很好，但是子线程并不能取到父线程的ThreadLocal类的变量，InheritableThreadLocal类就是解决这个问题的。
在使用InheritableThreadLocal类需要注意的一点是：如果子线程在取得值的同时，主线程将InheritableThreadLocal中的值进行更改，那么子线程取到的还是旧值。

四. Lock锁的使用

2019-06-09T13:07:49.285000Z

四. Lock锁的使用

四. Lock锁的使用

lock锁的使用

1 Lock接口

1.1 Lock接口简介

锁是用于通过多个线程控制对共享资源的访问的工具。
通常，锁提供对共享资源的独占访问：一次只能有一个线程可以获取锁，并且对共享资源的所有访问都要求首先获取锁。
但是，一些锁可能允许并发访问共享资源，如ReadWriteLock的读写锁。

在Lock接口出现之前，Java程序是靠synchronized关键字实现锁功能的。JDK1.5之后并发包中新增了Lock接口以及相关实现类来实现锁功能。

Lock接口的实现类：

ReentrantLock

ReentrantReadWriteLock.ReadLock

ReentrantReadWriteLock.WriteLock

1.2. Lock的简单使用

 Lock lock = new ReentrantLock()； 
 lock.lock(); 
 try{ 
 }finally{ 
 lock.unlock(); 
 }

因为Lock是接口所以使用时要结合它的实现类，另外在finall语句块中释放锁的目的是保证获取到锁之后，最终能够被释放。
注意：最好不要把获取锁的过程写在try语句块中，因为如果在获取锁时发生了异常，异常抛出的同时也会导致锁无法被释放。

1.3. Lock接口的特性和常见方法

Lock接口提供的synchronized关键字不具备的主要特性：

特性	描述
尝试非阻塞地获取锁	当前线程尝试获取锁，如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁
能被中断地获取锁	获取到锁的线程能够响应中断，当获取到锁的线程被中断时，中断异常将会被抛出，同时锁会被释放
超时获取锁	在指定的截止时间之前获取锁，超过截止时间后仍旧无法获取则返回

Lock接口基本的方法：

方法名称	描述
void lock()	获得锁。如果锁不可用，则当前线程将被禁用以进行线程调度，并处于休眠状态，直到获取锁。
void lockInterruptibly()	获取锁，如果可用并立即返回。如果锁不可用，那么当前线程将被禁用以进行线程调度，并且处于休眠状态，和lock()方法不同的是在锁的获取中可以中断当前线程（相应中断）。
Condition newCondition()	获取等待通知组件，该组件和当前的锁绑定，当前线程只有获得了锁，才能调用该组件的wait()方法，而调用后，当前线程将释放锁。
boolean tryLock()	只有在调用时才可以获得锁。如果可用，则获取锁定，并立即返回值为true；如果锁不可用，则此方法将立即返回值为false 。
boolean tryLock(long time, TimeUnit unit)	超时获取锁，当前线程在一下三种情况下会返回： 1. 当前线程在超时时间内获得了锁；2.当前线程在超时时间内被中断；3.超时时间结束，返回false.
void unlock()	释放锁。

2. Lock接口的实现类：ReentrantLock

ReentrantLock和synchronized关键字一样可以用来实现线程之间的同步互斥，但是在功能是比synchronized关键字更强大而且更灵活。

2.1 ReentrantLock类常见方法

构造方法：

方法名称	描述
ReentrantLock()	创建一个 ReentrantLock的实例。
ReentrantLock(boolean fair)	创建一个特定锁类型（公平锁/非公平锁）的ReentrantLock的实例

ReentrantLock类常见方法(Lock接口已有方法这里没加上)：

方法名称	描述
int getHoldCount()	查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。
protected Thread getOwner()	返回当前拥有此锁的线程，如果不拥有，则返回 null
protected Collection getQueuedThreads()	返回包含可能正在等待获取此锁的线程的集合
int getQueueLength()	返回等待获取此锁的线程数的估计。
protected Collection getWaitingThreads(Condition condition)	返回包含可能在与此锁相关联的给定条件下等待的线程的集合。
int getWaitQueueLength(Condition condition)	返回与此锁相关联的给定条件等待的线程数的估计。
boolean hasQueuedThread(Thread thread)	查询给定线程是否等待获取此锁。
boolean hasQueuedThreads()	查询是否有线程正在等待获取此锁。
boolean hasWaiters(Condition condition)	查询任何线程是否等待与此锁相关联的给定条件
boolean isFair()	如果此锁的公平设置为true，则返回 true 。
boolean isHeldByCurrentThread()	查询此锁是否由当前线程持有。
boolean isLocked()	查询此锁是否由任何线程持有。

2.2 第一个ReentrantLock程序

当一个线程运行完毕后才把锁释放，其他线程才能执行，其他线程的执行顺序是不确定的。

3. Condition接口简介

synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。
Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。
在使用notify/notifyAll()方法进行通知时，被通知的线程是有JVM选择的，使用ReentrantLock类结合Condition实例可以实现"选择性通知"，这个功能非常重要，而且是Condition接口默认提供的。

Condition接口的常见方法：

方法名称	描述
void await()	相当于Object类的wait方法
boolean await(long time, TimeUnit unit)	相当于Object类的wait(long timeout)方法
signal()	相当于Object类的notify方法
signalAll()	相当于Object类的notifyAll方法

synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法只会唤醒注册在该Condition实例中的所有等待线程

3.1 使用Condition实现等待/通知机制

使用单个Condition实例实现等待/通知机制：

必须执行完signal所在的try语句块之后才释放锁，condition.await()后的语句才能被执行。

注意：必须在condition.await()方法调用之前调用lock.lock()代码获得同步监视器，不然会报错。

使用多个Condition实例实现等待/通知机制：

实现"选择性通知",只会唤醒注册在指定Condition实例中的所有等待线程

使用Condition实现顺序执行

在一个线程运行完之后通过condition.signal()/condition.signalAll()方法通知下一个特定的线程运行，就这样循环往复即可。

注意：默认情况下ReentranLock类使用的是非公平锁

4. 公平锁与非公平锁

Lock锁分为：公平锁和非公平锁。

公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。

而非公平锁就是一种获取锁的抢占机制，是随机获取锁的，和公平锁不一样的就是先来的不一定先的到锁，这样可能造成某些线程一直拿不到锁，结果也就是不公平的了。

5. ReadWriteLock接口的实现类：ReentrantReadWriteLock

5.1 简介

ReentrantLock（排他锁）具有完全互斥排他的效果，即同一时刻只允许一个线程访问，这样做虽然虽然保证了实例变量的线程安全性，但效率非常低下。
ReadWriteLock接口的实现类-ReentrantReadWriteLock读写锁就是为了解决这个问题。

读写锁维护了两个锁，一个是读操作相关的锁也成为共享锁，
一个是写操作相关的锁也称为排他锁。
通过分离读锁和写锁，其并发性比一般排他锁有了很大提升。

多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥（只要出现写操作的过程就是互斥的）
在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，
而进行写入操作的Thread只有在获取写锁后才能进行写入操作。
即多个Thread可以同时进行读取操作,但是同一时刻只允许一个Thread进行写入操作。

5.2 ReentrantReadWriteLock的特性与常见方法

ReentrantReadWriteLock的特性：

特性	说明
公平性选择	支持非公平（默认）和公平的锁获取方式，吞吐量上来看还是非公平优于公平
重进入	该锁支持重进入，以读写线程为例：读线程在获取了读锁之后，能够再次获取读锁。而写线程在获取了写锁之后能够再次获取写锁也能够同时获取读锁
锁降级	遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级称为读锁

ReentrantReadWriteLock常见方法：
构造方法

方法名称	描述
ReentrantReadWriteLock()	创建一个 ReentrantReadWriteLock()的实例
ReentrantReadWriteLock(boolean fair)	创建一个特定锁类型（公平锁/非公平锁）的ReentrantReadWriteLock的实例

常见方法：
和ReentrantLock类类似

5.3 ReentrantReadWriteLock的使用

读读共享

两个线程同时运行read方法，你会发现两个线程可以同时或者说是几乎同时运行lock()方法后面的代码，输出的两句话显示的时间一样。这样提高了程序的运行效率。
写写互斥

两个线程同时运行write方法，你会发现同一时间只允许一个线程执行lock()方法后面的代码
读写互斥（读写互斥）
运行两个使用同一个Service对象实例的线程a,b，线程a执行上面的read方法，线程b执行上面的write方法。你会发现同一时间只允许一个线程执行lock()方法后面的代码。
- 记住：只要出现写操作的过程就是互斥的。

二. 线程安全

2019-06-09T13:07:51.586000Z

二. 线程安全

二. 线程安全

0. 锁

0.1 为什么需要锁（并发控制）？

在多用户环境中，在同一时间可能会有多个用户更新相同的记录，这会产生冲突。这就是著名的并发性问题。

典型的冲突有：

丢失更新：一个事务的更新覆盖了其它事务的更新结果，就是所谓的更新丢失。例如：用户A把值从6改为2，用户B把值从2改为6，则用户A丢失了他的更新。

脏读：当一个事务读取其它完成一半事务的记录时，就会发生脏读取。例如：用户A,B看到的值都是6，用户B把值改为2，用户A读到的值仍为6。

为了解决这些并发带来的问题。我们需要引入并发控制机制。

0.2 并发控制机制（锁）

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。

传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。

乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。

在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

0.3 两种锁的使用场景

乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。

但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

0.4 乐观锁的缺点

ABA 问题
如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回A，那CAS操作就会误认为它从来没有被修改过。这个问题被称为CAS操作的 "ABA"问题。

循环时间长开销大
自旋CAS（也就是不成功就一直循环执行直到成功）如果长时间不成功，会给CPU带来非常大的执行开销。

只能保证一个共享变量的原子操作
CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 无效。

0.5 乐观锁与悲观锁详解

乐观锁与悲观锁详解

1. synchronized关键字(1)

synchronized关键字1

synchronized

synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

Java并发编程这个领域中synchronized关键字一直都是元老级的角色，很久之前很多人都会称它为 "重量级锁" 。
但是，在JavaSE 1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的 偏向锁和 轻量级锁 以及其它各种优化之后变得在某些情况下并不是那么重了。synchronized的底层实现主要依靠 Lock-Free 的队列，基本思路是 自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但获得了高吞吐量。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS。

1.1 变量安全性

"非线程安全"(线程不安全) 问题存在于"实例变量"中，如果是方法内部的私有变量，则不存在"非线程安全"，所得结果也就是"线程安全"的了。
如果两个线程同时操作对象中的实例变量，则会出现"非线程安全"，解决办法就是在方法前加上synchronized关键字即可。

1.2 多个对象对个锁

synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁。所以在上面的实例中，哪个线程先执行带synchronized关键字的方法，则哪个线程就持有该方法所属对象的锁Lock，那么其他线程只能呈等待状态，前提是多个线程访问的是同一个对象。

1.3 synchronized方法与锁对象

synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁。如果多个线程访问的是同一个对象，哪个线程先执行带synchronized关键字的方法，则哪个线程就持有该方法，那么其他线程只能呈等待状态。
如果多个线程访问的是多个对象则不一定，因为多个对象会产生多个锁。

1.4 脏读

发生脏读的情况是在读取实例变量时，此值已经被其他线程更改过。

代码没有做同步，虽然set方法同步，但是由于get方法一般都会忘了，导致读的值是被写过的

1.5 synchronized锁重入

可重入锁"概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。

1.6 同步不具有继承性

如果父类有一个带synchronized关键字的方法，子类继承并重写了这个方法。但是同步不能继承，所以还是需要在子类方法中添加synchronized关键字。

2. synchronized关键字（2）

synchronized关键字2

2.1 synchronized方法的缺点

使用synchronized关键字声明方法有些时候是有很大的弊端的，比如我们有两个线程一个线程A调用同步方法后获得锁，那么另一个线程B就需要等待A执行完，但是如果说A执行的是一个很费时间的任务的话这样就会很耗时。

可以使用synchronized同步块来解决这个问题。但是要注意synchronized同步块的使用方式，如果synchronized同步块使用不好的话并不会带来效率的提升。

2.2 synchronized（this）同步代码块的使用

public class Task {

    private String getData1;
    private String getData2;

    public void doLongTimeTask() {
        try {
            System.out.println("begin task");
            Thread.sleep(3000);

            String privateGetData1 = "长时间处理任务后从远程返回的值1 threadName="
                    + Thread.currentThread().getName();
            String privateGetData2 = "长时间处理任务后从远程返回的值2 threadName="
                    + Thread.currentThread().getName();

            synchronized (this) {
                getData1 = privateGetData1;
                getData2 = privateGetData2;
            }

            System.out.println(getData1);
            System.out.println(getData2);
            System.out.println("end task");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

当一个线程访问一个对象的synchronized同步代码块时，另一个线程任然可以访问该对象非synchronized同步代码块。
不在synchronized代码块中就异步执行，在synchronized代码块中就是同步执行。

2.3 synchronized（object）代码块间使用

两个线程使用了同一个"对象监视器",所以运行结果是同步的。
两个线程使用了不同的"对象监视器",所以运行结果不是同步的了。

2.4 synchronized代码块间的同步性

当一个对象访问synchronized(this)代码块时，其他线程对同一个对象中所有其他synchronized(this)代码块代码块的访问将被阻塞，这说明synchronized(this)代码块使用的"对象监视器"是同一个。
和synchronized方法一样，synchronized(this)代码块也是锁定当前对象。

其他线程执行对象中synchronized同步方法和synchronized(this)代码块时呈现同步效果;

如果两个线程使用了同一个"对象监视器",运行结果同步，否则不同步.

2.5 静态同步synchronized方法与synchronized(class)代码块

synchronized关键字加到static静态方法和synchronized(class)代码块上都是是给Class类上锁，而synchronized关键字加到非静态方法上是给对象上锁。
静态同步synchronized方法与synchronized(class)代码块持有的锁一样，都是Class锁，Class锁对对象的所有实例起作用。

3. volatile关键字

volatile关键字

3.1 volatile关键字简介

volatile关键字可以用来提醒编译器它后面所定义的变量随时有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数。
如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。

3.2 volatile关键字的可见性

volatile 修饰的成员变量在每次被线程访问时，都强迫从主存（共享内存）中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到主存（共享内存）。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值，这样也就保证了同步数据的可见性。

3.3 synchronized关键字和volatile关键字比较

volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用synchronized关键字还是更多一些。
多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
volatile关键字用于解决变量在多个线程之间的可见性，而ynchronized关键字解决的是多个线程之间访问资源的同步性。

4. 等待/通知（wait/notify）机制

4.1 等待/通知机制介绍

为什么要使用等待/通知机制？

当两个线程之间存在生产和消费者关系，也就是说第一个线程（生产者）做相应的操作然后第二个线程（消费者）感知到了变化又进行相应的操作。
第二个语句不停过通过轮询机制来检测判断条件是否成立。如果轮询时间的间隔太小会浪费CPU资源，轮询时间的间隔太大，就可能取不到自己想要的数据。所以这里就需要我们今天讲到的等待/通知（wait/notify）机制来解决这两个矛盾。

概念

等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()/notifyAll()方法，线程A收到通知后退出等待队列，进入可运行状态，进而执行后续操作。上诉两个线程通过对象O来完成交互，而对象上的wait()方法和notify()/notifyAll()方法的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

4.2 等待/通知机制的实现

notify()执行后并不会立即释放锁
synchronized关键字可以将任何一个Object对象作为同步对象来看待，而Java为每个Object都实现了等待/通知（wait/notify）机制的相关方法，它们必须用在synchronized关键字同步的Object的临界区内。
通过调用wait()方法可以使处于临界区内的线程进入等待状态，同时释放被同步对象的锁。
而notify()方法可以唤醒一个因调用wait操作而处于阻塞状态中的线程，使其进入就绪状态。
被重新唤醒的线程会试图重新获得临界区的控制权也就是锁，并继续执行wait方法之后的代码。

4.3 notify()锁不释放

当方法wait()被执行后，锁自动被释放，但执行完notify()方法后，锁不会自动释放。必须执行完notify()方法所在的synchronized代码块后才释放。

三级基础知识

2019-04-01T05:22:48.236000Z

选择题

必考

问传输速度

OC-3 对应 155.52 Mbps
OC-12 对应 622.08 Mbps
OC-48对应2.488GMbps

求交换机带宽

某交换机有 12 个 10/100 Mbps 电端口和 2 个 1000 Mbps 光端口，所有端口都在全双工状态下，那么总带宽为（）
解：忽略 10/100 中的 10，当成 100 Mbps 就好。12 * 100 + 2 * 1000 = 3200，又因为全双工所以乘以 2 得 6400 Mbps ,即 6.4 Gbps

某交换机有 16个100/1000 Mbps 全双工下联端口，那么上联端口带宽至少为（）
解：16 * 1000 * 2 = 32000 Mbps = 32 Gbps，上联一般是下联的 1/20 ，所以至少为 32 除以 20 得 1.6 Gbps

3.系统可用性与停机时间

可用性	停机时间
99.9%	≤8.8小时
99.99%	≤53分钟
99.999%	≤5分钟

写地址块的子网掩码

例：IP 地址块 59.67.159.125/11 的子网掩码可写为（）
解：不用看 IP 地址，只看 /11 就够了。 11 代表子网掩码的前 11 位都是 1 ，所以可以写出子网掩码 11111111.11100000.00000000.00000000 转换为十进制即是 255.224.0.0

5. 网络地址转换 NAT

会给你一个这样的图，问你 ① ② 是什么只需要知道②和紧挨着它的 S 数字相同，所以②应该是 202.0.1.1,5001 ;同理，①是 10.0.0.1,3342。还有时候会问某个小方框里的 S,D 分别是什么，看上面的图你会发现，上面两个方框和下面两个方框里的数字是对称的，做题时对称一下就写出答案了。

IP 地址块聚合

第一种：问聚合后的地址块

步骤为：转成二进制；对齐找前多少位是相同的；转回十进制写答案。

第二种：问聚合后可用 IP 数
【第一种情况】如未来教育上机考试第一套试题第10题：
" IP 地址块 202.113.79.128/27、202.113.79.160/27 和 202.113.79.192/27 经过聚合后可用的地址数为___"
因为格式都是 xxx.xxx.xxx.xxx/27，本题中"/"后边的数字都是相同的。
所以遇到这种题，先把前两个 IP 聚合求出可用地址数，202.113.79.128/26 2^6-2=62
然后单独算出第三个 IP 地址可用地址数，2^5-2=32
两个地址数相加即正确答案。32+62=94
【第二种情况】如未来教育上机考试第三套试题第10题：
" IP 地址块 202.113.79.0/27、202.113.79.32/27、202.113.79.64/26 经过聚合后可用的地址数为___"
本题中"/"后边的数字前两个是相同的，第三个与前两个不同。
所以遇到这种题，直接将三个 IP 聚合得到地址块，202.113.79.0/25
然后求出三个 IP 的可用地址数。2^(32-25)-2=126

路由表距离更新

R1,R2 是一个系统中采用RIP路由协议的两个相邻路由器，R1 的路由表如（a）所示， R1 收到 R2 发送的报文（b）后，R1 更新后的距离值从上到下依次是（）

步骤为：b距离+1；与a距离比较；更新为距离最小的。则更新后的距离值从上到下依次是 0、4、4、3、2

还经常这样考——给出更新后距离值和（a）中的距离，求（b）报文距离的可能值。
b的报文距离>=更新后的距离值-1

IPv6 地址简化表示

例：某地址 FF23:0:0:0:0510:0:0:9C5B，
可以简化为 FF23::0510:0:0:9C5B，双冒号替代连续出现的 0 位段，
不能简化为 FF23::0510::9C5B，因为双冒号只能使用一次，
可以简化为 FF23::510:0:0:9C5B，因为 0510 就是 510 ，
不能简化为 FF23::051:0:0:9C5B，因为 0510 不是 51。

例：下列 IPv6 地址表示中错误的是（）
A) ::10F:BC:0:0:03DA
B) FE::0:45:03/48
C) FE31:0:BC:3E:0:050D:BC::03DA
D) FF34:42:BC::3E:50F:21:03D
解：IPv6 地址是 128 位划分为 8 段的地址，而 C 项不算双冒号那段已经有了 8 段，双冒号又至少压缩一个 0 位段，所以超了 8 段，是错误的。

数据包

例：下图是 A 发送的数据包通过路由器转发到 B 的过程示意图，求数据包 3 中的目的IP地址和目的MAC地址
解：无论哪个数据包，目的 IP 地址就是 B 的 IP 地址，所以数据包 3 的目的 IP 为 129.42.56.216；而目的 MAC 地址就是下一个路由器的 MAC 地址，数据包 3 的下一个路由器是 R3，所以数据包 3 的目的 MAC 地址是 00d0.63c3.3c41。

三种备份

备份速度从快到慢：增量备份、差异备份、完全备份（备份越详细越慢）
恢复速度从快到慢：完全备份、差异备份、增量备份（和上面顺序相反，也好理解，备份时详细的恢复快）
空间占用从多到少：完全备份、差异备份、增量备份（备份越详细占用空间越多）
题目通常问你其中某一种的顺序。

大段配置4选1

排除法找不同

正确错误四选一

1. 弹性分组环 RPR

每一个节点都执行SRP公平算法

与FDDI 一样使用双环结构

传统的 FDDI 环，当源结点向目的节点成功发送一个数据帧之后，这个数据帧由源结点从环中回收

而 RPR 环，当源结点向目的节点成功发送一个数据帧之后，这个数据帧由目的结点从环中回收

RPR 采用自愈环设计思路，能在 50ms时间内隔离故障结点和光纤段

两个 RPR 结点间的裸光纤最大长度可达 100公里

RPR 的外环（顺时针）和内环（逆时针）都可以用于传输分组和控制分组

2. 无线接入技术

主要有 WLAN、WiMAX、WiFi、WMAN 和 Ad hoc ( WiFi 肯定知道，记住无线技术一般是W开头的，但有个特殊的A开头)
APON 不是无限传输技术，这个经常是迷惑项

3. 广域网 QoS

考的时候通常只写英文缩写，下面写上中文名是为了方便你记忆（其他的地方也应该养成粗略推测英文缩写的习惯）主要的技术有资源预留（RSVP）、区分服务（DiffServ）、多协议标记交换（MPLS）

4. 接入技术特征

ASDL 使用一对铜双绞线，具有非对称技术特性，上行速率 64 kbps~640 kbps，下行速率 500 kbps~7 Mbps
采用 ADSL 技术可以通过 PSTN 接入 Internet
Cable Modom（电缆调制解调器）利用频分复用的方法将信道分为上行信道和下行信道，把用户计算机与有线电视同轴电缆连接起来
光纤传输距离可达 100km以上（这个知道光纤很远就行了）

5. 服务器技术

热插拔功能允许用户在不切断电源的情况下更换硬盘、板卡等（不能更换主板卡）
集群技术中，如果一台主机出现故障，不会影响正常服务，但会影响系统性能
磁盘性能表现在储存容量和 I/O 速度（I/O=input/output 即输入/输出，学过计算机应该知道）
服务器总体性能取决于 CPU 数量、CPU 主频、系统内存、网络速度

6. 综合布线

双绞线可以避免电磁干扰
嵌入式插座用来连接双绞线
多介质插座用来连接铜缆和光纤，满足用户"光纤到桌面"的需求
建筑群子系统可以是多种布线方式的任意组合，地下管道布线是最理想的方式，直埋最不利
STP 比 UTP 贵、复杂、抗干扰能力强、辐射小
水平布线子系统电缆长度在 90 m 以内
干线线缆铺设经常采用点对点结合和分支结合两种方式.

7. BGP 协议

BGP 是边界网关协议，而不是内部网关协议（所以遇到问某两个自治系统AS之间使用什么协议，就选 BGP）不同的自治系统
BGP 交换路由信息的节点数不小于自治系统数
一个 BGP 发言人使用 TCP（不是UDP）与其他自治系统的 BGP 发言人交换信息
BGP 采用路由向量协议，而 RIP 采用距离向量协议
BGP 发言人通过 update 而不是 noticfication 分组通知相邻系统
open 分组用来与相邻的另一个 BGP 发言人建立关系，两个 BGP 发言人需要周期性地交换 keepalive 分组来确认双方的相邻关系

8. RIP 协议

RIP 是内部网关协议中使用最广泛的一种协议，它是一种分布式、基于距离向量的路由选择协议，要求路由器周期性地向外发送路由刷新报文
路由刷新报文主要内容是由若干个 (V，D）组成的表 V 标识该路由器可以到达的目标网络（或目的主机）；D 指出该路由器到达目标网络（或目标主机）的距离。距离D对应该路由器上的跳数。其他路由器在接收到某个路由器的（V，D）报文后，按照最短路径原则对各自的路由表进行刷新
使用 RIP v1 路由协议在配置网络地址时无须给定子网掩码

9. OSPF 协议

OSPF 是内部网关协议的一种，每个区域有一个 32 位的标识符，区域内路由器不超过 200 个
链路状态数据库保存全网拓扑结构图，不知道其他区域的网络拓扑（拓扑的意思是链接形式和位置关系之类的）
链路状态"度量"主要指费用、距离、延时、带宽等
OSPF 采用洪泛法最短优先路径向所有路由器发送消息
通过区域划分提高收敛速度

10. 集线器

工作在物理层，连接到一个集线器的所有结点共享一个冲突域
集线器不是基于 MAC 地址完成数据转发，而是用广播的方法
在链路中串接一个集线器可以监听数据包
每次只有一个结点能够发送数据，而其他的结点都处于接收数据的状态。这些结点执行CSMA/CD介质访问控制方法

11. 交换机

是一种工作在数据链路层的网络设备，基本功能是维护一个表示 MAC 地址和交换机端口对应关系的交换表
在源端口与目的端口间建立虚链接
具有三种交换模式：1.快速转发直通式，接收到前 14 个字节就转发数据；2.碎片丢弃式，缓存前 64个字节；3.储存转发式，转发之前读取整个帧
三层交换机是具有部分路由器功能的交换机，用于加快大型局域网内部的数据交换

12. 路由器

丢包率是衡量路由器超负荷工作时的性能指标之一
背板能力决定路由器吞吐量
吞吐量指包转发能力
传统路由器一般采用共享背板的结构，高性能路由器一般采用交换式的结构
突发处理能力不是以最小帧间隔值来衡量的
语音视频业务对延时抖动要求较高高端路由器应达到：无故障连续工作时间大于 10 万小时；故障恢复时间小于 30 分钟；切换时间小于 50 毫秒

13. IEEE 802.11

IEEE 802.11 最初定义的三个物理层包括了两个扩频技术和一个红外传播规范，无线频道定义在 2.4GHz ISM频段，传输速度 1~2 Mbps
802.11b 最大容量 33 Mbps，将传输速率提高到 11 Mbps，
802.11a 将传输速率提高到 54 Mbps 容量 432 吞吐量28-31
802.11g 54Mbps，工作在ISM频段 容量 162 吞吐量28-31
IEEE 802.11d 是当前最流行的 STP（生成树协议）标准
IEEE 802.11b 标准使用的是开放的 2.4GHZ 频段，无须申请就可以直接使用

14. 蓝牙

同步信道速率 64 kbps，跳频速率为 1600 次/s
工作在 2.402 ~ 2.480 GHz 的 ISM 频段
非对称的异步信道速率为 723.2 kbps / 57.6 kbps
对称的异步信道速率为 433.9 kbps
发射功率 0dbm：1-10m | 20dbm：100m

15. Serv-U FTP 服务器

使用动态 IP 地址时，服务器 IP 地址应配置为空，而不是 0.0.0.0。（为空代表全部 IP 地址）
每个 Serv-U FTP 服务器中的虚拟服务器由 IP 地址和端口号唯一识别，而不是依靠 IP 地址
向服务器中添加"anonymous"，系统自动判定为匿名。而不是创建新域时自动添加一个"anonymous"匿名
服务器最大用户数是指服务器允许同时在线的最大用户数量
用户上传下载选项要求 FTP 客户端在下载信息的同时也要上传文件

16. DNS 服务器

允许客户机在发生更改时动态更新其资源记录(可配置)
DNS 服务器中的根服务器被自动加入到系统中，不需管理员手工配置
转发器是网络上的 DNS 服务器(可配置)，用于外域名的 DNS 查询
使用 nslookup 命令可以测试正向和反向查找区域，（可配置）
主机记录的生存时间指该记录被客户端查询到，放在缓存中的持续时间.
DNS解析，首先查询本地客户机的缓存
动态ip分配只需配DHCP服务器

17. DHCP 服务器

负责多个网段 IP 地址分配时需配置多个作用域(地址池)
添加保留时需在 DHCP 客户机上获得其 MAC 地址信息（添加排除时不需从客户端获得 MAC 地址）
不添加排除和保留时，服务器可将地址池内的 IP 地址动态指派给 DHCP 客户机
地址池是作用域应用排除范围之后剩余的 IP 地址
保留是指确保 DHCP 客户端永远可以得到同一 IP 地址，客户端可以释放该租约
收到非中继转发的"DHCP发现"消息时,选择收到该消息的子网所处的网段分配 IP 地址

18. WWW 服务器

Web 站点可以配置静态和动态 IP地址
访问 Web 站点时可以使用站点的域名或站点的 IP地址
建立 Web 站点时必须为该站点指定一个主目录好，也可以是虚拟的子目录
Web 站点的性能选项包括影响带宽使用的属性和客户端 Web 连接的数量
在 Web 站点的主目录选项卡中，可配置主目录的读取和写入等权限

Wmail 邮件服务器

发送邮件时通常采用 SMTP 协议，接收邮件时通常采用 POP3 或者 IMAP 协议。Winmail 用户使用浏览器查看邮件会使用到 HTTP 协议
邮件服务器可以设置用户名，域名，用户密码，不能设置管理员

23. 网络攻击

DDos 攻击：利用已经攻占的多个系统向目标攻击，被害设备面对大量请求无法正常处理而拒绝服务
SYN Flooding 攻击：利用 TCP 三次握手过程，使受害主机处于会话请求之中，直至连接超时停止响应
SQL 注入攻击：属于利用系统漏洞，防火墙（基于网络的防护系统）无法阻断
Land攻击：向某个设备发送数据包，并将数据包的源 IP 地址和目的地址都设置成攻击目标的地址
基于网络的防护系统也无法阻断 Cookie篡改和 DNS欺骗
Tear doop 、Smurf 攻击可以被路由器阻止

无线局域网设备

无线接入点（AP）：集合无线或者有线终端（类似于集线器和交换机），负责频段管理和漫游工作（SSID 是客户端设备用来访问接入点的唯一标识）
无线路由器：具有无线路由功能和 NAT 功能的 AP ，可用来建立小的无线局域网。
无线网桥：用于连接几个不同的网段，实现较远距离的无线通信（网桥最重要的维护工作是构建和维护 MAC 地址表）
无线网卡：实现点对点通信，安装于各终端节点

25. VLAN

VLAN name 用 1~32 个字符表示，它可以是字母和数字。不给定名字的 VLAN 系统自动按缺省的 VLAN 名（VLAN00xxx）
VLAN ID的取值范围是 1~4094。用12bit表示。其中无法执行"no vlan 1"命令
Ethernet vlanid 1-1000
属于数据链路层

26. Cisco 路由器上的存储器

configure terminal：global configuration

privilege EXEC 特权模式在用户模式 下输入enable

setup 设置模式刚出厂

RXBOOT 维护模式密码恢复
监视模式：系统映像更新，口令恢复

Cisco Aironet 1100快速配置页面
Broadcast SSID in Beacon:允许设备不指定SSID
configuration server protocol :自动分配ip
ip address: 设置接入点ip
radio server set ID：输入网络管理员SSID

Flash 主要用于存储当前使用的操作系统映像文件和微代码
NVRAM 主要存储启动配置文件或备份配置文件
RAM 主要存储路由表、快速交换缓存、ARP 缓存、数据分组缓冲区和缓冲队列、运行配置文件等
ROM 主要用来永久保存路由器的开机诊断程序、引导程序和操作系统软件

27. 防火墙对应端口的连接方案

pix525 在缺省情况下

ethernet0 被命名为外部接口 outside，安全级别是 0
ethernet1 被命名为内部接口 inside，安全级别是 100
ethernet2 被命名为中间接口 dmz，安装级别是 50

28. STP 生成树结构

STP运行在交换机和网桥上
IEEE802.1D最早的
无论是根的确定，还是树状结构的生成，主要依靠 BPDU 提供的信息
Bridge ID 由2个字节的优先级值和 6 个字节的交换机 MAC 地址组成，优先级取值范围是0~61440，增值量是4096，优先值越小，优先级越高
MAC 地址最小的为根网桥
BPDU 数据包有两种类型，配置 BPDU 不超过 35 个字节，拓扑变化通知 BPDU 不超过 4 个字节
BPDU每隔2秒发送一次，故障变化发送新的

Catelyst 配置命令

Catelyst3548 设置时间的格式是：clock set 小时:分钟:秒日月年
Catelyst6500 设置时间的格式是：set time 星期月/日/年小时分钟秒

30. windows2003 命令

ipconfig：tcp/ip网络配置
net view：域列表，计算机列表
nbtstat -a : 远程计算机
nslookup：internet域名信息，诊断DNS
netstat：tcp连接，本地地址，外部地址，状态

大题

填地址

已知ip地址和子网掩码求其他

主机位前面0的个数就是子网掩码1的个数

计算子网掩码和 IP 段部分

将 192.168.66.128/25 划分为三个子网，子网 1 能容纳 50 台主机，子网 2 和 3 能分别容纳 20 台主机……求他们的子网掩码和可用 IP 地址段

题中说多少台主机的具体数字不重要，刚好大于那个数字的 2 的 n 次方的数才重要。
台数要加2，比如 50+2 台，就是 64，是 2 的 6 次方。所以子网掩码后 6 位都是 0 （前面全是 1 ），11111111.11111111.11111111.11000000 ，最后填空写 255.255.255.192
同理 20+2 台，就是 32，是 2 的 5次方。所以子网掩码后 5位都是 0，最后填空 2 和 3 的子网掩码都是 255.255.255.224 （ 11100000）

可用 IP 地址从题目所给的那个数 +1 开始，本题是 192.168.66.128+1=129，从 129 开始，因为子网 1 的主机台数要是 64 ，所以到 190 结束（129+64-3=190，不用管为什么，结束都是 -3） 129-190

下一段从 193 开始（190+3=193，不用管为什么，开始都是 +3），因为子网 2 的那个数字是 32 ，所以到 222 结束（193+32-3=222） 193-222

再下一段从 225 开始（222+3=225），因为子网 3 的那个数字也是 32 ，所以到 254 结束（225+32-3=254） 225-254

3.综合题2

ip dhcp :exclude-address 保留地址的两个值
ip dhcp pool 地址池名
network 地址池地址子网掩码
default-route 缺省网关地址
dns-server address 两个域名服务器地址
lease 租用时间(天小时分钟)

4. 综合题3

type 后面的按顺序是release ，discover，offer，request，ack

第一行是release 代表有ip
如果第一行是discover代表没有ip 即 0.0.0.0 , 255.255.255.255
最后一行是 request IP address对应第一行的第一个ip
offer对应第二个ip

boot record type 2是reply
boot record type 1是request

最后一行是 server IP address 对应第二个ip

5. 综合题4

功能一般是路由
dest address ①处是它下面一行的第一个ip或域名
source address 就是第一行第一个ip
destination address 是 ip 域名

执行的命令一般是 tracert 域名

dns ip一般是第一行第二个ip
protocol : ICMP

6. 应用题

3个ip聚合的时候，要满足2n-2>=3,即子网掩码必须要小于32-3=29.(如果算出来是30就变为29)

如果算出来的ip和已有的ip重合了，就向左移一位，后面的1变为0，子网掩码因此减一。

问在某路由器上，最多还可链接的路由器数量是多少。如果所在子网掩码是 /29 就填 3，是 /28 就填 11。
问串接一种设备能监听路由器之间的流量，写 TAP
问串接一种设备能提供安全保护，警报阻断攻击，一般是 IPS RA的E1端口
问防火墙访问外网设置，分别填 nat 和 global
访问内网 static

linux操作系统

2019-09-19T03:50:22.378000Z

一. 认识操作系统

1.1 操作系统简介

操作系统（Operation System，简称OS）是管理计算机硬件与软件资源的程序，是计算机系统的内核与基石；
操作系统本质上是运行在计算机上的软件程序；
为用户提供一个与系统交互的操作界面；
操作系统分内核与外壳（我们可以把外壳理解成围绕着内核的应用程序，而内核就是能操作硬件的程序）。

1.2 操作系统简单分类.

Windows: 目前最流行的个人桌面操作系统，不做多的介绍，大家都清楚。
Unix：最早的多用户、多任务操作系统 .按照操作系统的分类，属于分时操作系统。Unix 大多被用在服务器、工作站，现在也有用在个人计算机上。它在创建互联网、计算机网络或客户端/服务器模型方面发挥着非常重要的作用。
Linux: Linux是一套免费使用和自由传播的类Unix操作系统.Linux存在着许多不同的Linux版本，但它们都使用了 Linux内核。Linux可安装在各种计算机硬件设备中，比如手机、平板电脑、路由器、视频游戏控制台、台式计算机、大型机和超级计算机。严格来讲，Linux这个词本身只表示Linux内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU 工程各种工具和数据库的操作系统。

二初探Linux

2.1 Linux简介

类Unix系统： Linux是一种自由、开放源码的类似Unix的操作系统
Linux内核：严格来说，Linux这个词本身只表示Linux内核

2.2 Linux的分类

Linux根据原生程度，分为两种：

内核版本： Linux不是一个操作系统，严格来讲，Linux只是一个操作系统中的内核。内核是什么？内核建立了计算机软件与硬件之间通讯的平台，内核提供系统服务，比如文件管理、虚拟内存、设备I/O等；
发行版本：一些组织或公司在内核版基础上进行二次开发而重新发行的版本。Linux发行版本有很多种（ubuntu和CentOS用的都很多，初学建议选择CentOS）

三. Linux文件系统概览

3.1 Linux文件系统简介

在Linux操作系统中，所有被操作系统管理的资源，例如网络接口卡、磁盘驱动器、打印机、输入输出设备、普通文件或是目录都被看作是一个文件。

也就是说在LINUX系统中有一个重要的概念：一切都是文件。其实这是UNIX哲学的一个体现，而Linux是重写UNIX而来，所以这个概念也就传承了下来。在UNIX系统中，把一切资源都看作是文件，包括硬件设备。UNIX系统把每个硬件都看成是一个文件，通常称为设备文件，这样用户就可以用读写文件的方式实现对硬件的访问。

3.2 文件类型与目录结构

**Linux支持5种文件类型： **

Linux的目录结构如下：
Linux文件系统的结构层次鲜明，就像一棵倒立的树，最顶层是其根目录：

常见目录说明：

/bin：存放二进制可执行文件(ls,cat,mkdir等)，常用命令一般都在这里；
/etc：存放系统管理和配置文件；
/home：存放所有用户文件的根目录，是用户主目录的基点，比如用户user的主目录就是/home/user，可以用~user表示；
/usr ：用于存放系统应用程序；
/opt：额外安装的可选应用程序包所放置的位置。一般情况下，我们可以把tomcat等都安装到这里；
/proc：虚拟文件系统目录，是系统内存的映射。可直接访问这个目录来获取系统信息；
/root：超级用户（系统管理员）的主目录（特权阶级^o^）；
/sbin: 存放二进制可执行文件，只有root才能访问。这里存放的是系统管理员使用的系统级别的管理命令和程序。如ifconfig等；
/dev：用于存放设备文件；
/mnt：系统管理员安装临时文件系统的安装点，系统提供这个目录是让用户临时挂载其他的文件系统；
/boot：存放用于系统引导时使用的各种文件；
/lib ：存放着和系统运行相关的库文件；
/tmp：用于存放各种临时文件，是公用的临时文件存储点；
/var：用于存放运行时需要改变数据的文件，也是某些大文件的溢出区，比方说各种服务的日志文件（系统启动日志等。）等；
/lost+found：这个目录平时是空的，系统非正常关机而留下"无家可归"的文件（windows下叫什么.chk）就在这里。

四. Linux基本命令

4.1 目录切换命令

cd usr：切换到该目录下usr目录
cd ..（或cd../）：切换到上一层目录
cd /：切换到系统根目录
cd ~：切换到用户主目录
cd -：切换到上一个操作所在目录

4.2 目录的操作命令(增删改查)

mkdir 目录名称：增加目录
ls或者ll（ll是ls -l的别名，ll命令可以看到该目录下的所有目录和文件的详细信息）：查看目录信息
find 目录参数：寻找目录（查）
示例：
- 列出当前目录及子目录下所有文件和文件夹: find.
- 在/home目录下查找以.txt结尾的文件名:find /home -name "*.txt"
- 同上，但忽略大小写: find /home -iname "*.txt"
- 当前目录及子目录下查找所有以.txt和.pdf结尾的文件:find . $ -name "*.txt" -o -name "*.pdf" $ 或 find . -name "*.txt" -o -name "*.pdf"
mv 目录名称新目录名称：修改目录的名称（改）
注意：mv的语法不仅可以对目录进行重命名而且也可以对各种文件，压缩包等进行重命名的操作。mv命令用来对文件或目录重新命名，或者将文件从一个目录移到另一个目录中。后面会介绍到mv命令的另一个用法。
mv 目录名称目录的新位置：移动目录的位置---剪切（改）
注意：mv语法不仅可以对目录进行剪切操作，对文件和压缩包等都可执行剪切操作。另外mv与cp的结果不同，mv好像文件"搬家"，文件个数并未增加。而cp对文件进行复制，文件个数增加了。
cp -r 目录名称目录拷贝的目标位置：拷贝目录（改），-r代表递归拷贝
注意：cp命令不仅可以拷贝目录还可以拷贝文件，压缩包等，拷贝文件和压缩包时不用写-r 递归
rm [-rf] 目录: 删除目录（删）注意：rm不仅可以删除目录，也可以删除其他文件或压缩包，为了增强大家的记忆，无论删除任何目录或文件，都直接使用rm -rf 目录/文件/压缩包

4.3 文件的操作命令(增删改查)

touch 文件名称: 文件的创建（增）
cat/more/less/tail 文件名称 : 文件的查看（查）

cat：查看显示文件内容
more：可以显示百分比，回车可以向下一行，空格可以向下一页，q可以退出查看
less：可以使用键盘上的PgUp和PgDn向上和向下翻页，q结束查看
tail-10 ：查看文件的后10行，Ctrl+C结束
注意：命令 tail -f 文件可以对某个文件进行动态监控，例如tomcat的日志文件，会随着程序的运行，日志会变化，可以使用tail -f catalina-2016-11-11.log 监控文件的变化

vim 文件：修改文件的内容（改）
vim编辑器是Linux中的强大组件，是vi编辑器的加强版，vim编辑器的命令和快捷方式有很多，但此处不一一阐述，大家也无需研究的很透彻，使用vim编辑修改文件的方式基本会使用就可以了。
在实际开发中，使用vim编辑器主要作用就是修改配置文件，下面是一般步骤：vim 文件------>进入文件----->命令模式------>按i进入编辑模式----->编辑文件 ------->按Esc进入底行模式----->输入:wq/q! （输入wq代表写入内容并退出，即保存；输入q!代表强制退出不保存。）
rm -rf 文件：删除文件（删）
同目录删除：熟记 rm -rf 文件即可

4.4 压缩文件的操作命令

1）打包并压缩文件：
Linux中的打包文件一般是以.tar结尾的，压缩的命令一般是以.gz结尾的。
而一般情况下打包和压缩是一起进行的，打包并压缩后的文件的后缀名一般.tar.gz。
命令：tar -zcvf 打包压缩后的文件名要打包压缩的文件 其中：
z：调用gzip压缩命令进行压缩
c：打包文件
v：显示运行过程
f：指定文件名

比如：加入test目录下有三个文件分别是 :aaa.txt bbb.txt ccc.txt,如果我们要打包test目录并指定压缩后的压缩包名称为test.tar.gz可以使用命令：tar -zcvf test.tar.gz aaa.txt bbb.txt ccc.txt或：tar -zcvf test.tar.gz /test/

2）解压压缩包：

命令：tar [-xvf] 压缩文件

其中：x：代表解压

示例：

1 将/test下的test.tar.gz解压到当前目录下可以使用命令：tar -xvf test.tar.gz

2 将/test下的test.tar.gz解压到根目录/usr下: tar -xvf xxx.tar.gz -C /usr（- C代表指定解压的位置）

4.5 Linux的权限命令

操作系统中每个文件都拥有特定的权限、所属用户和所属组。权限是操作系统用来限制资源访问的机制，在Linux中权限一般分为读(readable)、写(writable)和执行(excutable)，分为三组。分别对应文件的属主(owner)，属组(group)和其他用户(other)，通过这样的机制来限制哪些用户、哪些组可以对特定的文件进行什么样的操作。通过 ls -l 命令我们可以查看某个目录下的文件或目录的权限

文件的类型：

d：代表目录
-：代表文件
l：代表软链接（可以认为是window中的快捷方式）

Linux中权限分为以下几种：

r：代表权限是可读，r也可以用数字4表示
w：代表权限是可写，w也可以用数字2表示
x：代表权限是可执行，x也可以用数字1表示

文件和目录权限的区别：

对文件和目录而言，读写执行表示不同的意义。
对于文件：

权限名称	可执行操作
r	可以使用cat查看文件的内容
w	可以修改文件的内容
x	可以将其运行为二进制文件

对于目录：

权限名称	可执行操作
r	可以查看目录下列表
w	可以创建和删除目录下文件
x	可以使用cd进入目录

文件所有者/组

需要注意的是超级用户可以无视普通用户的权限，即使文件目录权限是000，依旧可以访问。 在linux中的每个用户必须属于一个组，不能独立于组外。在linux中每个文件有所有者、所在组、其它组的概念。

drwxr-xr-x 2 root root 48 2013-11-27 16:34 test/

第二个栏位，表示文件个数。如果是文件的话，那这个数目自然是1了，如果是目录的话，那它的数目就是该目录中的文件个数了。
第三个栏位，表示该文件或目录的拥有者。若使用者目前处于自己的Home,那这一栏大概都是它的账号名称。
第四个栏位，表示所属的组（group）。每一个使用者都可以拥有一个以上的组，不过大部分的使用者应该都只属于一个组，只有当系统管理员希望给予某使用者特殊权限时，才可能会给他另一个组。

所有者 u
一般为文件的创建者，谁创建了该文件，就天然的成为该文件的所有者，用ls ‐ahl命令可以看到文件的所有者也可以使用chown 用户名文件名来修改文件的所有者。
文件所在组 g
当某个用户创建了一个文件后，这个文件的所在组就是该用户所在的组用ls ‐ahl命令可以看到文件的所有组也可以使用chgrp 组名文件名来修改文件所在的组。
其它组 o
除开文件的所有者和所在组的用户外，系统的其它用户都是文件的其它组

修改文件/目录的权限的命令：

chmod

chmod u+x,g+w f01　　//为文件f01设置自己可以执行，组员可以写入的权限
chmod u=rwx,g=rw,o=r f01  //rwxrw-r--
chmod 764 f01   // rwxrw-r--
chmod a+x f01　　//对文件f01的u,g,o都设置可执行属性

增加服务并开机启动

服务脚本必须存放在 /etc/ini.d/ 目录下；
chkconfig --add servicename在chkconfig工具服务列表中增加此服务，此时服务会被在/etc/rc.d/rcN.d中赋予K/S入口了；
chkconfig servicename on 修改服务的默认启动等级。

4.6 Linux 用户管理

Linux系统是一个多用户多任务的分时操作系统，任何一个要使用系统资源的用户，都必须首先向系统管理员申请一个账号，然后以这个账号的身份进入系统。

用户的账号一方面可以帮助系统管理员对使用系统的用户进行跟踪，并控制他们对系统资源的访问；另一方面也可以帮助用户组织文件，并为用户提供安全性保护。

Linux用户管理相关命令:

useradd 选项用户名:添加用户账号
userdel 选项用户名:删除用户帐号
usermod 选项用户名:修改帐号
passwd 用户名:更改或创建用户的密码
passwd -S 用户名 :显示用户账号密码信息
passwd -d 用户名: 清除用户密码

使用useradd指令所建立的帐号，实际上是保存在/etc/passwd文本文件中。
passwd命令用于设置用户的认证信息，包括用户密码、密码过期时间等。系统管理者则能用它管理系统用户的密码。只有管理者可以指定用户名称，一般用户只能变更自己的密码。

4.7 Linux系统用户组的管理

每个用户都有一个用户组，系统可以对一个用户组中的所有用户进行集中管理。不同Linux 系统对用户组的规定有所不同，如Linux下的用户属于与它同名的用户组，这个用户组在创建用户时同时创建。

用户组的管理涉及用户组的添加、删除和修改。组的增加、删除和修改实际上就是对/etc/group文件的更新。

Linux系统用户组的管理相关命令:

groupadd 选项用户组 :增加一个新的用户组
groupdel 用户组:要删除一个已有的用户组
groupmod 选项用户组 : 修改用户组的属性

4.8 其他常用命令

pwd：显示当前所在位置
grep 要搜索的字符串要搜索的文件 --color：搜索命令，--color代表高亮显示
ps -ef/ps -aux：这两个命令都是查看当前系统正在运行进程，两者的区别是展示格式不同。如果想要查看特定的进程可以使用这样的格式：ps -aux | grep redis （查看包括redis字符串的进程），也可使用 pgrep redis -a。
注意：如果直接用ps（（Process Status））命令，会显示所有进程的状态，通常结合grep命令查看某进程的状态。
kill -9 进程的pid：杀死进程（-9 表示强制终止。）先用ps查找进程，然后用kill杀掉

网络通信命令：

查看当前系统的网卡信息：ifconfig
查看与某台机器的连接情况：ping
查看当前系统的端口使用：netstat -an

系统服务：

1.启动nfs服务 systemctl start nfs-server.service
2.设置开机自启动 systemctl enable nfs-server.service
3.停止开机自启动 systemctl disable nfs-server.service
4.查看服务当前状态 systemctl status nfs-server.service
5.重新启动某服务 systemctl restart nfs-server.service
6.查看所有已启动的服务 systemctl list -units --type=service
1. 彻底关闭防火墙：
  sudo systemctl status firewalld.service
  sudo systemctl stop firewalld.service
  sudo systemctl disable firewalld.service

线程总结

2019-06-09T13:07:54.104000Z

一.线程入门
二. 线程安全
三. 线程间通信知识点补充
四. Lock锁的使用
五. 并发编程中一些问题
六. 线程池与Executor 框架

一.线程入门

1. 进程和多线程简介

1.1 何为进程？

进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。

一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。

进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序

1.2 何为线程？

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。

与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

线程是在同一程序内几乎同时执行一个以上的程序段。

1.3 线程和进程的关系

基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。
从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

线程上下文的切换比进程上下文切换要快很多

进程切换时，涉及到当前进程的CPU环境的保存和新被调度运行进程的CPU环境的设置。

线程切换仅需要保存和设置少量的寄存器内容，不涉及存储管理方面的操作。

1.4 线程有哪些基本状态？这些状态是如何定义的?

新建(new)：新创建了一个线程对象。
可运行(runnable)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu的使用权。
运行(running)：可运行状态(runnable)的线程获得了cpu时间片（timeslice），执行程序代码。
阻塞(block)：阻塞状态是指线程因为某种原因放弃了cpu使用权，也即让出了cpu timeslice（时间片），暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice转到运行(running)状态。阻塞的情况分三种：

(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waiting queue)中。

(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

(三). 其他阻塞: 运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

死亡(dead)：线程run()、main()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

1.5 线程的优先级

每个线程都具有各自的优先级，线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。

线程优先级具有继承特性比如A线程启动B线程，则B线程的优先级和A是一样的。
线程优先级具有随机性也就是说线程优先级高的不一定每一次都先执行完。

Thread类中包含的成员变量代表了线程的某些优先级。

如Thread.MIN_PRIORITY（常数1），Thread.NORM_PRIORITY（常数5）,
Thread.MAX_PRIORITY（常数10）。
其中每个线程的优先级都在Thread.MIN_PRIORITY（常数1）到Thread.MAX_PRIORITY（常数10）之间。
在默认情况下优先级都是Thread.NORM_PRIORITY（常数5）。

1.6 何为多线程？

多线程就是多个线程同时运行或交替运行。单核CPU的话是顺序执行，也就是交替运行。多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行。

1.7 为什么多线程是必要的？

开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能

1.8 为什么提倡多线程而不是多进程？

线程就是轻量级进程，是程序执行的最小单位。使用多线程而不是用多进程去进行并发程序的设计，是因为线程间的切换和调度的成本远远小于进程。

2. 几个重要的概念

2.1 同步和异步

同步和异步通常用来形容一次方法调用。

同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。
异步方法调用更像一个消息传递，一旦开始，方法调用就会立即返回，调用者可以继续后续的操作。

2.2 并发(Concurrency)和并行(Parallelism)

多线程在单核CPU的话是顺序执行，也就是交替运行（并发）。
多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行（并行）。

2.3 高并发

高并发（High Concurrency）是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够同时并行处理很多请求。

高并发相关常用的一些指标有响应时间（Response Time），吞吐量（Throughput），每秒查询率QPS（Query Per Second），并发用户数等。

2.4 临界区

2.5 阻塞和非阻塞

非阻塞指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回，而阻塞与之相反。

3. 多线程

3.1 使用多线程常见的三种方式

继承Thread类

实现Runnable接口

使用线程池

3.2 Java多线程分类

用户线程：运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程

守护线程：运行在后台，为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 "佣人"。
特点：一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作
应用：数据库连接池中的检测线程，JVM虚拟机启动后的检测线程
最常见的守护线程：垃圾回收线程

3.3 如何设置守护线程？

通过调用Thead类的setDaemon(true)方法设置当前的线程为守护线程

1. setDaemon(true)必须在start()方法前执行，否则会抛出IllegalThreadStateException异常 
2.  在守护线程中产生的新线程也是守护线程 
3.  不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑

4. 一些常用方法

4.1 currentThread()

返回对当前正在执行的线程对象的引用。

4.2 getId()

返回此线程的标识符

4.3 getName()

返回此线程的名称

4.4 getPriority()

返回此线程的优先级

4.5 isAlive()

测试这个线程是否还处于活动状态。
什么是活动状态呢？
活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备运行的状态。

4.6 sleep(long millis)

使当前正在执行的线程以指定的毫秒数"休眠"（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。

4.7 interrupt()

中断这个线程。

4.8 interrupted() 和isInterrupted()

interrupted()：测试当前线程是否已经是中断状态，执行后具有将状态标志清除为false的功能
isInterrupted()：测试线程Thread对相关是否已经是中断状态，但部清楚状态标志

4.9 setName(String name)

将此线程的名称更改为等于参数 name 。

4.10 isDaemon()

测试这个线程是否是守护线程。

4.11 setDaemon(boolean on)

将此线程标记为 daemon线程或用户线程。

4.12 join()

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

join()的作用是："等待该线程终止"，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行

4.13 yield()

yield()方法的作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU时间。注意：放弃的时间不确定，可能一会就会重新获得CPU时间片。

4.14 setPriority(int newPriority)

更改此线程的优先级

二. 线程安全

0. 锁

0.1 为什么需要锁（并发控制）？

在多用户环境中，在同一时间可能会有多个用户更新相同的记录，这会产生冲突。这就是著名的并发性问题。

典型的冲突有：

丢失更新：一个事务的更新覆盖了其它事务的更新结果，就是所谓的更新丢失。例如：用户A把值从6改为2，用户B把值从2改为6，则用户A丢失了他的更新。

脏读：当一个事务读取其它完成一半事务的记录时，就会发生脏读取。例如：用户A,B看到的值都是6，用户B把值改为2，用户A读到的值仍为6。

为了解决这些并发带来的问题。我们需要引入并发控制机制。

0.2 并发控制机制（锁）

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。

传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。

乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。

在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

0.3 两种锁的使用场景

乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。

但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

0.4 乐观锁的缺点

ABA 问题
如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回A，那CAS操作就会误认为它从来没有被修改过。这个问题被称为CAS操作的 "ABA"问题。

循环时间长开销大
自旋CAS（也就是不成功就一直循环执行直到成功）如果长时间不成功，会给CPU带来非常大的执行开销。

只能保证一个共享变量的原子操作
CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 无效。

0.5 乐观锁与悲观锁详解

乐观锁与悲观锁详解

1. synchronized关键字(1)

synchronized关键字1

synchronized

Java并发编程这个领域中synchronized关键字一直都是元老级的角色，很久之前很多人都会称它为 "重量级锁" 。
但是，在JavaSE 1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的 偏向锁和 轻量级锁 以及其它各种优化之后变得在某些情况下并不是那么重了。synchronized的底层实现主要依靠 Lock-Free 的队列，基本思路是 自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但获得了高吞吐量。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS。

1.1 变量安全性

"非线程安全"(线程不安全) 问题存在于"实例变量"中，如果是方法内部的私有变量，则不存在"非线程安全"，所得结果也就是"线程安全"的了。
如果两个线程同时操作对象中的实例变量，则会出现"非线程安全"，解决办法就是在方法前加上synchronized关键字即可。

1.2 多个对象对个锁

synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁。所以在上面的实例中，哪个线程先执行带synchronized关键字的方法，则哪个线程就持有该方法所属对象的锁Lock，那么其他线程只能呈等待状态，前提是多个线程访问的是同一个对象。

1.3 synchronized方法与锁对象

synchronized取得的锁都是对象锁，而不是把一段代码或方法当做锁。如果多个线程访问的是同一个对象，哪个线程先执行带synchronized关键字的方法，则哪个线程就持有该方法，那么其他线程只能呈等待状态。
如果多个线程访问的是多个对象则不一定，因为多个对象会产生多个锁。

1.4 脏读

发生脏读的情况是在读取实例变量时，此值已经被其他线程更改过。

代码没有做同步，虽然set方法同步，但是由于get方法一般都会忘了，导致读的值是被写过的

1.5 synchronized锁重入

可重入锁"概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。

1.6 同步不具有继承性

如果父类有一个带synchronized关键字的方法，子类继承并重写了这个方法。但是同步不能继承，所以还是需要在子类方法中添加synchronized关键字。

2. synchronized关键字（2）

synchronized关键字2

2.1 synchronized方法的缺点

使用synchronized关键字声明方法有些时候是有很大的弊端的，比如我们有两个线程一个线程A调用同步方法后获得锁，那么另一个线程B就需要等待A执行完，但是如果说A执行的是一个很费时间的任务的话这样就会很耗时。

可以使用synchronized同步块来解决这个问题。但是要注意synchronized同步块的使用方式，如果synchronized同步块使用不好的话并不会带来效率的提升。

2.2 synchronized（this）同步代码块的使用

public class Task {

    private String getData1;
    private String getData2;

    public void doLongTimeTask() {
        try {
            System.out.println("begin task");
            Thread.sleep(3000);

            String privateGetData1 = "长时间处理任务后从远程返回的值1 threadName="
                    + Thread.currentThread().getName();
            String privateGetData2 = "长时间处理任务后从远程返回的值2 threadName="
                    + Thread.currentThread().getName();

            synchronized (this) {
                getData1 = privateGetData1;
                getData2 = privateGetData2;
            }

            System.out.println(getData1);
            System.out.println(getData2);
            System.out.println("end task");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

当一个线程访问一个对象的synchronized同步代码块时，另一个线程任然可以访问该对象非synchronized同步代码块。
不在synchronized代码块中就异步执行，在synchronized代码块中就是同步执行。

2.3 synchronized（object）代码块间使用

两个线程使用了同一个"对象监视器",所以运行结果是同步的。
两个线程使用了不同的"对象监视器",所以运行结果不是同步的了。

2.4 synchronized代码块间的同步性

当一个对象访问synchronized(this)代码块时，其他线程对同一个对象中所有其他synchronized(this)代码块代码块的访问将被阻塞，这说明synchronized(this)代码块使用的"对象监视器"是同一个。
和synchronized方法一样，synchronized(this)代码块也是锁定当前对象。

其他线程执行对象中synchronized同步方法和synchronized(this)代码块时呈现同步效果;

如果两个线程使用了同一个"对象监视器",运行结果同步，否则不同步.

2.5 静态同步synchronized方法与synchronized(class)代码块

synchronized关键字加到static静态方法和synchronized(class)代码块上都是是给Class类上锁，而synchronized关键字加到非静态方法上是给对象上锁。
静态同步synchronized方法与synchronized(class)代码块持有的锁一样，都是Class锁，Class锁对对象的所有实例起作用。

3. volatile关键字

volatile关键字

3.1 volatile关键字简介

volatile关键字可以用来提醒编译器它后面所定义的变量随时有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数。
如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。

3.2 volatile关键字的可见性

volatile 修饰的成员变量在每次被线程访问时，都强迫从主存（共享内存）中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到主存（共享内存）。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值，这样也就保证了同步数据的可见性。

3.3 synchronized关键字和volatile关键字比较

volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用synchronized关键字还是更多一些。
多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
volatile关键字用于解决变量在多个线程之间的可见性，而ynchronized关键字解决的是多个线程之间访问资源的同步性。

4. 等待/通知（wait/notify）机制

4.1 等待/通知机制介绍

为什么要使用等待/通知机制？

当两个线程之间存在生产和消费者关系，也就是说第一个线程（生产者）做相应的操作然后第二个线程（消费者）感知到了变化又进行相应的操作。
第二个语句不停过通过轮询机制来检测判断条件是否成立。如果轮询时间的间隔太小会浪费CPU资源，轮询时间的间隔太大，就可能取不到自己想要的数据。所以这里就需要我们今天讲到的等待/通知（wait/notify）机制来解决这两个矛盾。

概念

等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()/notifyAll()方法，线程A收到通知后退出等待队列，进入可运行状态，进而执行后续操作。上诉两个线程通过对象O来完成交互，而对象上的wait()方法和notify()/notifyAll()方法的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

4.2 等待/通知机制的实现

notify()执行后并不会立即释放锁
synchronized关键字可以将任何一个Object对象作为同步对象来看待，而Java为每个Object都实现了等待/通知（wait/notify）机制的相关方法，它们必须用在synchronized关键字同步的Object的临界区内。
通过调用wait()方法可以使处于临界区内的线程进入等待状态，同时释放被同步对象的锁。
而notify()方法可以唤醒一个因调用wait操作而处于阻塞状态中的线程，使其进入就绪状态。
被重新唤醒的线程会试图重新获得临界区的控制权也就是锁，并继续执行wait方法之后的代码。

4.3 notify()锁不释放

当方法wait()被执行后，锁自动被释放，但执行完notify()方法后，锁不会自动释放。必须执行完notify()方法所在的synchronized代码块后才释放。

三. 线程间通信知识点补充

线程通信知识补充

1. 管道输入/输出流

管道输入/输出流主要用于线程之间的数据传输，而且传输的媒介为内存。
管道输入/输出流主要包括下列两类的实现：

面向字节： PipedOutputStream、 PipedInputStream

面向字符: PipedWriter、 PipedReader

2. Thread.join()的使用

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。另外，一个线程需要等待另一个线程也需要用到join()方法。
Thread类除了提供join()方法之外，还提供了join(long millis)、join(long millis, int nanos)两个具有超时特性的方法。这两个超时方法表示，如果线程thread在指定的超时时间没有终止，那么将会从该超时方法中返回。
Thread.sleep(2000)不会释放锁，threadTest.join(2000)会释放锁。

3. ThreadLocal的使用

3.1 ThreadLocal介绍

变量值的共享可以使用public static变量的形式，所有线程都使用一个public static变量。如果想实现每一个线程都有自己的共享变量该如何解决呢？
JDK中提供的ThreadLocal类正是为了解决这样的问题。ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

3.2 ThreadLocal方法

方法名称	描述
get()	返回当前线程的此线程局部变量的副本中的值。
set(T value)	将当前线程的此线程局部变量的副本设置为指定的值
remove()	删除此线程局部变量的当前线程的值
initialValue()	返回此线程局部变量的当前线程的"初始值"

3.3 InheritableThreadLocal

ThreadLocal类固然很好，但是子线程并不能取到父线程的ThreadLocal类的变量，InheritableThreadLocal类就是解决这个问题的。
在使用InheritableThreadLocal类需要注意的一点是：如果子线程在取得值的同时，主线程将InheritableThreadLocal中的值进行更改，那么子线程取到的还是旧值。

四. Lock锁的使用

lock锁的使用

1 Lock接口

1.1 Lock接口简介

锁是用于通过多个线程控制对共享资源的访问的工具。
通常，锁提供对共享资源的独占访问：一次只能有一个线程可以获取锁，并且对共享资源的所有访问都要求首先获取锁。
但是，一些锁可能允许并发访问共享资源，如ReadWriteLock的读写锁。

在Lock接口出现之前，Java程序是靠synchronized关键字实现锁功能的。JDK1.5之后并发包中新增了Lock接口以及相关实现类来实现锁功能。

Lock接口的实现类：

ReentrantLock

ReentrantReadWriteLock.ReadLock

ReentrantReadWriteLock.WriteLock

1.2. Lock的简单使用

 Lock lock = new ReentrantLock()； 
 lock.lock(); 
 try{ 
 }finally{ 
 lock.unlock(); 
 }

因为Lock是接口所以使用时要结合它的实现类，另外在finall语句块中释放锁的目的是保证获取到锁之后，最终能够被释放。
注意：最好不要把获取锁的过程写在try语句块中，因为如果在获取锁时发生了异常，异常抛出的同时也会导致锁无法被释放。

1.3. Lock接口的特性和常见方法

Lock接口提供的synchronized关键字不具备的主要特性：

特性	描述
尝试非阻塞地获取锁	当前线程尝试获取锁，如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁
能被中断地获取锁	获取到锁的线程能够响应中断，当获取到锁的线程被中断时，中断异常将会被抛出，同时锁会被释放
超时获取锁	在指定的截止时间之前获取锁，超过截止时间后仍旧无法获取则返回

Lock接口基本的方法：

方法名称	描述
void lock()	获得锁。如果锁不可用，则当前线程将被禁用以进行线程调度，并处于休眠状态，直到获取锁。
void lockInterruptibly()	获取锁，如果可用并立即返回。如果锁不可用，那么当前线程将被禁用以进行线程调度，并且处于休眠状态，和lock()方法不同的是在锁的获取中可以中断当前线程（相应中断）。
Condition newCondition()	获取等待通知组件，该组件和当前的锁绑定，当前线程只有获得了锁，才能调用该组件的wait()方法，而调用后，当前线程将释放锁。
boolean tryLock()	只有在调用时才可以获得锁。如果可用，则获取锁定，并立即返回值为true；如果锁不可用，则此方法将立即返回值为false 。
boolean tryLock(long time, TimeUnit unit)	超时获取锁，当前线程在一下三种情况下会返回： 1. 当前线程在超时时间内获得了锁；2.当前线程在超时时间内被中断；3.超时时间结束，返回false.
void unlock()	释放锁。

2. Lock接口的实现类：ReentrantLock

ReentrantLock和synchronized关键字一样可以用来实现线程之间的同步互斥，但是在功能是比synchronized关键字更强大而且更灵活。

2.1 ReentrantLock类常见方法

构造方法：

方法名称	描述
ReentrantLock()	创建一个 ReentrantLock的实例。
ReentrantLock(boolean fair)	创建一个特定锁类型（公平锁/非公平锁）的ReentrantLock的实例

ReentrantLock类常见方法(Lock接口已有方法这里没加上)：

方法名称	描述
int getHoldCount()	查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。
protected Thread getOwner()	返回当前拥有此锁的线程，如果不拥有，则返回 null
protected Collection getQueuedThreads()	返回包含可能正在等待获取此锁的线程的集合
int getQueueLength()	返回等待获取此锁的线程数的估计。
protected Collection getWaitingThreads(Condition condition)	返回包含可能在与此锁相关联的给定条件下等待的线程的集合。
int getWaitQueueLength(Condition condition)	返回与此锁相关联的给定条件等待的线程数的估计。
boolean hasQueuedThread(Thread thread)	查询给定线程是否等待获取此锁。
boolean hasQueuedThreads()	查询是否有线程正在等待获取此锁。
boolean hasWaiters(Condition condition)	查询任何线程是否等待与此锁相关联的给定条件
boolean isFair()	如果此锁的公平设置为true，则返回 true 。
boolean isHeldByCurrentThread()	查询此锁是否由当前线程持有。
boolean isLocked()	查询此锁是否由任何线程持有。

2.2 第一个ReentrantLock程序

当一个线程运行完毕后才把锁释放，其他线程才能执行，其他线程的执行顺序是不确定的。

3. Condition接口简介

synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。
Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。
在使用notify/notifyAll()方法进行通知时，被通知的线程是有JVM选择的，使用ReentrantLock类结合Condition实例可以实现"选择性通知"，这个功能非常重要，而且是Condition接口默认提供的。

Condition接口的常见方法：

方法名称	描述
void await()	相当于Object类的wait方法
boolean await(long time, TimeUnit unit)	相当于Object类的wait(long timeout)方法
signal()	相当于Object类的notify方法
signalAll()	相当于Object类的notifyAll方法

synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法只会唤醒注册在该Condition实例中的所有等待线程

3.1 使用Condition实现等待/通知机制

使用单个Condition实例实现等待/通知机制：

必须执行完signal所在的try语句块之后才释放锁，condition.await()后的语句才能被执行。

注意：必须在condition.await()方法调用之前调用lock.lock()代码获得同步监视器，不然会报错。

使用多个Condition实例实现等待/通知机制：

实现"选择性通知",只会唤醒注册在指定Condition实例中的所有等待线程

使用Condition实现顺序执行

在一个线程运行完之后通过condition.signal()/condition.signalAll()方法通知下一个特定的线程运行，就这样循环往复即可。

注意：默认情况下ReentranLock类使用的是非公平锁

4. 公平锁与非公平锁

Lock锁分为：公平锁和非公平锁。

公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。

而非公平锁就是一种获取锁的抢占机制，是随机获取锁的，和公平锁不一样的就是先来的不一定先的到锁，这样可能造成某些线程一直拿不到锁，结果也就是不公平的了。

5. ReadWriteLock接口的实现类：ReentrantReadWriteLock

5.1 简介

ReentrantLock（排他锁）具有完全互斥排他的效果，即同一时刻只允许一个线程访问，这样做虽然虽然保证了实例变量的线程安全性，但效率非常低下。
ReadWriteLock接口的实现类-ReentrantReadWriteLock读写锁就是为了解决这个问题。

读写锁维护了两个锁，一个是读操作相关的锁也成为共享锁，
一个是写操作相关的锁也称为排他锁。
通过分离读锁和写锁，其并发性比一般排他锁有了很大提升。

多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥（只要出现写操作的过程就是互斥的）
在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，
而进行写入操作的Thread只有在获取写锁后才能进行写入操作。
即多个Thread可以同时进行读取操作,但是同一时刻只允许一个Thread进行写入操作。

5.2 ReentrantReadWriteLock的特性与常见方法

ReentrantReadWriteLock的特性：

特性	说明
公平性选择	支持非公平（默认）和公平的锁获取方式，吞吐量上来看还是非公平优于公平
重进入	该锁支持重进入，以读写线程为例：读线程在获取了读锁之后，能够再次获取读锁。而写线程在获取了写锁之后能够再次获取写锁也能够同时获取读锁
锁降级	遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级称为读锁

ReentrantReadWriteLock常见方法：
构造方法

方法名称	描述
ReentrantReadWriteLock()	创建一个 ReentrantReadWriteLock()的实例
ReentrantReadWriteLock(boolean fair)	创建一个特定锁类型（公平锁/非公平锁）的ReentrantReadWriteLock的实例

常见方法：
和ReentrantLock类类似

5.3 ReentrantReadWriteLock的使用

读读共享

两个线程同时运行read方法，你会发现两个线程可以同时或者说是几乎同时运行lock()方法后面的代码，输出的两句话显示的时间一样。这样提高了程序的运行效率。
写写互斥

两个线程同时运行write方法，你会发现同一时间只允许一个线程执行lock()方法后面的代码
读写互斥（读写互斥）
运行两个使用同一个Service对象实例的线程a,b，线程a执行上面的read方法，线程b执行上面的write方法。你会发现同一时间只允许一个线程执行lock()方法后面的代码。
- 记住：只要出现写操作的过程就是互斥的。

五. 并发编程中一些问题

并发编程的问题

1. 多线程就一定好吗？快吗？？

并发编程的目的就是为了能提高程序的执行效率提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，
比如：内存泄漏、上下文切换、死锁还有受限于硬件和软件的资源闲置问题。
多线程就是几乎同时执行多个线程（一个处理器在某一个时间点上永远都只能是一个线程！即使这个处理器是多核的，除非有多个处理器才能实现多个线程同时运行）。CPU通过给每个线程分配CPU时间片来实现伪同时运行，因为CPU时间片一般很短很短，所以给人一种同时运行的感觉。

2. 上下文切换

当前任务在执行完CPU时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换会这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。

上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。

2.1 减少上下文切换

上下文切换又分为2种：

让步式上下文切换
指执行线程主动释放CPU，与锁竞争严重程度成正比，可通过减少锁竞争和使用CAS算法来避免；

抢占式上下文切换。
指线程因分配的时间片用尽而被迫放弃CPU或者被其他优先级更高的线程所抢占，一般由于线程数大于CPU可用核心数引起，可通过适当减少线程数和使用协程来避免。

总结一下：

减少锁的使用。因为多线程竞争锁时会引起上下文切换。
使用CAS算法。这种算法也是为了减少锁的使用。CAS算法是一种无锁算法。
减少线程的使用。人物很少的时候创建大量线程会导致大量线程都处于等待状态。
使用协程。

2.2 CAS算法

CAS（比较与交换，Compare and swap）是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。
实现非阻塞同步的方案称为"无锁编程算法"（ Non-blocking algorithm）。属于乐观锁。

CAS算法涉及到三个操作数

需要读写的内存值V

进行比较的值A

拟写入的新值B

当且仅当 V 的值等于 A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。

2.3 协程

协程也可以说是微线程或者说是轻量级的线程，它占用的内存更少并且更灵活。很多编程语言中都有协程。

3. 避免死锁

3.1 如何产生的死锁

在操作系统中，死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

在线程中，如果两个线程同时等待对方释放锁也会产生死锁。

3.2 避免死锁的常见方法

避免一个线程同时获得多个锁

避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源

尝试使用定时锁，使用lock.tryLock(timeout)来替代使用内部锁机制

对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况

3.3 解决资源限制

什么是资源限制？

所谓资源限制就是我们在进行并发编程时，程序的运行速度受限于计算机硬件资源比如CPU,内存等等或软件资源比如软件的质量、性能等等。举个例子：如果说服务器的带宽只有2MB/s，某个资源的下载速度是1MB/s，系统启动10个线程下载该资源并不会导致下载速度编程10MB/s，所以在并发编程时，需要考虑这些资源的限制。硬件资源限制有：带宽的上传和下载速度、硬盘读写速度和CPU处理速度；软件资源限制有数据库的连接数、socket连接数、软件质量和性能等等。

资源限制引发的问题

在并发编程中，程序运行加快的原因是运行方式从串行运行变为并发运行，但是如果某段程序的并发执行由于资源限制仍然在串行执行的话，这时候程序的运行不仅不会加快，反而会更慢，因为可能增加了上下文切换和资源调度的时间。

3.如何解决资源限制的问题

对于硬件资源限制，可以考虑使用集群并行执行程序。既然单机的资源有限制，那么就让程序在多机上运行。比如使用Hadoop或者自己搭建服务器集群。
对于软件资源的限制，可以考虑使用资源池将资源复用。比如使用连接池将数据库和Socket复用，或者在调用对方webservice接口获取数据时，只建立一个连接。另外还可以考虑使用良好的开源软件。

在资源限制的情况下如何进行并发编程

根据不同的资源限制调整程序的并发度，比如下载文件程序依赖于两个资源-带宽和硬盘读写速度。有数据库操作时，设计数据库练连接数，如果SQL语句执行非常快，而线程的数量比数据库连接数大很多，则某些线程会被阻塞，等待数据库连接。

六. 线程池与Executor 框架

线程池与Executor框架

1. 使用线程池的好处

线程池提供了一种限制和管理资源（包括执行一个任务）。每个线程池还维护一些基本统计信息

使用线程池的好处

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

2. Executor 框架

2.1 Executor 简介

this逃逸是指在构造函数返回之前其他线程就持有该对象的引用. 调用尚未构造完全的对象的方法可能引发令人疑惑的错误。

2.2 Executor 框架结构(主要由三大部分组成)

1 任务

执行任务需要实现的Runnable接口或Callable接口。Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。

两者的区别：

Runnable接口不会返回结果,但是Callable接口可以返回结果。后面介绍Executors类的一些方法的时候会介绍到两者的相互转换。

2 任务的执行

包括任务执行机制的核心接口Executor ，以及继承自Executor 接口的ExecutorService接口。
ScheduledThreadPoolExecutor和ThreadPoolExecutor这两个关键类实现了ExecutorService接口。

3 异步计算的结果

Future接口以及Future接口的实现类FutureTask类。
当我们把Runnable接口或Callable接口的实现类提交（调用submit方法）给ThreadPoolExecutor或ScheduledThreadPoolExecutor时，会返回一个FutureTask对象。

2.3 Executor 框架的使用示意图

主线程首先要创建实现Runnable或者Callable接口的任务对象。

备注：工具类Executors可以实现Runnable对象和Callable对象之间的相互转换。（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule））
然后可以把创建完成的Runnable对象直接交给ExecutorService执行（ExecutorService.execute（Runnable command））；或者也可以把Runnable对象或Callable对象提交给ExecutorService执行（ExecutorService.submit（Runnable task）或ExecutorService.submit（Callable task））

执行execute()方法和submit()方法的区别是什么呢？
1)execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
2)submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完
如果执行ExecutorService.submit（…），ExecutorService将返回一个实现Future接口的对象（我们刚刚也提到过了执行execute()方法和submit()方法的区别，到目前为止的JDK中，返回的是FutureTask对象）。由于FutureTask实现了Runnable，程序员也可以创建FutureTask，然后直接交给ExecutorService执行。
最后，主线程可以执行FutureTask.get()方法来等待任务执行完成。主线程也可以执行FutureTask.cancel（boolean mayInterruptIfRunning）来取消此任务的执行。

3. ThreadPoolExecutor详解

线程池实现类ThreadPoolExecutor是Executor 框架最核心的类

3.1 ThreadPoolExecutor类的四个比较重要的属性

3.2 ThreadPoolExecutor类中提供的四个构造方法

 /**
     * 用给定的初始参数创建一个新的ThreadPoolExecutor。
     
     * @param corePoolSize 核心线程池大小
     
     * @param maximumPoolSize 最大线程池的大小
     
     * @param keepAliveTime 当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，
     *核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime；
     
     * @param unit  keepAliveTime参数的时间单位
     
     * @param workQueue 等待队列，当任务提交时，如果线程池中的线程数量大于等于corePoolSize的时候，把该任务封装成一个Worker对象放入等待队列；
     * 
     * @param threadFactory 执行者创建新线程时使用的工厂
     
     * @param handler RejectedExecutionHandler类型的变量，表示线程池的饱和策略。
     * 如果阻塞队列满了并且没有空闲的线程，这时如果继续提交任务，就需要采取一种策略处理该任务。
     * 线程池提供了4种策略：
        1.AbortPolicy：直接抛出异常，这是默认策略；
        2.CallerRunsPolicy：用调用者所在的线程来执行任务；
        3.DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
        4.DiscardPolicy：直接丢弃任务；
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

3.3 如何创建ThreadPoolExecutor

在《阿里巴巴Java开发手册》"并发处理"这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。

为什么呢？

使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者"过度切换"的问题。

Executors 返回线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadExecutor ：允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致OOM。

CachedThreadPool 和 ScheduledThreadPool ：允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。

方式一：通过构造方法实现

方式二：通过Executor 框架的工具类Executors来实现

我们可以创建三种类型的ThreadPoolExecutor：

FixedThreadPool
SingleThreadExecutor
CachedThreadPool
底层都是调用的ThreadPoolExecutor的构造方法

3.4 FixedThreadPool详解

FixedThreadPool被称为可重用固定线程数的线程池。

 /**
     * 创建一个可重用固定数量线程的线程池
	 *在任何时候至多有n个线程处于活动状态
	 *如果在所有线程处于活动状态时提交其他任务，则它们将在队列中等待，
	 *直到线程可用。 如果任何线程在关闭之前的执行期间由于失败而终止，
	 *如果需要执行后续任务，则一个新的线程将取代它。池中的线程将一直存在
	 *知道调用shutdown方法
     
     * @param nThreads 线程池中的线程数
     * @param threadFactory 创建新线程时使用的factory
     * @return 新创建的线程池
     * @throws NullPointerException 如果threadFactory为null
     * @throws IllegalArgumentException if {@code nThreads <= 0}
     */
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue(),
                                      threadFactory);
    }

 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

新创建的FixedThreadPool的corePoolSize和maximumPoolSize都被设置为nThreads。

FixedThreadPool的execute()方法运行示意图

上图说明：

如果当前运行的线程数小于corePoolSize，则创建新的线程来执行任务；

当前运行的线程数等于corePoolSize后，将任务加入LinkedBlockingQueue；

线程执行完1中的任务后，会在循环中反复从LinkedBlockingQueue中获取任务来执行；

FixedThreadPool使用无界队列 LinkedBlockingQueue（队列的容量为Intger.MAX_VALUE）作为线程池的工作队列会对线程池带来如下影响：

当线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize；

由于1，使用无界队列时maximumPoolSize将是一个无效参数；

由于1和2，使用无界队列时keepAliveTime将是一个无效参数；

运行中的FixedThreadPool（未执行shutdown()或shutdownNow()方法）不会拒绝任务

3.5 SingleThreadExecutor详解

SingleThreadExecutor是使用单个worker线程的Executor。

/**
     *创建使用单个worker线程运行无界队列的Executor
	 *并使用提供的ThreadFactory在需要时创建新线程
     *
     * @param threadFactory 创建新线程时使用的factory
     *
     * @return 新创建的单线程Executor
     * @throws NullPointerException 如果ThreadFactory为空
     */
    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue(),
                                    threadFactory));
    }

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }

SingleThreadExecutor使用无界队列作为线程池的工作队列会对线程池带来的影响与FixedThreadPool相同。

SingleThreadExecutor的运行示意图

上图说明:

如果当前运行的线程数少于corePoolSize，则创建一个新的线程执行任务；

当前线程池中有一个运行的线程后，将任务加入LinkedBlockingQueue

线程执行完1中的任务后，会在循环中反复从LinkedBlockingQueue中获取任务来执行；

3.6 CachedThreadPool详解

CachedThreadPool是一个会根据需要创建新线程的线程池。

/**
     * 创建一个线程池，根据需要创建新线程，但会在先前构建的线程可用时重用它，
	 *并在需要时使用提供的ThreadFactory创建新线程。
     * @param threadFactory 创建新线程使用的factory
     * @return 新创建的线程池
     * @throws NullPointerException 如果threadFactory为空
     */
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue(),
                                      threadFactory);
    }

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }

CachedThreadPool的execute()方法的执行示意图

上图说明：

首先执行SynchronousQueue.offer(Runnable task)。如果当前maximumPool中有闲线程正在执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)，那么主线程执行offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成，否则执行下面的步骤2；

当初始maximumPool为空，或者maximumPool中没有空闲线程时，将没有线程执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。这种情况下，步骤1将失败，此时CachedThreadPool会创建新线程执行任务，execute方法执行完成；

3.7 ThreadPoolExecutor使用示例

首先创建一个Runnable接口的实现类WorkerThread

public class ThreadPoolExecutorDemo {

   public static void main(String[] args) {
       //创建一个FixedThreadPool对象
       ExecutorService executor = Executors.newFixedThreadPool(5);
       for (int i = 0; i < 10; i++) {
           //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
           Runnable worker = new WorkerThread("" + i);
           //执行Runnable
           executor.execute(worker);
       }
       //终止线程池
       executor.shutdown();
       while (!executor.isTerminated()) {
       }
       System.out.println("Finished all threads");
   }
}

shutdown（）VS shutdownNow（）

shutdown（）方法表明关闭已在Executor上调用，因此不会再向DelayedPool添加任何其他任务（由ScheduledThreadPoolExecutor类在内部使用）, 但是，已经在队列中提交的任务将被允许完成。

shutdownNow（）方法试图终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的List。

isTerminated() Vs isShutdown()

isShutDown当调用shutdown()方法后返回为true。

isTerminated当调用shutdown()方法后，并且所有提交的任务完成后返回为true

4. ScheduledThreadPoolExecutor详解

4.1 ScheduledThreadPoolExecutor简介

ScheduledThreadPoolExecutor主要用来在给定的延迟后运行任务，或者定期执行任务。
ScheduledThreadPoolExecutor使用的任务队列DelayQueue封装了一个PriorityQueue，PriorityQueue会对队列中的任务进行排序，执行所需时间短的放在前面先被执行(ScheduledFutureTask的time变量小的先执行)，如果执行所需时间相同则先提交的任务将被先执行(ScheduledFutureTask的squenceNumber变量小的先执行)。

4.2 ScheduledThreadPoolExecutor运行机制

ScheduledThreadPoolExecutor的执行主要分为两大部分：

当调用ScheduledThreadPoolExecutor的 scheduleAtFixedRate() 方法或者scheduleWirhFixedDelay() 方法时，会向ScheduledThreadPoolExecutor的 DelayQueue 添加一个实现了 RunnableScheduledFutur 接口的 ScheduledFutureTask 。

线程池中的线程从DelayQueue中获取ScheduledFutureTask，然后执行任务。

ScheduledThreadPoolExecutor为了实现周期性的执行任务，对ThreadPoolExecutor做了如下修改：

使用 DelayQueue 作为任务队列；

获取任务的方不同

执行周期任务后，增加了额外的处理

4.3 ScheduledThreadPoolExecutor执行周期任务的步骤

线程1从DelayQueue中获取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任务是指ScheduledFutureTask的time大于等于当前系统的时间；

线程1执行这个ScheduledFutureTask；

线程1修改ScheduledFutureTask的time变量为下次将要被执行的时间；

线程1把这个修改time之后的ScheduledFutureTask放回DelayQueue中（DelayQueue.add())。

4.4 ScheduledThreadPoolExecutor使用示例

创建一个简单的实现Runnable接口的类
测试程序使用ScheduledExecutorService和Executors.newScheduledThreadPool实现的java调度

4.4.1 ScheduledExecutorService scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)方法

//可以使用ScheduledExecutorService scheduleAtFixedRate方法来安排任务在初始延迟后运行，然后在给定的时间段内运行。

scheduledThreadPool.scheduleAtFixedRate(worker, 0, 10, TimeUnit.SECONDS);

4.4.2 ScheduledExecutorService scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)方法

//ScheduledExecutorService scheduleWithFixedDelay方法可用于以初始延迟启动周期性执行，然后以给定延迟执行。 延迟时间是线程完成执行的时间。

scheduledThreadPool.scheduleWithFixedDelay(worker, 0, 1, TimeUnit.SECONDS);

4.4.3 scheduleWithFixedDelay() vs scheduleAtFixedRate()

scheduleAtFixedRate（…）将延迟视为两个任务开始之间的差异（即定期调用）
不管是否执行完
scheduleWithFixedDelay（…）将延迟视为一个任务结束与下一个任务开始之间的差异，执行完才开始下一个。

scheduleAtFixedRate(): 在给定的初始延迟之后创建并执行，随后以给定的时间段首先启用的周期性动作; 那就是执行将在initialDelay之后开始，然后initialDelay+period ，然后是initialDelay + 2 * period ，等等。如果任务的执行遇到异常，则后续的执行被抑制。否则，任务将仅通过取消或终止执行人终止。如果任务执行时间比其周期长，则后续执行可能会迟到，但不会同时执行。
scheduleWithFixedDelay() : 在给定的初始延迟之后创建并执行，首先启用的定期动作，随后在一个执行的终止和下一个执行的开始之间给定的延迟。如果任务的执行遇到异常，则后续的执行被抑制。否则，任务将仅通过取消或终止执行终止。

5. 各种线程池的适用场景介绍

FixedThreadPool：适用于为了满足资源管理需求，而需要限制当前线程数量的应用场景。它适用于负载比较重的服务器；

SingleThreadExecutor：适用于需要保证顺序地执行各个任务并且在任意时间点，不会有多个线程是活动的应用场景。

CachedThreadPool：适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器；

ScheduledThreadPoolExecutor：适用于需要多个后台执行周期任务，同时为了满足资源管理需求而需要限制后台线程的数量的应用场景，

SingleThreadScheduledExecutor：适用于需要单个后台线程执行周期任务，同时保证顺序地执行各个任务的应用场景。

树

2019-06-09T13:26:56.406000Z

树

一. 二叉树

1. 二叉树的基本概念

二叉树是每个结点最多有两个子树的树结构。通常子树被称作"左子树"（left subtree）和"右子树"（right subtree）。

一棵深度为k，且有2^k-1个节点的二叉树，称为满二叉树，这种树的特点是每一层上的节点数都是最大节点数。

1.1 二叉树基本形态

注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。
树和二叉树有两个主要差别：

树中结点的最大度数没有限制，而二叉树结点的最大度数为2；

树的结点无左、右之分，而二叉树的结点有左、右之分。

1.2 二叉树类型

(2)满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。

1.3 树的相关术语

结点的度：结点子树的个数
树的度：树中最大的结点度。
叶子结点：也叫终端结点，是度为 0 的结点；
分枝结点：度不为0的结点；

1.4 二叉树性质

(1) 在非空二叉树中，第i层的结点总数不超过 2^(i-1)

(2) 深度为h的二叉树最多有 2^h - 1 个结点,最少有h个结点

(3) 对于任意一棵二叉树，如果其叶子结点数为N0，而度数为2的结点总数为N2，则N0=N2+1；

(4)给定N个节点，能构成h(N)种不同的二叉树。
h(N)为卡特兰数的第N项。h(n)=C(2*n，n)/(n+1)

1.5 二叉树遍历

先序遍历
首先访问根，再先序遍历左（右）子树，最后先序遍历右（左）子树
中序遍历
首先中序遍历左（右）子树，再访问根，最后中序遍历右（左）子树
后序遍历
首先后序遍历左（右）子树，再后序遍历右（左）子树，最后访问根
层次遍历
即按照层次访问，通常用队列来做。访问根，访问子女，再访问子女的子女（越往后的层次越低）（两个子女的级别相同）

2. 完全二叉树

2.1 完全二叉树定义

若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。
完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。

(1)所有的叶结点都出现在第k层或k-l层（层次最大的两层）
(2)对任一结点，如果其右子树的最大层次为L，则其左子树的最大层次为L或L+l。

2.2 完全二叉树性质

假设n0是度为0的结点总数（即叶子结点数），n1是度为1的结点总数， n2是度为2的结点总数， n是结点总数则：

n0=n/2，其中n为奇数时（n1=0）向上取整；n为偶数时（n1=1）。可根据完全二叉树的结点总数计算出叶子结点数。

2.3 完全二叉树特点

2.4 完全二叉树存储

2.5 完全二叉树判定

3. 满二叉树

3.1 满二叉树定义

对于国内的满二叉树
1. 一个层数为k 的满二叉树总结点数为：2^k - 1,因此满二叉的结点树一定是奇数个。
2. 第i层上的结点数为：2^i -1 ;
3. 一个层数为k的满二叉树的叶子结点个数（也就是最后一层）:2^(k-1) ;
对于国外的满二叉树
满二叉树的任意节点，要么度为0，要么度为2.换个说法即要么为叶子结点，要么同时具有左右孩子。

4. 堆

4.1 堆的概念

堆是具有以下性质的完全二叉树：

每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；
或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

在一个堆有序的二叉树中，父节点的位置是K/2,它的两个子节点的位置是2k,2k+1。

4.2 堆的实现


//最大堆
public class MaxPQ {
    private List arr;      //定义一个数组
    private  int N;                   //定义队列中的元素个数

    public MaxPQ() {
        arr = new ArrayList();
        arr.add(1);
        N = 0;
    }

    public boolean isEmpty() {                   //方法，返回队列是否为空
        return N == 0;                                              
    }

    public int size() {                                 //方法，返回队列中元素的个数
        return N;
    }

    public void inSert(int number) {       //添加方法，添加元素到结合末尾，并且使用上浮方法到指定的位置
        arr.add(number);
        swim(++N);
    }

    public int deleteMax() {                //删除方法，删除最大元素并把最小的元素放到第一个，然后使用下浮方法
        int max = arr.get(1);
        int min  = arr.get(N);
        arr.set(1, min);
        arr.remove(N--);
        sink(1);
        return max;
    }
    //上浮
    public void swim(int N) {
        while(N > 1 && (arr.get(N/2) < arr.get(N))){
            int max = arr.get(N);
            int min = arr.get(N/2);
            arr.set(N,min );
            arr.set(N/2, max);
            N = N/2;
        }
    }
    //下沉
    public void sink(int number) {
        while(number*2 <= N) {
            int index = number*2;
            if(index < N && (arr.get(index) < arr.get(index + 1))) {
                index++;
            }
            if(!(arr.get(number) < arr.get(index))) {
                break;
            }
            int max = arr.get(index);
            int min = arr.get(number);
            arr.set(number, max);
            arr.set(index, min);
            number = index;
        }

    }

    @Override
    public String toString() {
        return "MaxPQ [arr=" + arr + ", N=" + N + "]";
    }
}

5. 二叉查找树(排序树)(Binary Search Tree，BST)

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于它的根节点点的值；
（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
（4）没有键值相等的节点。

例子：

二叉查找树例题

二叉树查找树的详细解析

6. 平衡二叉树(AVL树)

6.1 平衡二叉树定义

对于一般的二叉搜索树（Binary Search Tree），其期望高度（即为一棵平衡树时）为logN，其各操作的时间复杂度（O(logN)）同时也由此而决定。但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。
为了解决这个问题，要加上一个称为平衡的附加结构条件即：任何结点的深度不得过深
（子树高度相差不超过1），就是平衡二叉树（Balanced Binary Tree），它是G.M. Adelson-Velsky 和 E.M. Landis在1962年在论文中发表的，因此又叫AVL树。
AVL树只是实现平衡二叉树的一种方法，它还有很多的其他实现方法如红黑树、替罪羊树、Treap、伸展树等

6.2 平衡二叉树性质

6.3 平衡二叉树的设计

理解了平衡二叉树的概念后，我们在思考一下，那些操作可能引起平衡发生变化呢？
显然只有那些引起结点数量变化的操作才可能导致平衡被改变，也就是删除和插入操作了。
实际上也总是可以通过对树进行简单的修复来让其重新恢复到平衡，而这样的简单操作我们就称之为旋转，当然旋转也有单旋转和双旋转之分。
无论是插入还是删除，只有那些从插入点或者删除点到根结点的路径上的结点的平衡才有可能被改变，因为只有这些结点的子树才可能发生变化，所以最终也只需针对这些点进行平衡修复操作即可。

6.3.1 左左单旋转(LL)情景①分析

在结点X的左孩子结点的左子树中插入元素

6.3.2 右右单旋转(RR)情景④分析

在结点X的右孩子结点的右子树中插入元素

6.3.3 左右双旋转(LR)情景②分析

在结点X的左孩子结点的右子树中插入元素

6.3.4 右左双旋转(RL)情景③分析

在结点X的右孩子结点的左子树中插入元素

平衡二叉树详细解析

二 . 红黑树

1. 红黑树简介

节点是红色或黑色。
根节点是黑色。
每个叶子节点都是黑色的空节点（NIL节点）。
每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

2. 红黑树的修正

变色、左旋、右旋是红黑树在二叉树上的扩展操作，同时也是基于这三个操作才能遵守红黑树的五个特性。

2.1 左旋

    /*
     * 左旋做了三件事：

     * 1. 将y的左子节点赋给x的右子节点,并将x赋给y左子节点的父节点(y左子节点非空时)

     * 2. 将x的父节点p(非空时)赋给y的父节点，同时更新p的子节点为y(左或右)

     * 3. 将y的左子节点设为x，将x的父节点设为y

     */
    public void leftRotate(RBNode x) {
        if (x == null) return;
        //1. 将y的左子节点赋给x的右子节点,并将x赋给y左子节点的父节点(y左子节点非空时)
        RBNode y = x.right;
        x.right = y.left;
        if (y.left != null) {
            y.left.parent = x;
        }
        //2. 将x的父节点p(非空时)赋给y的父节点，同时更新p的子节点为y(左或右)
        y.parent = x.parent;
        if (x.parent == null) {
            this.mRoot = y;
        } else {
            if (x == x.parent.left) {
                x.parent.left = y;
            } else {
                x.parent.right = y;
            }
        }
        //3. 将y的左子节点设为x，将x的父节点设为y
        y.left = x;
        x.parent = y;
    }

2.2 右旋

/*      右旋做了三件事：
     * 1. 将x的右子节点赋给y的左子节点,并将y赋给x右子节点的父节点(x右子节点非空时)
     * 2. 将y的父节点p(非空时)赋给x的父节点，同时更新p的子节点为x(左或右)
     * 3. 将x的右子节点设为y，将y的父节点设为x
     */
   public void rightRotate(RBNode y) {
        if (y == null) return;
        //1. 将x的右子节点赋给y的左子节点,并将y赋给x右子节点的父节点(x右子节点非空时)
        RBNode x = y.left;
        y.left = x.right;
        if (x.right != null) {
            x.right.parent = y;
        }
        //2. 将y的父节点p(非空时)赋给x的父节点，同时更新p的子节点为x(左或右)
        x.parent = y.parent;
        if (y.parent == null) {
            this.mRoot = x;
        } else {
            if (y == y.parent.left) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        }
        //3. 将x的右子节点设为y，将y的父节点设为x
        x.right = y;
        y.parent = x;
    }

3. 红黑树节点的添加

红黑树的第 5 条特征规定，任一节点到它子树的每个叶子节点的路径中都包含同样数量的黑节点。也就是说当我们往红黑树中插入一个黑色节点时，会违背这条特征。
同时第 4 条特征规定红色节点的左右孩子一定都是黑色节点，当我们给一个红色节点下插入一个红色节点时，会违背这条特征。
因此我们需要在插入黑色节点后进行结构调整，保证红黑树始终满足这 5 条特征。

3.1 红黑树插入后节点的调整思想:

叔叔节点也为红色。
叔叔节点为空，且祖父节点、父节点和新节点处于一条斜线上。
叔叔节点为空，且祖父节点、父节点和新节点不处于一条斜线上。

3.1.1 插入操作-case 1(叔叔节点也为红色)

3.1.2 插入操作-case 2

叔叔节点为空，且祖父节点、父节点和新节点处于一条斜线上。
case 2的操作是：

B和C都是左节点，将B节点进行右旋操作，并且和父节点A互换颜色。通过该修复操作RBTRee的高度和颜色都符合红黑树的定义。
如果B和C节点都是右节点的话，只要将操作变成B节点左旋就可以了。

3.1.3 插入操作-case 3

叔叔节点为空，且祖父节点、父节点和新节点不处于一条斜线上。
case 3的操作是：

C是右节点，将C节点进行左旋，这样就从case 3转换成case 2了，然后针对case 2进行操作处理就行了。case2操作C节点做了一个右旋操作和颜色互换来达到目的。
如果C是左节点，将C节点进行右旋，转换成case2，再左旋就可以了。

4. 红黑树节点的删除

如果删除节点的左孩子和右孩子不同时为null，那么只需要让其子树继承删除该节点的位置
如果删除的节点是叶子节点，我们直接进行调整；
假如删除节点的左右孩子都不是null，需要后继节点替换被删除的节点和值和颜色，这样才不会引起红黑树平衡的破坏，只需要对后继节点删除后进行调整，这样我们就回归处理情况 1 和 2 的状态；
1. 后继节点为左子树最右边的子叶节点
2. 后继节点为右子树最左边的叶子节点；
3. 如果需要删除的节点颜色为红色，那么红黑树的结构不被破坏，也就不需要进行调整。如果我们判断删除节点的颜色为黑色，那么就进行调整；

4.1 红黑树删除之节点调整

调整思想：
为了保证删除节点的父节点左右两边黑色节点数一致，需要重点关注父节点没删除的那一边节点是不是黑色。

如果删除后父亲节点另一边比删除的一边黑色多，就要想办法搞到平衡。
- 1、把父亲节点另一边（即删除节点的兄弟树）其中一个节点弄成红色，也少了一个黑色。
- 2、或者把另一边多的节点（染成黑色）转过来一个

删除修复操作是针对删除黑色节点才有的，当黑色节点被删除后会让整个树不符合RBTree的定义的第四条。

当前节点是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）；
当前节点是黑色的，且兄弟节点是黑色的，
1）、兄弟节点的两个子节点均为黑色的；
2）、兄弟节点的左子节点是红色，右子节点时黑色的；
3）、兄弟节点的右子节点是红色，左子节点任意颜色；

4.1.1 删除操作-case 1

待删除的节点的兄弟节点是红色的节点。

将父节点涂红，将兄弟节点涂黑，然后将当前节点的父节点进行支点左旋。
case 1这样转换之后就会变成后面的case 2，case 3，或者case 4进行处理了。

4.1.2 删除操作-case 2

待删除的节点的兄弟节点是黑色的节点，且兄弟节点的子节点都是黑色的。

将兄弟节点涂红，将当前节点指向其父节点，将其父节点指向当前节点的祖父节点，继续往树根递归判断以及调整；

4.1.3 删除操作-case 3

待调整的节点的兄弟节点是黑色的节点，且和兄弟节点在一条斜线上的子节点也是黑色，另一个子节点是红色。

把当前节点的兄弟节点涂红，把兄弟节点的左子节点涂黑，然后以兄弟节点作为支点做右旋操作。

case 3的删除操作是一个中间步骤，它的目的是将左边的红色节点借调过来，这样就可以转换成case 4

4.1.4 删除操作-case 4

待调整的节点的兄弟节点是黑色的节点，且和兄弟节点在一条斜线上的子节点是红色，另一个子节点任意

把兄弟节点涂成父节点的颜色，再把父节点涂黑，把兄弟节点的右子节点涂黑，然后以当前节点的父节点为支点做左旋操作。

三 . B树、B+树、B*树

3.1 B树(B-树)

3.1.1 B树简介

B-树是一种多路搜索树（并不一定是二叉的）
1970年，R.Bayer和E.mccreight提出了一种适用于外查找的树，它是一种平衡的多叉树，称为B树（或B-树、B_树）。

B-Tree的接点结构B-tree中，每个结点包含：

本结点所含关键字的个数；
指向父结点的指针；
关键字；
指向子结点的指针数组；

3.1.2 B树特点

是一种多路搜索树（并不是二叉的）：

定义任意非叶子结点最多只有M个儿子；且M>2；
根结点的儿子数为[2, M]；
除根结点以外的非叶子结点的儿子数为[M/2, M]；
每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）
非叶子结点的关键字个数=指向儿子的指针个数-1；
非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；
非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树；
所有叶子结点位于同一层；

3.1.3 B树的查找

若在某结点内找到待查的关键字K，则返回该结点的地址及K在key[1..keynum]中的位置；
否则，确定K在某个key[i]和key[i+1]之间结点后，从磁盘中读son[i]所指的结点继续查找。直到在某结点中查找成功；或直至找到叶结点且叶结点中的查找仍不成功时，查找过程失败。

查找操作的时间开销

B-树上的查找有两个基本步骤：

在B-树中查找结点，该查找涉及读盘DiskRead操作，属外查找；
在结点内查找，该查找属内查找。

查找操作的时间为：

外查找的读盘次数不超过树高h，故其时间是O(h)；
内查找中，每个结点内的关键字数目keynum

注意：

实际上外查找时间可能远远大于内查找时间。
B-树作为数据库文件时，打开文件之后就必须将根结点读人内存，而直至文件关闭之前，此根一直驻留在内存中，故查找时可以不计读入根结点的时间。

3.1.4 B树的插入

插入一个元素时：

首先判断在B树中是否存在，如果不存在，即在叶子结点处结束，然后在叶子结点中插入该新的元素

注意：
1.1 如果叶子结点空间足够，这里需要向右移动该叶子结点中大于新插入关键字的元素，

3.1.5 B树的删除

首先查找B树中需删除的元素,如果该元素在B树中存在，则将该元素在其结点中进行删除，
如果删除该元素后，首先判断该元素是否有左右孩子结点，如果有，则上移孩子结点中的某相近元素到父节点中，然后是移动之后的情况；如果没有，直接删除后，移动之后的情况。

3.2 B+树

3.2.1 B+树简介

B+树用途

3.2.2 B+树定义

B+树是应文件系统所需而出的一种B-树的变型树。

B+树与B-树的不同

B+树是B-树的变体，也是一种多路搜索树：

定义基本与B-树同，除了：
叶子结点的子树指针与关键字个数相同；
叶子结点的子树指针P[i]，指向关键字值属于[K[i], K[i+1])的子树（B-树是开区间）；
为所有叶子结点增加一个链指针；
所有关键字都在叶子结点出现；

3.2.3 B+树的特性：

所有关键字都出现在叶子结点的链表中（稠密索引），且链表中的关键字恰好是有序的；
不可能在非叶子结点命中；
非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层；
更适合文件索引系统；

3.2.4 B+树 vs B树

为什么说B+-tree比B 树更适合实际应用中操作系统的文件索引和数据库索引？

B+-tree的磁盘读写代价更低
B+-tree的内部结点并没有指向关键字具体信息的指针。因此其内部结点相对B 树更小。如果把所有同一内部结点的关键字存放在同一盘块中，那么盘块所能容纳的关键字数量也越多。一次性读入内存中的需要查找的关键字也就越多。相对来说IO读写次数也就降低了。
举个例子，假设磁盘中的一个盘块容纳16bytes，而一个关键字2bytes，一个关键字具体信息指针2bytes。一棵9阶B-tree(一个结点最多8个关键字)的内部结点需要2个盘快。而B+ 树内部结点只需要1个盘快。当需要把内部结点读入内存中的时候，B 树就比B+ 树多一次盘块查找时间(在磁盘中就是盘片旋转的时间)。
B+-tree的查询效率更加稳定
由于非终结点并不是最终指向文件内容的结点，而只是叶子结点中关键字的索引。所以任何关键字的查找必须走一条从根结点到叶子结点的路。所有关键字查询的路径长度相同，导致每一个数据的查询效率相当。

3.3 B*树

3.3.1 B*树简介

3.3.2 B*树 vs B+树

B+树的分裂：
当一个结点满时，分配一个新的结点，并将原结点中1/2的数据复制到新结点，最后在父结点中增加新结点的指针；B+树的分裂只影响原结点和父结点，而不会影响兄弟结点，所以它不需要指向兄弟的指针；
B*树的分裂：
当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字（因为兄弟结点的关键字范围改变了）；如果兄弟也满了，则在原结点与兄弟结点之间增加新结点，并各复制1/3的数据到新结点，最后在父结点增加新结点的指针；

所以，B*树分配新结点的概率比B+树要低，空间使用率更高；

3.4 小结：

B-树：
多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键字范围的子结点；
所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中；

B+树：在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点中出现，非叶子结点作为叶子结点的索引；
B+树总是到叶子结点才命中；

B*树：在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率从1/2提高到2/3；

四. LSM树

4.1 LSM由来

B+树最大的性能问题是会产生大量的随机IO，随着新数据的插入，叶子节点会慢慢分裂，逻辑上连续的叶子节点在物理上往往不连续，甚至分离的很远，但做范围查询时，会产生大量读随机IO。

对于大量的随机写也一样，举一个插入key跨度很大的例子，如7->1000->3->2000 ... 新插入的数据存储在磁盘上相隔很远，会产生大量的随机写IO.

从上面可以看出，低下的磁盘寻道速度严重影响性能（近些年来，磁盘寻道速度的发展几乎处于停滞的状态）。

为了克服B+树的弱点，HBase引入了LSM树的概念，即Log-Structured Merge-Trees。

4.2 LSM树原理

为了更好的说明LSM树的原理，下面举个比较极端的例子：

现在假设有1000个节点的随机key，对于磁盘来说，肯定是把这1000个节点顺序写入磁盘最快，但是这样一来，读就悲剧了，因为key在磁盘中完全无序，每次读取都要全扫描；
那么，为了让读性能尽量高，数据在磁盘中必须得有序，这就是B+树的原理，但是写就悲剧了，因为会产生大量的随机IO，磁盘寻道速度跟不上。

LSM树本质上就是在读写之间取得平衡，和B+树相比，它牺牲了部分读性能，用来大幅提高写性能。

原理

它的原理是把一颗大树拆分成N棵小树，它首先写入到内存中（内存没有寻道速度的问题，随机写的性能得到大幅提升），在内存中构建一颗有序小树，随着小树越来越大，内存的小树会flush到磁盘上。当读时，由于不知道数据在哪棵小树上，因此必须遍历所有的小树，但在每颗小树内部数据是有序的。

实现

以上就是LSM树最本质的原理，有了原理，再看具体的技术就很简单了。

1）首先说说为什么要有WAL（Write Ahead Log），很简单，因为数据是先写到内存中，如果断电，内存中的数据会丢失，因此为了保护内存中的数据，需要在磁盘上先记录logfile，当内存中的数据flush到磁盘上时，就可以抛弃相应的Logfile。

2）什么是memstore, storefile？很简单，上面说过，LSM树就是一堆小树，在内存中的小树即memstore，每次flush，内存中的memstore变成磁盘上一个新的storefile。

3）为什么会有compact？很简单，随着小树越来越多，读的性能会越来越差，因此需要在适当的时候，对磁盘中的小树进行merge，多棵小树变成一颗大树。

linzhi's Site

工作总结

工作总结

TODO

spring拦截器 过滤器

线程+线程池

文件系统

消息队列mq

activi 流程

maven

settings.xml

日志写法

工具类

业务写法

1. controller

2. swagger注解：

打包

1. jar包：

2. war包：

3. assembly插件

分页

mybatis

response/request

linux

linux

权限

命令

基本命令

find

系统信息

ps和grep

用户管理

链接

文件操作

打包

awk

sed

vim

正常模式

编辑模式

命令模式

shell

bash 命令

特殊命令

命令替换

变量替换

运算符

字符串

数组

case esac语句

for

function

重定向

分支管理

分支管理

本地项目上传到github

提交修改的代码到新建分支（原来的分支代码不变）

暂时保存和恢复进度

数据结构总结

数据结构

基本概念

分类

逻辑结构

存储结构

判断

数据的运算

数据结构详解

1.线性表

1.1 线性表的顺序存储（SeqList）

1.2 线性表的链式存储

1.2.1 单链表

1.2.2 双链表

1.3 改良顺序表与双链表(类似ArrayList和LinkedList)

2. 栈(Stack)

2.1 顺序栈

2.2 链式栈

2.3 栈的应用

2.4 详细讲解

3. 队列(Queue)

3.1 顺序队列

spring拦截器过滤器