Multi-threaded things 15 (sequential locks)

[Disclaimer: All Rights Reserved. You are welcome to reprint it. Do not use it for commercial purposes. Contact Email: feixiaoxing @ 163.com]

In mutually exclusive data access, there is a situation where multiple reads and writes are less. For such a situation, we also propose a read/write Lock solution. However, this lock has some defects. What are the defects? That is, This write lock can only be written after all the read locks are completed. Otherwise, the write lock needs to wait.

So, is there any way to make write operations faster? That is the sequential lock.

[CPP] View plaincopy

1. Typedef Struct_ Sequence_lock
2. {
3. UnsignedIntSequence;
4. HandleHlock;
6. } Sequence_lock;

With such a data structure. So how can I start reading locks,

[CPP] View plaincopy

2. UnsignedIntGet_lock_begin (sequence_lock * hseqlock)
4. {
6. Assert (null! = Hseqlock );
10. ReturnHseqlock-> sequence;
12. }
16. IntGet_lock_retry (sequence_lock * hseqlock, unsignedIntValue)
18. {
20. UnsignedIntNew_value;
22. Assert (null! = Hseqlock );
26. New_value = hseqlock-> sequence;
28. Return(New_value & 0x1) | (new_value ^ value );
30. }

The write lock also needs to be modified,

[CPP] View plaincopy

2. VoidGet_write_lock (sequence_lock * hseqlock)
4. {
6. Assert (null! = Hseqlock );
10. Waitforsingleobject (hseqlock-> hlock );
12. Hseqlock-> sequence ++;
14. }
18. VoidRelease_write_lock (sequence_lock * hseqlock)
20. {
22. Assert (null! = Hseqlock );
26. Hseqlock-> sequence ++;
28. Releasemutex (hseqlock-> hlock );
30. }

If the application is used, it is not difficult,

[CPP] View plaincopy

2. VoidRead_process (sequence_lock * hseqlock)
4. {
6. UnsignedIntSequence;
10. Do{
12. Sequence = get_lock_begin (hseqlock );
14. /* Read operation */
16. }While(Get_lock_retry (hseqlock, sequence ));
18. }
22. VoidWrite_process (sequencce_lock * hseqlock)
24. {
26. Get_write_lock (hseqlock );
28. /* Write operation */
30. Release_write_lock (hseqlock );
32. }

Summary:
(1) There are two conditions for exit of the read lock: either the write operation is in progress or no write lock.

(2) The write locks must be mutually exclusive.

(3) The data of mutex operations cannot be pointers. Otherwise, exceptions may occur during access because it is possible to write and read simultaneously.

(4) The sequential lock cannot replace the read/write lock, because the read/write lock can ensure all data operations, but the sequential lock cannot.