std::vector <int> C;

UINT Thread1()
{
    ...
    size_t = C.size();
    if (t == 0)
    {
         iterator it = C.begin();  // 1
                                  
         *t = 666;                // 2
    }
    ....
}

UINT Thread2()
{
   ....
   C.erase(C.begin(), C.end());
   ....
}

// Пул входных контейнеров
template < class StoredType >
class C_InputPool
{
public:
  typedef std::list< StoredType > TContainer;
  typedef std::vector< TContainer > TInputPool; 
private:
  TInputPool pool;
  typename TInputPool::iterator input;
  CRITICAL_SECTION InputProtector;
public:
  C_InputPool(size_t PoolSize = 2);
  ~C_InputPool(void);
public:
  void Insert(StoredType value);
  TContainer* Swap(void);
  size_t Size();
};

// Хеш-мап, синхронизированный по вставке, удалению и поиску
template < class StoredType >
class C_SyncHashSet
{
public:
  typedef C_InputPool<StoredType> TInputPool;
  typedef stdext::hash_set<StoredType> TBaseContainer;
private:
  TInputPool InputPool;
  TBaseContainer base;
public:
  C_SyncHashSet(void);
  ~C_SyncHashSet(void);
public:
  void Swap(void);
  void Insert(StoredType value);
  size_t Count(StoredType value);
  size_t Size(void);
  void Erase(StoredType value);
};


//- C_SyncHashSet ----------------------------------------------------------------------
template < typename StoredType >
C_SyncHashSet<StoredType>::C_SyncHashSet():base(),InputPool()
{
}

template < typename StoredType >
C_SyncHashSet<StoredType>::~C_SyncHashSet()
{
}

template<class StoredType>
void C_SyncHashSet<StoredType>::Swap(void)
{
  TInputPool::TContainer* swapped = InputPool.Swap();
  if( swapped->empty()) return;

  base.insert(swapped->begin(), swapped->end());
  swapped->clear();
}
 
template<class StoredType>
void C_SyncHashSet<StoredType>::Insert(StoredType value)
{
  InputPool.Insert(value);    
}

template < class StoredType >
size_t C_SyncHashSet<StoredType>::Count(StoredType value)
{
  Swap();
  return base.count(value);
}

template < class StoredType >
size_t C_SyncHashSet<StoredType>::Size(void)
{
  return base.size() + InputPool.Size();
}

template<class StoredType>
void C_SyncHashSet<StoredType>::Erase(StoredType value)
{
  Swap();
  base.erase(value);
}

//- C_InputPool ------------------------------------------------------------------------

template < typename StoredType >
C_InputPool<StoredType>::C_InputPool(size_t PoolSize) :pool(PoolSize)
{
  ASSERT( PoolSize > 1 );
  input = pool.begin();
  InitializeCriticalSection(&InputProtector);
}

template < typename StoredType >
C_InputPool<StoredType>::~C_InputPool(void)
{
  DeleteCriticalSection(&InputProtector);
}

template < class StoredType >
void C_InputPool<StoredType>::Insert(StoredType value)
{
  EnterCriticalSection(&InputProtector);
  input->push_back(value);
  LeaveCriticalSection(&InputProtector);
}

template < class StoredType >
typename C_InputPool<StoredType>::TContainer* C_InputPool<StoredType>::Swap(void)
{
  TContainer * ret = &(*input);
  EnterCriticalSection(&InputProtector);

  input++;
  if(input == pool.end() ) input = pool.begin();

  LeaveCriticalSection(&InputProtector);
  return ret;
}

template < class StoredType >
size_t C_InputPool<StoredType>::Size()
{
  size_t ret = 0;
  TInputPool::iterator it;
  for( it = pool.begin(); it != pool.end(); it++)
  {
    if(it == input) EnterCriticalSection(&InputProtector);
    ret += it->size();
    if(it == input) LeaveCriticalSection(&InputProtector);
  }
  return ret;
}

EnterCriticalSection(&InputProtector);
// bla bla bla 
LeaveCriticalSection(&InputProtector);

G>  typedef std::list< StoredType > TContainer;
G>  typedef std::vector< TContainer > TInputPool; 
G>

  typedef std::vector< StoredType > TContainer;
  typedef std::list< TContainer > TInputPool;

template<class Container>
struct thread_safe_container
{
     boost::mutex m;
     Container c;
};

R>в таком вот аспекте
R>C_InputPool& C_InputPool::ThreadInstance()
R>{
R>  static __declspec( thread ) C_InputPool instance;
R>    return instance;
R>}

R>или в таком
R>void SomeFoo()
R>{
R>   C_InputPool<....> pool;
R>     .....
R>}
R>но не в таком
R>C_InputPool<....> g_pool;