Understanding key multithreading concepts is crucial for software developers, as it not only enhances skill set but also directly impacts application development, scalability, and the overall quality of software solutions.

Atomicity

In the context of multithreading, atomic operations ensure that a thread can execute a series of actions without interruption from other threads. Multiple threads may attempt to read or write shared data simultaneously. Without atomicity, concurrent modifications can lead to inconsistent or unexpected results, commonly known as race conditions.

Java Specification guarantees that 'reading' and 'writing' are atomic operations not their combinations. so an operation which 'reads, adds 1 and then writes the result back' is not atomic as per specification. such operations are called compound operations and they usually need to be atomic in context of their usage in our code.

Examples of Atomic Operations:

1. Incrementing a counter: If two threads increment a counter at the same time without atomicity, they may both read the same value and write back the same incremented value, leading to a loss of one increment.

2. Updating a shared variable: If one thread is reading a value while another is modifying it, without atomicity, the reading thread may get an inconsistent value.

Achieving Atomicity:

• Atomic Classes: Many programming languages provide atomic classes (e.g., AtomicIntegerin Java) that encapsulate operations that are guaranteed to be atomic.

• Synchronized Methods/Blocks: In languages like Java, you can use the synchronized keyword to ensure that only one thread can execute a block of code or a method at a time.

• Locks: Using explicit locks (e.g., ReentrantLockin Java) to manage access to shared resources.

Benefits

• Performance: Classes in java.util.concurrent.atomic also provide a lock-free approach to ensure thread safety, making them a preferred choice in many scenarios.
• Simplicity: Using atomic classes simplifies code, as developers don’t need to manage locks and can focus on the logic of the program.
• Thread Safety: Atomic operations ensure that variables are safely updated across multiple threads without the risk of data corruption or race conditions.

Immutability

Immutability refers to the property of an object whose state cannot be modified after it is created. In programming, immutable objects are those that, once initialized, cannot be changed or altered. Instead of modifying an immutable object, a new object is created with the desired changes.

Immutable means that once the constructor for an object has completed execution that instance can't be altered.

Characteristics of Immutable Objects

• No State Change: Once an immutable object is created, its state (attributes or fields) remains constant throughout its lifetime.

• Thread-Safe: Immutable objects can be safely shared between multiple threads without the need for synchronization, as they cannot be modified.

• Hashcode Stability: The hashcode of an immutable object remains the same throughout its lifetime, making it suitable for use in hash-based collections like HashMap or HashSet.

Achieving Immutability:

• Use of Records (in Java 14+): In Java, the record feature provides a concise way to create immutable data classes.

public record ImmutablePoint(int x, int y) {}

• Use Immutable Data Structures: Utilize existing immutable data structures provided by the programming language or libraries, such as:

1. Java: Collections.unmodifiableList(), List.of(), Set.of()

2. C#: ImmutableList, ImmutableArray from System.Collections.Immutable

3. Python: Tuplesare inherently immutable.

• Use Final Fields: Declare the fields of a class as final. This ensures that the fields can only be assigned once, during object construction.

• No Setters: Avoid providing setter methods for mutable fields. This prevents external code from changing the state of an object after it's been constructed.
  

public final class ImmutablePoint {
    private final int x;
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
}

• Static Factory Methods: Instead of providing a public constructor, use static factory methods that return new instances of the object, making it clear that the state cannot be changed

• Builder Pattern (for complex objects): For objects that require many parameters, use the builder pattern to create immutable objects. The builder accumulates the parameters and constructs an immutable instance at the end.

Benefits

• Concurrency: If the internal structure of an immutable object is valid, it will always be valid. There's no chance that different threads can create an invalid state within that object. Hence, immutable objects are Thread Safe.

• Garbage collection: It's much easier for the garbage collector to make logical decisions about immutable objects.

Outro

Arming yourself with this knowledge not only enhances your ability to write high-performance code but also prepares you for the challenges of modern software development, where responsiveness and scalability are paramount. As you continue your journey into the world of multithreading, remember that each concept you master will contribute to your growth as a developer and your capacity to create applications that meet and exceed user expectations.

Stay tuned as we will focus on starvation, deadlock, race-condition, OS scheduling and much more in upcoming write-up, that would elevate your programming skills and boost your career!

References

A huge thanks to the online documentation, community and all the resources available that made this write-up possible.

1. Info-graphic
2. Understanding Basic Multithreading Concepts
3. Atomicity
4. What is immutable