concurrent-4-锁

锁

锁的设计

    1.减少锁持有时间
        减少锁的持有时间有助于降低锁冲突的可能性，进而提升系统的并发能力。
    2.减小锁粒度
        缩小锁定对象的范围，从而减少锁冲突的可能性，进而提高系统的并发能力。
    3.读写分离锁
        在读多，写少的环境下用读写锁能大大减少线程等待时间。
    4.锁粗化
        在遇到一连串地对同一锁不断进行请求和释放的操作时，把所有的锁操作整合成对锁的一次请求，从而减少对锁的请求同步次数。

虚拟机对锁的优化

    1.锁偏向
        如果一个线程获得了锁，那么锁就进入偏向模式，当这个线程再次请求锁时，无须再做任何同步操作。
    2.轻量级锁
    3.自旋锁
    4.锁消除

无锁

    使用无锁的方式完全没有锁竞争带来的系统开销，也没有线程间频繁调度带来的开销，因此，它比基于锁的方式拥有更优越的性能

比较交换(CAS)

    它包含三个参数CAS(V,E,N) ，V表示要更新的变量，E表示预期值，N表示新值。仅当V值等于E值时，才会将V值设为N，如果V值和E值不同则说明有其它线程做了更新，则当前线程什么也不做。

AtomicInteger

        直接使用CAS操作的线程安全类型    
    AtomicLong，AtomicBoolean，AtomicReference类似；

//CAS 操作无须加锁，保证线程安全
    private static AtomicInteger atomicInteger=new AtomicInteger();

    private static CountDownLatch countDownLatch=new CountDownLatch(10);

    public static void main(String[] args) {
        ExecutorService executorService=Executors.newFixedThreadPool(10);
        for (int i = 0 ; i < 10 ; i ++) {
            executorService.submit(
                    ()->{
                        for(int k = 0 ; k < 10000 ; k ++) {
                            atomicInteger.incrementAndGet();
                        }
                        countDownLatch.countDown();  //计数
                    }
            );
        }
        try {
            countDownLatch.await();  //等待完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(atomicInteger);
        //输出
        //100000
    }

AtomicStampedReference

        //加入时间戳的CAS对象引用操作，可能解决由于线程修改n次后值不变的bug问题

    private static AtomicStampedReference<Integer> reference=new AtomicStampedReference<>(19, 0);

    public static void main(String[] args) {

        for (int i=0; i < 3; i++) {
            int stamp=reference.getStamp();
            new Thread(
                    () -> {
                        while (true) {
                            while (true) {
                                Integer money=TestAtomicStamped.reference.getReference();
                                if (money < 20) {
                                    if (reference.compareAndSet(money, money + 20, stamp, stamp + 1)) {
                                        System.out.println(" 充值20成功，余额 =" + reference.getReference());
                                        break;
                                    }
                                } else {
                                    System.out.println(" 余额大于20，无须充值");
                                    break;
                                }
                            }
                        }
                    }

            ).start();
        }
        for (int i=0; i < 3; i++) {
            new Thread(
                    () -> {
                        while (true) {
                            int stamp=reference.getStamp();
                            Integer money=TestAtomicStamped.reference.getReference();
                            if (money > 10) {
                                if (reference.compareAndSet(money, money - 10, stamp, stamp + 1)) {
                                    System.out.println(" 消费10，余额 = " + reference.getReference());
                                    break;
                                }
                            } else {
                                System.out.println(" 余额不足，请充值");
                                break;
                            }
                        }
                    }

            ).start();
        }
    }
    //输出
    充值20成功，余额 =39
    余额大于20，无须充值
    余额大于20，无须充值
    余额大于20，无须充值
    消费10，余额 = 29
    消费10，余额 = 19
    消费10，余额 = 9
    余额不足，请充值

死锁

    互相占用对方的请求的锁资源，造成线程blocking

private static  Object lock1 = new Object() ;

    private  static  Object lock2 = new Object() ;

    public static void main(String[] args) {

        new Thread(
                ()->{
                    synchronized (lock1){
                        try {
                            Thread.sleep(2000);
                            System.out.println(Thread.currentThread().getName() + "  lock1");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (lock2) {
                            System.out.println(Thread.currentThread().getName() + "  lock2");
                        }
                    }
                }
        ).start();

        new Thread(
                ()->{
                    synchronized (lock2){
                        try {
                            Thread.sleep(2000);
                            System.out.println(Thread.currentThread().getName() + "  lock2");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (lock1) {
                            System.out.println(Thread.currentThread().getName() + "  lock1");
                        }
                    }
                }
        ).start();
    }
    //输出
    Thread-1  lock2
    Thread-0  lock1