Are primitive datatypes thread-safe in Java
java, primitive, thread-safety
Solution
There are three ways in which they're not safe:
- `long` and `double` aren't even guaranteed to be updated atomically (you could see half of a write from a different thread)
- The Java Memory Model doesn't guarantee that you'll see the latest updates from one thread in another thread, without extra memory barriers of some kind
- The act of incrementing a variable isn't atomic anyway
Use `AtomicInteger` etc for thread-safe operations.
Problem
Are the primitive data types like `int` & `short` thread-safe in Java? I have executed the following code and couldn't see expected result 500 some times. ``` public class SampleThree extends Thread { static long wakeUpTime = System.currentTimeMillis() + (1000*20); static int inT; public static void main(String args[]) { System.out.println("initial:" + inT); for(int i=0; i<500; i++) new SampleThree().start(); try { Thread.sleep(wakeUpTime - System.currentTimeMillis() + (1000*30)); System.out.println("o/p:" + inT); } catch(Exception e){ e.printStackTrace(); } } public void run() { try { long s = wakeUpTime - System.currentTimeMillis(); System.out.println("will sleep ms: " + s); Thread.sleep(s); inT++; // System.out.println(inT); } catch(Exception e) { e.printStackTrace(); } } } ``` Here concurrently 500 thread will update the int variable `inT`. Main thread after waiting for concurrent update to be completed, prints `inT` value. Find similar example here