多线程共享数据无锁情况下极有可能会造成数据丢失
在没有锁的情况下,无论是从操作系统的角度还是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对象锁包括的东西都锁上把!