1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/wtf/threading_primitives.h"
#include "base/check.h"
#include "base/threading/platform_thread.h"
namespace blink {
void RecursiveMutex::lock() {
auto thread_id = base::PlatformThread::CurrentId();
// Even though the thread checker doesn't complain, we are not guaranteed to
// hold the lock here. However, reading |owner_| is fine because it is only
// ever set to |CurrentId()| when the current thread owns the lock. It is
// reset to another value before releasing the lock.
//
// So the observed values can be:
// 1. Us: we hold the lock
// 2. Stale kInvalidThreadId, or some other ID: not a problem, cannot be the
// current thread ID (as it would be set by the current thread, and thus
// not stale, back to case (1))
// 3. Partial value: not possible, std::atomic<> protects from load shearing.
if (owner_.load(std::memory_order_relaxed) != thread_id) {
lock_.Acquire();
DCHECK_EQ(lock_depth_, 0u);
}
lock_.AssertAcquired();
UpdateStateAfterLockAcquired(thread_id);
}
void RecursiveMutex::unlock() {
AssertAcquired();
CHECK_GT(lock_depth_, 0u); // No underflow.
lock_depth_--;
if (lock_depth_ == 0) {
owner_.store(base::kInvalidThreadId, std::memory_order_relaxed);
lock_.Release();
}
}
bool RecursiveMutex::TryLock() {
auto thread_id = base::PlatformThread::CurrentId();
// See comment above about reading |owner_|.
if ((owner_.load(std::memory_order_relaxed) == thread_id) || lock_.Try()) {
UpdateStateAfterLockAcquired(thread_id);
return true;
}
return false;
}
void RecursiveMutex::UpdateStateAfterLockAcquired(
base::PlatformThreadId thread_id) {
lock_depth_++; // uint64_t, no overflow.
owner_.store(thread_id, std::memory_order_relaxed);
}
} // namespace blink
|
