Mac OS X 上的 POSIX 信号量：sem_timedwait 替代方案

Question

我正在尝试将一个使用信号量的项目（从 Linux）移植到 Mac OS X，但是某些 posix 信号量在 Mac OS X 上并未实现

我在此端口中遇到的一个是 sem_timedwait()

我对信号量了解不多，但从手册页 sem_wait() 似乎接近 sem_timedwait 并且它是

从手册页

实现的

sem_timedwait() 函数应 锁定
引用的信号量 sem 与 sem_wait() 函数中一样。 但是，如果信号量不能
锁定，无需等待另一个 进程或线程解锁
通过执行 sem_post() 来获取信号量 函数，这个等待应该是ter-
当指定的超时时间时终止 过期

，我可以看到 sem_timedwait() 更安全，但我仍然应该能够使用 sem_wait()

这是正确的吗？ 如果没有，我还有什么其他选择...

谢谢

Answer 1

超时可能对算法的运行很重要。 因此，仅使用 sem_wait() 可能不起作用。

您可以使用 sem_trywait()，它在所有情况下都会立即返回。 然后，您可以循环并使用您选择的睡眠间隔，每次减少总超时，直到超时或获取信号量。

更好的解决方案是重写算法以使用条件变量，然后您可以使用 pthread_cond_timedwait() 来获取适当的超时。

Answer 2

我曾经在 OSX 上使用命名信号量，但现在 sem_timedwait 不可用，并且 sem_init 和朋友已被弃用。 我使用 pthread 互斥体和条件实现了信号量，如下所示，这对我有用（OSX 10.13.1）。 您可能必须创建一个句柄与结构表，并查找 sem_t 类型，如果它不能在其中保存 ptr （即指针是 64 位而 sem_t 是 32？）

#ifdef __APPLE__

typedef struct
{
    pthread_mutex_t count_lock;
    pthread_cond_t  count_bump;
    unsigned count;
}
bosal_sem_t;

int sem_init(sem_t *psem, int flags, unsigned count)
{
    bosal_sem_t *pnewsem;
    int result;

    pnewsem = (bosal_sem_t *)malloc(sizeof(bosal_sem_t));
    if (! pnewsem)
    {
        return -1;
    }
    result = pthread_mutex_init(&pnewsem->count_lock, NULL);
    if (result)
    {
        free(pnewsem);
        return result;
    }
    result = pthread_cond_init(&pnewsem->count_bump, NULL);
    if (result)
    {
        pthread_mutex_destroy(&pnewsem->count_lock);
        free(pnewsem);
        return result;
    }
    pnewsem->count = count;
    *psem = (sem_t)pnewsem;
    return 0;
}

int sem_destroy(sem_t *psem)
{
    bosal_sem_t *poldsem;

    if (! psem)
    {
        return EINVAL;
    }
    poldsem = (bosal_sem_t *)*psem;

    pthread_mutex_destroy(&poldsem->count_lock);
    pthread_cond_destroy(&poldsem->count_bump);
    free(poldsem);
    return 0;
}

int sem_post(sem_t *psem)
{
     bosal_sem_t *pxsem;
    int result, xresult;

    if (! psem)
    {
        return EINVAL;
    }
    pxsem = (bosal_sem_t *)*psem;

    result = pthread_mutex_lock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    pxsem->count = pxsem->count + 1;

    xresult = pthread_cond_signal(&pxsem->count_bump);

    result = pthread_mutex_unlock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
}

int sem_trywait(sem_t *psem)
{
    bosal_sem_t *pxsem;
    int result, xresult;

    if (! psem)
    {
        return EINVAL;
    }
    pxsem = (bosal_sem_t *)*psem;

    result = pthread_mutex_lock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    xresult = 0;

    if (pxsem->count > 0)
    {
        pxsem->count--;
    }
    else
    {
        xresult = EAGAIN;
    }
    result = pthread_mutex_unlock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
    return 0;
}

int sem_wait(sem_t *psem)
{
    bosal_sem_t *pxsem;
    int result, xresult;

    if (! psem)
    {
        return EINVAL;
    }
    pxsem = (bosal_sem_t *)*psem;

    result = pthread_mutex_lock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    xresult = 0;

    if (pxsem->count == 0)
    {
        xresult = pthread_cond_wait(&pxsem->count_bump, &pxsem->count_lock);
    }
    if (! xresult)
    {
        if (pxsem->count > 0)
        {
            pxsem->count--;
        }
    }
    result = pthread_mutex_unlock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
    return 0;
}

int sem_timedwait(sem_t *psem, const struct timespec *abstim)
{
    bosal_sem_t *pxsem;
    int result, xresult;

    if (! psem)
    {
        return EINVAL;
    }
    pxsem = (bosal_sem_t *)*psem;

    result = pthread_mutex_lock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    xresult = 0;

    if (pxsem->count == 0)
    {
        xresult = pthread_cond_timedwait(&pxsem->count_bump, &pxsem->count_lock, abstim);
    }
    if (! xresult)
    {
        if (pxsem->count > 0)
        {
            pxsem->count--;
        }
    }
    result = pthread_mutex_unlock(&pxsem->count_lock);
    if (result)
    {
        return result;
    }
    if (xresult)
    {
        errno = xresult;
        return -1;
    }
    return 0;
}

#endif

Answer 3

另一种选择可能是使用 sem_timedwait.c
由澳大利亚天文台软件组的 Keith Shortridge 实施。

从源文件：

/*
*                       s e m _ t i m e d w a i t
*
*  Function:
*     Implements a version of sem_timedwait().
*
*  Description:
*     Not all systems implement sem_timedwait(), which is a version of
*     sem_wait() with a timeout. Mac OS X is one example, at least up to
*     and including version 10.6 (Leopard). If such a function is needed,
*     this code provides a reasonable implementation, which I think is
*     compatible with the standard version, although possibly less
*     efficient. It works by creating a thread that interrupts a normal
*     sem_wait() call after the specified timeout.
*
* ...
*
*  Limitations:
*
*     The mechanism used involves sending a SIGUSR2 signal to the thread
*     calling sem_timedwait(). The handler for this signal is set to a null
*     routine which does nothing, and with any flags for the signal 
*     (eg SA_RESTART) cleared. Note that this effective disabling of the
*     SIGUSR2 signal is a side-effect of using this routine, and means it
*     may not be a completely transparent plug-in replacement for a
*     'normal' sig_timedwait() call. Since OS X does not declare the
*     sem_timedwait() call in its standard include files, the relevant 
*     declaration (shown above in the man pages extract) will probably have
*     to be added to any code that uses this.
* 
* ...
* 
*  Copyright (c) Australian Astronomical Observatory.
*  Commercial use requires permission.
*  This code comes with absolutely no warranty of any kind.
*/

Answer 4

您是否考虑过使用 apache 可移植运行时？ 它预装在每个 Mac OS X Box 和许多 Linux 发行版上，并且带有一个围绕线程并发的平台中立包装器，甚至可以在 MS Windows 上运行：

http://apr.apache.org/docs/apr/1.3/group__apr__thread__cond.html

Answer 5

一种选择是使用低级信号量 mach API：

#include <mach/semaphore.h>

semaphore_create(...)

semaphore_wait(...)
semaphore_timedwait(...)
semaphore_signal(...)

semaphore_destroy(...)

顺便说一句，它在 libuv 中使用。

参考：

• https://opensource.apple.com/ source/xnu/xnu-201/osfmk/kern/sync_sema.c
• https://github.com/libuv/libuv/blob/master/src/unix/thread.c

Answer 6

我认为最简单的解决方案是使用 sem_wait() 结合调用 Alarm() 来唤醒中止等待。 例如：

alarm(2);
int return_value = sem_wait( &your_semaphore );
if( return_value == EINTR )
   printf( "we have been interrupted by the alarm." );

一个问题是警报需要几秒钟的时间作为输入，因此在您的情况下定时等待可能太长。

——阿吉利斯

Answer 7

如果计时器到期后尚未被应该调用 sem_post() 的主线程调用，您是否可以尝试通过在另一个调用 sem_post() 的线程中启动计时器来模拟 sem_timedwait() 调用的功能？

Answer 8

如果您可以仅使用 MP API：

• MPCreateSemaphore/MPDeleteSemaphore
• MPSignalSemaphore/MPWaitOnSemaphore

如果超出指定超时且没有发出信号，则 MPWaitOnSemaphore 与 kMPTimeoutErr 一起存在。

Answer 9

我原本计划使用以下函数作为替代，但后来我发现 sem_getvalue() 也已被弃用并且在 OSX 上不起作用。 您可以在 MIT 或 LGPL 许可证（您的选择）下自由使用以下稍微未经测试的代码。

#ifdef __APPLE__
struct CSGX__sem_timedwait_Info
{
    pthread_mutex_t MxMutex;
    pthread_cond_t MxCondition;
    pthread_t MxParent;
    struct timespec MxTimeout;
    bool MxSignaled;
};

void *CSGX__sem_timedwait_Child(void *MainPtr)
{
    CSGX__sem_timedwait_Info *TempInfo = (CSGX__sem_timedwait_Info *)MainPtr;

    pthread_mutex_lock(&TempInfo->MxMutex);

    // Wait until the timeout or the condition is signaled, whichever comes first.
    int Result;
    do
    {
        Result = pthread_cond_timedwait(&TempInfo->MxCondition, &TempInfo->MxMutex, &TempInfo->MxTimeout);
        if (!Result)  break;
    } while (1);
    if (errno == ETIMEDOUT && !TempInfo->MxSignaled)
    {
        TempInfo->MxSignaled = true;
        pthread_kill(TempInfo->MxParent, SIGALRM);
    }

    pthread_mutex_unlock(&TempInfo->MxMutex);

    return NULL;
}

int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout)
{
    // Quick test to see if a lock can be immediately obtained.
    int Result;

    do
    {
        Result = sem_trywait(sem);
        if (!Result)  return 0;
    } while (Result < 0 && errno == EINTR);

    // Since it couldn't be obtained immediately, it is time to shuttle the request off to a thread.
    // Depending on the timeout, this could take longer than the timeout.
    CSGX__sem_timedwait_Info TempInfo;

    pthread_mutex_init(&TempInfo.MxMutex, NULL);
    pthread_cond_init(&TempInfo.MxCondition, NULL);
    TempInfo.MxParent = pthread_self();
    TempInfo.MxTimeout.tv_sec = abs_timeout->tv_sec;
    TempInfo.MxTimeout.tv_nsec = abs_timeout->tv_nsec;
    TempInfo.MxSignaled = false;

    sighandler_t OldSigHandler = signal(SIGALRM, SIG_DFL);

    pthread_t ChildThread;
    pthread_create(&ChildThread, NULL, CSGX__sem_timedwait_Child, &TempInfo);

    // Wait for the semaphore, the timeout to expire, or an unexpected error condition.
    do
    {
        Result = sem_wait(sem);
        if (Result == 0 || TempInfo.MxSignaled || (Result < 0 && errno != EINTR))  break;
    } while (1);

    // Terminate the thread (if it is still running).
    TempInfo.MxSignaled = true;
    int LastError = errno;

    pthread_mutex_lock(&TempInfo.MxMutex);
    pthread_cond_signal(&TempInfo.MxCondition);
    pthread_mutex_unlock(&TempInfo.MxMutex);
    pthread_join(ChildThread, NULL);
    pthread_cond_destroy(&TempInfo.MxCondition);
    pthread_mutex_destroy(&TempInfo.MxMutex);

    // Restore previous signal handler.
    signal(SIGALRM, OldSigHandler);

    errno = LastError;

    return Result;
}
#endif

SIGALRM 比 SIGUSR2 更有意义，因为这里显然使用了另一个示例（我没有费心去看它）。 SIGALRM 主要保留用于alarm() 调用，当您想要亚秒分辨率时，这些调用实际上毫无用处。

此代码首先尝试使用 sem_trywait() 获取信号量。 如果立即成功，那么它就会退出。 否则，它启动一个线程，该线程是通过 pthread_cond_timedwait() 实现计时器的地方。 MxSignaled 布尔值用于确定超时状态。

您可能还会发现此相关函数对于调用上述 sem_timedwait() 实现很有用（同样，MIT 或 LGPL，您的选择）：

int CSGX__ClockGetTimeRealtime(struct timespec *ts)
{
#ifdef __APPLE__
    clock_serv_t cclock;
    mach_timespec_t mts;

    if (host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock) != KERN_SUCCESS)  return -1;
    if (clock_get_time(cclock, &mts) != KERN_SUCCESS)  return -1;
    if (mach_port_deallocate(mach_task_self(), cclock) != KERN_SUCCESS)  return -1;

    ts->tv_sec = mts.tv_sec;
    ts->tv_nsec = mts.tv_nsec;

    return 0;
#else
    return clock_gettime(CLOCK_REALTIME, ts);
#endif
}

帮助使用最接近 Clock_gettime() 可以提供的内容填充 timespec 结构。 有各种评论表明重复调用 host_get_clock_service() 的成本很高。 但启动一个线程也很昂贵。

真正的解决办法是 Apple 实现整个 POSIX 规范，而不仅仅是强制性部分。 仅实现 POSIX 的强制性部分，然后声称符合 POSIX 要求，只会给每个人带来一个半损坏的操作系统和大量类似上述的解决方法，这些解决方法可能具有不太理想的性能。

综上所述，我放弃了 Mac OSX 和 Linux 上的本机信号量（Sys V 和 POSIX）。 它们以多种相当不幸的方式被破坏。 其他人也应该放弃他们。 （我不会放弃这些操作系统上的信号量，只是放弃本机实现。）无论如何，现在每个人都有一个 sem_timedwait() 实现，没有商业限制，其他人可以随心所欲地复制意大利面。

Answer 10

在 MacOS 上，我建议基于 SIGALRM 进行以下实现，以毫秒为单位给出超时：

    struct itimerval value, old_value;

    value.it_interval.tv_sec = 0;
    value.it_interval.tv_usec = 0;
    value.it_value.tv_sec = timeout / 1000;
    value.it_value.tv_usec = (timeout - value.it_value.tv_sec * 1000) * 1000;

    setitimer(ITIMER_REAL, &value, &old_value);
    int status = sem_wait(communication->server_ready);
    setitimer(ITIMER_REAL, &old_value, NULL);
    SHM_LOG("communication_timedwaitfor_server -- END()\n");
    if (status < 0) {
        if (errno == EINTR) {
            /* TIMEOUT */
        } else {
            /* Error */
        }
    } else {
        /* unlock before timeout */
    }