Programming Atomic Vs. Nonatomic

Many questions are asked about the atomic and the nonatomic in programming, and there is a lot to learn!

From operations and objects to the actual written code, there is so much to see and read, and this is one of the good places to do so. 

In this article, you will find the meaning behind the atomic and the nonatomic, their meaning, and their application in programming. Keep reading if you want to learn about this and see the actual example presented in the codes!

What Does Atomic Mean in Programming?

The term “atomic” refers to “one at a time.”

You can encounter the term “atomic” in programming and computer science. 

Let’s explain it further.

Atomic operations are crucial in applications where numerous threads, like a database, access the same shared resource.

An atomic action is one that, to the other threads, seems to happen instantly. 

In other words, you cannot intervene in the middle of atomic action. Instead, the procedure either succeeds or fails.

An “atom,” in this context, is an item that cannot be further subdivided. 

When physics was first introduced, an atom was once thought to be the smallest item that you could not divide further. 

Also, if you were wondering what an atomic action is, it is a process that cannot be divided into smaller subprocesses!

What is Atomic Object?

The C++ standard mandates a set of guidelines for operations and their consequences on atomic objects. 

So, an object is atomic if all operations adhere to these requirements.

If you’re asking yourself if the phrase “atomic object” means “object of atomic type,” then have a quick look below.

The standard doesn’t say it that way. 

However, this is not an implausible conclusion, given that the type of the object determines the result of operations. 

Basically, an atomic type is a type whose examples are atomic objects.

A collection of types with assured atomicity is available in the C++ standard library, as are functions for those kinds with guaranteed atomic operations!

What is Atomic Operation?

Atomic operations are program activities that operate totally separately from any other process in concurrent programming.

Many contemporary operating systems and parallel processing technologies employ atomic processes.

The kernel, the core of most operating systems, frequently uses atomic operations. Nevertheless, most computer hardware, compilers, and libraries also offer various degrees of atomic operations.

Let’s examine a practical comparison of atomic processes.

If building a home was an atomic process, the structure would instantly materialize out of nothing.

So there wouldn’t be a construction period. So either the home would be built, or it wouldn’t.

What Does Nonatomic Mean in Programming? 

The value held by the atomic variables at any time is (thread-lock) assured to be uncorrupted. 

That is because they cannot be interrupted, but maintaining this thread lock slows down access to them. 

On the other side, nonatomic variables do not make this promise but do provide the convenience of speedier access. 

To speed up things, use nonatomic when you know your variables won’t be accessible by several threads at once.

So, contrary to Atomic, nonatomic does not guarantee that an object will always return wholly initialized.

The pro of nonatomic would be the speedy execution. On the other hand, a con of the nonatomic would be the possibility of garbage value while using many threads, the thread is unsafe, and it is not the default behavior. 

In Atomic & Nonatomic, What Does The OBJC mean?

In this paragraph, you will learn about the atomic and nonatomic properties in Objective-C, which is a full name for the abbreviation OBJC. 

Atomic OBJC 

As the name implies, only one thread will be allowed to access the property at a time. 

One thread will have exclusive access to a property’s getter and setter to explain further. 

The first thread must release the get/set method before the other threads may use it. 

Let’s imagine we have an atomic property called GirlCode.

Thread A => obj .GirlCode=@”A”
Thread B => obj .GirlCode=@”B”
Thread C => NSLog(“Girl Code: %@” ,obj.GirlCode);

It guarantees a property’s value remains constant throughout its lifespan. All attributes are atomic by default.

Let’s see the example of atomic property. 

@property (strong,atomic) NSString *GirlCode;

OR

@property (strong) NSString *GirlCode;

This example of a getter setter for an atomic property shows how the methods will appear.

@synthesize GirlCode = _GirlCode; 
- (NSString *)GirlCode{
        @synchronized (self) {
                  return _GirlCode; 
         }
}
-(void)setGirlCode : (NSString *)GirlCode{
      @synchronized (self) {
                if( _GirlCode != GirlCode) {
                     [ _GirlCode release];
                     _GirlCode = [GirlCode retain];
                }
        } 
}

Locks are employed internally, although the Objective-C 2.0 specification doesn’t specify how specifically. 

The image you see above is an approximate representation of what an atomic getter or setter might look like; however, it may not be exact.

There are some advantages and disadvantages. 

Advantages: Ensures that the user receives a legitimate value rather than junk

Disadvantages: It’s slow and contains a read-write safety code.

Nonatomic OBJC 

The best way to explain nonatomic OBJC: Multiple threads may access nonatomic characteristics simultaneously. Hence there is always a possibility of inconsistent values.

Have a quick look at the example below. 

@property (strong,nonatomic) NSString *GirlCode;

That’s how the methods of a property will appear for an atomic property in a sample getter setter.

@synthesize GirlCode = _GirlCode; 
-(NSString *)GirlCode{
       return _GirlCode; 
}
-(void) setGirlCode : (NSString *)GirlCode{
      if( _GirlCode != GirlCode) {
           [ _GirlCode release];
           _GirlCode = [GirlCode retain];
      }
}

There are also some advantages and disadvantages.

The advantages include faster than atomic characteristics since no additional code is needed to manage access from different threads.

On the other hand, the disadvantages say there is no assurance that you will obtain genuine value.

What is Nonatomic Attribute?

Atomic properties guarantee the return of a valid value. 

However, legitimate does not equate to the correct answer.

Additionally, this does not imply that atomic properties are thread-safe. 

Many threads can read and write values simultaneously. 

Therefore, the value from before the modification or the altered value will be returned.

As a result of locking and unlocking before and after getting or setting value, atomic properties are experiencing performance degradation.

But you are here for a nonatomic attribute. So, let’s talk about it. 

A nonatomic property might have a value that is incorrect, partially right, or can even have a garbage value.

This improved speed of access characteristic is not thread-safe.

Atomic property lock during value setting,

Property that is not atomic does not lock when setting value.

What is a Nonatomic Operation?

Compared to other threads that are using this memory, an operation in a shared memory region is said to be atomic if finished in a single step. 

No thread can see a modification only partially made when such an operation is performed on a variable. 

Thanks to atomic loading, the variable will always be uploaded in full at once. 

Operations that are not atomic (nonatomic) do not offer such a guarantee.

There you go, now you have all the information on atomic and nonatomic programming! Hopefully, you can use some of this knowledge on your future projects!