Concurrency 使用监视器实现证券交易所

我正在尝试使用霍尔的监视器实现一个证券交易所

它有两个函数buy（）和sell（），如下所示：

buy(procid, ticker, nshares, limit)
sell(procid, ticker, nshares, limit)

并应打印买方id、卖方id、股票代码、股票数量和价格等信息。 公平总是令人满意的

monitor SE {
  int available_shares;
  int price;

  sell(procid, ticker, nshares, limit) {
    wait(ticker); // put sell order in ticker queue
    available_shares += nshares;
    price = limit;
    printf("Starting transaction with seller %i", procid);
  }

  buy(procid, ticker, nshares, limit) {
    if (limit <= price && nshares <= available_shares) {
      signal(ticker);
      available_share -= nshares;
      printf("Completing transaction with buyer %i", procid);
      printf("Transacting %i %s shares at %i", nshares, ticker, limit);
    } else {
      wait(ticker); // put buy order in ticker queue
    }
  }
}

我的解决方案的伪代码如下，但它并不完整。 它基本上为每个ticker使用一个条件变量队列。当卖方进程向证券交易所发送卖出指令时，卖方进程在该队列上处于休眠状态，买方进程向卖方进程发出信号，表示如果满足条件（匹配的价格限制和股票数量），卖方进程希望买入

monitor SE {
  int available_shares;
  int price;

  sell(procid, ticker, nshares, limit) {
    wait(ticker); // put sell order in ticker queue
    available_shares += nshares;
    price = limit;
    printf("Starting transaction with seller %i", procid);
  }

  buy(procid, ticker, nshares, limit) {
    if (limit <= price && nshares <= available_shares) {
      signal(ticker);
      available_share -= nshares;
      printf("Completing transaction with buyer %i", procid);
      printf("Transacting %i %s shares at %i", nshares, ticker, limit);
    } else {
      wait(ticker); // put buy order in ticker queue
    }
  }
}

监视SE{
国际可用股票；
国际价格；
卖出（procid、ticker、nshares、limit）{
等待（股票）；//将卖出订单放入股票队列
可用股份+=N股份；
价格=限额；
printf（“与卖方%i开始交易”，procid）；
}
买入（procid、股票代码、nshares、限额）{
如果（limit为了解决死锁问题，我将使用两个条件变量，一个用于买家，一个用于卖家。每种方法首先修改可用的_份额，然后发送自己的条件变量，最后等待另一个条件变量。尽管如此，每个操作在唤醒后都必须重新检查可用_份额的条件完成事务或再次进入睡眠状态

这里的问题是，这不能跟踪你从谁那里购买/出售多少股票。它甚至不能保证卖家在一次交易中出售其所有股票。因此，在回答你最初的问题时，我不认为这种方法能够处理多个股票的多个买卖订单。我建议使用哈希表的解决方案，或其中每个键都是一个限制，每个值都是一个或由标记器排序的解决方案：

monitor SE {
  int available_shares;
  int price;
  Dictionary<int, SortedList<int, Transac>> Ts;

  sell(procid, ticker, nshares, limit) {
    Transac t = new Transac(procid, nshares, limit);

    Ts[limit].enqueue(ticker, t); //probably you should verify first if the entry is not null 

    available_shares += nshares;

    notifyAll(tickerB);

    while(Ts[limit][ticker] > 0)
      wait(tickerS); 

    printf("Starting transaction with seller %i", Ts[limit][ticker].procid);
  }

  buy(procid, ticker, nshares, limit) {

    int nshares_copy = nshares;

    while(true){
      int cnt = 0;
      List<Transac> tmp = new List<Transac>();
      for(int i = 0; i < Ts.keys.length && cnt < nshares; i++){
          if(Ts.keys[i] <= limit){
            for(int j = 0; j < Ts[Ts.keys[i]].lenght && cnt < nshares; j++){
                cnt += Ts[Ts.keys[i]][j].nshares;
                tmp.add(Ts[Ts.keys[i]][j]);
            }
          }
      }
      if(nshares <= cnt){
          available_share -= nshares;

          foreach(Transac t in tmp){
            int min = min(t.nshares, nshares);
            t.nshares -= min;
            nshares -= min;
          }
          break;
      } else {
          wait(tickerB);
      }
    }

    notifyAll(tickerS);

    printf("Completing transaction with buyer %i", procid);
    printf("Transacting %i %s shares at %i", nshares_copy, ticker, limit);
  }
}

监视SE{
国际可用股票；
国际价格；
词典；
卖出（procid、ticker、nshares、limit）{
交易量t=新交易量（procid、nshares、限额）；
Ts[limit].enqueue（ticker，t）；//您可能应该首先验证条目是否不为null
可用股份+=N股份；
通知所有人（TICKRB）；
而（Ts[限额][行情]>0）
等待（股票行情）；
printf（“与卖方%i开始交易”，Ts[limit][ticker].procid）；
}
买入（procid、股票代码、nshares、限额）{
int nshares_copy=nshares；
while（true）{
int-cnt=0；
List tmp=新列表（）；
对于（int i=0；i如果（Ts.key[i]在我看来，这段代码可能会导致死锁情况，因为在等待之后，您会增加可用的_shares变量，因此买方在这种情况下总是会失败，卖方和买方都很可能会失败。您知道我如何解决这一问题吗？或者您是否可以建议一种不同的实现来实现这样一个stock-exchange？@ladypada-boost
lockfree
应该会有帮助，但请注意btw:ty教我如何存储和处理订单。