// Запись
  Settings new_settings = {/*...*/};
  InterlockedIncrement(&shared_data->version);
  memcpy( &shared_data->settings, &new_settings , sizeof(Settings));
  InterlockedIncrement(&shared_data->version);


// Чтение
  LONG before, after;
  Settings local_settings;
ReadSerrings:
  before = InterlockedAdd(&shared_data->version, 0);
  memcpy(&local_settings, &shared_data->settings, sizeof(Settings));
  after = InterlockedAdd(&shared_data->version, 0);
  if (before != after) {
    SwitchToThread();
    goto ReadSettings;
  }

// Запись
  Settings new_settings = {/*...*/};
  for (;;)
  {//ждемс другого писателя если надо
  LONG new_before = InterlockedIncrement(&shared_data->version_before);
  if (new_before == (shared_data->version_after+1)) break;
  InterlockedDecrement(&shared_data->version_before);
  SwitchToThread();
  }
  memcpy( &shared_data->settings, &new_settings , sizeof(Settings));
  InterlockedIncrement(&shared_data->version_after);


// Чтение
  Settings local_settings;
  ReadSerrings:
  for(;;)
  {
   LONG after = InterlockedCompareExchange(&shared_data->version_after, 0, 0);
   memcpy(&local_settings, &shared_data->settings, sizeof(Settings));
   if (InterlockedCompareExchange(&shared_data->version_before, after, after)==after) break;
   SwitchToThread();
  }

// Запись
  Settings new_settings = {/*...*/};
 
  InterlockedIncrement(&shared_data->version);
  memcpy( &shared_data->settings, &new_settings , sizeof(Settings));
  InterlockedIncrement(&shared_data->version2);


// Чтение
  LONG before, after;
  Settings local_settings;

  for(;;)
  {
      before = shared_data->version;
      memcpy(&local_settings, &shared_data->settings, sizeof(Settings));
      after = shared_data->version;
     if (before == after) break;
     for(;;)
     {
         if (after == &shared_data->version2) break;
         SwitchToThread();
     }
  }

2. Как-то можно сделать, чтобы SwitchToThread с большей вероятностью делал что нужно? (т.е. активировал сохраняющий настройки процесс)

// Чтение
  LONG before, after;
  Settings local_settings;

  for(;;)
  {
      before = shared_data->version;
      memcpy(&local_settings, &shared_data->settings, sizeof(Settings));
      after = shared_data->version;
     if (before == after) break;
     for(;;)
     {
         if (shared_data->version == shared_data->version2) break;
         SwitchToThread();
     }
  }

// Запись
  Settings new_settings = {/*...*/};
 
  InterlockedIncrement(&shared_data->version);
  memcpy( &shared_data->settings, &new_settings , sizeof(Settings)); //в процессе произошла переключение к читателю


// Чтение
//сюда переключили
      before = shared_data->version;//читаем уже новую версию
      memcpy(&local_settings, &shared_data->settings, sizeof(Settings));//получаем полубитые данные
      after = shared_data->version; //читаем ту же версию (новую)
     if (before == after) break; //а причем тут version 2

настройки меняются крайне редко

struct DATA
{
    volatile long counter;
    ... данные
};

struct MMF
{
    volatile long flag;
    DATA data[2];
};

MMF* mmf = ...

void write()
{
    DATA* data = &mmf->data[1 - mmf->flag];
    long counter = data->counter;
    data->counter = ++ counter;
    #StoreStore
    ... // пишем
    #StoreStore
    data->counter = ++ counter;
    #StoreStore
    mmf->flag = 1 - mmf->flag;
}

void read()
{
    long flag;
    long counter;
    DATA* data;

    do
    {
        flag = mmf->flag;
        #LoadLaod
        data = &mmf->data[flag];
        counter = data->counter;
        .... // читаем
        #LoadLaod
    }
    while (flag == mmf->flag && counter == data->counter);   // сначала - flag, потом - counter
}

boost::shared_mutex syncObj;

// Читаем данные:
// читатели друг дружку не ждут,
// впадают в ожидание, если данные собираются быть захвачены
// или уже захвачены писателем
{
    boost::shared_lock<boost::shared_mutex> lockObj(syncObj);
    // TODO
}

// Пишем данные:
// писатель ждёт всех читателей, кто ещё не успел закончить работу
// (в это время блокируется захват примитива "новыми читателями"),
// после чего захватывает окончательно и начинает писать.
{
    boost::upgrade_lock<boost::shared_mutex> lockObj(syncObj);
    boost::upgrade_to_unique_lock<boost::shared_mutex> lockObj2(lockObj);
    // TODO
}

// flag = mmf->flag;
// counter = data->counter;
R1: load(flag), допустим, тут прочитали 0.
R2: load(counter[0])
..... читаем

// while (!(flag == ... && counter == ...));
R3: load(flag), допустим, тут тоже прочитали 0.
R4: load(counter[0]) - здесь ноль, прочитанный на шаге R1 !!!

flag содержит 0.
..............
W1: counter[1] ++
// пишем
W2: counter[1] ++
W3: store(flag) <- 1

W4: counter[0] ++
// пишем
W5: counter[0] ++
W6: store(flag) <- 0

template<class _T>
class TMultiReaderAndOneWriterLock {
protected:
    CCriticalSection m_Sync ;     // protect for multi writers
    volatile _T* m_ActiveObject ;    // pointer to active data, must be alligned to CPU word
public:
    void Write( _T* obj ) {        // writer put new data
        m_Sync.Enter() ;
        _T* old = m_ActiveObject ;
        obj->AddRef() ;
        m_ActiveObject = obj ;
        m_Sync.Leave() ;
        old->Release() ;
    }

    // read current data
    // NOTES: Reader MUST release data after use it
    //      Reader can use data as long as needed,
    //      but better practice is to release it asap
    inline _T* Read() {            
        _T* result = m_ActiveObject ;
        result->AddRef() ;
        return( result ) ;
    }
} ;

RB>    #LoadLaod
RB>>    }
RB>>    while (!(flag == mmf->flag && counter == data->counter));   // сначала - flag, потом - counter
RB>>}
RB>>

    do
    {
        flag = mmf->flag;
        #LoadLaod
        data = &mmf->data[flag];
        counter = data->counter;
        #LoadLaod
        .... // читаем
        #LoadLaod
    }
    while (counter == data->counter);

typedef struct seqcount {
    unsigned sequence;
} seqcount_t;

#define seqcount_init(x)    do { *(x) = (seqcount_t) SEQCNT_ZERO; } while (0)

/* Start of read using pointer to a sequence counter only.  */
static inline unsigned read_seqcount_begin(const seqcount_t *s)
{
    unsigned ret;

repeat:
    ret = s->sequence;
    smp_rmb();
    if (unlikely(ret & 1)) {
        cpu_relax();
        goto repeat;
    }
    return ret;
}

/*
 * Test if reader processed invalid data because sequence number has changed.
 */
static inline int read_seqcount_retry(const seqcount_t *s, unsigned start)
{
    smp_rmb();

    return s->sequence != start;
}

/*
 * Sequence counter only version assumes that callers are using their
 * own mutexing.
 */
static inline void write_seqcount_begin(seqcount_t *s)
{
    s->sequence++;
    smp_wmb();
}

static inline void write_seqcount_end(seqcount_t *s)
{
    smp_wmb();
    s->sequence++;
}

// Чтение
  LONG before, after;
  Settings local_settings;
ReadSettings:
  before = InterlockedAdd(&shared_data->version, 0);
  if (before % 2) {
    SwitchToThread();
    goto ReadSettings;
  }
  memcpy(&local_settings, &shared_data->settings, sizeof(Settings));
  after = InterlockedAdd(&shared_data->version, 0);
  if (before != after) {
    SwitchToThread();
    goto ReadSettings;
  }

// Чтение
...
  memcpy(&local_settings, &shared_data->settings, sizeof(Settings));
  after = InterlockedAdd(&shared_data->version, 0);
  if (before != after) {
    if (after % 2)
    {
      // главный начал и не окончил запись
      DWORD code = 0;
      VERIFY(GetExitCodeProcess(main_process_handle, &code));
      if (code != STILL_ACTIVE) {
        // главный умер, больше делать нечего
        memset(&local_settings, 0, sizeof(Settings)); 
        goto NothingMoreToDo; 
      }
      // попробуем дать главному дописать
      SwitchToThread();
    }
    goto ReadSettings;
  }

R>

AG>// Чтение
AG>  LONG before, after;
AG>  Settings local_settings;
AG>ReadSettings:
AG>  before = InterlockedAdd(&shared_data->version, 0);
AG>  if (before % 2) {
AG>    SwitchToThread();
AG>    goto ReadSettings;
AG>  }
AG>  memcpy(&local_settings, &shared_data->settings, sizeof(Settings));
AG>  after = InterlockedAdd(&shared_data->version, 0);
AG>  if (before != after) {
AG>    SwitchToThread();
AG>    goto ReadSettings;
AG>  }
AG>

// Чтение
  LONG before, after;
  Settings local_settings;
ReadSettings:
  before = shared_data->version;
  if (before % 2) {
    SwitchToThread();
    goto ReadSettings;
  }
  memcpy(&local_settings, &shared_data->settings, sizeof(Settings));
  _ReadWriteBarrier();
  after = shared_data->version;
  if (before != after) {
    if (after % 2)
      SwitchToThread();
    goto ReadSettings;
  }