mark一下以后看

CSDN的代码显示太不厚道了...
真是懒得去编辑

你这个应该是可以实现自旋互斥的，你使用的不对吧？

class MutexExImp
{
public:
MutexExImp(MutexEx& mutex) : mMutex(mutex)       
                  {mMutex.enterLoop();}
                  ~MutexExImp(void){mMutex.leaveLoop();}
protected:
MutexEx& mMutex;
};

你这个在构造函数中锁 在析构中解锁. 没法用啊

这和 ACE_Guard 一样了

用的时候，比如：
MutexEx mutex;
void f()
{
   MutexExImp mutexImp(mutex);
   std:: cout << "ok" << std::ednl;
}
在定义的时候就加锁，在其生命周期结束的时候解锁。

啊

那貌似就没问题啊

刚写了个程序测试你这个，应该是没问题的，可以实现互斥，还是使用方法的问题吧？

恩，但是还是有问题，唉。。。

建议检查一下使用方的代码~

恩，我也是在查是不是我用的有问题。

刚用vc8写了一个简略的测试程序
-----------------------------------------------------
MutexEx g_mutex;

unsigned int WINAPI TestThread( void * pParam )
{
MutexExImp mutex( g_mutex );
int threadID = *(static_cast<int *>( pParam ));
for (int i = 0; i < 10; i++ )
{
CString str;
str.Format( L"Thread ID :%d\r\n", threadID ); 
OutputDebugString( str );
Sleep( 200 );
}
return 0;
}

void CTestSpinMutexDlg::OnBnClickedOk()
{
unsigned int threadID = 0;
static int id1 = 1;
CloseHandle( (HANDLE)_beginthreadex( NULL, 0, TestThread, &id1, 0, &threadID ) );
static int id2 = 2;
CloseHandle( (HANDLE)_beginthreadex( NULL, 0, TestThread, &id2, 0, &threadID ) );
}
-----------------------------------------------------

运行结果如下：
-----------------------------------------------------
Thread ID :1
Thread ID :1
Thread ID :1
Thread ID :1
Thread ID :1
Thread ID :1
Thread ID :1
Thread ID :1
Thread ID :1
Thread ID :1
Thread ID :2
线程 'Win32 线程' (0xa90) 已退出，返回值为 0 (0x0)。
Thread ID :2
Thread ID :2
Thread ID :2
Thread ID :2
Thread ID :2
Thread ID :2
Thread ID :2
Thread ID :2
Thread ID :2
线程 'Win32 线程' (0xec4) 已退出，返回值为 0 (0x0)。
-----------------------------------------------------

我检查了下，还是有问题，锁不住，用boost::mutex就不会有问题，晕晕。。。

把你调用的代码贴出来看看吧
顺便说一句，我测试的时候由于没有编译boost库，所以把boost::thread::yield()换成Sleep(0)的。

现贴一个很匪夷所思的代码：
void count(int id)
{
        for (int i = 0; i < 10; ++i)
        {
       MutexExImp m(mutex);
                //boost::mutex::scoped_lock
                //lock(io_mutex);
                std::cout << id << ": " <<
                i << std::endl;
        }
}

void main()
{
        boost::thread thrd1(
        boost::bind(&count, 1));
        boost::thread thrd2(
        boost::bind(&count, 2));
        thrd1.join();
        thrd2.join();
}
如果用我写的循环锁－输出：
1: 0
1: 1
1: 2
1: 3
1: 4
1: 5
1: 6
1: 7
2: 0
2: 1
2: 2
2: 3
2: 4
2: 5
2: 6
2: 7
2: 8
2: 9
1: 8
1: 9
如果用oost::mutex::scoped_lock lock(io_mutex)则输出：
1: 0
2: 0
1: 1
2: 1
1: 2
2: 2
1: 3
2: 3
1: 4
2: 4
1: 5
2: 5
1: 6
2: 6
1: 7
2: 7
1: 8
2: 8
1: 9
2: 9
输出应是按照boost的互斥，但是为什么用我的循环锁输出会是如此？

void count(int id)
{
        for (int i = 0; i < 10; ++i)
        {  {
       MutexExImp m(mutex);
                //boost::mutex::scoped_lock
                //lock(io_mutex);
                std::cout << id << ": " <<
                i << std::endl;

            }
                Sleep(0);
        }
}

mark