一、多线程带来的问题

多线程主要解决效率问题，但是也带来了线程安全问题。

例如两个线程 A 和 B 同时启动执行 400 次 m = m +1，期待 = 800 ，实际 m 的结果不一定正确，如下：

 public static void test1() throws InterruptedException {

        Method method = new Method();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 400; i++) {
                    method.add();
                    log.info( Thread.currentThread().getName() + " m= " + method.getM());
                }
                log.info( Thread.currentThread().getName() + " 执行结束：");
            }
        },"线程A");

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 400; i++) {
                    method.add();
                    log.info( Thread.currentThread().getName() + " m= " + method.getM());
                }
                log.info( Thread.currentThread().getName() + " 执行结束：");
            }
        }, "线程B");

        threadA.start();
        threadB.start();
        threadA.join();
        threadB.join();

        log.info("main 执行结束后 m：" + method.getM());

    }
    static class Method{
        int m = 0;
        public  void  add(){
            m = m +1;
        }
        public  int getM(){
            return m;
        }
    }

这是因为 m = m +1; 这行代码实际执行时分为 3 个步骤
（1）从主存中取出 m
（2）计算 m +1
（3）重新给 m 赋值

如果发生下面情况： m = 0 时 线程A和线程B 都执行 m = m+1 但是结果还是=1.

①线程A 执行（1）从主存中取出 m = 0
②线程A执行（2）计算 m +1 = 1
③线程B 执行（1）从主存中取出 m = 0
④线程B执行（2）计算 m +1 = 1
⑤线程B执行（3）重新给 m 赋值，m = 1
⑥线程A执行（3）重新给 m 赋值，m = 1

这个问题的根本是 m = m +1; 不是原子性的（要么全执行，要么全不执行）

如何解决线程安全问题

保证多个线程在访问共享资源时的互斥性
可以使用 synchronized 关键字修饰方法，该方法被称为同步方法。在多线程环境下，同一时间只有一个线程可以执行该方法。其他线程需要等待当前线程执行完毕后才能进入该方法。
例如 Java 容器 Hashtable 源码中的些方法都是用synchronized 修饰的，也就是达到了线程安全 。

public synchronized void  add(){
            m = m +1;
        }