Regarding iOS multithreading, it is enough for you to look at me

[[142590]]

In this article, I will sort out several multithreading solutions in iOS development, as well as their usage and precautions. Of course, I will also give several multithreading cases to experience their differences in actual use. Another thing to note is that this article will be explained in two languages ​​Swift and Objective-C. OK, let's begin!

Overview

In this article, I will not talk about what multithreading is, the difference between threads and processes, and the uses of multithreading. Of course, I will not talk about what serial is, what parallel is, etc. We should all know these.

There are actually 4 multi-threading solutions in iOS, they are:

• Pthreads
• NSThread
• GCD
• NSOperation & NSOperationQueue

So next, I will explain how to use these solutions and some cases one by one. While doing this, I will also talk about some multithreading peripheral products. For example: thread synchronization, delayed execution, singleton mode, etc.

Pthreads

In fact, this plan is self-explanatory, it is just used to fill in the numbers, so that everyone can understand it. Baidu Encyclopedia says this:

POSIX threads, or Pthreads for short, is the POSIX standard for threads. This standard defines a complete set of APIs for creating and manipulating threads. In Unix-like operating systems (Unix, Linux, Mac OS X, etc.), Pthreads are used as operating system threads.

Simply put, this is a set of multithreaded APIs that are common to many operating systems, so it is very portable (but it doesn't matter), and of course it can also be used in iOS. However, this is a framework based on C language, and it is so cool to use! Feel it:

OBJECTIVE-C

Of course, the first step is to include the header file

#import <pthread.h>

Then create a thread and execute the task

 - ( void )touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
 pthread_t thread;
 //Create a thread and execute it automatically  
    pthread_create(&thread, NULL, start, NULL);
 } 
 
 void *start( void *data) {
    NSLog(@ "%@" , [NSThread currentThread]); 
 
 return NULL;
 }

Print output:

2015-07-27 23:57:21.689 testThread[10616:2644653] <NSThread: 0x7fbb48d33690>{number = 2, name = (null)}

If you look at the code, you will find that it requires C language functions, which is quite annoying. What's even more annoying is that you need to manually handle the transitions between the various states of the thread, that is, manage the life cycle. For example, although this code creates a thread, it does not destroy it.

SWIFT

Unfortunately, I cannot execute this method in my current Swift 1.2 because this function needs to pass in a function pointer CFunctionPointer<T> type, but Swift cannot convert the method to this type. I heard that Swift 2.0 introduces a new feature @convention(c), which can complete the conversion of Swift methods into C language pointers. You can see it here

Well, that’s all I have to say about the multithreading of the Pthreads solution. After all, it is almost impossible to use it in iOS development. But if you are interested, or want to implement a multithreading solution yourself and customize it from the bottom up, you can search for relevant information.

NSThread

This solution is packaged by Apple and is completely object-oriented. So you can directly manipulate the thread object, which is very intuitive and convenient. However, its life cycle still needs to be managed manually, so this solution is only used occasionally. For example, [NSThread currentThread] can get the current thread class, so you can know the various properties of the current thread, which is very convenient for debugging. Let's take a look at some of its uses.

Create and start

• Create the thread class first, then start it

  OBJECTIVE-C

   // Create  
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector: @selector (run:) object:nil]; 
   
   // start up  
   [thread start];

  SWIFT

   //create  
    let thread = NSThread(target: self, selector: "run:" , object: nil) 
   
   //start up  
   thread.start()

• Create and automatically start

  OBJECTIVE-C

   [NSThread detachNewThreadSelector: @selector (run:) toTarget:self withObject:nil];

  SWIFT

   NSThread.detachNewThreadSelector( "run:" , toTarget: self, withObject: nil)

• Use NSObject methods to create and automatically start

  OBJECTIVE-C

   [self performSelectorInBackground: @selector (run:) withObject:nil];

  SWIFT

  Sadly too! Apple considers performSelector: unsafe and removed it from Swift.

  Note: The performSelector: method and related selector-invoking methods are not imported in Swift because they are inherently unsafe.

Other methods

In addition to creation and startup, NSThread also has many methods. Below I list some common methods. Of course, my list is not complete. You can see more methods in the class definition.

OBJECTIVE-C

 //Cancel the thread  
 - ( void )cancel; 
 
 //Start the thread  
 - ( void )start; 
 
 //Determine the properties of a thread's state  
 @property (readonly, getter=isExecuting) BOOL executing;
 @property (readonly, getter=isFinished) BOOL finished;
 @property (readonly, getter=isCancelled) BOOL canceled; 
 
 //Set and get the thread name  
 -( void )setName:(NSString *)n;
 -(NSString *)name; 
 
 //Get the current thread information  
 + (NSThread *)currentThread; 
 
 //Get the main thread information  
 + (NSThread *)mainThread; 
 
 //Pause the current thread for a period of time, or pause it to a certain time  
 + ( void )sleepForTimeInterval:(NSTimeInterval)time;
 + ( void )sleepUntilDate:(NSDate *)date;

SWIFT

The method names in Swift and OC are the same, so I won’t waste space listing them.

In fact, NSThread is quite simple to use, because it has only a few methods. At the same time, we only use NSThread in some very simple scenarios, after all, it is not smart enough to handle other advanced concepts in multithreading elegantly. So the content to be discussed next is the key point.

GCD

Grand Central Dispatch, the name sounds impressive. It is Apple's solution for multi-core parallel computing, so it will automatically and reasonably utilize more CPU cores (such as dual-core and quad-core). The most important thing is that it will automatically manage the life cycle of threads (create threads, schedule tasks, and destroy threads). We don't need to manage it at all. We just need to tell it what to do. At the same time, it also uses C language, but because of the use of Block (called closure in Swift), it is more convenient and flexible to use. So basically everyone uses the GCD solution, which is suitable for all ages. It is really a must-have medicine for home travel and murder. Sorry, it's a bit second-year student, let's continue.

Tasks and Queues

In GCD, two very important concepts are added: tasks and queues.

• Task: It is an operation. It is a piece of code, which is a block in GCD, so it is very convenient to add tasks. There are two execution modes for tasks: synchronous execution and asynchronous execution. The difference between them is whether a new thread will be created.

  Synchronous execution: All tasks that are executed synchronously will be executed in the current thread and no new thread will be opened.

  Asynchronous execution: As long as the task is executed asynchronously, a new thread will be opened and executed in another thread.

• Queue: used to store tasks. There are two types of queues, serial queue and parallel queue.

  The tasks in the serial queue will be executed one by one in a first-in-first-out manner according to the queue's definition of FIFO execution.

  Tasks in a parallel queue have different execution modes depending on whether they are synchronous or asynchronous. Although it is confusing, please see the following table:

Creating a Queue

• Main queue: This is a special serial queue. What is the main queue? Everyone knows it. It is used to refresh the UI. Any work that needs to refresh the UI must be executed in the main queue, so generally time-consuming tasks must be put into other threads for execution.

   //OBJECTIVE-C  
    dispatch_queue_t queue = ispatch_get_main_queue(); 
   
   //SWIFT  
    let queue = ispatch_get_main_queue()

• Self-created queues: All self-created queues are serial queues. The first parameter is an identifier, which is used to identify a unique queue during debugging. It can be empty. You can refer to the Xcode documentation to see the meaning of the parameters.

   //OBJECTIVE-C  
    dispatch_queue_t queue = dispatch_queue_create( "tk.bourne.testQueue" , ​​NULL); 
   
   //SWIFT  
    let queue = dispatch_queue_create( "tk.bourne.testQueue" , ​​nil);

• Global parallel queue: This should be the only parallel queue, and all parallel tasks are generally added to this queue.

   //OBJECTIVE-C  
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0 ); 
   
   //SWIFT  
    let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0 )

Create a task

• Synchronous tasks: no separate thread will be opened (SYNC)

  OBJECTIVE-C

   dispatch_sync(<#queue#>, ^{
   //code here  
        NSLog(@ "%@" , [NSThread currentThread]);
   });

  SWIFT

   dispatch_sync(<#queue#>, { () -> Void in
   //code here  
        println(NSThread.currentThread())
   })

• Asynchronous tasks: will open another thread (ASYNC)

  OBJECTIVE-C

   dispatch_async(<#queue#>, ^{
   //code here  
        NSLog(@ "%@" , [NSThread currentThread]);
   });

  SWIFT

   dispatch_async(<#queue#>, { () -> Void in
   //code here  
        println(NSThread.currentThread())
   })

Queue Group

Queue groups can add many queues to one group. The advantage of this is that when all tasks in this group are executed, the queue group will notify us through a method. The following is how to use it. This is a very practical function.

OBJECTIVE-C

 //1. Create a queue group  
 dispatch_group_t group = dispatch_group_create();
 //2. Create a queue  
 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0 ); 
 
 //3. Use the queue group method multiple times to execute tasks, only asynchronous methods  
 //3.1. Execute 3 loops  
 dispatch_group_async(group, queue, ^{
 for (NSInteger i = 0 ; i < 3 ; i++) {
        NSLog(@ "group-01 - %@" , [NSThread currentThread]);
 }
 }); 
 
 //3.2. The main queue executes 8 cycles  
 dispatch_group_async(group, dispatch_get_main_queue(), ^{
 for (NSInteger i = 0 ; i < 8 ; i++) {
        NSLog(@ "group-02 - %@" , [NSThread currentThread]);
 }
 }); 
 
 //3.3. Execute 5 cycles  
 dispatch_group_async(group, queue, ^{
 for (NSInteger i = 0 ; i < 5 ; i++) {
        NSLog(@ "group-03 - %@" , [NSThread currentThread]);
 }
 }); 
 
 //4. Automatically notify after everything is completed  
 dispatch_group_notify(group, dispatch_get_main_queue(), ^{
 NSLog(@ "Completed - %@" , [NSThread currentThread]);
 });

SWIFT

 //1. Create a queue group  
 let group = dispatch_group_create()
 //2. Create a queue  
 let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0 ) 
 
 //3. Use the queue group method multiple times to execute tasks, only asynchronous methods  
 //3.1. Execute 3 loops  
 dispatch_group_async(group, queue) { () -> Void in
 for _ in 0 ..< 3 {
        NSLog( "group-01 - %@" , NSThread.currentThread())
 }
 } 
 
 //3.2. The main queue executes 8 cycles  
 dispatch_group_async(group, dispatch_get_main_queue()) { () -> Void in
 for _ in 0 ..< 8 {
        NSLog( "group-02 - %@" , NSThread.currentThread())
 }
 } 
 
 //3.3. Execute 5 cycles  
 dispatch_group_async(group, queue) { () -> Void in
 for _ in 0 ..< 5 {
        NSLog( "group-03 - %@" , NSThread.currentThread())
 }
 } 
 
 //4. Automatically notify after everything is completed  
 dispatch_group_notify(group, dispatch_get_main_queue()) { () -> Void in
 NSLog( "Completed - %@" , NSThread.currentThread())
 }

Printing Results

2015-07-28 03:40:34.277 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.277 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319273] group-01 - <NSThread: 0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319273] group-01 - <NSThread: 0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319273] group-01 - <NSThread: 0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.279 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.279 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.279 test[12540:3319146] Finished - <NSThread: 0x7f977240ba60>{number = 1, name = main}

These are the basic functions of GCD, but its capabilities are far more than these. After we finish talking about NSOperation, we will look at some of its other uses. Moreover, as long as you have a rich imagination, you can combine better uses.

Update: Regarding GCD, I didn’t explain it very thoroughly and may have overlooked something. Please see the first comment.

NSOperation and NSOperationQueue

NSOperation is Apple's encapsulation of GCD, which is completely object-oriented, so it is easier to understand. You can see that NSOperation and NSOperationQueue correspond to GCD's tasks and queues respectively. The operation steps are also easy to understand:

1. Encapsulate the task to be performed into an NSOperation object.
2. Add the task to an NSOperationQueue object.

Then the system will automatically execute the task. As for whether it is synchronous or asynchronous, serial or parallel, please continue reading:

Add a task

It is worth mentioning that NSOperation is just an abstract class, so it cannot encapsulate tasks. But it has two subclasses for encapsulating tasks. They are: NSInvocationOperation and NSBlockOperation. After creating an Operation, you need to call the start method to start the task, which will execute synchronously in the current queue by default. Of course, you can also cancel a task midway by calling its cancel method.

• NSInvocationOperation: A method name needs to be passed in.

  OBJECTIVE-C

   //1. Create an NSInvocationOperation object  
    NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector: @selector (run) object:nil]; 
   
   //2. Start execution  
   [operation start];

  SWIFT

  In the harmonious society built by Swift, there is no place for NSInvocationOperation, a type-unsafe scum. Apple said so. Here is the explanation

• NSBlockOperation

  OBJECTIVE-C

   //1. Create an NSBlockOperation object  
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@ "%@" , [NSThread currentThread]);
   }]; 
   
   //2. Start the task  
   [operation start];

  SWIFT

   //1. Create an NSBlockOperation object  
    let operation = NSBlockOperation { () -> Void in
        println(NSThread.currentThread())
   } 
   
   //2. Start the task  
   operation.start()

  As mentioned before, such tasks will be executed in the current thread by default. However, NSBlockOperation has another method: addExecutionBlock:, which can be used to add multiple execution blocks to the Operation. In this way, the tasks in the Operation will be executed concurrently, and it will execute these tasks in the main thread and multiple other threads. Note the following print results:

  OBJECTIVE-C

   //1. Create an NSBlockOperation object  
        NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@ "%@" , [NSThread currentThread]);
   }]; 
   
   //Add multiple Blocks  
   for (NSInteger i = 0 ; i < 5 ; i++) {
            [operation addExecutionBlock:^{
                NSLog(@ "%ldth time: %@" , i, [NSThread currentThread]);
   }];
   } 
   
   //2. Start the task  
   [operation start];

  SWIFT

   //1. Create an NSBlockOperation object  
          let operation = NSBlockOperation { () -> Void in
              NSLog( "%@" , NSThread.currentThread())
   } 
   
   //2. Add multiple Blocks  
   for i in 0 ..< 5 {
              operation.addExecutionBlock { () -> Void in
                  NSLog( "%ldth time - %@" , i, NSThread.currentThread())
   }
   } 
   
   //2. Start the task  
   operation.start()

  Printing Output

  2015-07-28 17:50:16.585 test[17527:4095467] 2nd time - <NSThread: 0x7ff5c9701910>{number = 1, name = main}

  2015-07-28 17:50:16.585 test[17527:4095666] 1st time - <NSThread: 0x7ff5c972caf0>{number = 4, name = (null)}

  2015-07-28 17:50:16.585 test[17527:4095665] <NSThread: 0x7ff5c961b610>{number = 3, name = (null)}

  2015-07-28 17:50:16.585 test[17527:4095662] 0th time - <NSThread: 0x7ff5c948d310>{number = 2, name = (null)}

  2015-07-28 17:50:16.586 test[17527:4095666] 3rd time - <NSThread: 0x7ff5c972caf0>{number = 4, name = (null)}

  2015-07-28 17:50:16.586 test[17527:4095467] 4th time - <NSThread: 0x7ff5c9701910>{number = 1, name = main}

  ​

  NOTE: The addExecutionBlock method must be executed before the start() method, otherwise an error will be reported:

  '*** -[NSBlockOperation addExecutionBlock:]: blocks cannot be added after the operation has started executing or finished'

  ​

  NOTE: You may have discovered a problem. Why do I use NSLog() instead of println() to print output in Swift? The reason is that if you use print() / println() to output, it will simply use the concept of stream. Those who have learned C++ know it. It will output each character that needs to be output to the console one by one. There is no problem with normal use, but problems arise when multiple threads output synchronously. Since many println() are printed at the same time, the characters on the console will be piled up chaotically, and NSLog() does not have this problem. What does it look like? You can change the above NSLog() to println(), and then try it and you will know. For more differences between NSLog() and println(), see here

• Custom Operation

  In addition to the two operations above, we can also customize operations. To customize an operation, you need to inherit the NSOperation class and implement its main() method, because when the start() method is called, the main() method will be called internally to complete the relevant logic. So if the above two classes cannot meet your needs, you need to customize it. You can write any function you want to implement in it. In addition, you also need to implement various methods including cancel(). So this function is provided for advanced players, I will not talk about it here, I will study it when I need it, and I may update it at that time.

Creating a Queue

As you can see from the above content, we can call the start() method of an NSOperation object to start the task, but by default they are executed synchronously. Even the addExecutionBlock method will be executed in the current thread and other threads, which means it will still occupy the current thread. This is where the queue NSOperationQueue comes in. Moreover, there are two types of queues: main queue and other queues. As long as it is added to the queue, the start() method of the task will be automatically called.

• Main Queue

  Careful students will find that each multi-threaded solution has a main thread (of course, this is in iOS, and multi-system solutions like pthread do not have it, because the UI thread theory needs to be customized for each operating system). This is a special thread that must be serial. Therefore, tasks added to the main queue will be queued up one by one to be processed by the main thread.

   //OBJECTIVE-C  
   NSOperationQueue *queue = [NSOperationQueue mainQueue]; 
   
   //SWIFT  
   let queue = NSOperationQueue.mainQueue()

• Other queues

  Because the main queue is special, there is a separate class method to get the main queue. Then the queue generated by initialization is the other queue, because there are only these two queues, except for the main queue, other queues do not need names.

  Note: Tasks in other queues will be executed in parallel in other threads.

  OBJECTIVE-C

   //1. Create another queue  
   NSOperationQueue *queue = [[NSOperationQueue alloc] init]; 
   
   //2. Create an NSBlockOperation object  
   NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
      NSLog(@ "%@" , [NSThread currentThread]);
   }]; 
   
   //3. Add multiple Blocks  
   for (NSInteger i = 0 ; i < 5 ; i++) {
      [operation addExecutionBlock:^{
          NSLog(@ "%ldth time: %@" , i, [NSThread currentThread]);
   }];
   } 
   
   //4. Add tasks to the queue  
   [queue addOperation:operation];

  SWIFT

   //1. Create other queues  
   let queue = NSOperationQueue() 
   
   //2. Create an NSBlockOperation object  
   let operation = NSBlockOperation { () -> Void in
      NSLog( "%@" , NSThread.currentThread())
   } 
   
   //3. Add multiple Blocks  
   for i in 0 ..< 5 {
      operation.addExecutionBlock { () -> Void in
          NSLog( "%ldth time - %@" , i, NSThread.currentThread())
   }
   } 
   
   //4. Add tasks to the queue  
   queue.addOperation(operation)

  Printing Output

  2015-07-28 20:26:28.463 test[18622:4443534] <NSThread: 0x7fd022c3ac10>{number = 5, name = (null)}

  2015-07-28 20:26:28.463 test[18622:4443536] 2nd time - <NSThread: 0x7fd022e36d50>{number = 2, name = (null)}

  2015-07-28 20:26:28.463 test[18622:4443535] Time 0 - <NSThread: 0x7fd022f237f0>{number = 4, name = (null)}

  2015-07-28 20:26:28.463 test[18622:4443533] 1st time - <NSThread: 0x7fd022d372b0>{number = 3, name = (null)}

  2015-07-28 20:26:28.463 test[18622:4443534] 3rd time - <NSThread: 0x7fd022c3ac10>{number = 5, name = (null)}

  2015-07-28 20:26:28.463 test[18622:4443536] 4th time - <NSThread: 0x7fd022e36d50>{number = 2, name = (null)}

OK, now is the time to ask, if you compare NSOperationQueue with GCD queues, you will find that there is no parallel queue. What if I want 10 tasks to be executed serially in other threads?

This is the beauty of Apple's encapsulation. You don't have to worry about terms like serial, parallel, synchronous, and asynchronous. NSOperationQueue has a parameter maxConcurrentOperationCount, which is used to set the maximum number of tasks that can be executed simultaneously. When you set it to 1, it becomes serial!

NSOperationQueue also has a method for adding tasks, - (void)addOperationWithBlock:(void (^)(void))block; , which is similar to GCD? This way you can add a task to the queue, which is very convenient.

NSOperation has a very useful function, which is to add dependencies. For example, there are 3 tasks: A: download a picture from the server, B: add a watermark to the picture, C: return the picture to the server. Then you can use dependencies:

OBJECTIVE-C

 //1. Task 1: Download pictures  
 NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
 NSLog(@ "Download picture - %@" , [NSThread currentThread]);
    [NSThread sleepForTimeInterval: 1.0 ];
 }]; 
 
 //2. Task 2: Watermark  
 NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
 NSLog(@ "Watermark - %@" , [NSThread currentThread]);
    [NSThread sleepForTimeInterval: 1.0 ];
 }]; 
 
 //3. Task 3: Upload pictures  
 NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
 NSLog(@ "Upload picture - %@" , [NSThread currentThread]);
    [NSThread sleepForTimeInterval: 1.0 ];
 }]; 
 
 //4. Set dependencies  
 [operation2 addDependency:operation1]; //Task 2 depends on task 1  
 [operation3 addDependency:operation2]; //Task 3 depends on task 2   
 
 //5. Create a queue and join the task  
 NSOperationQueue *queue = [[NSOperationQueue alloc] init];
 [queue addOperations:@[operation3, operation2, operation1] waitUntilFinished:NO];

SWIFT

 //1. Task 1: Download pictures  
 let operation1 = NSBlockOperation { () -> Void in
 NSLog( "Download image - %@" , NSThread.currentThread())
    NSThread.sleepForTimeInterval( 1.0 )
 } 
 
 //2. Task 2: Watermark  
 let operation2 = NSBlockOperation { () -> Void in
 NSLog( "Watermark - %@" , NSThread.currentThread())
    NSThread.sleepForTimeInterval( 1.0 )
 } 
 
 //3. Task 3: Upload pictures  
 let operation3 = NSBlockOperation { () -> Void in
 NSLog( "Upload picture - %@" , NSThread.currentThread())
    NSThread.sleepForTimeInterval( 1.0 )
 } 
 
 //4. Set dependencies  
 operation2.addDependency(operation1) //Task 2 depends on task 1  
 operation3.addDependency(operation2) //Task 3 depends on task 2   
 
 //5. Create a queue and join the task  
 let queue = NSOperationQueue()
 queue.addOperations([operation3, operation2, operation1], waitUntilFinished: false )

Printing Results

2015-07-28 21:24:28.622 test[19392:4637517] Download image - <NSThread: 0x7fc10ad4d970>{number = 2, name = (null)}

2015-07-28 21:24:29.622 test[19392:4637515] Watermark - <NSThread: 0x7fc10af20ef0>{number = 3, name = (null)}

2015-07-28 21:24:30.627 test[19392:4637515] Upload picture - <NSThread: 0x7fc10af20ef0>{number = 3, name = (null)}

• Note: You cannot add mutual dependencies, which will cause deadlock, for example, A depends on B, and B depends on A.
• You can use removeDependency to remove dependencies.
• You can have dependencies between different queues. Anyway, this dependency is added to the task and has nothing to do with the queue.

Other methods

The above are some of the main methods. Here are some common methods that you should pay attention to:

• NSOperation

  BOOL executing; //Judge whether the task is being executed

  BOOL finished; //Judge whether the task is completed

  void (^completionBlock)(void); //Used to set the operations to be performed after completion

  - (void)cancel; //Cancel the task

  - (void)waitUntilFinished; //Block the current thread until this task is completed

• NSOperationQueue

  NSUInteger operationCount; //Get the number of tasks in the queue

  - (void)cancelAllOperations; //Cancel all tasks in the queue

  - (void)waitUntilAllOperationsAreFinished; //Block the current thread until all tasks in this queue are completed

  [queue setSuspended:YES]; // Suspend queue

  [queue setSuspended:NO]; // Continue queue

Well, that's about it. Of course, what I said is not complete, there may be some knowledge I didn't mention, but as a common method, these are enough. However, I just told you the functions of some methods here, but how to use them in the right place requires more practice. Next, I will talk about some cases about multithreading, so that everyone can understand it better.

Other Usages

In this part, I will talk about some cases related to multithreading knowledge. Some of them may be very simple and everyone already knows them, but since this article is about multithreading, it should be as comprehensive as possible. In addition, I will try to use multiple methods to implement them so that everyone can see the difference.

Thread synchronization

The so-called thread synchronization is a measure taken to prevent data security problems caused by multiple threads competing for the same resource. Of course, there are many ways to achieve this, please read on:

• Mutex lock: Adding a mutex lock to the code block that needs to be synchronized can ensure that only one thread accesses this code block at a time.

  OBJECTIVE-C

   @synchronized (self) {
   //The code block to be executed  
   }

  SWIFT

   objc_sync_enter(self)
   //The code block to be executed  
   objc_sync_exit(self)

• Synchronous execution: We can use the knowledge of multithreading to add multiple threads to execute this code to the same serial queue, thus realizing the concept of thread synchronization. Of course, GCD and NSOperation can be used here, and I will write them out.

  OBJECTIVE-C

//GCD  
 //A global variable queue is needed to add this operation of all threads to a queue  
 dispatch_sync(queue, ^{
      NSInteger ticket = lastTicket;
      [NSThread sleepForTimeInterval: 0.1 ];
      NSLog(@ "%ld - %@" ,ticket, [NSThread currentThread]);
 ticket -= 1 ;
 lastTicket = ticket;
 }); 
 
 
 //NSOperation & NSOperationQueue  
 //Key points: 1. Global NSOperationQueue, all operations are added to the same queue  
 // 2. Set the queue's maxConcurrentOperationCount to 1  
 // 3. If the subsequent operation requires the result in the Block, you need to call waitUntilFinished of each operation to block the current thread and wait until the current operation is completed before allowing the subsequent operation to be executed. waitUntilFinished must be called after adding to the queue!   
 
  NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
      NSInteger ticket = lastTicket;
      [NSThread sleepForTimeInterval: 1 ];
      NSLog(@ "%ld - %@" ,ticket, [NSThread currentThread]);
 ticket -= 1 ;
 lastTicket = ticket;
 }]; 
 
  [queue addOperation:operation]; 
 
  [operation waitUntilFinished]; 
 
 // What to do next  

SWIFT

I won’t write the Swift code here, because every sentence is the same, just the syntax is different, and you can write Swift by following the OC code. This article is already very long, so I won’t waste space, it’s not a high school essay.

Delayed execution

Delayed execution means executing a certain section of code after a certain period of time. Here are some common methods.

• perform

  OBJECTIVE-C

   // Automatically call the run: method of self after 3 seconds and pass the parameter: @"abc"  
    [self performSelector: @selector (run:) withObject:@ "abc" afterDelay: 3 ];

  SWIFT

  As mentioned before, this method has been removed in Swift.

• GCD

  You can use the dispatch_after method in GCD, which can be used in both OC and Swift. Here I only write the OC one, the Swift one is the same.

  OBJECTIVE-C

   // Create a queue  
   dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0 );
   // Set the delay in seconds  
   double delay = 3 ; 
   
   dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), queue, ^{
   // Tasks that need to be executed after 3 seconds  
   });

• NSTimer

  NSTimer is a timer class in iOS. It has many uses besides delayed execution, but here we will just talk about the delayed execution. I will only write the OC version, and the Swift version is the same.

  OBJECTIVE-C

   [NSTimer scheduledTimerWithTimeInterval: 3.0 target:self selector: @selector (run:) userInfo:@ "abc" repeats:NO];

Singleton Pattern

As for what the singleton pattern is, I won't say much, I'll just talk about how to implement it in general. In Objective-C, the method of implementing a singleton is very specific. Although there are other methods, generally a standard method is used. Let's take a look.

OBJECTIVE-C

 @interface Tool : NSObject <NSCopying> 
 
 + (instancetype)sharedTool; 
 
 @end   
 
 @implementation Tool 
 
 static id _instance; 
 
 + (instancetype)sharedTool {
 static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[Tool alloc] init];
 }); 
 
 return _instance;
 } 
 
 @end  

The reason why the singleton pattern is used here is because it uses the dispatch_once method of GCD. Let's take a look at the singleton pattern in Swift. The singleton pattern in Swift is very simple! If you want to know how to change the complex method of OC to the following writing method, please see here

SWIFT

 class Tool: NSObject {
 static let sharedTool = Tool() 
 
 //Private the constructor to prevent other objects from using the default '()' constructor of this class  
 private override init() {}
 }

How to return to the main thread from other threads

We all know that after other threads have completed operations, we must go to the main thread to update the UI. So, after introducing all the multi-threading solutions, let's see what methods are available to return to the main thread.

• NSThread

   //Objective-C  
   [self performSelectorOnMainThread: @selector (run) withObject:nil waitUntilDone:NO]; 
   
   //Swift  
   //swift cancels the performSelector method.  

• GCD

   //Objective-C  
   dispatch_async(dispatch_get_main_queue(), ^{ 
   
   }); 
   
   //Swift  
   dispatch_async(dispatch_get_main_queue(), { () -> Void in 
   
   })

• NSOperationQueue

   //Objective-C  
   [[NSOperationQueue mainQueue] addOperationWithBlock:^{ 
   
   }]; 
   
   //Swift  
   NSOperationQueue.mainQueue().addOperationWithBlock { () -> Void in 
   
   }

Summarize

OK, I finally finished writing it. I typed more than 6,000 words by hand. I am so moved. It took me two days, and the time span is a bit long, so there may be some places where the upper part does not connect to the lower part or some places are incomplete. If you find it difficult to read or there are any problems, you can tell me in the comment area and I will modify it in time. Of course, there are more things about multithreading. The title is just a title, don't take it seriously. If you want to know more, you have to go online to dig for relevant information. Read more official documents. I really can't write it anymore, everyone read it carefully~ By the way, seeing how hard I wrote, you should at least like it if you don't reward me.