多线程学习总结篇(一)

什么是线程安全问题
多线程同时访问一个资源,且其中至少有一个线程对这个资源进行了修改,导致其他的线程访问到的与期望的不一致这就是线程安全问题。只读不修改不存在线程安全问题。
线程安全问题产生的必要条件
1.多个线程同时访问一个资源 2.存在赋值操作 3.被访问的资源被所有线程共享
怎么避免线程安全问腿
我们创建十个线程,每个线程都对i进行自加10000次,最后输出的结果,应该是100001

private static int i=1;     public static void main(String[] args) throws InterruptedException {         for(int m=0;m<=9;m++){             new TestMyThread().start();         }         Thread.sleep(500);         System.out.println(i);      }     static class TestMyThread extends Thread{          @Override         public void run() {             for(int n=0;n<10000;n++){                 i++;             }             System.out.println(Thread.currentThread().getName()+"线程结束了");         }     }  

经测,每次输出结果都小于100001

那么用volatile关键字修饰共享变量有用吗?
多线程学习总结篇(一)
测试发现结果还是不尽人意。
volatile有两个特点:
1.防止指令重排序
2.强制从主内存中读取数据,而不是本地内存
所以volatile只能保障变量的可见性,但是不能保障变量赋值的原子性。

这时候我给出两种解决办法:

第一种:使用private static int i=1; private static Object object=new Object(); public static void main(String[] args) throws InterruptedException { for(int m=0;m<=9;m++){ new TestMyThread().start(); } Thread.sleep(500); System.out.println(i); } static class TestMyThread extends Thread{ @Override public void run() { synchronized (object){ for(int n=0;n<10000;n++){ i++; } System.out.println(Thread.currentThread().getName()+"线程结束了"); } } }

synchronized:锁静态变量和锁实例方法,锁this是一样的,锁静态方法和锁类是一样的。

第二种:
这时候我们可以使用java给我们提供的专门对整数进行并发处理的原子类AtomicInteger,该类在java.util.concurrent.atomic包下,来试试效果把
多线程学习总结篇(一)
如果,我们只是用普通的i++这种操作在高并发的情况下是非常危险的。进行一次i++分为三个步骤:
1.先获取旧值
2.再进行加一
3.再将新值赋给旧值
所以就可能出现加一后还没赋值,被其他线程读取了旧的值,也进行了加一,最后必有一个重复赋值的。这也就解释了,为什么使用volatile还是存在线程安全问题的原因。

通过原子类,可以让自加操作变为一个原子操作,底层其实就是修改值后,再和期望的旧值比较是否相等,如果相等就更新,不相等的话就再进行一次操作直到相等为止。(CAS算法)

手动实现CAS算法:

 public static void main(String[] args) throws InterruptedException {         CasCount casCount = new CasCount();         //创建10001个线程对i进行自加操作         for(int m=0;m<=10000;m++){             new Thread(new Runnable() {                 @Override                 public void run() {                     casCount.getAndIncrement();                 }             }).start();         }         Thread.sleep(1000);         System.out.println(casCount.getI());     }       static class CasCount{         volatile static private int i=0;          public int getI() {             return i;         }         private boolean compareAndSwap(int expectValue, int newValue){             synchronized (this){                 if(expectValue==i){                     i=newValue;                     return true;                 }else {                     return false;                 }             }         }         public  int getAndIncrement(){             int oldValue;             int newValue;             do{                 oldValue=getI();                 newValue=oldValue+1;             }while (!compareAndSwap(oldValue,newValue));             return newValue;         }      } 

CAS算法只能保证值和我们期望的一致,因为即使得到了我们想要的值,也可能被多个线程修改过,这也是CAS算法的缺点(ABA问题),但是我们可以创建一个版本号,来记录下每次对变量的修改,每修改一次,便加一,这样就能通过控制版本号保障来每次只被一个线程修改过啦。

版权声明:玥玥 发表于 2021-05-02 10:30:18。
转载请注明:多线程学习总结篇(一) | 女黑客导航