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

最新推荐文章于 2022-08-26 09:19:36 发布
最新推荐文章于 2022-08-26 09:19:36 发布
阅读量114 收藏
点赞数
文章标签： 数据库 java
原文链接：http://www.cnblogs.com/hyiam/p/7919091.html
版权

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

方案：

　　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();
//        }
    }
}

 

转载于:https://www.cnblogs.com/hyiam/p/7919091.html

weixin_30279751
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于内存搜索的进程检测方法
Richard的专栏
08-23 2577
内存 检测 进程 servicetable
java多线程 数据校验,通过volatile验证线程之间的可见性
weixin_32161697的博客
03-12 273
这篇文章主要介绍了通过volatile验证线程之间的可见性,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，工作内存是每个线程的私有数据区域，而Java内存 模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操...
线程池（四）----举例 多线程校验导入的excel数据并给错误的单元格加标注
w_t_y_y的博客
12-20 1306
一、需求：如这样的模板： 填写用户名和年龄，后台判断长度小于2视为错误数据，现需要把填写正确的数据行录入数据库，把错误行标红并加批注说明错误的原因： 二、代码： 1、pom: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchem...
多线程的双重校验
qq_44194174的博客
10-14 344
package com.jt.blog.controller; import java.util.ArrayList; import java.util.List; /** * 双重校验保证线程的安全性 * 假如有100个线程，则只会有3个线程进行双重校验，其余97个则直接执行下面代码，比方法锁的增强了97个校验效率 */ public class ListThreads { static List<Integer> cache=new ArrayList<>();
多线程处理数据
cpzhanghao的博客
09-30 909
https://www.cnblogs.com/qixing/p/9451714.html
内存泄露检测+锁管理
11-23
内存泄露检测是识别并解决这一问题的关键步骤，而锁管理则涉及到多线程编程中的同步和互斥，确保数据的一致性和程序的正确性。 在Windows和Linux环境下，内存泄露检测可以通过多种工具和方法进行。在Windows中，...
内存分配源代码MemoryAllocation.rar
08-30
5. **并发内存管理**：在多线程环境下，内存分配需要考虑线程安全，避免数据竞争和死锁问题。`synchronized`关键字可以用来保证同步访问，防止数据不一致。 6. **内存优化**：通过合理的数据结构选择、对象复用、...
x64下隐藏可执行内存
12-01
尽管TLS最初设计用于存储线程相关的数据，但也可以用来存放可执行代码，尤其是当线程数量较少时。 5. **地址空间布局随机化（ASLR）**：ASLR是一种防止攻击者预测内存地址的安全技术。不过，通过某些技巧，比如动态...
进程的内存监视.rar
03-29
9. **并发与内存**：在多线程环境下，理解内存同步和可见性问题至关重要，避免竞态条件和死锁，确保数据的一致性。 10. **内存安全**：防止缓冲区溢出、指针错误等内存安全问题，是保证程序稳定性和安全性的重要一...
JVM 内存管理及调优.zip_JVM内存_java_memory
09-23
Java虚拟机（JVM）内存管理与调优是Java开发中的关键环节，它涉及到程序的性能、稳定性和资源效率。...同时，理解Java内存模型（JMM）对于并发编程中的可见性、原子性和有序性也非常重要，这是保证多线程安全的基础。
数据/接口多线程处理效验
rebooting__jing的博客
08-26 219
数据/接口多线程处理效验
java验证多线程_验证后台线程的java多线程技术
weixin_42137539的博客
02-26 179
这个程序验证了后台线程与用户线程的区别以及之间的关系，证明了只要所有的用户线程结束了，那么后台线程就将必须结束！import java.util.concurrent.TimeUnit;public class Test {public static void main(String[] args){//将主线程的优先级设为最低，优先执行main线程创建的线程Thread.currentT...
多线程验证-单列&入参实体对象
c851204293的博客
04-08 246
/** * @program: data-transmission-platform * @description: * @author: chengh * @create: 2020-04-02 17:44 **/ @Slf4j @Service public class AsyncServiceImpl implements AsyncService { private ...
校验多线程是否是安全问题的标准是什么?如何解决？
qq_44022870的博客
02-23 146
校验多线程是否是安全问题的标准是什么?如何解决？ 标准是： 当前是否是一个多线程环境 是否存在共享数据 是否有多条语句对共享数据进行操作 解决方法 使用synchronized（锁对象）{ 多条语句对共享数据操作 } // private Object obj = new Object(); private Demo d = new Demo(); ... synchronized(d){//多个线程必须使用的是同一把锁（钥匙）//synchronized(obj) ... }
使用多线程优化双重for循环校验
tanwenfang的博客
12-21 3545
有时候项目中会出现双重for循环校验，类似下面这种：for (int i = 0; i < 10000; i++) { // 外循环 for (int j = i + 1; j < 10000; j++) { // 内循环 //校验规则。。。 } }像这种，外循环的每个i值都要和内循环的i之后的所有数据做校验，如果数据量特备大，而且校验规则很复杂的话，那么校验的次数可
使用多线程处理访问返回
qq_42892856的博客
03-18 359
1.访问请求token //获取token接口 public Map<String, String> whmallToken() { Map<String, String> map = new HashMap<>(); //rowBody基理提供参数 String rowBody = "{\"app_id\": \"xxx\",\"app_secret\": \"xxx\"}"; String
内存检测方法
06-01 1615
内存检测方法 针对常见的DDR内存故障进行了严格的检测处理，下图描述了该检测处理过程的三个步骤：检测数据线、地址线和DDR物理存储部件，主要涉及这三个步骤的处理过程和方法。 下面主要是相关的检测处理思路及问题： 1、为什么先检测数据线？ 因为如果数据线是断开的，那么一切无从谈起！接下来是检测地址线，只有数据线和地址线都通过，检测内存的存储单元才有意义，这样的流程也利于分割定位问题。上面te
内存数据校验 Hamming 偶校验 算法及实现
~{Dynamic}~·的专栏
04-01 819
计算机组成中的主存存储时，在数据读取的时候，为防止出现故障，故会先去检验一下数据的正确性。其中，Hamming偶校验就是其中的一种，这里不去详细的讲一些概念性问题，感兴趣的可以去参阅计算机组成相关书籍。 每个数据由两部分组成，第一部分就是原始数据，第二部分就是校验位。   这里 先来讲一讲Hamming偶校验的具体算法： Hamming(data,datalLength) // 这里的d
C语言多线程内存管理模块.pdf
最新发布
04-04
这个模块的实现有助于提高多线程环境下的程序稳定性，通过主动检测内存问题，可以减少因内存泄漏和越界导致的程序崩溃或不稳定现象。然而，需要注意的是，这样的工具虽然强大，但并不能完全替代对代码的审查和测试，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值