（十一）synchronized和ReentrantLock使用场景(2)（未完待续）

Posted 2023-04-09

参考技术A 从使用场景的角度出发来介绍对ReentrantLock的使用，相对来说容易理解一些。

可重入概念  

若一个程序或子程序可以“安全的被并行执行(Parallel computing)”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，可以再次进入并执行它（并行执行时，个别的执行结果，都符合设计时的预期）。可重入概念是在单线程操作系统的时代提出的。

(这种情况下synchronized和ReentrantLock哪种好？ReentrantLock除了忘记释放锁，synchronized可以放在方法的定义里面, 而reentrantlock只能放在块里面. 比较起来, synchronized可以减少嵌套，什么业务场景，ReentrantLock还有哪些缺点？)

a、用在定时任务时，如果任务执行时间可能超过下次计划执行时间，确保该有状态任务只有一个正在执行，忽略重复触发。 

b、用在界面交互时点击执行较长时间请求操作时，防止多次点击导致后台重复执行（忽略重复触发）。

以上两种情况多用于进行非重要任务防止重复执行，（如：清除无用临时文件，检查某些资源的可用性，数据备份操作等）

（线程池，消息队列ReentrantLock逻辑处理，不用订单，这个业务场景匹配是否匹配？什么业务用公平和不公平？）

防止资源使用冲突,对资源的争抢（如：文件操作，同步消息发送，有状态的操作等），保证同一时间内只有一个操作可以使用该资源。 

但与synchronized的明显区别是性能优势（伴随jvm的优化这个差距在减小）。同时Lock有更灵活的锁定方式，公平锁与不公平锁，而synchronized永远是公平的。

ReentrantLock默认情况下为不公平锁

区别 ： 

公平 情况下，操作会排一个队按 顺序执行 ，来保证执行顺序。（会 消耗 更多的 时间 来 排队 ） 

不公平 情况下，是无序状态允许插队， jvm 会 自动计算 如何处理更快速来调度插队。（如果不关心顺序，这个速度会更快）

不公平快：请求锁的线程 可能在其前面排列的 休眠线程恢复前 拿到锁， 提高并发 的性能。 挂起 的线程重新开始与它真正开始运行，二者之间会产生严重的延时，非公平锁就可以利用这段时间完成操作

这种其实属于场景2的改进，等待获得锁的操作有一个时间的限制，如果超时则放弃执行。 

用来防止由于资源处理不当长时间占用导致死锁情况（大家都在等待资源，导致线程队列溢出）。

场景4：如果发现该操作已经在执行，等待执行。这时可中断正在进行的操作立刻释放锁继续下一操作

（订单取消？）

synchronized与Lock在默认情况下是不会响应中断(interrupt)操作，会继续执行完。lockInterruptibly()提供了可中断锁来解决此问题。（场景2的另一种改进，没有超时，只能等待中断或执行完毕）

这种情况主要用于取消某些操作对资源的占用。如：（取消正在同步运行的操作，来防止不正常操作长时间占用造成的阻塞）

阿里真题：线程交叉打印

leetcode 1115. 交替打印FooBar 多线程交替打印
五种方案实现多线程交替打印。

涉及 CyclicBarrier 篱栅、回环屏障 、Semaphore 信号灯、ReentrantLock、synchronized、AtomicBoolean 无锁cas 。

全部都已经在leetCode 提交通过

关于这些关键字的原理解释点我

代码如下：

ReentrantLock 方案

 /**
     * 方案3 ReentrantLock
     */
    class FooBar3 
        private int n;

        public FooBar3(int n) 
            this.n = n;
        

        ReentrantLock lock = new ReentrantLock(true);
        Condition c = lock.newCondition();
        volatile boolean flag = true;

        public void foo(Runnable printFoo) throws InterruptedException 

            for (int i = 0; i < n; i++) 
                lock.lock();
                try 
                    if (!flag) 
                        c.await();
                    
                    printFoo.run();
                    flag = false;
                    c.signal();
                 finally 
                    lock.unlock();
                
            
        

        public void bar(Runnable printBar) throws InterruptedException 
            for (int i = 0; i < n; i++) 
                lock.lock();
                try 
                    if (flag) 
                        c.await();
                    
                    printBar.run();
                    flag = true;
                    c.signal();
                 finally 
                    lock.unlock();
                
            
        
    

synchronized 方案

 /**
     * 方案4 与方案三同理 synchronized
     */
    class FooBar4 
        private int n;

        public FooBar4(int n) 
            this.n = n;
        

        volatile boolean flag = true;
        private final Object lock = new Object();

        public void foo(Runnable printFoo) throws InterruptedException 
            for (int i = 0; i < n; i++) 
                synchronized (lock) 
                    //首次执行放行
                    if (!flag) 
                        //当前线程挂起
                        lock.wait();
                    
                    flag = false;
                    printFoo.run();
                    lock.notifyAll();
                
            
        

        public void bar(Runnable printBar) throws InterruptedException 
            for (int i = 0; i < n; i++) 
                synchronized (lock) 
                    if (flag) 
                        //当前线程挂起
                        lock.wait();
                    
                    printBar.run();
                    flag = true;
                    lock.notifyAll();
                
            
        
    

AtomicBoolean 方案 CAS 无锁

/**
     * 方案5 无锁方案 cas
     */
    class FooBar5 
        private int n;

        public FooBar5(int n) 
            this.n = n;
        
        AtomicBoolean flag = new AtomicBoolean(true);
        public void foo(Runnable printFoo) throws InterruptedException 
            for (int i = 0; i < n; i++) 
                while (!flag.get()) 
                    Thread.yield();
                
                printFoo.run();
                flag.compareAndSet(true, false);
            
        

        public void bar(Runnable printBar) throws InterruptedException 
            for (int i = 0; i < n; i++) 
                while (flag.get()) 
                    Thread.yield();
                
                printBar.run();
                flag.compareAndSet(false, true);
            
        
    

Semaphore 方案 信号灯

 /**
     * 方案2 信号灯，相对简单
     */
    class FooBar2 
        private int n;

        public FooBar2(int n) 
            this.n = n;
        

        /**
         * semaphore初始化为1个信号量
         */
        private Semaphore semaphore = new Semaphore(1);
        /**
         * semaphore初始化为0个信号量
         */
        private Semaphore semaphore2 = new Semaphore(0);


        public void foo(Runnable printFoo) throws InterruptedException 

            for (int i = 0; i < n; i++) 
                //判断semaphore信号量是否存在
                semaphore.acquire();
                printFoo.run();
                //释放1个semaphore信号量
                semaphore2.release();
            
        

        public void bar(Runnable printBar) throws InterruptedException 

            for (int i = 0; i < n; i++) 

                //判断semaphore信号量是否存在
                semaphore2.acquire();
                printBar.run();
                //释放1个semaphore信号量
                semaphore.release();
            
        
    

CyclicBarrier 回环屏障

public class FooBar 
    private int n;

    public FooBar(int n) 
        this.n = n;
    

    private static final CyclicBarrier c = new CyclicBarrier(2);

    public void foo(Runnable printFoo) throws InterruptedException 

        for (int i = 0; i < n; i++) 

            // printFoo.run() outputs "foo". Do not change or remove this line.
            printFoo.run();
            try 
                c.await();
             catch (Exception e) 

            

        
    

    public void bar(Runnable printBar) throws InterruptedException 

        for (int i = 0; i < n; i++) 

            // printBar.run() outputs "bar". Do not change or remove this line.
            printBar.run();
            try 
                c.await();
             catch (Exception e)