What is the Swift equivalent to Objective-C s synchronized

Question

I ve searched the Swift book  but can t find the Swift version of  synchronized  How do I do mutual exclusion in Swift

User · Answer

Using Bryan McLemore answer  I extended it to support objects that throw in a safe manor with the Swift 2 0 defer ability     func synchronized  lock AnyObject  block    throws - gt  Void   rethrows       objc sync enter lock      defer           objc sync exit lock             try block

User · Answer

Try  NSRecursiveLock     A lock that may be acquired multiple times by the same thread without   causing a deadlock    let lock   NSRecursiveLock    func f         lock lock         Your Code     lock unlock      func f2         lock lock       defer           lock unlock               Your Code

User · Answer

I like and use many of the answers here  so I d choose whichever works best for you   That said  the method I prefer when I need something like objective-c s  synchronized uses the defer statement introduced in swift 2          objc sync enter lock      defer   objc sync exit lock                   code of critical section goes here               lt -- lock released when this block is exited   The nice thing about this method  is that your critical section can exit the containing block in any fashion desired  e g   return  break  continue  throw   and  the statements within the defer statement are executed no matter how program control is transferred  1

User · Answer

Use NSLock in Swift4   let lock   NSLock   lock lock   if isRunning    true           print  Service IS running    gt  please wait           return   else       print  Service not running     isRunning   true lock unlock        Warning   The NSLock class uses POSIX threads to implement its locking behavior  When sending an unlock message to an NSLock object  you must be sure that message is sent from the same thread that sent the initial lock message  Unlocking a lock from a different thread can result in undefined behavior

User · Answer

Another method is to create a superclass and then inherit it  This way you can use GCD more directly  class Lockable       let lockableQ dispatch queue t      init             lockableQ   dispatch queue create  com blah blah   self dynamicType    DISPATCH QUEUE SERIAL             func lock closure     - gt                dispatch sync lockableQ  closure            class Foo  Lockable        func boo             lock                       do something

User · Answer

You can use GCD  It is a little more verbose than  synchronized  but works as a replacement   let serialQueue   DispatchQueue label   com test mySerialQueue   serialQueue sync          code

User · Answer

Why make it difficult and hassle with locks  Use Dispatch Barriers   A dispatch barrier creates a synchronization point within a concurrent queue   While it   s running  no other block on the queue is allowed to run  even if it   s concurrent and other cores are available   If that sounds like an exclusive  write  lock  it is  Non-barrier blocks can be thought of as shared  read  locks    As long as all access to the resource is performed through the queue  barriers provide very cheap synchronization

User · Answer

In conclusion  Here give more common way that include return value or void  and throw  import Foundation  extension NSObject         func synchronized lt T gt  lockObj  AnyObject   closure     throws - gt  T  rethrows - gt   T               objc sync enter lockObj          defer               objc sync exit lockObj                     return try closure

User · Answer

With Swift s property wrappers  this is what I m using now    propertyWrapper public struct NCCSerialized lt Wrapped gt        private let queue   DispatchQueue label   com nuclearcyborg NCCSerialized   UUID   uuidString         private var  wrappedValue  Wrapped     public var wrappedValue  Wrapped           get   queue sync    wrappedValue             set   queue sync    wrappedValue   newValue                public init wrappedValue  Wrapped            self  wrappedValue   wrappedValue           Then you can just do    NCCSerialized var foo  Int   10   or   NCCSerialized var myData   SomeStruct         Then access the variable as you normally would

User · Answer

To add return functionalty  you could do this   func synchronize lt T gt  lockObj  AnyObject   closure    - gt T  - gt  T     objc sync enter lockObj    var retVal  T   closure     objc sync exit lockObj    return retVal     Subsequently  you can call it using   func importantMethod      - gt  Bool     return synchronize self        if feelLikeReturningTrue    return true          do other things     if feelLikeReturningTrueNow    return true          more things     return whatIFeelLike   true   false

User · Answer

dispatch barrier async is the better way  while not blocking current thread   dispatch barrier async accessQueue                            dictionary object ID    object

User · Answer

Figure I ll post my Swift 5 implementation  built off of the prior answers  Thanks guys  I found it helpful to have one that returns a value too  so I have two methods   Here is a simple class to make first   import Foundation class Sync   public class func synced   lock  Any  closure     - gt                objc sync enter lock          defer   objc sync exit lock            closure             public class func syncedReturn   lock  Any  closure     - gt   Any    - gt  Any            objc sync enter lock          defer   objc sync exit lock            return closure             Then use it like so if needing a return value    return Sync syncedReturn self  closure           some code here     return  hello world       Or   Sync synced self  closure           do some work synchronously

User · Answer

In modern Swift 5  with return capability       Makes sure no other thread reenters the closure before the one running has not returned     discardableResult public func synchronized lt T gt    lock  AnyObject  closure    - gt  T  - gt  T       objc sync enter lock      defer   objc sync exit lock         return closure       Use it like this  to take advantage the return value capability   let returnedValue   synchronized self             Your code here      return yourCode       Or like that otherwise   synchronized self             Your code here     yourCode

User · Answer

Analog of the  synchronized directive from Objective-C can have an arbitrary return type and nice rethrows behaviour in Swift      Swift 3 func synchronized lt T gt    lock  AnyObject    body     throws - gt  T  rethrows - gt  T       objc sync enter lock      defer   objc sync exit lock        return try body       The use of the defer statement lets directly return a value without introducing a temporary variable     In Swift 2 add the  noescape attribute to the closure to allow more optimisations      Swift 2 func synchronized lt T gt  lock  AnyObject   noescape   body     throws - gt  T  rethrows - gt  T       objc sync enter lock      defer   objc sync exit lock        return try body       Based on the answers from GNewc  1   where I like arbitrary return type  and Tod Cunningham  2   where I like defer

User · Answer

You can sandwich statements between objc sync enter obj  AnyObject   and objc sync exit obj  AnyObject    The  synchronized keyword is using those methods under the covers  i e   objc sync enter self      synchronized code     objc sync exit self

User · Answer

I was looking for this myself and came to the conclusion there s no native construct inside of swift for this yet   I did make up this small helper function based on some of the code I ve seen from Matt Bridges and others   func synced   lock  Any  closure     - gt            objc sync enter lock      closure       objc sync exit lock      Usage is pretty straight forward  synced self        println  This is a synchronized closure       There is one problem I ve found with this   Passing in an array as the lock argument seems to cause a very obtuse compiler error at this point   Otherwise though it seems to work as desired   Bitcast requires both operands to be pointer or neither    26   bitcast i64  25 to  objc object    dbg  378 LLVM ERROR  Broken function found  compilation aborted

User · Answer

Details Xcode 8 3 1  Swift 3 1 Task Read write value from different threads  async   Code class AsyncObject lt T gt  CustomStringConvertible       private var  value  T     public private set  var dispatchQueueName  String         let dispatchQueue  DispatchQueue          init  value  T  dispatchQueueName  String             value   value         self dispatchQueueName   dispatchQueueName         dispatchQueue   DispatchQueue label  dispatchQueueName                 func setValue with closure   escaping    currentValue  T - gt  T              dispatchQueue sync    weak self  in             if let  self   self                    self  value   closure  self  value                                         func getValue with closure   escaping    currentValue  T - gt                dispatchQueue sync    weak self  in             if let  self   self                   closure  self  value                                              var value  T           get               return dispatchQueue sync    value                              set  newValue                dispatchQueue sync    value   newValue                        var description  String           return  quot    value  quot           Usage print  quot Single read write action quot      Use it when when you need to make single action let obj   AsyncObject lt Int gt  value  0  dispatchQueueName   quot Dispatch0 quot   obj value   100 let x   obj value print x   print  quot Write action in block quot      Use it when when you need to make many action obj setValue   current  - gt   Int  in     let newValue   current 2     print  quot previous    current   new    newValue  quot       return newValue    Full Sample  extension DispatchGroup  extension DispatchGroup            class func loop repeatNumber  Int  action   escaping    index  Int - gt     completion   escaping   - gt               let group   DispatchGroup           for index in 0   repeatNumber               group enter               DispatchQueue global qos   utility  async                   action index                  group leave                                            group notify queue  DispatchQueue global qos   userInitiated                 completion                       class ViewController  import UIKit  class ViewController  UIViewController        override func viewDidLoad             super viewDidLoad              sample1           sample2                  func sample1             print  quot                                                   nsample with variable quot                    let obj   AsyncObject lt Int gt  value  0  dispatchQueueName   quot Dispatch1 quot                    DispatchGroup loop repeatNumber  5  action    index in             obj value   index                          print  quot   obj value  quot                            func sample2             print  quot  n                                                  nsample with array quot           let arr   AsyncObject lt  Int  gt  value      dispatchQueueName   quot Dispatch2 quot           DispatchGroup loop repeatNumber  15  action    index in             arr setValue   current  - gt    Int   in                 var array   current                 array append index index                  print  quot index    index   value   array array count-1   quot                   return array                                        print  quot   arr value  quot

User · Answer

Swift 3   This code has the re-entry ability and can work with Asynchronous function calls  In this code  after someAsyncFunc   is called  another function closure on the serial queue will process but be blocked by semaphore wait   until signal   is called   internalQueue sync shouldn t be used as it will block the main thread if I m not mistaken   let internalQueue   DispatchQueue label   serialQueue   let semaphore   DispatchSemaphore value  1   internalQueue async        self semaphore wait           Critical section      someAsyncFunc                 Do some work here          self semaphore signal             objc sync enter objc sync exit isn t a good idea without error handling

User · Answer

SWIFT 4  In Swift 4 you can use GCDs dispatch queues to lock resources    class MyObject       private var internalState  Int   0     private let internalQueue  DispatchQueue   DispatchQueue label  LockingQueue      Serial by default      var state  Int           get               return internalQueue sync   internalState                      set  newState                internalQueue sync   internalState   newState

User · Answer

In the  Understanding Crashes and Crash Logs  session 414 of the 2018 WWDC they show the following way using DispatchQueues with sync    In swift 4 should be something like the following   class ImageCache       private let queue   DispatchQueue label   sync queue       private var storage   String  UIImage            public subscript key  String  - gt  UIImage            get             return queue sync               return storage key                                set             queue sync               storage key    newValue                                 Anyway you can also make reads faster using concurrent queues with barriers  Sync and async reads are performed concurrently and writing a new value waits for previous operations to finish    class ImageCache       private let queue   DispatchQueue label   with barriers   attributes   concurrent      private var storage   String  UIImage             func get   key  String  - gt  UIImage            return queue sync    weak self  in             guard let self   self else   return nil               return self storage key                       func set   image  UIImage  for key  String            queue async flags   barrier     weak self  in             guard let self   self else   return               self storage key    image

User · Answer

Based on  eurobur   test an sub-class case  class Foo  NSObject       func test             print  1           objc sync enter self          defer               objc sync exit self              print  3                      print  2             class Foo2  Foo       override func test             super test            print  11           objc sync enter self          defer               print  33               objc sync exit self                     print  22            let test   Foo2   test test     Output   1 2 3 11 22 33

[concurrency] What is the Swift equivalent to Objective-C's "@synchronized"?

Examples related to concurrency

Examples related to mutex

Examples related to swift