Skip to main content

The Singleton Pattern

The Singleton Pattern

Objective-C: Singletons

A Singleton is a special kind of class where only one instance of the class exists for the current process. Singletons can be an easy way to share data and common methods across your entire app. 


Note: Apple uses this approach a lot. For example:

 [NSUserDefaults standardUserDefaults], [UIApplication sharedApplication], [UIScreen mainScreen], [NSFileManager defaultManager] all return a Singleton object.


How to Use the Singleton Pattern

Take a look at the diagram below:


@interface LibraryAPI : NSObject
+ (LibraryAPI*)sharedInstance;
@end

+ (LibraryAPI*)sharedInstance
{
    // 1
    static LibraryAPI *_sharedInstance = nil;
    // 2
    static dispatch_once_t oncePredicate;
    // 3
    dispatch_once(&oncePredicate, ^{
        _sharedInstance = [[LibraryAPI alloc] init];
    });
    return _sharedInstance;
}

There’s a lot going on in this short method:
  1. Declare a static variable to hold the instance of your class, ensuring it’s available globally inside your class.
  2. Declare the static variable dispatch_once_t which ensures that the initialization code executes only once.
  3. Use Grand Central Dispatch (GCD) to execute a block which initializes an instance of LibraryAPI. This is the essence of the Singleton design pattern: the initializer is never called again once the class has been instantiated.
The next time you call sharedInstance, the code inside the dispatch_once block won’t be executed (since it’s already executed once) and you receive a reference to the previously created instance of LibraryAPI.

@synchronized vs dispatch_once


http://blog.bjhomer.com/2011/09/synchronized-vs-dispatchonce.html [Reference link]

It looks like dispatch_once is about 2x faster than @synchronized
Each test accessed the singleton object 10 million times. I ran both single-threaded tests and multi-threaded tests. Here were the results:

Single threaded results
-----------------------
  @synchronized: 3.3829 seconds
  dispatch_once: 0.9891 seconds

Multi threaded results
----------------------
  @synchronized: 33.5171 seconds
  dispatch_once: 1.6648 seconds

dispatch_once() is absolutely synchronous. Not all GCD methods do things asynchronously (case in point, dispatch_sync() is synchronous). The use of dispatch_once() replaces the following idiom:
+ (MyClass *)sharedInstance {
    static MyClass *sharedInstance;
    @synchronized(self) {
        if (sharedInstance == nil) {
            sharedInstance = [[MyClass alloc] init];
        }
    }
    return sharedInstance;
}
The benefit of dispatch_once() over this is that it's faster. It's also semantically cleaner, because it also protects you from multiple threads doing alloc init of your sharedInstance--if they all try at the same exact time. It won't allow two instances to be created. The entire idea of dispatch_once()is "perform something once and only once", which is precisely what we're doing.

Comments

Post a Comment

Popular posts from this blog

What Is a Closure?

Closures are self contained chunks of code that can be passed around and used in your code. Closures can capture and store references to any constants or variables from the context in which they are defined. This is know as closing over those variables, hence the name closures. Closures are use intensively in the Cocoa frameworks – which are used to develop iOS or Mac applications. Functions are a special kind of closures. There are three kinds of closures: global functions  – they have a name and cannot capture any values nested functions  – they have a name and can capture values from their enclosing functions closure expressions  – they don’t have a name and can capture values from their context The thing to keep in mind for the moment is that you already have an intuition about closures. They are almost the same as functions but don’t necessarily have a name. // a closure that has no parameters and return a String var hello: () -> ( String ) = { ...
Post a Comment
Read more

SQLite 3 Procedure & Functions

SQLite 3 Procedure & Functions iOS - SQLite Database SQLite can be used in iOS for handling data. It uses sqlite queries, which makes it easier for those who know SQL. Steps Involved Step 1.  Create a simple  View based application . Step 2.  Select your project file, then select targets and then add  libsqlite3.dylib  library in choose frameworks. Step 3.  Create a new file by selecting File-> New -> File... -> select  Objective C class  and click next. Step 4.  Name the class as  DBManager  with  "sub class of"  as NSObject. Step 5.  Select create. Step 6.  Update  DBManager.h  as follows − SQLite 3 Functions Preview sqlite3_open : This function is used to create and open a database file. It accepts two parameters, where the first one is the database file name, and the second a handler to the database. If the file does n...
Post a Comment
Read more

The differences between Core Data and a Database

Database Core Data Primary function is storing and fetching data Primary function is graph management (although reading and writing to disk is an important supporting feature) Operates on data stored on disk (or minimally and incrementally loaded) Operates on objects stored in memory (although they can be lazily loaded from disk) Stores "dumb" data Works with fully-fledged objects that self-manage a lot of their behavior and can be subclassed and customized for further behaviors Can be transactional, thread-safe, multi-user Non-transactional, single threaded, single user (unless you create an entire abstraction around Core Data which provides these things) Can drop tables and edit data without loading into memory Only operates in memory Perpetually saved to disk (and often crash resilient) Requires a save process Can be slow to create millions of new rows Can create millions of new objects in-memory very quickly (although saving these objects will be slow) Offer...
Post a Comment
Read more