标签: semaphore

示例线程池:

public class Example {
public static void Main() {

    ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc)); //task 1
    ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc)); //task 2
    ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc)); //task 3

    Console.WriteLine("Main thread does some work, then sleeps.");

    Thread.Sleep(1000);

    Console.WriteLine("Main thread exits.");
}
static void ThreadProc(Object stateInfo) {
    Console.WriteLine("Hello from the thread pool.");
}
}

示例信号量:

public class Example
{
private static Semaphore _pool;

private static int _padding;

public static void Main()
{
      _pool = new Semaphore(0, 3);

    // Create and start five numbered threads. 
    //
    for(int i = …

这是一个非常普遍的问题,大多只是概念性的.我正在考虑测试随机数发生器,看看它在一些x值上的均匀分布的有效性(骰子掷骰的前6).在一个简单的循环中这样做是我现在的方式,但我正在考虑多线程模拟.

我想知道这是否会给我任何加速,因为我只有一个随机数生成器在所有具有信号量保护的线程之间共享(需要确保没有两个线程访问并同时生成随机数意味着重复结果).

由于每个线程几乎没有其他操作(只是用于检查和递增x的语句)将线程化甚至给我更快的结果,或者对一个随机数生成器的依赖意味着它将基本上与单个线程相同？

需要说明的是:我主要是嵌入式内容,即它是C和微控制器中的某种实时内核; 但实际上这个问题应该与平台无关.

我读过Michael Barr的好文章:Mutexes和Semaphores Demystified,以及StackOverflow上的相关答案.我清楚地理解二进制信号量是什么,以及互斥量是什么.那很棒.

但说实话,我从来不知道,仍然无法理解,所谓的计数信号量(即最大计数> 1的信号量)是为了什么.在什么情况下我应该使用它？

很久以前,在我读过迈克尔·巴尔的上述文章之前,我已经说过" 你可以使用它,就像有一定数量的床的酒店房间一样.床的数量是最大的数量.信号量,就像那个房间的一些按键 ".

这可能听起来很不错,但实际上我的编程练习中从来没有这种情况(并且无法想象),迈克尔巴尔说这种方法是错误的,他似乎是对的.

然后,在我读完这篇文章后,我认为它可能会在我拥有某种FIFO缓冲区时使用.假设缓冲区的容量是10个元素,我们有两个任务:A(生产者)和B(消费者).然后:

• 信号量的最大计数应设置为10;
• 当A想要将数据放入缓冲区时,它signal就是信号量.
• 当B想要从缓冲区获取数据时,它wait就是信号量.

好吧,但它不起作用:

• 如果A试图将新数据放入FIFO,但没有空间怎么办？如何等待这个地方:它应该signal在放入新数据之前调用(signal然后应该能够等到最大计数<最大计数)？如果是这样,信号量将在数据实际放入FIFO之前发出信号,这是错误的.
• 信号量不足以实现正确的同步:FIFO本身也需要同步.然后,它产生经典的TOCTTOU问题:信号量已经发信号或等待时有一段时间,但FIFO尚未修改.

那么,我什么时候应该使用那个野兽,计数信号量呢？

我正在尝试使用信号量创建有界队列，并且我需要获取所有信号量许可。

Java中是否有任何方法可以做到这一点？

您好，我的代码中有下一个问题：

“从不同大小的整数转换为指针-wint-to-pointer-cast”

这个问题在这行代码中

pthread_create(&filos[i], NULL, (void *)filosofos,(void *) i);

特别是在(void *) i

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>

#define N 5               //num. de filosofos
#define IZQ (i-1)%N      //vecino izquierdo de i
#define DER (i+1)%N      //vecino derecho de i
#define PENSANDO 0
#define CON_HAMBRE 1
#define COME 2


pthread_t filos[N];       //hilos que representan a los filósofos
sem_t mutex ;             //semáforo para la sección crítica
sem_t s[N];               //semáforos para los filósofos
int estado [N] ;          //estado actual de cada filósosfo


/* …

我正在使用以下代码objective C来处理信号量。

-(void)doSome{
    semaphore = dispatch_semaphore_create(0);

    BaseViewController *baseVC = [[BaseViewController alloc]init];
    if(baseVC.isUserObjectExist){
        [self callLoginWebService:baseVC.userObject.username passwordString:baseVC.userObject.password];
    }else{
        dispatch_semaphore_signal(semaphore);
    }

    while (dispatch_semaphore_wait(semaphore, DISPATCH_TIME_NOW)) { //2
        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:100]];
    }

}

但

'dispatch_semaphore_t' 在 Swift 中不可用

如何在swift 3中集成信号量？

我有一个程序正在执行长时间运行的任务，该程序应该在程序启动时启动，并且应该可以在此后的任何时刻重新启动。

我的目的是，如果调用“重新启动”，则会发生以下情况：

• 要求完成所有任务
• 等待所有任务完成
• 所有功能重新启动

我想使用 async/await 并仍然锁定启动所有任务的过程，以确保在上一个启动/重新启动完成之前不会进行任何重新启动。

正如我所看到的，由于多种原因，async/await 不适用于锁定状态，因此我最终使用了 SemaphoreSlim，它对我来说非常有用。这是我的代码：

private readonly SemaphoreSlim m_semaphoreSlim;
private CancellationTokenSource m_cancellationTokenSource;
private CancellationToken m_cancellationToken;

public FeedClientService(IList<IFeedConfigurationBuilder> feedConfigs)
{
    m_semaphoreSlim = new SemaphoreSlim(1, 1);
    m_feedConfigs = feedConfigs;
}

public void Start()
{
    Task.Run(() => this.FetchFeeds());
}

public void Restart()
{
    if (m_cancellationTokenSource != null) m_cancellationTokenSource.Cancel();

    Task.Run(() => this.FetchFeeds());
}

private async Task FetchFeeds()
{
    try
    {
        await m_semaphoreSlim.WaitAsync();

        m_cancellationTokenSource = new CancellationTokenSource();
        m_cancellationToken = m_cancellationTokenSource.Token;

        Task[] tasks = new Task[m_feedConfigs.Count];
        for (int i = …

我有几种方法可以向数据库报告一些数据。我们希望异步调用对数据服务的所有调用。这些对数据服务的调用都结束了，因此我们要确保这些 DS 调用在任何给定时间按顺序依次执行。最初，我在这些方法中的每一个上使用 async await 并且每个调用都是异步执行的，但我们发现如果它们乱序，那么就有出错的空间。

所以，我认为我们应该将所有这些异步任务排队并在一个单独的线程中发送它们，但我想知道我们有哪些选择？我遇到了 'SemaphoreSlim' 。这在我的用例中是否合适？或者还有哪些其他选项适合我的用例？请指导我。

所以，我目前在我的代码中有什么

public static SemaphoreSlim mutex = new SemaphoreSlim(1);

//first DS call 

 public async Task SendModuleDataToDSAsync(Module parameters)
    {
        var tasks1 = new List<Task>();
        var tasks2 = new List<Task>();

        //await mutex.WaitAsync(); **//is this correct way to use SemaphoreSlim ?**
        foreach (var setting in Module.param)
        {
           Task job1 = SaveModule(setting);
           tasks1.Add(job1);
           Task job2= SaveModule(GetAdvancedData(setting));
           tasks2.Add(job2);
        }

        await Task.WhenAll(tasks1);
        await Task.WhenAll(tasks2);

        //mutex.Release(); // **is this correct?**
    }

 private async Task SaveModule(Module setting)
    {
        await Task.Run(() …

我在 Flask 中创建了一个 python 应用程序。这是代码的骨架

app = Flask(__name__)

@app.route('/', methods=['GET'])
def authentication():
    '''athentication process'''
    return 'authenticated'

因此，当用户调用该应用程序时，它将进行身份验证。但是，如果两个用户同时或在处理一个身份验证时调用该请求，我想保留新请求，直到旧请求完成，然后我想启动新请求。我尝试过semaphore但没有工作。这是我尝试过的

@app.route('/', methods=['GET'])
    def authentication():
        sem.acquire()
        '''athentication process'''
        sem.release()
        return 'authenticated'

我已将其部署在Heroku. 知道我该如何实现这一目标吗？

PS：如果这不能完成，至少我想响应另一个请求正在处理的新请求，并在一段时间后重试

因此，我尝试在 Visual Studio 2019 和 2022 中使用counting_semaphore，但我得到的只是“std 没有成员counting_semaphore”。

在各个组件中添加 clang 11 后，我在 Visual Studio 2019 中进行了尝试，但仍然遇到相同的错误。然后我就想，好吧，它不支持 C++20。所以我想也许这就是它不起作用的原因。

然后我看到Vs2022 Preview支持C++20。所以我安装了它，包括在内，但我仍然无法执行“std::counting_semaphore<5> slot(5);” 正如它所说，std 没有一个名为计数信号量的成员。

我还在 2022 年预览安装程序的各个组件中安装了 clang12，但仍然无法正常工作。

我不确定我做错了什么。

我在网上看到例子：

https://www.modernnescpp.com/index.php/semaphores-in-c-20 https://en.cppreference.com/w/cpp/thread/counting_semaphore

告诉如何使用它，但是当我将代码放入 vs 中时，它不起作用。

我可以在#include 上“查看代码”，它显示了counting_semaphore 的实现，但我无法使用它！

请有人澄清我做错了什么！