• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

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

互联网 diligentman 1周前 (02-17) 10次浏览

Web全栈~35.显式锁

上一期

接口Lock

显式锁接口的定义

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

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

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

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


程序员灯塔
转载请注明原文链接:Web全栈~35.使用tryLock()避免死锁
喜欢 (0)