ElasticSearch 并发冲突+悲观锁与乐观锁+基于_version和external version进行乐观锁并发控制

1.图解剖析Elasticsearch并发冲突问题

2.图解剖析悲观锁与乐观锁两种并发控制方案

3、图解Elasticsearch内部如何基于_version进行乐观锁并发控制

(1)_version元数据



PUT /test_index/test_type/6
{
"test_field": "test test"
}



{
"_index": "test_index",
"_type": "test_type",
"_id": "6",
"_version": 1,
"result": "created",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"created": true
}

第一次创建一个document的时候,它的_version内部版本号就是1;以后,每次对这个document执行修改或者删除操作,都会对这个_version版本号自动加1;哪怕是删除,也会对这条数据的版本号加1

{
"found": true,
"_index": "test_index",
"_type": "test_type",
"_id": "6",
"_version": 4,
"result": "deleted",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
}
}

我们会发现,在删除一个document之后,可以从一个侧面证明,它不是立即物理删除掉的,因为它的一些版本号等信息还是保留着的。先删除一条document,再重新创建这条document,其实会在delete version基础之上,再把version号加1

 

4、上机动手实战演练基于_version进行乐观锁并发控制

(1)先构造一条数据出来



PUT /test_index/test_type/7
{
"test_field": "test test"
}



(2)模拟两个客户端,都获取到了同一条数据



GET test_index/test_type/7



{
"_index": "test_index",
"_type": "test_type",
"_id": "7",
"_version": 1,
"found": true,
"_source": {
"test_field": "test test"
}
}

(3)其中一个客户端,先更新了一下这个数据

同时带上数据的版本号,确保说,es中的数据的版本号,跟客户端中的数据的版本号是相同的,才能修改



PUT /test_index/test_type/7?version=1
{
"test_field": "test client 1"
}



{
"_index": "test_index",
"_type": "test_type",
"_id": "7",
"_version": 2,
"result": "updated",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"created": false
}

(4)另外一个客户端,尝试基于version=1的数据去进行修改,同样带上version版本号,进行乐观锁的并发控制



PUT /test_index/test_type/7?version=1
{
"test_field": "test client 2"
}



{
"error": {
"root_cause": [
{
"type": "version_conflict_engine_exception",
"reason": "[test_type][7]: version conflict, current version [2] is different than the one provided [1]",
"index_uuid": "6m0G7yx7R1KECWWGnfH1sw",
"shard": "3",
"index": "test_index"
}
],
"type": "version_conflict_engine_exception",
"reason": "[test_type][7]: version conflict, current version [2] is different than the one provided [1]",
"index_uuid": "6m0G7yx7R1KECWWGnfH1sw",
"shard": "3",
"index": "test_index"
},
"status": 409
}

(5)在乐观锁成功阻止并发问题之后,尝试正确的完成更新



GET /test_index/test_type/7



{
"_index": "test_index",
"_type": "test_type",
"_id": "7",
"_version": 2,
"found": true,
"_source": {
"test_field": "test client 1"
}
}

基于最新的数据和版本号,去进行修改,修改后,带上最新的版本号,可能这个步骤会需要反复执行好几次,才能成功,特别是在多线程并发更新同一条数据很频繁的情况下



PUT /test_index/test_type/7?version=2
{
"test_field": "test client 2"
}



{
"_index": "test_index",
"_type": "test_type",
"_id": "7",
"_version": 3,
"result": "updated",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"created": false
}

5.上机动手实战演练基于external version进行乐观锁并发控制

external version

es提供了一个feature,就是说,你可以不用它提供的内部_version版本号来进行并发控制,可以基于你自己维护的一个版本号来进行并发控制。举个列子,加入你的数据在mysql里也有一份,然后你的应用系统本身就维护了一个版本号,无论是什么自己生成的,程序控制的。这个时候,你进行乐观锁并发控制的时候,可能并不是想要用es内部的_version来进行控制,而是用你自己维护的那个version来进行控制。

?version=1
?version=1&version_type=external

version_type=external,唯一的区别在于,_version,只有当你提供的version与es中的_version一模一样的时候,才可以进行修改,只要不一样,就报错;当version_type=external的时候,只有当你提供的version比es中的_version大的时候,才能完成修改

es,_version=1,?version=1,才能更新成功
es,_version=1,?version>1&version_type=external,才能成功,比如说?version=2&version_type=external

(1)先构造一条数据



PUT /test_index/test_type/8
{
"test_field": "test"
}



{
"_index": "test_index",
"_type": "test_type",
"_id": "8",
"_version": 1,
"result": "created",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"created": true
}

(2)模拟两个客户端同时查询到这条数据

GET /test_index/test_type/8

{
"_index": "test_index",
"_type": "test_type",
"_id": "8",
"_version": 1,
"found": true,
"_source": {
"test_field": "test"
}
}

(3)第一个客户端先进行修改,此时客户端程序是在自己的数据库中获取到了这条数据的最新版本号,比如说是2



PUT /test_index/test_type/8?version=2&version_type=external
{
"test_field": "test client 1"
}



{
"_index": "test_index",
"_type": "test_type",
"_id": "8",
"_version": 2,
"result": "updated",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"created": false
}

(4)模拟第二个客户端,同时拿到了自己数据库中维护的那个版本号,也是2,同时基于version=2发起了修改



PUT /test_index/test_type/8?version=2&version_type=external
{
"test_field": "test client 2"
}



{
"error": {
"root_cause": [
{
"type": "version_conflict_engine_exception",
"reason": "[test_type][8]: version conflict, current version [2] is higher or equal to the one provided [2]",
"index_uuid": "6m0G7yx7R1KECWWGnfH1sw",
"shard": "1",
"index": "test_index"
}
],
"type": "version_conflict_engine_exception",
"reason": "[test_type][8]: version conflict, current version [2] is higher or equal to the one provided [2]",
"index_uuid": "6m0G7yx7R1KECWWGnfH1sw",
"shard": "1",
"index": "test_index"
},
"status": 409
}

(5)在并发控制成功后,重新基于最新的版本号发起更新



GET /test_index/test_type/8



{
"_index": "test_index",
"_type": "test_type",
"_id": "8",
"_version": 2,
"found": true,
"_source": {
"test_field": "test client 1"
}
}



PUT /test_index/test_type/8?version=3&version_type=external
{
"test_field": "test client 2"
}



{
"_index": "test_index",
"_type": "test_type",
"_id": "8",
"_version": 3,
"result": "updated",
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"created": false
}

原文地址:https://www.cnblogs.com/Transkai/p/11249136.html

时间: 2024-08-01 19:35:35

ElasticSearch 并发冲突+悲观锁与乐观锁+基于_version和external version进行乐观锁并发控制的相关文章

基于external version进行乐观锁并发控制

?version=1?version=1&version_type=external它们的唯一区别在于,_version,只有当你提供的version与es中的_version一模一样的时候,才可以进行修改,只要不一样就报错:当version_type=external的时候,只有当你提供的version比es中的_version大的时候,才能完成修改. 比如:es中的_version=1?version=1 能更新成功?version>1&version_type=external

ElasticSearch(九)基于version进行乐观锁并发控制

一.基于version进行乐观锁并发控制 1).查看一条document GET /test_version/test_version_type/1 { "_index" : "test_version", "_type" : "test_version_type", "_id" : "1", "_version" : 1, "found" : t

Elasticsearch由浅入深(四)ES并发冲突、悲观锁与乐观锁、_version乐观锁并发

ES并发冲突 举个例子,比如是电商场景下,假设说,我们有个程序,工作的流程是这样子的: 读取商品信息(包含了商品库存) 用户下单购买 更新商品信息(主要是将库存减1) 我们比如咱们的程序就是多线程的,所以可能有多个线程并发的去执行上述的3步骤流程 有一个牙膏,库存100件,现在,同时有两个人都过来读取了牙育的数据,然后下单购买了这管牙膏,此时两个线程并发的服务于两个人,同时在进行商品库存数据的修改 总有一个线程是先到的,假设就是线程A ,此时线程A就会先将牙育的库存设置为99件,然后线程B再次将

Linq to Sql并发冲突及处理策略

0. 并发冲突的示例 单用户的系统现在应该比较罕见了,一般系统都会有很多用户在同时进行操作:在多用户系统中,涉及到的一个普遍问题:当多个用户“同时”更新(修改或者删除)同一条记录时,该如何更新呢?    下图展示了开放式并发冲突的一个示例: 假设数据库中有一条记录Record{Field1=5, Field2=6, Field3=7}(以下简写为{5, 6, 7}),A.B两个用户按照如下顺序操作这一条记录:(1). A读取该记录,取得的值为{5, 6, 7},读取完毕后,不对该记录加排他锁:(

Linq to Sql : 并发冲突及处理策略

原文:Linq to Sql : 并发冲突及处理策略 0. 并发冲突的示例 单用户的系统现在应该比较罕见了,一般系统都会有很多用户在同时进行操作:在多用户系统中,涉及到的一个普遍问题:当多个用户"同时"更新(修改或者删除)同一条记录时,该如何更新呢?    下图展示了开放式并发冲突的一个示例: 假设数据库中有一条记录Record{Field1=5, Field2=6, Field3=7}(以下简写为{5, 6, 7}),A.B两个用户按照如下顺序操作这一条记录:(1). A读取该记录,

互联网线上项目开发最大坑点-并发冲突处理

大家可能都有这样的经验,自个儿在家里很多功能很容易实现,一下就做完了,但是在做线上产品的时候,就变得无比复杂,需要花费很多的时间. 自己写的程序在家跑,所有的业务都很正常,一旦发布到线上,就会出现很多bug,而且很多bug在测试的时候很难重现,这是在互联网开发的时候经常遇到的现象. 这些难以重现的bug,大部分是由于并发产生的,为了能让大家充分的了解并发的问题,并且建立并发环境下的程序设计思维,我们为大家准备了几个小案例 大家来看一下,这个网站典型的场景,遇到内容比较多的情况下,我们会使用分页

分布式锁与实现(一)——基于Redis实现

概述 目前几乎很多大型网站及应用都是分布式部署的,分布式场景中的数据一致性问题一直是一个比较重要的话题.分布式的CAP理论告诉我们"任何一个分布式系统都无法同时满足一致性(Consistency).可用性(Availability)和分区容错性(Partition tolerance),最多只能同时满足两项."所以,很多系统在设计之初就要对这三者做出取舍.在互联网领域的绝大多数的场景中,都需要牺牲强一致性来换取系统的高可用性,系统往往只需要保证"最终一致性",只要这

JUC锁简析(基于源码的详解后续会陆续发出)

张图说明下要分享的内容: 01. Lock接口 JUC包中的 Lock 接口支持那些语义不同(重入.公平等)的锁规则.所谓语义不同,是指锁可是有"公平机制的锁"."非公平机制的锁"."可重入的锁"等等. "公平机制"是指"不同线程获取锁的机制是公平的", 而"非公平机制"则是指"不同线程获取锁的机制是非公平的","可重入的锁"是指同一个锁能够被一个

基于ATmega162的指纹识别电子机械锁设计

0 引言 随着生活水平的提高,人们对物质生活的要求越来越高,尤为注重住宅安全问题.随着生物特征识别技术的发展,指纹识别技术逐渐进入人们的生活领域,指纹锁进入了人们的家庭.常见的指纹锁,需要管理员指纹或者管理员密码,才能进行指纹和密码的添加和删除操作.本文设计的电子机械锁,具有上述功能,还可以用正确钥匙管理指纹和密码. 常见的指纹锁配备的机械锁,可使用普通的正确钥匙打开,安全级别较低,很容易被专业人员破解.本文设计的基于PIC16F72的机械锁,配套的钥匙内置编码芯片,能够设置正确钥匙以及发送钥匙