使用互斥操作和原语实现信号量

Question

前段时间面试，被要求实施 仅使用互斥操作和原语的信号量 （他允许 int 被认为是原子的）。我在下面提供了解决方案。 他不喜欢忙碌/等待部分——while (count >= size) {}——并要求通过使用更原始的方式来实现锁定 类型和互斥锁。我没有设法提供改进的解决方案。 有什么想法可以做到吗？

struct Semaphore {
int size;
atomic<int> count;
mutex updateMutex;

Semaphore(int n) : size(n) { count.store(0); }

void aquire() {
    while (1) {
        while (count >= size) {}
        updateMutex.lock();
        if (count >= size) {
            updateMutex.unlock();
            continue;
        }
        ++count;
        updateMutex.unlock();
        break;
    }
}

void release() {
    updateMutex.lock();
    if (count > 0) {
        --count;
    } // else log err
    updateMutex.unlock();
}
};

Answer 1

我敢打赌，如果没有繁忙循环仅使用互斥锁，这是不可能实现的。

如果不是忙循环，你必须在某个地方阻塞。您拥有的唯一阻塞原语是 互斥体。因此，当信号量计数器为零时，您必须阻止某些互斥锁。您只能被该互斥体的单一所有者唤醒。但是，您应该在任意线程向信号量返回计数器时唤醒。

现在，如果允许使用条件变量，情况就完全不同了。

Answer 2

正如@chill 指出的那样，我在这里写下的解决方案将不起作用，因为锁具有唯一的所有权。我猜你最终会恢复到忙等待（如果你不允许使用条件变量）。如果 ppl，我把它留在这里。有同样的想法，他们认为这不起作用；）

struct Semaphore {
int size;
atomic<int> count;
mutex protection;
mutex wait;

Semaphore(int n) : size(n) { count.store(0); }

void aquire() {
    protection.lock();
    --count;
    if (count < -1) {
        protection.unlock();
        wait.lock();
    }
    protection.unlock();
}

void release() {
    protection.lock();
    ++count;
    if (count > 0) {
        wait.unlock();
    }
    protection.unlock();
}
};

Answer 3

编辑 - 使用第二个互斥体代替线程进行排队

由于互斥体已经有适当的线程支持，它可以用来对线程进行排队（而不是像我第一次尝试那样显式地这样做）。 除非互斥锁只允许所有者解锁它（一个锁？），那么这个解决方案不起作用。

我在搜索时遇到的Anthony Howe's pdf 中找到了解决方案。还有另外两种解决方案。我更改了名称以使这个示例更有意义。

或多或少的伪代码：

Semaphore{
    int n;
    mutex* m_count;         //unlocked initially
    mutex* m_queue;         //locked initially
};

void wait(){
    m_count.lock();
    n = n-1;
    if(n < 0){
        m_count.unlock();
        m_queue.lock();     //wait
    }
    m_count.unlock();       //unlock signal's lock
}

void signal(){
    m_count.lock();
    n = n+1;

    if(n <= 0){
        m_queue.unlock();   //leave m_count locked
    }
    else{
        m_count.unlock();
    }
}

Answer 4

确实如此，因为从技术上讲，您的代码中的某些部分需要更多处理时间并且不需要存在。 1-您使用了原子数据类型atomic<int> count;，只要递增和递减被updateMutex.lock();代码锁定，这将花费更多时间来执行并且无用，因此在锁定状态期间没有其他线程可以更改它。

2- 你放了while (count >= size) {}，这也是没用的，因为你在 spinlock 语句之后再次检查了count，这是必要的，这里很重要，但这个不是。 "请记住，当互斥锁被另一个线程占用时，自旋锁是一个 while(1)。

如果你决定使用int count; 和一些编译器的优化，计数值不会改变，所以你需要使用 volatile。 最后，让我以更高效的方式重写您的代码。

struct Semaphore {
int size;
volatile int count;
mutex updateMutex;

Semaphore(int n) : size(n), count(0) {}

void aquire() {
    while (1) {
        updateMutex.lock();
        if (count >= size) {
            updateMutex.unlock();
            continue;
        }
        ++count;
        updateMutex.unlock();
        break;
    }
}

void release() {
    updateMutex.lock();
    if (count > 0) {
        --count;
    } // else log err
    updateMutex.unlock();
    }

 };

Answer 5

让我试试这个

`

# number of threads/workers
w = 10
# maximum concurrency
cr = 5
r_mutex = mutex()
w_mutex = [mutex() for x in range(w)]

# assuming mutex can be locked and unlocked by anyone 
# (essentially we need a binary semaphore)

def acquire(id):

    r_mutex.lock()
    cr -= 1
    # r_mutex.unlock()
    
    # if exceeding maximum concurrency
    if cr < 0:
        # lock twice to be waken up by someone
        w_mutex[id].lock()
        r_mutex.unlock()
        w_mutex[id].lock()
        w_mutex[id].unlock()
        return

    r_mutex.unlock()

    
    
       
def release(id):

    r_mutex.lock()
    cr += 1
    # someone must be waiting if cr < 0
    if cr <= 0:
        # maybe you can do this in a random order
        for w in w_mutex:
            if w.is_locked():
                w.unlock()
                break
    r_mutex.unlock()

`