thread safety and std::map

Hi,
I am trying to write a program which has two threads one of them write
to a map , and the other one deletes entries based on a certain
criterion..
first I cannot get the delete portion to work , what am i missing
here.
also is it possible/correct that the removeKeyValue function acquire
the mutex lock only during the call to map.erase(), and not the during
the whole iteration process as i have done here( i logically felt it
was safer to lock up the whole iteration ) but that can take up
massive amounts of time when the addKeyValue function would wait for
the lock to be released...

Thanks in advance
Digz

#include<map>
#include<iostream>
#include<boost/thread/thread.hpp>
#include<boost/thread/mutex.hpp>
#include<boost/bind.hpp>
#include<time.h>

boost::mutex _mutex;
typedef boost::mutex::scoped_lock Lock;
typedef std::map <int, time_t>::iterator mapIter;
std::map <int, time_t> timerMap;

void addKeyValue (std::map < int, time_t > &map) {
  int i = 0;
  time_t t;
  while (true) {
      {
        Lock guard (_mutex);
        map[++i] = time (&t);
        std::cout << "added: " << i << ", " << t << std::endl;
      } //end lock
      sleep (1);
    } //end while
}

void removeKeyValue (std::map < int, time_t > &map) {
  time_t t;
  while (true) {
      {
      Lock guard1 (_mutex);
      mapIter end = map.end ();
      for (mapIter beg = map.begin (); beg != end;) {
          if (time (&t) - (*beg).second > 3) {//anything older than 3
seconds needs attention
              std::cout << "removing: " << (*beg).first << ", " <<
(*beg).second << std::endl;
              map.erase (beg++);
            }
          else
            ++beg;
        } //end for
      } //end lock scope
    } //end while true
}

int main ()
{
  boost::thread t (boost::bind (addKeyValue, timerMap));
  boost::thread u (boost::bind (removeKeyValue, timerMap));
  t.join();
  u.join();
}

----------------