大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

Web全栈~35.显式锁

上一期

接口Lock

显式锁接口的定义

       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有两个构造方法

       参数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);
}