标签: semaphore

http://msdn.microsoft.com/en-us/library/system.threading.semaphoreslim.aspx

要创建信号量,我需要提供初始计数和最大计数.MSDN声明初始计数是 -

可以同时授予的信号量的初始请求数.

虽然它声明最大数量是

可以同时授予的信号量的最大请求数.

我可以理解,最大计数是可以同时访问资源的最大线程数.但是,初始计数的用途是什么？

如果我创建一个初始计数为0且最大计数为2的信号量,则我的线程池线程都不能访问该资源.如果我将初始计数设置为1并将最大计数设置为2,则只有线程池线程可以访问该资源.只有当我将初始计数和最大计数都设置为2时,2个线程才能同时访问资源.那么,我真的很困惑初始计数的意义？

SemaphoreSlim semaphoreSlim = new SemaphoreSlim(0, 2); //all threadpool threads wait
SemaphoreSlim semaphoreSlim = new SemaphoreSlim(1, 2);//only one thread has access to the resource at a time
SemaphoreSlim semaphoreSlim = new SemaphoreSlim(2, 2);//two threadpool threads can access the resource concurrently

我想阻止我的脚本一次运行多次.

我目前的做法是

• 创建一个包含正在运行的进程的pid的信号量文件
• 读取文件,如果我的进程ID不在它退出(你永远不知道......)
• 在处理结束时,删除该文件

为了防止进程挂起,我设置了一个cron作业,定期检查文件是否超过了最大允许的运行时间,如果文件仍然在运行,则会终止该进程.

是否存在我正在杀死错误进程的风险？

有没有更好的方法来执行这个整体？

这是我的代码,但我不明白SemaphoreSlim在做什么.

async Task WorkerMainAsync()
{
  SemaphoreSlim ss = new SemaphoreSlim(10);
  List<Task> trackedTasks = new List<Task>();
  while (DoMore())
  {
    await ss.WaitAsync();
    trackedTasks.Add(Task.Run(() =>
              {
                DoPollingThenWorkAsync();
                ss.Release();
              }));
  }
  await Task.WhenAll(trackedTasks);
}

void DoPollingThenWorkAsync()
{
  var msg = Poll();
  if (msg != null)
  {
    Thread.Sleep(2000); // process the long running CPU-bound job
  }
}

等待ss.WaitAsync(); & ss.Release();做什么？

我想如果我一次运行50个线程然后编写代码SemaphoreSlim ss = new SemaphoreSlim(10);那么它将被迫在时间运行10个活动线程.

当10个线程中的一个完成然后另一个线程将启动....如果我不对,那么请帮助我理解样本情况.

为什么需要等待使用ss.WaitAsync();？怎么ss.WaitAsync();办？

我正在研究一些使用pthread和信号量库的代码.该sem_init功能在我的Ubuntu机器上运行正常,但在OS X上该sem_init功能完全没有效果.图书馆有什么问题,或者有不同的方式吗？这是我用来测试的代码.

sem_t sem1;
sem_t sem2;
sem_t sem3;
sem_t sem4;
sem_t sem5;
sem_t sem6;

sem_init(&sem1, 1, 1);
sem_init(&sem2, 1, 2);
sem_init(&sem3, 1, 3);
sem_init(&sem4, 1, 4);
sem_init(&sem5, 1, 5);
sem_init(&sem6, 1, 6);

值似乎是随机数,并且在sem_init调用后它们不会更改.

在Javascript中是否存在原子测试和设置,信号量或锁定这样的事情？

我有javascript通过自定义协议调用异步后台进程(后台进程实际上在一个单独的进程中运行,与浏览器无关).我相信我遇到了竞争状态; 后台进程在我的测试和我的设置之间返回,在javascript端搞砸了.我需要一个测试和设置操作来使它成为一个真正的信号量.

这是尝试检测后台进程并将其排队的javascript代码:

Call = function () {

var isRunning = true,
    queue = [];

return  {
    // myPublicProperty: "something",

    call: function (method) {
            if (isRunning) {
                console.log("Busy, pushing " + method);
                queue.push(method);
            } else {
                isRunning = true;
                objccall(method);
            }
        },

        done: function() {
            isRunning = false;
            if (queue.length > 0) {
                Call.call(queue.shift());
            }
        }
    };
}();

呼叫是一个实现排队的单身人士; 任何想要调用外部进程的人都会调用Call.call("something").

有任何想法吗？

我想运行一堆异步任务,并限制在任何给定时间可以完成的任务数量.

假设您有1000个网址,并且您只希望一次打开50个请求; 但只要一个请求完成,您就会打开与列表中下一个URL的连接.这样,一次只打开50个连接,直到URL列表用完为止.

如果可能的话,我也想利用给定数量的线程.

我提出了一种扩展方法,ThrottleTasksAsync可以实现我想要的功能.那里有更简单的解决方案吗？我认为这是一种常见的情况.

用法:

class Program
{
    static void Main(string[] args)
    {
        Enumerable.Range(1, 10).ThrottleTasksAsync(5, 2, async i => { Console.WriteLine(i); return i; }).Wait();

        Console.WriteLine("Press a key to exit...");
        Console.ReadKey(true);
    }
}

这是代码:

static class IEnumerableExtensions
{
    public static async Task<Result_T[]> ThrottleTasksAsync<Enumerable_T, Result_T>(this IEnumerable<Enumerable_T> enumerable, int maxConcurrentTasks, int maxDegreeOfParallelism, Func<Enumerable_T, Task<Result_T>> taskToRun)
    {
        var blockingQueue = new BlockingCollection<Enumerable_T>(new ConcurrentBag<Enumerable_T>());

        var semaphore = new SemaphoreSlim(maxConcurrentTasks);

        // Run the throttler on a separate thread.
        var t = Task.Run(() => …

我有多个使用g ++编译的应用程序,在Ubuntu中运行.我正在使用命名信号量来协调不同的进程.

一切正常,除非在以下情况下:如果其中一个进程调用sem_wait()或sem_timedwait()减少信号量然后在它有机会调用之前崩溃或被杀死-9 sem_post(),那么从那一刻起,命名信号量就"无法使用".

通过"不可用",我的意思是信号量计数现在为零,并且应该将其增加回1的过程已经死亡或被杀死.

我找不到一个sem_*()API,可能会告诉我上次减少崩溃的过程.

我在某个地方错过了API吗？

以下是我打开命名信号量的方法:

sem_t *sem = sem_open( "/testing",
    O_CREAT     |   // create the semaphore if it does not already exist
    O_CLOEXEC   ,   // close on execute
    S_IRWXU     |   // permissions:  user
    S_IRWXG     |   // permissions:  group
    S_IRWXO     ,   // permissions:  other
    1           );  // initial value of the semaphore

这是我如何减少它:

struct timespec timeout = { 0, 0 };
clock_gettime( CLOCK_REALTIME, &timeout );
timeout.tv_sec += 5;

if …

使用pthread_cond_wait或使用信号量的优点/缺点是什么？我正在等待这样的状态变化:

pthread_mutex_lock(&cam->video_lock);
while(cam->status == WAIT_DISPLAY) {
    pthread_cond_wait(&cam->video_cond, &cam->video_lock);
}
pthread_mutex_unlock(&cam->video_lock);

使用正确初始化的信号量,我想我可以这样做:

while(cam->status == WAIT_DISPLAY) {
    sem_wait(&some_semaphore);
}

每种方法的优缺点是什么？

在我读过的关于多线程的资源中,与信号量相比,更经常使用和讨论互斥.我的问题是你什么时候使用信号量而不是互斥量？我没有在Boost线程中看到信号量.这是否意味着信号量这些天不再使用太多？

据我所知,信号量允许多个线程共享资源.只有当这些线程只读取资源但不写入时,才可能这样做.它是否正确？

我有一个页面,在执行某项任务之前检查用户是否处于特定角色,并且对功能没有任何问题,并且没有对相关代码进行明显的相关更改.该站点位于运行IIS 7.0的开发计算机(Windows Vista)上,数据库位于单独的服务器上,是MS SQL 2005.突然间,所有的呼叫都会User.IsInRole导致

System.Threading.SemaphoreFullException:将指定的计数添加到信号量将导致它超过其最大计数.

我确信重新启动IIS会"解决"这个问题,但我想了解导致它的原因,以便我可以确保它不会发生在我的生产网站上.

堆栈跟踪的顶部是:

[SemaphoreFullException:将指定的计数添加到信号量将导致它超过其最大计数.] System.Threading.Semaphore.Release(Int32 releaseCount)+6065293 System.Data.ProviderBase.DbConnectionPool.PutNewObject(DbConnectionInternal obj)+57 System. Data.ProviderBase.DbConnectionPool.DeactivateObject(DbConnectionInternal obj)+338 System.Data.ProviderBase.DbConnectionPool.PutObject(DbConnectionInternal obj,Object owningObject)+163 System.Data.ProviderBase.DbConnectionInternal.CloseConnection(DbConnection owningObject,DbConnectionFactory connectionFactory)+117 System .Data.SqlClient.SqlInternalConnection.CloseConnection(DbConnection owningObject,DbConnectionFactory connectionFactory)+37 System.Data.SqlClient.SqlConnection.Close()+ 158 System.Web.DataAccess.SqlConnectionHolder.Close()+25 System.Web.Security.SqlRoleProvider .GetRolesForUser(String username)+847 System.Web.Security.RolePrincipal.IsInRole(String role)+182