什么是线程安全问题
多线程同时访问一个资源,且其中至少有一个线程对这个资源进行了修改,导致其他的线程访问到的与期望的不一致这就是线程安全问题。只读不修改不存在线程安全问题。
线程安全问题产生的必要条件
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只能保障变量的可见性,但是不能保障变量赋值的原子性。
这时候我给出两种解决办法:
第一种:使用synchronized加锁来实现线程同步
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){
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问题),但是我们可以创建一个版本号,来记录下每次对变量的修改,每修改一次,便加一,这样就能通过控制版本号保障来每次只被一个线程修改过啦。