linux怎么把文件同时进行读写锁

读写锁与互斥量类似，不过读写锁的并行性更高。

读写锁可以有三种状态：（1）读模式加锁；（2）写模式加锁；（3）不加锁。

在写加锁状态时，在解锁之前，所有试图对这个锁加锁的线程都会被阻塞。在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权限。但是如果线程希望以写模式加锁，它必须阻塞，直至所有的线程释放读锁。

读写锁很适合于对数据结构读的次数远大于写的情况。

相关函数：

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr)

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock) // 成功则返回0，失败则返回错误代码

int pthread_rwlock_rdlock(pthread_rwlock_t *restrict rwlock) //读模式加锁

int pthread_rwlock_wrlock(pthread_rwlock_t *restrict rwlock)//写模式加锁

int pthread_rwlock_unlock(pthread_rwlock_t *restrick rwlock)

int pthread_rwlock_tryrdlock(pthread_rwlock_t *restrict rwlock)

int pthread_rwlock_trywrlock(pthread_rwlock_t *restrict rwlock)

int pthread_rwlock_trywrlock(pthread_rwlock_t *restrict rwlock)

相关示例：读者写者问题，这也是一个很经典的多线程题目，题目大意：有一个写者多个读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读取文件，同样有读者读文件时

#include <stdio.h>

#include <pthread.h>

#define Read_Num 2

pthread_rwlock_t lock

class Data

{

public:

Data(int i, float f): I(i),F(f)

{}

private:

int I

float F

}

Data *pdata = NULL

void *read(void * arg)

{

int id = (int)arg

while(true)

{

pthread_rwlock_rdlock(&lock)

printf(" reader %d is reading data!\n", id)

if(data == NULL)

{

printf("data is NULL\n")

}

else

{

printf("data: I = %d, F = %f \n", pdata->I, pdata->F)

}

pthread_rwlock_unlock(&lock)

}

pthread_exit(0)

}

void *write()

{

while(true)

{

pthread_rwlock_wrlock(&lock)

printf(" writer is writind data!\n")

if(pdata == NULL)

{

pdata = new Data(1, 1.1)

printf("Writer is writing data: %d, %f\n", pdata->I, pdata->F)

}

else

{

delete pdata

pdata = NULL

printf("writer free the data!")

}

pthread_rwlock_unlock(&lock)

}

pthread_exit(0)

}

void main()

{

pthread_t reader[Read_Num]

pthread_t writer

for(int i = 0i<Read_Numi++)

{

pthread_create(&read[i],NULL,read,(void *)i)

}

pthread_create(writer, NULL, write, NULL)

sleep(1)

return 0

}

为了能够有效的控制多个进程之间的沟通过程，保证沟通过程的有序和和谐，OS必须提供一定的同步机制保证进程之间不会自说自话而是有效的协同工作。比如在 共享内存的通信方式中，两个或者多个进程都要对共享的内存进行数据写入，那么怎么才能保证一个进程在写入的过程中不被其它的进程打断，保证数据的完整性 呢？又怎么保证读取进程在读取数据的过程中数据不会变动，保证读取出的数据是完整有效的呢？

常用的同步方式有： 互斥锁、条件变量、读写锁、记录锁(文件锁)和信号灯.

互斥锁：

顾名思义，锁是用来锁住某种东西的，锁住之后只有有钥匙的人才能对锁住的东西拥有控制权(把锁砸了，把东西偷走的小偷不在我们的讨论范围了)。所谓互斥， 从字面上理解就是互相排斥。因此互斥锁从字面上理解就是一点进程拥有了这个锁，它将排斥其它所有的进程访问被锁住的东西，其它的进程如果需要锁就只能等待，等待拥有锁的进程把锁打开后才能继续运行。 在实现中，锁并不是与某个具体的变量进行关联，它本身是一个独立的对象。进(线)程在有需要的时候获得此对象，用完不需要时就释放掉。

互斥锁的主要特点是互斥锁的释放必须由上锁的进(线)程释放，如果拥有锁的进(线)程不释放，那么其它的进(线)程永远也没有机会获得所需要的互斥锁。

互斥锁主要用于线程之间的同步。

条件变量：

上文中提到，对于互斥锁而言，如果拥有锁的进(线)程不释放锁，其它进(线)程永远没机会获得锁，也就永远没有机会继续执行后续的逻辑。在实际环境下，一 个线程A需要改变一个共享变量X的值，为了保证在修改的过程中X不会被其它的线程修改，线程A必须首先获得对X的锁。现在假如A已经获得锁了，由于业务逻 辑的需要，只有当X的值小于0时，线程A才能执行后续的逻辑，于是线程A必须把互斥锁释放掉，然后继续“忙等”。如下面的伪代码所示：

1.// get x lock

2.while(x

信号量与互斥锁之间的区别：

1. 互斥量用于线程的互斥，信号量用于线程的同步。

这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。

互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。

同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源

2. 互斥量值只能为0/1，信号量值可以为非负整数。

也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。

3. 互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。

---