在看書時，瞭解到boost執行緒中的yield方法：可以將本執行緒的CPU時間片放棄，並允許其他執行緒執行。認為其是一個操作執行緒之利器，所以寫了個3個執行緒，迴圈列印ABC字串，以驗證其交出時間片功能。

程式碼如下：

#include <windows.h>
#include <iostream>
#include <boost/thread.hpp>
#include <boost/atomic.hpp>
#include <boost/ref.hpp>

using namespace std;
using namespace boost;

enum MARK
{
	A,
	B,
	C,
};

mutex io_mutex;
typedef boost::atomic<MARK> ENUM_MARK;

void print_abc(ENUM_MARK& mark, MARK CurID)
{
	for (int nIndex = 0; nIndex < 10;)
	{
		mutex::scoped_lock lock(io_mutex);
		switch (CurID)
		{
		case A:
			{
				if (mark == MARK::C)
				{
					cout << "A";
					mark = MARK::A;
					nIndex++;
				}
				break;
			}
		case B:
			{
				if (mark == MARK::A)
				{
					cout << "B";
					mark = MARK::B;
					nIndex++;
				}
				break;
			}
		case C:
			{
				if (mark == MARK::B)
				{
					cout << "C" << endl;
					mark = MARK::C;
					nIndex++;
				}
				break;
			}
		default:
			break;
		}

		// 加個yield，交出本執行緒時間片，讓其他執行緒執行。
		this_thread::yield();
	}
}

int main()
{
	ENUM_MARK mark	= MARK::C;
	int nRetry		= 0;

	// 建立3個執行緒，依次輸出ABC。
	// 連續迴圈3此，觀察執行時間。
	while (nRetry < 3)
	{
		DWORD nStart = ::GetTickCount();

		thread t1(print_abc, boost::ref(mark), MARK::A);
		thread t2(print_abc, boost::ref(mark), MARK::B);
		thread t3(print_abc, boost::ref(mark), MARK::C);

		// 等待t3執行緒結束，因為其輸出最後一個C。
		t3.join();

		DWORD nEnd		= ::GetTickCount();
		DWORD nTotal	= nEnd - nStart;

		cout << "Total times:" << nTotal << endl;
		nRetry++;
	}

	getchar();
	return 0;
}
 

執行後，3個執行緒列印10次ABC所耗的時間大約是30ms。發現30ms有點長，是不是yield引起的？

當我把this_thread::yield();註釋掉後，再次執行，發現執行緒執行速度加快，平均10ms不到。

比較奇怪，檢視yield的實現程式碼，才發現其實它就執行了Sleep(0)，Sleep(0)的確會放棄CPU時間片，允許其他執行緒執行。但其它執行緒，也包含了放棄CPU時間片的執行緒，這樣就可能造成單個執行緒無限次的放棄CPU時間片，又再一次獲得執行許可權。

this_thread::yield()的程式碼定義如下：

void yield() BOOST_NOEXCEPT
        {
            detail::win32::Sleep(0);
        }
 

為了更好的驗證一下自己的推論，我直接使用了Win32 API的執行緒程式碼：

#include <windows.h>
#include <iostream>
#include <string>

using namespace std;

CRITICAL_SECTION CK;

enum MARK
{
	A,
	B,
	C,
};

struct MyStruct
{
	volatile MARK* mark;
	MARK CurID;
};

DWORD WINAPI Win32_Thread(LPVOID pStruct)
{
	MyStruct* myStruct = (MyStruct*)(pStruct);

	for (int nIndex = 0; nIndex < 10;)
	{
		EnterCriticalSection(&CK);

		switch (myStruct->CurID)
		{
		case A:
			{
				if (*myStruct->mark == MARK::C)
				{
					cout << "A";
					*myStruct->mark = MARK::A;
					nIndex++;
				}
				break;
			}
		case B:
			{
				if (*myStruct->mark == MARK::A)
				{
					cout << "B";
					*myStruct->mark = MARK::B;
					nIndex++;
				}
				break;
			}
		case C:
			{
				if (*myStruct->mark == MARK::B)
				{
					cout << "C" << endl;
					*myStruct->mark = MARK::C;
					nIndex++;
				}
				break;
			}
		default:
			break;
		}

		LeaveCriticalSection(&CK);
	}
	return 0;
}

int main()
{
	::InitializeCriticalSection(&CK);

	MyStruct myStruct;
	myStruct.CurID	= A;
	myStruct.mark	= new MARK;
	*myStruct.mark	= C;

	DWORD dwID1, dwID2, dwID3;
	HANDLE hThreadA = ::CreateThread(NULL, 0, &Win32_Thread, &myStruct, 0, &dwID1);

	MyStruct myStruct2;
	myStruct2.CurID	= B;
	myStruct2.mark	= myStruct.mark;
	HANDLE hThreadB = ::CreateThread(NULL, 0, &Win32_Thread, &myStruct2, 0, &dwID2);

	MyStruct myStruct3;
	myStruct3.CurID	= C;
	myStruct3.mark	= myStruct.mark;
	HANDLE hThreadC = ::CreateThread(NULL, 0, &Win32_Thread, &myStruct3, 0, &dwID3);

	getchar();
	DeleteCriticalSection(&CK);

	return 0;
}
 

像上面這樣，沒有用Sleep(0)，3個執行緒都快速的輸出了ABC。但如果我加了個Sleep(1)線上程的LeaveCriticalSection(&CK);前面，就發生了惡性競爭，基本上是每隔幾秒鐘，才輸出ABC中的一個字母。

以下是出現惡性競爭的程式碼：

#include <windows.h>
#include <iostream>
#include <string>

using namespace std;

CRITICAL_SECTION CK;

enum MARK
{
	A,
	B,
	C,
};

struct MyStruct
{
	volatile MARK* mark;
	MARK CurID;
};

DWORD WINAPI Win32_Thread(LPVOID pStruct)
{
	MyStruct* myStruct = (MyStruct*)(pStruct);

	for (int nIndex = 0; nIndex < 10;)
	{
		EnterCriticalSection(&CK);

		switch (myStruct->CurID)
		{
		case A:
			{
				if (*myStruct->mark == MARK::C)
				{
					cout << "A";
					*myStruct->mark = MARK::A;
					nIndex++;
				}
				break;
			}
		case B:
			{
				if (*myStruct->mark == MARK::A)
				{
					cout << "B";
					*myStruct->mark = MARK::B;
					nIndex++;
				}
				break;
			}
		case C:
			{
				if (*myStruct->mark == MARK::B)
				{
					cout << "C" << endl;
					*myStruct->mark = MARK::C;
					nIndex++;
				}
				break;
			}
		default:
			break;
		}
		// 這裡加了Sleep，引起惡性競爭。
		::Sleep(1);
		LeaveCriticalSection(&CK);
	}
	return 0;
}

int main()
{
	::InitializeCriticalSection(&CK);

	MyStruct myStruct;
	myStruct.CurID	= A;
	myStruct.mark	= new MARK;
	*myStruct.mark	= C;

	DWORD dwID1, dwID2, dwID3;
	HANDLE hThreadA = ::CreateThread(NULL, 0, &Win32_Thread, &myStruct, 0, &dwID1);

	MyStruct myStruct2;
	myStruct2.CurID	= B;
	myStruct2.mark	= myStruct.mark;
	HANDLE hThreadB = ::CreateThread(NULL, 0, &Win32_Thread, &myStruct2, 0, &dwID2);

	MyStruct myStruct3;
	myStruct3.CurID	= C;
	myStruct3.mark	= myStruct.mark;
	HANDLE hThreadC = ::CreateThread(NULL, 0, &Win32_Thread, &myStruct3, 0, &dwID3);

	getchar();
	DeleteCriticalSection(&CK);

	return 0;
}

從而我們得出以下結論：

1. yield方法其實就是::Sleep(0)。

2. Sleep會交出CPU時間片，允許其他執行緒執行，但“其他執行緒”也包含了交出CPU時間片的那個執行緒。

3. 想要更好的進行執行緒切換，不能夠使用Sleep，而應採用執行緒鎖或其他執行緒切換方法。