互斥实现方式------锁(Linux)

最新推荐文章于 2024-07-16 02:28:31 发布

晴耕雨读912

最新推荐文章于 2024-07-16 02:28:31 发布

阅读量949

点赞数 15

文章标签： linux 信息与通信驱动开发

本文链接：https://blog.csdn.net/weixin_63602189/article/details/138013073

版权

前言：

互斥机制的实现有多种方式，在应用层进程线程间的互斥通过互斥锁，无名信号量，条件变量等方式实现，在Linux内核中的并发竞态的解决通过中断屏蔽，自旋锁，信号量，互斥体，原子操作的解决办法，在本篇文章中单独将锁拿出来介绍，互斥锁以应用层介绍，自旋锁以内核底层介绍，其余方法后文中介绍。

一.锁的分类

二.锁的介绍及实现机制

2.1悲观锁

悲观锁比较基于形象化，悲观锁包括互斥锁，自旋锁，读写锁，其所实现比较悲观故称悲观锁，其锁认为多线程同时修改共享资源的概率比较高，很容易造成冲突，所以在访问共享资源前要先上锁。

2.1.1互斥锁

互斥锁是一种独占锁，当线程1加锁成功后，互斥锁被线程1占用，只要线程1不释放手中的锁，那么线程2是不会拿到锁并加锁成功，线程2加锁失败，会释放CPU资源让给其他进程，线程2释放掉了CPU资源后，线程加锁代码就会进入阻塞状态。

至于互斥锁加锁失败进入的阻塞是由操作系统内核实现的，在加锁失败后，内核会将线程置为睡眠状态，等锁被释放后，内核会在合适时机唤醒休眠线程，当线程成功获取到锁之后则可以继续执行任务。

加锁过程分为两步：

查看锁的状态，如果锁是空闲的，则会进行第二步
将所设置为当前进程所有

注意：当互斥锁加锁失败时，线程会从用户态陷入到内核态，由内核来切换线程，与此同时增加性能开销成本。

开销成本(两次线程上下文切换的成本)：

当线程加锁失败时，内核会把线程的状态从运行态设置为睡眠态，然后将CPU切换给其他线程使用
当锁被线程释放后，休眠阻塞的线程会从睡眠态转为就绪态，由内核选择合适的时间将CPU切换到该线程，该线程执行任务

线程的上下文切换：当线程属于同一个进程时，因为虚拟内存的共享，所以在切换时，虚拟内存中的资源保持不变，只需要切换线程私有数据，寄存器等不共享资源。

上下文切换大概是在几十纳秒和几微秒之间，因此如果说可以确定被锁代码的执行时间很短的话可以选择不加锁。

线程互斥锁代码示例：

#include <my_head.h>

pthread_mutex_t lock;//定义互斥锁
int money = 1000;
void *func1(void *arg){
    while(1){
        sleep(1);
        pthread_mutex_lock(&lock);//加锁
        if(money >= 50){
            money -= 50;
            printf("张三取走了 50 元, 剩余 %d 元\n", money);
        }else{
            printf("不足50了, 张三取钱失败\n");
            pthread_mutex_unlock(&lock);//线程结束前 也要先解锁 再结束
            pthread_exit(NULL);
        }
        pthread_mutex_unlock(&lock);//解锁
    }
}
void *func2(void *arg){
    while(1){
        sleep(1);
        pthread_mutex_lock(&lock);//加锁
        if(money >= 100){
            money -= 100;
            printf("李四取走了 100 元, 剩余 %d 元\n", money);
        }else{
            printf("不足100了, 李四取钱失败\n");
            pthread_mutex_unlock(&lock);//线程结束前 也要先解锁 再结束
            pthread_exit(NULL);
        }
        pthread_mutex_unlock(&lock);//解锁
    }
}

int main(int argc, const char *argv[]){
    //动态初始化锁
    pthread_mutex_init(&lock, NULL);

    pthread_t tid1 = 0, tid2 = 0;
    int ret = 0;
    if(0 != (ret = pthread_create(&tid1, NULL, func1, NULL))){
        printf("pthread_create error : errno = [%d] errstr = [%s]\n", ret, strerror(ret));
        exit(EXIT_FAILURE);
    }
    if(0 != (ret = pthread_create(&tid2, NULL, func2, NULL))){
        printf("pthread_create error : errno = [%d] errstr = [%s]\n", ret, strerror(ret));
        exit(EXIT_FAILURE);
    }
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_mutex_destroy(&lock);//销毁锁  需要在没有线程使用锁的时候才能销毁
    return 0;
}

2.1.2自旋锁

自旋锁：当一个进程获取到自旋锁之后，另外一个进程也想获取这把锁，此时后一个进程处于自旋状态(原地打转)，这种锁又叫忙等锁。

自旋锁是通过CPU提供的CAS(Compare And Swap)函数，在用户态完成加锁和解锁操作，不会主动产生线程上下文，相对于互斥锁来说，会快一些，开销也会小一些。

CAS函数会将加锁两个步骤合并成一条硬件级指令，形成原子指令，保证了加锁两个步骤的不可分割性，要不全都执行，要不全都不执行。

自旋锁特点：

自旋锁是针对多核设计的
自旋锁状态是需要消耗CPU资源的
自旋锁可能会产生死锁(在同一个进程内多次获取同一把锁未解决)
自旋锁的保护临界要尽可能的小，也就是说不能在临界区中执行延时，耗时，休眠的代码，也不能有copy_to_user/copy_from_user等函数
自旋锁可以工作在中断上下文
自旋锁在加锁前会关闭抢占

自旋锁使用代码(底层驱动代码)示例：

#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#define CNAME "mycdev"
#define COUNT 3
struct cdev* cdev;
int major = 510; //=0动态申请  >0静态指定
int minor = 0;
struct class* cls;
struct device* dev;
char kbuf[128] = { 0 };
spinlock_t lock; // 定义自旋锁
int flags = 0; // 定义标志位的变量
int mycdev_open(struct inode* inode, struct file* file)
{
    spin_lock(&lock); // 上锁
    if (flags != 0) {
        spin_unlock(&lock); // 解锁
        return -EBUSY;
    }
    flags = 1;
    spin_unlock(&lock); // 解锁
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
ssize_t mycdev_read(struct file* file,
    char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret) {
        printk("copy_to_user error\n");
        return -EIO;
    }
    return size;
}
ssize_t mycdev_write(struct file* file,
    const char __user* ubuf, size_t size, loff_t* offs)
{
    int ret;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret) {
        printk("copy_from_user error\n");
        return -EIO;
    }
    return size;
}
int mycdev_close(struct inode* inode, struct file* file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    spin_lock(&lock); // 上锁
    flags = 0;
    spin_unlock(&lock); // 解锁
    return 0;
}
const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};
static int __init mycdev_init(void)
{
    int ret, i;
    dev_t devno;
    // 1.分配对象
    cdev = cdev_alloc();
    if (cdev == NULL) {
        printk("cdev_alloc error\n");
        ret = -ENOMEM;
        goto ERR1;
    }
    // 2.初始化对象
    cdev_init(cdev, &fops);
    // 3.申请设备号
    if (major == 0) {
        // 动态申请设备号
        ret = alloc_chrdev_region(&devno, minor, COUNT, CNAME);
        if (ret) {
            printk("alloc_chrdev_region error\n");
            goto ERR2;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
    } else if (major > 0) {
        // 静态指定
        ret = register_chrdev_region(MKDEV(major, minor), COUNT, CNAME);
        if (ret) {
            printk("register_chrdev_region error\n");
            goto ERR2;
        }
    }
    // 4.注册
    ret = cdev_add(cdev, MKDEV(major, minor), COUNT);
    if (ret) {
        printk("cdev_add error\n");
        goto ERR3;
    }
    // 5.自动创建设备节点
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("class_create error\n");
        ret = PTR_ERR(cls);
        goto ERR4;
    }
    for (i = 0; i < COUNT; i++) {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "%s%d", CNAME, i);
        if (IS_ERR(dev)) {
            printk("device_create error\n");
            ret = PTR_ERR(dev);
            goto ERR5;
        }
    }

    spin_lock_init(&lock); // 初始化自旋锁
    return 0; /******************千万别忘记写了！！！***************************/
ERR5:
    for (--i; i >= 0; i--) {
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
ERR4:
    cdev_del(cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major, minor), COUNT);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}
static void __exit mycdev_exit(void)
{
    int i;
    for (i = 0; i < COUNT; i++) {
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
    cdev_del(cdev);
    unregister_chrdev_region(MKDEV(major, minor), COUNT);
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

2.1.3读写锁

读写锁适用于能明确区分读操作和写操作的场景

读写锁的工作原理：

当写锁没有被线程持有时，多个线程能够并发的持有读锁，极大地提高了共享内存的访问效率，读锁是用于读取共享资源的场景，多个线程同时持有读锁时也不会破坏共享资源的数据。
当写锁被线程持有后，读线程获取读锁的操作会被阻塞，而且其他写线程获取写锁操作也会被阻塞。

因此，写锁是独占锁，在任何时刻只能有一个线程获取写锁，类似互斥锁和自旋锁，而读锁是共享锁，可被多个线程同时持有。

读写锁可在读多写少的情况下发挥优势。

公平读写锁是比较简单的一种方式：用队列把获取锁的线程排队，不管是写线程还是读线程都会按照先进先出的原则加锁，这样读线程仍然可以并发，也不会出现饥饿现象。

2.1.3.1读优先锁

读锁能被更多的线程持有，以提高读线程并发性。

工作方式：当读线程1先持有了读锁，写线程2获取写锁的时候会被阻塞，在阻塞的时候，后到的读线程3仍然可以成功获取读锁，，最后直到线程1和线程3释放读锁后，写线程2才可以成功获取写锁。

2.1.3.2写优先锁

写优先锁主要的是优先服务线程

工作方式：当读线程1先持有了读锁，写线程2在获取写锁的时候会被阻塞，在阻塞的过程中，读线程3获取读锁失败，进入阻塞，只有读线程1释放锁资源后，写线程2才会获取写锁。

2.2乐观锁

乐观锁也是一种形象化，它的工作方式是先修改完共享资源，再验证这段时间有没有发生冲突，如果没有其他进程修改资源，那么操作完成，如果发现有其他进程已经修改过这个资源，那么会放弃这次操作。在实现过程中并有加锁机制，所以也称为无锁编程。

2.3死锁

死锁产生条件(四个必须同时满足)：

互斥条件：多个线程不能同时使用同一个资源
持有并等待条件：当线程1已经持有了资源1，又想申请资源2，而资源2已经被线程3持有，线程1就会处于等待状态，于此同时线程1在等待资源2的同时并不会释放自己已经持有的资源1.
不可剥夺条件：当线程1已经持有了资源，在自己使用完之前不能被其他线程获取，线程2如果也想获取这个资源，只能在线程1使用完并且释放后才可以获取。
环路等待条件：在死锁发生的时候，两个线程获取资源的顺序构成环形链。

避免死锁产生方式：破坏其中一个条件即可，常用的是使用资源有序分配法来破坏环路等待条件。

在我们编程使用锁的时候一定要合理使用锁，合理有序分配资源，避免死锁的产生，如果有死锁的产生，可通过gdb调试工具调试解决。

总结：本文展开性的解释了互斥机制中关于锁的部分，如果有缺陷或有错误还请指出，与此同时也希望我的总结解释可以提供给需要的人。

注：文中所示代码仅供解释及提供思路参考，请谨慎下载运行调试！！！

晴耕雨读912

关注

15
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
互斥实现方式------锁(Linux)

互斥机制的实现有多种方式，在应用层进程线程间的互斥通过互斥锁，无名信号量，条件变量等方式实现，在Linux内核中的并发竞态的解决通过中断屏蔽，自旋锁，信号量，互斥体，原子操作的解决办法，在本篇文章中单独将锁拿出来介绍，互斥锁以应用层介绍，自旋锁以内核底层介绍，其余方法后文中介绍。悲观锁比较基于形象化，悲观锁包括互斥锁，自旋锁，读写锁，其所实现比较悲观故称悲观锁，其锁认为多线程同时修改共享资源的概率比较高，很容易造成冲突，所以在访问共享资源前要先上锁。2.1.1互斥锁互斥锁是一种独占锁。
复制链接

扫一扫