struct Subsc_t {
        virtual void doSome() = 0;
    };

    set<Subsc_t*> subscribers;

    for (auto s: subscribers) {
        s->doSome();
    }

for (auto i = container.begin(); i != container.end(); ++i)
{
    auto some_value = do_something_with(*i);
    call_some_other_code(some_value);
    // another 100500 lines of code
}

some_type do_something_with(const some_other_type& what)
{
    //....
}

for (auto i = container.begin(); i != container.end(); ++i)
{
    auto some_value = do_something_with(*i);      // А в этот прекрасный момент другой поток делает контейнеру clear()
}

    volatile Set<Subsc_t> subscribers = Collections.emptySet();

public void doSome()
{//тут локи не нужны, т.к. коллекция никогда не меняется
    for (var s: subscribers) {
        s->doSome();
    }
}
public void add(Subscrber s)
{
    synchronized(lock) {
        var newSubscribers = new HashSet<>(subscribers);//потому что мы всегда создаём новую
        newSubscribers.add(s);
        subscribers = newSubscribers;
    }
}

ksd>    struct Subsc_t {
ksd>        virtual void doSome() = 0;
ksd>    };

ksd>    set<Subsc_t*> subscribers;

ksd>    for (auto s: subscribers) {
        s->>doSome();
ksd>    }
ksd>

insert(some)
{
  cs.lock()
  insertedItems.insert(some)
  cs.unlock()
}
erase(some)
{
  cs.lock()
  erasedItems.insert(some)
  cs.unlock()
}

doSome()
{
  for(){...}
  if(insertedItems.size()+erasedItems.size() > 0)
  {
     cs.lock();
     //insert or erase to/from subscribers
     cs.unlock();
  }
}

VVV>doSome()
VVV>{
VVV>  for(){...}
VVV>  if(insertedItems.size()+erasedItems.size() > 0)
VVV>  {
VVV>     cs.lock();
VVV>     //insert or erase to/from subscribers
VVV>     cs.unlock();
VVV>  }
VVV>}

doSome()
{
  for(){...}
  //for insert objects
  if(head != tail)
  {
    tail_=atomicget(tail);
    from(head to tail_){...}
    head=tail_;
  }
}

insert(some)
{
  insertedObjects[(tail+1)%bufsize]=some;
  atomicset(tail, (tail+1)%bufsize);
}