多线程测试程序

多线程测试程序：

/*
-* syncthread.cpp: test for synchronizing multiple threads
-* Date: 2013-05-08
*/

#include <cassert>
#include <atomic>
#include <thread> // for std::thread, not supported in gcc-4.8.0

#include <boost/thread/thread.hpp>

std::atomic<bool> x, y;
std::atomic<int> z;
std::atomic_int glbCnt;

void write_x_then_y()
{
    x.store(true, std::memory_order_relaxed);
    y.store(true, std::memory_order_release);
}

void read_y_then_x()
{
    while(!y.load(std::memory_order_acquire))
    {
        /* waiting */
    }
    if(x.load(std::memory_order_relaxed))
        ++z;
}

int main_atomic(int argc, char **argv)
{
    x = false;
    y = false;
    z = 0;

    //std::thread a(write_x_then_y);
    boost::thread a(&write_x_then_y);
    //std::thread b(read_y_then_x);
    boost::thread b(&read_y_then_x);

    a.join();
    b.join();

    assert(z.load()!=0);
    return 0;
}

/////////////////////////////////////////////////

int glbCountPeterson = 0;

static bool flagA = 0;
static bool flagB = 0;

// must have "turn", otherwise the two threads
// might introduce deadlock at both DETECT lines of "while..."
static int glbSemaphore = 1;
//static std::atomic<int> glbSemaphore;

void PetersonA()
{
    flagA = true;
    glbSemaphore = 0;

    //DETECT:
    while (flagB && (glbSemaphore == 0))
    {
        /* waiting */
    }

    // enter critical section
    glbCountPeterson++;
    // leave critical section
    flagA = 0;
}

void PetersonB()
{
    flagB = true;
    glbSemaphore = 1;

    // DETECT
    while (flagA && (glbSemaphore != 0))
    {
        /* waiting */
    }

    // enter critical setion
    glbCountPeterson++;
    // leave critical section
    flagB = 0;
}

int ThreadFuncA( )
{
    int i;
    //cout << "Starting Thread 1" << endl;
    for (i = 0; i < 10000000; i++)
    {
        PetersonA();
    }
    return 0;
}

int ThreadFuncB( )
{
    int i;
    //cout << "Starting Thread 2" << endl;
    for (i = 0; i < 10000000; i++)
    {
        PetersonB();
    }
    return 0;
}

int main_peterson(int argc, char **argv)
{
    glbCountPeterson = 0;

    flagA = false;
    flagB = false;

    glbSemaphore = 1;

    boost::thread a(&ThreadFuncA);
    boost::thread b(&ThreadFuncB);

    a.join();
    b.join();

    std::cout << glbCountPeterson << std::endl;

    if (glbCountPeterson == 20000000)
        std::cout << "Success" << std::endl;
    else
        std::cout << "Fail" << std::endl;

    return 0;
}

//////////////////////////////////////////////////////

int numThreads = 3;
int glbCountDijk = 0;
//int attempFlag[3] = {0, 0, 0};
std::atomic_int attempFlag[3];
//int filterTurn[3] = {1, 1, 1};
std::atomic_int filterTurn[3];

int Dijk(int tid)
{
    int i = tid; // thread i (0 <= i < THREAD_NUM)
    int j, k;
    // attemp to enter critical section
    for (j = 1; j < numThreads; j++) // N-1 times iteration
    {
        attempFlag[i] = j;
        filterTurn[j] = i;
        for (k = 0; k < numThreads; k++)
        {
            if (k == i) continue;
            // different between "attempFlag[i] < attempFlag[k]" and "attempFlag[k] >= attempFlag[i]"?
            //while (attempFlag[i] < attempFlag[k] && filterTurn[j] == i)
            while (attempFlag[k] >= attempFlag[i] && filterTurn[j] == i)
            {
                /* waiting */
            }
        }
    }
    // critical section
    glbCountDijk++;
    // leave critical section
    attempFlag[i] = 0;

    return 0;
}

void DijkA()
{
    int i = 0; // thread i (0 <= i < n)
    int j, k;
    // attemp to enter critical section
    for (j = 1; j < numThreads; j++)
    {
        attempFlag[i] = j;
        filterTurn[j] = i;
        for (k = 0; k < numThreads; k++)
        {
            if (k == i) continue;
            while (attempFlag[k] >= attempFlag[i] && filterTurn[j] == i)
            {
                /* waiting */
            }
        }
    }
    // critical section
    glbCountDijk++;
    // leave critical section
    attempFlag[i] = 0;
}

void DijkB()
{
    int i = 1; // thread i (0 <= i < n)
    int j, k;
    // attemp to enter critical section
    for (j = 1; j < numThreads; j++)
    {
        attempFlag[i] = j;
        filterTurn[j] = i;
        for (k = 0; k < numThreads; k++)
        {
            if (k == i) continue;
            while (attempFlag[k] >= attempFlag[i] && filterTurn[j] == i)
            {
                /* waiting */
            }
        }
    }
    // critical section
    glbCountDijk++;
    // leave critical section
    attempFlag[i] = 0;
}

void DijkC()
{
    int i = 2; // thread i (0 <= i < n)
    int j, k;
    // attemp to enter critical section
    for (j = 1; j < numThreads; j++)
    {
        attempFlag[i] = j;
        filterTurn[j] = i;
        for (k = 0; k < numThreads; k++)
        {
            if (k == i) continue;
            while (attempFlag[k] >= attempFlag[i] && filterTurn[j] == i)
            {
                /* waiting */
            }
        }
    }
    // critical section
    glbCountDijk++;
    // leave critical section
    attempFlag[i] = 0;
}

int ThreadA(int cnt)
{
    int i;
    //cout << "Starting Thread 1" << endl;
    for (i = 0; i < cnt; i++)
    {
        //DijkA();
        Dijk(0); /* tid = 0 */
    }
    return 0;
}

int ThreadB(int cnt)
{
    int i;
    //cout << "Starting Thread 1" << endl;
    for (i = 0; i < cnt; i++)
    {
        //DijkB();
        Dijk(1); /* tid = 1 */
    }
    return 0;
}

int ThreadC(int cnt)
{
    int i;
    //cout << "Starting Thread 1" << endl;
    for (i = 0; i < cnt; i++)
    {
        //DijkC();
        Dijk(2); /* tid = 2 */
    }
    return 0;
}

int main_dijk(int argc, char **argv)
{
    int loop;

    numThreads = 3;
    glbCountDijk = 0;

    attempFlag[0] = 0;
    attempFlag[1] = 0;
    attempFlag[2] = 0;

    filterTurn[0] = 1;
    filterTurn[1] = 1;
    filterTurn[2] = 1;

    loop = 10000000;

    boost::thread a(&ThreadA, loop);
    boost::thread b(&ThreadB, loop);
    boost::thread c(&ThreadC, loop);

    a.join();
    b.join();
    c.join();

    std::cout << glbCountDijk << std::endl;

    if (glbCountDijk == loop * numThreads)
        std::cout << "Success" << std::endl;
    else
        std::cout << "Fail" << std::endl;

    return 0;
}

///////////////////////////////////////////////

int main(int argc, char **argv)
{
    std::atomic_flag flag = ATOMIC_FLAG_INIT;
    std::atomic_bool cond[3];

    flag.test_and_set();
    if (cond[0].is_lock_free())
        std::cout << "lock is free" << std::endl;

    main_atomic(argc, argv);
    main_peterson(argc, argv);
    main_dijk(argc, argv);

    return 0;
}