当两个信号量同时变化并且两者之一不能立即减少时会发生什么？

问题描述

考虑这个代码：

struct sembuf s_op[2];

s_op[0].sem_num = old;
s_op[0].sem_op = 1;
s_op[0].sem_flg = 0;
s_op[1].sem_num = new;
s_op[1].sem_op = -1;
s_op[1].sem_flg = 0;
semop(semid,s_op,2);

现在，如果“new”不能立即递减（因为它已经是0了），会不会有一个时间间隔，“旧”信号量增加而“新”信号量没有增加？我的意思是，这总是原子地发生吗？

解决方法

是否会存在“旧”信号量增加而“新”信号量没有增加的时间间隔？

这是一个实现细节。实现可以检查操作是否可行，然后进行操作，或者一个接一个地进行操作，如果一个操作不能完成，则返回已经完成的操作。或者实现可能根本不做任何事情，直到下一个 sem* 操作然后查询操作，等等。底部是无论哪种方式，只有 observable 状态才是重要的，并且任何进程都无法观察到一个增加而另一个不增加的状态，因为操作是“原子地”完成的。

这总是原子性地发生吗？

是的，其中“原子地”意味着没有进程可以观察操作过程中的状态。这并不意味着这种状态“不存在”，因为内核必须一个接一个地查询操作。这意味着无法从使用 POSIX api 的进程中观察到这种状态。

以下是 Linux 5.4 中的一些实现细节。管理 sysV 信号量的源代码位于 ipc/sem.c 中。

semop() 系统调用入口点调用常见的内部 do_semtimedop() 函数，并将 timeout 参数设置为 NULL：

SYSCALL_DEFINE3(semop,int,semid,struct sembuf __user *,tsops,unsigned,nsops)
{
    return do_semtimedop(semid,nsops,NULL);
}

在对参数和权限进行一些检查后，松散地说，do_semtimedop() 锁定整个信号量集并调用另一个名为 perform_atomic_semop() 的内部例程，它使请求的“sem 操作”。 该函数扫描信号量集两次：

第一次扫描循环确定是否有任何操作导致集合中信号量的负值。如果是，如果在标志中设置了 IPC_NOWAIT，则返回 -EAGAIN，如果未设置，则返回 1。如果其中一项操作的结果大于最大值（在 include/uapi/linux/sem 中定义为 SEMVMX = 32767），它也可能返回 -ERANGE .h).
第二次扫描循环 执行请求的操作，因为第一次循环确定这不会导致信号量的负值。返回 0。

static int perform_atomic_semop(struct sem_array *sma,struct sem_queue *q)
[...]
    /*
     * We scan the semaphore set twice,first to ensure that the entire
     * operation can succeed,therefore avoiding any pointless writes
     * to shared memory and having to undo such changes in order to block
     * until the operations can go through.
     */
    for (sop = sops; sop < sops + nsops; sop++) {
        int idx = array_index_nospec(sop->sem_num,sma->sem_nsems);

        curr = &sma->sems[idx];
        sem_op = sop->sem_op;
        result = curr->semval;

        if (!sem_op && result)
            goto would_block; /* wait-for-zero */

        result += sem_op;
        if (result < 0)
            goto would_block;

        if (result > SEMVMX)
            return -ERANGE;

        if (sop->sem_flg & SEM_UNDO) {
            int undo = un->semadj[sop->sem_num] - sem_op;

            /* Exceeding the undo range is an error. */
            if (undo < (-SEMAEM - 1) || undo > SEMAEM)
                return -ERANGE;
        }
    }

    for (sop = sops; sop < sops + nsops; sop++) {
        curr = &sma->sems[sop->sem_num];
        sem_op = sop->sem_op;
        result = curr->semval;

        if (sop->sem_flg & SEM_UNDO) {
            int undo = un->semadj[sop->sem_num] - sem_op;

            un->semadj[sop->sem_num] = undo;
        }
        curr->semval += sem_op;
        ipc_update_pid(&curr->sempid,q->pid);
    }

    return 0;

would_block:
    q->blocking = sop;
    return sop->sem_flg & IPC_NOWAIT ? -EAGAIN : 1;
}

回到 do_semtimedop()，检查 perform_atomic_semop() 的返回：

如果返回值为 0，则信号量集上的任何等待任务都会在被唤醒之前被唤醒以运行其挂起的操作（即为每个等待任务调用 do_semtimedop()）。全局锁被释放，返回0
如果返回值为负（-EAGAIN 或任何其他检测到的错误，如 -ERANGE），则释放全局锁并返回 errno
如果返回值 > 0（实际上是 1），则调用任务进入睡眠状态：它被添加到信号量集的等待队列中。调用被阻塞，直到任务被唤醒。

因此，为了回答这个问题，没有一个中间时间段，其中一个信号量操作已完成，而另一个信号量正在同一组中待处理。一次性完成所有任务，或者调用任务进入休眠状态，直到它可以完成为止。

atomic c ipc posix semaphore