多线程，内存存放数据检验

背景：为提高帐户校验效率，将原来的数据库检验方式变更为将数据存于内存，动态变更内存数据，检验取内存数据的方式，解决检验问题

方案：

　　1. 创建对象Map用于存放帐户当前可用金额信息

　　2. 检验时，判断金额信息是否存在，存在则使用内存金额进行校验，不存在则查询数据库获取最新的可用金额信息

　　3. 检验通过，则更新可用金额

　　4.每隔一段时间，对内存消息进行核对，将数据库查询到的信息更新到内存中

关键点实现：

　　1. 存放帐户可用金额的对用，必须是线程安全的，使用ConcurrentHashMap，可以在保证效率的同时做到线程安全。

　　eg：

　　// 账户可用额度相关信息Map
　　public static ConcurrentHashMap<Long,AccountGroupInfo> currentAccountGroupAmountMap = new ConcurrentHashMap<Long,AccountGroupInfo>();

　　2. 在对帐户可用额度Map进行操作时，需要进行加锁，保证多线程调用时的数据正确性，同时为了满足加锁未成功的情况下，可设置等待时间，不让校验操作无限等待。

在Map中设计isLock字段，标志帐户是被锁，进行校验，更新操作时，需要对帐户进行加锁。

　　3. 在进行加锁操作时，需要进行同步处理，保证锁的获取是同步的。使用synchronized字段实现锁，但是只对单个的帐户对象进行加锁，保证在同一个帐户的加锁操作上是同步的。

　　4. 对加锁操作进行尝试次数和等待时间控制，加锁操作可以尝试5次，每次尝试失败等待100毫秒，如果在5次100毫秒内未加锁成功，则抛出异常，将此次的校验置为失败，进行下次操作

　　eg：

synchronized (accountGroupInfo) {
            boolean lockSuccess = false;
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"尝试加锁次数"+(i+1)+"==========laccountid============"+laccountid);
                if(!accountGroupInfo.isLock()){
                    accountGroupInfo.setLock(true);
                    lockSuccess = true;
                    System.out.println("---------------加锁成功"+Thread.currentThread().getName()+"==========laccountid============"+laccountid);
                    break;
                }else{
                    Thread.sleep(100);
                }
            }
            if(!lockSuccess){
                System.out.println("加锁失败"+Thread.currentThread().getName()+"==========laccountid============"+laccountid);
                throw new Exception("加锁失败");
            }
        }

附：

　　1.对象加锁

       String key = getKey();
       Object object = getLock(key);
       synchronized (object ) {
             // 逻辑处理代码
       }
        /**
     * 得到对象锁
     */
    private static Object getLock(Long key){
        Object value = new Object();
        Object v = locks.putIfAbsent(key, value);
        if(v == null){
            return value;
        }
        return v;
    } 

　　

 

　　2. 锁逻辑原则

 　　3. 整体代码实现

package com.iss.itreasury.accountgroup;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.concurrent.ConcurrentHashMap;

import com.iss.itreasury.settlement.base.SettlementException;
import com.iss.itreasury.settlement.setting.dao.SettAccountGroupSettingDao;
import com.iss.itreasury.settlement.util.UtilOperation;
import com.iss.itreasury.util.DataFormat;
import com.iss.itreasury.util.Database;
import com.iss.itreasury.util.Env;

public class AccountGroupOperation {
    
    // 账户与账户组的关联关系
    public static ConcurrentHashMap<Long,Long> accountGroup = new ConcurrentHashMap<Long,Long>();
    
    // 账户组可用额度相关信息Map
    public static ConcurrentHashMap<Long,AccountGroupInfo> currentAccountGroupAmountMap = new ConcurrentHashMap<Long,AccountGroupInfo>();
    
    // 帐户组锁
    public static ConcurrentHashMap<Long, Object> locks = new ConcurrentHashMap<Long, Object>();
    

    /**
     *  判断该账户所在账户组本区间是否透支
     * @param 账户ID，支付金额
     * @return 透支true   不透支false
     * @throws Exception 
     * */
    public static boolean isOverDraftAccgroup(long laccountid,double payamount,long lOfficeID,long lCurrencyID) throws Exception{
        
        return isOverDraftAccgroup(laccountid, payamount, lOfficeID, lCurrencyID,false);
    }
    
    
    /**
     *  判断该账户所在账户组本区间是否透支
     * @param 账户ID，支付金额
     * @return 透支true   不透支false
     * @throws Exception 
     * */
    public static boolean isOverDraftAccgroup(long laccountid,double payamount,long lOfficeID,long lCurrencyID,boolean isEbank) throws Exception{
        boolean flag = false;
        // 开机日期
        Timestamp systemDate = Env.getSystemDate(lOfficeID, lCurrencyID);
        SettAccountGroupSettingDao dao = new SettAccountGroupSettingDao();
        // 1. 帐户是否加入了帐户组
        long accountGroupId;
        // 如果账户与帐户组关联关系没有，进行初始化
        if(isEbank){
            accountGroup = new ConcurrentHashMap<Long,Long>();
        }
        if(accountGroup.size()==0){
            AccountGroupOperation.init();
        }
        try {
            // 1.1 获取帐户组ID
            accountGroupId = findAccountGroup(laccountid);
        } catch (Exception e1) {
            e1.printStackTrace();
            throw new Exception("获取帐户组关系失败");
        }
        // 1.2 帐户不在帐户组中，无需校验
        if(accountGroupId == -1){
            System.out.println("帐户:"+laccountid+"不在帐户组中，无需校验");
            return false;
        }
        Object lock = getLock(accountGroupId);
        // 2. 内存currentAccountGroupAmountMap中是否存在该账户组可用额度相关信息
        synchronized (lock) {
            if(currentAccountGroupAmountMap.get(accountGroupId)==null||isEbank){
                System.out.println("==================账户组可用额度Map初始化==================");
                // 2.1 账户组额度信息初始化
                AccountGroupInfo accountGroupInfo = new AccountGroupInfo();
                accountGroupInfo.setLock(false);
                accountGroupInfo.setLimitAmount(-1);
                accountGroupInfo.setLimitDate(systemDate);
                boolean isAccgroupBudget = false;
                try {
                    // 账户是否加入账户组且该年月设置了账户组额度
                    isAccgroupBudget = dao.CheckAccgroupExistBudget(laccountid, accountGroupInfo.getLimitDate()) > 0;
                } catch (Exception e) {
                    e.printStackTrace();
                    throw new Exception("账户是否加入账户组且该年月设置了账户组额度校验失败");
                }
                accountGroupInfo.setAccgroupBudget(isAccgroupBudget);
                currentAccountGroupAmountMap.put(accountGroupId, accountGroupInfo);
            }
        }
        AccountGroupInfo accountGroupInfo = currentAccountGroupAmountMap.get(accountGroupId);
        // 3    额度校验 是否设置了预算
        // 如果月份发生改变，对是否设置预算进行重新赋值
        if(!(DataFormat.getRealMonthString(accountGroupInfo.getLimitDate()).equals(DataFormat.getRealMonthString(systemDate))&&DataFormat.getYearString(accountGroupInfo.getLimitDate()).equals(DataFormat.getYearString(systemDate)))){
            boolean isAccgroupBudget = dao.CheckAccgroupExistBudget(laccountid, accountGroupInfo.getLimitDate()) > 0;
            accountGroupInfo.setAccgroupBudget(isAccgroupBudget);
            // 有变成无，移除缓存内容
            if(accountGroupInfo.isAccgroupBudget()&&!isAccgroupBudget){
                currentAccountGroupAmountMap.remove(accountGroupId);
                System.out.println("帐户:"+laccountid+"不需要进行账户组额度校验");
                return false;
            }
        }
        if(!accountGroupInfo.isAccgroupBudget()){
            System.out.println("帐户:"+laccountid+"不需要进行账户组额度校验");
            return false;
        }
        // 4.帐户组加锁
        synchronized (accountGroupInfo) {
            boolean lockSuccess = false;
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"尝试加锁次数"+(i+1)+"==========laccountid============"+laccountid);
                if(!accountGroupInfo.isLock()){
                    accountGroupInfo.setLock(true);
                    lockSuccess = true;
                    System.out.println("---------------加锁成功"+Thread.currentThread().getName()+"==========laccountid============"+laccountid);
                    break;
                }else{
                    Thread.sleep(1000);
                }
            }
            if(!lockSuccess){
                System.out.println("加锁失败"+Thread.currentThread().getName()+"==========laccountid============"+laccountid);
                throw new Exception("加锁失败");
            }
        }
        // 4.2 额度校验 额度核对(如果“当前可用额度”为-1或“额度日期”不等于开机日或“更新时间”与当前应用服务器时间差值超过1个小时，则执行核对逻辑)
        try{
            checkAccountGroup(accountGroupId,lOfficeID,lCurrencyID);
        }catch (Exception e) {
            e.printStackTrace();
            if(accountGroupInfo.isLock()){
                accountGroupInfo.setLock(false);
            }
            throw new Exception("帐户组额度核对失败");
        }
        // 4.3 额度校验
        System.out.println("======占用前======");
        System.out.println("账户ID======"+laccountid);
        System.out.println("账户组ID======"+accountGroupId);
        System.out.println("账户组可用金额======"+DataFormat.formatNumber(accountGroupInfo.getLimitAmount(),2));
        
        if(UtilOperation.Arith.sub(payamount, accountGroupInfo.getLimitAmount()) > 0 ){
            if(accountGroupInfo.isLock()){
                accountGroupInfo.setLock(false);
            }
            System.out.println("帐户组透支---------------解锁成功"+Thread.currentThread().getName()+"==========laccountid============"+laccountid);
            return true;
        }
        
        // 5  额度占用
        accountGroupInfo.setLimitAmount(UtilOperation.Arith.sub(accountGroupInfo.getLimitAmount(), payamount));
        accountGroupInfo.setUpdateTime(new Timestamp(System.currentTimeMillis()));
        
        System.out.println("======占用后======");
        System.out.println("账户ID======"+laccountid);
        System.out.println("账户组ID======"+accountGroupId);
        System.out.println("账户组可用金额======"+DataFormat.formatNumber(accountGroupInfo.getLimitAmount(),2));
        
        // 6  帐户组解锁
        if(accountGroupInfo.isLock()){
            accountGroupInfo.setLock(false);
        }
        System.out.println("---------------解锁成功"+Thread.currentThread().getName()+"==========laccountid============"+laccountid);
        return flag;
    }
    
    
    
    /**
     *  释放账户组额度
     * @param 账户ID，释放金额
     * @throws Exception 
     * */
    public static void releaseDraftAccgroup(long laccountid,double payamount) throws Exception{
        
        
        // 1. 帐户是否加入了帐户组
        long accountGroupId;
        try {
            // 1.1 获取帐户组ID
            accountGroupId = findAccountGroup(laccountid);
        } catch (Exception e1) {
            e1.printStackTrace();
            throw new Exception("获取帐户组关系失败");
        }
        // 1.2 帐户不在帐户组中，无需校验
        if(accountGroupId == -1){
            System.out.println("帐户:"+laccountid+"不在帐户组中");
            return;
        }
        AccountGroupInfo accountGroupInfo = currentAccountGroupAmountMap.get(accountGroupId);
        // 没有缓存无需释放
        if(accountGroupInfo==null){
            System.out.println("账户组:"+accountGroupId+"没有缓存无需释放");
            return;
        }
        // 2  额度校验 是否设置了预算
        if(!accountGroupInfo.isAccgroupBudget()){
            System.out.println("账户组:"+accountGroupId+"没有设置预算");
            return;
        }
        // 3   帐户组加锁
        Object lock = getLock(accountGroupId);
        boolean lockSuccess = false;
        synchronized (lock) {
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"尝试加锁次数"+(i+1)+"==========laccountid============"+laccountid);
                if(!accountGroupInfo.isLock()){
                    accountGroupInfo.setLock(true);
                    lockSuccess = true;
                    System.out.println("---------------加锁成功"+Thread.currentThread().getName()+"==========laccountid============"+laccountid);
                    break;
                }else{
                    Thread.sleep(1000);
                }
            }
            if(!lockSuccess){
                System.out.println("加锁失败"+Thread.currentThread().getName()+"==========laccountid============"+laccountid);
                throw new Exception("加锁失败");
            }
        }
        System.out.println("======释放前======");
        System.out.println("账户ID======"+laccountid);
        System.out.println("账户组ID======"+accountGroupId);
        System.out.println("账户组可用金额======"+DataFormat.formatNumber(accountGroupInfo.getLimitAmount(),2));
        
        // 4  可用额度释放
        accountGroupInfo.setLimitAmount(UtilOperation.Arith.add(accountGroupInfo.getLimitAmount(), payamount));
        
        System.out.println("======释放后======");
        System.out.println("账户ID======"+laccountid);
        System.out.println("账户组ID======"+accountGroupId);
        System.out.println("账户组可用金额======"+DataFormat.formatNumber(accountGroupInfo.getLimitAmount(),2));
        // 5  帐户组解锁
        if(accountGroupInfo.isLock()){
            accountGroupInfo.setLock(false);
        }
    }
    
    /**
     *  帐户组更新方法
     * @param 账户ID，支付金额
     * @return 透支true   不透支false
     * @throws Exception 
     * */
    public static void DraftAccgroupUpdate(long accountGroupId,String year,String month,long lOfficeID,long lCurrencyID) throws Exception{
        // 开机日期
        Timestamp systemDate = Env.getSystemDate(lOfficeID, lCurrencyID);
        SettAccountGroupSettingDao dao = new SettAccountGroupSettingDao();
        
        // 如果预算不为当前月份
        if(!(DataFormat.getRealMonthString(systemDate).equals(month)&&DataFormat.getYearString(systemDate).equals(year))){
            // 无需通知
            System.out.println("==================预算不为当前月份无需通知==================");
            return;
        }
        
        Object lock = getLock(accountGroupId);
        // 2. 内存currentAccountGroupAmountMap中是否存在该账户组可用额度相关信息
        synchronized (lock) {
            if(currentAccountGroupAmountMap.get(accountGroupId)==null){
                System.out.println("==================账户组可用额度Map初始化==================");
                // 2.1 账户组额度信息初始化
                AccountGroupInfo accountGroupInfo = new AccountGroupInfo();
                accountGroupInfo.setLock(false);
                accountGroupInfo.setLimitAmount(-1);
                accountGroupInfo.setLimitDate(systemDate);
                boolean isAccgroupBudget = false;
                try {
                    // 账户是否加入账户组且该年月设置了账户组额度
                    isAccgroupBudget = dao.CheckGroupExistBudget(accountGroupId, accountGroupInfo.getLimitDate()) > 0;
                } catch (Exception e) {
                    e.printStackTrace();
                    throw new Exception("账户是否加入账户组且该年月设置了账户组额度校验失败");
                }
                accountGroupInfo.setAccgroupBudget(isAccgroupBudget);
                currentAccountGroupAmountMap.put(accountGroupId, accountGroupInfo);
                return;
            }
        }
        AccountGroupInfo accountGroupInfo = currentAccountGroupAmountMap.get(accountGroupId);
        // 4.帐户组加锁
        synchronized (accountGroupInfo) {
            boolean lockSuccess = false;
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"尝试加锁次数"+(i+1)+"==========laccountid============"+accountGroupId);
                if(!accountGroupInfo.isLock()){
                    accountGroupInfo.setLock(true);
                    lockSuccess = true;
                    System.out.println("---------------加锁成功"+Thread.currentThread().getName()+"==========laccountid============"+accountGroupId);
                    break;
                }else{
                    Thread.sleep(1000);
                }
            }
            if(!lockSuccess){
                System.out.println("加锁失败"+Thread.currentThread().getName()+"==========laccountid============"+accountGroupId);
                throw new Exception("加锁失败");
            }
        }
        // 额度更新为-1
        accountGroupInfo.setLimitAmount(-1);
        // 6  帐户组解锁
        if(accountGroupInfo.isLock()){
            accountGroupInfo.setLock(false);
        }
        System.out.println("---------------解锁成功"+Thread.currentThread().getName()+"==========laccountid============"+accountGroupId);
    }
    /**
     * 得到帐户组锁
     */
    private static Object getLock(Long key){
        Object value = new Object();
        Object v = locks.putIfAbsent(key, value);
        if(v == null){
            return value;
        }
        return v;
    }
    /**
     * add by jiecheni 2017-11-02 
     * 账户与账户组关联关系初始化
     */
    public static void init() {
        System.out.println("==========================账户与账户组关联关系初始化开始==========================");
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            //先清理缓存
            accountGroup.clear();
            
            con = Database.getConnection();
            StringBuffer sb = new StringBuffer();
            sb.append(" select a.naccgroupid,a.naccountid from sett_budgetaccassign a where a.nstatusid > 0 ");
            ps = con.prepareStatement(sb.toString());
            rs = ps.executeQuery();
            while (rs.next()) {
                try {
                    accountGroup.put(rs.getLong("naccountid"), rs.getLong("naccgroupid"));
                } catch (NullPointerException e) {
                    continue;
                }
            }
            rs.close();
            rs = null;
            ps.close();
            ps = null;
            con.close();
            con = null;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null)
                {
                    rs.close();
                    rs = null;
                }
                if (ps != null)
                {
                    ps.close();
                    ps = null;
                }
                if (con != null)
                {
                    con.close();
                    con = null;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }    
        }
        System.out.println("==========================账户与账户组关联关系初始化结束，初始化关系数量=========================="+accountGroup.size());
    }
    
    /**
     * add by jiecheni 2017-11-02 
     * 查询账户是否在账户组
     * @param id
     * @return
     * @throws Exception
     */
    public static long findAccountGroup(long id) throws Exception {
        Long result = null;
        try {
            result = accountGroup.get(Long.valueOf(id));
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("查询出现异常，出错原因："+e.getMessage(), e);
        }
        return result == null ? -1 : result;
    }
    
    /**
     * add by jiecheni 2017-11-02 
     * 将账户与账户组关联信息存入缓存
     * @param accountId
     * @param accountGroupId
     */
    public static void putAccountGroup(long accountId,long accountGroupId) {
        accountGroup.put(accountId, accountGroupId);
    }
    
    /**
     * add by jiecheni 2017-11-02 
     * 将账户与账户组关联信息从缓存中清除
     * @param accountId
     */
    public static void removeAccountGroup(long accountId) {
        accountGroup.remove(accountId);
    }
    
    /**
     * 账户组额度核对
     * @param accountGroupId    账户组Id
     * @param lOfficeID            办事处Id
     * @param lCurrencyID        币种id
     * @throws Exception
     */
    public static void checkAccountGroup(long accountGroupId,long lOfficeID,long lCurrencyID) throws Exception{
        int isCheckResult = isCheckAccountGroup(accountGroupId,lOfficeID,lCurrencyID);
        AccountGroupInfo accountGroupInfo = currentAccountGroupAmountMap.get(accountGroupId);
        Timestamp limitDate = accountGroupInfo.getLimitDate();
        if(isCheckResult == 3){
            Timestamp systemDate = Env.getSystemDate(lOfficeID,lCurrencyID);
            double accountGroupAmount = UtilOperation.Arith.sub(queryAccountGroupBudget(accountGroupId,systemDate),queryAccountGroupUsedAmount(accountGroupId,systemDate));
            accountGroupInfo.setLimitDate(systemDate);
            accountGroupInfo.setLimitAmount(accountGroupAmount);
            accountGroupInfo.setUpdateTime(new Timestamp(System.currentTimeMillis()));
            currentAccountGroupAmountMap.put(accountGroupId, accountGroupInfo);
        }else if(isCheckResult > 0){
            double accountGroupAmount = UtilOperation.Arith.sub(queryAccountGroupBudget(accountGroupId,limitDate),queryAccountGroupUsedAmount(accountGroupId,limitDate));
            accountGroupInfo.setLimitAmount(accountGroupAmount);
            accountGroupInfo.setUpdateTime(new Timestamp(System.currentTimeMillis()));
            currentAccountGroupAmountMap.put(accountGroupId, accountGroupInfo);
        }
    }
    
    /**
     * 是否核对账户组额度
     * @param accountGroupId    账户组Id    
     * @param lOfficeID            办事处Id
     * @param lCurrencyID        币种id
     * @return 
     * 1: 当前可用额度为-1.
     * 2: 账户组更新时间与当前应用服务器时间差是否超过一个小时.
     * 3: 开机日是否与额度日期不同.
     * 
     */
    public static int isCheckAccountGroup(long accountGroupId,long lOfficeID,long lCurrencyID) throws Exception{
        int isCheckAccountGroup = 0;
        AccountGroupInfo accountGroupInfo = currentAccountGroupAmountMap.get(accountGroupId);
        if(accountGroupInfo != null){
            //如果"当前可用额度"为-1或"额度日期"不等于开机日或"更新时间"与当前应用服务器时间差值超过1个小时，则执行核对逻辑
            //a、"当前可用额度"为-1
            if(accountGroupInfo.getLimitAmount() <= 0){
                return 1;
            }
            //b、账户组更新时间与当前应用服务器时间差是否超过一个小时
            if(accountGroupInfo.getUpdateTime() != null){ 
                if((System.currentTimeMillis()-accountGroupInfo.getUpdateTime().getTime()) > 1*60*60*1000){
                    return 2;
                }
            }
            //c、开机日是否与额度日期不同
            Timestamp systemDate = Env.getSystemDate(lOfficeID,lCurrencyID);
            Timestamp limitDate = accountGroupInfo.getLimitDate();
            boolean isSameDate = com.iss.itreasury.util.UtilOperation.isSameDate(systemDate,limitDate);
            if(!isSameDate){
                return 3;
            }
        }else{
            //初始化账户组额度信息
            initAccountGroup(accountGroupId);
        }
        return isCheckAccountGroup;
    }
    
    /**
     * 初始化账户组额度信息
     * @param accountGroupId    账户组Id
     * @throws Exception
     */
    private static void initAccountGroup(long accountGroupId) throws Exception{
        AccountGroupInfo accountGroupInfo = new AccountGroupInfo();
        Timestamp systemDate = Env.getSystemDate(1,1);
        double accountGroupAmount = UtilOperation.Arith.sub(queryAccountGroupBudget(accountGroupId,systemDate),queryAccountGroupUsedAmount(accountGroupId,systemDate));
        accountGroupInfo.setAccgroupBudget(true);
        accountGroupInfo.setLock(false);
        accountGroupInfo.setLimitDate(systemDate);
        accountGroupInfo.setLimitAmount(accountGroupAmount);
        accountGroupInfo.setUpdateTime(new Timestamp(System.currentTimeMillis()));
        currentAccountGroupAmountMap.put(accountGroupId, accountGroupInfo);
    }
    
    /**
     * 查询账户组设置预算额度
     * @param accountGroupId    账户组Id
     * @param executedate        执行日期
     * @return
     * @throws Exception
     */
    public static double queryAccountGroupBudget(long accountGroupId,Timestamp executedate) throws Exception{
        //账户组设置预算额度
        double accountGroupBudgetAmount = 0.0;
        int year = 0;//年份
        int month = 0;//月份
        
        AccountGroupDao agDao = new AccountGroupDao();
        if(executedate != null){
            Calendar calendar = Calendar.getInstance();
            calendar.setTimeInMillis(executedate.getTime());
            year = calendar.get(GregorianCalendar.YEAR);
            month = calendar.get(GregorianCalendar.MONTH) + 1;
        }else{
            throw new SettlementException("执行日期为空",new Exception());
        }
        //查询账户组设置预算额度
        accountGroupBudgetAmount = agDao.queryAccountGroupBudgetAmount(accountGroupId,executedate,year,month);

        return accountGroupBudgetAmount;
    }
    
    /**
     * 统计查询账户组已使用额度 
     * 账户组已使用额度 = 网银、CBE使用额度 + 结算、银行流水入账使用额度
     * @param accountGroupId    账户组Id
     * @param executedate        执行日期
     * @return
     * @throws Exception
     */
    public static double queryAccountGroupUsedAmount(long accountGroupId,Timestamp executedate) throws Exception{
        //账户组已使用额度
        double accountGroupUsedAmount = 0.0;
        //网银和CBE使用额度
        double ebankUsedAmount = 0.0;
        //柜台业务和入账使用额度
        double settUsedAmount = 0.0;
        
        AccountGroupDao agDao = new AccountGroupDao();
        //统计查询网银和CBE使用额度
        ebankUsedAmount = agDao.queryEbankUsedAmount(accountGroupId,null,executedate);
        //查询统计柜台业务和入账使用额度
        settUsedAmount = agDao.querySettUsedAmount(accountGroupId,null,executedate);
        
        accountGroupUsedAmount = ebankUsedAmount + settUsedAmount;
        return accountGroupUsedAmount;
    }
    
    /**
     * 统计查询账户组已使用额度 
     * 账户组已使用额度 = 网银、CBE使用额度 + 结算、银行流水入账使用额度
     * @param accountGroupId    账户组Id
     * @param startExecuteDate    开始执行日期
     * @param startExecuteDate    结束执行日期
     * @return
     * @throws Exception
     */
    public static double queryAccountGroupUsedAmount(long accountGroupId,Timestamp startExecuteDate,Timestamp endExecuteDate) throws Exception{
        //账户组已使用额度
        double accountGroupUsedAmount = 0.0;
        //网银和CBE使用额度
        double ebankUsedAmount = 0.0;
        //柜台业务和入账使用额度
        double settUsedAmount = 0.0;
        
        AccountGroupDao agDao = new AccountGroupDao();
        //统计查询网银和CBE使用额度
        ebankUsedAmount = agDao.queryEbankUsedAmount(accountGroupId,startExecuteDate,endExecuteDate);
        //查询统计柜台业务和入账使用额度
        settUsedAmount = agDao.querySettUsedAmount(accountGroupId,startExecuteDate,endExecuteDate);
        
        accountGroupUsedAmount = ebankUsedAmount + settUsedAmount;
        return accountGroupUsedAmount;
    }
    // test
    public static void main(String[] args) {
        
//        accountGroup.put(1L, 2L);
//        accountGroup.put(2L, 2L);
//        accountGroup.put(3L, 2L);
//        accountGroup.put(4L, 3L);
//        
//        try {
//            Thread thread1 = new Thread(){
//                public void run(){
//                    try {
////                        AccountGroupOperation accountGroupOperation = new AccountGroupOperation();
//                        System.out.println("fasdfasdfasdf1111===="+AccountGroupOperation.isOverDraftAccgroup(1, 10000, 1, 1));
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//                } 
//            };
//            Thread thread2 = new Thread(){
//                public void run(){
//                    try {
////                        AccountGroupOperation accountGroupOperation = new AccountGroupOperation();
//                        System.out.println("fasdfasdfasdf222===="+AccountGroupOperation.isOverDraftAccgroup(2, 10000, 1, 1));
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//                } 
//            };
//            Thread thread3 = new Thread(){
//                public void run(){
//                    try {
////                        AccountGroupOperation accountGroupOperation = new AccountGroupOperation();
//                        System.out.println("fasdfasdfasdf3333===="+AccountGroupOperation.isOverDraftAccgroup(3, 10000, 1, 1));
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//                }
//            };
//            Thread thread4 = new Thread(){
//                public void run(){
//                    try {
////                        AccountGroupOperation accountGroupOperation = new AccountGroupOperation();
//                        System.out.println("fasdfasdfasdf44444===="+AccountGroupOperation.isOverDraftAccgroup(4, 10000, 1, 1));
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//                }
//            };
//            
//            thread1.start();
//            thread2.start();
//            thread3.start();
//            thread4.start();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    }
}