linuxc读写锁

A. linux C 缓冲文件和非缓冲文件读写方式用法

1.用write, read, open等系统调用编写分别实现如下功能的程序（要求进行必要的出错检查）：
(1)创建一个文件testfile.txt，文件内容从键盘输入;
(2)将testfile.txt的内容显示在屏幕上,并将testfile.txt的内容复制到一个新的文件file2.txt中。
实验代码：
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
int main()

B. 在linux中用C语言实现死锁

让我来告诉你答案!设置状态变量lock=0，在占用资源的函数中，设置lock=1；并在处理结束后设lock=0.
比如：
boollock=0;
intscan()
{
while(lock!=0);//循环检测，直到资源释放才执行下面的语句
lock=1;//锁定资源
...//具体的执行扫描的语句
lock=1;//释放资源
return0;
}
这个方法容易实现，但是占用CPU,假定其他线程正在占用扫描仪，那么这个线程就会在自己的时间片内不停的执行while语句直到对方释放扫描仪。由此造成了浪费。
现在流行的做法是通过中断信号来做，那是一本书的内容，建议看linux内核编程方面的书。

C. 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 = 0;i<Read_Num;i++)
{
pthread_create(&read[i],NULL,read,(void *)i);
}

pthread_create(writer, NULL, write, NULL);

sleep(1);
return 0;
}

D. linux有没有进程间的读写锁

所谓进程间的读写锁，就必须需要你自己编写程序，来实现不同进程间的同步与互斥关系，即：P、V 操作，以达到锁定的目的。

E. Linux的C文件以只读模式打开，怎样修改成可读可写呀

你好！
#chmod
777
C文件名
第一个7
文件属主有读,写,执行权限,
第二个7
文件属组有读,写,执行权限,
第三个7
其它用户有读,写,执行权限.
如有疑问，请追问。

F. linux 互斥锁和读写锁的区别与联系

信号量与互斥锁之间的区别：
1. 互斥量用于线程的互斥，信号量用于线程的同步。
这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。
互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源
2. 互斥量值只能为0/1，信号量值可以为非负整数。
也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。
3. 互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。

G. Linux高级程序设计的目录

第1章Linux下C语言开发环境
1.1Linux操作系统概述
1.2Linux开发初步
1.3Linux内核及库文件管理
1.4Linux下编码风格
第2章Linux下C语言开发工具
2.1Linux开发的基本工具
2.2GCC/G++编译器
2.3make工具及makefile文件
2.4GDB调试工具
2.5GCC程序开发过程实例
2.6自动编译调试工具
第3章内存管理及相关工具
3.1内存管理基本概念
3.2内存管理函数
3.3常用Linux内存管理及调试工具
第4章ANSIC文件管理
4.1文件基本概念及文件指针
4.2ANSIC标准文件I/O操作
第5章POSIX标准文件I/O管理
5.1Linux系统下文件类型及属性
5.2POSIX标准下文件I/O管理
第6章Linux文件管理及目录操作
6.1Linux文件系统管理
6.2Linux文件及目录管理操作
第7章Linux进程管理与程序开发
7.1进程环境及进程属性
7.2Linux进程控制
7.3Linux进程调度
第8章进程间通信——管道和信号
8.1进程通信——无名管道
8.2进程通信——有名管道FIFO
8.3信号中断处理
第9章SystemV进程间通信
9.1SystemVIPC基础
9.2消息队列
9.3信号量通信机制
9.4共享内存
第10章Linux多线程编程
10.1Linux线程概述
10.2Linux线程基本操作
10.3线程属性控制
10.4线程调度
第11章线程间通信机制
11.1互斥锁通信机制
11.2条件变量通信机制
11.3读写锁通信机制
11.4线程信号量
11.5线程信号
第12章LinuxSocket网络编程
12.1网络通信基础
12.2Socket通信基本概念及过程
12.3面向连接的TCP套接字编程实例
12.4面向无连接的UDP套接字编程实例
12.5其他SocketAPI应用编程
附录AGCC参数说明
附录Bgdb命令手册
附录Cvim参考手册
附录DEmacs编辑器
附录ECVS服务器配置

H. unix c中文件读写锁的问题。

其实读写锁和读写操作本身没有联系。他们是相互独立的。
锁的作用就是让一个线程判断当前文件有没有另一个线程正在操作。
a线程给文件加上写锁，对于其他线程并不代表它不可写。它只是告诉其他线程，有线程正在操作这个文件等我解锁了你们再操作。如果有人不检查锁的状态，直接open 和 write操作依旧可以成功，只不过两个线程同时写入数据，文件数据就被破坏了。
所以在open 和 write之前要对文件加写锁，如果有其他线程正在操作文件，加锁过程会被阻塞，直到文件解锁。

在所有线程中必须在执行文件操作给文件加锁以等待锁的状态。

I. 关于linux C的文件读写

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX 1024

void lower1(char *p)
{
int i,len;
len = strlen(p);
for(i=0;i<len;i++)
if(p[i] >= 'A' && p[i] <= 'Z')
p[i] += 32;
}

int main(void)
{
FILE *fp,*fpw;
char *p;
char buf[MAX],buf1[MAX]="GAME OVER";
int n,m;
fp = fopen("txt","rw");
if(fp == NULL)
{
perror("Fail to open");
exit(1);
}

while((n = fread(buf,sizeof(char),MAX-1,fp)) > 0)
{
buf[n]='\0';
lower1(buf);
printf("%s",buf);
printf("%d",n);
}
rewind(fp);
while((n = fread(buf,sizeof(char),MAX-1,fp)) > 0) //你这里什么意思？你这里有问题
{
fputs(buf,fp);
}

if(n < 0){
perror("Fail to read");
exit(1);
}

fclose(fp);
return 0;
}

顺便，看样子你也知道，读写无法同时进行的，所以，你读万，一定要rewind一下