当前位置：移动技术网 > IT编程>开发语言>C/C++ > Linux 读写锁

Linux 读写锁

2019年06月21日 | 移动技术网IT编程 | 我要评论

疑中科院昆明某研究所人员宾馆约炮,空间留言板留言,任仲平

线程的读写锁函数：

1，读写锁的初始化与销毁，静态初始化的话，可以直接使用pthread_rwlock_initializer。

#include <pthread.h>
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
           const pthread_rwlockattr_t *restrict attr);
pthread_rwlock_t rwlock = pthread_rwlock_initializer;

2，用读的方式加锁和尝试（没锁上就立即返回）加锁。

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

3，用写的方式加锁和尝试（没锁上就立即返回）加锁。

#include <pthread.h>
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

4，解锁

#include <pthread.h>
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

多个进程在同时读写同一个文件，会发生什么？

例子1：用下面的例子的执行结果，观察多个进程在同时读写同一个文件，会发生什么。

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

#define maxline 100
#define fn "num1"

void my_lock(int fd){
  return;
}

void my_unlock(int fd){
  return;
}

int main(int args, char** argv){

  int fd;
  long i,seqno;
  pid_t pid;
  ssize_t n;
  char line[maxline + 1];

  pid = getpid();
  fd = open(fn, o_rdwr, 0664);

  for(i = 0; i < 20; ++i){
    my_lock(fd);

    lseek(fd, 0l, seek_set);
    n = read(fd, line, maxline);
    line[n] = '\0';

    seqno = atol(line);
    printf("%s:pid = %ld, seq = %ld\n", argv[0], (long)pid, seqno);

    seqno++;

    snprintf(line, sizeof(line), "%ld\n", seqno);

    lseek(fd, 0l, seek_set);
    write(fd, line, strlen(line));

    my_unlock(fd);
  }

  return 0;
}

执行方法：同时执行上面例子的程序2次，也就是2个进程同时读写同一个文件。

ubuntu$ ./flockmain1 & ./flockmain1 &

执行结果如下，发现2个进程同时读写，在①处开始，内核切换进程时，数字乱套了。

ubuntu$ ./flockmain1 & ./flockmain1 &
[1] 4760
[2] 4761
ubuntu$ ./flockmain1:pid = 4761, seq = 1
./flockmain1:pid = 4761, seq = 2
./flockmain1:pid = 4761, seq = 3
./flockmain1:pid = 4761, seq = 4
./flockmain1:pid = 4761, seq = 5
./flockmain1:pid = 4761, seq = 6
./flockmain1:pid = 4761, seq = 7
./flockmain1:pid = 4761, seq = 8
./flockmain1:pid = 4761, seq = 9
./flockmain1:pid = 4761, seq = 10   ------------①
./flockmain1:pid = 4760, seq = 10
./flockmain1:pid = 4761, seq = 11
./flockmain1:pid = 4761, seq = 12
./flockmain1:pid = 4761, seq = 13
./flockmain1:pid = 4761, seq = 14
./flockmain1:pid = 4761, seq = 15
./flockmain1:pid = 4761, seq = 16
./flockmain1:pid = 4761, seq = 17
./flockmain1:pid = 4761, seq = 18
./flockmain1:pid = 4761, seq = 19
./flockmain1:pid = 4761, seq = 20
./flockmain1:pid = 4760, seq = 11
./flockmain1:pid = 4760, seq = 12
./flockmain1:pid = 4760, seq = 13
./flockmain1:pid = 4760, seq = 14
./flockmain1:pid = 4760, seq = 15
./flockmain1:pid = 4760, seq = 16
./flockmain1:pid = 4760, seq = 17
./flockmain1:pid = 4760, seq = 18
./flockmain1:pid = 4760, seq = 19
./flockmain1:pid = 4760, seq = 20
./flockmain1:pid = 4760, seq = 21
./flockmain1:pid = 4760, seq = 22
./flockmain1:pid = 4760, seq = 23
./flockmain1:pid = 4760, seq = 24
./flockmain1:pid = 4760, seq = 25
./flockmain1:pid = 4760, seq = 26
./flockmain1:pid = 4760, seq = 27
./flockmain1:pid = 4760, seq = 28
./flockmain1:pid = 4760, seq = 29

为了解决上面的问题，必须对文件的内容进行加锁。

如何对文件内容加锁？

使用fcntl函数，它既可以锁整文件，也可以锁文件里的某段内容。通过结构体flock来指定要锁的范围。如果 whence = seek_set;l_start = 0;l_len = 0;就是锁定整个文件。

struct flock {
               ...
               short l_type;    /* type of lock: f_rdlck,
                                   f_wrlck, f_unlck */
               short l_whence;  /* how to interpret l_start:
                                   seek_set, seek_cur, seek_end */
               off_t l_start;   /* starting offset for lock */
               off_t l_len;     /* number of bytes to lock */
               pid_t l_pid;     /* pid of process blocking our lock
                                   (set by f_getlk and f_ofd_getlk) */
               ...
           };

f_setlk：上锁。如果发现已经被别的进程上锁了，就直接返回-1，errno被设置成eacces或者eagain，不阻塞。
f_setlkw：上锁。阻塞等待。
f_getlk：得到锁的状态。

修改上面的函数my_lock，my_unlock。main函数不变。

例子2：

void my_lock(int fd){
  struct flock lock;
  lock.l_type = f_wrlck;
  wlock.l_whence = seek_set;
  lock.l_start = 0;
  lock.l_len = 0;
  
  fcntl(fd, f_setlkw, lock);
}

void my_unlock(int fd){
  struct flock lock;
  lock.l_type = f_unlck;
  lock.l_whence = seek_set;
  lock.l_start = 0;
  lock.l_len = 0;

  fcntl(fd, f_setlk, lock);
}

执行结果如下，发现数字不乱套了。

ubuntu$ ./flockmain & ./flockmain &
[1] 4882
[2] 4883
ubuntu$ ./flockmain:pid = 4883, seq = 1
./flockmain:pid = 4883, seq = 2
./flockmain:pid = 4883, seq = 3
./flockmain:pid = 4883, seq = 4
./flockmain:pid = 4883, seq = 5
./flockmain:pid = 4883, seq = 6
./flockmain:pid = 4883, seq = 7
./flockmain:pid = 4883, seq = 8
./flockmain:pid = 4883, seq = 9
./flockmain:pid = 4883, seq = 10
./flockmain:pid = 4883, seq = 11
./flockmain:pid = 4883, seq = 12
./flockmain:pid = 4883, seq = 13
./flockmain:pid = 4883, seq = 14
./flockmain:pid = 4883, seq = 15
./flockmain:pid = 4883, seq = 16
./flockmain:pid = 4883, seq = 17
./flockmain:pid = 4883, seq = 18
./flockmain:pid = 4883, seq = 19
./flockmain:pid = 4883, seq = 20
./flockmain:pid = 4882, seq = 21
./flockmain:pid = 4882, seq = 22
./flockmain:pid = 4882, seq = 23
./flockmain:pid = 4882, seq = 24
./flockmain:pid = 4882, seq = 25
./flockmain:pid = 4882, seq = 26
./flockmain:pid = 4882, seq = 27
./flockmain:pid = 4882, seq = 28
./flockmain:pid = 4882, seq = 29
./flockmain:pid = 4882, seq = 30
./flockmain:pid = 4882, seq = 31
./flockmain:pid = 4882, seq = 32
./flockmain:pid = 4882, seq = 33
./flockmain:pid = 4882, seq = 34
./flockmain:pid = 4882, seq = 35
./flockmain:pid = 4882, seq = 36
./flockmain:pid = 4882, seq = 37
./flockmain:pid = 4882, seq = 38
./flockmain:pid = 4882, seq = 39
./flockmain:pid = 4882, seq = 40

到此为止，貌似解决了问题，但是如果同时执行例子1和例子2，结果如下，发现还是乱的。

也就是说在协作线程（cooperating processes）间，文件锁（也叫劝告性上锁）也起作用的。但是不完全不相关的进程中，文件锁也不起作用的。如何解决呢？使用强制性上锁。

ys@ys-virtualbox:~/ipc$ ./flockmain1 & ./flockmain &
[1] 3602
[2] 3603
ys@ys-virtualbox:~/ipc$ ./flockmain1:pid = 3602, seq = 1
./flockmain:pid = 3603, seq = 1
./flockmain:pid = 3603, seq = 2
./flockmain:pid = 3603, seq = 3
./flockmain:pid = 3603, seq = 4
./flockmain:pid = 3603, seq = 5
./flockmain:pid = 3603, seq = 6
./flockmain:pid = 3603, seq = 7
./flockmain:pid = 3603, seq = 8
./flockmain:pid = 3603, seq = 9
./flockmain:pid = 3603, seq = 10
./flockmain1:pid = 3602, seq = 2
./flockmain1:pid = 3602, seq = 3
./flockmain1:pid = 3602, seq = 4
./flockmain:pid = 3603, seq = 11
./flockmain:pid = 3603, seq = 12
./flockmain1:pid = 3602, seq = 5
./flockmain:pid = 3603, seq = 13
./flockmain1:pid = 3602, seq = 6
./flockmain1:pid = 3602, seq = 7
./flockmain1:pid = 3602, seq = 8
./flockmain:pid = 3603, seq = 14
./flockmain:pid = 3603, seq = 15
./flockmain1:pid = 3602, seq = 9
./flockmain1:pid = 3602, seq = 10
./flockmain:pid = 3603, seq = 16
./flockmain:pid = 3603, seq = 17
./flockmain1:pid = 3602, seq = 11
./flockmain:pid = 3603, seq = 18
./flockmain1:pid = 3602, seq = 12
./flockmain1:pid = 3602, seq = 13
./flockmain1:pid = 3602, seq = 14
./flockmain:pid = 3603, seq = 19
./flockmain:pid = 3603, seq = 20
./flockmain1:pid = 3602, seq = 15
./flockmain1:pid = 3602, seq = 16
./flockmain1:pid = 3602, seq = 17
./flockmain1:pid = 3602, seq = 18
./flockmain1:pid = 3602, seq = 19
./flockmain1:pid = 3602, seq = 20

第一个问题：假如一个文件被一个进程以读的方式锁定，并有另一个进程在等待读锁定解锁后，用写入的方式锁定，这时是否允许另一个进程的还以读的方式取得锁定？

用例子3来观察：

#include <time.h>
#include <sys/time.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

void gftime(char* buf){
  struct timeval tv;
  gettimeofday(&tv, null);
  long usec = tv.tv_usec;
  struct tm* tm = localtime(&tv.tv_sec);
  sprintf(buf, "%d:%d:%d.%ld",tm->tm_hour, tm->tm_min, tm->tm_sec,usec);

}

int main(){
  char buff[100] = {0};
 
  int fd = open("test.dat", o_rdwr | o_creat, 0664);

  struct flock lock;
  
  lock.l_type = f_rdlck;
  lock.l_whence = seek_set;
  lock.l_start = 0;
  lock.l_len = 0;
  fcntl(fd, f_setlk, &lock);

  gftime(buff);
  printf("%s: parent has read lock\n", buff);

  //first child
  if(fork() == 0){

    char buf2[100] = {0};
    sleep(1);
    gftime(buf2);
    printf("%s: first child tries to obtain write lock\n", buf2);

    struct flock lock2;
    lock2.l_type = f_wrlck;
    lock2.l_whence = seek_set;
    lock2.l_start = 0;
    lock2.l_len = 0;
    fcntl(fd, f_setlkw, &lock2);

    gftime(buf2);
    printf("%s: first child obtains write lock\n", buf2);

    sleep(2);

    lock2.l_type = f_unlck;
    lock2.l_whence = seek_set;
    lock2.l_start = 0;
    lock2.l_len = 0;
    fcntl(fd, f_setlk, &lock2);

    gftime(buf2);
    printf("%s: first child releases write lock\n", buf2);
    
    exit(0);
  }
  //secodn child
  if(fork() == 0){
    char buf1[100] = {0};
    sleep(3);
    gftime(buf1);
    printf("%s: second child tries to obtain read lock\n", buf1);

    struct flock lock1;
    lock1.l_type = f_rdlck;
    lock1.l_whence = seek_set;
    lock1.l_start = 0;
    lock1.l_len = 0;
    fcntl(fd, f_setlkw, &lock1);

    gftime(buf1);
    printf("%s: second child obtains read lock\n", buf1);

    sleep(4);

    lock1.l_type = f_unlck;
    lock1.l_whence = seek_set;
    lock1.l_start = 0;
    lock1.l_len = 0;
    fcntl(fd, f_setlk, &lock1);

    gftime(buf1);
    printf("%s: second child release read lock\n", buf1);
    
    exit(0);
  }

  //parent process
  sleep(5);

  lock.l_type = f_unlck;
  lock.l_whence = seek_set;
  lock.l_start = 0;
  lock.l_len = 0;
  fcntl(fd, f_setlk, &lock);

  gftime(buff);
  printf("%s: parent releases read lock\n", buff);
  
  wait(null);
  wait(null);

  exit(0);
}

在ubuntu上执行结果：

17:49:44.348946: parent has read lock
17:49:45.350191: first child tries to obtain write lock
17:49:47.350155: second child tries to obtain read lock
17:49:47.350409: second child obtains read lock
17:49:49.349442: parent releases read lock
17:49:51.351197: second child release read lock
17:49:51.351582: first child obtains write lock
17:49:53.351689: first child releases write lock

第一个问题的答案：允许另一个进程的还以读的方式取得锁定

第二个问题：假如一个文件被一个进程以写的方式锁定，这时又有2个进程在等待这个锁的释放，其中一个进程是以写锁的方式等待，其中另一个进程是以读锁的方式等待，哪一个会优先取得锁？

用例子4来观察：

#include <time.h>
#include <sys/time.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

void gftime(char* buf){
  struct timeval tv;
  gettimeofday(&tv, null);
  long usec = tv.tv_usec;
  struct tm* tm = localtime(&tv.tv_sec);
  sprintf(buf, "%d:%d:%d.%ld",tm->tm_hour, tm->tm_min, tm->tm_sec,usec);

}

int main(){
  char buff[100] = {0};
 
  int fd = open("test.dat", o_rdwr | o_creat, 0664);

  struct flock lock;
  
  lock.l_type = f_wrlck;
  lock.l_whence = seek_set;
  lock.l_start = 0;
  lock.l_len = 0;
  fcntl(fd, f_setlk, &lock);

  gftime(buff);
  printf("%s: parent has write lock\n", buff);

  //first child
  if(fork() == 0){

    char buf2[100] = {0};
    sleep(1);
    gftime(buf2);
    printf("%s: first child tries to obtain write lock\n", buf2);

    struct flock lock2;
    lock2.l_type = f_wrlck;
    lock2.l_whence = seek_set;
    lock2.l_start = 0;
    lock2.l_len = 0;
    fcntl(fd, f_setlkw, &lock2);

    gftime(buf2);
    printf("%s: first child obtains write lock\n", buf2);

    sleep(2);

    lock2.l_type = f_unlck;
    lock2.l_whence = seek_set;
    lock2.l_start = 0;
    lock2.l_len = 0;
    fcntl(fd, f_setlk, &lock2);

    gftime(buf2);
    printf("%s: first child releases write lock\n", buf2);
    
    exit(0);
  }
  //secodn child
  if(fork() == 0){
    char buf1[100] = {0};
    sleep(3);
    gftime(buf1);
    printf("%s: second child tries to obtain read lock\n", buf1);

    struct flock lock1;
    lock1.l_type = f_rdlck;
    lock1.l_whence = seek_set;
    lock1.l_start = 0;
    lock1.l_len = 0;
    fcntl(fd, f_setlkw, &lock1);

    gftime(buf1);
    printf("%s: second child obtains read lock\n", buf1);

    sleep(4);

    lock1.l_type = f_unlck;
    lock1.l_whence = seek_set;
    lock1.l_start = 0;
    lock1.l_len = 0;
    fcntl(fd, f_setlk, &lock1);

    gftime(buf1);
    printf("%s: second child release read lock\n", buf1);
    
    exit(0);
  }

  //parent process
  sleep(5);

  lock.l_type = f_unlck;
  lock.l_whence = seek_set;
  lock.l_start = 0;
  lock.l_len = 0;
  fcntl(fd, f_setlk, &lock);

  gftime(buff);
  printf("%s: parent releases write lock\n", buff);
  
  wait(null);
  wait(null);

  exit(0);
}

在ubuntu上执行结果：

17:49:29.796599: parent has write lock
17:49:30.797099: first child tries to obtain write lock
17:49:32.796885: second child tries to obtain read lock
17:49:34.796868: parent releases write lock
17:49:34.796987: second child obtains read lock
17:49:38.797148: second child release read lock
17:49:38.797297: first child obtains write lock
17:49:40.797727: first child releases write lock

第二个问题的答案：没有准确答案。在ubuntu上的执行结果上看，读锁优先了，但是，可能在别的环境上又是写锁优先。按道理来说应该写锁优先吧？

c/c++ 学习互助qq群：877684253

本人微信：xiaoshitou5854

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！点击进行留言回复

C++ 作用域

作用域：名称在翻译单元（包括文件）的可见范围局部：只在定义它的代码块中可用，如自动变量全局（文件作用域）：从定义位置到文件结尾都可用注意：静... [阅读全文]
Prim计算最小生成树权值 C语言

题目描述现在，你被委托在一个广阔区域里面为某些确定的结点设计连接网络。首先，你会给定在区域里面的一系列结点，和连接这些结点的一组线路。对于每条可能使用... [阅读全文]
C打印楼梯，同时在楼梯上方打印两个笑脸

题目：打印楼梯，同时在楼梯上方打印两个笑脸。程序分析：用 ASCII 1 来输出笑脸；用i控制行，j来控制列，j根据i的变化来控制输出黑方格的个数。 ... [阅读全文]
算法笔记刷题6 ( PAT 1003我要通过 )

算法笔记刷题6 ( PAT1003我要通过 ) 题目本体 “ 答案正确 ”是自动判题系统给出的最令人欢喜的回复。本题属于 PAT 的“ 答案正确 ”大派... [阅读全文]
聚合类型与POD类型

Lippman在《深度探索C++对象模型》的前言中写道： I have heard a number of people over the years ... [阅读全文]
GetAsyncKeyState 获取键盘按键消息

1 #include <Windows.h> 2 #include <iostream> 3 using namespace s... [阅读全文]
c primer plus(中文版)第一章的一处错误

c primer plus(中文版)1.8.8 第三段第三段第一句：“UNIX系统内置Mac OS X”。这句话讲不通，UNIX系统内置MAC OS ... [阅读全文]
如何在没有core文件的情况下用dmesg+addr2line定位段错误

前言在现网环境下，程序奔溃后不一定会留下core文件，原因有很多，比如存储空间不足就是其中一个常见的原因。此时我们只能依据linux记录的错误日志来定位... [阅读全文]
用QT制作3D点云显示器——QtDataVisualization

因为QT的三维显示模块QtDataVisualization已经对个人开发免费开放了，所以在制作点云，地图，表格之类的东西的时候，其实我们都不需要使用Q... [阅读全文]
判断一个数是否为素数（质数）

质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。 ... [阅读全文]

网友评论


验证码：