多线程共享数据被破坏的原因和解决方法

多线程共享数据无锁情况下极有可能会造成数据丢失

在没有锁的情况下，无论是从操作系统的角度还是Java多线程，或者其他语言的多线程的角度，多线程的并发性对共享数据的IO极有可能会对数据进行破坏。

举例

public class test {

    private static  long data = 1 ;
    private static  long pdata = 1 ;
    private static  long cdata = 1 ;

    public static void main(String[] args) {
        new Thread(new Runnable(){

            @Override
            public void run() {
                while(true){
                    data++;
                    pdata++;
                    System.out.println("data:"+data+" pdata："+pdata+" cdata："+cdata+" 差值："+((pdata+cdata)-data));
                }
            }

        }).start() ;

        new Thread(new Runnable(){

            @Override
            public void run() {
                while(true){
                    data++;
                    cdata++;
                }
            }

        }).start() ;
    }
}

说明：在此代码中，data pada在父线程中进行死循环++，并且自增1后输出（pdata+cdata）-data的差值，子线程中data cdata在死循环中++。乍一看，两个线程都在同时跑，并且pdata 和cdata在子父线程分别++，而data在两个线程中都++，他们的差值输出应该永远都是0。
测试结果如下：
图片中已经运行了几秒钟，前面还有6780行，这个结果的差值时一直递增的，为什么会这样？为什么不是0？
答案：
在对变量进行++操作时，也就是重新赋值时，是由底层的寄存器来操作的，例如data++其可简单“翻译”为1.register=data；
2.register=register+1；3.data=register；这三个步骤。他们的运算速度极快，当父线程中寄存器在运算的时候，子线程会不会也拿到寄存器进行运算呢。在没有锁的情况下，当然可以。

• 父线程
• register=data --------------0------------------父
• register=register+1------1=0+1------------父
• 此时刻子线程调用寄存器运算
• register=data --------------0------------------子
• data=register--------------data=1-----------父
• register=register+1------1=0+1------------子
• data=register--------------data=1-----------子
  最终结果本应该data的值是2，但实际上是1，就是因为两个线程分别同时调用寄存器进行操作的时候造成了干扰，导致它的值缺失了1。
  这样推算，data的值会每次进行一次寄存器运算就有可能会丢失数据，而cdata，pdata的++操作只存在一个线程中，数据并不会被破坏。他们的差值在while（1）的驱使下会逐渐递增。

解决方案：
多线程在对共享数据进行操作时，如果没有任何的隔离措施，必定会造成数据的破坏，如果没有，那只是时间的问题。怎么隔离？锁它，当一个线程对共享数据进行操作开始的时候上锁，结束时解锁，另一个线程看到有锁的时候就干等着，不断地观察锁的状态，锁一开，就进入继续对共享数据进行操作。难道真的要去买一把锁吗？当然不是，自定义上锁解锁函数lock unlock，当然在高级语言没必要这样，有现成的函数，比如java去继承Runnable类，调用里面的锁即可。

接着，对data上锁，也就是说data的数据不会被破坏，并且分别在两个线程的cdata和pdata都不会有数据的丢失，但是也会出现差值不为0

class Demo {
    public int data;
    public int pdata;
    public int cdata;
}

public class test {

    public static void main(String[] args) throws InterruptedException {
        Demo a=new Demo();
        a.data=0;
        a.pdata=0;
        a.cdata=0;
        new Thread(() -> {
            while(true){
                synchronized (a){
                    a.data++;
                    a.pdata++;
                    if(a.data%1000000==0){
                        System.out.println("data:"+a.data+" pdata："+a.pdata+" cdata："+a.cdata+" 差值："+((a.pdata+a.cdata)-a.data));
                    }
                }
            }
        }).start() ;
        new Thread(() -> {
            while(true){
                synchronized (a){
                    a.data++;
                    a.cdata++;
                }
            }
        }).start() ;
    }
}

把父线程data++ pdata++和输出，子线程data++ cdata++加上锁的时候，惊奇的发现，他们的值完全相等，差值最终为0。

但是这样的套的锁，套的并不好，因为锁上越多的东西，就代表着，你有更多的程序需要执行，需要耗时，别的线程就要等待等待，当有很多很多线程，锁中的内容又有很多无意义的内容，这样就会降低性能，下面再看看把输出排除到锁外面会怎么样。

new Thread(() -> {
            while(true){
                synchronized (a){
                    a.data++;
                    a.pdata++;
                }
                if(a.data%1000000==0){
                    System.out.println("data:"+a.data+" pdata："+a.pdata+" cdata："+a.cdata+" 差值："+((a.pdata+a.cdata)-a.data));
                }
            }
        }).start() ;
        new Thread(() -> {
            while(true){
                synchronized (a){
                    a.data++;
                    a.cdata++;
                }
            }
        }).start() ;

下面就会出现这样的情况了，线程不安全，但是我认为数据时原本没有改变的，只是因为输出操作耽误了一些时间，导致了一些偏差。最好还是用上面的，全部给a对象锁包括的东西都锁上把！