java volatile 线程间的变量可见性

public class VolatileTest {

    public static void main(String[] args) {
        final T t = new T();

        /**
         * 线程1每一秒让t对象count + 1
         * 线程2 当t.count == 5 循环结束
         * 加上volatile t2可以检测到t.count的变化
         *
         * volatile 保证了多个线程之间变量的可见性
         * 线程在开始运行时会从主内存中copy t.count 到各自线程的工作内存中,在运行中并不会再去堆内存去读取count 所以各个线程是不可见的
         * 加上 volatile 当t.count 写入主内存中的时候 会给其他线程发送 缓冲过期通知 其他线程会再去主内存中读取
         * 注意 volatile 是不适合做同步的 更不能代替synchronized
         */

        System.out.println(t.getCount().hashCode());
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0 ; i < 10; i++) {
                    System.out.println(t.getCount().hashCode());
                    t.next();
                    try {
                        System.out.println(t.getCount());
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t1.start();

        final Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if(t.getCount() == 5) {
                        System.out.println("t2 end");
                        break;
                    }
                }
            }
        });

        t2.start();
    }
}

class T {

    volatile Integer count = 0;

    void next() {
        count ++;
    }

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }
}