我目前正在接受以前迭代的OS考试培训,我遇到了这个:
实现"N进程障碍",即确保一组中的每个进程在其各自的执行中的某个时刻等待其他进程到达其给定点.
您有以下操作:
init(sem,value), wait(sem) and signal(sem)
N是任意数.我可以使它适用于给定数量的进程,但不适用于任何数字.
有任何想法吗？用伪代码回复是可以的,这不是一项任务,只是个人学习.
computer-science operating-system semaphore systems-programming barrier
我需要停止一个线程,直到另一个线程设置一个布尔值,我不想在它们之间共享一个事件.
我目前所拥有的是使用Sleep的以下代码(这是我想要更改的代码):
while (!_engine.IsReadyToStop())
{
System.Threading.Thread.Sleep(Properties.Settings.Default.IntervalForCheckingEngine);
}
有任何想法吗？
编辑澄清事:
我不拥有一个名为_engine的对象.我无法修改它,这就是为什么我不想在它们之间共享事件.我需要等到该类的方法返回true.
非二进制的..
我从未遇到过要求我使用信号量而不是互斥量的问题.那么这主要是理论上的构造,还是像Office这样的真实流行,Firefox有哪些地方可以使用它？如果是这样,信号量的常用模式是什么？
我会假设我知道如何使用DispatchGroup,为了解问题,我尝试过:
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
performUsingGroup()
}
func performUsingGroup() {
let dq1 = DispatchQueue.global(qos: .userInitiated)
let dq2 = DispatchQueue.global(qos: .userInitiated)
let group = DispatchGroup()
group.enter()
dq1.async {
for i in 1...3 {
print("\(#function) DispatchQueue 1: \(i)")
}
group.leave()
}
group.wait()
dq2.async {
for i in 1...3 {
print("\(#function) DispatchQueue 2: \(i)")
}
}
group.notify(queue: DispatchQueue.main) {
print("done by group")
}
}
}
结果 - 预期 - 是:
performUsingGroup() DispatchQueue 1: 1
performUsingGroup() DispatchQueue …我想检查a的状态Semaphore以查看是否发出信号(如果发出信号,我可以发布它).我怎样才能做到这一点？
EDIT1:
我有两个线程,一个会等待信号量,另一个应该释放一个Semaphore.问题是Release()当第一个线程没有等待它时,第二个线程可能会多次调用.所以第二个线程应该检测到,如果它调用Release()它会生成任何错误(如果你试图释放信号量,如果没有人等待它,它会产生错误).我怎样才能做到这一点？我知道我可以使用旗帜来做到这一点,但它很难看.有没有更好的方法？
我试图理解公平性在Semaphore课堂上的用处.
特别引用Javadoc提到:
通常,用于控制资源访问的信号量应初始化为公平,以确保没有线程缺乏访问资源.当将信号量用于其他类型的同步控制时,非公平排序的吞吐量优势通常超过公平性考虑.
有人可以提供一个例子,在这里可能需要趸船.我想不到过去的资源访问用例.另外,为什么默认是非公平行为？
最后,使用公平行为是否有任何性能影响？
POSIX 匿名信号量允许我在共享内存中创建和使用信号量。这非常有效，因为这意味着不应访问信号量的其他进程也无法访问信号量。此外，它很容易融入现有结构。
Windows 提供类似的功能吗？我发现的最接近的事情是CreateSemaphore在没有名字的情况下打电话，然后将其继承或DuplicateHandle()传给孩子。
编辑：@IInspectable 希望我提供背景信息。我计划通过共享内存实现一种 RPC 系统。共享内存中的数据如下所示：
struct shm_rpc_block {
enum rpc_state {
send = 0,
receive
};
rpc_state state;
sem_t lock;
char data[2048 - sizeof(rpc_state) - sizeof(sem_t)];
};
该state变量从“发送”状态开始。进程 1 将其数据写入数组data，然后将状态更改为“接收”并解锁，从而允许进程 2 锁定。进程2读取发送的数据，生成响应，然后将其发回。然后第一个进程读取结果，并将 RPC 状态重置为“发送”。
我有两种方法
-(void) a {
@synchronized(self) {
// critical section 1
}
}
-(void) b {
@synchronized(self) {
// critical section 2
}
}
现在我的问题是,如果一个线程处于关键部分1,那么关键部分2是否会被其他线程锁定,或者其他线程可以访问关键部分2.
我正在研究Ruby中"Fair Barbershop"问题的实现.这是一个课堂作业,但我不是在寻找任何讲义.我一直在寻找疯狂,但我似乎无法找到一个反映在C中找到的信号量的Ruby实现.
我知道有Mutex,这很棒.单一实现,确实完成了那种信号量应该做的事情.
那就是条件变量.我认为这样做会很好,但是看看这些,他们需要一个Mutex用于每次等待调用,这对我来说就像我不能将数值放到信号量上(因为我有七个理发店,3理发师等).
我想我需要一个Counting Semaphore,但我认为Ruby(我能找到的)在其核心中包含这样一个类有点奇怪.谁能帮助我指出正确的方向？
当我在 Python 3.7 中运行此代码时：
import asyncio
sem = asyncio.Semaphore(2)
async def work():
async with sem:
print('working')
await asyncio.sleep(1)
async def main():
await asyncio.gather(work(), work(), work())
asyncio.run(main())
它因运行时错误而失败：
$ python3 demo.py
working
working
Traceback (most recent call last):
File "demo.py", line 13, in <module>
asyncio.run(main())
File "/opt/local/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/runners.py", line 43, in run
return loop.run_until_complete(main)
File "/opt/local/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/base_events.py", line 584, in run_until_complete
return future.result()
File "demo.py", line 11, in main
await asyncio.gather(work(), work(), work())
File "demo.py", line 6, in work
async with sem:
File …