线程安全？你创建出的线程计算结果不准确？

一、线程安全

     如果你想用两个线程计算从1计算到10000000.为了提高计算效率，你引入了两个线程帮你一起计算。例如：

public class ThreadTest {
    static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Object locker=new Object();
        Thread thread=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 500000; i++) {
                        count++;
                }
            }
        };
        Thread thread1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 500000; i++) {
                        count++;
                }
            }
        };
        thread.start();
        thread1.start();
         thread.join();
         thread1.join();
        System.out.println(count);
    }
}

你会发现你每次计算的结果都与真实答案不一致，并且每次的结果都不一样，这是为什么呢？

---

      因为，在该代码中你使用了一个操作，count++。

在代码运行的过程中，count++被分解成了三个机器指令。

（1） load    将内存中的数据放到寄存器A.

  (2)   add      将(寄存器）中的数据+1.

（3）save   将寄存器的值保存存放在内存中。

由于在线程执行的过程中，线程的调度顺序不确定，是随机调度，且为抢占式调度。这一问题就会导致这三个指令被分开执行。就有可能出现以下情况：

就会导致，count语句执行了两遍，但count数值只增加了1。由于线程调度的顺序不确定，所以，load,add,save的执行情况就会有很多种。

为了防止以上的情况产生，我们有以下几种情况避免出现这种线程不安全的情况。

二、解决方案

（1）从根源上解决，不在多个线程中修改同一个变量。

public class Thread1Test {
     static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(){
            @Override
            public void run() {
                int sum=0
                for (int i = 0; i <500000 ; i++) {
                    sum++;
                }
                count+=sum;
            }
        };
        Thread thread1=new Thread(){
            @Override
            public void run() {
                int sum=0
                for (int i = 0; i <500000 ; i++) {
                    sum++;
                }
                count+=sum;
            }
        };
        thread.start();
        thread1.start();
        thread.join();
        thread1.join();
        System.out.println(count);
    }
}

（2）给操作加锁

public class ThreadTest {
    static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Object locker=new Object();
        Thread thread=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 500000; i++) {
                    synchronized(locker){
                        count++;
                    }
                }
            }
        };
        Thread thread1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 500000; i++) {
                    synchronized(locker){
                        count++;
                    }
                }
            }
        };
        thread.start();
        thread1.start();
        //尽量少使用一个共同变量
         thread.join();
         thread1.join();
        System.out.println(count);
    }
}

      在java中有很多的加锁方式，在上述代码中采用的是

synchronzied(){

}

       进入语句表示给以下的操作加锁，执行完毕表示给上述语句解锁。同时，在线程执行到括号里的内容的时候，如果其他线程也执行到同一个对象的synchronzied时，其他线程则进入到阻塞等待，直至括号中的代码执行完毕。

其中括号中的是任何一个对象。例如：

  Object locker=new Object();

同时，需要注意的是：

  (1)如果多个线程修改同一个变量，为了防止出现线程安全问题的出现，需要将关于修改变量的多个线程中的代码都加上锁。

（2）确保多个线程之间使用的是同一个对象，否则也会出现线程安全问题。

三、小贴士

       在代码的不同地方加上synchronzied，会有不同的效果。加上锁，则将代码打包成了原子操作，不会被其他的代码干扰，要么不做，要么全做。

    本文只解锁了多种加锁方式之一，后序内容尽请期待。

    我们在多个线程中修改不同变量，一个线程中修改多个变量，多个线程中读取多个变量，以上情况，都不会出现线程安全。