Правильный способ реализации поточно-безопасного метода в C++ 11

Question

У меня есть класс, представляющий различные виды инструментов (GCC, LEX, YACC, ...). Каждому экземпляру присваивается тип, представляющий инструмент, и разрешается специальная конфигурация.

Чтобы обрабатывать конфигурацию по умолчанию, у меня есть набор карт и вектор, сохраняющий значения по умолчанию. Как я хочу, чтобы класс, который будет использоваться в любом контексте, она должна была бы быть поточно-, таким образом, чтобы избежать гонки я осуществил следующее:

int Tool::addType(std::string typeName, 
     std::string typeFlagName) 
    throw (GP::Exceptions::LockAcquisitionException) 
{ 
    static std::timed_mutex mutex; 
    std::unique_lock<std::timed_mutex> lock{mutex}; 

    int typeId = 0; 

    if (lock.try_lock_for(std::chrono::microseconds(100))) 
    { 
     int typeId = typeNames.size(); 
     typeNames[typeId] = typeName; 
     typeFlagNames[typeId] = typeFlagName; 
    } 
    else 
    { 
     throw GP::Exceptions::LockAcquisitionException{"Unable to generate new type ID within 100 microseconds."}; 
    } 
    return typeId; 
} 

Я хотел бы знать, если это хорошее решение, или если Я что-то упускаю. Если это нормально, есть ли другое решение, менее подробное?

Answer 1

Почему-то не так?

class tool 
{ 
    std::atomic<int> index_; 
    std::array<std::pair<std::string, std::string>, 2048> types_; // Should be more than enough room. 

    int addType(std::string typeName, std::string typeFlagName) 
    { 
     int id = index++; 

     if(id >= types_.size()) 
      throw GP::Exceptions{"To many types."}; 

     types_[id] = std::make_pair(typeName, typeFlagName); 

     return id; 
    } 

}; 

Вы могли бы сделать это немного умнее с помощью зЬй :: вектор и иметь блокировку только тогда, когда он должен быть перераспределены для большего размера.

ПРИМЕЧАНИЕ: предложение throw() устарело в C++ 11.

Answer 2

Мое предложение было бы:

class tool 
{ 
    std::mutex myMutex; 

    std::vector<std::string> typeNames; 

    int addType(std::string typeName) 
    { 
     std::lock_guard myLock(myMutex); 
     typeNames.push_back(typeName); 
     return typeNames.size()-1; // 
    } 

    // Only hold lock when needed 
    void longComplexFunction(int f) 
    { 
     // Compute as much as possible before 
     int complexMagic = veryLongFunction(f); 

     { 
      std::lock_guard myLock(myMutex); 
      typeNames[complexMagic] += "s"; 
     } 
    } 

}