public class VolatileIntExample {

    private volatile int count;
    private final Map map = new ConcurrentHashMap();

    public void start() {
        Thread[] threads = new Thread[10];
        for (int i = 0 ; i < threads.length ; ++i) {
            threads[i] = new Thread(() ->
                while(count <= 1000000) {
                    ++ count;
                    map.put(Integer.valueOf(count), Integer.valueOf(count));
                }
            });
        }
        for (int i = 0 ; i < threads.length ; ++i) {
            threads[i].start();
        }
    }

    public static void main(String[] args) throws Exception {
        VolatileIntExample example = new VolatileIntExample();
        example.start();
        Thread.sleep(3000);
        System.out.println(example.map.size());
    }
}

2. AtomicBoolean: vừa có khả năng thông báo vừa đảm bảo giá trị sẽ được đồng bộ, vì bên trong nó sử dụng <code>private volatile int value;</code>, nên trong ví dụ trên, bạn cũng có thể sử dụng thế này:

public class AtomicExample {

    private AtomicBoolean active = new AtomicBoolean(false);

    public void prepare() throws InterruptedException {
        new Thread(() -> {
            System.out.println("application preparing ...");
            sleep(3);
            active.set(true);
        })
        .start();
    }

    public void start() throws Exception {
        new Thread(() -> {
            while(!active.get());
            System.out.println("application started");
        })
        .start();
    }

    private static void sleep(int second) {
        try {
            Thread.sleep(second * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        AtomicExample example = new AtomicExample();
        example.prepare();
        example.start();
        sleep(10);
    }
}

public class AtomicIntExample {

    private AtomicInteger count = new AtomicInteger(0);
    private final Map map = new ConcurrentHashMap();

    public void start() {
        Thread[] threads = new Thread[10];
        for (int i = 0 ; i < threads.length ; ++i) {
            threads[i] = new Thread(() -> {
                int value;
                while((value = count.incrementAndGet()) <= 1000000) {
                    map.put(Integer.valueOf(value), Integer.valueOf(value));
                }
            });
        }
        for (int i = 0 ; i < threads.length ; ++i) {
            threads[i].start();
        }
    }

    public static void main(String[] args) throws Exception {
        AtomicIntExample example = new AtomicIntExample();
        example.start();
        Thread.sleep(3000);
        System.out.println(example.map.size());
    }
}