std::map multithreaded access, lock needed?

With the recent acceptance of multithreading questions, I assume this
question is on topic. If not, let me know.

I have a singleton is going to be accessed by any threads. My singleton
class contains a static std::map that will be read and written to. I am
wondering if I need to lock it when being read from and written to? The sgi
docs lead me to beleive I do... See LoggerWindow::OpenLog below.

// in the .h

#include "LogWindow.h"

#include <map>

[snip]

class LoggerWindow
{
public:

/**
* Constructor
*/
LoggerWindow();

/**
* Destructor
*/
~LoggerWindow();

/**
* Creates child windows for one log
*/
void OpenLog(std::string title);

private:

[snip]

static HANDLE m_frameCreated; // Event that is signalled when the frame
window has been created

/** Pointers to the LogWindow instances that are the MDI children */
typedef std::map<std::string, LogWindow *> LogWindows;
static LogWindows m_logWindows;

[snip]
};

// in the .cpp

#include "LoggerWindow.h"

[snip]

//----------------------------------------------------------------------------------------------------------------------
// Initialize static members of the LoggerWindow class

[snip]

HANDLE LoggerWindow::m_frameCreated = CreateEvent(NULL, TRUE, FALSE, NULL);
LoggerWindow::LogWindows LoggerWindow::m_logWindows;

[snip]

[snip]

//----------------------------------------------------------------------------------------------------------------------
void LoggerWindow::OpenLog(std::string title)
{
   // This operation cannot execute until the frame window is fully created
   WaitForSingleObject(m_frameCreated, INFINITE);

   // Is a lock needed here????

   // Check if the LogWindow already exists
   LogWindows::iterator it = m_logWindows.find(title);
   if( it == m_logWindows.end() )
   {
      // Create a Log Window which is an MDI child of this window
      LogWindow * logWindow = new LogWindow(m_hwndClient, title);
      m_logWindows[title] = logWindow;
   }

   // Is an unlock needed here????
}

[snip]