相关疑难解决方法(0)

我听说过这些与并发编程有关的词,但它们之间的区别是什么？

我是多线程的新手,并试图了解互斥锁的工作原理.很多谷歌和我找到了一个体面的教程,但它仍然有一些怀疑它是如何工作的,因为我创建了自己的程序,其中锁定不起作用.

互斥体的一个绝对非直观的语法是pthread_mutex_lock( &mutex1 );,当看起来互斥锁被锁定时,我真正想要锁定的是其他变量.这种语法是否意味着锁定互斥锁会锁定代码区域,直到互斥锁被解锁？然后线程如何知道该区域被锁定？[ 更新:线程知道该区域被 内存屏蔽锁定 ].这种现象应该被称为临界区吗？[ 更新:关键部分对象仅在Windows中可用,其中对象比互斥锁更快,并且仅对实现它的线程可见.否则,临界区只是指由互斥锁保护的代码区域 ]

简而言之,您能否帮助解决最简单的互斥示例程序以及关于它如何工作的逻辑的最简单的解释？我相信这会帮助很多其他新手.

我们何时应该使用互斥锁？什么时候应该使用信号量？

我确定互斥是不够的,这就是条件变量概念存在的原因; 但它打败了我,当一个条件变量必不可少时,我无法用一个具体的场景来说服自己.

条件变量,互斥锁和锁定问题的接受答案之间的区别是条件变量是a

锁定"信号"机制.当线程需要等待资源变得可用时使用它.线程可以在CV上"等待",然后资源生成器可以"发出信号"变量,在这种情况下,等待CV的线程会得到通知并可以继续执行

我感到困惑的是,一个线程也可以在互斥锁上等待,当它被发出信号时,只是意味着该变量现在可用,为什么我需要一个条件变量？

PS:此外,无论如何,需要一个互斥锁来保护条件变量,当我的视力更加偏向于看不到条件变量的目的时.

这是一个面试问题.

是否可以在Linux/UNIX上的多处理案例中使用互斥？

我的想法:不,不同的进程有独立的内存空间.

mutex仅用于多线程.

信号量用于多处理以进行同步.

对 ？

欢迎任何评论.

谢谢

天真的问题......

我之前读过 - " 只有通过锁定它的线程才能解锁MUTEX. "

但是我写了一个程序,其中THREAD1锁定了mutexVar并进入睡眠状态.然后THREAD2可以直接解锁mutexVar做一些操作并返回.

==>我知道每个人都说我为什么这样做？但我的问题是 - 这是MUTEX的正确行为吗？

==>添加示例代码

void *functionC()
{
   pthread_mutex_lock( &mutex1 );
   counter++;
   sleep(10);
   printf("Thread01: Counter value: %d\n",counter);
   pthread_mutex_unlock( &mutex1 );
}

void *functionD()
{
   pthread_mutex_unlock( &mutex1 );
   pthread_mutex_lock( &mutex1 );
   counter=10;
   printf("Counter value: %d\n",counter);
}

int main()
{
   int rc1, rc2;
   pthread_t thread1, thread2;

   if(pthread_mutex_init(&mutex1, NULL))
   printf("Error while using pthread_mutex_init\n");

   if( (rc1=pthread_create( &thread1, NULL, &functionC, NULL)) )
   {   
      printf("Thread creation failed: %d\n", rc1);
   }   

   if( (rc2=pthread_create( &thread2, NULL, &functionD, NULL)) …

对于OS类,我当前必须在linux内核中创建一个线程安全队列,该队列使用系统调用进行交互.

现在对于关键部分,我的直觉是我想要使用标题中的mutex_lock和mutex_unlock函数mutex.h.但是,有人告诉我,我可以改用二进制信号与down_interruptible和up的semaphore.h头,并且它会更好.

我已经阅读了二进制信号量和互斥量之间的区别:从中我了解到,互斥体的主要优点是它强制执行所有权的强度,以及信号量的优势在于,因为它不强制实施所有权,所以您可以使用它作为两个(多个？)不同线程之间的同步机制.

我的问题是二进制信号量的优点是什么,如果你以与互斥量完全相同的方式使用它.如果我写的话更明确:

down()
/* critical */
up()

就像我一样

mutex_lock()
/* critical */
mutex_unlock()

是否有一些性能优势,因为它不如互斥锁安全？我错过了什么吗？

如果你想要更多的上下文(这是我的第一个C proj),这里有一小段我想要线程安全的代码片段:

#define MESSAGE_MAX_SIZE 512

typedef struct list_head list_node;

/* Create message struct */
typedef struct {
  size_t size;
  list_node node;
  char data[MESSAGE_MAX_SIZE];
} Message;

/* Create the linked list queue with dummy head */
struct {
  size_t size;
  list_node head;
} my_q = { 0, LIST_HEAD_INIT(my_q.head) };

/*
  Adds …

我正在阅读有关互斥,信号量和关键部分的内容.我理解mutex同步一个资源,这样只有一个线程在一个信号量允许特定的线程没有线程访问资源时访问它,但关键部分做了什么？

我们正在多线程python环境中工作，需要相互排斥的一段代码，例如：

lock = threading.Lock()
with lock:
    # get data from shared storage
    # process
    # put back to shared storage

目前，在我看来，二进制信号量threading.Semaphore()和锁定threading.Lock() 将类似地用于此目的。如果我从锁定切换到二进制信号量，反之亦然，会有一些陷阱或收获吗？

注意：代码在greenthreads中运行（如果这会改变情况）

这主要是关于对这个概念的理解,这让我很困惑.

Mutex意味着一个线程控制共享资源的访问,执行操作并解锁它,然后只有其他线程可以获得锁定权限

而二进制信号量就像一个线程可以访问共享资源但获得对锁的访问权限,而另一个线程可以解锁它

在我在这里看到的最后一个问题,有人提到过"semaphores are more suitable for some synchronization problems like producer-consumer".

我的问题是,例如,如果生产者线程已获得锁定并用数据填充一些队列,而消费者同时解锁它,是不是有任何并发​​问题？

我正在阅读二进制信号量和互斥量之间的差异（二进制信号量和互斥量之间的差异），我想验证的一件事是，当任务锁定（获取）互斥量时，它只能解锁（释放）它。如果另一个任务试图解锁一个尚未锁定的互斥锁（因此不拥有该互斥锁），则会遇到错误情况，最重要的是，互斥锁未解锁，为此我在c ++ 14的代码下面创建了该互斥锁：

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
using namespace std;

int counter;
int i;
std::mutex g_pages_mutex;
void increment()
{
    std::cout<<"increment...."<<std::endl;    
    g_pages_mutex.lock();
    bool flag = g_pages_mutex.try_lock();
    std::cout<<"increment Return value is "<<flag<<std::endl;
    counter++;
    std::this_thread::sleep_for(5s);
}
void increment1()
{
    std::this_thread::sleep_for(5s);    
    std::cout<<"increment1...."<<std::endl;       
    g_pages_mutex.unlock();    
    counter++;
    bool flag = g_pages_mutex.try_lock();
    std::cout<<"increment1 Return value is "<<flag<<std::endl;
}
int main()
{
    counter = 0;
    std::thread t(increment);
    std::thread t1(increment1);
    t.join();
    t1.join();
    return 0;
}

但是，在此示例中，我能够从不拥有该线程的线程中解锁互斥锁，因此只希望有一些理解上的差距，还是在c ++ 14 std :: mutex中存在此问题？