Question

以下是代码

的示例

#define MAX PROCESSES 255
int number_of_processes = 0;

/* the implementation of fork() calls this function */

int allocate process() 
{
    int new pid;
    if (number_of_processes == MAX PROCESSES)
        return -1;
    else {
    /* allocate necessary process resources */
        ++number_of_processes;
        return new pid;
    }
}

/* the implementation of exit() calls this function */
void release process()
{
    /* release process resources */
    --number_of_processes;
}

我知道竞争条件是number_of_processes。我想了解种族情况。我的问题是，如果我有一个带有acquire（）和release（）操作的互斥锁，我可以在哪里放置锁以避免竞争条件。我刚刚开始阅读有关进程同步的内容并且非常有趣。也可以使用原子整数，例如atomic_t number_of_processes而不是int number_of_processes。我知道原子整数用于避免上下文切换但不确定但是可能吗？

Answer 1

考虑以这种方式更改代码，对于互斥锁：

#define MAX PROCESSES 255
int number_of_processes = 0;

/* the implementation of fork() calls this function */

int allocate_process() 
{
    try {
        lock.acquire();
        int new pid;
        if (number_of_processes == MAX PROCESSES)
            return -1;
        else {
            /* allocate necessary process resources */
            ++number_of_processes;
            return new pid;
        }
    } finally {
        lock.release();
    }
}

/* the implementation of exit() calls this function */
void release_process()
{
    try {
        lock.acquire();
        /* release process resources */
        --number_of_processes;
    } finally {
        lock.release();
    }
}

我使用Java中的try / finally语法，对于C ++可能略有不同。

重新定位原子整数 - 用int简单替换atomic_t将无济于事，因为number_of_processes中有allocate_process的两个操作，因此整个操作不是原子操作

在竞争条件下需要帮助

1 个答案: