精华内容
下载资源
问答
  • 线程线程资源共享问题
    千次阅读
    2017-12-01 18:25:11

    简介

    在多线程的环境下, 由于公共资源可能会被多个线程共享, 也就是多个线程可能会操作( 增、删、改等 )同一资源.
    当多个线程操作同一块资源时, 很容易导致数据错乱或发生数据安全问题, 即:
    数据有可能丢失, 有可能增加, 有可能错乱.

    资源共享经典问题–>卖票

    逻辑伪代码:
    if( 余票 > 0 )
    ……余票-1
    else
    ……提示无票

    代码

    Swift

    var votes = 10
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // 售票
        self.saleTickets()
    }
    
    @objc func saleTickets() {
        while true {
            // 模拟耗时操作
            Thread.sleep(forTimeInterval: 1.0)
            if(self.votes > 0) {
                self.votes = self.votes - 1
                print(Thread.current.description + "  余票数为 " + self.votes.description)
            }
            else {
                print(Thread.current.description + "  无票")
                break;
            }
        }
    }

    OC

    // 票数
    @property (nonatomic, assign) int votes;
    
    - (void)viewDidLoad {
        [super viewDidLoad];
        self.tickets = 10;
        // 售票
        [self saleTickets];
    }
    
    - (void)saleTickets
    {
        while(YES)
        {
            // 模拟耗时操作
            [NSThread sleepForTimeInterval:1.0];
            if(self.votes > 0)
            {
                self.votes--;
                NSLog(@"余票数为%d", self.votes);
            }
            else
            {
                NSLog(@"无票");
                break;
            }
        }
    }

    问题

    这时候我们在单线程上面运行是没问题的, 但是当有多个售票员(子线程)在卖票(共同访问同一个数据)的时候, 就会出现以下的情况:
    代码:
    OC

    // 售票员1
    NSThread *conductor1 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTickets) object:nil];
    conductor1.name = @"售票员1";
    [conductor1 start];
    
    // 售票员2
    NSThread *conductor2 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTickets) object:nil];
    conductor2.name = @"售票员2";
    [conductor2 start];

    Swift

    // 售票员1
    let conductor1 = Thread.init(target: self, selector: #selector(saleTickets), object: nil)
    conductor1.name = "售票员1"
    conductor1.start()
    
    // 售票员2
    let conductor2 = Thread.init(target: self, selector: #selector(saleTickets), object: nil)
    conductor2.name = "售票员2"
    conductor2.start()

    打印:
    这里写图片描述

    PS: 笔者记得两三年前刚接触iOS的多线程的时候, 测试有次测得余票数是-1的, 现在侧很久都没发现有-1的情况. 有兴趣的大兄弟可以试试

    原因

    这里写图片描述

    解决

    在共同资源( 票数 )被访问( 确切说是准备变化 )的时候( 如上图线程1写入时 ), 该资源只能被一个线程操作.
    这时, 我们就可以使用互斥锁等保证被锁定的代码( 资源 ), 同一时间, 只能有一个线程可以操作.

    代码修改:
    Swift

    @objc func saleTickets() {
        while true {
            Thread.sleep(forTimeInterval: 0.1)
            /// 添加互斥锁
            /// 由于互斥锁为了数据安全会牺牲性能, 所有互斥锁的范围一定要尽可能地小
            /// 参数: 可以使任意的继承自基类NSObject的对象
            /// 但是, 这个参数一定要确保, 互斥的其他线程认识这把锁.
            /// 由于self本身就是一个全局变量, 所以一般我们都直接给self
            objc_sync_enter(self)
            if(self.votes > 0) {
                self.votes = self.votes - 1
                print(Thread.current.description + "  余票数为 " + self.votes.description)
            }
            else {
                print(Thread.current.description + "  无票, 当前票数为" + self.votes.description)
                break;
            }
            objc_sync_exit(self) // 记得退出互斥锁
        }
    }

    OC

    - (void)saleTickets
    {
        while(YES)
        {
            // 模拟耗时操作
            [NSThread sleepForTimeInterval:1.0];
            // 添加互斥锁
            @synchronized (self) 
            {
                if(self.votes > 0)
                {
                    self.votes--;
                    NSLog(@"余票数为%d", self.votes);
                }
                else
                {
                    NSLog(@"无票");
                    break;
                }
            }
        }
    }
    更多相关内容
  • 线程共享资源

    千次阅读 2019-05-12 18:49:41
    1. 线程共享资源   如果说pthread_create函数跟fork函数是对应的,一个创建线程,一个创建进程(实际上fork和pthread_create都是调用的内核函数clone,只是clone的参数不同,fork出来的进程拥有不同的地址空间,...

    https://blog.csdn.net/qq_35733751/article/details/82777127

    1. 线程共享资源

      如果说pthread_create函数跟fork函数是对应的,一个创建线程,一个创建进程(实际上fork和pthread_create都是调用的内核函数clone,只是clone的参数不同,fork出来的进程拥有不同的地址空间,而pthread_create创建的线程共享地址空间)

      但是进程调用fork创建进程的代价较高,调用的过程实际上非常复杂,即便是依靠写时复制机制,仍然需要复制诸如内存页表和文件描述符表之类的多种进程属性,这意味着fork调用在时间上的开销比pthread_create函数更多(关于fork函数参考:18-用fork函数创建新进程)。

       但线程解决了这个问题,线程之所以能够方便,快速的共享数据,是因为进程调用fork创建子进程所需复制的诸多进程属性在线程间本来就是共享的,无需复制内存页,页表等(因为复制内存页和页表花费的开销不少),这对线程来说,效率提高了不少。当然这是有代价的:不过这要避免出现多个线程同时修改同一份数据的情况,这需要使用线程同步机制(这里暂时不讨论同步问题)。

    图1(图片摘自《linux/unix系统编程手册》)

    从图1来看,由于同一进程的多个线程共享进程的资源,比如全局内存(数据段和堆),除此之外还共享以下资源和环境:

    代码文本段
    打开的文件描述符
    信号处理函数
    当前工作目录
    用户id和组id
    进程id和父进程id
    …


    有些资源是每个线程各自独有一份,非共享:

    线程id
    用户空间栈
    errno变量
    信号屏蔽字
    调度优先级
    …


    2. 线程共享实验——全局变量

    #include <stdio.h>
    #include <pthread.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    //全局变量
    int var = 100;
    
    //线程主控函数
    void *tfn(void *arg) {
            
            //修改全局变量var的值
            var = 200;
            printf(" create thread succesful\n");
            return NULL;
    }
    
    int main(void) {
            //主控线程第一次打印var
            printf("before pthread_create var = %d\n", var);
            pthread_t tid;
            pthread_create(&tid, NULL, tfn, NULL);
            sleep(1);
            //主控线程再次打印var
            printf("after pthread_create, var = %d\n", var);
            return 0;
    }

     

    程序执行结果:

    说明线程间是共享全局变量的


    3. 线程共享实验——局部变量

    既然全局变量是共享的,那么局部变量是不是也是共享的呢?为了验证这个问题,我们来看实验二

    #include <stdio.h>
    #include <pthread.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    //线程主控函数
    void *tfn(void *arg) {
            int i = (int)arg;
            //局部变量
            int temp_val = 250;
            if(i == 0){
                    //线程1修改了temp_val后,打印temp_val的值
                    temp_val = 100;
                    printf("pthread1 , temp_val = %d\n" , temp_val);
            }else{
                    //线程2打印temp_val的值
                    printf("pthread2 , temp_val = %d\n" , temp_val);
            }
            printf(" create thread succesful\n");
            return NULL;
    }
    
    int main(void) {
            pthread_t tid[2];
            int i;
            for(i = 0; i < 2; i++){
                    pthread_create(&tid[i] , NULL , tfn , (void *)i);
            }
            sleep(1);
            return 0;
    }

    程序执行结果:


      局部变量temp_val的初始值是250,在创建了2个线程,线程1修改了temp_val的值为100并打印,而线程2再访问temp_val的值还是250,这说明线程间是不共享局部变量的(有趣的是可以通过指针直接访问另个一个线程的局部变量,这也不奇怪,图1可知多个线程虽然都有自己的栈区域,但总体上都是在进程的栈中)


      问题来了,为什么线程间不共享局部变量,为了弄明白这个问题,我们还得回到图1。

    图2

      首先,线程的生命周期一般是在线程主函数中,当线程一创建就会在用户栈开辟一块空间给线程主函数使用,这意味着我们每创建一个线程都会在用户栈开辟一块空间给线程主函数使用。如图2所示:线程1修改局部变量temp_val的值为100,实际上修改的是线程1的栈里的temp_val的值,并不会影响线程2的栈中的temp_val,所以线程2打印temp_val的值还是250,也就是说多线程不共享用户栈。


    4. 线程和进程的区别

      另外之前在学习进程时,我们的理解是进程就是程序运行的执行体,而实际上进程一旦创建就自动包含了一个主线程,真正的执行体是主线程。

      那么进程是什么?我们可以把进程理解为空间上的概念,它为所有的执行体(线程)提供必要的资源(内存、文件描述符、代码等),而线程,是时间上的概念,它是抽象的、假想的、动态的指令执行过程。

      可以把进程理解为学校或学校的各种资源,线程是学校里的一个个学习的学生,学生共享学校里的各种资源。

      但是以上这些都是概念上的线程和进程的区别,如果我们要真正的本质区分进程和线程,就是看是否共享PCB进程控制块,因为进程间PCB是各自独立的,而线程间PCB是共享的。

      因为线程间是共享全局变量的,这说明了线程间的虚拟地址空间是一样的,pthread_create函数底层也复制了一份一模一样的PCB,所以说一个线程修改了数据空间的数据的话,其他线程都会因此受到影响。
     

    展开全文
  • 即使用一个两个线程都能够共享的变量(如全局变量),这样两个线程都能够访问和修改该变量,从而达到共享数据的目的。 Qt 线程共享数据是本文介绍的内容,多的不说,先来啃内容。Qt线程共享数据主要有两种方式...
  • 在进行多线程开发时最令人头痛的问题估计就是对共享资源的控制了吧,今天就让我们谈一谈这个问题吧。 共享资源顾名思义就是需要被多个线程使用的资源,但是很多情况下我们是不能允许多个线程同时使用这个资源的。这...
  • 解决多线程当中共享资源冲突的问题 1. 冲突问题展示: /* * 共享资源冲突的问题 */ class SingleThread implements Runnable { // 共享资源,100张票 private static int ticket = 100; @Override public void ...
  • Lockers在多线程编程里面一个重要的概念是锁定,如果一个资源是多个线程共享的,为了保证数据的完整性,在进行事务性操作时需要将共享资源锁定,这样可以保证在做事务性操作时只有一个线程能对资源进行操作,下面看...
  • 对于未加锁的多线程共享资源并发访问程序,在某些计算机上不容易再现错误,请问:怎么改进程序能够容易看到错误的执行结果?加锁以后的多线程共享资源并发访问程序执行时出现过计算结果错误吗?
  • 线程资源共享集合

    2014-04-13 11:34:03
    线程资源共享,synchronized,Runnable,Thread
  • 一、线程共享数据  a)继承Thread,那么我们可以创建很多个这样的类,但是每个这样的类都是相互不关联的,也是说我们Thread类中的内容每个创建出来的类都有一份,因此它不适合作为数据共享的线程来操作。同时由于...
  • 线程间到底共享了哪些进程资源

    千次阅读 2020-12-15 21:20:00
    点击上方IT牧场,选择置顶或者星标技术干货每日送达进程和线程这两个话题是程序员绕不开的,操作系统提供的这两个抽象概念实在是太重要了。关于进程和线程有一个极其经典的问题,那就是进程和...

    点击上方 IT牧场 ,选择 置顶或者星标

    技术干货每日送达

    进程和线程这两个话题是程序员绕不开的,操作系统提供的这两个抽象概念实在是太重要了。

    关于进程和线程有一个极其经典的问题,那就是进程和线程的区别是什么?相信很多同学对答案似懂非懂。

    记住了不一定真懂

    关于这个问题有的同学可能已经“背得”滚瓜烂熟了:“进程是操作系统分配资源的单位,线程是调度的基本单位,线程之间共享进程资源”。

    可是你真的理解了上面最后一句话吗?到底线程之间共享了哪些进程资源,共享资源意味着什么?共享资源这种机制是如何实现的?对此如果你没有答案的话,那么这意味着你几乎很难写出能正确工作的多线程程序,同时也意味着这篇文章就是为你准备的。

    逆向思考

    查理芒格经常说这样一句话:“反过来想,总是反过来想”,如果你对线程之间共享了哪些进程资源这个问题想不清楚的话那么也可以反过来思考,那就是有哪些资源是线程私有的

     

    线程私有资源

    线程运行的本质其实就是函数的执行,函数的执行总会有一个源头,这个源头就是所谓的入口函数,CPU从入口函数开始执行从而形成一个执行流,只不过我们人为的给执行流起一个名字,这个名字就叫线程。

    既然线程运行的本质就是函数的执行,那么函数执行都有哪些信息呢?

    在《函数运行时在内存中是什么样子》这篇文章中我们说过,函数运行时的信息保存在栈帧中,栈帧中保存了函数的返回值、调用其它函数的参数、该函数使用的局部变量以及该函数使用的寄存器信息,如图所示,假设函数A调用函数B:

    此外,CPU执行指令的信息保存在一个叫做程序计数器的寄存器中,通过这个寄存器我们就知道接下来要执行哪一条指令。由于操作系统随时可以暂停线程的运行,因此我们保存以及恢复程序计数器中的值就能知道线程是从哪里暂停的以及该从哪里继续运行了。

    由于线程运行的本质就是函数运行,函数运行时信息是保存在栈帧中的,因此每个线程都有自己独立的、私有的栈区。

    同时函数运行时需要额外的寄存器来保存一些信息,像部分局部变量之类,这些寄存器也是线程私有的,一个线程不可能访问到另一个线程的这类寄存器信息

    从上面的讨论中我们知道,到目前为止,所属线程的栈区、程序计数器、栈指针以及函数运行使用的寄存器是线程私有的。

    以上这些信息有一个统一的名字,就是线程上下文,thread context。

    我们也说过操作系统调度线程需要随时中断线程的运行并且需要线程被暂停后可以继续运行,操作系统之所以能实现这一点,依靠的就是线程上下文信息。

    现在你应该知道哪些是线程私有的了吧。

    除此之外,剩下的都是线程间共享资源。

    那么剩下的还有什么呢?还有图中的这些。

    这其实就是进程地址空间的样子,也就是说线程共享进程地址空间中除线程上下文信息中的所有内容,意思就是说线程可以直接读取这些内容。

    接下来我们分别来看一下这些区域。

     

    代码区

    进程地址空间中的代码区,这里保存的是什么呢?从名字中有的同学可能已经猜到了,没错,这里保存的就是我们写的代码,更准确的是编译后的可执行机器指令

    那么这些机器指令又是从哪里来的呢?答案是从可执行文件中加载到内存的,可执行程序中的代码区就是用来初始化进程地址空间中的代码区的。

    线程之间共享代码区,这就意味着程序中的任何一个函数都可以放到线程中去执行,不存在某个函数只能被特定线程执行的情况

     

     数据区

    进程地址空间中的数据区,这里存放的就是所谓的全局变量。

    什么是全局变量?所谓全局变量就是那些你定义在函数之外的变量,在C语言中就像这样:

    char c; // 全局变量
    void func() {    }
    

    其中字符c就是全局变量,存放在进程地址空间中的数据区。

    在程序员运行期间,也就是run time,数据区中的全局变量有且仅有一个实例,所有的线程都可以访问到该全局变量

    值得注意的是,在C语言中还有一类特殊的“全局变量”,那就是用static关键词修饰过的变量,就像这样:

    void func(){    static int a = 10;}
    

    注意到,虽然变量a定义在函数内部,但变量a依然具有全局变量的特性,也就是说变量a放在了进程地址空间的数据区域,即使函数执行完后该变量依然存在,而普通的局部变量随着函数调用结束和函数栈帧一起被回收掉了,但这里的变量a不会被回收,因为其被放到了数据区。

    这样的变量对每个线程来说也是可见的,也就是说每个线程都可以访问到该变量。

     

    堆区

    堆区是程序员比较熟悉的,我们在C/C++中用malloc或者new出来的数据就存放在这个区域,很显然,只要知道变量的地址,也就是指针,任何一个线程都可以访问指针指向的数据,因此堆区也是线程共享的属于进程的资源。

     

    栈区

    唉,等等!刚不是说栈区是线程私有资源吗,怎么这会儿又说起栈区了?

    确实,从线程这个抽象的概念上来说,栈区是线程私有的,然而从实际的实现上看,栈区属于线程私有这一规则并没有严格遵守,这句话是什么意思?

    通常来说,注意这里的用词是通常,通常来说栈区是线程私有,既然有通常就有不通常的时候。

    不通常是因为不像进程地址空间之间的严格隔离,线程的栈区没有严格的隔离机制来保护,因此如果一个线程能拿到来自另一个线程栈帧上的指针,那么该线程就可以改变另一个线程的栈区,也就是说这些线程可以任意修改本属于另一个线程栈区中的变量。

    这从某种程度上给了程序员极大的便利,但同时,这也会导致极其难以排查到的bug。

    试想一下你的程序运行的好好的,结果某个时刻突然出问题,定位到出问题代码行后根本就排查不到原因,你当然是排查不到问题原因的,因为你的程序本来就没有任何问题,是别人的问题导致你的函数栈帧数据被写坏从而产生bug,这样的问题通常很难排查到原因,需要对整体的项目代码非常熟悉,常用的一些debug工具这时可能已经没有多大作用了。

    说了这么多,那么同学可能会问,一个线程是怎样修改本属于其它线程的数据呢?

    接下来我们用一个代码示例讲解一下。

     

    修改线程私有数据

    不要担心,以下代码足够简单:

    void thread(void* var) {
        int* p = (int*)var;
        *p = 2;
    }
    
    
    int main() {
        int a = 1;
        pthread_t tid;
        
        pthread_create(&tid, NULL, thread, (void*)&a);
        return 0;
    }
    

    这段代码是什么意思呢?

    首先我们在主线程的栈区定义了一个局部变量,也就是 int a= 1这行代码,现在我们已经知道了,局部变量a属于主线程私有数据,但是,接下来我们创建了另外一个线程。

    在新创建的这个线程中,我们将变量a的地址以参数的形式传给了新创建的线程,然后我来看一下thread函数。

    在新创建的线程中,我们获取到了变量a的指针,然后将其修改为了2,也就是这行代码,我们在新创建的线程中修改了本属于主线程的私有数据。

    现在你应该看明白了吧,尽管栈区是线程的私有数据,但由于栈区没有添加任何保护机制,一个线程的栈区对其它线程是可以见的,也就是说我们可以修改属于任何一个线程的栈区。

    就像我们上文说得到的,这给程序员带来了极大便利的同时也带来了无尽的麻烦,试想上面这段代码,如果确实是项目需要那么这样写代码无可厚非,但如果上述新创建线程是因bug修改了属于其它线程的私有数据的话,那么产生问题就很难定位了,因为bug可能距离问题暴露的这行代码已经很远了,这样的问题通常难以排查。

     

    动态链接库

    进程地址空间中除了以上讨论的这些实际上还有其它内容,还有什么呢?

    这就要从可执行程序说起了。

    什么是可执行程序呢?在Windows中就是我们熟悉的exe文件,在Linux世界中就是ELF文件,这些可以被操作系统直接运行的程序就是我们所说的可执行程序。

    那么可执行程序是怎么来的呢?

    有的同学可能会说,废话,不就是编译器生成的吗?

    实际上这个答案只答对了一半。

    假设我们的项目比较简单只有几个源码文件,编译器是怎么把这几个源代码文件转换为最终的一个可执行程序呢?

    原来,编译器在将可执行程序翻译成机器指令后,接下来还有一个重要的步骤,这就是链接,链接完成后生成的才是可执行程序。

    完成链接这一过程的就是链接器。

    其中链接器可以有两种链接方式,这就是静态链接动态链接

    静态链接的意思是说把所有的机器指令一股脑全部打包到可执行程序中,动态链接的意思是我们不把动态链接的部分打包到可执行程序,而是在可执行程序运行起来后去内存中找动态链接的那部分代码,这就是所谓的静态链接和动态链接。

    动态链接一个显而易见的好处就是可执行程序的大小会很小,就像我们在Windows下看一个exe文件可能很小,那么该exe很可能是动态链接的方式生成的

    而动态链接的部分生成的库就是我们熟悉的动态链接库,在Windows下是以DLL结尾的文件,在Linux下是以so结尾的文件。

    说了这么多,这和线程共享资源有什么关系呢?

    原来如果一个程序是动态链接生成的,那么其地址空间中有一部分包含的就是动态链接库,否则程序就运行不起来了,这一部分的地址空间也是被所有线程所共享的。

    也就是说进程中的所有线程都可以使用动态链接库中的代码。

    以上其实是关于链接这一主题的极简介绍,关于链接这一话题的详细讨论可以参考《彻底理解链接器》系列文章。

     

    文件

    最后,如果程序在运行过程中打开了一些文件,那么进程地址空间中还保存有打开的文件信息,进程打开的文件也可以被所有的线程使用,这也属于线程间的共享资源。

     

     One More Thing:TLS

    本文就这些了吗?

    实际上关于线程私有数据还有一项没有详细讲解,因为再讲下去本篇就撑爆了,而且本篇已经讲解的部分足够用了,剩下的这一点仅仅作为补充,也就是选学部分,如果你对此不感兴趣的话完全可以跳过,没有问题

    关于线程私有数据还有一项技术,那就是线程局部存储,Thread Local Storage,TLS。

    这是什么意思呢?

    其实从名字上也可以看出,所谓线程局部存储,是指存放在该区域中的变量有两个含义:

    • 存放在该区域中的变量是全局变量,所有线程都可以访问

    • 虽然看上去所有线程访问的都是同一个变量,但该全局变量独属于一个线程,一个线程对此变量的修改对其他线程不可见。

    说了这么多还是没懂有没有?没关系,接下来看完这两段代码还不懂你来打我。

    我们先来看第一段代码,不用担心,这段代码非常非常的简单:

    int a = 1; // 全局变量
    
    
    void print_a() {
        cout<<a<<endl;
    }
    
    
    void run() {
        ++a;
        print_a();
    }
    
    
    void main() {
        thread t1(run);
        t1.join();
    
    
        thread t2(run);
        t2.join();
    }
    

    怎么样,这段代码足够简单吧,上述代码是用C++11写的,我来讲解下这段代码是什么意思。

    • 首先我们创建了一个全局变量a,初始值为1

    • 其次我们创建了两个线程,每个线程对变量a加1

    • 线程的join函数表示该线程运行完毕后才继续运行接下来的代码

    那么这段代码的运行起来会打印什么呢?

    全局变量a的初始值为1,第一个线程加1后a变为2,因此会打印2;第二个线程再次加1后a变为3,因此会打印3,让我们来看一下运行结果:

    2
    3
    

    看来我们分析的没错,全局变量在两个线程分别加1后最终变为3。

    接下来我们对变量a的定义稍作修改,其它代码不做改动:

    __thread int a = 1; // 线程局部存储
    

    我们看到全局变量a前面加了一个__thread关键词用来修饰,也就是说我们告诉编译器把变量a放在线程局部存储中,那这会对程序带来哪些改变呢?

    简单运行一下就知道了:

    2
    2
    

    和你想的一样吗?有的同学可能会大吃一惊,为什么我们明明对变量a加了两次,但第二次运行为什么还是打印2而不是3呢?

    想一想这是为什么。

    原来,这就是线程局部存储的作用所在,线程t1对变量a的修改不会影响到线程t2,线程t1在将变量a加到1后变为2,但对于线程t2来说此时变量a依然是1,因此加1后依然是2。

    因此,线程局部存储可以让你使用一个独属于线程的全局变量。也就是说,虽然该变量可以被所有线程访问,但该变量在每个线程中都有一个副本,一个线程对改变量的修改不会影响到其它线程。

     

    总结

    怎么样,没想到教科书上一句简单的“线程共享进程资源”背后竟然会有这么多的知识点吧,教科书上的知识看似容易,但,并不简单

    希望本篇能对大家理解进程、线程能有多帮助。

    最后的最后,如果觉得文章对你有帮助的话,请多多分享转发在看

    关注我

    展开全文
  • Java多线程共享资源

    千次阅读 2016-11-10 21:46:00
    线程中的一个核心问题就是对共享资源的读写问题。你永远都不知道一个线程何时在运行。如果同时有多个线程对一个对象进行读写,结果就会出现脏数据接下来展示一个多线程同时对一个对象进行读写出现脏数据的案例。...

    多线程中的一个核心问题就是对共享资源的读写问题。你永远都不知道一个线程何时在运行。如果同时有多个线程对一个对象进行读写,结果就会出现脏数据

    接下来展示一个多线程同时对一个对象进行读写出现脏数据的案例。

    为了方便解耦,创建一个抽象类。

    public abstract class Ingenerator  {
    
        private volatile boolean caceled = false;
        public abstract int next();
    
        public void cacel(){
            caceled = true;
        }
        public boolean isCanceled(){
            return caceled;
        }
    
    }
    

    EvenChecker任务总是读取和测试从其相关的Ingenerator 返回的值。

    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class EvenChecker implements Runnable {
    
        private Ingenerator generator;
        public EvenChecker(Ingenerator g){
            generator = g;
        }
    
        @Override
        public void run() {
            // TODO Auto-generated method stub
            while(!generator.isCanceled()){
                int val = generator.next();
                if(val%2!=0){
                    System.out.println(val + " not even!");
                    generator.cacel();
                }
            }
    
        }
    
        public static void test(Ingenerator gp,int count){
            System.out.println("Press Control to exit");
            ExecutorService exec = Executors.newCachedThreadPool();
            for(int i = 0;i<count;i++){
                exec.execute(new EvenChecker(gp));
            }
            exec.shutdown();
        }
    
    }
    

    继承Ingenerator抽象类的next()产生偶数。

    public class EvenGenerator extends Ingenerator {
        private int currentEvenValue = 0;
    
        @Override
        public int next() {
            ++currentEvenValue;
            ++currentEvenValue;
            return currentEvenValue;
        }
    
        public static void main(String[] args) {
            EvenChecker.test(new EvenGenerator(), 10);
        }
    
    }
    

    一个线程有可能在另一个线程执行第一个++currentEvenValuede 操作之后,还没有来得及执行第二个操作之前调用了next()方法。这个时候可能就会产生一个奇数。也就是脏数据。

    基本上所有的并发模式在解决线程冲突问题的时候,都是采用序列化访问共享资源的方案。
    一个屋子只有一个浴室,多个人(多个线程)都希望能单独使用这个浴室(共享资源)。为了使用浴室,一个人先敲门,看看有没有人,如果没人的话,他就进入浴室并锁上门。等待使用浴室的人们挤在浴室门口,当锁住浴室门的那个人打开锁离开的时候,离门最近的那个人可能进入浴室,可以通过yield()和setPriority()来给线程调度器提供建议,虽然未必有用。还是取决于CPU。

    Java提供关键字synchronized的形式,来防止资源冲突。当线程执行被synchronized关键字保护的代码片段时,它将检查锁是否可用,然后获取锁,执行代码,释放锁。

    这里写图片描述

    注意,在使用并发的时候,将域(currentEvenValuede)设置为private非常重要,否则,synchronized关键字就不能阻止其它线程之间访问域。
    一个线程可以多次获得对象的锁,如果一个方法在同一对象上调用第二个方法,后者又调用同一对象上的另一个方法,就会发生这种情况。JVM负责跟踪对象被加锁的次数。如果一个对象被解锁(即锁被完全释放),其计数变为0。在线程第一次给对象加锁的时候,计数变为1.每当这个相同的线程在这个对象获得锁时,计数都会递增。显然,只有首先获得了锁的线程才能允许继续获取多个锁。每当任务离开一个synchronized方法,计数递减,当计数为0时,锁被完全释放。

    针对每个类,也有一个锁,所以synchronized static方法可以在类的范围内防止对static数据的并发访问。
    如果在你的类中有超过一个方法在处理共享资源,那么你必须同步所有相关的方法。

    使用显式的Lock对象

    Lock对象必须被显式的创建,锁定和释放。
    这里写图片描述
    当你使用synchronized关键字的时候,需要写的代码量更少,并且用户错误出现的可能性也会降低,因此通常只有在解决特殊问题时,才使用显式的Lock对象。例如,用synchronized关键字不能尝试获取锁且最终获取锁会失败,或者尝试着获取锁一段时间,然后放弃它。

    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantLock;
    
    
    public class AttemptLocking {
    
        private ReentrantLock lock = new ReentrantLock();
    
        public void untimed(){
    
            boolean captured = lock.tryLock();
            try {
                System.out.println("tryLock(): "+captured);
            } finally{
                if(captured)lock.unlock();
            }
    
        }
    
        public void timed(){
    
            boolean captured = false;
            try {
                captured = lock.tryLock(2, TimeUnit.SECONDS);
            } catch (Exception e) {
                throw new RuntimeException();
            }
    
            try {
                System.out.println("tryLock(2, TimeUnit.SECONDS):" + captured);
            } finally{
                if(captured)lock.unlock();
            }
    
        }
    
        public static void main(String[] args) {
            final AttemptLocking al = new AttemptLocking();
            al.untimed();
            al.timed();
    
            new Thread(){
                {setDaemon(true);}
                public void run() {
                    al.lock.lock();
                    System.out.println("acquired");
                };
            }.start();
    
            //通过yield()来使的后台线程和al.untimed()对al这个资源进行竞争,如果后台线程先获取到资源则把资源锁定了。
            Thread.yield();
            al.untimed();
            al.timed();
    
        }
    
    }
    

    ReentrantLock允许你尝试着获取锁,如果获取失败,那你可以决定离开去执行其它事情,而不用一直等待这个锁被释放,就像在untimed()方法中所看到的。在timed()中,做出了尝试去获取锁,该尝试可以在2秒之后失败。
    这里写图片描述

    展开全文
  • C++ 线程 共享资源保护

    千次阅读 2017-04-16 18:02:56
    一、C++互斥量 头文件介绍 Mutex 系列类(四种) - std::mutex,最基本的 Mutex 类。...使用mutex保护共享资源时,mutex应申明为全局或者静态变量。或者至少要保证两个线程使用的是同一个mutex。
  • 线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程; 同一个进程中...
  • 众所周知, 在多线程中,因为共享全局变量,会导致资源修改结果不一致,所以需要加锁来解决这个问题,保证同一时间只有一个线程资源进行操作 但是在分布式架构中,我们的服务可能会有n个实例,但线程锁只对同一个...
  • 线程之间共享哪些资源

    千次阅读 2019-04-01 18:46:44
    同一进程间的线程究竟共享哪些资源呢,而又各自独享哪些资源呢? 共享资源有: 一个。堆由于堆是在进程空间中开辟出来的,所以它是理所当然地被共享的;因此新出来的都是共享的(16位平台上分全局堆和局部堆,...
  • Java线程共享变量

    千次阅读 2019-12-04 15:16:46
    这篇文章描述两种线程共享实例变量的通用模型,一个Java线程是Thread类的实例,一个thread必须从一个thread base创建。一个thread包含一个thread base和隐藏的控制结构,隐藏的控制结构允许thread可以与其他线程并行...
  • 线程共享资源案例

    千次阅读 2017-08-31 20:13:29
    最近研究了一下多线程,主要针对于多线程共享同一资源,和多线程执行各自的资源 其实主要要就是搞清楚资源的含义:你要操作什么,什么就是线程的资源! 1.先说一下多线程执行各自的资源: 执行各自的资源从字面...
  • Java多线程如何实现资源共享

    千次阅读 2015-04-11 22:21:04
    Java实现多线程方式有两种:继承Thread类或者实现...实现Runnable接口可以实现资源共享 下面让我们来看一下代码:public class Thread1 extends Thread{ private int num = 5; @Override public void run() { for
  • 如何在线程之间共享资源

    千次阅读 2018-08-25 17:10:03
    点击“蓝字”关注Java高级部落!介绍当涉及IO读/写时,多线程可以提高应用程序性能。不幸的是,共享资源(共享变量)在每个CPU缓存中可以有不同的版本。结果是应用程序的行...
  • linux多线程间使用共享内存例程,C++版本。可用于大量数据的多线程共享
  • 操作系统--多线程之间共享哪些资源

    万次阅读 多人点赞 2018-08-21 18:23:57
    【同一进程间的线程共享资源有】 a. 堆 由于堆是在进程空间中开辟出来的,所以它是理所当然地被共享的;因此new出来的都是共享的(16位平台上分全局堆和局部堆,局部堆是独享的) b. 全局变量 它是与具体某一...
  • NULL 博文链接:https://903497571.iteye.com/blog/1869428
  • 线程共享的环境包括:进程代码段、进程的公有数据(利用这些共享的数据,线程很容易的实现相互之间的通讯)、进程打开的文件描述符、信号的处理器、进程的当前目录和进程用户ID与进程组ID。 进程拥有这许多共性的同时...
  • 线程仅仅被视为一个与其他进程共享某些资源的进程,而 是否共享地址空间几乎是进程和 Linux 中所谓线程的唯一区别 。线程创建的时候,加上了 CLONE_VM 标记,这样 线程的内存描述符 将直接指向 父进程的内存描述符 ...
  • 线程之间共享哪些资源

    万次阅读 多人点赞 2016-09-15 20:06:04
    同一进程间的线程究竟共享哪些资源呢,而又各自独享哪些资源呢? 共享资源有 a. 堆 由于堆是在进程空间中开辟出来的,所以它是理所当然地被共享的;因此new出来的都是共享的(16位平台上分全局堆和局部堆,...
  • 这也是为什么我把内存区域分为线程共享和非线程共享的原因,非线程共享的那三个区域的生命周期与所属线程相同,而线程共享的区域与JAVA程序运行的生命周期相同,所以这也是系统垃圾回收的场所只发生在线程共享的区域...
  • 线程共享的环境包括:进程代码段、进程的公有数据(利用这些共享的数据,线程很容易的实现相互之间的通讯)、进程打开的文件描述符、信号的处理器、进程的当前目录和进程用户ID与进程组ID。 非共享的包括:线程ID,...
  • 线程共享的环境包括:进程代码段、进程的共有数据(利用这些共享的数据,线程很容易的实现相互之间的通讯)、进程打开的文件描述符、信号的处理器、进程的当前目录和进程用户ID与进程组ID。进程拥有这些共性的同时,...
  • 线程之间的共享资源以及独占资源共享资源独占资源 共享资源 1、进程申请的堆内存 2、进程打开的文件描述符 3、进程的全局数据(可用于线程之间通信) 4、进程ID、进程组ID 5、进程目录 6、信号处理器 独占资源 1、线程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 468,727
精华内容 187,490
关键字:

线程共享资源

友情链接: DAC8562_STM32F407.zip