What are the ways to use primitive data types in multithreaded programming?

In multithreaded programming, using primitive data types requires consideration of visibility and atomicity issues.

Main ways to work with primitives:

• Using the volatile keyword — guarantees that reading and writing a variable will occur directly from main memory, ensuring visibility of changes between threads. However, volatile does not guarantee atomicity of complex operations.

• Using atomic classes from java.util.concurrent.atomic, such as AtomicInteger, AtomicLong. They provide atomic operations (increment, compare and set, etc.) without the need for synchronization.

• Synchronization via synchronized or locks — to ensure atomicity and consistency when working with primitives in complex scenarios.

Example with AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

This approach is safe in a multithreaded environment without explicit synchronization.