Web全栈~35.使用tryLock()避免死锁

港控/mmm° 2022-10-30 01:21 75阅读 0赞

# Web全栈~35.显式锁 #

## [上一期][Link 1] ##

## 接口Lock ##

### 显式锁接口的定义 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDI0Njg4_size_16_color_FFFFFF_t_70]

lock（）/unlock（）：就是普通的获取锁和释放锁方法，lock（）会阻塞直到成功。

lockInterruptibly（）：与lock（）的不同是，它可以响应中断，如果被其他线程中断了，则抛出InterruptedException。

tryLock（）：只是尝试获取锁，立即返回，不阻塞，如果获取成功，返回true，否则返回false。

tryLock（long time，TimeUnit unit）：先尝试获取锁，如果能成功则立即返回true，否则阻塞等待，但等待的最长时间由指定的参数设置，在等待的同时响应中断，如果发生了中断，抛出InterruptedException，如果在等待的时间内获得了锁，返回true，否则返回false。

newCondition：新建一个条件，一个Lock可以关联多个条件

可以看出，相比synchronized，显式锁支持以非阻塞方式获取锁、可以响应中断、可以限时，这使得它灵活得多。

## ReentrantLock ##

Lock接口的主要实现类是ReentrantLock，它的基本用法lock/unlock实现了与synchronized一样的语义

ReentrantLock有两个构造方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDI0Njg4_size_16_color_FFFFFF_t_70 1]

参数fair表示是否保证公平，不指定的情况下，默认为false，表示不保证公平。所谓公平是指，等待时间最长的线程优先获得锁。保证公平会影响性能，一般也不需要，所以默认不保证，synchronized锁也是不保证公平的

使用显式锁，一定要记得调用unlock。一般而言，应该将lock之后的代码包装到try语句内，在finally语句内释放锁。

### 代码示例 ###

public void fun() { 
          lock.lock();
          try{ 
              count++;
          }finally { 
              lock.unlock();
          }
      }

## 使用tryLock()避免死锁 ##

使用tryLock（），可以避免死锁。在持有一个锁获取另一个锁而获取不到的时候，可以释放已持有的锁，给其他线程获取锁的机会，然后重试获取所有锁。

### 银行转账实例 ###

##### 账户类 #####

class Account{ 
        private Lock lock = new ReentrantLock();
        private volatile double money;
        public Account(double initialMoney){ 
            this.money = initialMoney;
        }
        public void add(double money){ 
            lock.lock();
            try{ 
                this.money = money;
            }finally { 
                lock.unlock();
            }
        }
        public void reduce(double money){ 
            lock.lock();
            try{ 
                this.money -= money;
            }finally { 
                lock.unlock();
            }
        }
        public double getMoney() { 
            return money;
        }
        public void lock(){ 
            lock.lock();
        }
        public void unlock(){ 
            lock.unlock();
        }
        public boolean tryLock(){ 
            return lock.tryLock();
        }
    }

在账户之间转账，需要两个账户都锁定，如果不使用tryLock，而直接使用lock就会发生死锁。这里可以试一试

class NoEnoughMoney extends Exception { 
        public static void transfer(Account from,Account to,double money)
            throws NoEnoughMoney { 
            from.lock();
            try { 
                to.lock();
                try { 
                if(from.getMoney() >= money) { 
                    from.reduce(money);
                    to.add(money);
                } else { 
                    throw new NoEnoughMoney();
                }
                } finally { 
                    to.unlock();
                }
            } finally { 
                from.unlock();
            }
        }
    }

##### 模拟死锁的过程 #####

public static void simulateDeadLock() { 
        final int accountNum = 10;
        final Account[]accounts = new Account[accountNum];
        final Random rnd = new Random();
        for(int i = 0; i < accountNum; i++) { 
            accounts[i]= new Account(rnd.nextInt(10000));
        }
        int threadNum = 100;
        Thread[]threads = new Thread[threadNum];
        for(int i = 0; i < threadNum; i++) { 
            threads[i]= new Thread() { 
                public void run() { 
                    int loopNum = 100;
                    for(int k = 0; k < loopNum; k++) { 
                        int i = rnd.nextInt(accountNum);
                        int j = rnd.nextInt(accountNum);
                        int money = rnd.nextInt(10);
                        if(i!= j) { 
                            try { 
                                transfer(accounts[i],accounts[j],money);
                            } catch (NoEnoughMoney e) { 
                            }
                        }
                    }
                }
            };
            threads[i].start();
        }
    }

这里有10个账户，100个线程，每个线程执行100次循环，在每次循环中，随机挑选两个账户进行转账。每次执行该段代码都会发生死锁。

### 使用tryLock实现转账 ###

public static boolean tryTransfer(Account from,Account to,double money) throws NoEnoughMoney { 
            if(from.tryLock()) { 
                try { 
                    if(to.tryLock()) { 
                        try { 
                            if(from.getMoney() >= money) { 
                                from.reduce(money);
                                to.add(money);
                            } else { 
                                throw new NoEnoughMoney();
                            }
                            return true;
                        } finally { 
                            to.unlock();
                        }
                    }
                } finally { 
                    from.unlock();
                }
            }
            return false;
        }

如果两个锁都能够获得，且转账成功，则返回true，否则返回false。不管怎样，结束都会释放所有锁。

transfer方法可以循环调用该方法以避免死锁

public static void transfer(Account from,Account to,double money) throws NoEnoughMoney { 
        boolean success = false;
        do { 
            success = tryTransfer(from,to,money);
            if(!success) { 
                Thread.yield();
            }
        } while (!success);
    }

[Link 1]: https://blog.csdn.net/qq_41424688/article/details/113816515
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDI0Njg4_size_16_color_FFFFFF_t_70]: /images/20221024/ac5efdaa8b3c4d12ac7affe9ab672d29.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDI0Njg4_size_16_color_FFFFFF_t_70 1]: /images/20221024/320828a586aa419eacc9557431984878.png