Свернуть блокировку конкуренции C++ std :: map

Question

У меня есть std::map<int, Object*> ObjectMap. Теперь мне нужно обновить карту, и обновление может произойти через несколько потоков. Таким образом, мы блокируем карту для обновлений. Но каждое обновление приводит к длительному вычислению и, следовательно, приводит к конфликту блокировки.

Рассмотрим следующий сценарий.

class Order //Subject  
{ double _a, _b,_c; 
    std::vector<Customer* > _customers; 

    public:   
    void notify(int a, int b. int c) 
    {  
    //update all customers via for loop. assume a for loop and iterator i  
    _customers[i] ->updateCustomer(a,b,c) 
    }  

}; 
class SomeNetworkClass 
{ 
private: 
    std::map<int, Order*> _orders; 
public: 
    void updateOrder(int orderId, int a, int b, intc) 
    {  
    //lock the map 
     Order* order = _orders[orderId]; 
     order->notify(); 
    //release the lock 
    }  
} 

class Customer 
{ 
public: 
    void updateCustomer(int a,int b, int c) 
    { 
    //some lengthy function. just for this example. 
    //assume printing a, b and c multiple times 
    } 
} 

Каждый клиент также обновляется с использованием некоторых вычислений. Теперь это тривиальный шаблон наблюдателя. Но с большим количеством наблюдателей и огромными расчетами в каждом наблюдателе есть убийца для этого дизайна. Контекст блокировки поднимается в моем коде. Я предполагаю, что это практическая проблема, но люди используют более разумные способы, и я ищу эти умные способы. Я надеюсь, что я немного ясно на этот раз

Спасибо Шив

Answer 1

Поскольку обновление происходит на элемент карты, и не принимает карту в качестве аргумента, я полагаю, карта неизменна.

Я представляю структуру как цепочку объектов для каждого идентификатора карты. Теперь, если цепочка содержит отдельные записи (а обновление не имеет доступа к каким-либо элементам за пределами своей цепочки или к любым глобальным элементам), вы можете уйти с добавлением блокировки к корневому элементу каждой цепочки.

Однако, если объекты вниз по цепочке потенциально разделены, у вас возникает более сложная проблема. В этом случае достаточно добавить блокировку к каждому объекту. Вы можете показать, что если цепочки ведут себя правильно (каждый узел имеет один ребенок, но дети могут быть разделены), то блокировки должны быть получены в последовательном порядке, то есть нет никаких шансов на тупик.

Если между цепями существует другое разделение, тогда вероятность столкновения с тупиками велика.

Если у вас есть случай 2, то ваш код будет выглядеть примерно как этот

class Object 
{ 
    Object * next; 
    Lock l; 
    Data d; 
    void update(Data d_new) 
    { 
    l.lock(); 
    d = d_new; 
    next->update(d_new); 
    l.unlock(); 
    } 
};