Shulou(Shulou.com)06/01 Report--

Preface

As we all know, in multithreading, sharing global variables will lead to inconsistent results of resource modification, so locks are needed to solve this problem to ensure that only one thread operates on the resource at a time.

But in a distributed architecture, our service may have n instances, but thread locks are only valid for the same instance, so we need to use distributed locks-redis setnx

Principle

When modifying a resource, set a key,value in redis to decide how to represent it according to the actual situation.

Since we want to check whether key exists (it means that a thread is modifying resources and resources are locked, and other threads cannot operate at the same time, if key does not exist, resources are not occupied by threads, and threads are allowed to preempt them. Then vlaue is set through setnx, indicating that resources are locked, and other threads cannot operate at the same time).

The figure shows:

Analysis.

Our service is in a cluster, and there is a problem if we simply use thread locks to solve the above problems: because threads are process-based, the two web server are in different process spaces.

In other words, the request of user1 is sent to web server1, which can only be locked with other requests of web server1, but cannot affect the request of web server2.

In the figure above, the thread responsible for processing the requests sent by user1 to web server1 is Thread1, which is the same as the thread thread2 responsible for processing requests from user2 to web server2.

At the same time, 1, both threads read the value of residue_ticket in mysql as 100. corresponding to figure (1) (2) above, they each perform-1 operation on 100 and update it to the database, corresponding to (3) (4).

What we expect is that the residue_ tick value is reduced twice, which should be 98, but in reality, both threads do 100-1% 99 operations and both change the value in mysql to 99, which leads to final data inconsistency, so distributed locks are used.

Why use redis?

Because redis is single-threaded, there is no multithreaded resource competition, and it is really fast

Why use setnx instead of set?

Setnx means that the setting can only be successful if key does not exist, but set will modify value if key exists.

Using the features of setnx, we can design it like this:

Pseudo code:

# redis key for setting redis locks = 'residue_ticket_lock' # get_ticket is the logical def get_ticket for handling ticket purchases (): time_out = 5 # in order to prevent the performance impact caused by too many threads, the current thread cannot acquire the lock and is in a loop for a long time, we set a timeout if the current thread does not preempt the distributed lock within the timeout. Return the failed result while True: if redis.setnx ('residue_ticket_lock','lock',5): # if setnx returns True, it means that no other thread is operating the database at this time, and the current thread can lock successfully. Note that not only value=lock but also expiration time is set, which is necessary In order to prevent the locked thread from collapsing so that it cannot be released (delete key) and all other threads will never get the operation right residue_ticket = mysql.get ('residue_ticket') # get the current remaining votes from mysql mysql.update (' residue_ticket',residue_ticket-1) # order successfully, the number of votes will be-1 Update data to mysql # Delete key, release lock redis.del ('residue_ticket') return True else: # if setnx returns False, it means that another thread is operating, and the current thread waits for 0.01s And continue to cycle time.sleep (0.01) time_out-= 0.01continue return False

The above is the whole content of this article, I hope it will be helpful to your study, and I also hope that you will support it.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.