Doubts on concurrency with objects that can be used multiple times like formatters

Maybe a stupid question to ask but I need some confirmations on it.

Usually, when I deal with objects that can be used multiple times within my application I use an approach like the following.

  • Futures for Objective-C?
  • NSURLSession concurrent requests with Alamofire
  • What are the different ways for calling my method on separate thread?
  • How to do multithreading, concurrency or parallelism in iOS Swift?
  • What's the difference between the “global queue” and the “main queue” in GCD?
  • Making Core Data Thread-safe
  • Create an extension, say for example NSDecimalNumber+Extension, or a class utility where a number formatter is created like the following.

    + (NSNumberFormatter*)internal_sharedNumberFormatter
        static NSNumberFormatter* _internal_numberFormatter = nil;
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            _internal_numberFormatter = [[NSNumberFormatter alloc] init];
            // other configurations here...
        return _internal_numberFormatter;
    + (NSString*)stringRepresentationOfDecimalNumber:(NSDecimalNumber*)numberToFormat
        NSString *stringRepresentation = [[self class] internal_sharedNumberFormatter] stringFromNumber:numberToFormat];
        return stringRepresentation;

    This approach is quite good since, for example, formatters are expensive to create. But it could be applied to other situations as well.

    Now, my questions is the following.

    Does this approach is also valid in situations where different path of execution (different threads) are involved?

    So, if I call first stringRepresentationOfDecimalNumber on the main thread and then in a different thread, what could happen?

    I think is valid to perform different calls to stringRepresentationOfDecimalNumber in different threads since the shared formatter, in this case, is reading only, but I would like to have a reply from experts.

    Thanks in advance.

    Solutions Collect From Internet About “Doubts on concurrency with objects that can be used multiple times like formatters”

    NSNumberFormatter is mutable, so it is generally not thread safe and cited in Thread Safety Summary (see the “Thread-Unsafe Classes” section) in the non thread safe classes list.

    But if you treat your object as an immutable object, you don’t have to worry about race conditions. So for example, you cannot change the format if there are multiple threads accessing the formatter. If _internal_numberFormatter isn’t altered in any way, and you have just these two methods in the category, you should consider it thread safe.