CAS和AQS

CAS的概念：

　　CAS的全称为Compare And Swap，直译就是比较交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，其实现方式是基于硬件平台的汇编指令，在intel的CPU中，使用的是cmpxchg指令，就是说CAS是靠硬件实现的，从而在硬件层面提升效率。

CAS的原理：

　　CAS （compareAndSwap），中文叫比较交换，一种无锁原子算法。过程是这样：它包含 3 个参数 CAS（V，E，N），V表示要更新变量的值，E表示预期值，N表示新值。仅当 V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做了更新，则当前线程则什么都不做。最后，CAS 返回当前V的真实值。CAS 操作时抱着乐观的态度进行的，它总是认为自己可以成功完成操作。

AQS的概念：

　　AQS（abstractQueueSychronizer）同步发生器。通过内置得到FIFO同步队列来完成线程争夺资源的管理工作。

AtomicInteger的用法：

/**
 * AtomicInteger的用法
 * @author Administrator
 *
 */
public class CAS2 {
    //声明原子型变量
    private static AtomicInteger atomic1 = new AtomicInteger(100);
    
    public static void main(String[] args) throws Exception {
        /**
         * compareAndSet(期望值，改变值)
         */
        Thread t1 = new Thread(()->{
            System.out.println("t1:"+atomic1.compareAndSet(100, 110));
            System.out.println("t1.atomic1:"+atomic1.get());
        });
        t1.start();
        
        Thread t2 = new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t2:"+atomic1.compareAndSet(110, 100));
            System.out.println("t2.atomic1:"+atomic1.get());
        });
        t2.start();
        
        Thread t3 = new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t3:"+atomic1.compareAndSet(100, 120));
            System.out.println("t3.atomic1:"+atomic1.get());
        });
        t3.start();
    }
}

AtomicStampedReference的用法：

/**
 * AtomicStampedReference的用法
 * @author Administrator
 *
 */
public class CAS3 {

    private static AtomicStampedReference<Integer> asf = new AtomicStampedReference<Integer>(100, 1);
    
    public static void main(String[] args) throws Exception {
        
        /**
         * compareAndSet(期望值，改变值，当前版本号，改变后的版本号)
         */
        Thread t1 = new Thread(()->{
            System.out.println("t1:"+asf.compareAndSet(100, 110, asf.getStamp(), asf.getStamp()+1));
            System.out.println("t1.asf:"+asf.getReference());
        });
        t1.start();
        
        Thread t2 = new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t2:"+asf.compareAndSet(110,100,asf.getStamp(),asf.getStamp()+1));
            System.out.println("t2.asf:"+asf.getReference());
        });
        t2.start();
        
        Thread t3 = new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t3:"+asf.compareAndSet(100, 120,asf.getStamp(),asf.getStamp()+1));
            System.out.println("t3.asf:"+asf.getReference());
        });
        t3.start();
    }

}

通过实现Java的Lock接口来模拟一个锁的实现功能：

/**
 * 模拟实现锁的方法
 * @author Administrator
 *
 */
public class MyLock implements Lock {

    //实例化帮助器
    private Helper helper = new Helper();
    /**
     * 定义内部类帮助器，方便下面方法的执行
     * @author Administrator
     *
     */
    private class Helper extends AbstractQueuedSynchronizer{
        //以独占的方式获取锁
        @Override
        protected boolean tryAcquire(int arg) {
            //调用父类的获取状态的方法
            int state = getState();
            if(state == 0){//如果状态为0 ，那说明可以获得锁
                //利用CAS原理修改state，保证原子性
                boolean stateFlag = compareAndSetState(0, arg);
                if(stateFlag){//如果未true，那么说明当前可以获得锁，进行状态修改
                    //设置当前线程占有资源
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;//返回值，说明获取锁成功
                }
            }else if(getExclusiveOwnerThread() == Thread.currentThread()){//判断当前占有的线程是不是请求的线程
                //增加可重入性功能
                setState(getState()+arg);
                return true;
            }
            //其他情况设置为false，说明获取锁失败
            return false;
        }
        
        //释放锁
        @Override
        protected boolean tryRelease(int arg) {
            //获取当前锁的状态
            int state = getState()-arg;
            //设置标志位
            boolean flag = false;
            //判断释放当前锁后，状态是否为0
            if(state == 0){//说明当前线程锁全部释放
                setExclusiveOwnerThread(null);
                flag=true;
            }
            setState(state);
            return flag;
        }
        
        //条件限制，在某些条件下加锁
        public Condition newConditionObject(){
            return new ConditionObject();
        }
    }
    
    @Override
    public void lock() {
        //设置锁
        helper.acquire(1);

    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        //中断锁
        helper.acquireInterruptibly(1);

    }

    @Override
    public boolean tryLock() {
        // TODO Auto-generated method stub
        return helper.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        // TODO Auto-generated method stub
        return helper.tryAcquireNanos(1, unit.toNanos(time));
    }

    @Override
    public void unlock() {
        // 释放锁
        helper.release(1);
    }

    @Override
    public Condition newCondition() {
        // 在特定条件下给加锁
        return helper.newConditionObject();
    }

}

模拟锁测试类：

/**
 * 测试类
 * @author Administrator
 *
 */
public class MyLockTest {

    private MyLock lock = new MyLock();
    private int m = 0;
    public int next(){
        //开始加锁
        lock.lock();
        try {
            return m++;
        } finally {
            //释放锁
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        MyLockTest t = new MyLockTest();
        Thread[] th = new Thread[20];
        for (int i = 0; i < th.length; i++) {
            th[i] = new Thread(()->{
                System.out.println("m="+t.next());
            });
            th[i].start();
        }
    }
}

使用JDK提供的可重入性锁（ReentrantLock类）：

　　可重入性：同一个锁当有多个同一资源进行占有的时候，直接分配给这个线程。

/**
 * JDK提供的可重入性互斥锁
 * @author Administrator
 *
 */
public class JDKLock {
    //使用JDK提供的可重入性锁
    ReentrantLock lock = new ReentrantLock();
    public void a(){
        lock.lock();
        System.out.println("a");
        b();
        lock.unlock();
    }
    public void b(){
        lock.lock();
        System.out.println("b");
        lock.unlock();
    }
    public static void main(String[] args) {
        JDKLock t = new JDKLock();
        new Thread(()->{
            t.a();
        }).start();
    }

}

使用CountDownLatch（int count）类来实现航空公司卖票的示例：

　　构造器中的计数值（count）实际上就是闭锁需要等待的线程数量，这个值只能被设置一次，而且CountDownLatch函数没有提供任何机制去重新设置这个值。

　　与CountDownLatch的第一次交互是主线程等待其他线程，主线程必须在启动其他线程后立即调用CountDownLatch.await()方法，这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。其他N个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务，这种通知机制是通过CountDownLatch.countDown()方法来完成的，每调用一次这个方法，在构造函数中初始化的count就会减1，所以当N个线程都用了这个方法，count的值就是0，然后主线程就能通过await()方法，恢复执行自己的任务。

/**
 * 模拟航空公司卖票系统
 * @author Administrator
 *
 */
public class FightQueryDemo {

    //公司列表
    private static List<String> companys = Arrays.asList("东方航空","海南航空","南方航空");
    //
    private static List<String> fightList = new ArrayList<>();
    
    public static void main(String[] args) throws InterruptedException {
        //起始地
        String oringin ="BJ";
        //目的地
        String dest = "SH";
        //根据公司数量创建线程数组
        Thread[] threads = new Thread[companys.size()];
        //创建线程统计计数器
        CountDownLatch latch = new CountDownLatch(companys.size());
        
        for (int i = 0; i < threads.length; i++) {
            //获取当前公司名称
            String name = companys.get(i);
            threads[i] = new Thread(()->{
                System.out.printf("%s 查询从%s出发到%s的机票\n",name,oringin,dest);
                //随机产生票数
                int val = new Random().nextInt(10);
                try {
                    TimeUnit.SECONDS.sleep(2);
                    fightList.add(name+"--"+val);
                    System.out.printf("%s 航空公司查询成功\n",name);
                    //计数器减一
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            threads[i].start();
        }
        //线程执行完以后，唤醒主线程，保证执行完上面的线程，在执行下面的
        latch.await();    
        System.out.println("=========查询结果如下============");
        fightList.forEach(System.out::println);
    }
}

CyclicBarrier方法实现运动员起跑的示例：

　　需要所有的子任务都完成时，才执行主任务，这个时候可以选择CyclicBarrier。

　　基本原理：每个线程执行时都会碰到一个屏障，直到所有线程执行结束，然后屏障便会打开，使所有线程继续往下执行。

　　在CyclicBarrier的内部定义了一个Lock对象，每当一个线程调用await()方法时，将拦截的线程数加1，然后判断剩余拦截数是否为初始值parties，如果不是，进入Lock对象的条件队列等待，如果是，执行barrierAction对象的Runnable方法，然后将锁的条件队列中的所有线程放入锁等待队列中，这些线程会依次的获取锁，释放锁。

　　CyclicBarrier的两个构造函数CyclicBarrier(int parties)和CyclicBarrier(int parties,Runnable  barrierAction)，前者只需要声明需要拦截的线程数即可，而后者还需要定义一个等待所有线程到达屏障优先执行的Runnable对象。

/**
 * 使用CyclicBarrier实现运动员跑道实例
 * @author Administrator
 *
 */
public class RaceDemo {

    public static void main(String[] args) {
        int num = 8;
        CyclicBarrier barriers = new CyclicBarrier(num);
        Thread[] player = new Thread[num];
        for (int i = 0; i < player.length; i++) {
            player[i] = new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName()+"准备好了！");
                    //设置屏障
                    barriers.await();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("选手"+Thread.currentThread().getName()+"起跑");
            },"play["+i+"]");
            player[i].start();
        }

    }

}

CountDownLatch和CyclicBarrier的对比：

　　对于CountDownLatch和CyclicBarrier两个类，我们可以看到CountDownLatch类是一个类似于集合点的概念，很多个线程做完事情后等待其他线程完成，全部线程完成之后再恢复运行。不同的是CountDownLatch类需要自己调用countDown()方法减少一个计数，然后调用await()方法即可，而CyclicBarrier则直接调用await()方法即可。

　　所以从上面来看，CountDownLatch更倾向于多个线程合作的情况，等你所有的东西都准备好了，我这边就自动执行了，而CyclicBarrier则是我们都在一个地方等你，大家到齐了再一起执行。

使用Semaphore实现停车场控制车辆进出的示例：

 　　Semaphore解决有限的资源共享问题。

/**
 * 使用Semaphore实现停车场功能
 * @author Administrator
 *
 */
public class CarDemo {

    public static void main(String[] args) {
        //创建seamphore
        Semaphore sp = new Semaphore(5);
        //请求许可
        Thread[] carThread = new Thread[10];
        for (int i = 0; i < carThread.length; i++) {
            carThread[i] = new Thread(()->{
                //请求许可
                try {
                    TimeUnit.SECONDS.sleep(2);
                    sp.acquire();
                    System.out.println(Thread.currentThread().getName()+"可以进入停车场");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //使用资源(占用资源一段时间)
                try {
                    int val = new Random().nextInt(10);
                    TimeUnit.SECONDS.sleep(val);
                    System.out.println(Thread.currentThread().getName()+"停留了"+val+"秒！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //释放资源
                try {
                    sp.release();
                    System.out.println(Thread.currentThread().getName()+"离开了停车场！");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },"carThread["+i+"]");
            carThread[i].start();
        }
    }
}