linux顺序锁

#include<linux/fs.h>

#include<linux/sched.h>

#include<linux/kthread.h>

#include<linux/module.h>

#include<linux/delay.h>

#include<linux/seqlock.h>//顺序锁头文件

static int i=0,j=100;//一个线程从0开始加,一个线程从100开始加

struct task_struct *MyThread1=NULL;//线程1

struct task_struct *MyThread2=NULL;//线程2

static int myVar = 0;//定义变量

static int count = 0;

seqlock_t lock;//定义顺序锁

static void setMyVar(int input)//写变量

{

write_seqlock(&lock);//加顺序写锁

//临界区

if(count)//count=1进入

{

printk("busy setMyVar\n");

}

count++;//conut=1

myVar = input;//写变量,将input值赋值给myVar

printk("setMyVar is %d\n",myVar);//打印写的变量值

write_sequnlock(&lock);//释放顺序写锁

count--;//count=0;

}

static int getMyVar(void)//读变量

{

int res = 0;//用于读取变量myVar的值

unsigned long seq;//顺序锁中的顺序计数器

do

{

seq=read_seqbegin(&lock);//读取顺序号,如果是奇数,说明正在进行写操作,处理器就等待,如果不是奇数,就返回读到的顺序号

//临界区

if(count)

{

printk("busy setMyVar\n");

}

count++;

res = myVar;//读变量,将myVar变量值赋值给res

printk("getMyVar is %d\n",res);//打印读取的变量res的值

}while(read_seqretry(&lock,seq));//检测读的数据有没有效,如果顺序号跟一开始的不一致,就返回1,说明修改了临界区,需要重新读数据

count--;//count=0;

return 0;

}

static int print1(void *data)//线程1打印函数

{

while(!kthread_should_stop())//判断该线程是否停止,若线程未停止则进入

{

printk("this is thread1......\n");//提示这是线程1

getMyVar();//读变量

setMyVar(i);//写变量

ssleep(1);//沉睡1秒

i++;//i+1

}

return 0;

}

static int print2(void *data)//线程2打印函数

{

while(!kthread_should_stop())//判断该线程是否停止,若线程未停止则进入

{

printk("this is thread2......\n");//提示这是线程2

getMyVar();//读变量

setMyVar(j);//写变量

ssleep(1);//沉睡1秒

j++;//j+1

}

return 0;

}

static int __init hello_init(void){//模块加载入口函数

seqlock_init(&lock);//顺序锁初始化

MyThread1 = kthread_run(print1,NULL,"mythread1");//创建线程1,名字是mythread1,调用的函数是print1函数

MyThread2 = kthread_run(print2,NULL,"mythread2");//创建线程2,名字是mythread2,调用的函数是print2函数

return 0;

}

static void __exit

hello_exit(void){//模块退出函数

if(MyThread1)//如果线程1还存在,那么就停止该线程

{

printk("kthread1 stop....\n");//提示即将停止线程1

kthread_stop(MyThread1);//调用kthread_stop函数停止线程1

MyThread1=NULL;//将结构体指针MyThread1指向空

}

if(MyThread2)//如果线程2还存在,那么就停止该线程

{

printk("kthread2 stop....\n");//提示即将停止线程2

kthread_stop(MyThread2);//调用kthread_stop函数停止线程2

MyThread2=NULL;//将结构体指针MyThread2指向空

}

}

module_init(hello_init);//模块加载

module_exit(hello_exit);//模块退出

MODULE_LICENSE("GPL");//模块许可证

MODULE_AUTHOR("Valerie Henson [email protected]");//模块作者信息

MODULE_DESCRIPTION("\"rwlock\" minimal module");//模块描述

MODULE_VERSION("printk");//模块版本

时间: 2024-10-23 13:18:58

linux顺序锁的相关文章

大话Linux内核中锁机制之内存屏障、读写自旋锁及顺序锁

大话Linux内核中锁机制之内存屏障.读写自旋锁及顺序锁 在上一篇博文中笔者讨论了关于原子操作和自旋锁的相关内容,本篇博文将继续锁机制的讨论,包括内存屏障.读写自旋锁以及顺序锁的相关内容.下面首先讨论内存屏障的相关内容. 三.内存屏障 不知读者是是否记得在笔者讨论自旋锁的禁止或使能的时候,提到过一个内存屏障函数.OK,接下来,笔者将讨论内存屏障的具体细节内容.我们首先来看下它的概念,Memory Barrier是指编译器和处理器对代码进行优化(对读写指令进行重新排序)后,导致对内存的写入操作不能

Linux设备驱动程序 之 顺序锁

当要保护的资源很小,很简单,会频繁的被访问而且写入访问很少的且必须快速时(即读不允许让写饥饿),就可以使用顺序锁(seqlock):从本质上讲,顺序锁会允许读取者对资源的自由访问,但需要读取者检查是否和写入者发生冲突,当这种冲突发生时,就需要重试对资源的访问: 顺序锁通常不能用于保护包含指针的数据结构,因为在写入者修改该数据结构的同时,读取这可能会追随一个无效指针: seqlock定义在<linux/seqlock>中,通常用于初始化seqlock的方法有: 静态定义和初始化: 1 #defi

linux内核同步之信号量、顺序锁、RCU、完成量、关闭中断【转】

转自:http://blog.csdn.net/goodluckwhh/article/details/9006065 版权声明:本文为博主原创文章,未经博主允许不得转载. 目录(?)[-] 一信号量 信号量的概念 信号量的数据结构和相关API 数据结构 初始化 获取和释放信号量 读写信号量的概念 读写信号量的数据结构 二顺序锁 顺序锁的概念 数据结构 写操作 读操作 三Read-Copy Update RCU 写操作 读操作 释放旧的版本 四完成量Completions 完成量的概念 数据结构

Linux互斥锁、条件变量和信号量

Linux互斥锁.条件变量和信号量  来自http://kongweile.iteye.com/blog/1155490 博客分类: Linux sem_init:初始化信号量sem_t,初始化的时候可以指定信号量的初始值,以及是否可以在多进程间共享.sem_wait:一直阻塞等待直到信号量>0.sem_timedwait:阻塞等待若干时间直到信号量>0.sem_post:使信号量加1.sem_destroy:释放信号量.和sem_init对应. 进行多线程编程,最应该注意的就是那些共享的数据

linux 自旋锁和信号量【转】

转自:http://blog.csdn.net/xu_guo/article/details/6072823 版权声明:本文为博主原创文章,未经博主允许不得转载. 自旋锁最多只能被一个可执行线程持有(读写自旋锁除外).自旋锁不会引起调用者睡眠,如果一个执行线程试图获得一个已经被持有的自旋锁,那么线程就会一直进行忙循环,一直等待下去(一直占用 CPU ),在那里看是否该自旋锁的保持者已经释放了锁, " 自旋 " 一词就是因此而得名. 由于自旋锁使用者一般保持锁时间非常短,因此选择自旋而不

多线程编程之顺序锁

一.什么是顺序锁 顺序锁对读写锁的一种优化,使用顺序锁时,读不会被写执行单元阻塞(在读写锁中,写操作必须要等所有读操作完成才能进行).也就是说,当向一个临界资源中写入的同时,也可以从此临界资源中读取,即实现同时读写,但是不允许同时写数据.如果读执行单元在读操作期间,写执行单元已经发生了写操作,那么,读执行单元必须重新开始,这样保证了数据的完整性,当然这种可能是微乎其微.顺序锁的性能是非常好的,同时他允许读写同时进行,大大的提高了并发性. 二.顺序锁的缺陷 顺序锁的缺陷在于,互斥访问的资源不能是指

自旋锁,读写锁和顺序锁的实现原理

常用的同步原语锁,到多核处理器时代锁已经是必不可少的同步方式之一了.无论设计多优秀的多线程数据结构,都避不开有竞争的临界区,此时高效的锁显得至关重要.锁的颗粒度是框架/程序设计者所关注的,当然越细越好(也不尽然),同时不同的锁往往也会体现出完全不同的效率,Linux有posix的pthread_mutex_t,Windows有CreateMutex创造的HANDLE,boost有mutex而且C++11也定义了std::mutex,这些锁在获取不到锁时都会进入睡眠状态(try_lock方法例外)

linux 自旋锁和信号量

自旋锁最多只能被一个可执行线程持有(读写自旋锁除外).自旋锁不会引起调用者睡眠,如果一个执行线程试图获得一个已经被持有的自旋锁,那么线程就会一直进行忙循环,一直等待下去(一直占用 CPU ),在那里看是否该自旋锁的保持者已经释放了锁, " 自旋 " 一词就是因此而得名. 由于自旋锁使用者一般保持锁时间非常短,因此选择自旋而不是睡眠是非常必要的,自旋锁的效率远高于互斥锁. 信号量和读写信号量适合于保持时间较长的情况,它们会导致调用者睡眠,因此只能在进程上下文使用(因为中断的上下文不允许休

linux 建议锁和强制锁

作为APUE 14.3节的参考 linux是有强制锁的,但是默认不开启.想让linux支持强制性锁,不但在mount的时候需要加上-o mand,而且对要加锁的文件也需要设置相关权限. 1.??????????????建议锁又称协同锁.对于这种类型的锁,内核只是提供加减锁以及检测是否加锁的操作,但是不提供锁的控制与协调工作.也就是说,如果应用程序对某个文件进行操作时,没有检测是否加锁或者无视加锁而直接向文件写入数据,内核是不会加以阻拦控制的.因此,建议锁,不能阻止进程对文件的操作,而只能依赖于大