读写锁 linux 静态,Linux中读写锁--写锁优先

my_pthread_rwlock.c

#include"my_pthread_rwlock.h"

#includeint my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw)

{

int result;

if(rw->rw_magic != RW_MAGIC)

return -1;

if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)

return result;

while(rw->rw_refcount<0 || rw->rw_nwaitwriters>0)

{

rw->rw_nwaitreaders++;

result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);

rw->rw_nwaitreaders--;

if(result != 0)

break;

}

if(result == 0)

rw->rw_refcount++;

pthread_mutex_unlock(&rw->rw_mutex);

return result;

}

int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)

{

int result;

if(rw->rw_magic != RW_MAGIC)

return -1;

if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)

return result;

while(rw->rw_refcount != 0)

{

rw->rw_nwaitwriters++;

result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);

rw->rw_nwaitwriters--;

if(result != 0)

break;

}

if(result == 0)

rw->rw_refcount = -1;

pthread_mutex_unlock(&rw->rw_mutex);

return result;

}

int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw)

{

int result;

if(rw->rw_magic != RW_MAGIC)

return -1;

if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)

return result;

if(rw->rw_refcount > 0)

rw->rw_refcount--;

else if(rw->rw_refcount == -1)

rw->rw_refcount = 0;

else

printf("unlock error.\n");

if(rw->rw_nwaitwriters > 0)

{

if(rw->rw_refcount == 0)

{

result = pthread_cond_signal(&rw->rw_condwriters);

}

}

else if(rw->rw_nwaitreaders > 0)

result = pthread_cond_broadcast(&rw->rw_condreaders);

pthread_mutex_unlock(&rw->rw_mutex);

return result;

}

int my_phread_rwlock_destroy(my_pthread_rwlock_t *rw)

{

if(rw->rw_magic != RW_MAGIC)

return (EINVAL);

if(rw->rw_refcount != 0 || rw->rw_nwaitreaders != 0 || rw->rw_nwaitwriters != 0)

return (EBUSY);

pthread_mutex_destroy(&rw->rw_mutex);

pthread_cond_destroy(&rw->rw_condreaders);

pthread_cond_destroy(&rw->rw_condwriters);

rw->rw_magic = 0;

return 0;

}

my_pthread_rwlock_tryrdlock(my_pthread_rwlock_t *rw)

{

int result;

if(rw->rw_magic != RW_MAGIC)

return (EINVAL);

if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)

return result;

if(rw->rw_refcount <0 || rw->rw_nwaitwriters > 0)

result = (EBUSY);

else

rw->rw_refcount++;

pthread_mutex_unlock(&rw->rw_mutex);

return result;

}

my_pthread_rwlock_trywrlock(my_pthread_rwlock_t *rw)

{

int result;

if(rw->rw_magic != RW_MAGIC)

return (EINVAL);

if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)

return result;

if(rw->rw_refcount != 0)

return (EBUSY);

else

rw->rw_refcount = -1;

pthread_mutex_unlock(&rw->rw_mutex);

return result;

}

my_pthread_rwlock.h

#pragma once

#include#includetypedef struct

{

pthread_mutex_t rw_mutex;

pthread_cond_t rw_condreaders;

pthread_cond_t rw_condwriters;

int rw_magic;

int rw_nwaitreaders;

int rw_nwaitwriters;

int rw_refcount; // 0 >0 ==-1

}my_pthread_rwlock_t;

#define RW_MAGIC 0x20180326

#define MY_PTHREAD_RWLOCK_INITIALIZER {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER,\

RW_MAGIC,0,0,0}

typedef int my_pthread_rwlockattr_t;

int my_pthread_rwlock_init(my_pthread_rwlock_t *rw, my_pthread_rwlockattr_t *attr);

int my_pthread_rwlock_destroy(my_pthread_rwlock_t *rw);

int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw);

int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw);

int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw);

int my_pthread_rwlock_tryrdlock(my_pthread_rwlock_t *rw);

int my_pthread_rwlock_trywrlock(my_pthread_rwlock_t *rw);

test.c//测试文件

#include#include#include#include"my_pthread_rwlock.h"

#include"my_pthread_rwlock.c"

my_pthread_rwlock_t rwlock = MY_PTHREAD_RWLOCK_INITIALIZER;

void * thread_fun1(void *arg)

{

my_pthread_rwlock_wrlock(&rwlock);

printf("thread 1 wrlock.\n");

sleep(3);

my_pthread_rwlock_unlock(&rwlock);

}

void * thread_fun2(void *arg)

{

my_pthread_rwlock_wrlock(&rwlock);

//my_pthread_rwlock_trywrlock(&rwlock);

//printf("thread 2 trywrlock\n");

printf("thread 2 wrlock.\n");

my_pthread_rwlock_unlock(&rwlock);

}

void * thread_fun3(void *arg)

{

my_pthread_rwlock_rdlock(&rwlock);

//my_pthread_rwlock_tryrdlock(&rwlock);

//printf("thread 3 tryrdlock.\n");

printf("thread 3 rdlock.\n");

my_pthread_rwlock_unlock(&rwlock);

}

int main()

{

pthread_t tid1, tid2, tid3;

pthread_create(&tid1, NULL, thread_fun1, NULL);

sleep(1);

pthread_create(&tid3, NULL, thread_fun3, NULL);

pthread_create(&tid2, NULL, thread_fun2, NULL);

pthread_join(tid1, NULL);

pthread_join(tid2, NULL);

pthread_join(tid3, NULL);

return 0;

}

/*

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

void* thread_fun1(void *arg)

{

pthread_rwlock_wrlock(&rwlock);

printf(" thread fun 1 wrlock.\n");

sleep(15);

printf("thread fun 1 unlock.\n");

pthread_rwlock_unlock(&rwlock);

}

void* thread_fun2(void *arg)

{

int index = *(int*)arg;

printf("thread fun 2[ %d] start up.\n",index);

pthread_rwlock_wrlock(&rwlock);

printf("thread fun 2:[%d] wrlock\n",index);

pthread_rwlock_unlock(&rwlock);

}

void* thread_fun3(void *arg)

{

int index = *(int *)arg;

printf("thread fun 2[ %d] start up.\n",index);

pthread_rwlock_rdlock(&rwlock);

printf("thread fun 3:[%d] rdlock\n",index);

pthread_rwlock_unlock(&rwlock);

}

int main()

{

pthread_t tid1, tid2[5], tid3[5];

pthread_create(&tid1, NULL, thread_fun1, NULL);

sleep(1);

int i;

for(i=0; i<5; ++i)

{

pthread_create(&tid2[i], NULL, thread_fun2, &i);

sleep(1);

}

for(i=0; i<5; ++i)

{

pthread_create(&tid3[i], NULL, thread_fun3, &i);

}

for(i=0; i<5; ++i)

{

pthread_join(tid2[i], NULL);

pthread_join(tid3[i], NULL);

}

pthread_join(tid1, NULL);

return 0;

}

/*

void* thread_fun1(void *arg)

{

pthread_mutex_lock(&mutex);

printf("This is thread fun 1.\n");

sleep(3);

printf("thread fun 1 cond wait.......\n");

pthread_cond_wait(&cond, &mutex);

printf("thread fun 1 waked up.\n");

pthread_mutex_unlock(&mutex);

}

void* thread_fun2(void *arg)

{

printf("This is thread fun 2.\n");

pthread_mutex_lock(&mutex);

printf("aaaaaaaaaaaaaaa\n");

sleep(2);

printf("cond signal thread......\n");

pthread_cond_signal(&cond);

sleep(3);

printf("====================\n");

pthread_mutex_unlock(&mutex);

}

void * thread_fun3(void *arg)

{

printf("This is thread fun 3.\n");

pthread_mutex_lock(&mutex);

printf("bbbbbbbbbbbbbbbbb\n");

pthread_cond_signal(&cond);

pthread_mutex_unlock(&mutex);

}

int main()

{

pthread_t tid1, tid2, tid3;

pthread_create(&tid1, NULL, thread_fun1, NULL);

sleep(1);

pthread_create(&tid3, NULL, thread_fun3, NULL);

pthread_create(&tid2, NULL, thread_fun2, NULL);

pthread_join(tid1, NULL);

pthread_join(tid2, NULL);

return 0;

}

*/