Question

所以，我正在我的一个班级中学习一个调度程序。基本上，我们假装一次只能执行一个线程。我们应该使用信号量类来允许这些线程阻塞自己来模拟等待CPU的线程。

问题是，线程似乎在错误的时间阻塞并在错误的时间执行。我想知道我是否缺少对信号量的概念性理解以及如何实现它。我想知道我是否可以得到一些关于我的实施的反馈。教师提供了这个头文件，我没有以任何方式修改过：

class Semaphore {
private:
  int             value;
  pthread_mutex_t m;
  pthread_cond_t  c;

public:

  /* -- CONSTRUCTOR/DESTRUCTOR */

  Semaphore(int _val);

  //~Semaphore();

  /* -- SEMAPHORE OPERATIONS */

  int P();
  int V();
};

这是我使用posix的实现：

Semaphore::Semaphore(int _val){
    value = _val;
    c = PTHREAD_COND_INITIALIZER;
    m = PTHREAD_MUTEX_INITIALIZER;
}

int Semaphore::P(){
    if(value <= 0){
        pthread_cond_wait(&c, &m);
    }
    value--;
}

int Semaphore::V(){
    value++;
    if(value > 0){
        pthread_cond_signal(&c);
    }
}

Answer 1

您忽略了锁定互斥锁。

其次，你在这里有一个计数信号量，而不是二进制信号量。二进制信号量只有两个状态，因此bool变量是合适的：

class Semaphore {
private:
  bool            signaled;   // <- changed
  pthread_mutex_t m;
  pthread_cond_t  c;

  void Lock() { pthread_mutex_lock(&m); }          // <- helper inlines added
  void Unlock() { pthread_mutex_unlock(&m); }
public:

  /* -- CONSTRUCTOR/DESTRUCTOR */

  Semaphore(bool);

  //~Semaphore();

  /* -- SEMAPHORE OPERATIONS */

  void P();   // changed to void: you don't return anything
  void V();
};

默认地将Impl：

// consider using C++ constructor initializer syntax.

Semaphore::Semaphore(bool s){        // don't use leading underscores on identifiers
    signaled = s;
    c = PTHREAD_COND_INITIALIZER;    // Not sure you can use the initializers this way!
    m = PTHREAD_MUTEX_INITIALIZER;   // they are for static objects.

    // pthread_mutex_init(&m); // look, this is shorter!
}

void Semaphore::P(){
    Lock();              // added
    while (!signaled){   // this must be a loop, not if!
        pthread_cond_wait(&c, &m);
    }
    signaled = false;
    Unlock();
}

void Semaphore::V(){
    bool previously_signaled;
    Lock();
    previusly_signaled = signaled; 
    signaled = true;
    Unlock();  // always release the mutex before signaling
    if (!previously_signaled)
      pthread_cond_signal(&c); // this may be an expensive kernel op, so don't hold mutex
}

Answer 2

您的计数信号量算法缺少while循环，并且不必要地发出信号量信号。

原始逻辑，添加了锁（参见其他答案）：

int Semaphore::P(){
    Lock();
    if(value <= 0){
        pthread_cond_wait(&c, &m);
    }
    value--;
    Unlock();
}

int Semaphore::V(){
    Lock();
    value++;
    if(value > 0){
       pthread_cond_signal(&c);
    }
    Unlock(); 
}

正确的方法：

int Semaphore::P(){
    Lock();
    while (value <= 0){   // not if
        pthread_cond_wait(&c, &m);
    }
    // value is now > 0, guaranteed by while loop
    value--;
    // value is now >= 0
    Unlock();
}

int Semaphore::V(){
    Lock();
    int prior_value = value++;
    Unlock();

    // E.g. if prior_value is 50, should we signal? Why?

    if (prior_value == 0) // was not signaled previously, now is.
        pthread_cond_signal(&c);
}

为了提高效率，请收集有关是否在互斥锁内发出信号的信息，然后在互斥锁外部执行信号。互斥体应该尽可能少地保留机器指令，因为它们会增加争用，从而降低并发性。信号操作可能需要数百个周期（内核跳转到等待队列操作）。

在等待条件变量时必须使用循环，因为可能会出现虚假的唤醒。此外，如果您在互斥锁之外发出信号，则状态信号并不总是转到“预期”线程。在unlock和signal之间，某些线程可以潜入并调用P并减少互斥量。然后在条件上醒来的那个必须重新评估测试，否则它将不正确地进行。

在C ++中实现二进制信号量类

2 个答案: