标签: semaphore

我在让Semaphores在C语言系统上工作时遇到了很多困难.

我的申请流程如下:

1. 申请开始
2. 申请分叉到孩子/父母
3. 每个进程使用sem_open一个通用名称来打开信号量.

如果我在分叉之前创建信号量,它可以正常工作.但是,要求阻止我这样做.当我sem_open第二次尝试呼叫时,我收到"权限被拒绝"错误(通过errno).

是否有可能以任何方式做到这一点？或者有没有办法在一个进程中打开信号量并使用共享内存机制与子进程共享它？

.NET Semaphore类的文档声明:

没有保证的顺序,例如FIFO或LIFO,其中被阻塞的线程进入信号量.

在这种情况下,如果我想要保证订单(FIFO或LIFO),我的选择是什么？这是不容易实现的事情吗？我必须写自己的信号量吗？我认为那会很先进吗？

谢谢,

史蒂夫

当使用带有取消令牌的SemaphorSlim时,我应该如何构造try/finally,以便正确处理OperationCancelledException？在选项A中,取消令牌源会抛出OperationCancelledException但不会调用Release().在选项B中,取消令牌源会抛出OperationCancelledException,并且DOES会调用Release().

// option A:
_semaphorSlim.Wait( _cancellationTokenSource.Token );
try
{
     // do work here
}
finally
{
     _semaphorSlim.Release();
}


// option B:
try
{
     _semaphorSlim.Wait( _cancellationTokenSource.Token );
     // do work here
}
finally
{
     _semaphorSlim.Release();
}

AFAIK,在LDD3(Linux设备驱动程序第3版)编写完成后,mutex API被引入内核,所以书中没有对它进行描述.

该书描述了如何将内核的信号量API用于互斥功能.

它建议使用down_interruptable()而不是down():

作为一般规则,您不希望使用不间断操作,除非确实没有其他选择.不可中断的操作是创建不可杀死进程的好方法(在ps中看到可怕的"D状态"),并且惹恼用户[Linux设备驱动程序第3版]

现在.这是我的问题:

互斥锁API有两个"相似"功能: mutex_lock_killable()一mutex_lock_interruptable().我应该选择哪一个？

我有一些代码,我使用dispatch_semaphore_t来指示操作完成.当信号量是成员变量时,它似乎行为不正确.我将展示有效的示例代码和一个似乎不起作用的示例:

@implementation someClass  
{  
  dispatch_semaphore_t memberSem;  
  dispatch_semaphore_t* semPtr;  
  NSThread* worker;
  BOOL taskDone;  
}  

- (id)init  
{  
  // Set up the worker thread and launch it - not shown here.  
  memberSem= dispatch_semaphore_create(0); 
  semPtr= NULL;  
  taskDone= FALSE;  
}  

- (void)dealloc  
{  
  // Clean up the worker thread as needed - not shown here.  
  if((NULL != semPtr) && (NULL != *semPtr))  
    disptatch_release(*semPtr);  

  dispatch_release(memberSem);  
}  

- (void)doSomethingArduous  
{  
  while([self notDone])  // Does something like check a limit.  
    [self doIt];  // Does something like process …

我有一个网页,其中异步触发某个Ajax事件.这个Ajax部分可以被调用一次或多次.我无法控制触发此事件的次数,也无法控制时间.

此外,Ajax部分中有一些代码应作为关键部分运行,这意味着,当它运行时,不应该运行该代码的其他副本.

这是一个伪代码:

1. 运行JavaScript或jQuery代码
2. 输入作为Ajax的关键部分(当某个进程正在等待响应回调时,请不要再次进入此部分,直到此过程完成)
3. 运行更多JavaScript或jQuery代码

我的问题是,我怎样才能按照上述方式运行第2步？如何使用JavaScript或jQuery创建/保证互斥部分.

我理解理论(信号量,锁,等等),但我无法使用JavaScript或jQuery实现解决方案.

编辑

如果你建议一个布尔变量进入临界区,这将不起作用,下面的行将解释原因.

关键部分的代码如下(使用布尔变量建议):

load_data_from_database = function () {

    // Load data from the database. Only load data if we almost reach the end of the page
    if ( jQuery(window).scrollTop() >= jQuery(document).height() - jQuery(window).height() - 300) {

        // Enter critical section
        if (window.lock == false) {

            // Lock the critical section
            window.lock = true;

            // Make Ajax call
            jQuery.ajax({
                type:        'post',
                dataType:    'json',
                url:         path/to/script.php,
                data:        {
                    action:  'action_load_posts'
                },
                success:     function (response) …

我有一个包含AFHTTPSessionManager*fileTransferSessionManager的单例类.在其中我有时想要取消所有下载,在重新开始之前,这是通过downloadTasks运行并取消它们.问题是,当调用downloadtasks属性时,如果有正在运行的下载,则主线程会冻结.

// My method canceling download tasks:
NSArray *downloadTasks =  self.fileTransferSessionManager.downloadTasks;   
for (NSURLSessionDownloadTask *downloadTask in downloadTasks) {
     [downloadTask cancel];
}

// In AFURLSessionManager.m
- (NSArray *)downloadTasks {
    return [self tasksForKeyPath:NSStringFromSelector(_cmd)];
}

调用冻结主线程的方法,因为从不调用带有dispatch_semaphore_signal(信号量)的getTasksWithCompletionHandler:

// In AFURLSessionManager.m
- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
    __block NSArray *tasks = nil;
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
        if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
            tasks = dataTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
            tasks = uploadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
            tasks …

是否可以在Linux上用C++创建系统范围的全局变量/信号量/互斥量？

原因如下:我有一个系统经常在不相关的数据上运行同一软件的多个副本.通常有4个作业,每个作业运行相同的软件.该软件有一个小部分,它创建一个占用大量内存的巨大图形; 在该部分以外的内存使用量适中.

有时会发生这样的情况,即2个作业同时遇到同样占用大量内存的部分,整个系统开始交换.因此,我们希望通过在不同作业之间创建类似于临界区互斥体的东西来防止这种情况,这样一次就不会有多个内存分配大量内存.

如果这些是相同工作的线程,pthread锁将完成这项工作.

在不同的工作之间实现这种互斥量的好方法是什么？

我有以下类型的代码:

synchronized block1 {
    //only one thread in the block
}

{lot of code where synchronization not necessary}

synchronized block2 {
    //only one thread in the block. 
    //All the threads that executed block1 before this thread should have already executed this block.
}

每个线程首先以相同的顺序执行block1,non synchronized block和block2.

如果线程T1在线程T2之前执行block1,那么T1应该在T2之前执行block2.有两个以上的线程.

有没有办法在java中实现这一点？

现在我正在AWS中的一个生产区域测试一个非常简单的信号量.在部署时,延迟从150ms跳到300ms.我假设会发生延迟,但是如果它可以被丢弃那就太好了.这对我来说有点新鲜,所以我正在尝试.我已设置信号量以允许10000个连接.这与Redis设置的最大连接数相同.代码是否最佳？如果没有,有人可以帮助我优化它,如果我做错了等等.我想把它作为一个中间件保存,这样我就可以在服务器上简单地调用它n.UseHandler(wrappers.DoorMan(wrappers.DefaultHeaders(myRouter), 10000)).

package wrappers

import "net/http"

// DoorMan limit requests
func DoorMan(h http.Handler, n int) http.Handler {
    sema := make(chan struct{}, n)

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        sema <- struct{}{}
        defer func() { <-sema }()

        h.ServeHTTP(w, r)
    })
}