Архитектура многопоточного приложения

TCriticalSection *p_cs = new TCriticalSection;
 
unsigned int myThread::get_count(){
    unsigned int zn;
    p_cs->Acquire(); // lock out other threads
    zn = this->count;
    p_cs->Release();
    return zn;
} 
 
void __fastcall myThread::Execute(){
    for(unsigned int i=0;i<max;i++)
        this->count++;      
}

myThread * mth = new myThread(true);
 
unsigned int = mth->get_count();

void __fastcall myThread::Execute()
{
   for(unsigned int i=0;i<max;i++)
  {
       p_cs->Acquire(); // вот эти две строчки
       this->count++;
       p_cs->Release();  // нужно добавить
  }
}

volatile unsigned int count;

TCriticalSection *p_cs = new TCriticalSection;
class dataThread{
  unsigned int data ;
 
  public:
    unsigned int get_count(){
        unsigned int zn;
        p_cs->Acquire();
            zn = this->data;
        p_cs->Release();
        return zn;
    }
 
    void set_count(const unsigned int & zn){
        p_cs->Acquire();
            this->data = zn;
        p_cs->Release();
    }
};

class CriticalSection
{
public:
  CriticalSection()  { InitializeCriticalSection(&cs_); };
  ~CriticalSection() { DeleteCriticalSection(&cs_); };
  void enter()       { EnterCriticalSection(&cs_);}
  bool tryEnter()    { return  TryEnterCriticalSection(&cs_); }
  void leave()       { LeaveCriticalSection(&cs_);  };
 
private:
  CRITICAL_SECTION cs_;
};
 
 
class CSLocker
{
public:
  CSLocker(CriticalSection* lock):lock_(lock)  { lock_->enter(); };
  ~CSLocker() { lock_->leave();}
private:
  CriticalSection* lock_;
};
 
template<typename T>
class Data
{
  T value()const
  {  
     CSLocker locker(&lock_);
     return value_;
  }
  
  void setValue(T value)
  {
    CSLocker locker(&lock_);
    value_= value;   
  } 
  
  private:
    mutable CriticalSection lock_;
    T value_;
};

сlass Data
{
   public:
      long value()const { return value_; }
      void increment(){  InterlockedIncrement(&value_);  }
     
   private:
      volatile long value_; /*  но тут есть сомнения в необходимости volatile */
};