blocks|key|3354357|text|您可能想要考虑自旋锁，它在单处理器中执行繁忙等待并且不需要semaphore.However，不使用自旋锁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3354358|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You might want to think about spin-locks which do busy-waiting and do not require semaphore.However in a uniprocessor spin-locks are not used.

blocks|key|1671578|text|锁可以通过Thread:Sleep来实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1671579|class+Lock+{
++public:
++++Lock(char*+debugName);++++++++++//+initialize+lock+to+be+FREE
++++~Lock();++++++++++++++++//+deallocate+lock
++++char*+getName()+{+return+name;+}++++//+debugging+assist

++++void+Acquire();+//+these+are+the+only+operations+on+a+lock
++++void+Release();+//+they+are+both+*atomic*

++++bool+isHeldByCurrentThread()+{+return+(thread+==+currentThread);+}++//+true+if+the+current+thread
++++++++++++++++++++//+holds+this+lock.++Useful+for
++++++++++++++++++++//+checking+in+Release,+and+in
++++++++++++++++++++//+Condition+variable+ops+below.

++private:
++++char*+name;+++++++++++++//+for+debugging
++++//+plus+some+other+stuff+you'll+need+to+define
++++Thread+*thread;+++++//the+thread+who+holds+this+lock
++++enum+value+{FREE,+BUSY};
++++List+*queue;
};

Lock::Lock(char*+debugName):name(debugName),+thread(NULL),+value(FREE),+queue(new+List())
{+}
Lock::~Lock()
{
++++delete+queue;
}
void+Lock::Acquire()
{
++++IntStatus+oldLevel+=+interrupt->SetLevel(IntOff);+++//+disable+interrupts
++++if+(value+==+BUSY)+{
++++++++queue->Append((void+*)currentThread);
++++++++currentThread->Sleep();
++++}
++++value+=+BUSY;
++++thread+=+currentThread;
++++(void)+interrupt->SetLevel(oldLevel);+++//+re-enable+interrupts
}
void+Lock::Release()
{
++++Thread+*nextThread;
++++IntStatus+oldLevel+=+interrupt->SetLevel(IntOff);+++//+disable+interrupts
++++nextThread+=+(Thread+*)queue->Remove();
++++if+(nextThread+!=+NULL)++++//+make+thread+ready,+consuming+the+V+immediately
++++++++scheduler->ReadyToRun(nextThread);
++++value+=+FREE;
++++(void)+interrupt->SetLevel(oldLevel);+++//+re-enable+interrupts
}|code-block|syntax|javascript|1671580|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Lock can be implemented by Thread:Sleep.

<pre><code>class Lock {
 public:
 Lock(char* debugName); // initialize lock to be FREE
 ~Lock(); // deallocate lock
 char* getName() { return name; } // debugging assist

 void Acquire(); // these are the only operations on a lock
 void Release(); // they are both *atomic*

 bool isHeldByCurrentThread() { return (thread == currentThread); } // true if the current thread
 // holds this lock. Useful for
 // checking in Release, and in
 // Condition variable ops below.

 private:
 char* name; // for debugging
 // plus some other stuff you'll need to define
 Thread *thread; //the thread who holds this lock
 enum value {FREE, BUSY};
 List *queue;
};

Lock::Lock(char* debugName):name(debugName), thread(NULL), value(FREE), queue(new List())
{ }
Lock::~Lock()
{
 delete queue;
}
void Lock::Acquire()
{
 IntStatus oldLevel = interrupt-&gt;SetLevel(IntOff); // disable interrupts
 if (value == BUSY) {
 queue-&gt;Append((void *)currentThread);
 currentThread-&gt;Sleep();
 }
 value = BUSY;
 thread = currentThread;
 (void) interrupt-&gt;SetLevel(oldLevel); // re-enable interrupts
}
void Lock::Release()
{
 Thread *nextThread;
 IntStatus oldLevel = interrupt-&gt;SetLevel(IntOff); // disable interrupts
 nextThread = (Thread *)queue-&gt;Remove();
 if (nextThread != NULL) // make thread ready, consuming the V immediately
 scheduler-&gt;ReadyToRun(nextThread);
 value = FREE;
 (void) interrupt-&gt;SetLevel(oldLevel); // re-enable interrupts
}
</code></pre>

blocks|key|1671591|text|首先检查锁的当前持有者是否是当前线程。然后使用中断开关和休眠来实现锁定。在线程从睡眠中唤醒之后，它应该再次检查锁是繁忙的还是空闲的，因为唤醒线程只会将其传递到就绪队列。在此线程可以获取锁之前，某个其他线程可能会同时再次获取锁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1671592|void+Lock::Acquire()+{
++++ASSERT(!isHeldByCurrentThread());++//+cannot+acquire+a+lock+twice

++++IntStatus+oldLevel+=+interrupt->SetLevel(IntOff);+++//+disable+interrupts
++++while+(freeOrBusy+==+'b')+{
++++++++queue->Append((void+*)currentThread);
++++++++currentThread->Sleep();
++++}
++++freeOrBusy+=+'b';
++++currentHolder+=+currentThread;
++++(void)+interrupt->SetLevel(oldLevel);+++//+re-enable+interrupts
}

void+Lock::Release()+{
++++ASSERT(isHeldByCurrentThread());

++++IntStatus+oldLevel+=+interrupt->SetLevel(IntOff);
++++freeOrBusy+=+'f';
++++currentHolder+=+NULL;

++++Thread+*thread+=+(Thread+*)queue->Remove();+++//+"queue"+is+the+list+of+threads+waiting
++++if+(thread+!=+NULL)++++//+make+thread+ready
+++++++scheduler->ReadyToRun(thread);++

++++(void)+interrupt->SetLevel(oldLevel);

}|code-block|syntax|javascript|1671593|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

At first check whether the current holder of the lock is the current thread or not. Then use interrupt on-off and sleep to achieve lock. After a thread wakes from sleep, it should again check whether the lock is busy or free, because waking up a thread only passes it to the ready queue. Some other thread may meanwhile acquire the lock again before this thread can acquire the lock.

<pre><code>void Lock::Acquire() {
 ASSERT(!isHeldByCurrentThread()); // cannot acquire a lock twice

 IntStatus oldLevel = interrupt-&gt;SetLevel(IntOff); // disable interrupts
 while (freeOrBusy == 'b') {
 queue-&gt;Append((void *)currentThread);
 currentThread-&gt;Sleep();
 }
 freeOrBusy = 'b';
 currentHolder = currentThread;
 (void) interrupt-&gt;SetLevel(oldLevel); // re-enable interrupts
}

void Lock::Release() {
 ASSERT(isHeldByCurrentThread());

 IntStatus oldLevel = interrupt-&gt;SetLevel(IntOff);
 freeOrBusy = 'f';
 currentHolder = NULL;

 Thread *thread = (Thread *)queue-&gt;Remove(); // "queue" is the list of threads waiting
 if (thread != NULL) // make thread ready
 scheduler-&gt;ReadyToRun(thread); 

 (void) interrupt-&gt;SetLevel(oldLevel);

}
</code></pre>

I am working on a school project (explains my restrictions in the question). My question is how to implement locks without semaphores in NACHOS. Although a NACHOS specific answer would be great, what I am looking for is a push in the right direction. So far, from my understanding, monitors use locks which use semaphores (mutexes really). Initially we thought to replace semaphores with monitors to implement locks, however, that didn't make sense.

Implement locks without semaphores

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在做一个学校项目(解释了我在问题中的限制)。我的问题是如何在NACHOS中实现没有信号量的锁。虽然玉米片的具体答案会很好，但我正在寻找的是在正确的方向上推动。到目前为止，根据我的理解，监视器使用的锁使用信号量(实际上是互斥)。最初，我们认为用监视器替换信号量来实现锁，然而，这没有意义。

问实现不带信号量的锁
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问实现不带信号量的锁EN