Linux 之互斥锁和读写锁

正文

互斥锁

Linux下的互斥锁是一个pthread_mutex_t类型的结构体。
pthread_mutex_init函数
pthread_mutex_destroy函数
pthread_mutex_lock函数
pthread_mutex_trylock函数
pthread_mutex_unlock函数
以上5个函数的返回值都是：成功返回0，失败返回错误号。

pthread_mutex_init

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
参数：
mutex: 要初始化的互斥锁
attr：锁的属性
对于mutex有两种初始化的方式：
动态初始化：使用 pthread_mutex_init函数惊醒初始化，属性通常传NULL使用默认属性，也可以使用PTHREAD_PROCESS_PRIVATE（线程共享）或PTHREAD_PROCESS_SHARED（进程间共享）来初始化。
静态初始化：对于全局的或static的变量，可以直接使用宏来初始化
pthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER

pthread_mutex_destroy

int pthread_mutex_destroy(pthread_mutex_t *mutex);

pthread_mutex_lock

int pthread_mutex_lock(pthread_mutex_t *mutex);
对一个互斥量上锁，上锁失败阻塞。

pthread_mutex_trylock

int pthread_mutex_trylock(pthread_mutex_t *mutex);
尝试对一个互斥量上锁，上锁失败不阻塞。

pthread_mutex_unlock

int pthread_mutex_unlock(pthread_mutex_t *mutex);
对一个互斥量解锁。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<errno.h>
#include<pthread.h>

pthread_mutex_t mutex;
int a = 0;

void str_error()
{
    
    
  const char * str = strerror(errno);
  write(STDERR_FILENO,str,sizeof(str));
  exit(-1);
}


void *fun(void * arg)
{
    
    
  int n =10000;
  while(n--)
  {
    
    
    pthread_mutex_lock(&mutex);
    printf("thread[%ld] %d\n",pthread_self(),++a);
    pthread_mutex_unlock(&mutex);
  }
  return NULL;
}

int main()
{
    
    

    pthread_mutex_init(&mutex,PTHREAD_PROCESS_PRIVATE);
    pthread_t tid[2];
    for(int i=0;i<2;i++)
    {
    
    
     if( pthread_create(&tid[i],NULL,fun,NULL) != 0)
     {
    
    
       str_error();
     }
    }
    for(int i=0;i<2;i++)
      pthread_join(tid[i],NULL);
    pthread_mutex_destroy(&mutex);

}

读写锁

pthread_rwlock_init函数
pthread_rwlock_destroy函数
pthread_rwlock_rdlock函数
pthread_rwlock_wrlock函数
pthread_rwlock_tryrdlock函数
pthread_rwlock_trywrlock函数
pthread_rwlock_unlock函数
以上7 个函数的返回值都是：成功返回0，失败直接返回错误号。

pthread_rwlock_init

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
初始化方式与互斥锁一样

pthread_rwlock_destroy

同上

pthread_rwlock_rdlock

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
读方式上锁，若是已经被上写锁将上锁失败，成功后上读锁失败，可以继续上写锁。（共享锁）

pthread_rwlock_wrlock

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
上写锁，使用方法与互斥锁一样（独占锁）。

pthread_rwlock_tryrdlock

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);wr
尝试上读锁，失败不阻塞。

pthread_rwlock_trywrlock

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
尝试上写锁，失败不阻塞。

pthread_rwlock_unlock

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
解锁。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<errno.h>
#include<pthread.h>

pthread_rwlock_t mutex;

void str_error()
{
    
    
  const char * str = strerror(errno);
  write(STDERR_FILENO,str,sizeof(str));
  exit(-1);
}

void* rdfun(void *arg)
{
    
    
    pthread_rwlock_rdlock(&mutex);
    while(1)
    {
    
    
        sleep(1);
    }
    pthread_rwlock_unlock(&mutex);
    return NULL;
}
void* rdfun1(void *arg)
{
    
    
    sleep(1);
    pthread_rwlock_rdlock(&mutex);
    printf("rd\n");
    pthread_rwlock_unlock(&mutex);
    return NULL;
}

void* wrfun(void *arg)
{
    
    
    sleep(1);
    pthread_rwlock_wrlock(&mutex);
    printf("wr\n");
    pthread_rwlock_unlock(&mutex);
    return NULL;
}

int main()
{
    
    
    if( pthread_rwlock_init(&mutex,NULL) != 0)
            str_error();
     pthread_t fd1,fd2,fd3;
    if( pthread_create(&fd1,NULL,rdfun,NULL) != 0)
            str_error();
    if( pthread_create(&fd2,NULL,wrfun,NULL) != 0)
            str_error();
    if( pthread_create(&fd3,NULL,rdfun1,NULL) != 0)
            str_error();
     pthread_rwlock_destroy(&mutex);
     pthread_join(fd2,NULL);
}