这次当我给面试官提及到读写锁的时候，详细问了我的读写锁，我知道怎么回事，用法，但是具体没实践过，听过的还是不要给面试官说了，不然又给自己挖坑。

   下面这个程序就是读写锁的程序，分别有两个读者，两个写着，当写着输入end的时候并且读者读到程序运行结束，里面的读写锁是动态初始化，最后用pthread_join()，主要主线程等待子线程运行完她才可以结束。对于现在锁，我才感觉到都是有套路的，都被玩坏了。初始化，处理的，最后是销毁的。此外，我还遇到的一个问题是当时忘记在写线程忘记休眠sleep，结果一直让我写，写，写，那么她就一直拿着cpu写，就算输入end也就结束不了，因为读线程根本执行不到。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <bits/pthreadtypes.h>


#define  WORK_SIZE  1024

static  pthread_rwlock_t  rwlock;

char work_area[WORK_SIZE];
int time_to_exit;

void *thread_to_read_o(void *arg);
void *thread_to_read_t(void *arg);
void *thread_to_write_o(void *arg);
void *thread_to_write_t(void *arg);


void *thread_to_read_o(void *arg)
{
    printf("thread read one try to get lock\n");

    pthread_rwlock_rdlock(&rwlock);
    while(strncmp("end",work_area,3) != 0){
        printf("this is thread read one\n");
        printf("the characters is %s\n",work_area);
        pthread_rwlock_unlock(&rwlock);
        sleep(2);
        pthread_rwlock_rdlock(&rwlock);
        while(work_area[0] == '\0'){
           pthread_rwlock_unlock(&rwlock);
           sleep(2);
           pthread_rwlock_rdlock(&rwlock);
        }
    }
    pthread_rwlock_unlock(&rwlock);
    time_to_exit = 1;
    pthread_exit(0);
}

void *thread_to_read_t(void *arg)
{
    printf("thread read one try to get lock\n");

    pthread_rwlock_rdlock(&rwlock);
    while(strncmp("end",work_area,3) != 0){
        printf("this is thread read two\n");
        printf("the characters is %s\n",work_area);
        pthread_rwlock_unlock(&rwlock);
        sleep(5);
        pthread_rwlock_rdlock(&rwlock);
        while(work_area[0] == '\0'){
             pthread_rwlock_unlock(&rwlock);
             sleep(5);
             pthread_rwlock_rdlock(&rwlock);
        }
    }
    pthread_rwlock_unlock(&rwlock);
    time_to_exit = 1;
    pthread_exit(0);
}
void *thread_to_write_o(void *arg)
{
    printf("this is write thread one try to get lock\n");
    while(!time_to_exit){
           pthread_rwlock_wrlock(&rwlock);
           printf("this is write thread one\n,input some text,enter 'end'  to finish\n");
           fgets(work_area,WORK_SIZE,stdin);
           pthread_rwlock_unlock(&rwlock);
           sleep(15); // forget sleep,so write always
    }

    pthread_rwlock_unlock(&rwlock);
    pthread_exit(0);
}
void *thread_to_write_t(void *arg)
{
    sleep(10);
    while(!time_to_exit){
       pthread_rwlock_wrlock(&rwlock);
       printf("this is write thread two\n input some text,enter 'end' to finish\n");
       fgets(work_area,WORK_SIZE,stdin);
       pthread_rwlock_unlock(&rwlock);
       sleep(20);
    }
    pthread_rwlock_unlock(&rwlock);
    pthread_exit(0);
}




int main(int argc,char *argv[])
{
    int retval;
    pthread_t a_thread,b_thread,c_thread,d_thread;
    void *thread_result;

    retval = pthread_rwlock_init(&rwlock,NULL);
    if(retval != 0){
          //  error
          exit(1);
    }

    retval = pthread_create(&a_thread,NULL,thread_to_read_o,NULL);
    if(retval != 0){
          //  error
          exit(1);
    }

    retval = pthread_create(&b_thread,NULL,thread_to_read_t,NULL);
    if(retval != 0){
          //  error
          exit(1);
    }

    retval = pthread_create(&c_thread,NULL,thread_to_write_o,NULL);
    if(retval != 0){
          //  error
          exit(1);
    }
    retval = pthread_create(&d_thread,NULL,thread_to_write_t,NULL);
    if(retval != 0){
          //  error
          exit(1);
    }

    // suspend main thread
    pthread_join(a_thread,NULL);

    pthread_join(b_thread,NULL);

    pthread_join(c_thread,NULL);

    pthread_join(d_thread,NULL);


    // destroy rwlock
    pthread_rwlock_destroy(&rwlock);

    printf("main thread will exit\n");

    return 0;
}

  

关于读写锁的第二个程序，主要是测试读锁和写锁哪个更加优先的问题，linux默认的是读者优先

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

pthread_rwlock_t rwlock;

void *readers(void *arg)
{
    pthread_rwlock_rdlock(&rwlock);
    printf("readers %d got the lock\n",(int)arg);
    pthread_rwlock_unlock(&rwlock);
}

void *writes(void *arg)
{
    pthread_rwlock_wrlock(&rwlock);
    printf("write %d got the lock\n",(int)arg);
    pthread_rwlock_unlock(&rwlock);
}

int main(int argc,char *argv[])
{
    int retval,i;
    pthread_t writer_id,reader_id;
    pthread_attr_t attr;
    int nreadercount = 1;
    int nwritercount = 1;

    if(argc != 2){
         // error
         exit(1);
    }

    retval = pthread_rwlock_init(&rwlock,NULL);
    if(retval != 0){
        //error
        exit(2);
    }

    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);


 //   pthread_rwlock_wrlock(&rwlock);
    pthread_rwlock_rdlock(&rwlock);
    for(i = 0; i < atoi(argv[1]);i++){
       if(random() % 2){
            pthread_create(&reader_id,&attr,readers,(void *)nreadercount);
            printf("create reader %d\n",nreadercount++);
       }else{
            pthread_create(&writer_id,&attr,writes,(void *)nwritercount);
            printf("create writer %d\n",nwritercount++);
       }
    }

  //  sleep(10);
    pthread_rwlock_unlock(&rwlock);
    sleep(10);
    return 0;
}

在上面的程序中如果有这个pthread_rwlock_wrlock(&rwlock);那么就算读者先加锁了，这时写者来了，那么再来的读者就不能加锁了，写者一直等到第一个读者结束后自己在加锁。理论是这样的，但是实际的结果，确实有点偏差，先看图

第6个读者先得到了锁，我感觉这个里面做了优化，前9个因为加锁的缘故只能先创建完之后再执行线程，最后一个readers 6，内核已经知道迟早readers 6要执行的，既然内核现在拿着这个reader 6，内核就顺便执行，才不管你有么有pthread_rwlock_wrlock(&rwlock)；

在上面的程序中如果有这个pthread_rwlock_rdlock(&rwlock)，运行结果

如果有什么问题，欢迎指正