AtomicLong in Multithreading

I'm trying to use AtomicLong in Multi Threading Environment. My desired result is not working,

public class Account implements Runnable {

    private final AtomicLong amount = new AtomicLong(0);

    public Account(long difference) {
        amount.set(difference);
    }

    public void run() {
        System.out.println("The Balance is : " + amount);
    }
}

public class Examples {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        IntStream.range(0, 100).forEach(i -> service.submit(new Account(i)));
    }
}

I tried to use Read/Write Lock and block level synchronization but no luck. Could please someone spot where am doing mistake?

I output has to be starts from 0,1,2...99.

There's no data shared between any of your threads... each creates its own AtomicLong, no sharing. Even if it was shared there would be no guarantee at all that the numbers will print in order. They would not even be a guarantee that all numbers are printed (some of them could be printed more than once).

If I change your code like this:

public static class Account implements Runnable {
    private static final AtomicLong amount = new AtomicLong(0);

    public Account(long difference) {
        amount.set(difference);
    }

    public void run() {
        System.out.println("The Balance is : " + amount);
    }
}

Here's an example of output I get:

The Balance is : 2
The Balance is : 2
The Balance is : 2
The Balance is : 4
The Balance is : 5
The Balance is : 6
The Balance is : 7
The Balance is : 8
The Balance is : 9
The Balance is : 9

The reason is that the following scenario is possible:

• main thread creates Account(0). This writes 0 to the shared AtomicLong.,
• Thread-0 starts up
• main thread creates Account(1). This writes 1 to the shared AtomicLong.
• Thread-0 prints the value, it's now 1. In this case 0 will never be printed.

The only thing that AtomicLong does guarantee you is that all the writes to the value will always be visible by all threads making a read afterwards.

The properties of atomic variables are detailed in the javadoc (see here).

Maybe you meant something like that:

public class Account implements Runnable {

    private final static AtomicLong seq = new AtomicLong(0);
    private final long amount;

    public Account() {
        amount = seq.getAndIncrement();
    }

    public void run() {
        System.out.println("The Balance is : " + amount);
    }
}

public class Examples {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        IntStream.range(0, 100).forEach(i -> service.submit(new Account()));
    }
}

This will guarantee that each account will get a unique value of amount, but the values could be printed in different order.