证券交易系统用户资产的设计

廖雪峰 / 文章 / ... / Reads: 3239 Edit

在《证券交易系统撮合引擎的设计》一文中,我们已经实现了一个最简单的完整的撮合引擎。但是光有撮合引擎是不够的,撮合引擎能处理订单的前提,是用户根据他的资产(法币和证券)来决定买卖。因此,我们还需要一个用户资产管理系统。

用户在买入证券时,需要花费法币,而卖出证券后,获得法币。在A股交易的老股民都知道,下单买入时,系统会先冻结对应的金额,下单卖出时,系统会先冻结对应的证券。之所以需要有冻结这一操作,是因为判断能否下单成功,是根据用户的可用资产判断。每下一个新的订单,就会有一部分可用资产被冻结,因此,用户资产本质上是一个由用户ID和资产ID标识的二维表:

用户ID资产ID可用冻结
101FIAT8900.31200
101STOCK5000
102FIAT128000
103STOCK050

上述二维表有一个缺陷,就是对账很困难,因为缺少了一个关键的负债账户。对任何一个资产管理系统来说,要时刻保证整个系统的资产负债表为零。

对交易所来说,用户拥有的法币和证券就是交易所的系统负债,只需引入一个负债账户,记录所有用户权益,就可以保证整个系统的资产负债表为零。假设负债账户以ID为1的系统用户表示,则用户资产表如下:

用户ID资产ID可用冻结
1FIAT-23400.30
1STOCK-5500
101FIAT8900.31200
101STOCK5000
102FIAT128000
103STOCK050

引入了负债账户后,我们就可以定义资产的数据结构了。

在数据库中,上述表结构就是资产表的结构,将用户ID和资产ID标记为联合主键即可。

但是在内存中,我们怎么定义资产结构呢?

可以使用一个两层的ConcurrentMap定义如下:

// 用户ID -> (资产ID -> Asset)
ConcurrentMap<Long, ConcurrentMap<String, Asset>> userAssets = new ConcurrentHashMap<>();

第一层Map的Key是用户ID,第二层Map的Key是资产ID,这样就可以用Asset结构表示资产:

public class Asset {
    // 可用余额:
    BigDecimal available;
    // 冻结余额:
    BigDecimal frozen;

    public Asset() {
        this(BigDecimal.ZERO, BigDecimal.ZERO);
    }

    public Asset(BigDecimal available, BigDecimal frozen) {
        this.available = available;
        this.frozen = frozen;
    }
}

下一步我们在AssetService上定义对用户资产的操作。实际上,所有资产操作只有一种操作,即转账。转账类型可用Transfer定义为枚举类:

public enum Transfer {
    // 可用转可用:
    AVAILABLE_TO_AVAILABLE,
    // 可用转冻结:
    AVAILABLE_TO_FROZEN,
    // 冻结转可用:
    FROZEN_TO_AVAILABLE;
}

转账操作只需要一个tryTransfer()方法,实现如下:

/**
 * @param type         转账类型
 * @param fromUser     源用户ID
 * @param toUser       目标用户ID
 * @param assetId      资产ID
 * @param amount       转账金额
 * @param checkBalance 是否检查余额足够
 * @return 成功返回true,失败返回false
 */
public boolean tryTransfer(Transfer type, Long fromUser, Long toUser, String assetId, BigDecimal amount, boolean checkBalance) {
    // 转账金额不能为负:
    if (amount.signum() < 0) {
        throw new IllegalArgumentException("Negative amount");
    }
    // 获取源用户资产:
    Asset fromAsset = getAsset(fromUser, assetId);
    if (fromAsset == null) {
        // 资产不存在时初始化用户资产:
        fromAsset = initAssets(fromUser, assetId);
    }
    // 获取目标用户资产:
    Asset toAsset = getAsset(toUser, assetId);
    if (toAsset == null) {
        // 资产不存在时初始化用户资产:
        toAsset = initAssets(toUser, assetId);
    }
    return switch (type) {
    case AVAILABLE_TO_AVAILABLE -> {
        // 需要检查余额且余额不足:
        if (checkBalance && fromAsset.available.compareTo(amount) < 0) {
            // 转账失败:
            yield false;
        }
        // 源用户的可用资产减少:
        fromAsset.available = fromAsset.available.subtract(amount);
        // 目标用户的可用资产增加:
        toAsset.available = toAsset.available.add(amount);
        // 返回成功:
        yield true;
    }
    // 从可用转至冻结:
    case AVAILABLE_TO_FROZEN -> {
        if (checkBalance && fromAsset.available.compareTo(amount) < 0) {
            yield false;
        }
        fromAsset.available = fromAsset.available.subtract(amount);
        toAsset.frozen = toAsset.frozen.add(amount);
        yield true;
    }
    // 从冻结转至可用:
    case FROZEN_TO_AVAILABLE -> {
        if (checkBalance && fromAsset.frozen.compareTo(amount) < 0) {
            yield false;
        }
        fromAsset.frozen = fromAsset.frozen.subtract(amount);
        toAsset.available = toAsset.available.add(amount);
        yield true;
    }
    default -> {
        throw new IllegalArgumentException("invalid type: " + type);
    }
    };
}

除了用户存入资产时,需要调用tryTransfer()并且不检查余额,因为此操作是从系统负债账户向用户转账,其他常规转账操作均需要检查余额:

public void transfer(Transfer type, Long fromUser, Long toUser, String assetId, BigDecimal amount) {
    if (!tryTransfer(type, fromUser, toUser, assetId, amount, true)) {
        throw new RuntimeException("Transfer failed");
    }
}

冻结操作可在tryTransfer()基础上封装一个方法:

public boolean tryFreeze(Long userId, String assetId, BigDecimal amount) {
    return tryTransfer(Transfer.AVAILABLE_TO_FROZEN, userId, userId, assetId, amount, true);
}

解冻操作实际上也是在tryTransfer()基础上封装:

public void unfreeze(Long userId, String assetId, BigDecimal amount) {
    if (!tryTransfer(Transfer.FROZEN_TO_AVAILABLE, userId, userId, assetId, amount, true)) {
        throw new RuntimeException("Unfreeze failed");
    }
}

可以编写一个测试,调用各种转账操作:

static final Long USER_A = Users.TRADER;
static final Long USER_B = Users.TRADER + 1;

@Test
public void testAssetService() {
    AssetService assetService = new AssetService();
    assetService.tryTransfer(Transfer.AVAILABLE_TO_AVAILABLE, Users.DEBT, USER_A, "FIAT", bd("12345.67"), false);
    assertBDEquals(bd("12345.67"), assetService.getAsset(USER_A, "FIAT").getAvailable());
    assertBDEquals(bd("-12345.67"), assetService.getAsset(Users.DEBT, "FIAT").getAvailable());

    assetService.tryTransfer(Transfer.AVAILABLE_TO_AVAILABLE, Users.DEBT, USER_B, "FIAT", bd("45678.9"), false);
    assertBDEquals(bd("45678.9"), assetService.getAsset(USER_B, "FIAT").getAvailable());
    assertBDEquals(bd("-58024.57"), assetService.getAsset(Users.DEBT, "FIAT").getAvailable());

    assertFalse(assetService.tryFreeze(USER_A, "FIAT", bd("12345.68")));
    assertTrue(assetService.tryFreeze(USER_A, "FIAT", bd("1234.56")));
    assertBDEquals(bd("11111.11"), assetService.getAsset(USER_A, "FIAT").getAvailable());
    assertBDEquals(bd("1234.56"), assetService.getAsset(USER_A, "FIAT").getFrozen());

    assetService.tryTransfer(Transfer.AVAILABLE_TO_AVAILABLE, Users.DEBT, USER_B, "STOCK", bd("12.34"), false);
    assertBDEquals(bd("12.34"), assetService.getAsset(USER_B, "STOCK").getAvailable());
    assertBDEquals(bd("-12.34"), assetService.getAsset(Users.DEBT, "STOCK").getAvailable());

    assetService.debug();
}

打印出内存的用户资产如下:

---------- assets ----------
  User 1:
    FIAT: [A = -58024.57, F = 0.00]
    STOCK: [A = -12.34, F = 0.00]
  User 100:
    FIAT: [A = 11111.11, F = 1234.56]
  User 101:
    FIAT: [A = 45678.90, F = 0.00]
    STOCK: [A = 12.34, F = 0.00]
---------- // assets ----------

可验证所有资产的各余额总和为0。

最后是问题解答:

为什么不使用数据库?

因为我们要实现的交易引擎是100%全内存交易引擎,因此所有用户资产均存放在内存中,无需访问数据库。

为什么要使用ConcurrentMap

使用ConcurrentMap并不是为了让多线程并发写入,因为AssetService中并没有任何同步锁。对AssetService进行写操作必须是单线程,不支持多线程调用tryTransfer()

但是读取Asset支持多线程并发读取,这也是使用ConcurrentMap的原因。如果改成HashMap,根据不同JDK版本的实现不同,多线程读取HashMap可能造成死循环(注意这不是HashMap的bug),必须引入同步机制。

参考源码

可以从GitHub下载本文源码。

小结

本文讨论并实现了一个高性能的用户资产系统,其核心只有一个tryTransfer()转账方法,业务逻辑非常简单。

Comments

Make a comment

Author: 廖雪峰

Publish at: ...

关注公众号不定期领红包:

关注微博获取实时动态: