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

This article mainly explains the "Libtask source code analysis of how to understand locks", the article explains the content is simple and clear, easy to learn and understand, the following please follow the editor's ideas slowly in depth, together to study and learn "Libtask source code analysis of how to understand locks" bar!

In fact, locks are not needed in libtask, because the co-program in libtask is non-preemptive, and there is no race condition. But libtask still implements a set of locking mechanisms. Let's take a look at the implementation of this locking mechanism. First, let's look at the structure.

Struct QLock {/ / lock holder Task * owner; / / queue Tasklist waiting; waiting for the lock}

Then let's take a look at the operation of the lock.

Add lock

Static int _ qlock (QLock * l, int block) {/ / lock does not have a holder, then the current protocol is set as the holder and returns directly. 1 indicates successful locking if (l-> owner = = nil) {l-> owner = taskrunning; return 1;} / / non-blocking returns directly, 0 indicates locking failure if (! block) return 0 / / insert the waiting lock queue addtask (& l-> waiting, taskrunning); taskstate ("qlock"); / / switch to another taskswitch () / / when switching back, if the program holding the lock is not the current one, it exits abnormally, because only holding the lock will be switched back. See unqlock if (1-> owner! = taskrunning) {fprint (2, "qlock: owner=%p self=%p oops\ n", 1-> owner, taskrunning); abort ();} return 1;}

If there is no holder of the current lock, the current co-program X becomes the lock holder, otherwise, insert the co-program X into the waiting lock queue, then give up the cpu and switch to another co-program. When the subsequent lock is released and held by Synerg X, it will be awakened to continue. Locking can be divided into two modes: blocking and non-blocking. Non-blocking does not switch protocols even if locking fails.

/ / blocking locking void qlock (QLock * l) {_ qlock (l, 1);} / non-blocking locking int canqlock (QLock * l) {return _ qlock (l, 0);}

Release lock

Let's take a look at the logic of releasing the lock.

/ / release lock void qunlock (QLock * l) {Task * ready; / / the lock does not have a holder, abnormal exit if (l-> owner= = 0) {fprint (2, "qunlock: owner=0\ n"); abort () } / / if there is a co-program waiting for the lock, set it to the holder and remove it from the waiting queue, then modify the status to ready and join the ready queue if ((l-> owner = ready = l-> waiting.head)! = nil) {deltask (& l-> waiting, ready); taskready (ready);}}

When the lock is released, if there is a co-program waiting for the lock, a node is extracted from the waiting queue, then becomes the holder of the lock and is removed from the waiting queue. Finally, the ready queue is inserted to wait for scheduling. The above is an implementation of mutex. Let's take a look at the read-write lock mechanism. Read-write locks are also mutually exclusive, but can also be shared in some cases. Let's take a look at the data structure of read-write locks.

Struct RWLock {/ / the number of readers reading int readers; / / Writers currently being written, there is only one Task * writer; / / queue Tasklist rwaiting; Tasklist wwaiting; for reading and writing.

Then let me take a look at the locking logic.

Add read lock

/ / add a read lock static int _ rlock (RWLock * l, int block) {/ * is not writing and is not waiting to write, the lock is successful, and the number of readers plus one * / if (l-> writer = = nil & & l-> wwaiting.head = = nil) {l-> readers++; return 1;} / / if non-blocking returns if (! block) return 0 directly / / insert addtask waiting to read queue (& l-> rwaiting, taskrunning); taskstate ("rlock"); / / switch context taskswitch (); / / switch back, indicating lock successfully return 1;}

The read lock can be added successfully when and only if there are no writers who are writing or waiting for writing, otherwise the next step of processing will be carried out according to the locking mode, directly returning the locking failure or inserting the waiting queue, and then switching to other protocols. We see that when there is a co-program waiting to be written (l-> wwaiting.head! = nil), subsequent readers will not be able to lock successfully, but will be inserted into the waiting queue, otherwise the writer may be hungry.

Add write lock

/ / write lock static int _ wlock (RWLock * l, int block) {/ / is not being written and is not being read, the lock is successful, and the co-writer is the current protocol if (l-> writer = = nil & & l-> readers = = 0) {l-> writer = taskrunning; return 1; for non-blocking, it directly returns if (! block) return 0 / / join the waiting queue addtask (& l-> wwaiting, taskrunning); taskstate ("wlock"); / / switch taskswitch (); / / switch back to indicate that you have got the lock return 1;}

The write lock can be added successfully if and only if there are no writers and readers who are reading. Otherwise, it will be treated like a read lock.

Release the read lock

/ / release the read lock void runlock (RWLock * l) {Task * t; / / the reader minus one. If it is equal to 0 and there is a co-program waiting to be written, the first co-program in the queue holds the lock if (--l-> readers = = 0 & & (t = l-> wwaiting.head)! = nil) {deltask (& l-> wwaiting, t); l-> writer = t; taskready (t);}}

Holding a read lock means that there are certainly no writers currently writing, but there may be writers waiting to write and readers waiting to read (because there are writers waiting to write that cannot be locked successfully). When the read lock is released, if there are other readers, other readers can continue to hold the lock, because the reader can share the read lock, while the writer remains in its original state. If there are no readers but there are writers waiting to write, select the first node from the queue to be the holder of the lock, and the other writers continue to wait, because writers cannot share the write lock.

Release the write lock

/ / release write lock void wunlock (RWLock * l) {Task * t; / / No writing is in progress, abnormal exit if (l-> writer = = nil) {fprint (2, "wunlock: not locked\ n"); abort ();} / / empty, no co-program is writing l-> writer = nil / / there are unreadable if (l-> readers! = 0) {fprint (2, "wunlock: readers\ n"); abort () } / / when releasing the write lock, priority is given to the reader to hold the lock, because the reader can share the lock, improve the concurrency / / read can be shared, add all the protocols waiting for reading to the ready queue, and hold the lock while ((t = 1-> rwaiting.head)! = nil) {deltask (& l-> rwaiting, t); l-> readers++; taskready (t) } / / when the write lock is released, if there is no reader and there is a co-program waiting to be written, the first co-program waiting for writing in the queue holds the lock if (l-> readers = = 0 & & (t = l-> wwaiting.head)! = nil) {deltask (& l-> wwaiting, t); l-> writer = t; taskready (t);}}

With a write lock, there may be writers waiting to write and readers waiting to read. Here, the reader has priority in holding the lock, because the reader can share the lock, improve concurrency, and then judge the writer if there is no reader.

Thank you for your reading, the above is the "Libtask source code analysis of how to understand the lock" content, after the study of this article, I believe you on the Libtask source code analysis of how to understand the lock of this problem has a deeper understanding, the specific use of the situation also needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

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.