精华内容
下载资源
问答
  • 操作系统 互斥到底是什么Operating systems are mainly runs processes and applications to share resources of the system. These resources may CPU, RAM, Network Connection etc. Mutual Exclusion Object a.k....
    操作系统 互斥到底是什么

    操作系统 互斥到底是什么

    Operating systems are mainly runs processes and applications to share resources of the system. These resources may CPU, RAM, Network Connection etc. Mutual Exclusion Object a.k.a. Mutex is a program object that allows and manages multiple process and applications to share these system resources simultaneously.

    操作系统主要是运行进程和应用程序以共享系统资源。 这些资源可能包括CPU,RAM,网络连接等。互斥对象(也称为互斥对象)是一个程序对象,它允许并管理多个进程和应用程序以同时共享这些系统资源。

    示例案例 (Example Case)

    Log files are used to store information about events created by services, programs and applications. Single log file can be populated by multiple programs. If in the same time two program try to access log file and add some event this will create a collusion. This should be managed and the log file which is a resources should be shared between this programs. There are different libraries for different programming languages in order to create Mutex.

    日志文件用于存储有关服务,程序和应用程序创建的事件的信息。 单个日志文件可以由多个程序填充。 如果在同一时间两个程序尝试访问日志文件并添加一些事件,则将创建共谋。 应该对此进行管理,并且应在此程序之间共享作为资源的日志文件。 为了创建Mutex,针对不同的编程语言有不同的库。

    当互斥锁有用时 (When Mutex Is Useful)

    Following cases are where Mutex is useful.

    以下是Mutex有用的情况。

    • Writing to the single file by multiple processes.

      通过多个过程写入单个文件。
    • Reading an writing data to the network resource like network interface

      将写入数据读取到网络资源(如网络接口)
    • Web server threads writing to a file

      Web服务器线程写入文件

    临界区(Critical Section)

    Shared resource area is named as Critical Section . Critical section can be accessed by multiple Threads or applications. We can lock critical sections in case of any thread or application will access it. After the source usage is completed we can unlock the Critical Section.

    共享资源区域称为Critical Section 。 关键部分可以由多个线程或应用程序访问。 我们可以锁定关键部分,以防任何线程或应用程序访问它。 在完成源使用后,我们可以解锁关键部分。

    比赛条件 (Race Condition)

    We have learned Critical Section in previous part. If two process thread try to access same resource in the same time and try to change in the same time this will create a Race Condition . Two or more process thread will create a race to access to the same resource.

    我们已经在上一部分中学习了临界部分。 如果两个进程线程试图同时访问同一资源并试图同时进行更改,这将创建Race Condition 。 两个或多个进程线程将创建争用访问同一资源的竞争。

    C#Mutex示例 (C# Mutex Example)

    In this part we will look a C# program which uses Mutex order to manage object access by locking the object.

    在这一部分中,我们将看一个C#程序,该程序使用互斥锁命令通过锁定对象来管理对象访问。

    private static readonly Object instanceLock = new Object();
    private static MySingleton instance;
    public static MySingleton Instance
    {
        lock(instanceLock)
        {
            if(instance == null)
            {
                instance = new MySingleton();
            }
            return instance;
        }
    }
    

    Java Mutex示例 (Java Mutex Example)

    Here is a Java Mutex examaple.

    这是Java Mutex示例。

    try {
      mutex.acquire();
      try {
        // do something
      } finally {
        mutex.release();
      }
    } catch(InterruptedException ie) {
      // ...
    }
    

    翻译自: https://www.poftut.com/what-is-mutex-exclusion-in-operating-systems/

    操作系统 互斥到底是什么

    展开全文
  • 进程之间的这种相互制约的关系成为进程互斥。 并发进程在一些关键点上可能需要互相等待与互通消息,这种相互制约的等待与互通信息称为进程同步。 实际上进程互斥也是一种同步,他协调多个进程互斥进入同一个临界...

    在操作系统中,当某一进程正在访问某一存储区域时,就不允许其他进程进行读写或者修改该存储区的内容,否则就会发生后果无法估计的错误。进程之间的这种相互制约的关系成为进程互斥。

    并发进程在一些关键点上可能需要互相等待与互通消息,这种相互制约的等待与互通信息称为进程同步。

    实际上进程互斥也是一种同步,他协调多个进程互斥进入同一个临界资源对应的临界区。

    转载于:https://www.cnblogs.com/luo841997665/p/4664854.html

    展开全文
  • 什么是互斥

    2021-03-29 22:44:05
    互斥锁是什么互斥锁: 对共享数据进行锁定,保证同一时刻只能有一个线程去操作。 注意: 互斥锁是多个线程一起去抢,抢到锁的线程先执行,没有抢到锁的线程需要等待,等互斥锁使用完释放后,其它等待的线程再去抢...

    互斥锁是什么?

    互斥锁: 对共享数据进行锁定,保证同一时刻只能有一个线程去操作。

    注意: 互斥锁是多个线程一起去抢,抢到锁的线程先执行,没有抢到锁的线程需要等待,等互斥锁使用完释放后,其它等待的线程再去抢这个锁。

     

    互斥锁的使用

    threading模块中定义了Lock变量,这个变量本质上是一个函数,通过调用这个函数可以获取一把互斥锁。

    import threading
    g_num=0
    lock=threading.Lock()
    #循环100万次执行的任务
    def task1():
        # 上锁
        lock.acquire()
        for i in range(2000000):
            global g_num #声明修改全局变量的内存地址
            g_num=g_num+1
        print("task1",g_num)
        #释放锁
        lock.release()
    
    
    #循环100万次执行的任务
    def task2():
        # 上锁
        lock.acquire()
        for i in range(1000000):
            global g_num #声明修改全局变量的内存地址
            g_num=g_num+1
        print("task2",g_num)
        # 释放锁
        lock.release()
    
    if __name__=='__main__':
        first_threat=threading.Thread(target=task1)
        second_threat = threading.Thread(target=task2)
        first_threat.start()
        second_threat.start()
    
    #互斥锁可以保证同意时刻只有一个线程会执行代码,能够保证全局变量的数据没有问题
    #线程等待把互斥锁都是把多任务改成单任务去执行,保证了数据的准确性,但是执行性能会下降
    
    
    #输出结果
    task1 2000000
    task2 3000000

    注意点:

    • acquire和release方法之间的代码同一时刻只能有一个线程去操作
    • 如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁,那么此时acquire方法会堵塞,直到这个互斥锁释放后才能再次上锁。

     

     小结

    • 互斥锁的作用就是保证同一时刻只能有一个线程去操作共享数据,保证共享数据不会出现错误问题
    • 使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行
    • 使用互斥锁会影响代码的执行效率,多任务改成了单任务执行
    • 互斥锁如果没有使用好容易出现死锁的情况

     

    展开全文
  • 在前面两篇中介绍了线程的基本概念和线程控制 今天来看一下线程之间的同步和互斥关系 互斥关系 线程之间的互斥关系 对于一块临界资源,同一时间只能有一个线程进行访问,对于之前学习的进程间通信中讲的管道...

    在前面两篇中介绍了线程的基本概念和线程控制
    今天来看一下线程之间的同步和互斥关系

    互斥关系

    线程之间的互斥关系


    对于一块临界资源,同一时间只能有一个线程进行访问,对于之前学习的进程间通信中讲的管道和消息队列,均内置的互斥同步机制。

    大部分情况下,线程使用的函数都是全局的,如果这样的话,就可能发生当一个线程正在访问一资源时,另外一个线程也来访问该资源,此时就可能发生逻辑错误。经典场景即使售票机制。

    #include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <unistd.h>
    
    
    //************购票问题
    
    int ticket=10;
    pthread_mutex_t mutex;
    
    void * Entry(void * arg)
    {
      (void)arg;
      while(1)
      {
        if(ticket>0)//如果还有票。就执行买票,票数减一
        {
          ticket--;
          printf("ticket:%d\n",ticket);
        }
        else//没有票就退出
        {
          break;
        }
        sleep(1);
      }
      return NULL;
    }
    void test()
    {
      pthread_t thread[10];
      //创建线程
      int i=0;
      for(i=0;i<10;i++)
      {
        pthread_create(&thread[i],NULL,Entry,NULL);
      }
      //进行线程等待
      for(i=0;i<10;i++)
      {
        pthread_join(thread[i],NULL);
    
      }
    }
    
    int main()
    {
      test();
      return 0;
    
    }
    

    利用互斥量来解决上面的问题,保证每次判断票数不为0 和票数减一这两个操作为原子操作。即对访问临临界资源的那段代码进行上锁。

    mutex 互斥量

    基于cpu中实现了将寄存器中的值和内存中的值交换的原子操作

    #include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <unistd.h>
    
    //进程间互斥关系
    //购票问题
    
    int ticket=10;
    pthread_mutex_t mutex;
    
    void * Entry(void * arg)
    {
      (void)arg;
      while(1)
      {
        //获取互斥锁,保证下面的操作一次全部执行完(原子操作)
        pthread_mutex_lock(&mutex);
        if(ticket>0)
        {
          ticket--;
          printf("ticket:%d\n",ticket);
        }
        else
        {
          break;
        }
        pthread_mutex_unlock(&mutex);
        //释放互斥锁,保证其他线程可以进行访问
        sleep(1);
      }
      return NULL;
    }
    
    void test()
    {
      pthread_t thread_1,thread_2;
    
      //初始化互斥量
      pthread_mutex_init(&mutex,NULL);
      //创建两个线程
      pthread_create(&thread_1,NULL,Entry,NULL);
      pthread_create(&thread_2,NULL,Entry,NULL);
      //进行线程等待
      pthread_join(thread_1,NULL);
      pthread_join(thread_2,NULL);
      //销毁互斥量
      pthread_mutex_destroy(&mutex);
    }
    
    int main()
    {
      test();
      return 0;
    }
    

    执行结果

    同步关系

    线程之间的同步关系


    为了完成同以目标,需要线程之间按照一定是顺序来执行,不仅是为了保证正确性,也是为了提高效率。

    条件变量

    在linux 操作系统下实现了用条件变量实现进程间同步关系
    这里用球员之间传球和投篮之间的同步关系来说明

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <pthread.h>
    
    
    //************简单同步问题***********************
    //投篮和传球·
    
    pthread_cond_t g_cond;//条件变量
    pthread_mutex_t mutex;//互斥量
    
    void * Pass(void * arg)
    {
      (void )arg;
      while(1)
      {
        pthread_cond_wait(&g_cond,&mutex);//等待投篮的人
        printf("传球\n");
        sleep(1);
      }
      return NULL;
    }
    
    void * Shoot(void * arg)
    {
      (void )arg;
      while(1)
      {
        printf("投篮\n");
        sleep(1);
        pthread_cond_signal(&g_cond);//告知传球的人可以进行传球了
        sleep(2);
      }
      return NULL;
    }
    
    
    void test()
    {
      //初始化互斥量
      pthread_mutex_init(&mutex,NULL);
      //初始化条件变量
      pthread_cond_init(&g_cond,NULL);
    
      pthread_t thread_1,thread_2;
      //创建两个线程,分别完成传球和投篮任务
      pthread_create(&thread_1,NULL,Shoot,NULL);
      pthread_create(&thread_2,NULL,Pass,NULL);
    
      //进行线程等待
      pthread_join(thread_1,NULL);
      pthread_join(thread_2,NULL);
      //销毁互斥量
      pthread_mutex_destroy(&mutex);
      //销毁条件变量
      pthread_cond_destroy(&g_cond);
    }
    
    
    int main()
    {
      test();
      return 0;
    }
    

    若想更深入了了解同步互斥问题
    可以参考一下:
    经典互斥问题—生产者消费者模型
    经典同步问题—读者写着模型

    什么是死锁

    在我们解决互斥问题时,我们会在临界区加上锁,那么就会存在这样的问题,当一个线程已经获取了锁,还没有进行释放该锁,又尝试获取再次获取锁,很明显这把锁已经被自己占用了,还没有来的及释放,再次获取锁时一定会阻塞,直到等到锁,那么,既不能释放拥有的锁,也不可获得当前的锁,该线程就会一直阻塞,我们称类似于这种状态为死锁状态。
    造成死锁的原因

    进程没有及时的释放锁
    1. 一个进程尝试获取两次锁
    2. 尝试交叉式获取锁,n个进程n把锁,都尝试获取对方的锁(哲学家就餐问题)

    线程安全函数

    线程安全函数:多个线程调用该函数不会出现任何逻辑错误

    之前我们讲过,可重入函数可重入函数
    可重入函数:在不同的执行流中调用该函数不会出现逻辑错误
    这里的不同执行流,不仅包含线程,还包含信号处理函数,所以可重入函数要求更严格
    可重入函数一定是线程安全函数
    线程安全函数不一定是可重入的
    一个线程安全但不可重入的例子

    #include <stdio.h>
    #include <signal.h>
    #include <pthread.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    //定义一个全局的互斥量
    pthread_mutex_t mutex;
    //定义一个全局的变量
    int count = 5;
    
    
    
    //下面的函数是线程安全函数,但不是可重入函数
    void pthread_security_function()
    {
      while(1)
      {
        //上锁
        pthread_mutex_lock(&mutex);
        if(count < 0)
        {
          exit(1);
        }
        sleep(3);
        printf("count: %d\n",count);
        sleep(1);
        count--;
        //解锁
        pthread_mutex_unlock(&mutex);
      }
    }
    
    
    //线程入口函数
    void * Entry(void * arg)
    {
      (void)arg;
      pthread_security_function();
      return NULL;
    }
    
    
    //信号处理函数
    void sig_entry(int sig)
    {
      //在信号处理函数中进行调用一个线程安全函数
      (void)sig; 
      pthread_security_function();
    }
    
    
    
    void test()
    {
      //对互斥量进行初始化
      pthread_mutex_init(&mutex,NULL);
    
      //信号捕捉
      signal(SIGINT,sig_entry);
    
      //创建线程
      pthread_t tid_1,tid_2;
      pthread_create(&tid_1,NULL,Entry,NULL);
      pthread_create(&tid_2,NULL,Entry,NULL);
    
      //线程等待
      pthread_join(tid_1,NULL);
      pthread_join(tid_2,NULL);
    
      //销毁互斥量
      pthread_mutex_destroy(&mutex);
    
    
    }
    
    
    int main()
    {
      test();
      return 0;
    }
    

    执行结果:
    执行结果

    展开全文
  • 信号量可以被计数,而互斥量只能算到1。假设你有一个接受客户端连接的线程正在运行。 这个线程可以同时处理10个客户端。 然后每个新的客户端设置信号量,直到它达到10.当信号量有10个标志,那么你的线程将不会接受新...
  • 什么是线程互斥

    2015-05-05 20:58:22
    线程之间通信的两个基本问题是互斥和同步 线程同步是指线程之间具有的一种制约关系,一个线程的执行依赖另一个线程的消息,当它没有得到另一个线程的消息时应等待,直到消息到达时才被唤醒 线程互斥是指对于共享的...
  • 什么是同步?什么是互斥

    千次阅读 2018-09-29 19:55:45
    现代操作系统基本都是多任务操作系统,即同时有大量可调度实体在运行。在多任务操作系统中,同时运行的多个任务可能: ...互斥:是指散步在不同任务之间的若干程序片断,当某个任务运行其中一个...
  • 互斥锁的概念及使用

    千次阅读 多人点赞 2020-03-03 10:57:33
    文章目录互斥锁的概念及使用互斥锁解决多线程代码示例 在上一篇博客中我们提到多线程共享同一个资源,怎么解决多个线程之间共享同一个共享资源,是多线程编程需要考虑的一个问题!本章将会对此问题做出解答!首先...
  • 互斥信号量概念及其应用: 一,互斥信号定义: 在要被抢走时,把低优先级任务抬高。这样就解决了优先级翻转问题。 二值信号量用于信号同步: 互斥锁: 二,FreeRTOS互斥信号量介绍: 互斥信号量包括:普通互斥...
  • 互斥概念

    2006-08-06 14:05:00
    互斥的几种实现方式:一,忙等待互斥1,禁止中断2,锁变量3,严格的轮换4,peterson算法5,Tsl忙等待存在着各种各样的问题,一个最大的问题使消耗cpu,另外容器产生各种错误。而且还可能出现优先级反转问题,所以忙等待并...
  • 互斥对象的概念

    2014-07-12 14:18:19
    互斥对象 如何控制好多个线程相互之间的联系,不产生冲突和重复,这需要用到互斥对象,即:System.Threading 命名空间中的 Mutex 类。 我们可以把Mutex看作一个出租车,乘客看作线程。乘客首先等车,然后...
  • 1 互斥锁解决资源竞争-重点 1.1 资源竞争产生原因: ​ 1 多线程共享全局资源 ​ 2 多个线程不加限制随意访问全局资源 产生竞争 导致数据错误 1.2 互斥锁使用 ​ 加互斥锁(保证任意时刻只有一个线程能够占有锁) ​ 1 ...
  • 同步和互斥什么联系和区别

    千次阅读 2018-07-07 09:22:03
    同步和互斥什么联系和区别区别:互斥:是指三部在不同进程之间的若干程序片断,当某个进程运行其中一个程序片段时,其它进程就不能运行它们之中的任一程序片段,只能等到该进程运行完这个程序片段后才可以运行。...
  • C/C++的互斥器Mutex是什么,求初步介绍: 今天重新看了EFFCETIVE C++,那个互斥器是什么东东,多线程编程怎么用?
  • 互斥对象有利于实现多线程中数据的线程安全。 线程调用锁函数来获得互斥对象的所有权,调用对应的解锁函数来放弃所有权...BasicLockable概念 BasicLockable是独占模型。 满足这个模型的对象需要实现两个接口 ...
  • 线程互斥

    2021-05-03 15:37:09
    线程互斥什么会有线程互斥互斥量mutex抢票问题互斥量实现原理总结可重入和线程安全概念常见的线程不安全的情况常见的线程安全情况常见的不可重入的情况常见的可重入的情况可重入与线程安全联系可重入与线程安全...
  • 互斥

    2020-04-22 23:58:25
    1.互斥锁的概念 互斥锁: 对共享数据进行锁定,保证同一时刻只能有一个线程去操作。 注意: 互斥锁是多个线程一起去抢,抢到锁的线程先执行,没有抢到锁的线程需要等待,等互斥锁使用完释放后,其它等待的线程再去抢这...
  • linux 同步 互斥 概念

    2012-02-13 09:34:04
    相交进程之间的关系主要有两种,同步与互斥。所谓互斥,是指散步在不同进程之间的若干程序片断,当某个进程运行其中一个程序片段时,其它进程就不能运行它 们之中的任一程序片段,只能等到该进程运行完这个程序片段...
  • 在使用boost库实现线程同步之前,我们先了解一下下面的概念: 对于互斥可以这样理解,线程A和线程B互斥访问某个资源则它们之间就会产个顺序问题——要么线程A等待线程B操作完毕,要么线程B等待线程操作完毕,这其实...
  • 本文主要讲述了操作系统中同步和互斥这两个概念,并说明了操作系统中是如何实现同步和互斥的。除此之外,本文还重点讲述了线程和进程的概念
  • 互斥锁的概念和使用方法。

    千次阅读 2014-04-16 16:18:35
    在单线程条件下,由于对数据操作,在同样的时间下,只有一个线程来操作。所以不用担心数据的同步问题。现代的操作系统,大都提供并发机制,虽然有时候是表面的并发。...1互斥概念互斥锁提供一个可以在同一时间
  • 文章目录前言同步和互斥锁 前言 在linux操作系统下。线程实际上上是应用层的进程。 同步和互斥

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,256
精华内容 43,702
关键字:

互斥是什么概念