Do I need to synchronize?

Just wondering about this, if I want to do something like this in a thread, do I have to synchronize them?

Code:

---

(example 1)
//global vector
std::vector<Object> objects;

//main code
objects.back().doSomething();

//thread code
objects.pop_back();

(example 2)
//global vector
std::vector<Object> objects;

//main code
objects[0].move();

//thread code
objects[0].draw();

---

In example 1, is it possible for the object to get deleted before doSomething() completes?
And in example 2, is it possible that something will go screwy with the stack pointer or something (I don't really know what I'm talking about, and my books don't help) or is Windows smart enough to be sure everything happens properly?

In both examples, will I need to use a critical section or something related to ensure exclusive access to the vector? :confused:

Yes, you have to syncronize them. Yes, you can use a critical section. If there is only one shared resource you can use a simple lock:

Code:

---

struct sentry {
sentry(bool & key);
~sentry();
void lock();
void unlock();
bool & _locked;
bool mine;
};
sentry(bool & key, bool now = false)
 :_locked(key)
{
 mine = false;
 if(now)
  lock();
}
~sentry()
{
 unlock();
}
void lock()
{
  if(!mine)
  {
    while(_locked)
    continue;
    mine = _locked = true;
  }
}
void unlock()
{
  if(mine)
 {
  mine = _locked = false;
 }
}





//global vector
std::vector<Object> objects;
bool key = false;

//main code
sentry gate(key);
gate.lock();
objects.back().doSomething();
gate.unlock();


//thread code
sentry gate(key, true);
objects.pop_back();
gate.unlock();

---

So I need to synchronize them in example 2 too, right?

Of course you do. Any data structure that will be accessed from different threads must *always* be controlled by syncronization objects. Consider a simple array of chars. If one thread is copying the array while the other is reading it - what do you think will happen? Corruption. Pure and simple.

>>>
Any data structure that will be accessed from different threads must *always* be controlled by syncronization objects.
<<<

Not necessarily. If all threads are only reading common data, no synch is necessary at all.

If a collection of threads at start increment a shared thread counter, then decrement it as they exit, again, there is no synch needed.

The are other examples. Generally you will want to synch shared data, however, synching when it is not necessary simply hacks at the programs performance.