template < class _ListData, template < class > class _LockType >
class YourAppClass: public _LockType< YourAppClass >
{
public:
typedef _ListData listdata_type;
//...
// write list operation
void Add( const listdata_type &data )
{
Lock guard( *this );
_list.push_back( data );
}
// read list operation
bool First( listdata_type &data )
{
Lock guard( *this );
::std::list< listdata_type >::iterator it = _list.begin();
if ( _list.end() == it ) return false;
data = *it;
return true;
}
protected:
::std::list< listdata_type > _list;
};

我老早写的一个win32下的锁，看看对你是否有用，其它操作系统同理：
template < class T >
class SingleLock
{
public:
typedef T DataType;
public:
class Lock
{
Lock( const Lock& );
Lock& operator=( const Lock& );
public:
explicit Lock( SingleLock< DataType >& ) {}
~Lock() {}
};
public:
SingleLock() {}
~SingleLock() {}
};

#ifdef _WINDOWS_

template < class T >
class ObjectLevelLock
{
ObjectLevelLock( const ObjectLevelLock& );
ObjectLevelLock& operator=( const ObjectLevelLock& );

public:
typedef T DataType;
public:
ObjectLevelLock()
{
InitializeCriticalSection( &_cs );
}
~ObjectLevelLock()
{
DeleteCriticalSection( &_cs );
}
public:
class Lock
{
Lock( const Lock& );
Lock& operator=( const Lock& );
public:
explicit Lock( ObjectLevelLock< DataType >& host ):_host( host )
{
EnterCriticalSection( &_host._cs );
}
~Lock()
{
LeaveCriticalSection( &_host._cs );
}
private:
ObjectLevelLock& _host;
};
friend class Lock;

private:
CRITICAL_SECTION _cs;
};

template < class T >
class ClassLevelLock
{
public:
typedef T DataType;
public:
ClassLevelLock() {}
~ClassLevelLock() {}

public:
class Initializer;
class Lock
{
Lock( const Lock& );
Lock& operator=( const Lock& );
public:
explicit Lock( ClassLevelLock< DataType >& host ):_initializer( host._initializer )
{
EnterCriticalSection( &_initializer._cs );
}
~Lock()
{
LeaveCriticalSection( &_initializer._cs );
}
private:
Initializer& _initializer;
};
friend class Lock;
public:
class Initializer
{
friend class Lock;
Initializer( const Initializer& );
Initializer& operator=( const Initializer& );
public:
Initializer()
{
InitializeCriticalSection( &_cs );
}
~Initializer()
{
DeleteCriticalSection( &_cs );
}
private:
CRITICAL_SECTION _cs;
};

private:
static Initializer _initializer;
};

template< class T >
typename ClassLevelLock< T >::Initializer ClassLevelLock< T >::_initializer;