Linux中读写锁--写锁优先

my_pthread_rwlock.c

#include"my_pthread_rwlock.h"
#include<errno.h>

int 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<pthread.h>
#include<stdio.h>

typedef 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<stdio.h>
#include<unistd.h>
#include<pthread.h>
#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;
}
*/