<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="3.9.0">Jekyll</generator><link href="https://jialiangbujiaj1a.github.io//feed.xml" rel="self" type="application/atom+xml" /><link href="https://jialiangbujiaj1a.github.io//" rel="alternate" type="text/html" /><updated>2021-06-21T14:36:07+00:00</updated><id>https://jialiangbujiaj1a.github.io//feed.xml</id><title type="html">加量不加价</title><subtitle>欢迎！
</subtitle><author><name>加量不加价</name></author><entry><title type="html">缓存和redis</title><link href="https://jialiangbujiaj1a.github.io//2021/03/09/%E7%BC%93%E5%AD%98%E5%92%8CRedis.html" rel="alternate" type="text/html" title="缓存和redis" /><published>2021-03-09T00:00:00+00:00</published><updated>2021-03-09T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2021/03/09/%E7%BC%93%E5%AD%98%E5%92%8CRedis</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2021/03/09/%E7%BC%93%E5%AD%98%E5%92%8CRedis.html">&lt;h1 id=&quot;缓存和redis&quot;&gt;缓存和Redis&lt;/h1&gt;

&lt;h2 id=&quot;缓存&quot;&gt;缓存&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;缓存：指数据交换的缓冲区，目的即是提升程序的读写性能。&lt;/strong&gt;&lt;/p&gt;

&lt;h3 id=&quot;缓存算法&quot;&gt;缓存算法&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;LRU（最近最少使用)：新添加的数据放在头部 ，被访问到的数据放在头部，超过最大缓存量的数据将被移除。&lt;/li&gt;
  &lt;li&gt;LFU（最不经常使用)&lt;/li&gt;
  &lt;li&gt;FIFO（先进先出)&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;缓存常见问题&quot;&gt;缓存常见问题&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;1、缓存穿透：&lt;/strong&gt;指查询一个一定&lt;strong&gt;不存在&lt;/strong&gt;的数据。&lt;/p&gt;

&lt;p&gt;​		缓存是不命中时被动写（当从缓存中查不到数据时，然后从数据库查询到该数据，写入该数据到缓存中。），如果从 DB 查不到数据则不写入缓存。&lt;/p&gt;

&lt;p&gt;​		&lt;strong&gt;解决：&lt;/strong&gt;方案一，缓存空对象。当从DB查询出的数据为空，将这个空结果进行缓存并设置较短的过期时间，一般不超过五分钟。&lt;/p&gt;

&lt;p&gt;​					方案二，布隆过滤器，即查询缓存前先根据 KEY 查询【BloomFilter 缓存】。如果不存在对应的值，直接返回；如果存在，继续向下执行。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2、缓存雪崩&lt;/strong&gt;：指缓存由于某些原因无法提供服务( 例如，缓存挂掉了 )，所有请求全部达到 DB 中，导致 DB 负荷大增，最终挂掉的情况。&lt;/p&gt;

&lt;p&gt;​	&lt;strong&gt;解决：&lt;/strong&gt;方案一，缓存高可用（搭建集群）&lt;/p&gt;

&lt;p&gt;​				方案二，使用本地缓存（设置较短的过期时间，保证实时性）&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3、缓存击穿：&lt;/strong&gt;指某个&lt;strong&gt;极度“热点”&lt;/strong&gt;数据在某个时间点过期时，恰好在这个时间点对这个 KEY 有大量的并发请求过来，这些请求发现缓存过期一般都会从 DB 加载数据并回设到缓存。&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;和缓存“雪崩“”的区别在于，前者针对某一 KEY 缓存，后者则是很多 KEY 。&lt;/li&gt;
  &lt;li&gt;和缓存“穿透“”的区别在于，这个 KEY 是真实存在对应的值的。&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;​		&lt;strong&gt;解决：&lt;/strong&gt;方案一，加锁，请求发现缓存不存在后，去查询 DB 前，使用分布式锁，保证有且只有一个线程去查询 DB ，并更新到缓存。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4、缓存和 DB 的一致性如何保证&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;场景&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;并发的场景下，在删除 Cache 的数据, 和更新 DB 数据时间之间有线程读取老的 DB 数据，更新到缓存中。&lt;/p&gt;

&lt;p&gt;缓存和 DB 的操作，不在一个事务中，可能只有一个 DB 操作成功，而另一个 Cache 操作失败，导致不一致。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;解决&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;1、将缓存可能存在的并行写，实现串行写。&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
  &lt;p&gt;注意，这里指的是缓存的并行写。在被动读中，如果缓存不存在，也存在写。&lt;/p&gt;
&lt;/blockquote&gt;

&lt;ul&gt;
  &lt;li&gt;2、实现数据的最终一致性。&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;方案一：&lt;/strong&gt;先淘汰缓存，再写数据库&lt;/p&gt;

&lt;p&gt;因为先淘汰缓存，所以数据的最终一致性是可以得到有效的保证的。先淘汰缓存，即使写数据库发生异常，也就是下次缓存读取时，多读取一次数据库。&lt;/p&gt;

&lt;p&gt;但是，这种方案会存在缓存和 DB 的数据会不一致的情况，那么，我们需要解决缓存并行写，实现串行写。比较简单的方式，引入分布式锁。&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;在写请求时，先淘汰缓存之前，先获取该分布式锁。&lt;/li&gt;
  &lt;li&gt;在读请求时，发现缓存不存在时，先获取分布式锁。&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;方案二：&lt;/strong&gt;先写数据库，再更新缓存&lt;/p&gt;

&lt;p&gt;按照“先写数据库，再更新缓存”，我们要保证 DB 和缓存的操作，能够在“同一个事务”中，从而实现最终一致性。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;基于定时任务来实现&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;首先，写入数据库。&lt;/li&gt;
  &lt;li&gt;然后，在写入数据库所在的事务中，插入一条记录到任务表。该记录会存储需要更新的缓存 KEY 和 VALUE 。&lt;/li&gt;
  &lt;li&gt;【异步】最后，定时任务每秒扫描任务表，更新到缓存中，之后删除该记录。&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;redis&quot;&gt;Redis&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;介绍：&lt;/strong&gt;是一个基于内存的高性能Key-Value数据库。&lt;/p&gt;

&lt;h3 id=&quot;redis常见数据存储类型&quot;&gt;Redis常见数据存储类型&lt;/h3&gt;

&lt;p&gt;Redis自身以key：value形式存储数据，数据存储类型指的是value，key部分永远都是字符串。&lt;/p&gt;

&lt;h4 id=&quot;string&quot;&gt;String：&lt;/h4&gt;

&lt;p&gt;&lt;strong&gt;介绍：&lt;/strong&gt;通常使用字符串，如果字符串以整数的形式展示，可以作为数字操作使用&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;常用命令:&lt;/strong&gt; &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;set,get,strlen,exists,dect,incr,setex&lt;/code&gt; 等等。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;应用场景&lt;/strong&gt; ：一般常用在需要计数的场景，比如用户的访问次数、热点文章的点赞转发数量等等。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;注意：&lt;/strong&gt; 数据最大存储量512M，数值计算最大范围为Java中long的最大值&lt;/p&gt;

&lt;h4 id=&quot;hash&quot;&gt;hash:&lt;/h4&gt;

&lt;p&gt;&lt;strong&gt;介绍：&lt;/strong&gt;hash 是一个 string 类型的 field 和 value 的映射表，适合用于存储对象,底层使用哈希表结构实现数据存储&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;常用命令：&lt;/strong&gt; &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;hset,hmset,hexists,hget,hgetall,hkeys,hvals&lt;/code&gt; 等。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;应用场景:&lt;/strong&gt; 系统中对象数据的存储。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;注意：&lt;/strong&gt;hash类型下的value只能存储字符串&lt;/p&gt;

&lt;h4 id=&quot;list&quot;&gt;list：&lt;/h4&gt;

&lt;p&gt;&lt;strong&gt;介绍：&lt;/strong&gt;保存多个数据，底层使用双向链表存储结构实现，支持双向添加，查找。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;常用命令:&lt;/strong&gt; &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;rpush,lpop,lpush,rpop,lrange、llen&lt;/code&gt; 等。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;应用场景:&lt;/strong&gt; 发布与订阅或者说消息队列、慢查询。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;注意：&lt;/strong&gt;list中保存的数据都是string类型的，ist具有索引的概念，但是操作数据时通常以队列的形式进行入队出队操作，或以栈的形式进行入栈出栈操作 ， 获取全部数据操作结束索引设置为-1&lt;/p&gt;

&lt;h4 id=&quot;set&quot;&gt;set：&lt;/h4&gt;

&lt;p&gt;&lt;strong&gt;介绍 ：&lt;/strong&gt; set 类似于 Java 中的 &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;HashSet&lt;/code&gt; 。Redis 中的 set 类型是一种无序集合，集合中的元素没有先后顺序。set 提供了判断某个成员是否在一个 set 集合内的重要接口，可以基于 set 轻易实现交集、并集、差集的操作&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;常用命令：&lt;/strong&gt; &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;sadd,spop,smembers,sismember,scard,sinterstore,sunion&lt;/code&gt; 等。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;应用场景:&lt;/strong&gt; 需要存放的数据不能重复以及需要获取多个数据源交集和并集等场景&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;注意：&lt;/strong&gt;与hash存储结构完全相同，仅存储键，不存储值（nil）&lt;/p&gt;

&lt;h4 id=&quot;sorted-set&quot;&gt;sorted set&lt;/h4&gt;

&lt;p&gt;&lt;strong&gt;介绍：&lt;/strong&gt; 和 set 相比，sorted set 增加了一个权重参数 score，使得集合中的元素能够按 score 进行有序排列，还可以通过 score 的范围来获取元素的列表。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;常用命令：&lt;/strong&gt; &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;zadd,zcard,zscore,zrange,zrevrange,zrem&lt;/code&gt; 等。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;应用场景：&lt;/strong&gt; 需要对数据根据某个权重进行排序的场景。比如在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;注意：&lt;/strong&gt;score保存的数据存储空间是64位，score保存的数据也可以是一个双精度的double值，基于双精度浮点数的特征，可能会丢失精度，使用时 候要慎重  sorted_set 如果重复添加相同的数据，score值将被反 复覆盖，保留最后一次修改的结果&lt;/p&gt;

&lt;p&gt;###&lt;/p&gt;

&lt;h3 id=&quot;redis的线程模型&quot;&gt;Redis的线程模型&lt;/h3&gt;

&lt;p&gt;Redis 内部使用文件事件处理器 &lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;file event handler&lt;/code&gt;，这个文件事件处理器是单线程的，所以 Redis 才叫做单线程的模型。它采用 IO 多路复用机制同时监听多个 Socket，根据 Socket 上的事件来选择对应的事件处理器进行处理。&lt;/p&gt;

&lt;p&gt;文件事件处理器的结构包含 4 个部分：&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;多个 Socket 。&lt;/li&gt;
  &lt;li&gt;IO 多路复用程序。&lt;/li&gt;
  &lt;li&gt;文件事件分派器。&lt;/li&gt;
  &lt;li&gt;事件处理器（连接应答处理器、命令请求处理器、命令回复处理器）。&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;多个 Socket 可能会并发产生不同的操作，每个操作对应不同的文件事件，但是 IO 多路复用程序会监听多个 socket，会将 socket 产生的事件放入队列中排队，事件分派器每次从队列中取出一个事件，把该事件交给对应的事件处理器进行处理&lt;/p&gt;

&lt;h3 id=&quot;redis-单线程模型效率高原因&quot;&gt;Redis 单线程模型效率高原因&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;1、C 语言实现。&lt;/li&gt;
  &lt;li&gt;2、纯内存操作。&lt;/li&gt;
  &lt;li&gt;3、基于非阻塞的 IO 多路复用机制。&lt;/li&gt;
  &lt;li&gt;4、单线程，避免了多线程的频繁上下文切换问题。&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;持久化&quot;&gt;持久化&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;RDB—AOF：记录数据—记录数据产生的过程&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;方式一：&lt;/strong&gt; &lt;strong&gt;RDB&lt;/strong&gt;【全量】持久化，将当前数据状态进行保存，快照形式，存储数据结果，存储格式简单，关注点在数据&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;RDB启动方式：&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;save指令：会阻塞直到RDB过程完成&lt;/li&gt;
  &lt;li&gt;bgsave指令：手工启动后台保存操作，不是立即执行
    &lt;ul&gt;
      &lt;li&gt;客户端执行&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;bgsave&lt;/code&gt;,返回&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;Background saving started&lt;/code&gt;消息，接下来调用fork函数生成子进程，创建.rdb文件&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;save配置：满足限定时间范围内key的变化数量达到指定数量即进行持久化（使用的bgsave）&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;方式二：&lt;/strong&gt; &lt;strong&gt;AOF&lt;/strong&gt;【增量】持久化，将数据的操作过程进行保存，日志形式，存储操作过程，存储格式复杂，关注点在数据的操作过程&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;AOF写数据三种策略(appendfsync)：&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;always(每次） 每次写入操作均同步到AOF文件中，数据零误差，性能较低&lt;/li&gt;
  &lt;li&gt;everysec（每秒） 每秒将缓冲区中的指令同步到AOF文件中，数据准确性较高，性能较高&lt;/li&gt;
  &lt;li&gt;no（系统控制） 由操作系统控制每次同步到AOF文件的周期&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;AOF重写：&lt;/strong&gt; 将对同一个数据的若干个条命令执行结果转化成最终结果数据对应的指令进行记录。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;选择：&lt;/strong&gt;不要仅仅使用RDB那样会丢失数据，也不要仅仅使用AOF，没有RDB恢复速度来的快&lt;/p&gt;

&lt;h3 id=&quot;事务&quot;&gt;事务&lt;/h3&gt;

&lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;multi&lt;/code&gt; 开启事务,设定事务的开启位置，此指令执行后，后续的所有指令均加入到事务中&lt;/p&gt;

&lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;exec&lt;/code&gt; 执行事务,设定事务的结束位置，同时执行事务。与multi成对出现，成对使用&lt;/p&gt;

&lt;p&gt;加入事务的命令暂时进入到任务队列中，并没有立即执行，只有执行exec命令才开始执行&lt;/p&gt;

&lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;discard&lt;/code&gt; 取消事务&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;注意：&lt;/strong&gt;如果有某一条命令执行失败，其后的命令仍然会被继续执行。&lt;/p&gt;

&lt;h3 id=&quot;分布式锁&quot;&gt;分布式锁&lt;/h3&gt;

&lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;setnx&lt;/code&gt; 获取锁&lt;/p&gt;

&lt;p&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;expire &lt;/code&gt; 设置超时自动释放锁&lt;/p&gt;

&lt;h3 id=&quot;删除策略&quot;&gt;删除策略&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;过期数据：&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;内存中的数据可以通过TTL指令获取其状态&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;XX：具有时效性的数据&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;-1：永久有效的数据&lt;/li&gt;
  &lt;li&gt;-2 ：已经过期的数据 或 被删除的数据 或 未定义的数据&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;数据删除策略：&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;定时删除：创建一个定时器，当key设置有过期时间，且过期时间到达时，由定时器任务立即执行对键的删除操作&lt;/li&gt;
  &lt;li&gt;惰性删除：数据到达过期时间，不做处理。等下次访问该数据时  如果未过期，返回数据  发现已过期，删除，返回不存在&lt;/li&gt;
  &lt;li&gt;定期删除：周期性轮询redis库中的时效性数据，采用随机抽取的策略，利用过期数据占比的方式控制删除频度&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;数据淘汰策略：&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;检测易失数据（可能会过期的数据集server.db[i].expires ）&lt;/p&gt;

    &lt;ul&gt;
      &lt;li&gt;① volatile-lru：挑选最近最少使用的数据淘汰&lt;/li&gt;
      &lt;li&gt;② volatile-lfu：挑选最近使用次数最少的数据淘汰&lt;/li&gt;
      &lt;li&gt;③ volatile-ttl：挑选将要过期的数据淘汰&lt;/li&gt;
      &lt;li&gt;④ volatile-random：任意选择数据淘汰&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;检测全库数据（所有数据集server.db[i].dict ）&lt;/p&gt;

    &lt;ul&gt;
      &lt;li&gt;⑤ allkeys-lru：挑选最近最少使用的数据淘汰&lt;/li&gt;
      &lt;li&gt;⑥ allkeys-lfu：挑选最近使用次数最少的数据淘汰&lt;/li&gt;
      &lt;li&gt;⑦ allkeys-random：任意选择数据淘汰&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;放弃数据驱逐&lt;/p&gt;

    &lt;ul&gt;
      &lt;li&gt;⑧ no-enviction（驱逐）：禁止驱逐数据（redis4.0中默认策略），会引发错误OOM（Out Of Memory）&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;redis-高级数据类型&quot;&gt;Redis 高级数据类型&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;HyperLogLog： 应用于独立信息统计 （用于进行基数（数据集去重后个数）统计，不是集合，不保存数据，只记录数量而不是具体数据）&lt;/li&gt;
  &lt;li&gt;Geo：应用于地理位置计算（设置坐标点，计算坐标点距离及范围内数据）&lt;/li&gt;
  &lt;li&gt;Bitmap：应用于信息状态统计（对key按位进行交、并、非、或操作）&lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;主从复制&quot;&gt;主从复制&lt;/h3&gt;

&lt;p&gt;主从复制即将master中的数据即时、有效的复制到slave中&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;特征：&lt;/strong&gt;一个master可以拥有多个slave，一个slave只对应一个master&lt;/p&gt;

&lt;p&gt;**职责： **&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;master:  写数据  执行写操作时，将出现变化的数据自动同步到slave  读数据（可忽略）&lt;/li&gt;
  &lt;li&gt; slave:  读数据  写数据（禁止）&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;过程：&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;建立连接阶段（即准备阶段）&lt;/p&gt;

    &lt;p&gt;slave保存master的IP与端口，创建连接maste的socket，master保存slave的端口&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;数据同步阶段&lt;/p&gt;

    &lt;p&gt;初次连接master后，复制master中的所有数据到slave&lt;/p&gt;

    &lt;ul&gt;
      &lt;li&gt;全量复制：接收master的RDB，清空数据，执行RDB文件恢复过程&lt;/li&gt;
      &lt;li&gt;部分复制：接收master的缓冲区信息，执行bgrewriteaof，恢复数据&lt;/li&gt;
    &lt;/ul&gt;

    &lt;p&gt;master保存slave当前数据同步的位置&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;命令传播阶段&lt;/p&gt;

    &lt;p&gt;master与slave间需要进行信息交换，使用心跳机制进行维护，实现双方连接保持在线&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;哨兵机制&quot;&gt;哨兵机制&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;哨兵：&lt;/strong&gt; 是一个分布式系统，用于对主从结构中的每台服务器进行监控，当出现故障时通过投票机制选择新的 master并将所有slave连接到新的master。&lt;/p&gt;

&lt;h3 id=&quot;缓存预热&quot;&gt;缓存预热&lt;/h3&gt;

&lt;p&gt;缓存预热就是系统启动前，提前将相关的缓存数据直接加载到缓存系统。避免在用户请求的时候，先查询数据库，然后再将数据缓 存的问题！用户直接查询事先被预热的缓存数据！&lt;/p&gt;

&lt;p&gt;解决方案&lt;/p&gt;

&lt;p&gt;前置准备工作： 1. 日常例行统计数据访问记录，统计访问频度较高的热点数据 2. 利用LRU数据删除策略，构建数据留存队列 例如：storm与kafka配合&lt;/p&gt;

&lt;p&gt;准备工作： 1. 将统计结果中的数据分类，根据级别，redis优先加载级别较高的热点数据 2. 利用分布式多服务器同时进行数据读取，提速数据加载过程 3. 热点数据主从同时预热&lt;/p&gt;

&lt;p&gt;实施： 1. 使用脚本程序固定触发数据预热过程 2. 如果条件允许，使用了CDN（内容分发网络），效果会更好&lt;/p&gt;

&lt;h3 id=&quot;缓存雪崩&quot;&gt;缓存雪崩&lt;/h3&gt;

&lt;p&gt;短时间内大量key过期&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;解决&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;LRU与LFU切换&lt;/li&gt;
  &lt;li&gt;数据有效期策略调整  根据业务数据有效期进行分类错峰，A类90分钟，B类80分钟，C类70分钟  过期时间使用固定时间+随机值的形式，稀释集中到期的key的数量&lt;/li&gt;
  &lt;li&gt;超热数据使用永久key&lt;/li&gt;
  &lt;li&gt;定期维护（自动+人工） 对即将过期数据做访问量分析，确认是否延时，配合访问量统计，做热点数据的延时&lt;/li&gt;
&lt;/ol&gt;

&lt;h3 id=&quot;缓存击穿&quot;&gt;缓存击穿&lt;/h3&gt;

&lt;p&gt;缓存击穿就是单个高热数据过期的瞬间，数据访问量较大，未命中redis后，发起了大量对同一数据的数据库访问&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;解决：&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;预先设定 以电商为例，每个商家根据店铺等级，指定若干款主打商品，在购物节期间，加大此类信息key的过期时长 注意：购物节不仅仅指当天，以及后续若干天，访问峰值呈现逐渐降低的趋势&lt;/li&gt;
  &lt;li&gt;现场调整 监控访问量，对自然流量激增的数据延长过期时间或设置为永久性key&lt;/li&gt;
  &lt;li&gt;后台刷新数据 启动定时任务，高峰期来临之前，刷新数据有效期，确保不丢失&lt;/li&gt;
  &lt;li&gt;二级缓存 设置不同的失效时间，保障不会被同时淘汰就行&lt;/li&gt;
&lt;/ol&gt;

&lt;h3 id=&quot;缓存穿透&quot;&gt;缓存穿透&lt;/h3&gt;

&lt;p&gt;缓存击穿访问了不存在的数据，跳过了合法数据的redis数据缓存阶段，每次访问数据库，导致对数据库服务器造成压力&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;解决&lt;/strong&gt;&lt;/p&gt;

&lt;ol&gt;
  &lt;li&gt;缓存null 对查询结果为null的数据进行缓存（长期使用，定期清理），设定短时限，例如30-60秒，最高5分钟&lt;/li&gt;
  &lt;li&gt;白名单策略  提前预热各种分类数据id对应的bitmaps，id作为bitmaps的offset，相当于设置了数据白名单。当加载正常数据时，放 行，加载异常数据时直接拦截（效率偏低）  使用布隆过滤器（有关布隆过滤器的命中问题对当前状况可以忽略）&lt;/li&gt;
  &lt;li&gt;实施监控 实时监控redis命中率（业务正常范围时，通常会有一个波动值）与null数据的占比  非活动时段波动：通常检测3-5倍，超过5倍纳入重点排查对象  活动时段波动：通常检测10-50倍，超过50倍纳入重点排查对象 根据倍数不同，启动不同的排查流程。然后使用黑名单进行防控（运营）&lt;/li&gt;
  &lt;li&gt;key加密 问题出现后，临时启动防灾业务key，对key进行业务层传输加密服务，设定校验程序，过来的key校验 例如每天随机分配60个加密串，挑选2到3个，混淆到页面数据id中，发现访问key不满足规则，驳回数据访问&lt;/li&gt;
&lt;/ol&gt;</content><author><name>加量不加价</name></author><summary type="html">缓存和Redis 缓存 缓存：指数据交换的缓冲区，目的即是提升程序的读写性能。 缓存算法 LRU（最近最少使用)：新添加的数据放在头部 ，被访问到的数据放在头部，超过最大缓存量的数据将被移除。 LFU（最不经常使用) FIFO（先进先出) 缓存常见问题 1、缓存穿透：指查询一个一定不存在的数据。 ​ 缓存是不命中时被动写（当从缓存中查不到数据时，然后从数据库查询到该数据，写入该数据到缓存中。），如果从 DB 查不到数据则不写入缓存。 ​ 解决：方案一，缓存空对象。当从DB查询出的数据为空，将这个空结果进行缓存并设置较短的过期时间，一般不超过五分钟。 ​ 方案二，布隆过滤器，即查询缓存前先根据 KEY 查询【BloomFilter 缓存】。如果不存在对应的值，直接返回；如果存在，继续向下执行。 2、缓存雪崩：指缓存由于某些原因无法提供服务( 例如，缓存挂掉了 )，所有请求全部达到 DB 中，导致 DB 负荷大增，最终挂掉的情况。 ​ 解决：方案一，缓存高可用（搭建集群） ​ 方案二，使用本地缓存（设置较短的过期时间，保证实时性） 3、缓存击穿：指某个极度“热点”数据在某个时间点过期时，恰好在这个时间点对这个 KEY 有大量的并发请求过来，这些请求发现缓存过期一般都会从 DB 加载数据并回设到缓存。 和缓存“雪崩“”的区别在于，前者针对某一 KEY 缓存，后者则是很多 KEY 。 和缓存“穿透“”的区别在于，这个 KEY 是真实存在对应的值的。 ​ 解决：方案一，加锁，请求发现缓存不存在后，去查询 DB 前，使用分布式锁，保证有且只有一个线程去查询 DB ，并更新到缓存。 4、缓存和 DB 的一致性如何保证 场景 并发的场景下，在删除 Cache 的数据, 和更新 DB 数据时间之间有线程读取老的 DB 数据，更新到缓存中。 缓存和 DB 的操作，不在一个事务中，可能只有一个 DB 操作成功，而另一个 Cache 操作失败，导致不一致。 解决 1、将缓存可能存在的并行写，实现串行写。 注意，这里指的是缓存的并行写。在被动读中，如果缓存不存在，也存在写。 2、实现数据的最终一致性。 方案一：先淘汰缓存，再写数据库 因为先淘汰缓存，所以数据的最终一致性是可以得到有效的保证的。先淘汰缓存，即使写数据库发生异常，也就是下次缓存读取时，多读取一次数据库。 但是，这种方案会存在缓存和 DB 的数据会不一致的情况，那么，我们需要解决缓存并行写，实现串行写。比较简单的方式，引入分布式锁。 在写请求时，先淘汰缓存之前，先获取该分布式锁。 在读请求时，发现缓存不存在时，先获取分布式锁。 方案二：先写数据库，再更新缓存 按照“先写数据库，再更新缓存”，我们要保证 DB 和缓存的操作，能够在“同一个事务”中，从而实现最终一致性。 基于定时任务来实现 首先，写入数据库。 然后，在写入数据库所在的事务中，插入一条记录到任务表。该记录会存储需要更新的缓存 KEY 和 VALUE 。 【异步】最后，定时任务每秒扫描任务表，更新到缓存中，之后删除该记录。 Redis 介绍：是一个基于内存的高性能Key-Value数据库。 Redis常见数据存储类型 Redis自身以key：value形式存储数据，数据存储类型指的是value，key部分永远都是字符串。 String： 介绍：通常使用字符串，如果字符串以整数的形式展示，可以作为数字操作使用 常用命令: set,get,strlen,exists,dect,incr,setex 等等。 应用场景 ：一般常用在需要计数的场景，比如用户的访问次数、热点文章的点赞转发数量等等。 注意： 数据最大存储量512M，数值计算最大范围为Java中long的最大值 hash: 介绍：hash 是一个 string 类型的 field 和 value 的映射表，适合用于存储对象,底层使用哈希表结构实现数据存储 常用命令： hset,hmset,hexists,hget,hgetall,hkeys,hvals 等。 应用场景: 系统中对象数据的存储。 注意：hash类型下的value只能存储字符串 list： 介绍：保存多个数据，底层使用双向链表存储结构实现，支持双向添加，查找。 常用命令: rpush,lpop,lpush,rpop,lrange、llen 等。 应用场景: 发布与订阅或者说消息队列、慢查询。 注意：list中保存的数据都是string类型的，ist具有索引的概念，但是操作数据时通常以队列的形式进行入队出队操作，或以栈的形式进行入栈出栈操作 ， 获取全部数据操作结束索引设置为-1 set： 介绍 ： set 类似于 Java 中的 HashSet 。Redis 中的 set 类型是一种无序集合，集合中的元素没有先后顺序。set 提供了判断某个成员是否在一个 set 集合内的重要接口，可以基于 set 轻易实现交集、并集、差集的操作 常用命令： sadd,spop,smembers,sismember,scard,sinterstore,sunion 等。 应用场景: 需要存放的数据不能重复以及需要获取多个数据源交集和并集等场景 注意：与hash存储结构完全相同，仅存储键，不存储值（nil） sorted set 介绍： 和 set 相比，sorted set 增加了一个权重参数 score，使得集合中的元素能够按 score 进行有序排列，还可以通过 score 的范围来获取元素的列表。 常用命令： zadd,zcard,zscore,zrange,zrevrange,zrem 等。 应用场景： 需要对数据根据某个权重进行排序的场景。比如在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息。 注意：score保存的数据存储空间是64位，score保存的数据也可以是一个双精度的double值，基于双精度浮点数的特征，可能会丢失精度，使用时 候要慎重 sorted_set 如果重复添加相同的数据，score值将被反 复覆盖，保留最后一次修改的结果 ### Redis的线程模型 Redis 内部使用文件事件处理器 file event handler，这个文件事件处理器是单线程的，所以 Redis 才叫做单线程的模型。它采用 IO 多路复用机制同时监听多个 Socket，根据 Socket 上的事件来选择对应的事件处理器进行处理。 文件事件处理器的结构包含 4 个部分： 多个 Socket 。 IO 多路复用程序。 文件事件分派器。 事件处理器（连接应答处理器、命令请求处理器、命令回复处理器）。 多个 Socket 可能会并发产生不同的操作，每个操作对应不同的文件事件，但是 IO 多路复用程序会监听多个 socket，会将 socket 产生的事件放入队列中排队，事件分派器每次从队列中取出一个事件，把该事件交给对应的事件处理器进行处理 Redis 单线程模型效率高原因 1、C 语言实现。 2、纯内存操作。 3、基于非阻塞的 IO 多路复用机制。 4、单线程，避免了多线程的频繁上下文切换问题。 持久化 RDB—AOF：记录数据—记录数据产生的过程 方式一： RDB【全量】持久化，将当前数据状态进行保存，快照形式，存储数据结果，存储格式简单，关注点在数据 RDB启动方式： save指令：会阻塞直到RDB过程完成 bgsave指令：手工启动后台保存操作，不是立即执行 客户端执行bgsave,返回Background saving started消息，接下来调用fork函数生成子进程，创建.rdb文件 save配置：满足限定时间范围内key的变化数量达到指定数量即进行持久化（使用的bgsave） 方式二： AOF【增量】持久化，将数据的操作过程进行保存，日志形式，存储操作过程，存储格式复杂，关注点在数据的操作过程 AOF写数据三种策略(appendfsync)： always(每次） 每次写入操作均同步到AOF文件中，数据零误差，性能较低 everysec（每秒） 每秒将缓冲区中的指令同步到AOF文件中，数据准确性较高，性能较高 no（系统控制） 由操作系统控制每次同步到AOF文件的周期 AOF重写： 将对同一个数据的若干个条命令执行结果转化成最终结果数据对应的指令进行记录。 选择：不要仅仅使用RDB那样会丢失数据，也不要仅仅使用AOF，没有RDB恢复速度来的快 事务 multi 开启事务,设定事务的开启位置，此指令执行后，后续的所有指令均加入到事务中 exec 执行事务,设定事务的结束位置，同时执行事务。与multi成对出现，成对使用 加入事务的命令暂时进入到任务队列中，并没有立即执行，只有执行exec命令才开始执行 discard 取消事务 注意：如果有某一条命令执行失败，其后的命令仍然会被继续执行。 分布式锁 setnx 获取锁 expire 设置超时自动释放锁 删除策略 过期数据： 内存中的数据可以通过TTL指令获取其状态 XX：具有时效性的数据 -1：永久有效的数据 -2 ：已经过期的数据 或 被删除的数据 或 未定义的数据 数据删除策略： 定时删除：创建一个定时器，当key设置有过期时间，且过期时间到达时，由定时器任务立即执行对键的删除操作 惰性删除：数据到达过期时间，不做处理。等下次访问该数据时  如果未过期，返回数据  发现已过期，删除，返回不存在 定期删除：周期性轮询redis库中的时效性数据，采用随机抽取的策略，利用过期数据占比的方式控制删除频度 数据淘汰策略： 检测易失数据（可能会过期的数据集server.db[i].expires ） ① volatile-lru：挑选最近最少使用的数据淘汰 ② volatile-lfu：挑选最近使用次数最少的数据淘汰 ③ volatile-ttl：挑选将要过期的数据淘汰 ④ volatile-random：任意选择数据淘汰 检测全库数据（所有数据集server.db[i].dict ） ⑤ allkeys-lru：挑选最近最少使用的数据淘汰 ⑥ allkeys-lfu：挑选最近使用次数最少的数据淘汰 ⑦ allkeys-random：任意选择数据淘汰 放弃数据驱逐 ⑧ no-enviction（驱逐）：禁止驱逐数据（redis4.0中默认策略），会引发错误OOM（Out Of Memory） Redis 高级数据类型 HyperLogLog： 应用于独立信息统计 （用于进行基数（数据集去重后个数）统计，不是集合，不保存数据，只记录数量而不是具体数据） Geo：应用于地理位置计算（设置坐标点，计算坐标点距离及范围内数据） Bitmap：应用于信息状态统计（对key按位进行交、并、非、或操作） 主从复制 主从复制即将master中的数据即时、有效的复制到slave中 特征：一个master可以拥有多个slave，一个slave只对应一个master **职责： ** master:  写数据  执行写操作时，将出现变化的数据自动同步到slave  读数据（可忽略）  slave:  读数据  写数据（禁止） 过程： 建立连接阶段（即准备阶段） slave保存master的IP与端口，创建连接maste的socket，master保存slave的端口 数据同步阶段 初次连接master后，复制master中的所有数据到slave 全量复制：接收master的RDB，清空数据，执行RDB文件恢复过程 部分复制：接收master的缓冲区信息，执行bgrewriteaof，恢复数据 master保存slave当前数据同步的位置 命令传播阶段 master与slave间需要进行信息交换，使用心跳机制进行维护，实现双方连接保持在线 哨兵机制 哨兵： 是一个分布式系统，用于对主从结构中的每台服务器进行监控，当出现故障时通过投票机制选择新的 master并将所有slave连接到新的master。 缓存预热 缓存预热就是系统启动前，提前将相关的缓存数据直接加载到缓存系统。避免在用户请求的时候，先查询数据库，然后再将数据缓 存的问题！用户直接查询事先被预热的缓存数据！ 解决方案 前置准备工作： 1. 日常例行统计数据访问记录，统计访问频度较高的热点数据 2. 利用LRU数据删除策略，构建数据留存队列 例如：storm与kafka配合 准备工作： 1. 将统计结果中的数据分类，根据级别，redis优先加载级别较高的热点数据 2. 利用分布式多服务器同时进行数据读取，提速数据加载过程 3. 热点数据主从同时预热 实施： 1. 使用脚本程序固定触发数据预热过程 2. 如果条件允许，使用了CDN（内容分发网络），效果会更好 缓存雪崩 短时间内大量key过期 解决 LRU与LFU切换 数据有效期策略调整  根据业务数据有效期进行分类错峰，A类90分钟，B类80分钟，C类70分钟  过期时间使用固定时间+随机值的形式，稀释集中到期的key的数量 超热数据使用永久key 定期维护（自动+人工） 对即将过期数据做访问量分析，确认是否延时，配合访问量统计，做热点数据的延时 缓存击穿 缓存击穿就是单个高热数据过期的瞬间，数据访问量较大，未命中redis后，发起了大量对同一数据的数据库访问 解决： 预先设定 以电商为例，每个商家根据店铺等级，指定若干款主打商品，在购物节期间，加大此类信息key的过期时长 注意：购物节不仅仅指当天，以及后续若干天，访问峰值呈现逐渐降低的趋势 现场调整 监控访问量，对自然流量激增的数据延长过期时间或设置为永久性key 后台刷新数据 启动定时任务，高峰期来临之前，刷新数据有效期，确保不丢失 二级缓存 设置不同的失效时间，保障不会被同时淘汰就行 缓存穿透 缓存击穿访问了不存在的数据，跳过了合法数据的redis数据缓存阶段，每次访问数据库，导致对数据库服务器造成压力 解决 缓存null 对查询结果为null的数据进行缓存（长期使用，定期清理），设定短时限，例如30-60秒，最高5分钟 白名单策略  提前预热各种分类数据id对应的bitmaps，id作为bitmaps的offset，相当于设置了数据白名单。当加载正常数据时，放 行，加载异常数据时直接拦截（效率偏低）  使用布隆过滤器（有关布隆过滤器的命中问题对当前状况可以忽略） 实施监控 实时监控redis命中率（业务正常范围时，通常会有一个波动值）与null数据的占比  非活动时段波动：通常检测3-5倍，超过5倍纳入重点排查对象  活动时段波动：通常检测10-50倍，超过50倍纳入重点排查对象 根据倍数不同，启动不同的排查流程。然后使用黑名单进行防控（运营） key加密 问题出现后，临时启动防灾业务key，对key进行业务层传输加密服务，设定校验程序，过来的key校验 例如每天随机分配60个加密串，挑选2到3个，混淆到页面数据id中，发现访问key不满足规则，驳回数据访问</summary></entry><entry><title type="html">Rabbitmq笔记</title><link href="https://jialiangbujiaj1a.github.io//2021/03/05/RabbitMQ%E7%AC%94%E8%AE%B0.html" rel="alternate" type="text/html" title="Rabbitmq笔记" /><published>2021-03-05T00:00:00+00:00</published><updated>2021-03-05T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2021/03/05/RabbitMQ%E7%AC%94%E8%AE%B0</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2021/03/05/RabbitMQ%E7%AC%94%E8%AE%B0.html">&lt;h1 id=&quot;rabbitmq笔记&quot;&gt;RabbitMQ笔记&lt;/h1&gt;

&lt;h2 id=&quot;1基础概念&quot;&gt;1、基础概念&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;ConnectionFactory、Connection、Channel：&lt;/strong&gt;ConnectionFactory、Connection、Channel都是RabbitMQ对外提供的API中最基本的对象。Connection是RabbitMQ的socket链接，它封装了socket协议相关部分逻辑。ConnectionFactory为Connection的制造工厂。 Channel是在 connection 内部建立的逻辑连接（每访问一次mq建立一个连接，开销巨大），如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，大部分的业务操作是在Channel这个接口中完成的，包括定义Queue、定义Exchange、绑定Queue与Exchange、发布消息等。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Message acknowledgment：&lt;/strong&gt;消息回执&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Message durability：&lt;/strong&gt;消息持久化&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Broker:&lt;/strong&gt;接收和分发消息的应用，&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;RabbitMQ Server就是 Message Broker。&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Virtual host:&lt;/strong&gt;把AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Queue:&lt;/strong&gt;队列对象，用于存储消息&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Exchange：&lt;/strong&gt;message 到达 broker 的第一站，根据分发规则，&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;匹配查询表中的 routing key，&lt;/code&gt;分发消息到queue 中去。常用的类型有：&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;direct (point-to-point)&lt;/code&gt;把消息路由到那些binding key与routing key完全匹配的Queue中&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;topic (publish-subscribe)&lt;/code&gt;把消息路由到那些binding key与routing key通配符匹配的Queue中，*用于匹配一个单词，#用于匹配多个单词（可以0个）&lt;/li&gt;
  &lt;li&gt;&lt;code class=&quot;language-plaintext highlighter-rouge&quot;&gt;fanout (multicast)&lt;/code&gt;把所有发送到该Exchange的消息路由到所有与它绑定的Queue中&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Routing key:&lt;/strong&gt;生产者在将消息发送给Exchange的时候，一般会指定一个routing key，来指定这个消息的路由规则，而这个routing key需要与Exchange Type及binding key联合使用才能最终生效。 RabbitMQ为routing key设定的长度限制为255 bytes。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Binding:&lt;/strong&gt;exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Binding key:&lt;/strong&gt;在绑定（Binding）Exchange与Queue的同时，一般会指定一个binding key；消费者将消息发送给Exchange时，一般会指定一个routing key；当binding key与routing key相匹配时，消息将会被路由到对应的Queue中。&lt;/p&gt;

&lt;h2 id=&quot;2运转流程&quot;&gt;2、运转流程&lt;/h2&gt;

&lt;ul&gt;
  &lt;li&gt;生产者发送消息
    &lt;ol&gt;
      &lt;li&gt;生产者创建连接（Connection），开启一个信道（Channel），连接到RabbitMQ Broker；&lt;/li&gt;
      &lt;li&gt;声明队列并设置属性；如是否排它，是否持久化，是否自动删除；&lt;/li&gt;
      &lt;li&gt;将路由键（空字符串）与队列绑定起来；&lt;/li&gt;
      &lt;li&gt;发送消息至RabbitMQ Broker；&lt;/li&gt;
      &lt;li&gt;关闭信道；&lt;/li&gt;
      &lt;li&gt;关闭连接；&lt;/li&gt;
    &lt;/ol&gt;
  &lt;/li&gt;
  &lt;li&gt;消费者接收消息
    &lt;ol&gt;
      &lt;li&gt;消费者创建连接（Connection），开启一个信道（Channel），连接到RabbitMQ Broker&lt;/li&gt;
      &lt;li&gt;向Broker 请求消费相应队列中的消息，设置相应的回调函数；&lt;/li&gt;
      &lt;li&gt;等待Broker回应闭关投递响应队列中的消息，消费者接收消息；&lt;/li&gt;
      &lt;li&gt;确认（ack，自动确认）接收到的消息；&lt;/li&gt;
      &lt;li&gt;RabbitMQ从队列中删除相应已经被确认的消息；&lt;/li&gt;
      &lt;li&gt;关闭信道；&lt;/li&gt;
      &lt;li&gt;关闭连接；&lt;/li&gt;
    &lt;/ol&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;3ttltime-to-live-过期时间&quot;&gt;3、TTL（Time-To-Live 过期时间）&lt;/h2&gt;

&lt;p&gt;RabbitMQ可以对消息和队列设置TTL。第一种方法是通过队列属性设置(channel.queueDeclare方法中加入x-message-ttl参数，单位为ms.)，队列中所有消息都有相同的过期时间。第二种方法是对消息进行单独设置（channel.basicPublish方法中加入expiration的属性参数，单位为ms.），每条消息TTL可以不同，每条消息是否过期是在该消息在队列头部时（消费时）才会判定。如果上述两种方法同时使用，则消息的过期时间以两者之间TTL较小的那个数值为准。消息在队列的生存时间一旦超过设置的TTL值，就称为dead message， 消费者将无法再收到该消息。&lt;/p&gt;

&lt;h2 id=&quot;4dlx死信队列&quot;&gt;4、DLX(死信队列)&lt;/h2&gt;

&lt;p&gt;DLX, Dead-Letter-Exchange。利用DLX, 当消息在一个队列中变成死信（dead message）之后，它能被重新publish到另一个Exchange，这个Exchange就是DLX。消息变成死信一向有一下几种情况：&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;队列消息长度到达限制；&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;原队列存在消息过期设置，消息到达超时时间未被消费；&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;DLX也是一个正常的Exchange，和一般的Exchange没有区别，它能在任何的队列上被指定，实际上就是设置某个队列的属性，当这个队列中有死信时，RabbitMQ就会自动的将这个消息重新发布到设置的Exchange上去，进而被路由到另一个队列，可以监听这个队列中消息做相应的处理，这个特性可以弥补RabbitMQ 3.0以前支持的immediate参数（可以参考&lt;a href=&quot;http://blog.csdn.net/u013256816/article/details/54914525&quot;&gt;RabbitMQ之mandatory和immediate&lt;/a&gt;）的功能。&lt;/p&gt;

&lt;p&gt;核心代码实现：通过在queueDeclare方法中加入“x-dead-letter-exchange”实现。你也可以为这个DLX指定routing key，如果没有特殊指定，则使用原队列的routing key。&lt;/p&gt;

&lt;h2 id=&quot;5延迟队列&quot;&gt;5、延迟队列&lt;/h2&gt;

&lt;p&gt;TTL+DLX&lt;/p&gt;

&lt;h2 id=&quot;6消息可靠性&quot;&gt;6、消息可靠性&lt;/h2&gt;

&lt;h3 id=&quot;61-服务端确认机制-事务机制&quot;&gt;6.1 服务端确认机制-事务机制&lt;/h3&gt;

&lt;p&gt;通过一个 channel.txSelect()的方法把信道设置成事务模式，然后就可以发布消息给 RabbitMQ 了，如果 channel.txCommit();的方法调用成功，就说明事务提交成功，则消息一定到达了 RabbitMQ 中。如果在事务提交执行之前由于 RabbitMQ 异常崩溃或者其他原因抛出异常，这个时候我们便可以将其捕获，进而通过执行 channel.txRollback()方法来实现事务回滚。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;缺点&lt;/strong&gt;：在事务模式里面，只有收到了服务端的 Commit-OK 的指令，才能提交成功。所以可以解决生产者和服务端确认的问题。但是&lt;strong&gt;事务模式有一个缺点，它是阻塞的&lt;/strong&gt;，&lt;/p&gt;

&lt;h3 id=&quot;62-服务端确认机制-confirm确认模式&quot;&gt;6.2 &lt;strong&gt;服务端确认机制-Confirm(确认)模式&lt;/strong&gt;：&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;1.普通确认模式&lt;/strong&gt;：在生产者这边通过调用 channel.confirmSelect()方法将信道设置为 Confirm 模式，然后发送消息。一旦消息被投递到所有匹配的队列之后，RabbitMQ 就会发送一个确认(Basic.Ack)给生产者，也就是调用 channel.waitForConfirms()返回 true，这样生产者就知道消息被服务端接收了！—-》方式消息效率还不是太高&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2.批量确认模式&lt;/strong&gt;：批量确认，就是在开启 Confirm 模式后，先发送一批消息。只要channel.waitForConfirmsOrDie();方法没有抛出异常，就代表消息都被服务端接收了。&lt;/p&gt;

&lt;p&gt;批量确认的方式比单条确认的方式效率要高，但是也有两个问题，第一个就是批量的数量的确定。对于不同的业务，到底发送多少条消息确认一次?数量太少，效率提升不上去。数量多的话，又会带来另一个问题，比如我们发 1000 条消息才确认一次，如果前面 999 条消息都被服务端接收了，如果第 1000 条消息被拒绝了，那么前面所有的消息都要重发。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3.异步确认模式&lt;/strong&gt;：一边发送一边确认！异步确认模式需要添加一个 ConfirmListener，并且用一个 SortedSet 来维护没有被确认的消息。Confirm 模式是在 Channel 上开启的，Ø使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。&lt;/p&gt;

&lt;h3 id=&quot;63-消息从交换机路由到队列&quot;&gt;6.3 消息从交换机路由到队列&lt;/h3&gt;

&lt;p&gt;rebbitmqTemplate设置mandatory为true&lt;/p&gt;

&lt;p&gt;使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。并执行回调函数returnedMessage。&lt;/p&gt;

&lt;h3 id=&quot;64-持久化&quot;&gt;6.4 持久化&lt;/h3&gt;

&lt;p&gt;1）队列持久化 2）交换机持久化 3)消息持久化 4）集群&lt;/p&gt;

&lt;h3 id=&quot;65-消费者ack&quot;&gt;6.5 消费者ACK&lt;/h3&gt;

&lt;p&gt;ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。&lt;/p&gt;

&lt;p&gt;有三种确认方式：&lt;/p&gt;

&lt;p&gt;•自动确认：acknowledge=”none”&lt;/p&gt;

&lt;p&gt;•手动确认：acknowledge=”manual”&lt;/p&gt;

&lt;p&gt;•根据异常情况确认：acknowledge=”auto”，（这种方式使用麻烦，不作讲解）&lt;/p&gt;

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

&lt;h2 id=&quot;7消息幂等性&quot;&gt;7、消息幂等性&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;乐观锁&lt;/strong&gt;&lt;/p&gt;

&lt;h2 id=&quot;8消息顺序性&quot;&gt;8、消息顺序性&lt;/h2&gt;

&lt;p&gt;方案一，拆分多个 queue，每个 queue 一个 consumer&lt;/p&gt;

&lt;p&gt;方案二，或者就一个 queue 但是对应一个 consumer，然后这个 consumer 内部用内存队列做排队，然后分发给底层不同的 worker 来处理。&lt;/p&gt;</content><author><name>加量不加价</name></author><summary type="html">RabbitMQ笔记 1、基础概念 ConnectionFactory、Connection、Channel：ConnectionFactory、Connection、Channel都是RabbitMQ对外提供的API中最基本的对象。Connection是RabbitMQ的socket链接，它封装了socket协议相关部分逻辑。ConnectionFactory为Connection的制造工厂。 Channel是在 connection 内部建立的逻辑连接（每访问一次mq建立一个连接，开销巨大），如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，大部分的业务操作是在Channel这个接口中完成的，包括定义Queue、定义Exchange、绑定Queue与Exchange、发布消息等。 Message acknowledgment：消息回执 Message durability：消息持久化 Broker:接收和分发消息的应用，RabbitMQ Server就是 Message Broker。 Virtual host:把AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念 Queue:队列对象，用于存储消息 Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到queue 中去。常用的类型有： direct (point-to-point)把消息路由到那些binding key与routing key完全匹配的Queue中 topic (publish-subscribe)把消息路由到那些binding key与routing key通配符匹配的Queue中，*用于匹配一个单词，#用于匹配多个单词（可以0个） fanout (multicast)把所有发送到该Exchange的消息路由到所有与它绑定的Queue中 Routing key:生产者在将消息发送给Exchange的时候，一般会指定一个routing key，来指定这个消息的路由规则，而这个routing key需要与Exchange Type及binding key联合使用才能最终生效。 RabbitMQ为routing key设定的长度限制为255 bytes。 Binding:exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据 Binding key:在绑定（Binding）Exchange与Queue的同时，一般会指定一个binding key；消费者将消息发送给Exchange时，一般会指定一个routing key；当binding key与routing key相匹配时，消息将会被路由到对应的Queue中。 2、运转流程 生产者发送消息 生产者创建连接（Connection），开启一个信道（Channel），连接到RabbitMQ Broker； 声明队列并设置属性；如是否排它，是否持久化，是否自动删除； 将路由键（空字符串）与队列绑定起来； 发送消息至RabbitMQ Broker； 关闭信道； 关闭连接； 消费者接收消息 消费者创建连接（Connection），开启一个信道（Channel），连接到RabbitMQ Broker 向Broker 请求消费相应队列中的消息，设置相应的回调函数； 等待Broker回应闭关投递响应队列中的消息，消费者接收消息； 确认（ack，自动确认）接收到的消息； RabbitMQ从队列中删除相应已经被确认的消息； 关闭信道； 关闭连接； 3、TTL（Time-To-Live 过期时间） RabbitMQ可以对消息和队列设置TTL。第一种方法是通过队列属性设置(channel.queueDeclare方法中加入x-message-ttl参数，单位为ms.)，队列中所有消息都有相同的过期时间。第二种方法是对消息进行单独设置（channel.basicPublish方法中加入expiration的属性参数，单位为ms.），每条消息TTL可以不同，每条消息是否过期是在该消息在队列头部时（消费时）才会判定。如果上述两种方法同时使用，则消息的过期时间以两者之间TTL较小的那个数值为准。消息在队列的生存时间一旦超过设置的TTL值，就称为dead message， 消费者将无法再收到该消息。 4、DLX(死信队列) DLX, Dead-Letter-Exchange。利用DLX, 当消息在一个队列中变成死信（dead message）之后，它能被重新publish到另一个Exchange，这个Exchange就是DLX。消息变成死信一向有一下几种情况： 队列消息长度到达限制； 消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false； 原队列存在消息过期设置，消息到达超时时间未被消费； DLX也是一个正常的Exchange，和一般的Exchange没有区别，它能在任何的队列上被指定，实际上就是设置某个队列的属性，当这个队列中有死信时，RabbitMQ就会自动的将这个消息重新发布到设置的Exchange上去，进而被路由到另一个队列，可以监听这个队列中消息做相应的处理，这个特性可以弥补RabbitMQ 3.0以前支持的immediate参数（可以参考RabbitMQ之mandatory和immediate）的功能。 核心代码实现：通过在queueDeclare方法中加入“x-dead-letter-exchange”实现。你也可以为这个DLX指定routing key，如果没有特殊指定，则使用原队列的routing key。 5、延迟队列 TTL+DLX 6、消息可靠性 6.1 服务端确认机制-事务机制 通过一个 channel.txSelect()的方法把信道设置成事务模式，然后就可以发布消息给 RabbitMQ 了，如果 channel.txCommit();的方法调用成功，就说明事务提交成功，则消息一定到达了 RabbitMQ 中。如果在事务提交执行之前由于 RabbitMQ 异常崩溃或者其他原因抛出异常，这个时候我们便可以将其捕获，进而通过执行 channel.txRollback()方法来实现事务回滚。 缺点：在事务模式里面，只有收到了服务端的 Commit-OK 的指令，才能提交成功。所以可以解决生产者和服务端确认的问题。但是事务模式有一个缺点，它是阻塞的， 6.2 服务端确认机制-Confirm(确认)模式： 1.普通确认模式：在生产者这边通过调用 channel.confirmSelect()方法将信道设置为 Confirm 模式，然后发送消息。一旦消息被投递到所有匹配的队列之后，RabbitMQ 就会发送一个确认(Basic.Ack)给生产者，也就是调用 channel.waitForConfirms()返回 true，这样生产者就知道消息被服务端接收了！—-》方式消息效率还不是太高 2.批量确认模式：批量确认，就是在开启 Confirm 模式后，先发送一批消息。只要channel.waitForConfirmsOrDie();方法没有抛出异常，就代表消息都被服务端接收了。 批量确认的方式比单条确认的方式效率要高，但是也有两个问题，第一个就是批量的数量的确定。对于不同的业务，到底发送多少条消息确认一次?数量太少，效率提升不上去。数量多的话，又会带来另一个问题，比如我们发 1000 条消息才确认一次，如果前面 999 条消息都被服务端接收了，如果第 1000 条消息被拒绝了，那么前面所有的消息都要重发。 3.异步确认模式：一边发送一边确认！异步确认模式需要添加一个 ConfirmListener，并且用一个 SortedSet 来维护没有被确认的消息。Confirm 模式是在 Channel 上开启的，Ø使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。 6.3 消息从交换机路由到队列 rebbitmqTemplate设置mandatory为true 使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。并执行回调函数returnedMessage。 6.4 持久化 1）队列持久化 2）交换机持久化 3)消息持久化 4）集群 6.5 消费者ACK ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。 有三种确认方式： •自动确认：acknowledge=”none” •手动确认：acknowledge=”manual” •根据异常情况确认：acknowledge=”auto”，（这种方式使用麻烦，不作讲解） 其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。 7、消息幂等性 乐观锁 8、消息顺序性 方案一，拆分多个 queue，每个 queue 一个 consumer 方案二，或者就一个 queue 但是对应一个 consumer，然后这个 consumer 内部用内存队列做排队，然后分发给底层不同的 worker 来处理。</summary></entry><entry><title type="html">Java并发</title><link href="https://jialiangbujiaj1a.github.io//2021/03/01/Java%E5%B9%B6%E5%8F%91.html" rel="alternate" type="text/html" title="Java并发" /><published>2021-03-01T00:00:00+00:00</published><updated>2021-03-01T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2021/03/01/Java%E5%B9%B6%E5%8F%91</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2021/03/01/Java%E5%B9%B6%E5%8F%91.html">&lt;h1 id=&quot;java并发&quot;&gt;Java并发&lt;/h1&gt;

&lt;h2 id=&quot;进程与线程&quot;&gt;进程与线程&lt;/h2&gt;

&lt;h3 id=&quot;1线程进程程序&quot;&gt;1、线程、进程、程序&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;进程&lt;/strong&gt;是程序的实例，是程序（浏览器）的一次执行实例，进程可以分为一到多个线程。&lt;/p&gt;

&lt;p&gt;线程作为最小调度单位，进程作为资源分配的最小单位。&lt;/p&gt;

&lt;h3 id=&quot;2并发并行&quot;&gt;2、并发、并行&lt;/h3&gt;

&lt;p&gt;并发（concurrent）是同一时间应对多件事情的能力&lt;/p&gt;

&lt;p&gt;并行（parallel）是同一时间动手做多件事情的能力&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;单核 cpu 下，多线程不能实际提高程序运行效率，线程实际还是串行执行的，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu&lt;/strong&gt;&lt;/p&gt;

&lt;h2 id=&quot;java线程&quot;&gt;Java线程&lt;/h2&gt;

&lt;h3 id=&quot;1创建线程的四种方式&quot;&gt;1、创建线程的四种方式&lt;/h3&gt;

&lt;p&gt;1）继承Thread类创建线程（定义Thread类子类，重写run()方法，调用start()方法启动线程）&lt;/p&gt;

&lt;p&gt;2）实现Runnable接口创建线程（定义Runnable接口实现类，重写run()方法，将该类实例作为target创建Thread对象，调用start()方法启动线程）&lt;/p&gt;

&lt;p&gt;3）使用Callable和Future创建线程（创建Callable接口实现类，实现call()方法，使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值，使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口），调用FutureTask对象的get()方法来获得子线程执行结束后的返回值）&lt;/p&gt;

&lt;p&gt;Callable接口提供了一个call（）方法作为线程执行体，call()方法可以有返回值，可以声明抛出异常，Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。&lt;/p&gt;

&lt;p&gt;4）使用线程池例如用Executor框架&lt;/p&gt;

&lt;h3 id=&quot;2常见方法&quot;&gt;2、常见方法&lt;/h3&gt;

&lt;h4 id=&quot;thread类&quot;&gt;Thread类&lt;/h4&gt;

&lt;p&gt;&lt;strong&gt;start()&lt;/strong&gt; 让线程进入就绪状态，当得到CPU时间片时才会运行&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;run()&lt;/strong&gt; 线程启动后调用的方法（直接调用不会创建线程执行，Runnable方式创建，线程启动后调用Runnable的run()方法，继承Thread则是调用覆盖的run()方法）&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;join()&lt;/strong&gt; 当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;isInterrupted()&lt;/strong&gt; 判断是否被打断，不会清除打断标记&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;interrupt()&lt;/strong&gt; 打断线程（如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除打断标记 ；如果打断的正在运行的线程，则会设置打断标记 ；park 的线程被打断，也会设置 打断标记）&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;interrupted()&lt;/strong&gt; （static）判断当前线程是否被打断会清除打断标记&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;sleep(long n)&lt;/strong&gt; 线程进入阻塞状态，不释放锁资源（static）让当前执行的线程休眠n毫秒，并让出cpu的时间片给其它线程&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;yield()&lt;/strong&gt; 线程进入就绪状态，不释放锁资源（static）提示线程调度器让出当前线程对CPU的使用&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;stop()&lt;/strong&gt; 停止线程运行 比较暴力，已过时&lt;/p&gt;

&lt;h4 id=&quot;object类&quot;&gt;Object类&lt;/h4&gt;

&lt;p&gt;&lt;strong&gt;wait()&lt;/strong&gt; 当前线程释放对象锁，进入等待队列 使用是需要对象锁，而LockSupport.park()不需要&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;notify()&lt;/strong&gt; 唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。&lt;/p&gt;

&lt;h3 id=&quot;守护线程&quot;&gt;守护线程&lt;/h3&gt;

&lt;p&gt;为用户线程服务，只要非守护线程运行结束，即使守护线程没有执行完，也会强制结束。&lt;/p&gt;

&lt;p&gt;可以通过Thread.setDaemon(true)设置线程为守护线程（在start()方法之前）&lt;/p&gt;

&lt;h3 id=&quot;线程状态&quot;&gt;线程状态&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;初始状态NEW&lt;/strong&gt; 实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;就绪状态（运行中状态）&lt;/strong&gt; 调用start()方法进入就绪状态，获得CPU时间片进入运行中状态，用完时间片、调用当前线程yield()或获取到锁的线程进入就绪状态&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;阻塞状态&lt;/strong&gt; 线程阻塞在进入synchronized或者lock时的状态&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;等待状态&lt;/strong&gt; 此状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;超时等待状态&lt;/strong&gt; 处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;终止状态&lt;/strong&gt; 当线程的run()方法完成时，或者主线程的main()方法完成时，就认为它终止&lt;/p&gt;

&lt;h2 id=&quot;synchronized&quot;&gt;Synchronized&lt;/h2&gt;

&lt;h3 id=&quot;1介绍&quot;&gt;1、介绍&lt;/h3&gt;

&lt;p&gt;Synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。加锁解锁由JVM实现。&lt;/p&gt;

&lt;h3 id=&quot;2用法&quot;&gt;2、用法&lt;/h3&gt;

&lt;blockquote&gt;
  &lt;p&gt;用于普通同步方法，锁是当前实例对象&lt;/p&gt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
  &lt;p&gt;用于静态同步方法，锁是当前类的class对象&lt;/p&gt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
  &lt;p&gt;用于同步方法块，锁是括号里面的对象&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h3 id=&quot;3原理&quot;&gt;3、原理&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;Java对象头&lt;/strong&gt; synchronized用的锁存在对象头中，对象头包含Mark Word（标记字段，用于存储对象自身运行时数据）、Klass Pointer（类型指针，对象指向它的类元数据指针）&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Monitor监视器&lt;/strong&gt; 每个对象头都可以关联一个Monitor对象，当用Synchronized给对象上锁后，对象头的 MarkWord 中的LockWord指向Monitor的起始地址&lt;/p&gt;

&lt;p&gt;刚开始 Monitor中Owner为null，当第一个线程执行synchronized(obj)就会将Monitor的所有者Owner置为自己，Monitor中只能有一个 Owner，如果其它线程也来执行 synchronized(obj)，就会进入阻塞队列 BLOCKED，当第一个线程执行完同步代码块的内容，然后唤醒阻塞队列中等待的线程来竞争锁，竞争的时是非公平的&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;实现&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;同步代码块是使用 monitorenter 和 monitorexit 指令实现的；&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;同步方法（在这看不出来需要看JVM底层实现）依靠的是方法修饰符上的ACC_SYNCHRONIZED 实现。&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;4轻量级锁&quot;&gt;4、轻量级锁&lt;/h3&gt;

&lt;p&gt;不存在多线程竞争（多线程加锁时间错开），减少重量级锁的性能消耗&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;流程&lt;/strong&gt; 每个线程都的栈帧都会包含一个锁记录（Lock Record）的结构，内部可以存储锁定对象的Mark Word，加锁时让锁记录中 Object reference指向锁对象，并尝试用cas替换对象的 Mark Word，将Mark Word的值存入锁记录，如果cas替换成功，对象头中存储了锁记录地址和状态00 ，表示由该线程给对象加锁；若cas失败，一种情况是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程；另一种情况是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数，当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一；当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头成功，则解锁成功，失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程&lt;/p&gt;

&lt;h3 id=&quot;5锁膨胀&quot;&gt;5、锁膨胀&lt;/h3&gt;

&lt;p&gt;尝试加轻量级锁的过程中，CAS（线程锁记录交换对象的Mark word） 操作无法成功，可能有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;流程&lt;/strong&gt; 锁对象指向Monitor锁地址，当前线程进入阻塞队列阻塞，当进入同步块的线程解锁时，使用cas交换锁记录中的Mark word给对象头，此时失败，会按照对象头中Monitor地址找到Monitor设置owner为null，唤醒阻塞队列中线程&lt;/p&gt;

&lt;h3 id=&quot;6自旋锁&quot;&gt;6、自旋锁&lt;/h3&gt;

&lt;p&gt;让该线程等待一段时间，不会被立即挂起，看持有锁的线程是否会很快释放锁。自旋（执行一段无意义的循环）。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;适应自旋锁&lt;/strong&gt; 若对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋&lt;/p&gt;

&lt;h3 id=&quot;7偏向锁&quot;&gt;7、偏向锁&lt;/h3&gt;

&lt;p&gt;轻量级锁在没有竞争时（只有一个线程获取锁），每次重入仍然需要执行 CAS 操作。&lt;/p&gt;

&lt;p&gt;Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后只需检查 ThreadID 是否是自己，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;撤销&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;调用对象 hashCode （偏向锁的对象 MarkWord 中存储的是线程 id&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;其它线程使用对象（当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁）&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;调用 wait/notify&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;批量重偏向&lt;/strong&gt; 如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象的 Thread ID当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至加锁线程&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;批量撤销&lt;/strong&gt; 当撤销偏向锁阈值超过 40 次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的&lt;/p&gt;

&lt;h3 id=&quot;8总结&quot;&gt;8、总结&lt;/h3&gt;

&lt;p&gt;（同一线程下）轻量级锁是线程的锁记录与锁对象的Mark word交换（每次都是），偏向锁是第一次用线程ID替换锁对象的Mark word，之后检查线程ID是否是自己&lt;/p&gt;

&lt;p&gt;轻量级锁锁的是线程的锁记录，重量级锁锁的是Monitor对象&lt;/p&gt;

&lt;h3 id=&quot;死锁活锁&quot;&gt;死锁/活锁&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;死锁&lt;/strong&gt; 多个线程相互争夺对方已有的资源，造成的相互等待&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;活锁&lt;/strong&gt; 两个线程互相改变对方的结束条件，导致都无法结束&lt;/p&gt;

&lt;h3 id=&quot;waitnotify&quot;&gt;wait/notify&lt;/h3&gt;

&lt;p&gt;进入同步块的线程调用wait()方法变为waiting状态，此时线程阻塞，释放锁，直到Monitor的owner线程调用notify()/notifyAll()唤醒，进入阻塞队列竞争&lt;/p&gt;

&lt;h2 id=&quot;volatile&quot;&gt;volatile&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;作用&lt;/strong&gt; 保证可见性，避免指令重排&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;原理&lt;/strong&gt; 底层实现原理是内存屏障，对 volatile 变量的写指令后会加入写屏障，读指令前会加入读屏障&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;内存屏障&lt;/strong&gt; 屏障下面的代码不能跟屏障上面的代码交换执行顺序。在有内存屏障的地方，线程修改完共享变量以后会马上把该变量从本地内存写回到主内存，并且让其他线程本地内存中该变量副本失效&lt;/p&gt;

&lt;h2 id=&quot;aqs&quot;&gt;AQS&lt;/h2&gt;

&lt;p&gt;抽象队列同步器，是阻塞式锁和同步器工具的框架&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;特点&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;用volatile修饰的state属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁。 getState - 获取 state 状态，setState - 设置 state 状态，compareAndSetState - cas 机制设置 state 状态，独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;提供了基于 FIFO 的等待队列，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态 waitStatus&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;reentrantlock&quot;&gt;ReentrantLock&lt;/h2&gt;

&lt;p&gt;可重入锁，默认非公平&lt;/p&gt;

&lt;h3 id=&quot;加锁流程&quot;&gt;加锁流程&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;当没有竞争时，CAS修改state=1，设置当前线程为独占线程；&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;此时再有一个线程竞争时，cas尝试修改state由0到1，失败，构造等待队列节点，最终队列中第一个节点为哨兵节点，不关联线程，且waitStatus=-1，下一个节点关联当前等待线程，waitStatus=0&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;解锁流程&quot;&gt;解锁流程&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;获取锁成功的流程释放锁，设置独占线程为null，设置state=0；&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;若等待队列不为null，并且head的waitStatus=-1,找到队列中head的下一个node，unPark()，若该node关联线程加锁成功，CAS修改state=1，设置当前线程为独占线程，头结点指向该线程关联节点，清空该节点关联线程，之前头结点从链表断开，可以垃圾回收&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;若获取锁成功的流程释放锁后又来一个线程参与竞争，且竞争成功，会将新线程设置为独占线程，node节点关联的线程重新park()阻塞&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;可重入原理&quot;&gt;可重入原理&lt;/h3&gt;

&lt;ul&gt;
  &lt;li&gt;
    &lt;p&gt;若当前线程已经获取到锁，再次获取锁，则发生了锁重入，对state自增即可&lt;/p&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;p&gt;解锁时对state自减，只有减为0，锁才释放成功&lt;/p&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h3 id=&quot;公平锁原理&quot;&gt;公平锁原理&lt;/h3&gt;

&lt;p&gt;相比非公平锁，公平锁在获取同步状态时会检查阻塞队列中是否有阻塞的线程，即自己不是首个等待获取同步状态的节点&lt;/p&gt;

&lt;h3 id=&quot;条件变量&quot;&gt;条件变量&lt;/h3&gt;

&lt;p&gt;每个条件变量对应一个等待队列&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;await流程&lt;/strong&gt; 当前持有锁的线程调用await，创建新的Node状态为-2，关联当前线程，加入等待队列尾部&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;signal流程&lt;/strong&gt; 持有锁线程唤醒等待队列线程，即将等待队列中Node加入AQS队列尾部，将waitStatus改为0，将上一个节点waitStatus改为-1&lt;/p&gt;

&lt;h2 id=&quot;readwritelock&quot;&gt;ReadWriteLock&lt;/h2&gt;

&lt;p&gt;读写锁支持多个读操作并发执行，写操作只能由一个线程来操作。内部使用同一个state和队列，读锁占用state的高16位，写锁占用低16位。&lt;/p&gt;

&lt;h2 id=&quot;semaphorecountdownlatchcyclibarrier&quot;&gt;Semaphore/Countdownlatch/CycliBarrier&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Semaphore&lt;/strong&gt; 信号量，用来限制同时访问共享资源的线程上限&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Countdownlatch&lt;/strong&gt; 用来线程同步操作，等待所有线程完成倒计时，构造参数用来初始化等待计数值，await()用来等待计数归零，countDown()用来让计数减一&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;CyclicBarrier&lt;/strong&gt; 循环栅栏，用来进行线程协调，等待线程满足某个计数，构造时设置计数个数，每个线程执行到某个需要同步的时刻调用await()等待，当等待的线程数满足计数个数时，继续执行。&lt;/p&gt;</content><author><name>加量不加价</name></author><category term="Java并发" /><summary type="html">Java并发 进程与线程 1、线程、进程、程序 进程是程序的实例，是程序（浏览器）的一次执行实例，进程可以分为一到多个线程。 线程作为最小调度单位，进程作为资源分配的最小单位。 2、并发、并行 并发（concurrent）是同一时间应对多件事情的能力 并行（parallel）是同一时间动手做多件事情的能力 单核 cpu 下，多线程不能实际提高程序运行效率，线程实际还是串行执行的，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu Java线程 1、创建线程的四种方式 1）继承Thread类创建线程（定义Thread类子类，重写run()方法，调用start()方法启动线程） 2）实现Runnable接口创建线程（定义Runnable接口实现类，重写run()方法，将该类实例作为target创建Thread对象，调用start()方法启动线程） 3）使用Callable和Future创建线程（创建Callable接口实现类，实现call()方法，使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值，使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口），调用FutureTask对象的get()方法来获得子线程执行结束后的返回值） Callable接口提供了一个call（）方法作为线程执行体，call()方法可以有返回值，可以声明抛出异常，Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。 4）使用线程池例如用Executor框架 2、常见方法 Thread类 start() 让线程进入就绪状态，当得到CPU时间片时才会运行 run() 线程启动后调用的方法（直接调用不会创建线程执行，Runnable方式创建，线程启动后调用Runnable的run()方法，继承Thread则是调用覆盖的run()方法） join() 当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁 isInterrupted() 判断是否被打断，不会清除打断标记 interrupt() 打断线程（如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除打断标记 ；如果打断的正在运行的线程，则会设置打断标记 ；park 的线程被打断，也会设置 打断标记） interrupted() （static）判断当前线程是否被打断会清除打断标记 sleep(long n) 线程进入阻塞状态，不释放锁资源（static）让当前执行的线程休眠n毫秒，并让出cpu的时间片给其它线程 yield() 线程进入就绪状态，不释放锁资源（static）提示线程调度器让出当前线程对CPU的使用 stop() 停止线程运行 比较暴力，已过时 Object类 wait() 当前线程释放对象锁，进入等待队列 使用是需要对象锁，而LockSupport.park()不需要 notify() 唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。 守护线程 为用户线程服务，只要非守护线程运行结束，即使守护线程没有执行完，也会强制结束。 可以通过Thread.setDaemon(true)设置线程为守护线程（在start()方法之前） 线程状态 初始状态NEW 实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来 就绪状态（运行中状态） 调用start()方法进入就绪状态，获得CPU时间片进入运行中状态，用完时间片、调用当前线程yield()或获取到锁的线程进入就绪状态 阻塞状态 线程阻塞在进入synchronized或者lock时的状态 等待状态 此状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒 超时等待状态 处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。 终止状态 当线程的run()方法完成时，或者主线程的main()方法完成时，就认为它终止 Synchronized 1、介绍 Synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。加锁解锁由JVM实现。 2、用法 用于普通同步方法，锁是当前实例对象 用于静态同步方法，锁是当前类的class对象 用于同步方法块，锁是括号里面的对象 3、原理 Java对象头 synchronized用的锁存在对象头中，对象头包含Mark Word（标记字段，用于存储对象自身运行时数据）、Klass Pointer（类型指针，对象指向它的类元数据指针） Monitor监视器 每个对象头都可以关联一个Monitor对象，当用Synchronized给对象上锁后，对象头的 MarkWord 中的LockWord指向Monitor的起始地址 刚开始 Monitor中Owner为null，当第一个线程执行synchronized(obj)就会将Monitor的所有者Owner置为自己，Monitor中只能有一个 Owner，如果其它线程也来执行 synchronized(obj)，就会进入阻塞队列 BLOCKED，当第一个线程执行完同步代码块的内容，然后唤醒阻塞队列中等待的线程来竞争锁，竞争的时是非公平的 实现 同步代码块是使用 monitorenter 和 monitorexit 指令实现的； 同步方法（在这看不出来需要看JVM底层实现）依靠的是方法修饰符上的ACC_SYNCHRONIZED 实现。 4、轻量级锁 不存在多线程竞争（多线程加锁时间错开），减少重量级锁的性能消耗 流程 每个线程都的栈帧都会包含一个锁记录（Lock Record）的结构，内部可以存储锁定对象的Mark Word，加锁时让锁记录中 Object reference指向锁对象，并尝试用cas替换对象的 Mark Word，将Mark Word的值存入锁记录，如果cas替换成功，对象头中存储了锁记录地址和状态00 ，表示由该线程给对象加锁；若cas失败，一种情况是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程；另一种情况是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数，当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一；当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头成功，则解锁成功，失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程 5、锁膨胀 尝试加轻量级锁的过程中，CAS（线程锁记录交换对象的Mark word） 操作无法成功，可能有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。 流程 锁对象指向Monitor锁地址，当前线程进入阻塞队列阻塞，当进入同步块的线程解锁时，使用cas交换锁记录中的Mark word给对象头，此时失败，会按照对象头中Monitor地址找到Monitor设置owner为null，唤醒阻塞队列中线程 6、自旋锁 让该线程等待一段时间，不会被立即挂起，看持有锁的线程是否会很快释放锁。自旋（执行一段无意义的循环）。 适应自旋锁 若对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋 7、偏向锁 轻量级锁在没有竞争时（只有一个线程获取锁），每次重入仍然需要执行 CAS 操作。 Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后只需检查 ThreadID 是否是自己，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有。 撤销 调用对象 hashCode （偏向锁的对象 MarkWord 中存储的是线程 id 其它线程使用对象（当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁） 调用 wait/notify 批量重偏向 如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象的 Thread ID当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至加锁线程 批量撤销 当撤销偏向锁阈值超过 40 次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的 8、总结 （同一线程下）轻量级锁是线程的锁记录与锁对象的Mark word交换（每次都是），偏向锁是第一次用线程ID替换锁对象的Mark word，之后检查线程ID是否是自己 轻量级锁锁的是线程的锁记录，重量级锁锁的是Monitor对象 死锁/活锁 死锁 多个线程相互争夺对方已有的资源，造成的相互等待 活锁 两个线程互相改变对方的结束条件，导致都无法结束 wait/notify 进入同步块的线程调用wait()方法变为waiting状态，此时线程阻塞，释放锁，直到Monitor的owner线程调用notify()/notifyAll()唤醒，进入阻塞队列竞争 volatile 作用 保证可见性，避免指令重排 原理 底层实现原理是内存屏障，对 volatile 变量的写指令后会加入写屏障，读指令前会加入读屏障 内存屏障 屏障下面的代码不能跟屏障上面的代码交换执行顺序。在有内存屏障的地方，线程修改完共享变量以后会马上把该变量从本地内存写回到主内存，并且让其他线程本地内存中该变量副本失效 AQS 抽象队列同步器，是阻塞式锁和同步器工具的框架 特点 用volatile修饰的state属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁。 getState - 获取 state 状态，setState - 设置 state 状态，compareAndSetState - cas 机制设置 state 状态，独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源 提供了基于 FIFO 的等待队列，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态 waitStatus 条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet ReentrantLock 可重入锁，默认非公平 加锁流程 当没有竞争时，CAS修改state=1，设置当前线程为独占线程； 此时再有一个线程竞争时，cas尝试修改state由0到1，失败，构造等待队列节点，最终队列中第一个节点为哨兵节点，不关联线程，且waitStatus=-1，下一个节点关联当前等待线程，waitStatus=0 解锁流程 获取锁成功的流程释放锁，设置独占线程为null，设置state=0； 若等待队列不为null，并且head的waitStatus=-1,找到队列中head的下一个node，unPark()，若该node关联线程加锁成功，CAS修改state=1，设置当前线程为独占线程，头结点指向该线程关联节点，清空该节点关联线程，之前头结点从链表断开，可以垃圾回收 若获取锁成功的流程释放锁后又来一个线程参与竞争，且竞争成功，会将新线程设置为独占线程，node节点关联的线程重新park()阻塞 可重入原理 若当前线程已经获取到锁，再次获取锁，则发生了锁重入，对state自增即可 解锁时对state自减，只有减为0，锁才释放成功 公平锁原理 相比非公平锁，公平锁在获取同步状态时会检查阻塞队列中是否有阻塞的线程，即自己不是首个等待获取同步状态的节点 条件变量 每个条件变量对应一个等待队列 await流程 当前持有锁的线程调用await，创建新的Node状态为-2，关联当前线程，加入等待队列尾部 signal流程 持有锁线程唤醒等待队列线程，即将等待队列中Node加入AQS队列尾部，将waitStatus改为0，将上一个节点waitStatus改为-1 ReadWriteLock 读写锁支持多个读操作并发执行，写操作只能由一个线程来操作。内部使用同一个state和队列，读锁占用state的高16位，写锁占用低16位。 Semaphore/Countdownlatch/CycliBarrier Semaphore 信号量，用来限制同时访问共享资源的线程上限 Countdownlatch 用来线程同步操作，等待所有线程完成倒计时，构造参数用来初始化等待计数值，await()用来等待计数归零，countDown()用来让计数减一 CyclicBarrier 循环栅栏，用来进行线程协调，等待线程满足某个计数，构造时设置计数个数，每个线程执行到某个需要同步的时刻调用await()等待，当等待的线程数满足计数个数时，继续执行。</summary></entry><entry><title type="html">优雅的转换Bean对象</title><link href="https://jialiangbujiaj1a.github.io//2020/11/10/%E4%BC%98%E9%9B%85%E7%9A%84%E8%BD%AC%E6%8D%A2Bean%E5%AF%B9%E8%B1%A1.html" rel="alternate" type="text/html" title="优雅的转换Bean对象" /><published>2020-11-10T00:00:00+00:00</published><updated>2020-11-10T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2020/11/10/%E4%BC%98%E9%9B%85%E7%9A%84%E8%BD%AC%E6%8D%A2Bean%E5%AF%B9%E8%B1%A1</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2020/11/10/%E4%BC%98%E9%9B%85%E7%9A%84%E8%BD%AC%E6%8D%A2Bean%E5%AF%B9%E8%B1%A1.html">&lt;h3 id=&quot;对比&quot;&gt;对比&lt;/h3&gt;

&lt;p&gt;BeanUtils.copyProperties：如果是用Apache的BeanUtil类，有很大的性能问题，如果采用的是像Spring的BeanUtils类，要在调用次数足够多的时候，你才能明显的感受到卡顿&lt;/p&gt;

&lt;p&gt;复制对象时字段类型不一致 复制对象时字段名称不一致 如果是集合类的复制，例如List转换为List 该如何解决？&lt;/p&gt;

&lt;h3 id=&quot;mapstruct&quot;&gt;MapStruct&lt;/h3&gt;

&lt;h4 id=&quot;pom&quot;&gt;pom&lt;/h4&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;    &amp;lt;properties&amp;gt;
        &amp;lt;java.version&amp;gt;1.8&amp;lt;/java.version&amp;gt;
        &amp;lt;mapstruct.version&amp;gt;1.3.1.Final&amp;lt;/mapstruct.version&amp;gt;
        &amp;lt;lombok.version&amp;gt;1.18.12&amp;lt;/lombok.version&amp;gt;
    &amp;lt;/properties&amp;gt;

    &amp;lt;dependencies&amp;gt;
        &amp;lt;!-- 引入 mapstruct 依赖 --&amp;gt;
        &amp;lt;dependency&amp;gt;
            &amp;lt;groupId&amp;gt;org.mapstruct&amp;lt;/groupId&amp;gt;
            &amp;lt;artifactId&amp;gt;mapstruct&amp;lt;/artifactId&amp;gt;
            &amp;lt;version&amp;gt;${mapstruct.version}&amp;lt;/version&amp;gt;
        &amp;lt;/dependency&amp;gt;

        &amp;lt;!-- 引入 lombok 依赖 --&amp;gt;
        &amp;lt;dependency&amp;gt;
            &amp;lt;groupId&amp;gt;org.projectlombok&amp;lt;/groupId&amp;gt;
            &amp;lt;artifactId&amp;gt;lombok&amp;lt;/artifactId&amp;gt;
            &amp;lt;version&amp;gt;${lombok.version}&amp;lt;/version&amp;gt;
        &amp;lt;/dependency&amp;gt;
    &amp;lt;/dependencies&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h4 id=&quot;实例&quot;&gt;实例&lt;/h4&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CarVo {
    private Integer id;
    private String brand;
    private String name;
    private String createTime;
}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AttributePo {
    private double price;
    private String color;
}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CarBo {
    private Integer id;
    private String brand;
    private String carName;
    private Date createTime;
    private double price;
    private String color;
}

@Mapper
public interface CarCovertBasic {
    CarCovertBasic INSTANCE = Mappers.getMapper(CarCovertBasic.class);

    //(1)两个类型属性不一致 此时CarPo的一个属性为carName，而CarVo对应的属性为name！ 我们在接口上增加对应关系即可，如下所示
    //(2)集合类型转换 如果我们要从List转换为List怎么办呢？简单，接口里加一个方法就行
    //(3)类型不一致 在CarPo加一个属性为Date类型的createTime,而在CarVo加一个属性为String类型的createTime,那么代码如下
    (4)多对一 在实际业务情况中，我们有时候会遇到将两个Bean映射为一个Bean的情况，假设我们此时还有一个类为AtrributePo,我们要将CarPo和AttributePo同时映射为CarBo,我们可以这么写

    @Mappings({
        @Mapping(source = &quot;carName&quot;, target = &quot;name&quot;),
        @Mapping(target = &quot;createTime&quot;, expression = &quot;java(com.guduyan.util.DateUtil.dateToStr(source.getCreateTime()))&quot;)
    })
    CarVo toConvertVo(CarPo source);

    List&amp;lt;CarVo&amp;gt; toConvertVos(List&amp;lt;CarPo&amp;gt; source);

    CarBo toConvertBo(CarPo source1, AttributePo source2);
}




&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;</content><author><name>加量不加价</name></author><category term="优雅的转换Bean对象" /><summary type="html">对比 BeanUtils.copyProperties：如果是用Apache的BeanUtil类，有很大的性能问题，如果采用的是像Spring的BeanUtils类，要在调用次数足够多的时候，你才能明显的感受到卡顿 复制对象时字段类型不一致 复制对象时字段名称不一致 如果是集合类的复制，例如List转换为List 该如何解决？ MapStruct pom &amp;lt;properties&amp;gt; &amp;lt;java.version&amp;gt;1.8&amp;lt;/java.version&amp;gt; &amp;lt;mapstruct.version&amp;gt;1.3.1.Final&amp;lt;/mapstruct.version&amp;gt; &amp;lt;lombok.version&amp;gt;1.18.12&amp;lt;/lombok.version&amp;gt; &amp;lt;/properties&amp;gt; &amp;lt;dependencies&amp;gt; &amp;lt;!-- 引入 mapstruct 依赖 --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.mapstruct&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;mapstruct&amp;lt;/artifactId&amp;gt; &amp;lt;version&amp;gt;${mapstruct.version}&amp;lt;/version&amp;gt; &amp;lt;/dependency&amp;gt; &amp;lt;!-- 引入 lombok 依赖 --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.projectlombok&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;lombok&amp;lt;/artifactId&amp;gt; &amp;lt;version&amp;gt;${lombok.version}&amp;lt;/version&amp;gt; &amp;lt;/dependency&amp;gt; &amp;lt;/dependencies&amp;gt; 实例 @Data @Builder @NoArgsConstructor @AllArgsConstructor public class CarVo { private Integer id; private String brand; private String name; private String createTime; } @Data @Builder @NoArgsConstructor @AllArgsConstructor public class AttributePo { private double price; private String color; } @Data @Builder @NoArgsConstructor @AllArgsConstructor public class CarBo { private Integer id; private String brand; private String carName; private Date createTime; private double price; private String color; } @Mapper public interface CarCovertBasic { CarCovertBasic INSTANCE = Mappers.getMapper(CarCovertBasic.class); //(1)两个类型属性不一致 此时CarPo的一个属性为carName，而CarVo对应的属性为name！ 我们在接口上增加对应关系即可，如下所示 //(2)集合类型转换 如果我们要从List转换为List怎么办呢？简单，接口里加一个方法就行 //(3)类型不一致 在CarPo加一个属性为Date类型的createTime,而在CarVo加一个属性为String类型的createTime,那么代码如下 (4)多对一 在实际业务情况中，我们有时候会遇到将两个Bean映射为一个Bean的情况，假设我们此时还有一个类为AtrributePo,我们要将CarPo和AttributePo同时映射为CarBo,我们可以这么写 @Mappings({ @Mapping(source = &quot;carName&quot;, target = &quot;name&quot;), @Mapping(target = &quot;createTime&quot;, expression = &quot;java(com.guduyan.util.DateUtil.dateToStr(source.getCreateTime()))&quot;) }) CarVo toConvertVo(CarPo source); List&amp;lt;CarVo&amp;gt; toConvertVos(List&amp;lt;CarPo&amp;gt; source); CarBo toConvertBo(CarPo source1, AttributePo source2); }</summary></entry><entry><title type="html">Spring中的bean线程安全问题</title><link href="https://jialiangbujiaj1a.github.io//2020/11/09/Spring%E4%B8%AD%E7%9A%84bean%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98.html" rel="alternate" type="text/html" title="Spring中的bean线程安全问题" /><published>2020-11-09T00:00:00+00:00</published><updated>2020-11-09T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2020/11/09/Spring%E4%B8%AD%E7%9A%84bean%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2020/11/09/Spring%E4%B8%AD%E7%9A%84bean%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98.html">&lt;p&gt;结论：不是线程安全的&lt;/p&gt;

&lt;p&gt;下面总结一下：&lt;/p&gt;

&lt;p&gt;1、在@Controller/@Service等容器中，默认情况下，scope值是单例-singleton的，也是线程不安全的。&lt;/p&gt;

&lt;p&gt;2、尽量不要在@Controller/@Service等容器中定义静态变量，不论是单例(singleton)还是多实例(prototype)他都是线程不安全的。&lt;/p&gt;

&lt;p&gt;3、默认注入的Bean对象，在不设置scope的时候他也是线程不安全的。&lt;/p&gt;

&lt;p&gt;4、一定要定义变量的话，用ThreadLocal来封装，这个是线程安全的&lt;/p&gt;</content><author><name>加量不加价</name></author><category term="Spring中的bean线程安全问题" /><summary type="html">结论：不是线程安全的 下面总结一下： 1、在@Controller/@Service等容器中，默认情况下，scope值是单例-singleton的，也是线程不安全的。 2、尽量不要在@Controller/@Service等容器中定义静态变量，不论是单例(singleton)还是多实例(prototype)他都是线程不安全的。 3、默认注入的Bean对象，在不设置scope的时候他也是线程不安全的。 4、一定要定义变量的话，用ThreadLocal来封装，这个是线程安全的</summary></entry><entry><title type="html">单元测试</title><link href="https://jialiangbujiaj1a.github.io//2020/09/02/%E5%8D%95%E5%85%83%E6%B5%8B%E8%AF%95.html" rel="alternate" type="text/html" title="单元测试" /><published>2020-09-02T00:00:00+00:00</published><updated>2020-09-02T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2020/09/02/%E5%8D%95%E5%85%83%E6%B5%8B%E8%AF%95</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2020/09/02/%E5%8D%95%E5%85%83%E6%B5%8B%E8%AF%95.html">&lt;h3 id=&quot;controller&quot;&gt;Controller&lt;/h3&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c1&quot;&gt;// UserController2.java&lt;/span&gt;

&lt;span class=&quot;nd&quot;&gt;@RestController&lt;/span&gt;
&lt;span class=&quot;nd&quot;&gt;@RequestMapping&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;/users2&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;UserController2&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

&lt;span class=&quot;nd&quot;&gt;@Autowired&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;UserService&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;userService&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

&lt;span class=&quot;cm&quot;&gt;/**
 * 获得指定用户编号的用户
 *
 * @param id 用户编号
 * @return 用户
 */&lt;/span&gt;
&lt;span class=&quot;nd&quot;&gt;@GetMapping&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;/v2/{id}&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;UserVO&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;get2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nd&quot;&gt;@PathVariable&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;id&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Integer&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
    &lt;span class=&quot;k&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;userService&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;id&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;);&lt;/span&gt;
&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h3 id=&quot;service&quot;&gt;Service&lt;/h3&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;// UserService.java

@Service
public class UserService {

    public UserVO get(Integer id) {
        return new UserVO().setId(id).setUsername(&quot;test&quot;);
    }

}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h3 id=&quot;单元测试&quot;&gt;单元测试&lt;/h3&gt;

&lt;div class=&quot;language-java highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;&lt;span class=&quot;c1&quot;&gt;// UserControllerTest2.java&lt;/span&gt;

&lt;span class=&quot;nd&quot;&gt;@RunWith&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;SpringRunner&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;class&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;nd&quot;&gt;@WebMvcTest&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;UserController&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;class&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)&lt;/span&gt;
&lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;class&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;UserControllerTest2&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;

    &lt;span class=&quot;nd&quot;&gt;@Autowired&lt;/span&gt;
    &lt;span class=&quot;kd&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;MockMvc&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mvc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

    &lt;span class=&quot;nd&quot;&gt;@MockBean&lt;/span&gt;
    &lt;span class=&quot;kd&quot;&gt;private&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;UserService&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;userService&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;;&lt;/span&gt;

    &lt;span class=&quot;nd&quot;&gt;@Test&lt;/span&gt;
    &lt;span class=&quot;kd&quot;&gt;public&lt;/span&gt; &lt;span class=&quot;kt&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;testGet2&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;()&lt;/span&gt; &lt;span class=&quot;kd&quot;&gt;throws&lt;/span&gt; &lt;span class=&quot;nc&quot;&gt;Exception&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;{&lt;/span&gt;
        &lt;span class=&quot;c1&quot;&gt;// Mock UserService 的 get 方法&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;System&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;println&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;before mock:&quot;&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;userService&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// &amp;lt;1.1&amp;gt;&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;Mockito&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;when&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;n&quot;&gt;userService&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;)).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;thenReturn&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;
                &lt;span class=&quot;k&quot;&gt;new&lt;/span&gt; &lt;span class=&quot;nf&quot;&gt;UserVO&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;().&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;setId&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;).&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;setUsername&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;username:1&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// &amp;lt;1.2&amp;gt;&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;System&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;out&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;println&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;after mock:&quot;&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;userService&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;mi&quot;&gt;1&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// &amp;lt;1.3&amp;gt;&lt;/span&gt;

        &lt;span class=&quot;c1&quot;&gt;// 查询用户列表&lt;/span&gt;
        &lt;span class=&quot;nc&quot;&gt;ResultActions&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;resultActions&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;=&lt;/span&gt; &lt;span class=&quot;n&quot;&gt;mvc&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;perform&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;MockMvcRequestBuilders&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;get&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;/users/v2/1&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt;
        &lt;span class=&quot;c1&quot;&gt;// 校验结果&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;resultActions&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;andExpect&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;MockMvcResultMatchers&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;status&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;().&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;isOk&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;());&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// 响应状态码 200&lt;/span&gt;
        &lt;span class=&quot;n&quot;&gt;resultActions&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;andExpect&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;nc&quot;&gt;MockMvcResultMatchers&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;.&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;content&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;().&lt;/span&gt;&lt;span class=&quot;na&quot;&gt;json&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;(&lt;/span&gt;&lt;span class=&quot;s&quot;&gt;&quot;{\n&quot;&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;
                &lt;span class=&quot;s&quot;&gt;&quot;    \&quot;id\&quot;: 1,\n&quot;&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;
                &lt;span class=&quot;s&quot;&gt;&quot;    \&quot;username\&quot;: \&quot;username:1\&quot;\n&quot;&lt;/span&gt; &lt;span class=&quot;o&quot;&gt;+&lt;/span&gt;
                &lt;span class=&quot;s&quot;&gt;&quot;}&quot;&lt;/span&gt;&lt;span class=&quot;o&quot;&gt;));&lt;/span&gt; &lt;span class=&quot;c1&quot;&gt;// 响应结果&lt;/span&gt;
    &lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;

&lt;span class=&quot;o&quot;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;p&gt;在类上添加 @WebMvcTest 注解，并且传入的是 UserController 类，表示我们要对 UserController 进行单元测试。&lt;/p&gt;

&lt;p&gt;同时，@WebMvcTest 注解，是包含了 @AutoConfigureMockMvc 的组合注解，所以它会自动化配置我们稍后注入的 MockMvc Bean 对象 mvc 。在后续的测试中，我们会看到都是通过 mvc 调用后端 API 接口。但是！每一次调用后端 API 接口，并不会执行真正的后端逻辑，而是走的 Mock 逻辑。也就是说，整个逻辑，走的是单元测试，只会启动一个 Mock 的 Spring 环境。&lt;/p&gt;</content><author><name>加量不加价</name></author><category term="单元测试" /><summary type="html">Controller // UserController2.java @RestController @RequestMapping(&quot;/users2&quot;) public class UserController2 { @Autowired private UserService userService; /** * 获得指定用户编号的用户 * * @param id 用户编号 * @return 用户 */ @GetMapping(&quot;/v2/{id}&quot;) public UserVO get2(@PathVariable(&quot;id&quot;) Integer id) { return userService.get(id); } } Service // UserService.java @Service public class UserService { public UserVO get(Integer id) { return new UserVO().setId(id).setUsername(&quot;test&quot;); } } 单元测试 // UserControllerTest2.java @RunWith(SpringRunner.class) @WebMvcTest(UserController.class) public class UserControllerTest2 { @Autowired private MockMvc mvc; @MockBean private UserService userService; @Test public void testGet2() throws Exception { // Mock UserService 的 get 方法 System.out.println(&quot;before mock:&quot; + userService.get(1)); // &amp;lt;1.1&amp;gt; Mockito.when(userService.get(1)).thenReturn( new UserVO().setId(1).setUsername(&quot;username:1&quot;)); // &amp;lt;1.2&amp;gt; System.out.println(&quot;after mock:&quot; + userService.get(1)); // &amp;lt;1.3&amp;gt; // 查询用户列表 ResultActions resultActions = mvc.perform(MockMvcRequestBuilders.get(&quot;/users/v2/1&quot;)); // 校验结果 resultActions.andExpect(MockMvcResultMatchers.status().isOk()); // 响应状态码 200 resultActions.andExpect(MockMvcResultMatchers.content().json(&quot;{\n&quot; + &quot; \&quot;id\&quot;: 1,\n&quot; + &quot; \&quot;username\&quot;: \&quot;username:1\&quot;\n&quot; + &quot;}&quot;)); // 响应结果 } } 在类上添加 @WebMvcTest 注解，并且传入的是 UserController 类，表示我们要对 UserController 进行单元测试。 同时，@WebMvcTest 注解，是包含了 @AutoConfigureMockMvc 的组合注解，所以它会自动化配置我们稍后注入的 MockMvc Bean 对象 mvc 。在后续的测试中，我们会看到都是通过 mvc 调用后端 API 接口。但是！每一次调用后端 API 接口，并不会执行真正的后端逻辑，而是走的 Mock 逻辑。也就是说，整个逻辑，走的是单元测试，只会启动一个 Mock 的 Spring 环境。</summary></entry><entry><title type="html">Java并发之ThreadLocal</title><link href="https://jialiangbujiaj1a.github.io//2020/08/27/Java%E5%B9%B6%E5%8F%91%E4%B9%8BThreadLocal.html" rel="alternate" type="text/html" title="Java并发之ThreadLocal" /><published>2020-08-27T00:00:00+00:00</published><updated>2020-08-27T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2020/08/27/Java%E5%B9%B6%E5%8F%91%E4%B9%8BThreadLocal</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2020/08/27/Java%E5%B9%B6%E5%8F%91%E4%B9%8BThreadLocal.html">&lt;p&gt;ThreadLocal与线程同步机制不同，线程同步机制是多个线程共享同一个变量，而ThreadLocal是为每一个线程创建一个单独的变量副本，故而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。可以说ThreadLocal为多线程环境下变量问题提供了另外一种解决思路。 ThreadLocal定义了四个方法：&lt;/p&gt;

&lt;p&gt;get()：返回此线程局部变量的当前线程副本中的值。&lt;/p&gt;

&lt;p&gt;initialValue()：返回此线程局部变量的当前线程的“初始值”。&lt;/p&gt;

&lt;p&gt;remove()：移除此线程局部变量当前线程的值。&lt;/p&gt;

&lt;p&gt;set(T value)：将此线程局部变量的当前线程副本中的值设置为指定值。&lt;/p&gt;

&lt;p&gt;除了这四个方法，ThreadLocal内部还有一个静态内部类ThreadLocalMap，该内部类才是实现线程隔离机制的关键，get()、set()、remove()都是基于该内部类操作。ThreadLocalMap提供了一种用键值对方式存储每一个线程的变量副本的方法，key为当前ThreadLocal对象，value则是对应线程的变量副本。&lt;/p&gt;</content><author><name>加量不加价</name></author><category term="并发" /><category term="ThreadLocal" /><summary type="html">ThreadLocal与线程同步机制不同，线程同步机制是多个线程共享同一个变量，而ThreadLocal是为每一个线程创建一个单独的变量副本，故而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。可以说ThreadLocal为多线程环境下变量问题提供了另外一种解决思路。 ThreadLocal定义了四个方法： get()：返回此线程局部变量的当前线程副本中的值。 initialValue()：返回此线程局部变量的当前线程的“初始值”。 remove()：移除此线程局部变量当前线程的值。 set(T value)：将此线程局部变量的当前线程副本中的值设置为指定值。 除了这四个方法，ThreadLocal内部还有一个静态内部类ThreadLocalMap，该内部类才是实现线程隔离机制的关键，get()、set()、remove()都是基于该内部类操作。ThreadLocalMap提供了一种用键值对方式存储每一个线程的变量副本的方法，key为当前ThreadLocal对象，value则是对应线程的变量副本。</summary></entry><entry><title type="html">Java内存模型</title><link href="https://jialiangbujiaj1a.github.io//2020/03/12/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.html" rel="alternate" type="text/html" title="Java内存模型" /><published>2020-03-12T00:00:00+00:00</published><updated>2020-03-12T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2020/03/12/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2020/03/12/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.html">&lt;h3 id=&quot;内存模型&quot;&gt;内存模型&lt;/h3&gt;

&lt;blockquote&gt;
  &lt;p&gt;Java内存模型的主要目标是定义程序中变量的访问规则。即在虚拟机中将变量存储到主内存或者将变量从主内存取出这样的底层细节&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Java 内存模型对主内存与工作内存之间的具体交互协议定义了八种操作：&lt;/p&gt;

&lt;p&gt;lock(锁定):作用于主内存的变量，一个变量在同一时间只能一个线程锁定，该操作表示这条线成独占这个变量&lt;/p&gt;

&lt;p&gt;unlock(解锁):作用于主内存的变量，表示这个变量的状态由处于锁定状态被释放，这样其他线程才能对该变量进行锁定&lt;/p&gt;

&lt;p&gt;read(读取):作用于主内存变量，表示把一个主内存变量的值传输到线程的工作内存，以便随后的load操作使用&lt;/p&gt;

&lt;p&gt;load(载入):作用于线程的工作内存的变量，表示把read操作从主内存中读取的变量的值放到工作内存的变量副本中(副本是相对于主内存的变量而言的)&lt;/p&gt;

&lt;p&gt;use(使用):作用于线程的工作内存中的变量，表示把工作内存中的一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时就会执行该操作&lt;/p&gt;

&lt;p&gt;assign(赋值):作用于线程的工作内存的变量，表示把执行引擎返回的结果赋值给工作内存中的变量，每当虚拟机遇到一个给变量赋值的字节码指令时就会执行该操作&lt;/p&gt;

&lt;p&gt;store(存储):作用于线程的工作内存中的变量，把工作内存中的一个变量的值传递给主内存，以便随后的write操作使用&lt;/p&gt;

&lt;p&gt;write(写入):作用于主内存的变量，把store操作从工作内存中得到的变量的值放入主内存的变量中&lt;/p&gt;

&lt;p&gt;注意：&lt;/p&gt;

&lt;p&gt;不允许read和load、store和write操作之一单独出现；不允许一个线程丢弃最近的assign操作；不允许一个线程回写没有修改的变量到主内存；变量只能在主内存中产生；一个变量在同一时刻只能被一个线程对其进行lock操作；对变量执行lock操作，就会清空工作空间该变量的值；不允许对没有lock的变量执行unlock操作；对一个变量执行unlock之前，必须先把变量同步回主内存中。&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;https://jialiangbujiaj1a.github.io/imgs/java内存模型/内存模型.jpg&quot; alt=&quot;内存模型&quot; /&gt;&lt;/p&gt;

&lt;h3 id=&quot;volatile&quot;&gt;volatile&lt;/h3&gt;

&lt;p&gt;关键字volatile可以说是java虚拟机中提供的最轻量级的同步机制.&lt;/p&gt;

&lt;p&gt;volatile类型的变量保证对所有线程的可见性：volatile类型的变量每次值被修改了就立即同步回主内存，每次使用时就需要从主内存重新读取值。&lt;/p&gt;

&lt;p&gt;volatile类型的变量禁止指令重排序优化：在本地代码中插入许多内存屏障指令来禁止指令重排序，保证处理器不发生代码乱序执行行为。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;原子性(Automicity)&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;可见性&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。&lt;/p&gt;

&lt;p&gt;正如前面所说，volatile类型的变量在修改后会立即同步给主内存，在使用的时候会从主内存重新读取，是依赖主内存为中介来保证多线程下变量对其他线程的可见性的。
除了volatile，synchronized和final也可以实现可见性。synchronized关键字是通过unlock之前必须把变量同步回主内存来实现的，final则是在初始化后就不会更改，所以只要在初始化过程中没有把this指针传递出去也能保证对其他线程的可见性。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;有序性&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;即程序执行的顺序按照代码的先后顺序执行。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;volatile原理&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;加入volatile关键字时，会多出一个lock前缀指令。lock前缀指令其实就相当于一个内存屏障。内存屏障是一组处理指令，用来实现对内存操作的顺序限制。&lt;/p&gt;

&lt;p&gt;volatile 变量进行写操作时，JVM 会向处理器发送一条 Lock 前缀的指令，将这个变量所在缓存行的数据写回到系统内存。Lock 前缀指令确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;总结&lt;/strong&gt;&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;volatile可见性；对一个volatile的读，总可以看到对这个变量最终的写；&lt;/p&gt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
  &lt;p&gt;volatile原子性；volatile对单个读/写具有原子性（32位Long、Double），但是复合操作除外，例如i++;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
  &lt;p&gt;JVM底层采用“内存屏障”来实现volatile语义&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;a href=&quot;https://www.jianshu.com/p/15106e9c4bf3&quot;&gt;内存模型&lt;/a&gt;&lt;/p&gt;

&lt;h3 id=&quot;happen-before原则&quot;&gt;happen-before原则&lt;/h3&gt;

&lt;p&gt;&lt;strong&gt;概念&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;保证了程序的“有序性”，它规定如果两个操作的执行顺序不存在于happens-before原则中，那么他们就不能保证有序性，可以随意进行重排序&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;原则&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；&lt;/p&gt;

&lt;p&gt;锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；&lt;/p&gt;

&lt;p&gt;volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；&lt;/p&gt;

&lt;p&gt;传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；&lt;/p&gt;

&lt;p&gt;线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；&lt;/p&gt;

&lt;p&gt;线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；&lt;/p&gt;

&lt;p&gt;线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；&lt;/p&gt;

&lt;p&gt;对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；&lt;/p&gt;

&lt;h3 id=&quot;重排序&quot;&gt;重排序&lt;/h3&gt;

&lt;p&gt;在执行程序时，为了提供性能，处理器和编译器常常会对指令进行重排序，但是不能随意重排序，不是你想怎么排序就怎么排序，它需要满足以下两个条件：&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;在单线程环境下不能改变程序运行的结果；&lt;/p&gt;
&lt;/blockquote&gt;

&lt;blockquote&gt;
  &lt;p&gt;存在数据依赖关系的不允许重排序&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;上述两点可以归结于一点：无法通过happens-before原则推导出来的，JMM允许任意的排序。&lt;/p&gt;</content><author><name>加量不加价</name></author><category term="Java内存模型" /><summary type="html">内存模型 Java内存模型的主要目标是定义程序中变量的访问规则。即在虚拟机中将变量存储到主内存或者将变量从主内存取出这样的底层细节 Java 内存模型对主内存与工作内存之间的具体交互协议定义了八种操作： lock(锁定):作用于主内存的变量，一个变量在同一时间只能一个线程锁定，该操作表示这条线成独占这个变量 unlock(解锁):作用于主内存的变量，表示这个变量的状态由处于锁定状态被释放，这样其他线程才能对该变量进行锁定 read(读取):作用于主内存变量，表示把一个主内存变量的值传输到线程的工作内存，以便随后的load操作使用 load(载入):作用于线程的工作内存的变量，表示把read操作从主内存中读取的变量的值放到工作内存的变量副本中(副本是相对于主内存的变量而言的) use(使用):作用于线程的工作内存中的变量，表示把工作内存中的一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时就会执行该操作 assign(赋值):作用于线程的工作内存的变量，表示把执行引擎返回的结果赋值给工作内存中的变量，每当虚拟机遇到一个给变量赋值的字节码指令时就会执行该操作 store(存储):作用于线程的工作内存中的变量，把工作内存中的一个变量的值传递给主内存，以便随后的write操作使用 write(写入):作用于主内存的变量，把store操作从工作内存中得到的变量的值放入主内存的变量中 注意： 不允许read和load、store和write操作之一单独出现；不允许一个线程丢弃最近的assign操作；不允许一个线程回写没有修改的变量到主内存；变量只能在主内存中产生；一个变量在同一时刻只能被一个线程对其进行lock操作；对变量执行lock操作，就会清空工作空间该变量的值；不允许对没有lock的变量执行unlock操作；对一个变量执行unlock之前，必须先把变量同步回主内存中。 volatile 关键字volatile可以说是java虚拟机中提供的最轻量级的同步机制. volatile类型的变量保证对所有线程的可见性：volatile类型的变量每次值被修改了就立即同步回主内存，每次使用时就需要从主内存重新读取值。 volatile类型的变量禁止指令重排序优化：在本地代码中插入许多内存屏障指令来禁止指令重排序，保证处理器不发生代码乱序执行行为。 原子性(Automicity) 即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。 可见性 可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。 正如前面所说，volatile类型的变量在修改后会立即同步给主内存，在使用的时候会从主内存重新读取，是依赖主内存为中介来保证多线程下变量对其他线程的可见性的。 除了volatile，synchronized和final也可以实现可见性。synchronized关键字是通过unlock之前必须把变量同步回主内存来实现的，final则是在初始化后就不会更改，所以只要在初始化过程中没有把this指针传递出去也能保证对其他线程的可见性。 有序性 即程序执行的顺序按照代码的先后顺序执行。 volatile原理 加入volatile关键字时，会多出一个lock前缀指令。lock前缀指令其实就相当于一个内存屏障。内存屏障是一组处理指令，用来实现对内存操作的顺序限制。 volatile 变量进行写操作时，JVM 会向处理器发送一条 Lock 前缀的指令，将这个变量所在缓存行的数据写回到系统内存。Lock 前缀指令确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成。 总结 volatile可见性；对一个volatile的读，总可以看到对这个变量最终的写； volatile原子性；volatile对单个读/写具有原子性（32位Long、Double），但是复合操作除外，例如i++; JVM底层采用“内存屏障”来实现volatile语义 内存模型 happen-before原则 概念 保证了程序的“有序性”，它规定如果两个操作的执行顺序不存在于happens-before原则中，那么他们就不能保证有序性，可以随意进行重排序 原则 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作； 锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作； volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作； 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C； 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作； 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生； 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行； 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始； 重排序 在执行程序时，为了提供性能，处理器和编译器常常会对指令进行重排序，但是不能随意重排序，不是你想怎么排序就怎么排序，它需要满足以下两个条件： 在单线程环境下不能改变程序运行的结果； 存在数据依赖关系的不允许重排序 上述两点可以归结于一点：无法通过happens-before原则推导出来的，JMM允许任意的排序。</summary></entry><entry><title type="html">AQS</title><link href="https://jialiangbujiaj1a.github.io//2020/03/11/AQS.html" rel="alternate" type="text/html" title="AQS" /><published>2020-03-11T00:00:00+00:00</published><updated>2020-03-11T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2020/03/11/AQS</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2020/03/11/AQS.html">&lt;p&gt;&lt;strong&gt;介绍&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;AQS全称AbstractQueuedSynchronizer抽象队列同步器，是并发包中的基础类，ReetrantLock，ReentrantReadWriteLock底层都用到了AQS来实现&lt;/p&gt;

&lt;p&gt;AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，即将暂时获取不到锁的线程加入到队列中。&lt;/p&gt;

&lt;p&gt;当lock.lock()的时候，实际上底层是由AQS来完成的加锁，AQS提供了一个state表示加锁状态，默认0表示不加锁，Thread的属性存放加锁线程；&lt;/p&gt;

&lt;p&gt;当加锁的时候，通过cas操作将state+1，则成功获取锁，cas操作达到了加锁的互斥效果&lt;/p&gt;

&lt;p&gt;锁的可重入性，就是通过state不断+1实现，对一个ReentrantLock不断加锁，则state不断+1，释放锁则-1&lt;/p&gt;

&lt;p&gt;当加锁失败后，会把失败线程加到AQS中的队列里，等待获取锁&lt;/p&gt;

&lt;p&gt;如果是公平锁，当释放锁后会从队列头结点来获取线程加锁，非公平锁则可能新来的线程也可能抢到锁。&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;原理&lt;/strong&gt;
AQS使用一个int类型的成员变量state来表示同步状态，当state&amp;gt;0时表示已经获取了锁，当state = 0时表示释放了锁。它提供了三个方法（getState()返回同步状态的当前值、setState(int newState)设置当前同步状态、compareAndSetState(int expect,int update)使用CAS设置当前状态，该方法能够保证状态设置的原子性）来对同步状态state进行操作，当然AQS可以确保对state的操作是安全的。 AQS通过内置的FIFO同步队列来完成资源获取线程的排队工作，如果当前线程获取同步状态失败（锁）时，AQS则会将当前线程以及等待状态等信息构造成一个节点（Node）并将其加入同步队列（在CLH同步队列中，一个节点表示一个线程，它保存着线程的引用（thread）、状态（waitStatus）、前驱节点（prev）、后继节点（next）），同时会阻塞当前线程，当同步状态释放时，则会把首节点中的线程唤醒，使其再次尝试获取同步状态。&lt;/p&gt;</content><author><name>加量不加价</name></author><category term="AQS" /><summary type="html">介绍 AQS全称AbstractQueuedSynchronizer抽象队列同步器，是并发包中的基础类，ReetrantLock，ReentrantReadWriteLock底层都用到了AQS来实现 AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，即将暂时获取不到锁的线程加入到队列中。 当lock.lock()的时候，实际上底层是由AQS来完成的加锁，AQS提供了一个state表示加锁状态，默认0表示不加锁，Thread的属性存放加锁线程； 当加锁的时候，通过cas操作将state+1，则成功获取锁，cas操作达到了加锁的互斥效果 锁的可重入性，就是通过state不断+1实现，对一个ReentrantLock不断加锁，则state不断+1，释放锁则-1 当加锁失败后，会把失败线程加到AQS中的队列里，等待获取锁 如果是公平锁，当释放锁后会从队列头结点来获取线程加锁，非公平锁则可能新来的线程也可能抢到锁。 原理 AQS使用一个int类型的成员变量state来表示同步状态，当state&amp;gt;0时表示已经获取了锁，当state = 0时表示释放了锁。它提供了三个方法（getState()返回同步状态的当前值、setState(int newState)设置当前同步状态、compareAndSetState(int expect,int update)使用CAS设置当前状态，该方法能够保证状态设置的原子性）来对同步状态state进行操作，当然AQS可以确保对state的操作是安全的。 AQS通过内置的FIFO同步队列来完成资源获取线程的排队工作，如果当前线程获取同步状态失败（锁）时，AQS则会将当前线程以及等待状态等信息构造成一个节点（Node）并将其加入同步队列（在CLH同步队列中，一个节点表示一个线程，它保存着线程的引用（thread）、状态（waitStatus）、前驱节点（prev）、后继节点（next）），同时会阻塞当前线程，当同步状态释放时，则会把首节点中的线程唤醒，使其再次尝试获取同步状态。</summary></entry><entry><title type="html">CAS和原子变量类</title><link href="https://jialiangbujiaj1a.github.io//2020/03/11/CAS%E5%92%8C%E5%8E%9F%E5%AD%90%E5%8F%98%E9%87%8F%E7%B1%BB.html" rel="alternate" type="text/html" title="CAS和原子变量类" /><published>2020-03-11T00:00:00+00:00</published><updated>2020-03-11T00:00:00+00:00</updated><id>https://jialiangbujiaj1a.github.io//2020/03/11/CAS%E5%92%8C%E5%8E%9F%E5%AD%90%E5%8F%98%E9%87%8F%E7%B1%BB</id><content type="html" xml:base="https://jialiangbujiaj1a.github.io//2020/03/11/CAS%E5%92%8C%E5%8E%9F%E5%AD%90%E5%8F%98%E9%87%8F%E7%B1%BB.html">&lt;h3 id=&quot;cas&quot;&gt;CAS&lt;/h3&gt;

&lt;blockquote&gt;
  &lt;p&gt;比较并交换(compare and swap, CAS)，是原子操作的一种，可用于在多线程编程中实现不被打断的数据交换操作&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当内存值V的值等于旧的预期值A时才会将内存值V的值修改为B，否则什么都不干。&lt;/p&gt;

&lt;p&gt;当多个线程同时对某个资源进行CAS操作，只能有一个线程操作成功，但是并不会阻塞其他线程,其他线程只会收到操作失败的信号。可见 CAS 其实是一个乐观锁。&lt;/p&gt;

&lt;p&gt;主存中保存V值，线程中要使用V值要先从主存中读取V值到线程的工作内存A中，然后计算后变成B值，最后再把B值写回到内存V值中。多个线程共用V值都是如此操作。CAS的核心是在将B值写入到V之前要比较A值和V值是否相同，如果不相同证明此时V值已经被其他线程改变，重新将V值赋给A，并重新计算得到B，如果相同，则将B值赋给V。&lt;/p&gt;

&lt;p&gt;CAS实现：&lt;/p&gt;

&lt;p&gt;java 的 cas 利用的的是 unsafe 这个类提供的 cas 操作。&lt;/p&gt;

&lt;p&gt;unsafe 的cas 依赖了的是 jvm 针对不同的操作系统实现的 Atomic::cmpxchg&lt;/p&gt;

&lt;p&gt;Atomic::cmpxchg 的实现使用了汇编的 cas 操作，并使用 cpu 硬件提供的 lock信号保证其原子性&lt;/p&gt;

&lt;p&gt;调用Unsafe的方法，而Unsafe底层实际上是调用C代码，C代码调用汇编，最后生成出一条CPU指令cmpxchg，完成操作&lt;/p&gt;

&lt;p&gt;&lt;a href=&quot;https://cloud.tencent.com/developer/article/1462258&quot;&gt;Java 的 CAS原理&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;ABA问题&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;CAS需要检查操作值有没有发生改变，如果没有发生改变则更新。但是存在这样一种情况：如果一个值原来是A，变成了B，然后又变成了A，那么在CAS检查的时候会发现没有改变，但是实质上它已经发生了改变，这就是所谓的ABA问题。对于ABA问题其解决方案是加上版本号，即在每个变量都加上一个版本号，每次改变时加1，即A —&amp;gt; B —&amp;gt; A，变成1A —&amp;gt; 2B —&amp;gt; 3A。&lt;/p&gt;

&lt;h3 id=&quot;原子变量类&quot;&gt;原子变量类&lt;/h3&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;public class Count{

    // 共享变量(使用AtomicInteger来替代Synchronized锁)
    private AtomicInteger count = new AtomicInteger(0);

    public Integer getCount() {
        return count.get();
    }
    //自增
    public void increase() {
        count.incrementAndGet();
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;</content><author><name>加量不加价</name></author><category term="CAS和原子变量类" /><summary type="html">CAS 比较并交换(compare and swap, CAS)，是原子操作的一种，可用于在多线程编程中实现不被打断的数据交换操作 CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当内存值V的值等于旧的预期值A时才会将内存值V的值修改为B，否则什么都不干。 当多个线程同时对某个资源进行CAS操作，只能有一个线程操作成功，但是并不会阻塞其他线程,其他线程只会收到操作失败的信号。可见 CAS 其实是一个乐观锁。 主存中保存V值，线程中要使用V值要先从主存中读取V值到线程的工作内存A中，然后计算后变成B值，最后再把B值写回到内存V值中。多个线程共用V值都是如此操作。CAS的核心是在将B值写入到V之前要比较A值和V值是否相同，如果不相同证明此时V值已经被其他线程改变，重新将V值赋给A，并重新计算得到B，如果相同，则将B值赋给V。 CAS实现： java 的 cas 利用的的是 unsafe 这个类提供的 cas 操作。 unsafe 的cas 依赖了的是 jvm 针对不同的操作系统实现的 Atomic::cmpxchg Atomic::cmpxchg 的实现使用了汇编的 cas 操作，并使用 cpu 硬件提供的 lock信号保证其原子性 调用Unsafe的方法，而Unsafe底层实际上是调用C代码，C代码调用汇编，最后生成出一条CPU指令cmpxchg，完成操作 Java 的 CAS原理 ABA问题 CAS需要检查操作值有没有发生改变，如果没有发生改变则更新。但是存在这样一种情况：如果一个值原来是A，变成了B，然后又变成了A，那么在CAS检查的时候会发现没有改变，但是实质上它已经发生了改变，这就是所谓的ABA问题。对于ABA问题其解决方案是加上版本号，即在每个变量都加上一个版本号，每次改变时加1，即A —&amp;gt; B —&amp;gt; A，变成1A —&amp;gt; 2B —&amp;gt; 3A。 原子变量类 public class Count{ // 共享变量(使用AtomicInteger来替代Synchronized锁) private AtomicInteger count = new AtomicInteger(0); public Integer getCount() { return count.get(); } //自增 public void increase() { count.incrementAndGet(); } }</summary></entry></feed>