码迷,www.ydgpx.tw
142双色球复式投注要多少钱 > 编程语言 > 详细

大乐透复式123中31:JAVA中ReentrantLock详解

时间:2018-09-15 20:51:27      阅读:781      评论:0      收藏:0      [点我收藏+]

142双色球复式投注要多少钱 www.ydgpx.tw 标签:amount   get   bank   with   rgs   img   tac   returns   util   

前言:本文解决的问题

  • RentrantLock与Synchronized区别
  • ReentrantLock特征
  • ReentrantLock类的方法介绍

1.什么是ReentrantLock

1.1ReentrantLock 与Synchronized区别

在面试中询问ReentrantLock与Synchronized区别时,一般回答都是

ReentrantLock

  • ReentrantLock是JDK方法,需要手动声明上锁和释放锁,因此语法相对复杂些;如果忘记释放锁容易导致死锁
  • ReentrantLock具有更好的细粒度,可以在ReentrantLock里面设置内部Condititon类,可以实现分组唤醒需要唤醒的线程
  • RenentrantLock能实现公平锁

Synchronized

  • Synchoronized语法上简洁方便
  • Synchoronized是JVM方法,由编辑器保证枷锁和释放

1.2ReentrantLock特征介绍

JAVA的java.util.concurrent框架中提供了ReentrantLock类(于JAVA SE 5.0时引入),ReentrantLock实现了lock接口,具体在JDK中的定义如下:

public class ReentrantLock implements Lock, java.io.Serializable {

 public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

}

看到一个类首先就需要知道它的构造方法有哪些,ReentrantLock有两个构造方法,一个是无参的 ReentrantLock() ;另一个含有布尔参数public ReentrantLock(boolean fair)。后面一个构造函数说明ReentrantLock可以新建公平锁;而Synchronized只能建立非公平锁。

那么Lock接口有哪些方法
技术分享图片
Lock接口中有lock和unlock方法,还有newCondition() 方法,这就是上面说的ReentrantLock里面设置内部Condititon类。由于ReentrantLock实现了Lock接口,因此它必须实现该方法,具体如下:

  public Condition newCondition() {
        return sync.newCondition();
    }

返回Condition类的一个实例。

2 ReentrantLock其它方法介绍

在介绍它的其它方法前,要先明白它的使用方法,以下JDK中的建议:

 class X {
     private final ReentrantLock lock = new ReentrantLock();
      // ...
  
      public void m() {
       lock.lock();  // block until condition holds
       try {
        // ... method body
        } finally {
        lock.unlock()
      }
    }

建议用try,在finally里面一定要释放锁,防止被中断时锁没释放,造成死锁

lock()

 public void lock() {
        sync.lock();
    }

如果该锁没被其它线程获得,则立即返回;并且把 lock hold count的值变位1.

unlock()

 public void unlock() {
        sync.release(1);
    }

如果当前线程是该锁的持有者,则保持计数递减。 如果保持计数现在为零,则锁定被释放。 如果当前线程不是该锁的持有者,则抛出IllegalMonitorStateException 。

isFair()

public final boolean isFair() {
        return sync instanceof FairSync;
    }

判断该锁是不是公平锁

newCondition()

 public Condition newCondition() {
        return sync.newCondition();
    }

返回新的ConditionObject对象。

Condition接口中的方法

  • await(): void await() throws InterruptedException;
    Condition接口中的方法,导致当前线程等到发信号。

  • siginal()
 /**
         * Moves the longest-waiting thread, if one exists, from the
         * wait queue for this condition to the wait queue for the
         * owning lock.
         *
         * @throws IllegalMonitorStateException if {@link #isHeldExclusively}
         *         returns {@code false}
         */
        public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

唤醒一个等待该条件的线程去获得锁(第一个)。

  • signalAll():唤醒所有等待线程。

3 ReentrantLock完整实例介绍

package chapter10.reentrantlock;

import java.util.Arrays;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*模拟转账,把钱从一个账户转到另一个账户
 * */
public class ReentrantLockUse {
    public static final int NACCOUNTS = 100;
    public static final double INITIAL_BALANCE = 1000;
    public static final double MAX_AMOUNT = 1000;
    public static final int DELAY = 10;

    
    public static void main(String[] args) {
        Bank bank = new Bank(NACCOUNTS,INITIAL_BALANCE);
        for(int i = 0 ; i < NACCOUNTS ; i++) {
            int fromAccount = i ;
            Runnable r = () ->{//lambda表达式
                try {
                    while(true) {
                        int toAccount  = (int) (bank.size()*Math.random());
                        double amount = MAX_AMOUNT * Math.random();
                        bank.transfer(fromAccount, toAccount, amount);
                        Thread.sleep((int)(DELAY*Math.random()));
                    }
                }
                catch(InterruptedException e) {
                    
                }
            };
            Thread t = new Thread(r);//新建线程
            t.start();
        }

    }

}

class Bank{
    private final double[] account;//账户
    private Lock bankLock ;     //重复锁
    private Condition sufficientFunds;  //条件对象
    
    
    
    public Bank(int n, double initialBalance) {
        account = new double[n];        
        Arrays.fill(account, initialBalance);
        bankLock = new ReentrantLock();  //构造对象时,实例化锁
        sufficientFunds = bankLock.newCondition();//新建条件对象
    }
    /*转账,把from账户里面的钱转到to里面,金额是amount*/
    public void transfer(int from , int to,double amount) {
        
        bankLock.lock();
        try {
            while(account[from] < amount) {  
                sufficientFunds.await();
            }
            System.out.println(Thread.currentThread());
            account[from] -=amount;
            System.out.printf("%10.2f from %d to %d ",amount,from,to);
            account[to] +=amount;
            System.out.printf(" Total Balance : %10.2f%n", getTotalBalance());
            sufficientFunds.signalAll();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally {
            bankLock.unlock();
        }
    }
    /*做的所有账户总额*/
    public double getTotalBalance() {
        bankLock.lock();
        try {
             double sum = 0;
             for(double a : account) {
                 sum +=a;
             }
             return sum;
        }
        finally {
            bankLock.unlock();
        }
    }
    
    public int size() {
        return account.length;
    }
}

执行结果
技术分享图片

结果分析
循环建立100个线程,每个线程都在不停转账,由于ReentrantLock的使用,任何时刻所有账户的总额都保持不变。另外,把钱amount从A账户转到B账户,要先判断A账户中是否有这么多钱,不过没有就调用条件对象ConditionObject中的await()方法,放弃该线程,等该其它线程转钱进来;转钱完成后调用.siginalAll()。

JAVA中ReentrantLock详解

标签:amount   get   bank   with   rgs   img   tac   returns   util   

原文地址:https://www.cnblogs.com/java-learner/p/9651675.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
? 2014 142双色球复式投注要多少钱 版权所有 京ICP备13008772号-2
迷上了代码!