Variables and Data Types in Java

In Java, every variable has a type, a name, and often a value. The type tells Java what kind of data it can store.

int age = 25;
String city = "Sydney";
boolean isActive = true;

Once you give a variable a type, you cannot put the wrong kind of data into it. For example, you cannot store text in an int.

Java has eight primitive data types. They are the basic building blocks for other types.

• String — text
• Arrays — list of values
• Wrapper classes — Integer, Double, Boolean
• Custom classes — classes you create

String title = "Java Guide";
int[] scores = {90, 85, 78};
Integer count = Integer.valueOf(42);

Two threads may update the same number at the same time. This can give the wrong result.

int count = 0;

// Thread A and Thread B both do:
count++;   // NOT safe

// count++ is really 3 steps:
// 1. read count
// 2. add 1
// 3. write count back

If both threads read 0 at the same time, both may write 1. One update is lost. This is called a race condition.

An atomic variable updates a value in one complete step. No other thread can interrupt in the middle. They live in java.util.concurrent.atomic.

Common atomic classes

AtomicInteger example

import java.util.concurrent.atomic.AtomicInteger;

AtomicInteger visits = new AtomicInteger(0);

visits.incrementAndGet();  // safe ++
int total = visits.get();  // read value

Useful methods

• get() — read the value
• set(value) — set a new value
• incrementAndGet() — add 1 safely
• compareAndSet(old, new) — change only if value is still old

AtomicBoolean example

AtomicBoolean started = new AtomicBoolean(false);

// Only the first thread starts the service
if (started.compareAndSet(false, true)) {
    System.out.println("Starting...");
}

CAS means Compare And Swap. Before updating, it checks the value:

1. Look at the current value
2. Decide the new value
3. Update only if nobody else changed it
4. If someone else changed it, try again

Example: value is 5, thread wants 6. CAS says: "If it is still 5, change it to 6." If another thread already made it 7, skip and try again.

volatile means: when one thread changes this variable, other threads see the new value quickly.

volatile boolean running = true;

// One thread
running = false;

// Other threads see running == false soon

Use the tool that matches your problem:

volatile boolean running = true;

visits.incrementAndGet();

synchronized void transfer(...) {
    from.balance -= amount;
    to.balance += amount;
}

Quick rule: use volatile for a flag, use atomic for one shared number, use synchronized when many related changes must happen together.

A normal shared variable is seen by all threads. A ThreadLocal variable is different: each thread has its own separate value. One thread cannot see or change another thread's ThreadLocal value.

ThreadLocal<String> userName = new ThreadLocal<>();

// Thread A
userName.set("Alice");
System.out.println(userName.get()); // Alice

// Thread B (different thread)
userName.set("Bob");
System.out.println(userName.get()); // Bob

// Alice's value is still Alice in Thread A
// Bob's value is still Bob in Thread B

• set(value) — store a value for the current thread
• get() — read this thread's value
• remove() — delete this thread's value

• Store data that belongs to one request/thread only
• Keep a user id or transaction id for the current thread
• Avoid passing the same value through many method calls

class UserContext {
    private static final ThreadLocal<String> CURRENT_USER =
            new ThreadLocal<>();

    static void setUser(String name) {
        CURRENT_USER.set(name);
    }

    static String getUser() {
        return CURRENT_USER.get();
    }

    static void clear() {
        CURRENT_USER.remove(); // important!
    }
}

Important: always call remove() when the work is finished (especially with thread pools). If you forget, an old value may stay and leak into the next task that reuses the same thread.