Thread-safety of StringBuffer


The StringBuffer class in Java is designed to provide thread-safe operations, ensuring safe access and modification of strings in multi-threaded environments. Here are some important details to consider:


Synchronized methods:

StringBuffer achieves thread safety by synchronizing its methods, which means that only one thread can execute a synchronized method at a time.

Synchronization ensures that multiple threads can safely access and modify the contents of a StringBuffer object without conflicts or data corruption.


Atomicity of operations:

In StringBuffer, individual operations such as appending, inserting, deleting, replacing, or modifying strings are performed atomically.

An atomic operation means that the operation is executed as a single, indivisible unit, ensuring that it is completed entirely before another thread can access or modify the StringBuffer object.


Consistent state:

StringBuffer maintains a consistent internal state throughout its operations.

The synchronization guarantees that the contents of the StringBuffer are not corrupted or left in an inconsistent state due to concurrent access or modification by multiple threads.

Example:


class StringBufferExample { 
private static StringBuffer stringBuffer = new StringBuffer(); 
public static void main(String[] args) { 
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) { 
 stringBuffer.append("A");
            } 
 }); 
Thread thread2 = new Thread(() -> { 
for (int i = 0; i < 1000; i++) { 
 stringBuffer.append("B"); 
 }
        }); 
 thread1.start(); 
 thread2.start(); 
try { 
 thread1.join(); 
 thread2.join();
 } 
catch (InterruptedException e) {
 e.printStackTrace();
 } 
 System.out.println(stringBuffer.toString().length()); // Output: 2000
    } 
}


In this example, two threads, thread1 and thread2, are concurrently appending "A" and "B" respectively to a shared StringBuffer object.

 The join() method ensures that the main thread waits for the completion of both threads before printing the length of the resulting string.


The synchronized methods of StringBuffer guarantee that the append operations of each thread are executed atomically. 

As a result, the final output will always be 2000, indicating that both threads successfully completed their append operations without any data corruption or conflicts.


By using StringBuffer in a multi-threaded environment, you can safely perform string manipulations without the risk of data corruption or inconsistent state caused by concurrent access or modification by multiple threads.