Lock on reading with the ability to capture to write

Good day!
After a more detailed analysis of the task, it turned out that the most appropriate synchronization element in my case would be a read lock, with the possibility of capturing the write lock, since the design contains functions that: 1) only read the table, 2) just write the table, 3) sequentially, logically inextricably read and write the table (for example, searching for an element with its subsequent deletion). Based on the avp example from my previous question, thanks again, I wrote my own version of the implementation of such a lock based on the rwlock posix-primitive.
I would like to discuss the advantages and disadvantages.

Lock implementation:

#include "my_rwlock.h" static pthread_mutex_t lock_protect_mutex = PTHREAD_MUTEX_INITIALIZER; //идентификатор потока, захватившего блокировку с дозахватом static pthread_mutex_t tid_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_t protect_tid; int smart_rwlock_operation(p_rwlock, operation) pthread_rwlock_t *p_rwlock; uint8_t operation; { int res = 0; int ok = 0; if(p_rwlock == (pthread_rwlock_t *)NULL) return(EINVAL); switch(operation){ case MY_RDLOCK ://обычная блокировка на чтение res = pthread_rwlock_rdlock(p_rwlock); #ifdef DEBUG if(res) printf("Error %d of locking rwlock (pthread %u)\n", res,pthread_self()); #endif break; case MY_WRLOCK ://обычная блокировка на запись res = pthread_rwlock_wrlock(p_rwlock); #ifdef DEBUG if(res) printf("Error %d of locking rwlock (pthread %u)\n", res,pthread_self()); #endif break; case MY_UNLOCK ://снятие блокировки res = pthread_rwlock_unlock(p_rwlock); #ifdef DEBUG if(res) printf("Error %d of unlocking rwlock (pthread %u)\n", res,pthread_self()); #endif break; case MY_RDLOCK_PROTECT ://захват на чтение блокировки с дозахватом res = pthread_mutex_lock(&lock_protect_mutex); if(!res){ // мьютекс захвачен, захватываем блокировку чтения res = pthread_rwlock_rdlock(p_rwlock); if(!res){ //блокировка захвачена pthread_mutex_lock(&tid_mutex); protect_tid = pthread_self(); pthread_mutex_unlock(&tid_mutex); } else{ //ошибка - отпустим мьютекс res = pthread_mutex_unlock(&lock_protect_mutex); } } #ifdef DEBUG if(res) printf("Error %d of protected read-locking (pthread %u)\n",res,pthread_self()); #endif break; case MY_UNLOCK_PROTECT ://снятие блокировки с дозахватом pthread_mutex_lock(&tid_mutex); if((res = (pthread_mutex_trylock(&lock_protect_mutex)) == EBUSY) && (pthread_equal(pthread_self(),protect_tid) != 0)){ //мьютекс уже захвачен этим же потоком ok = 1; } else if(!res){ //мьютекс захвачен, некорректная операция pthread_mutex_unlock(&lock_protect_mutex); res = EINVAL; } else //мьютекс захвачен другим потоком, некорректная операция res = EBUSY; pthread_mutex_unlock(&tid_mutex); if(ok){ //мы в нужном потоке, можно освободить блокировку и мьютекс res = pthread_rwlock_unlock(p_rwlock); if(!res) res = pthread_mutex_unlock(&lock_protect_mutex); else pthread_mutex_unlock(&lock_protect_mutex); } #ifdef DEBUG if(res) printf("Error %d of protected unlocking (pthread %u)\n",res,pthread_self()); #endif break; case MY_FROMRD_TOWR_PROTECT ://дозахват блокировки на чтение до записи pthread_mutex_lock(&tid_mutex); if((pthread_mutex_trylock(&lock_protect_mutex) == EBUSY) && (pthread_equal(pthread_self(),protect_tid) != 0)){ ok = 1; } else if(!res){ pthread_mutex_unlock(&lock_protect_mutex); res = EINVAL; } else res = EBUSY; pthread_mutex_unlock(&tid_mutex); if(ok){ //дозахватываем блокировку на запись res = pthread_rwlock_unlock(p_rwlock); if(!res) res = pthread_rwlock_wrlock(p_rwlock); } #ifdef DEBUG if(res) printf("Error %d of update to write-locking (pthread %u)\n",res,pthread_self()); #endif break; case MY_FROMWR_TORD_PROTECT ://осовбождение блокировки на запись до чтения pthread_mutex_lock(&tid_mutex); if((pthread_mutex_trylock(&lock_protect_mutex) == EBUSY) && (pthread_equal(pthread_self(),protect_tid) != 0)){ ok = 1; } else if(!res){ pthread_mutex_unlock(&lock_protect_mutex); res = EINVAL; } else res = EBUSY; pthread_mutex_unlock(&tid_mutex); if(ok){ //откатываемся к блокировке чтения res = pthread_rwlock_unlock(p_rwlock); if(!res) res = pthread_rwlock_rdlock(p_rwlock); } #ifdef DEBUG if(res) printf("Error %d of update to read-locking (pthread %u)\n",res,pthread_self()); #endif break; case MY_WRLOCK_PROTECT : res = pthread_mutex_lock(&lock_protect_mutex); if(!res){ // мьютекс захвачен, захватываем блокировку записи res = pthread_rwlock_wrlock(p_rwlock); if(!res){ //блокировка захвачена pthread_mutex_lock(&tid_mutex); protect_tid = pthread_self(); pthread_mutex_unlock(&tid_mutex); } else{ //ошибка - отпустим мьютекс res = pthread_mutex_unlock(&lock_protect_mutex); } } #ifdef DEBUG if(res) printf("Error %d of protected write-locking (pthread %u)\n",res,pthread_self()); #endif break; default : return(EINVAL); break; } return(res); } 

Test:
//my_rwlock.h

 #ifndef __MY_RWLOCK__ #define __MY_RWLOCK__ #include <stdlib.h> #include <stdio.h> #include <sys/types.h> #include <strings.h> #include <errno.h> #include <pthread.h> #define CNT_EL 5 #define BUF_LEN 256 #define MAX_CNT 20 // операции над блокировкой чтения-записи с дозахватом #define MY_RDLOCK 0x00 #define MY_WRLOCK 0x01 #define MY_UNLOCK 0x02 #define MY_RDLOCK_PROTECT 0x03 #define MY_UNLOCK_PROTECT 0x04 #define MY_FROMRD_TOWR_PROTECT 0x05 #define MY_FROMWR_TORD_PROTECT 0x06 #define MY_WRLOCK_PROTECT 0x07 int array[CNT_EL]; int cnt; pthread_rwlock_t array_lock; int smart_rwlock_operation(pthread_rwlock_t *, uint8_t ); #endif //__MY_RWLOCK__ 

//main.c

 #include "my_rwlock.h" void *func_reader(void *arg){ //функция читателя int i; while(1){ smart_rwlock_operation(&array_lock, MY_RDLOCK); if(cnt >= MAX_CNT){ smart_rwlock_operation(&array_lock, MY_UNLOCK); break; } printf("Read with simple rdlock : "); for(i = 0; i < CNT_EL; i++) printf("%d ",array[i]); printf("\n"); smart_rwlock_operation(&array_lock, MY_UNLOCK); sleep(1); } return((void *)0); } void *func_writer(void *arg){ //функция писателя int i; while(1){ smart_rwlock_operation(&array_lock, MY_WRLOCK_PROTECT); if(cnt >= MAX_CNT){ smart_rwlock_operation(&array_lock, MY_UNLOCK_PROTECT); break; } cnt++; printf("Write with simple wrlock : "); for(i = 0; i < CNT_EL; i++){ array[i] = i+10; printf("%d ",array[i]); } printf("\n"); smart_rwlock_operation(&array_lock, MY_UNLOCK_PROTECT); sleep(2); } return((void *)0); } void *func_smart_reader(void *arg){ //функиция читателя, который может прокачаться до писателя int i; while(1){ smart_rwlock_operation(&array_lock, MY_RDLOCK_PROTECT); if(cnt >= MAX_CNT){ smart_rwlock_operation(&array_lock, MY_UNLOCK_PROTECT); break; } //захватили блокировку чтения с возможностью дозахвата на запись printf("Read with smart rwlock : "); for(i = 0; i < CNT_EL; i++) printf("%d ",array[i]); printf("\n"); if(array[0] != 0){ //вернем старый массив smart_rwlock_operation(&array_lock, MY_FROMRD_TOWR_PROTECT); //проапгрейдили блокировку чтения до записи cnt++; printf("Write with smart rwlock : "); for(i = 0; i < CNT_EL; i++){ array[i] = i; printf("%d ",array[i]); } printf("\n"); smart_rwlock_operation(&array_lock, MY_FROMWR_TORD_PROTECT); // снова понизили блокировку до чтения } printf("Affordable to read\n"); smart_rwlock_operation(&array_lock, MY_UNLOCK_PROTECT); sleep(1); } return((void *)0); } int main(int argc, char *argv[]) { int i; pthread_t tid[4]; char buf[BUF_LEN]; void *res; array_lock = PTHREAD_MUTEX_INITIALIZER; for(i = 0;i < CNT_EL; i++) array[i] = i; cnt = 0; if(pthread_create(&tid[0],NULL,func_reader,NULL) != 0){ bzero(buf,BUF_LEN); strerror_r(errno,buf,BUF_LEN); printf("Error of thread createng : %s\n",buf); } if(pthread_create(&tid[1],NULL,func_reader,NULL) != 0){ bzero(buf,BUF_LEN); strerror_r(errno,buf,BUF_LEN); printf("Error of thread createng : %s\n",buf); } if(pthread_create(&tid[2],NULL,func_writer,NULL) != 0){ bzero(buf,BUF_LEN); strerror_r(errno,buf,BUF_LEN); printf("Error of thread createng : %s\n",buf); } if(pthread_create(&tid[3],NULL,func_smart_reader,NULL) != 0){ bzero(buf,BUF_LEN); strerror_r(errno,buf,BUF_LEN); printf("Error of thread createng : %s\n",buf); } for(i = 0; i < 4; i++) pthread_join(tid[i], &res); printf("Bye!!!\n"); return 0; } 

Results :
...

 Read with simple rdlock : Read with simple rdlock : 0 1 2 3 4 Read with smart rwlock : 0 1 2 3 4 Affordable to read 0 1 2 3 4 Write with simple wrlock : 10 11 12 13 14 Read with simple rdlock : 10 11 12 13 14 Read with simple rdlock : 10 11 12 13 14 Read with smart rwlock : 10 11 12 13 14 Write with smart rwlock : 0 1 2 3 4 Affordable to read Read with simple rdlock : 0 1 2 3 4 Read with smart rwlock : 0 1 2 3 4 Affordable to read Read with simple rdlock : 0 1 2 3 4 Write with simple wrlock : 10 11 12 13 14 Read with simple rdlock : 10 Read with simple rdlock : 11 12 13 14 10 11 12 13 14 Read with smart rwlock : 10 11 12 13 14 Write with smart rwlock : 0 1 2 3 4 Affordable to read Read with simple rdlock : 0 Read with smart rwlock : 0 1 2 3 4 Affordable to read Read with simple rdlock : 0 1 2 3 4 1 2 3 4 Write with simple wrlock : 10 11 12 13 14 Read with simple rdlock : 10 11 12 13 14 Read with smart rwlock : 10 11 12 13 14 Read with simple rdlock : 10 11 12 13 14 Write with smart rwlock : 0 1 2 3 4 Affordable to read Read with simple rdlock : 0 1 Read with simple rdlock : 0 Read with smart rwlock : 0 1 1 2 3 4 Affordable to read 2 3 4 2 3 4 

...

* I did not specifically block the output operation so that it could be seen that the reader threads are working simultaneously.

UPDATE

It is implied that MY_RDLOCK_PROTECT used only when we need to capture a read-write read-write (there is a similar primitive in Boost), it will be used only in the third variant, when reading and writing are logically related. In functions where only reading is MY_RDLOCK , MY_RDLOCK used, in it the lock_protect_mutex mutex lock_protect_mutex not performed. Thus, they will work at the same time - all the threads that captured the lock using MY_RDLOCK , and the threads that captured MY_RDLOCK_PROTECT , until they upgrade the read-to-write lock using MY_FROMRD_TOWR_PROTECT .
When a read lock is captured for writing via MY_FROMRD_TOWR_PROTECT , "writers only" cannot get into this process, since lock_protect_mutex is still captured.

The streams are “writers only”, they will first wait for the lock_protect_mutex mutex to be lock_protect_mutex , and then wait for “only readers” to remain. At the same time, since the mutex is already captured, threads that have a mixed version of "read + write" will wait for the completion of the "only writer" work.

To summarize, I wanted to achieve the following: “only writers” and “writer + reader” never work at the same time, while “only readers” and “writer + reader” work simultaneously in the period when “writer + reader” has not produced dozakvat lock before recording, or on the contrary, lowered it from writing to reading.