标签: semaphore

前段时间我一直在考虑如何相互实现各种同步原语.例如,在pthreads中,您可以获得互斥锁和条件变量,从中可以构建信号量.

在Windows API(或至少是旧版本的Windows API)中,存在互斥锁和信号量,但没有条件变量.我认为应该可以用互斥量和信号量来构建条件变量,但对于我的生活,我只是想不出办法.

有没有人知道这样做的好建筑？

我们正在为Python + Celery开发一个用于我们任务队列的分布式应用程序.

我们的应用程序要求我们通过IMAP(例如:gmail)从远程ISP下载电子邮件,我们希望能够并行完成此任务.对于给定的电子邮件帐户,您被授予限制为多个模拟连接,因此我们需要一种方法来原子地跟踪所有正在下载的帐户的活动连接.

我已经使用Redis找到了Celery的多个原子锁示例,但没有一个可以跟踪这样的有限资源池,并且所有实现我们自己的尝试都导致难以调试竞争条件,导致我们的锁定间歇性地永远不会被释放.

我已经看过我能找到的唯一一个类似的帖子了,但这不是我想要的.

基本上,我正在尝试使用分叉运行Odd-Even Sort,因此孩子运行赔率并且父母运行平均值.这两者都需要共享矢量inputValues,以及布尔排序.

以下代码没有任何失败的共享内存尝试,只是使用搜索算法的分叉的基本框架:

while(!sorted)
{
    pID = fork();
    sorted = true;
    cout << "Sort set to TRUE." << endl;

    if(pID == 0)
    {
        int num = 1;
        cout << "Child swap run" << endl;
        Swap((void *) num);
        cout << "Status: " << ((sorted) ? "SORTED" : "UNSORTED") << endl;
        exit(0);
    }
    else if(pID < 0)
    {
        cout << "Failed to fork." << endl;
        exit(1);
    }
    else
    {
        wpid = waitpid(pID, &status, waitStatus);
        int num = 0;
        cout …

如果相同代码的多个实例在不同的服务器上运行,我想使用数据库来确保如果某个服务器已经在另一台服务器上运行,则它不会在一台服务器上启动.

我可能会提出一些可行的SQL命令,它们使用Oracle事务处理,锁存器或其他任何东西,但我宁愿找到一些经过尝试和真实的东西.

几年前,作为SQL wiz的开发人员有一个SQL事务,它获取了信号量,如果得到它则返回true,如果没有得到它则返回false.然后在我处理结束时,我需要运行另一个SQL事务来释放信号量.这很酷,但我不知道数据库支持的信号量是否有可能超时.超时是一个巨大的好处!

编辑:

以下是一些可行的SQL命令,但除了通过cron job hack之外没有超时:

---------------------------------------------------------------------
--Setup
---------------------------------------------------------------------
CREATE TABLE "JOB_LOCKER" ( "JOB_NAME" VARCHAR2(128 BYTE), "LOCKED" VARCHAR2(1 BYTE), "UPDATE_TIME" TIMESTAMP (6) );
CREATE UNIQUE INDEX "JOB_LOCKER_PK" ON "JOB_LOCKER" ("JOB_NAME") ;
ALTER TABLE "JOB_LOCKER" ADD CONSTRAINT "JOB_LOCKER_PK" PRIMARY KEY ("JOB_NAME");
ALTER TABLE "JOB_LOCKER" MODIFY ("JOB_NAME" NOT NULL ENABLE);
ALTER TABLE "JOB_LOCKER" MODIFY ("LOCKED" NOT NULL ENABLE);

insert into job_locker (job_name, locked) values ('myjob','N');
commit;

---------------------------------------------------------------------
--Execute at the beginning of the job
--AUTOCOMMIT MUST BE OFF!
---------------------------------------------------------------------
select …

我认为下面的代码会让所有10个线程一次运行两个,然后在Release()调用10次后打印"done" .但事情并非如此:

        int count = 0;

        Semaphore s = new Semaphore(2, 2);
        for (int x = 0; x < 10; x++)
        {
            Thread t = new Thread(new ThreadStart(delegate()
            {
                s.WaitOne();
                Thread.Sleep(1000);
                Interlocked.Increment(ref count);                       
                s.Release();
            }));
            t.Start(x);
        }

        WaitHandle.WaitAll(new WaitHandle[] { s });
        Console.WriteLine("done: {0}", count);

输出:

done: 6

如果实现我正在寻找的功能的唯一方法是传递一个EventWaitHandle到每个线程,然后WaitAll()在那些数组上做一个EventWaitHandles,那么WaitAll()在一个只有一个信号量的数组上做什么是什么意思？换句话说,等待线程何时解除阻塞？

我为什么陷入困境？

- (void)foo
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{

        [self foo];

    });

    // whatever...
}

我希望foo在第一次通话时执行两次.

我知道在同步世界中第一个片段是正确的,但是WaitAsync和async/await magic是什么？请给我一些.net内部.

await _semaphore.WaitAsync();
try
{
    // todo
}
finally
{
    _semaphore.Release();
}

要么

try
{
    await _semaphore.WaitAsync();
    // todo
    }
    finally
    {
        _semaphore.Release();
    }
}

由于使用了太多的Websphere Message Broker实例或者某些东西,我们的Linux机箱上的信号量用完了.

一位同事和我想知道为什么这甚至是有限的 - 它只是一点记忆,对吧？

我彻底用Google搜索,一无所获.

有谁知道这是为什么？

干杯

我试图测量有多少线程同时执行一段代码.目前我(ab)使用信号量,有更好的方法吗？

final int MAX_THREADS = Integer.MAX_VALUE;

Semaphore s = new Semaphore(MAX_THREADS);

s.acquire(); // start of section

// do some computations

// track how many threads are running the section
trackThreads( (MAX_THREADS - s.availablePermits()) );         

s.release(); // end of section

这是我在学校一直听到的一个问题,但在我被要求接受采访之前从未有过这样的理由.

提示:使用2个线程"Thread i: The number is 'j'"按顺序打印,其中j = 1:100,i是线程编号.线程1只能打印奇数j,线程2只能打印j.

编辑必须订购j的输出

这是我的尝试,但我没有在面试过程中继续前进.我缺少什么基本部分？有优化吗？

import java.util.concurrent.Semaphore;

public class ThreadSynchronization implements Runnable {

  private int start;
  private Semaphore semaphore;

  private ThreadSynchronization(int start, Semaphore semaphore) {
      this.start = start;
      this.semaphore = semaphore;
  }

  public static void main(String[] args) {
      Semaphore semaphore = new Semaphore(1, true);
      semaphore.acquireUninterruptibly();

      start(1, semaphore);
      start(2, semaphore);

      semaphore.release();
  }

  private static void start(int start, Semaphore semaphore) {
      ThreadSynchronization ts = new ThreadSynchronization(start, semaphore);
      Thread thread = new Thread(ts); …