@@ -52,83 +52,61 @@ extension Locking {
52
52
/// block efficiently on contention. This locking type behaves the same for both
53
53
/// read and write locks.
54
54
///
55
- /// - On recent versions of Darwin (iOS 10.0, macOS 12.0, tvOS 1.0, watchOS 3.0,
56
- /// or better), this efficiency is a guarantee.
55
+ /// - On Apple platforms (iOS, macOS, tvOS, watchOS, or better), this efficiency is a guarantee.
57
56
/// - On Linux, BSD, or Android, waiters perform comparably to a kernel lock
58
57
/// under contention.
59
58
public final class NativeLock : Locking {
60
- private let lock : UnsafeMutableRawPointer
59
+ #if canImport(os)
60
+ private let lock = UnsafeMutablePointer< os_unfair_lock> . allocate( capacity: 1 )
61
+ #else
62
+ private let lock = UnsafeMutablePointer< pthread_mutex_t> . allocate( capacity: 1 )
63
+ #endif
61
64
62
65
/// Creates a standard platform lock.
63
66
public init ( ) {
64
67
#if canImport(os)
65
- if #available( macOS 10 . 12 , iOS 10 . 0 , tvOS 10 . 0 , watchOS 3 . 0 , * ) {
66
- let lock = UnsafeMutablePointer< os_unfair_lock> . allocate( capacity: 1 )
67
- lock. initialize ( to: os_unfair_lock ( ) )
68
- self . lock = UnsafeMutableRawPointer ( lock)
69
- return
70
- }
71
- #endif
72
-
73
- let lock = UnsafeMutablePointer< pthread_mutex_t> . allocate( capacity: 1 )
68
+ lock. initialize ( to: os_unfair_lock ( ) )
69
+ #else
74
70
lock. initialize ( to: pthread_mutex_t ( ) )
75
71
pthread_mutex_init ( lock, nil )
76
- self . lock = UnsafeMutableRawPointer ( lock )
72
+ #endif
77
73
}
78
74
79
75
deinit {
80
- #if canImport(os)
81
- if #available( macOS 10 . 12 , iOS 10 . 0 , tvOS 10 . 0 , watchOS 3 . 0 , * ) {
82
- let lock = self . lock. assumingMemoryBound ( to: os_unfair_lock. self)
83
- lock. deinitialize ( count: 1 )
84
- lock. deallocate ( )
85
- return
86
- }
87
- #endif
88
-
89
- let lock = self . lock. assumingMemoryBound ( to: pthread_mutex_t. self)
76
+ #if !canImport(os)
90
77
pthread_mutex_destroy ( lock)
78
+ #endif
91
79
lock. deinitialize ( count: 1 )
92
80
lock. deallocate ( )
93
81
}
94
82
95
83
public func withReadLock< Return> ( _ body: ( ) throws -> Return ) rethrows -> Return {
96
84
#if canImport(os)
97
- if #available( macOS 10 . 12 , iOS 10 . 0 , tvOS 10 . 0 , watchOS 3 . 0 , * ) {
98
- let lock = self . lock. assumingMemoryBound ( to: os_unfair_lock. self)
99
- os_unfair_lock_lock ( lock)
100
- defer {
101
- os_unfair_lock_unlock ( lock)
102
- }
103
- return try body ( )
85
+ os_unfair_lock_lock ( lock)
86
+ defer {
87
+ os_unfair_lock_unlock ( lock)
104
88
}
105
- #endif
106
-
107
- let lock = self . lock. assumingMemoryBound ( to: pthread_mutex_t. self)
89
+ #else
108
90
pthread_mutex_lock ( lock)
109
91
defer {
110
92
pthread_mutex_unlock ( lock)
111
93
}
94
+ #endif
112
95
return try body ( )
113
96
}
114
97
115
98
public func withAttemptedReadLock< Return> ( _ body: ( ) throws -> Return ) rethrows -> Return ? {
116
99
#if canImport(os)
117
- if #available( macOS 10 . 12 , iOS 10 . 0 , tvOS 10 . 0 , watchOS 3 . 0 , * ) {
118
- let lock = self . lock. assumingMemoryBound ( to: os_unfair_lock. self)
119
- guard os_unfair_lock_trylock ( lock) else { return nil }
120
- defer {
121
- os_unfair_lock_unlock ( lock)
122
- }
123
- return try body ( )
100
+ guard os_unfair_lock_trylock ( lock) else { return nil }
101
+ defer {
102
+ os_unfair_lock_unlock ( lock)
124
103
}
125
- #endif
126
-
127
- let lock = self . lock. assumingMemoryBound ( to: pthread_mutex_t. self)
104
+ #else
128
105
guard pthread_mutex_trylock ( lock) == 0 else { return nil }
129
106
defer {
130
107
pthread_mutex_unlock ( lock)
131
108
}
109
+ #endif
132
110
return try body ( )
133
111
}
134
112
}
0 commit comments