起100个线程 + 1，循环100次查看结果，正常来说应该是100对吧

public static int t = 0;
    public static void main(String[] args) throws InterruptedException {
        for (int i=0;i<100;i++){
            for (int j=0;j<100;j++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        add();
                    }
                }).start();
            }
            //打印t的值
            System.out.println(t);
            t = 0;
        }
    }

    public static void add(){
        t = t + 1;
        System.out.println("t after "+t);
    }

可以看出100个线程操作成员变量a，线程不安全，可以将 t after 注释打开看下就明白了    结果如下

t after 95
t after 96
t after 97
t after 98
t after 99
99 

那么如何保证线程安全？

1.加synchronized，范围越小越好，因为是阻塞的，这里可以对add方法加上此关键字

2.Lock，同样可以对a = a + 1上锁

3.利用JUC类，如AtomicIntege

这里用atomicInteger举例，是通过CAS来保证线程安全的，不懂的可以去查查

public static AtomicInteger t = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        for (int i=0;i<100;i++){
            for (int j=0;j<100;j++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        add();
                    }
                }).start();
            }
            //打印t的值
            System.out.println(t);
            Thread.sleep(2000);//每隔2s置0重计数
            t = new AtomicInteger(0);
        }
    }

    public static void add(){
        int x = t.incrementAndGet();
        System.out.println("t after "+x);
    }

结果如下

t after 95
t after 96
t after 97
t after 98
98
t after 99
t after 100

会发现打印t的值是98，但是后续又运行了2次完毕，而最后的结果才是我们想要打印的值，所以可以在打印t之前等待2s，以等待线程执行完毕，t的打印就会正确了