mongoDB的事务

Posted 2020-12-11 Nucky_yang

官网传送门：

https://docs.mongodb.com/manual/core/replica-set-write-concern/

https://docs.mongodb.com/manual/core/transactions/#read-concern-write-concern-read-preference

MongoDB ACID 多文档事务支持

事务属性	支持程度
Atomocity 原子性	单表单文档 ： 1.x 就支持 复制集多表多行：4.0 复制集 分片集群多表多行4.2
Consistency 一致性	writeConcern, readConcern (3.2)
Isolation 隔离性	readConcern (3.2)
Durability 持久性	Journal and Replication

 

Atomocity 原子性 

一个事务作为一个提交单位，要么一起成功要么一起失败，分布式关注的重点就是多节点之间数据的原子性控制。

Consistency 一致性 

读和写的一致性，会不会读到脏数据。

Isolation 隔离性   

每个事务相互之间是独立的，每个事务内与主表之间也是互不影响、相互独立的。
Durability 持久性   

数据落盘持久化，通过记录Journal日志文件和备份副本。

先从mongoDB的一致性相关的writeConcern, readConcern说。

什么是 writeConcern ？

writeConcern 决定一个写操作落到多少个节点上才算成功。writeConcern 的取值包括：
• 0：发起写操作，不关心是否成功；
• 1~集群最大数据节点数：写操作需要被复制到指定节点数才算成功；默认是1。
• majority：写操作需要被复制到大多数节点上才算成功。

• all：写入所有节点才算成功。
发起写操作的程序将阻塞到写操作到达指定的节点数为止

默认情况 w:“1”

 

 

大多数节点确认（即一半以上节点）   w: “majority” 

全部节点确认 w: “all”

 

 

 

j:true

 writeConcern 可以决定写操作到达多少个节点才算成功，journal 则定义如何才算成
功。取值包括：
• true: 写操作落到 journal 文件中才算成功；
• false: 写操作到达内存即算作成功。

数据库数据写入的顺序  数据在内存中先写日志文件（journal 中落地持久化日志文件），再写数据文件

 

 

 mongoDB shell中使用

db.test.insert( {count: 1}, {writeConcern: {w: "majority"}})
db.test.insert( {count: 1}, {writeConcern: {w: 3 }})
db.test.insert( {count: 1}, {writeConcern: {w: 4 }})

 

readPreference与readConcern

readPreference 设置 分布式数据库从哪里读

readConcern 什么样的数据可以读

readPreference 

readPreference 决定使用哪一个节点来满足正在发起的读请求。可选值包括：

• primary: 只选择主节点；

• primaryPreferred：优先选择主节点，如果不可用则选择从节点；

• secondary：只选择从节点；

• secondaryPreferred：优先选择从节点，如果从节点不可用则选择主节点；

• nearest：选择最近的节点；

 

 场景举例：大量高并发读取的数据场景可以选择从节点，写入数据的时候，用主节点。

readPreference的 配置方式

通过 MongoDB 的连接串参数：
• mongodb://host1:27107,host2:27107,host3:27017/?replicaSet=rs&readPreference=secondary
通过 MongoDB 驱动程序 API：
• MongoCollection.withReadPreference(ReadPreference readPref)
Mongo Shell：
• db.collection.find({}).readPref( “secondary” ) 

readConcern

在 readPreference 选择了指定的节点后，readConcern 决定这个节点上的数据哪些是可读的，类似于关系数据库的隔离级别。可选值包括：
• available：读取所有可用的数据;
• local：读取所有可用且属于当前分片的数据;
• majority：读取在大多数节点上提交完成的数据;
• linearizable：可线性化读取文档;
• snapshot：读取最近快照中的数据;

在复制集中 local 和 available 是没有区别的。两者的区别主要体现在分片集上。考虑以下场景：
• 一个 chunk x 正在从 shard1 向 shard2 迁移；
• 整个迁移过程中 chunk x 中的部分数据会在 shard1 和 shard2 中同时存在，但源分片 shard1仍然是chunk x 的负责方：
　　所有对 chunk x 的读写操作仍然进入 shard1；
　　config 中记录的信息 chunk x 仍然属于 shard1；
• 此时如果读 shard2，则会体现出 local 和 available 的区别：
　　local：只取应该由 shard2 负责的数据（不包括 x）；
　　available：shard2 上有什么就读什么（包括 x）；

注意事项：
• 虽然看上去总是应该选择 local，但毕竟对结果集进行过滤会造成额外消耗。在一些无关紧要的场景（例如统计）下，也可以考虑 available；
• MongoDB <=3.6 不支持对从节点使用 {readConcern: "local"}；
• 从主节点读取数据时默认 readConcern 是 local，从从节点读取数据时默认readConcern 是 available（向前兼容原因）。

readConcern : ”majority” vs “local”

majority 如果有如下场景：

应业务需要做读写分离，主节点A主要做写入操作，从节点做读取操作；向主节点写入一条数据；立即从从节点读取这条数据。

如果用默认配置local，有的复制集从节点B到主A可能是有延时的，而导致在主节点A上修改数据后，立刻在从节点读取，发现有脏数据，主从数据不同步。所以需要majority配置，和其他节点互交确认大多数据节点上都是一样的数据才返回。

#注意配置文件内server参数开启 
enableMajorityReadConcern:ture

#这种方式读取不到刚写入的数据
db.orders.insert({ oid: 101, sku: ”kite", q: 1})  //主节点写入
db.orders.find({oid:101}).readPref("secondary")   //从节点读取

#使用 writeConcern + readConcern majority来解决 
db.orders.insert({ oid: 101, sku: "kiteboar", q: 1}, {writeConcern:{w: "majority”}})   //主节点写入
db.orders.find({oid:101}).readPref(“secondary”).readConcern("majority") 　　　　　　　　//从节点读取

readConcern: majority 与脏读
MongoDB 中的回滚：

• 写操作到达大多数节点之前都是不安全的，一旦主节点崩溃，而从节还没复制到该次操作，刚才的写操作就丢失了；
• 把一次写操作视为一个事务，从事务的角度，可以认为事务被回滚了。所以从分布式系统的角度来看，事务的提交被提升到了分布式集群的多个节点级别的“提交”，而不再是单个节点上的“提交”。在可能发生回滚的前提下考虑脏读问题：
• 如果在一次写操作到达大多数节点前读取了这个写操作，然后因为系统故障该操作回滚了，则发生了脏读问题；
使用 {readConcern: “majority”} 可以有效避免脏读

readConcern: linearizable

只读取大多数节点确认过的数据。和 majority 最大差别是保证绝对的操作线性顺序:

在写操作自然时间后面的发生的读，一定可以读到之前的写(会在读取的节点，向其他所有节点发起确认请求)
- 只对读取单个文档时有效；
- 可能导致非常慢的读，因此总是建议配合使用 maxTimeMS；

下图情况是在主节点网络异常时，从节点发起选举期间发生的脏读

 

readConcern: snapshot（最高级别）

{readConcern: “snapshot”} 只在多文档事务中生效。将一个事务的 readConcern
设置为 snapshot，将保证在事务中的读：
• 不出现脏读；
• 不出现不可重复读；
• 不出现幻读。
因为所有的读都将使用同一个快照，直到事务提交为止该快照才被释放。

官网mongoDB Java Client 事务使用示例：

final MongoClient client = MongoClients.create(uri);
/*
    Prereq: Create collections. CRUD operations in transactions must be on existing collections.
 */
client.getDatabase("mydb1").getCollection("foo")
        .withWriteConcern(WriteConcern.MAJORITY).insertOne(new Document("abc", 0));
client.getDatabase("mydb2").getCollection("bar")
        .withWriteConcern(WriteConcern.MAJORITY).insertOne(new Document("xyz", 0));
/* Step 1: Start a client session. */
final ClientSession clientSession = client.startSession();
/* Step 2: Optional. Define options to use for the transaction. */
TransactionOptions txnOptions = TransactionOptions.builder()
        .readPreference(ReadPreference.primary())
        .readConcern(ReadConcern.LOCAL)
        .writeConcern(WriteConcern.MAJORITY)
        .build();

/* Step 3: Define the sequence of operations to perform inside the transactions. */
TransactionBody txnBody = new TransactionBody<String>() {
    public String execute() {
        MongoCollection<Document> coll1 = client.getDatabase("mydb1").getCollection("foo");
        MongoCollection<Document> coll2 = client.getDatabase("mydb2").getCollection("bar");
        /*
           Important:: You must pass the session to the operations.
         */
        coll1.insertOne(clientSession, new Document("abc", 1));
        coll2.insertOne(clientSession, new Document("xyz", 999));
        return "Inserted into collections in different databases";
    }
};
try {
    /*
       Step 4: Use .withTransaction() to start a transaction,
       execute the callback, and commit (or abort on error).
    */

    clientSession.withTransaction(txnBody, txnOptions);
} catch (RuntimeException e) {
    // some error handling
} finally {
    clientSession.close();
}

java 示例2：

//MongoDB 多文档事务的使用方式与关系数据库非常相似：
try (ClientSession clientSession = client.startSession()) {
    clientSession.startTransaction();
    collection.insertOne(clientSession, docOne);
    collection.insertOne(clientSession, docTwo);
    clientSession.commitTransaction();
}

 

 db.fsyncLock() 与db.fsyncUnlock() 可以锁定/解锁节点的写入，可以用来做事务代码的测试。