Shulou(Shulou.com)06/03 Report--

Editor to share with you how iOS uses multithreading to improve concurrent data access, I believe most people do not know much about it, so share this article for your reference, I hope you can learn a lot after reading this article, let's go to know it!

Thread synchronization

Now, let's turn to another very important part of multithreading. Since each thread runs on its own stack and creates its own object, how does your thread communicate and share data with other threads in the application? As mentioned earlier, it is risky when you share your data structure or object among multiple threads, because many threads try to change the data structure of the object.

First of all, let me introduce you to a new term called thread safety. Thread-safe classes (or functions) are such classes that you don't need to worry about the security issues mentioned earlier. These classes are either handled carefully with locks, or they are immutable (they will not be changed). The following are thread-safe classes or functions:

NSArray

NSConnection

NSData

NSDate

NSDictionary

NSNumber

NSObject

NSSet

NSString

Instead, here are mutable, non-thread-safe classes:

NSMutableArray

NSMutableAttributedString

NSMUtableCharacterSet

NSMutableData

NSMutableDictionary

NSMutableSet

NSMutableString

Why should you use thread-safe classes rather than non-thread-safe classes? Why don't you use the mutble class, but make sure you use locks? Let me give you an example of using locks, which may change objects when accessing objects with threads:

NSMutableArray* myArray = GetSharedArray ()

Id anObject

If ([myArray count] > 0) {

AnObject = [myArray objectAtIndex:0]

}

[anObject doSomething]

This example is very simple, but you help you understand a very important concept. Do you see the problem with this code? After you check the length of the array, another thread can modify the array, so there may be no objects in the array, because other threads may delete all the objects in the array. Therefore, you can solve this problem by using locks, but it is not the best solution.

This will be much better, but there are still problems, such as the object you get may be modified by other threads. Therefore, the next step is to add [anObject doSomething]; to the lock.

If myArray is NSArray, not NSMutableArray, you don't need a lock at all. You can call them normally.

This is the advantage of using immutable objects over mutable objects. You can make sure that when you are dealing with these objects, no one can modify or change their properties.

These are all the contents of the article "how iOS uses multithreading to improve concurrent data access". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.