多线程学习总结篇（一）

什么是线程安全问题
多线程同时访问一个资源，且其中至少有一个线程对这个资源进行了修改，导致其他的线程访问到的与期望的不一致这就是线程安全问题。只读不修改不存在线程安全问题。
线程安全问题产生的必要条件
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){
     
            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问题），但是我们可以创建一个版本号，来记录下每次对变量的修改，每修改一次，便加一，这样就能通过控制版本号保障来每次只被一个线程修改过啦。