我对使用信号量相当陌生，所以我不确定我是否正确使用它。
当我尝试这样做时：
var group = dispatch_group_create();
dispatch_async(dispatch_get_global_queue(Int(QOS_CLASS_USER_INITIATED.value), 0)){
var myRef = self.userRef.childByAppendingPath(self.userRef.authData.uid)
myRef.observeSingleEventOfType(.Value, withBlock: { snapshot in
// do some stuff once
println("WE ARE IN HERE")
firstName = snapshot.value["firstName"] as String!
lastName = snapshot.value["lastName"] as String!
})
}
dispatch_semaphore_wait(group, DISPATCH_TIME_FOREVER)
dispatch_semaphore_signal(group)
println("WE MADE IT OUT OF THERE")
输出始终是：
"WE MADE IT OUF OF THERE"
"WE ARE IN HERE"
为什么它不等待我的信号量完成后再执行其余代码？
编辑：
dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), { () -> () in
// do some task
var myRef = self.userRef.childByAppendingPath(self.userRef.authData.uid)
myRef.observeSingleEventOfType(.Value, withBlock: { snapshot in …我正在process-1尝试将数据写入共享内存。同时process-2我正在从同一共享内存中读取数据。在这种情况下，我需要在这两个进程之间提供同步。如果我要遍历未命名的信号量（使用shm_init(),mmap()），它会起作用吗？
我写了这样的代码，它能工作吗？
fd = shm_open("shm_name", O_CREAT| O_RDWR, S_IRUSR | S_IWUSR);
sema = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE,MAP_SHARED , fd, 0);
sem_init(sema, 1, 1);
我是一个使用共享内存的初学者，我已经实现了一个并行加法器，其中每个 k 处理器都作为子进程实现。具体来说，给定一组 n 个整数和 k 的值，主程序创建 k 个子进程，分配每个子进程计算其指定的 n/k 个数字上限的总和，等待 k 个数字中每一个的小计子进程，对小计进行求和，并打印每个小计的结果以及总和。我没有使用线程。
该程序是为学院中的作业而创建的，预计可以在任何部门的计算机上运行。
该代码在 Kali Linux 上可以正确编译，但无法在其他 Linux 版本上编译和运行。当我尝试在 Ubuntu 上编译时，出现错误：
对“sem_init”的未定义引用
我在编译行中使用了 -lrt 。请帮我解决这个问题。
这是我创建的代码。
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/wait.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<fcntl.h>
#include<errno.h>
#include<semaphore.h>
#include<unistd.h>
#include<math.h>
#include<stdlib.h>
#define BUFFER_SIZE 100
#define BUFFER_SUB 2
typedef struct
{
int bufMax;
int datalimit;
int buff[BUFFER_SIZE];
sem_t mutex, empty, full;
} shared_inputs;
typedef struct
{
int sub[BUFFER_SUB];
sem_t mutex,empty,full;
}sub_tot;
int main(int argc, char *argv[])
{
int x = 0;
int data,count,i,j,tot;
int …我有两个关于互斥体的问题： 1. 当互斥体变量等于 1 时，我们对其进行 signal() 操作，预计会发生什么？2. 当互斥量等于0时，我们执行wait()，然后线程被阻塞，互斥量保持为0。正确吗？过了一会儿，另一个线程进行signal()操作，然后阻塞被释放。现在互斥量的值是多少？0还是1？
全面披露：虽然这不是针对课程的，但它是一个简化的示例，涉及我之前的作业（现已通过）中遇到的问题。
考虑使用 POSIX 共享内存在两个进程之间传输文件。生产者进程共享从文件中读取的内容，并将其按块写入共享内存区域；消费者进程从该区域读取一大块字节并将其写出（例如写入文件）。起初，我尝试了一种简单的同步方法 - 只是锁定对信号量中共享内存的访问 - 但当然，这允许单个写入/读取的多个读取/写入。
我想我已经找到了一种方法来做到这一点，即使用第二个共享内存区域，根据其当前值阻止对读取器或写入器的访问。然后，用伪代码：
before request begins:
initialize shared memory region SHM
initialize synchronization region SHM2 = "0"
initialize sem
consumer:
loop until total bytes read = file length:
while (SHM2 == "0" [lock access to SHM2 while checking]):
wait
read N bytes from SHM
write N bytes to file
sem_wait(sem)
set SHM2 = "0"
sem_post(sem)
producer:
loop until total bytes written = file length:
while (SHM2 == "1" [lock access to SHM2 while checking]): …I have a very basic doubt.
当进程正在等待信号量时，它会进入睡眠状态。所以它无法轮询信号量值。
内核是否轮询信号量值，如果可用，向所有等待它的进程发送信号？如果是这样，内核的开销不会太大。
或者 signal() 调用在内部通知所有等待信号量的进程。请让我知道这一点。
我的 WCF 应用程序必须调用一个没有任何并发检查的服务。它是由第三方创建的服务，可能无法让他们添加并发检查。
我可以确保调用第三方服务的唯一方法是通过我的 WCF 应用程序。所以我正在考虑在我的代码中加入并发检查。
为此，我将使用唯一描述正在修改的数据的标识符。这个想法是，如果对服务的一次调用正在修改与标识符相关的数据，那么对该标识符的其他调用将需要等到它完成。
我的 WCF 服务是负载平衡的。我可以在不同的虚拟机上同时运行多达 16 个实例。
因此，大多数处理同步的 .NET 类都假定共享内存空间。
是否有标准的“最佳实践”类型的方法来为服务的负载平衡实例进行同步？
我曾考虑使用数据库表 (SQL Server) 来尝试管理它，但从架构的角度来看，将我的持久层用于此目的似乎是错误的。我希望有另一种解决方案。
如何跨机器进行同步（锁、互斥、信号量等）？（最好不使用数据库表来管理它。）
我有两个 Java 文件：
检查.java
import java.util.concurrent.Semaphore;
class Check
{
public static void main(String[] args)
{
Semaphore s = new Semaphore(1);
MyThread t1 = new MyThread("t1",s);
MyThread t2 = new MyThread("t2",s);
t1.start();
t2.start();
t2.interrupt();
}
}
MyThread.java
import java.util.concurrent.Semaphore;
class MyThread extends Thread
{
Semaphore s;
MyThread(String name, Semaphore s)
{
super(name);
this.s=s;
}
public void run()
{
try
{
s.acquireUninterruptibly();
for(int i=0; i<5; i++)
{
Thread.sleep(500);
System.out.println(Thread.currentThread().getName()+"-"+i);
}
s.release();
}
catch(InterruptedException e){}
}
}
如果我注释掉语句“t2.interrupt()”，那么两个线程都可以正常执行。但如果我不评论该语句，那么线程 t2 根本不会执行。根据我对 acquireUninterruptically() 方法的理解，线程 t2 …
试图：
public interface ISemaphore
{
void Aquire();
void Release();
}
public class SpinlockSemaphore : ISemaphore
{
private int _cur;
private const int B = 1;
private const int A = 0;
public SpinlockSemaphore()
{
this._cur = A;
}
public void Aquire()
{
// Locally named variables for clarity. Could obviously be
// condensed to something like:
// while (Interlocked.CompareExchange(ref this._cur, B, A) != A);
var flipped = false;
do
{
// Flip to B only if it is A
var …我需要一段代码，根据参数键只允许同时由 1 个线程执行：
private static readonly ConcurrentDictionary<string, SemaphoreSlim> Semaphores = new();
private async Task<TModel> GetValueWithBlockAsync<TModel>(string valueKey, Func<Task<TModel>> valueAction)
{
var semaphore = Semaphores.GetOrAdd(valueKey, s => new SemaphoreSlim(1, 1));
try
{
await semaphore.WaitAsync();
return await valueAction();
}
finally
{
semaphore.Release(); // Exception here - System.ObjectDisposedException
if (semaphore.CurrentCount > 0 && Semaphores.TryRemove(valueKey, out semaphore))
{
semaphore?.Dispose();
}
}
}
我时不时地收到错误：
The semaphore has been disposed. : System.ObjectDisposedException: The semaphore has been disposed.
at System.Threading.SemaphoreSlim.CheckDispose()
at System.Threading.SemaphoreSlim.Release(Int32 releaseCount)
at Project.GetValueWithBlockAsync[TModel](String valueKey, Func`1 valueAction) …