Mutex Class Reference

互斥锁（Mutex） More...

#include <mutex.hpp>

Collaboration diagram for Mutex:

Public Member Functions
auto	Lock () -> Expected< void >
	获取锁（阻塞）
auto	UnLock () -> Expected< void >
	释放锁
auto	TryLock () -> Expected< void >
	尝试获取锁（非阻塞）
auto	IsLockedByCurrentTask () const -> bool
	检查锁是否被当前线程持有
构造/析构函数
	Mutex (const char *_name)
	Mutex ()=default
	Mutex (const Mutex &)=delete
	Mutex (Mutex &&)=delete
auto	operator= (const Mutex &) -> Mutex &=delete
auto	operator= (Mutex &&) -> Mutex &=delete
	~Mutex ()=default

Public Attributes
const char *	name {"unnamed_mutex"}
	锁的名称

Protected Attributes
std::atomic< bool >	locked_ {false}
	锁状态
std::atomic< Pid >	owner_ {std::numeric_limits<Pid>::max()}
	持有锁的任务 ID，max() 表示未被持有
ResourceId	resource_id_ {}
	资源 ID，用于任务阻塞队列

Detailed Description

互斥锁（Mutex）

Copyright

Copyright The SimpleKernel Contributors

实现基于任务调度的互斥锁：

• 当锁被占用时，请求线程会被阻塞并进入等待队列
• 当锁释放时，会唤醒一个等待线程
• 支持所有者跟踪和递归检测

Note

使用限制：

1. 不可重入：同一线程不能递归获取同一锁
2. 所有权：必须由获取锁的线程释放锁
3. 阻塞语义：获取锁失败时会阻塞当前任务
4. 必须在任务上下文中使用：不能在中断处理程序中使用

Definition at line 30 of file mutex.hpp.

Constructor & Destructor Documentation

Mutex() [1/4]

Mutex::Mutex ( const char *  _name )

inlineexplicit

Definition at line 73 of file mutex.hpp.

      : name(_name),
        resource_id_(ResourceType::kMutex, reinterpret_cast<uint64_t>(this)) {}

Mutex() [2/4]

Mutex::Mutex ( )

default

Mutex() [3/4]

Mutex::Mutex ( const Mutex &  )

delete

Mutex() [4/4]

Mutex::Mutex ( Mutex &&  )

delete

~Mutex()

Mutex::~Mutex ( )

default

Member Function Documentation

IsLockedByCurrentTask()

auto Mutex::IsLockedByCurrentTask

(

)

const -> bool

检查锁是否被当前线程持有

Returns

true 当前线程持有锁

false 当前线程未持有锁

Definition at line 99 of file mutex.cpp.

                                                {
  auto current_task = TaskManagerSingleton::instance().GetCurrentTask();
  if (current_task == nullptr) {
    return false;
  }
 
  return locked_.load(std::memory_order_acquire) &&
         owner_.load(std::memory_order_acquire) == current_task->pid;
}

Lock()

auto Mutex::Lock

(

)

-> Expected<void>

获取锁（阻塞）

如果锁已被其他线程持有，当前线程将被阻塞直到锁可用。 如果当前线程已持有锁，返回错误（不支持递归）。

Returns

Expected<void> 成功返回空值，失败返回错误

Copyright

Copyright The SimpleKernel Contributors

Definition at line 11 of file mutex.cpp.

                                   {
  auto current_task = TaskManagerSingleton::instance().GetCurrentTask();
  if (current_task == nullptr) {
    klog::Err("Mutex::Lock: Cannot lock mutex '{}' outside task context", name);
    return std::unexpected(Error{ErrorCode::kMutexNoTaskContext});
  }
 
  Pid current_pid = current_task->pid;
 
  if (IsLockedByCurrentTask()) {
    klog::Warn("Mutex::Lock: Task {} tried to recursively lock mutex '{}'",
               current_pid, name);
    return std::unexpected(Error{ErrorCode::kMutexRecursiveLock});
  }
 
  bool expected = false;
  while (!locked_.compare_exchange_weak(
      expected, true, std::memory_order_acquire, std::memory_order_relaxed)) {
    klog::Debug("Mutex::Lock: Task {} blocking on mutex '{}'", current_pid,
                name);
    TaskManagerSingleton::instance().Block(resource_id_);
 
    expected = false;
  }
 
  owner_.store(current_pid, std::memory_order_release);
  klog::Debug("Mutex::Lock: Task {} acquired mutex '{}'", current_pid, name);
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

auto Mutex::operator= ( const Mutex &  ) -> Mutex &=delete

delete

operator=() [2/2]

auto Mutex::operator= ( Mutex &&  ) -> Mutex &=delete

delete

TryLock()

auto Mutex::TryLock

(

)

-> Expected<void>

尝试获取锁（非阻塞）

尝试获取锁，如果锁不可用则立即返回。

Returns

Expected<void> 成功返回空值，失败返回错误

Definition at line 68 of file mutex.cpp.

                                      {
  auto current_task = TaskManagerSingleton::instance().GetCurrentTask();
  if (current_task == nullptr) {
    klog::Err("Mutex::TryLock: Cannot trylock mutex '{}' outside task context",
              name);
    return std::unexpected(Error{ErrorCode::kMutexNoTaskContext});
  }
 
  Pid current_pid = current_task->pid;
 
  if (IsLockedByCurrentTask()) {
    klog::Debug(
        "Mutex::TryLock: Task {} tried to recursively trylock mutex '{}'",
        current_pid, name);
    return std::unexpected(Error{ErrorCode::kMutexRecursiveLock});
  }
 
  bool expected = false;
  if (locked_.compare_exchange_strong(expected, true, std::memory_order_acquire,
                                      std::memory_order_relaxed)) {
    owner_.store(current_pid, std::memory_order_release);
    klog::Debug("Mutex::TryLock: Task {} acquired mutex '{}'", current_pid,
                name);
    return {};
  }
 
  klog::Debug("Mutex::TryLock: Task {} failed to acquire mutex '{}'",
              current_pid, name);
  return std::unexpected(Error{ErrorCode::kMutexNotLocked});
}

Here is the call graph for this function:

UnLock()

auto Mutex::UnLock

(

)

-> Expected<void>

释放锁

释放锁并唤醒一个等待线程（如果有）。 只能由持有锁的线程调用。

Returns

Expected<void> 成功返回空值，失败返回错误

Definition at line 41 of file mutex.cpp.

                                     {
  auto current_task = TaskManagerSingleton::instance().GetCurrentTask();
  if (current_task == nullptr) {
    klog::Err("Mutex::UnLock: Cannot unlock mutex '{}' outside task context",
              name);
    return std::unexpected(Error{ErrorCode::kMutexNoTaskContext});
  }
 
  Pid current_pid = current_task->pid;
 
  if (!IsLockedByCurrentTask()) {
    klog::Warn(
        "Mutex::UnLock: Task {} tried to unlock mutex '{}' it doesn't own",
        current_pid, name);
    return std::unexpected(Error{ErrorCode::kMutexNotOwned});
  }
 
  owner_.store(std::numeric_limits<Pid>::max(), std::memory_order_release);
  locked_.store(false, std::memory_order_release);
 
  klog::Debug("Mutex::UnLock: Task {} released mutex '{}'", current_pid, name);
 
  TaskManagerSingleton::instance().Wakeup(resource_id_);
 
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

locked_

std::atomic<bool> Mutex::locked_ {false}

protected

锁状态

Definition at line 87 of file mutex.hpp.

{false};

name

const char* Mutex::name {"unnamed_mutex"}

锁的名称

Definition at line 33 of file mutex.hpp.

{"unnamed_mutex"};

owner_

std::atomic<Pid> Mutex::owner_ {std::numeric_limits<Pid>::max()}

protected

持有锁的任务 ID，max() 表示未被持有

Definition at line 90 of file mutex.hpp.

{std::numeric_limits<Pid>::max()};

resource_id_

ResourceId Mutex::resource_id_ {}

protected

资源 ID，用于任务阻塞队列

Definition at line 93 of file mutex.hpp.

{};

---

The documentation for this class was generated from the following files:

• /workspaces/SimpleKernel/src/include/mutex.hpp
• /workspaces/SimpleKernel/src/task/mutex.cpp