// 8:15 AM/09/28/2017

#pragma once

#include <iostream>       // std::cout

#include <thread>         // std::thread

#include <mutex>          // std::mutex

#include <chrono>

using namespace std;

volatile int counter();

volatile int counter2();

mutex mtx;//This mutex class is synchronization primitive that

//can be used to protect shared data from being simultaneously accessed by multiple threads.

// mutex类是一个同步原语，用来保护共享数据，阻止多线程同时访问

mutex mtx2;

void run()

{

    for (int i = ; i < ; ++i)

    {

        mtx.lock();// lock mtx,blocks if mtx is not available

        // the word block means that when the mtx is avaiable,it will lock mtx and the following code will being executed

        ++counter;

        cout << this_thread::get_id() << "==> " << counter << endl;

        mtx.unlock();// this function will make mtx is available,

        //and other threads that is being blocked will detect the mtx is available

        // but the others don't mean that all of them can detect the mtx is available because if one detect it and it will lock it.

        // only the one thread will own the mtx

        //here the function unlock is necessary
        //一般不直接使用mutex 而用 std::unique_lock, std::lock_guard等
        //mutex is usually not accessed directly

    }

}

void run2()

{

    for (int i = ; i < ; i++)

    {

        if (mtx2.try_lock())

            //It differs from the function lock.Here,it will not block and if mtx2 is available,it will be lock and return ture.

        {

            ++counter2;

            cout << this_thread::get_id() << "==> " << counter2 << endl;

            mtx2.unlock();

        }

    }

}

int main(int argc, const char* argv[])

{

    thread ts[];

    for (int i = ; i < ; ++i)

    {

        ts[i] = thread(run);

    }

    for (auto& t : ts) t.join();

    std::this_thread::sleep_for(std::chrono::seconds());

    // sleep for 2s

    thread ts2[];

    for (int i = ; i < ; ++i)

    {

        ts2[i] = thread(run2);

    }

    for (auto& t : ts2)t.join();

}

//We see that the results of counter and counter2 are not same,and we convincingly konw the counter is equal

//to 1000 because of the function lock.The counter2,however,may not have a unique result owing to the function

// try_lock without blocking.