Etcd tutorial - Chapter 9 etcd implementation of distributed locks

One 、 adopt Etcd txn Implement distributed locks

adopt Etcd Implement distributed locks , It also needs to be consistent 、 Mutual exclusion and reliability .Etcd The transaction txn、lease The lease and watch Monitoring features , Can make based on Etcd Distributed locks that implement the above requirements .

1.1 Thought analysis

1. adopt Etcd The transaction features of can help us achieve consistency and mutual exclusion .Etcd The transactional nature of , The use of IF-Then-Else sentence ,IF Language judgment Etcd Whether the server has the specified key, That is, the key Create version number create_revision Is it 0 To check key Does it already exist , Because it's time to key If it already exists , its create_revision The version number is not 0.

2. Satisfy IF In the case of condition, use then perform put operation , otherwise else Statement returns the result of the failed lock snatch . Of course , Besides using key Whether it was successfully created as IF On the basis of , You can also create... With the same prefix key, Compare these key Of revision To determine which request the distributed lock should belong to .

3. The client requests that after getting the distributed lock , If something unusual happens , The lock needs to be released in time . So you need a lease , When we apply for distributed locks, we need to specify the lease time . exceed lease The lease time will automatically release the lock , Ensure the availability of the business .

4. Is that enough ？ When executing business logic , If the client initiates a time-consuming operation , If the operation is not completed, please , The lease has expired , Causes other requests to acquire distributed locks , To cause disagreement . In this case, it needs to be renewed , That is to refresh the lease , Enables the client to communicate with etcd The server keeps the heartbeat .

Two 、 Concrete realization

2.1 flow chart

We are based on the above analysis , Draw the implementation etcd Flow chart of distributed lock , As shown below ：

2.2 Implementation code

be based on Go The realization of language etcd Distributed lock , The test code is as follows ：

func TestLock(t *testing.T) {
	//  Client configuration 
	config = clientv3.Config{
		Endpoints:   []string{"localhost:2379"},
		DialTimeout: 5 * time.Second,
	}
	//  Establishing a connection 
	if client, err = clientv3.New(config); err != nil {
		fmt.Println(err)
		return
	}

	// 1.  Lock and create a lease 
	lease = clientv3.NewLease(client)

	if leaseGrantResp, err = lease.Grant(context.TODO(), 5); err != nil {
		panic(err)
	}
	leaseId = leaseGrantResp.ID

	// 2  Automatic renewal 
	//  Create a cancellable lease , The main purpose is to release when you exit 
	ctx, cancelFunc = context.WithCancel(context.TODO())

	// 3.  Release the lease 
	defer cancelFunc()
	defer lease.Revoke(context.TODO(), leaseId)

	if keepRespChan, err = lease.KeepAlive(ctx, leaseId); err != nil {
		panic(err)
	}
	//  Renewal response 
	go func() {
		for {
			select {
			case keepResp = <-keepRespChan:
				if keepRespChan == nil {
					fmt.Println(" The lease has lapsed ")
					goto END
				} else { //  It will be renewed every second ,  So you get a response 
					fmt.Println(" Auto renewal response received :", keepResp.ID)
				}
			}
		}
	END:
	}()

	// 1.3  Grab the lock during the lease time （etcd  The lock inside is one  key）
	kv = clientv3.NewKV(client)

	//  Create transaction 
	txn = kv.Txn(context.TODO())

	//if  non-existent  key,then  Set it up ,else  Lock snatch failed 
	txn.If(clientv3.Compare(clientv3.CreateRevision("lock"), "=", 0)).
		Then(clientv3.OpPut("lock", "g", clientv3.WithLease(leaseId))).
		Else(clientv3.OpGet("lock"))

	//  Commit transaction 
	if txnResp, err = txn.Commit(); err != nil {
		panic(err)
	}

	if !txnResp.Succeeded {
		fmt.Println(" Lock occupied :", string(txnResp.Responses[0].GetResponseRange().Kvs[0].Value))
		return
	}

	//  After seizing the lock, execute the business logic , There's no exit 
	fmt.Println(" Processing tasks ")
	time.Sleep(5 * time.Second)

}

The expected implementation results are as follows ：

=== RUN   TestLock
 Processing tasks 
 Auto renewal response received : 7587848943239472601
 Auto renewal response received : 7587848943239472601
 Auto renewal response received : 7587848943239472601
--- PASS: TestLock (5.10s)
PASS

In general , As mentioned above about etcd The implementation process of distributed lock is divided into four steps ：

1. Client initialization and connection establishment ;
2. Create a lease , Automatic renewal ;
3. Create transaction , Get the lock ;
4. Execute business logic , Finally release the lock .

When you create a lease , You need to create a cancellable lease , The main purpose is to release when you exit . The steps to release the lock , Above defer In the sentence . When defer When the lease closes , Distributed locks correspond to key Will be released .