如何实现Java中的synchronized？

[lydmc]

初看synchronized觉得像Windows的临界区。
但当它内部有Wait语句时：
进入synchronized的范围时，则获取了this在这个线程的锁定。
而再进入了Wait状态时，会释放this在这个线程的锁定。

这个就不同于Windows的临界区了，临界区是不会被自动退出的。

请各位指教。

[珍惜生命远离CPP]

应该是这样的效果吧
仿照ATL中的东西
class MultiThreadLock
{
CRITICAL_SECTION m_lock;
protected:
typedef AutoLockT<MultiThreadLock> AutoLock;
public:
inline MultiThreadLock()
{
InitializeCriticalSection(&m_lock);
}
inline ~MultiThreadLock()
{
DeleteCriticalSection(&m_lock);
}
inline void Lock()
{
EnterCriticalSection(&m_lock);
}
inline void UnLock()
{
LeaveCriticalSection(&m_lock);
}
};
template<class T>
struct AutoLockT
{
inline AutoLockT(T* p):m_p(p)
{
m_p->Lock();
}
inline ~AutoLockT()
{
m_p->UnLock();
}
private:
T* m_p;
};


class test:public MultiThreadLock
{
typedef AutoLockT<test> AutoLock;
public:
void Do()
{
//do some ..
{
AutoLock lock(this);
//do some ..
}
//do some ..
}
};

[healer_kx]

很简单，
就是临界区。

但是出于Java的描述，它应该是一个对象聚合一个临界区。


class MyClass {


private:
CRITICAL_SECTION m_cs;

};

然后在你想要实现synchronized的方法里使用临界区就可以了。


我认为楼上的代码，把public继承改成protected继承，就是完美的实现方式了。

[healer_kx]

信我，没错的，有本书讲C＃的线程安全，就是用这样的代码作为讲解的。

[lydmc]

可能我没有说清楚：
[java]
class A｛
public synchronized foo(){
...
wait(); // 这里如果进入等待，则释放this在这个线程的锁定
...
}
｝

[c++]
...
EnterCriticalSection(&m_lock);
...
WaitforSingleObject(...); // 这里如果进入等待，并不会释放m_lock在这个线程的锁定
...
LeaveCriticalSection(&m_lock);
...

c++怎样实现类似java中“进入等待，同时退出临界区”的效果？

[healer_kx]

信号灯，临界区就是信号灯实现的，好像。
希望能启发你一下了。