共享锁linux

A. linux共享锁与排斥锁的作用

共享锁【S锁】又称读锁，若事务T对数据对象A加上S锁，则事务T可以读A但不能修改A，其他事务只能再对A加S锁，而不能加X锁，直到T释放A上的S锁。这保证了其他事务可以读A，但在T释放A上的S锁之前不能对A做任何修改。排他锁【X锁】又称写锁。若事务T对数据对象A加上X锁，事务T可以读A也可以修改A，其他事务不能再对A加任何锁，直到T释放A上的锁。这保证了其他事务在T释放A上的锁之前不能再读取和修改A。

B. 操作系统，linux中 lockf(1,1,0);和 lockf(1,0,0); 是什么作用

ockf(fd,1,0)是给fd文件上锁，lockf(fd,0,0)是解锁，配合使用，实现进程的互斥。

头文件

#include <sys/file.h>

函数:

int lockf(int fd, int cmd, off_t len);

fd -- 文件id.

fcntl(2)的接口(inteface)函数

返回1表示调用lockf成功.

lockf用于锁定或打开锁定一个共享文件.

操作有:

F_LOCK(锁定),F_TLOCK,F_ULOCK(打开锁定),F_TEST

(2)共享锁linux扩展阅读：

注意事项

lockf()函数允许将文件区域用作信号量（监视锁），或用于控制对锁定进程的访问（强制模式记录锁定）。试图访问已锁定资源的其他进程将返回错误或进入休眠状态，直到资源解除锁定为止。当关闭文件时，将释放进程的所有锁定，即使进程仍然有打开的文件。当进程终止时，将释放进程保留的所有锁定。

函数声明：

/* 'lockf' is a simpler interface to the locking facilities of 'fcntl'. LEN is always relative to the current file position. The CMD argument is one of the following. This function is a cancellation point and therefore not marked with __THROW. */

#include <unistd.h>

int lockf(int fd, int cmd, off_t len);

C. linux有没有多进程间的读写锁

Linux共享内存可以不用加锁，不过需要一种机制来标记共享内存的读写状态;也就是说要让两个进程知道:1)负责写入的进程，必须知道当前共享内存是否可以写入，上一次的写入内容是否有被负责读取的进程读走;2)负责读取的进程，必须知道当前共享内存是否需要读取，防止重复读取。一般的这种标记机制是通过以下方式来简单实现:1)通过读写锁来控制;2)共享内存上设置一个地方，专门存放当前共享内存的读写状态;

D. linux pthread 信号量 占用资源吗

glibc提供的pthread互斥信号量可以用在进程内部，也可以用在进程间，可以在初始化时通过pthread_mutexattr_setpshared接口设置该信号量属性，表示是进程内还是进程间。进程内的使用较为简单，本文的总结主要是针对进程间的，进程内的也可以参考，其代码实现原理是类似的。
一、实现原理
pthread mutex的实现是非常轻量级的，采用原子操作+futex系统调用。
在没有竞争的情况下，即锁空闲时，任务获取信号量只需要通过原子操作锁的状态值，把值置为占有，再记录其他一些俄信息（owner，计数，如果使能回收功能则串入任务的信号量回收链表等），然后就返回了。
如果在获取锁时发现被占用了，如果调用者需要睡眠等待，这时候会触发futex系统调用，由内核继续处理，内核会让调用任务睡眠，并在适当时候唤醒（超时或者锁状态为可用）。
占用锁的任务释放锁时，如果没有任务等待这把锁，只需要把锁状态置为空闲即可。如果发现有其他任务在等待此锁，则触发futex系统调用，由内核唤醒等待任务。
由此可见，在没有竞争的情况下，mutex只需要在用户态操作锁状态值，无须陷入内核，是非常高效的。
获取到锁的任务没有陷入内核，那么当锁支持优先级翻转时，高优先级任务等待这把锁，正常处理必须提升占用锁的任务优先级。内核又是怎么知道是哪个任务占用了锁呢？实现上，复用了锁的状态值，该值在空闲态时为0，非空闲态则保存了锁的持有者ID，即PID,内核态通过PID就知道是那个任务了。
二、内核对锁的管理
内核维护了一个hash链表，每把锁都被插入到hash链表中去，hash值的计算如下（参考get_futex_key)：1，如果是进程内的锁，则通
过锁的虚拟地址+任务mm指针值+锁在页内偏移；2，如果是进程间的锁，则会获取锁虚拟地址对应物理地址的page描述符，由page描述符构造
hash值。
这样计算的原因是进程间的锁在各个进程内虚拟地址可能是不同的，但都映射到同一个物理地址，对应同一个page描述符。所以，内
核使用它来定位是否同一个锁。
这里对进程间互斥锁计算hash值的方法，给进程间共享锁的使用设置了一个隐患条件。下面描述这个问题。

三、进程间互斥信号量的使用限制：必须在系统管理的内存上定义mutex结构，而不能在用户reserved的共享内存上定义mutex结构。
锁要实现进程间互斥，必须各个进程都能看到这个锁，因此，锁结构必须放在共享内存上。
获取系统的共享内存通过System V的API接口创建：shmget, shmat,shmdt。但是shmget的参数需要一个id值，各进程映射同一块共享内存需要同样的ID值。如果各个进程需要共享的共享内存比较多，如几千上万个，ID值如果管理？shmget的man帮助和一些示例代码给出的是通过ftok函数把一个文件转为ID值（实际就是把文件对应的INODE转为ID值），但实际应用中，如果需要的共享内存个数较多，难道创建成千上万个文件来使用？而且怎么保证文件在进程的生命周期内不会被删除或者重建？
当时开发的系统还存在另外一种共享内存，就是我们通过remap_pfn_range实现的，自己管理了这块内存的申请释放。申请接口参数为字符串，相同的字符串表示同一块内存。因此，倾向于使用自己管理的共享内存存放mutex结构。但在使用中，发现这种方法达不到互斥的效果。为什么？
原因是自己管理的共享内存在内核是通过remap_pfn_range实现的，内核会把这块内存置为reserved，表示非内核管理，获取锁的HASH值时，查找不到page结构，返回失败了。最后的解决方法还是通过shmget申请共享内存，但不是通过ftok获取ID，而是通过字符串转为ID值并处理冲突。

四、进程间互斥信号量回收问题。
假设进程P1获取了进程间信号量，异常退出了，还没有释放信号量，这时候其他进程想来获取信号量，能获取的到吗？
或者进程P1获取了信号量后，其他进程获取不到进入了睡眠后，P1异常退出了，谁来负责唤醒睡眠的进程？
好在系统设计上已经考虑了这一点。
只要在信号量初始化时调用pthread_mutexattr_setrobust_np设置支持信号量回收机制，然后，在获取信号量时，如果原来占有信号量的进程退出了，系统将会返回EOWNERDEAD，判断是这个返回值后，调用pthread_mutex_consistent_np完成信号量owner的切换工作即可。
其原理如下：
任务创建时，会注册一个robust list（用户态链表）到内核的任务控制块TCB中期，获取了信号量时，会把信号量挂入链表。进程复位时，内核会遍历此链表（内核必须非常小心，因为此时的链表信息可能不可靠了，可不能影响到内核），置上ownerdead的标志到锁状态，并唤醒等待在此信号量链表上的进程。
五、pthread接口使用说明
pthread_mutex_init: 根据指定的属性初始化一个mutex，状态为空闲。
pthread_mutex_destroy: 删除一个mutex
pthread_mutex_lock/trylock/timedlock/unlock: 获取锁、释放锁。没有竞争关系的情况下在用户态只需要置下锁的状态值即返回了，无须陷入内核。但是timedlock的入参为超时时间，一般需要调用系统API获取，会导致陷入内核，性能较差，实现上，可先trylock，失败了再timedlock。
pthread_mutexattr_init:配置初始化
pthread_mutexattr_destroy:删除配置初始化接口申请的资源
pthread_mutexattr_setpshared:设置mutex是否进程间共享
pthread_mutexattr_settype:设置类型，如递归调用，错误检测等。
pthread_mutexattr_setprotocol:设置是否支持优先级翻转
pthread_mutexattr_setprioceiling:设置获取信号量的任务运行在最高优先级。
每个set接口都有对应的get接口。

六、pthread结构变量说明

struct __pthread_mutex_s
{
int __lock; ----31bit:这个锁是否有等待者；30bit：这个锁的owner是否已经挂掉了。其他bit位：0锁状态空闲，非0为持有锁的任务PID；
unsigned int __count; ----获取锁的次数，支持嵌套调用，每次获取到锁值加1，释放减1。
int __owner; ----锁的owner
unsigned int __nusers; ----使用锁的任务个数，通常为1（被占用）或0（空闲）
int __kind;----锁的属性，如递归调用，优先级翻转等。
int __spins; ----SMP下，尝试获取锁的次数，尽量不进入内核。
__pthread_list_t __list; ----把锁插入回收链表，如果支持回收功能，每次获取锁时要插入任务控制块的回收链表。
}__data;

E. 关于linux 线程互斥锁的问题，到底怎么锁的

首先初始化的锁为全局变量，为所有线程共享，你一个线程得到锁后自然而然就将其他线程阻塞了嘛，解锁后其他线程才能获取锁，理解哪个锁是一个阻塞性函数就ok，何必纠结呢，具体深挖掘的话就可以参照Linux环境高级编程了！

F. linux 共享内存 可不可以不加锁呢 系统有两个进程,一个负责写入,一个负责读取

Linux共享内存可以不用加锁，不过需要一种机制来标记共享内存的读写状态；
也就是说要让两个进程知道：
1）负责写入的进程，必须知道当前共享内存是否可以写入，上一次的写入内容是否有被负责读取的进程读走；
2）负责读取的进程，必须知道当前共享内存是否需要读取，防止重复读取。
一般的这种标记机制是通过以下方式来简单实现：
1）通过读写锁来控制；
2）共享内存上设置一个地方，专门存放当前共享内存的读写状态；

G. linux中fcntl()函数的使用

前面的这5个基本函数实现了文件的打开、读写等基本操作，这一节将讨论的是，在文 件已经共享的情况下如何操作，也就是当多个用户共同使用、操作一个文件的情况，这时，Linux 通常采用的方法是给文件上锁，来避免共享的资源产生竞争的状态。
文件锁包括建议性锁和强制性锁。
建议性锁要求每个上锁文件的进程都要检查是否有锁存，并且尊重已有的锁。在一般情况下，内核和系统都不使用建议性锁。强制性锁是由内 核执行的锁，当一个文件被上锁进行写入操作的时候，内核将阻止其他任何文件对其进行读写操作。采用强制性锁对性能的影响很大，每次读写操作都必须检查是否有锁存在。
在 Linux 中，实现文件上锁的函数有lock和fcntl，其中flock用于对文件施加建议性锁,而fcntl不仅可以施加建议性锁，还可以施加强制锁。同时，fcntl还能对文件的某一记录进行上锁，也就是记录锁。
记录锁又可分为读取锁和写入锁，其中读取锁又称为共享锁，它能够使多个进程都能在文件的同一部分建立读取锁。而写入锁又称为排斥锁，在任何时刻只能有一个进程在文件的某个部分上建立写入锁。当然，在文件的同一部分不能同时建立读取锁和写入锁。

H. linux自旋锁使用时需要注意的几个地方

1、在内核多线程编程时，为了保护共享资源通常需要使用锁，而使用的比较多的就是spinlock，但需要注意的是：所有临界区代码都需要加锁保护，否则就达不到保护效果。也就是，访问共享资源的多个线程需要协同工作共同加锁才能保证不出错。在实际写代码时，有时候会网掉这一点，以致出现各种稀奇古怪的问题，而且很难找到原因。
2、在出现两个和多个自旋锁的嵌套使用时，务必注意加锁和解锁的顺序。
比如：在线程1中，spinlock A -> spinlock B -> spin unlock B -> spin unlock A ；那么，在需要同步的线程2中，若需要加相同的锁，则顺序也应该保持相同，spinlock A -> spinlock B -> spin unlock B -> spin unlock A ；否则，很有可能出现死锁。
3、spinlock保护的代码执行时间要尽量短，若有for循环之类的代码，则一定要确保循环可以在短时间可以退出，从而使得spinlock可以释放。
4、spinlock所保护的代码在执行过程中不能睡眠。比如，在spinlock和spinunlock之间不能调用kmalloc, _from_user,kthread_stop等调用，因为这些函数调用均有可能导致线程睡眠。
5、spinlock在实际使用时有如下几种类型，spin_lock，spin_lock_bh，spin_lock_irqsave。在具体使用时，需要根据被保护临界区锁处的上下文选择合适的spinlock类型。
spin_lock用于不同cpu线程间同步，spin_lock_bh和spin_lock_irqsave主要用于本cpu线程间的同步，前者关软中断，后者关硬中断。

I. linux c 如何实现进程间互斥呢

文件锁/信号量，不要用进程共享锁。

J. iuni系统怎么把应用上锁

文件锁
1．fcntl()函数说明
前面讲述的5个基本函数实现了文件的打开、读/写等基本操作，本节将讨论在文件已经共享的情况下如何操作，也就是当多个用户共同使用、操作一个文件的情况。这时，Linux通常采用的方法是给文件上锁，来避免共享的资源产生竞争的状态。
文件锁包括建议性锁和强制性锁。建议性锁要求每个上锁文件的进程都要检查是否有锁存在，并且尊重已有的锁。在一般情况下，内核和系统都不使用建议性锁。强制性锁是由内核执行的锁，当一个文件被上锁进行写入操作时，内核将阻止其他任何文件对其进行读写操作。采用强制性锁对性能的影响很大，每次读写操作都必须检查是否有锁存在。
在Linux中，实现文件上锁的函数有lockf()和fcntl()，其中lockf()用于对文件施加建议性锁，而fcntl()不仅可以施加建议性锁，还可以施加强制性锁。同时，fcntl()还能对文件的某一记录上锁，也就是记录锁。
记录锁又可分为读取锁和写入锁，其中读取锁又称为共享锁，它能够使多个进程都能在文件的同一部分建立读取锁。而写入锁又称为排斥锁，在任何时刻只能有一个进程在文件的某个部分建立写入锁。当然，在文件的同一部分不能同时建立读取锁和写入锁。
fcntl()函数具有很丰富的功能，它可以对已打开的文件描述符进行各种操作，不仅包括管理文件锁，还包括获得设置文件描述符和文件描述符标志、文件描述符的复制等很多功能。本节主要介绍fcntl()函数建立记录锁的方法，关于它的其他操作，感兴趣的读者可以参看fcntl手册。
2．fcntl()函数格式
用于建立记录锁的fcntl()函数语法要点如表2.6所示。

表2.6 fcntl()函数语法要点

所需头文件
#include
<sys/types.h>
#include <unistd.h>
#include <fcntl.h>

函数原型
int fcntl(int fd, int cmd, struct flock
*lock)

函数传入值
fd：文件描述符

cmd
F_DUPFD：复制文件描述符

F_GETFD：获得fd的close-on-exec标志，若标志未设置，则文件经过exec()函数之后仍保持打开状态

F_SETFD：设置close-on-exec标志，该标志由参数arg的FD_CLOEXEC位决定

F_GETFL：得到open设置的标志

F_SETFL：改变open设置的标志

F_GETLK：根据lock描述，决定是否上文件锁

F_SETLK：设置lock描述的文件锁

F_SETLKW：这是F_SETLK的阻塞版本（命令名中的W表示等待（wait））。
在无法获取锁时，会进入睡眠状态；如果可以获取锁或者捕捉到信号则会返回

lock：结构为flock，设置记录锁的具体状态，后面会详细说明

函数返回值
成功：0
1：出错

这里，lock的结构如下所示：

struct flock
{
short
l_type;
off_t l_start;
short l_whence;
off_t
l_len;
pid_t l_pid;
}
lock结构中每个变量的取值含义如表2.7所示。

表2.7 lock结构变量取值

l_type
F_RDLCK：读取锁（共享锁）

F_WRLCK：写入锁（排斥锁）

F_UNLCK：解锁

l_start
加锁区域在文件中的相对位移量（字节），与l_whence值一起决定加锁区域的起始位置

l_whence：
相对位移量的起点（同lseek的whence）

SEEK_SET：当前位置为文件的开头，新位置为偏移量的大小

SEEK_CUR：当前位置为文件指针的位置，新位置为当前位置加上偏移量

SEEK_END：当前位置为文件的结尾，新位置为文件的大小加上偏移量的大小

l_len
加锁区域的长度

为加锁整个文件，通常的方法是将l_start设置为0，l_whence设置为SEEK_SET，l_len设置为0。
3．fcntl()使用实例
下面首先给出了使用fcntl()函数的文件记录锁功能的代码实现。在该代码中，首先给flock结构体的对应位赋予相应的值。
接着调用两次fcntl()函数。用F_GETLK命令判断是否可以进行flock结构所描述的锁操作：若可以进行，则flock结构的l_type会被设置为F_UNLCK，其他域不变；若不可进行，则l_pid被设置为拥有文件锁的进程号，其他域不变。
用F_SETLK和F_SETLKW命令设置flock结构所描述的锁操作，后者是前者的阻塞版。
当第一次调用fcntl()时，使用F_GETLK命令获得当前文件被上锁的情况，由此可以判断能不能进行上锁操作；当第二次调用fcntl()时，使用F_SETLKW命令对指定文件进行上锁/解锁操作。因为F_SETLKW命令是阻塞式操作，所以，当不能把上锁/解锁操作进行下去时，运行会被阻塞，直到能够进行操作为止。
文件记录锁的功能代码具体如下所示：

/* lock_set.c */
int lock_set(int
fd, int type)
{
struct flock old_lock,
lock;
lock.l_whence = SEEK_SET;
lock.l_start =
0;
lock.l_len = 0;
lock.l_type =
type;
lock.l_pid = -1;

/* 判断文件是否可以上锁
*/
fcntl(fd, F_GETLK, &lock);
if (lock.l_type !=
F_UNLCK)
{
/* 判断文件不能上锁的原因 */
if
(lock.l_type == F_RDLCK) /* 该文件已有读取锁
*/
{
printf("Read lock already set by %d\n",
lock.l_pid);
}
else if (lock.l_type == F_WRLCK) /*
该文件已有写入锁 */
{
printf("Write lock already set
by %d\n", lock.l_pid);
}
}

/* l_type
可能已被F_GETLK修改过 */
lock.l_type = type;
/*
根据不同的type值进行阻塞式上锁或解锁 */
if ((fcntl(fd, F_SETLKW, &lock)) <
0)
{
printf("Lock failed:type = %d\n",
lock.l_type);
return
1;
}

switch(lock.l_type)
{
case
F_RDLCK:
{
printf("Read lock set by %d\n",
getpid());
}
break;
case
F_WRLCK:
{
printf("Write lock set by %d\n",
getpid());
}
break;
case
F_UNLCK:
{
printf("Release lock by %d\n",
getpid());
return
1;
}
break;
default:
break;
}/*
end of switch */
return 0;
}
下面的实例是文件写入锁的测试用例，这里首先创建了一个hello文件，之后对其上写入锁，最后释放写入锁。代码如下所示：

/* write_lock.c */
#include
<unistd.h>
#include <sys/file.h>
#include
<sys/types.h>
#include <sys/stat.h>
#include
<stdio.h>
#include <stdlib.h>
#include
"lock_set.c"

int main(void)
{
int
fd;

/* 首先打开文件 */
fd = open("hello",O_RDWR | O_CREAT,
0644);
if(fd < 0)
{
printf("Open file
error\n");
exit(1);
}

/* 给文件上写入锁
*/
lock_set(fd, F_WRLCK);
getchar();
/* 给文件解锁
*/
lock_set(fd, F_UNLCK);
getchar();

close(fd);
exit(0);
}
为了能够使用多个终端，更好地显示写入锁的作用，本实例主要在PC上测试，读者可将其交叉编译，下载到目标板上运行。下面是在PC上的运行结果。为了使程序有较大的灵活性，笔者采用文件上锁后由用户输入任意键使程序继续运行。建议读者开启两个终端，并且在两个终端上同时运行该程序，以达到多个进程操作一个文件的效果。在这里，笔者首先运行终端一，请读者注意终端二中的第一句。
终端一：

$ ./write_lock
write lock set by
4994
release lock by 4994
终端二：

$ ./write_lock
write lock already
set by 4994
write lock set by 4997
release lock by 4997
由此可见，写入锁为互斥锁，同一时刻只能有一个写入锁存在。
接下来的程序是文件读取锁的测试用例，原理与上面的程序一样。

/* fcntl_read.c */
#include
<unistd.h>
#include <sys/file.h>
#include
<sys/types.h>
#include <sys/stat.h>
#include
<stdio.h>
#include <stdlib.h>
#include
"lock_set.c"

int main(void)
{
int fd;
fd
= open("hello",O_RDWR | O_CREAT, 0644);
if(fd <
0)
{
printf("Open file
error\n");
exit(1);
}

/* 给文件上读取锁
*/
lock_set(fd, F_RDLCK);
getchar();
/* 给文件解锁
*/
lock_set(fd, F_UNLCK);
getchar();

close(fd);
exit(0);
}
同样开启两个终端，并首先启动终端一上的程序，其运行结果如下所示。
终端一：

$ ./read_lock
read lock set by
5009
release lock by 5009
终端二：

$ ./read_lock
read lock set by
5010
release lock by 5010
读者可以将此结果与写入锁的运行结果相比较，可以看出，读取锁为共享锁，当进程5009已设置读取锁后，进程5010仍然可以设置读取锁。