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

This article is about how to achieve a read-write lock in Python. The editor thinks it is very practical, so I share it with you. I hope you can get something after reading this article.

Simple implementation

Import threadingclass RWlock (object): def _ init__ (self): self._lock = threading.Lock () self._extra = threading.Lock () self.read_num = 0 def read_acquire (self): with self._extra: self.read_num + = 1 if self.read_num = = 1: self._lock.acquire () Def read_release (self): with self._extra: self.read_num-= 1 if self.read_num = = 0: self._lock.release () def write_acquire (self): self._lock.acquire () def write_release (self): self._lock.release ()

This is a simple implementation of the read-write lock. Self.read_num is used to hold the number of threads that acquired the read lock. This property belongs to the critical section, and its operation is also locked, so an additional lock self._extra is needed to protect the internal data.

But this lock is unfair. Ideally, threads should have the same chance of getting what they want, regardless of whether the thread is a read operation or a write operation. As you can see from the above code, the read request immediately sets self.read_num + = 1, regardless of whether the lock is acquired or not, while the write request has to wait until read_num is 0 to acquire the lock.

So this makes it possible to get write permission only if the lock is not occupied or if there is no read request. We should find ways to avoid long-term occupation of read mode locks.

Priority of read-write lock

Read-write locks also have read priority and write priority. The above code belongs to read first.

If you want to change to write first, then instead to record the reference count of the writer thread, when read and write compete at the same time, you can let the writer thread increase the write count, so that the reader thread can not get the read lock all the time, because the reader thread has to judge the reference count of the write first, if it is not 0, wait for it to be 0, and then read. This part of the code is not listed.

But this is obviously not flexible enough. We don't need two similar read-write lock classes. We want to ReFactor our code to make it more powerful.

Improve

In order to satisfy the read-write lock of custom priority, the number of read and write threads waiting is recorded, and two conditional threading.Condition are required to handle which party takes precedence notification. Counting references can expand the semantics: positive: indicates the number of threads reading, negative: indicates the number of threads writing (up to-1)

When getting the read operation, first and then judge that there is a writer thread waiting for the read operation. If there is no, do the read operation, then wait for the read count to add 1 and then wait for the Condition notification; the count waiting for the read minus 1, the count reference plus 1, and continue the read operation. If the condition is not true, the loop waits.

When obtaining a write operation, if the lock is not occupied, the reference count is subtracted by 1. If occupied, wait for the number of write threads to increase by 1, and wait for the notification of the write condition Condition.

The release of both read mode and write mode is the same, and the corresponding Condition needs to be notified according to judgment:

Class RWLock (object): def _ init__ (self): self.lock = threading.Lock () self.rcond = threading.Condition (self.lock) self.wcond = threading.Condition (self.lock) self.read_waiter = 0 # number of threads waiting for read lock self.write_waiter = 0 # number of threads waiting for write lock self.state = 0 # positive number: negative number of threads reading operation: number of threads writing operation (up to-1) self.owners = [] # threads operating id collection self.write_first = True # default write priority False means read first def write_acquire (self) Blocking=True): # get a write lock only if me = threading.get_ident () with self.lock: while not self._write_acquire (me): if not blocking: return False self.write_waiter + = 1 self.wcond.wait () self.write_ Waiter-= 1 return True def _ write_acquire (self Me): # acquire a write lock only if the lock is unoccupied Or the current thread has occupied if self.state = = 0 or (self.state

< 0 and me in self.owners): self.state -= 1 self.owners.append(me) return True if self.state >

0 and me in self.owners: raise RuntimeError ('cannot recursively wrlock a rdlocked lock') return False def read_acquire (self Blocking=True): me = threading.get_ident () with self.lock: while not self._read_acquire (me): if not blocking: return False self.read_waiter + = 1 self.rcond.wait () self.read_waiter-= 1 return True def _ read_acquire (self Me): if self.state

< 0: # 如果锁被写锁占用 return False if not self.write_waiter: ok = True else: ok = me in self.owners if ok or not self.write_first: self.state += 1 self.owners.append(me) return True return False def unlock(self): me = threading.get_ident() with self.lock: try: self.owners.remove(me) except ValueError: raise RuntimeError('cannot release un-acquired lock') if self.state >

0: self.state-= 1 else: self.state + = 1 if not self.state: if self.write_waiter and self.write_first: # if a write operation is waiting (default write priority) self.wcond.notify () elif self.read_waiter: Self.rcond.notify_all () elif self.write_waiter: self.wcond.notify () read_release = unlock write_release = unlock above is how to implement a read-write lock in Python The editor believes that there are some knowledge points that we may see or use in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

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.