C++ 11 многопоточность

std::atomic<int> prog{0};
 
int some_work() {
   while (prog != 100) {
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
      ++prog;
   }
   return 42;
}
 
int main()
{
   auto res = std::async(std::launch::async, some_work);
   while (prog != 100) {
      std::cout << "Progress: " << prog << "\n";
      system("cls");
   }
   std::cout << "Done. Res = " << res.get();
 
   return 0;
}

#include <iostream>
#include <string>
#include <thread>
#include <future>
#include <chrono>
#include <atomic>
 
using namespace std;
 
int main() {
    atomic<int> processed(0);
    int process = 0;
    atomic<bool> finished(false);
    // пока не приписал launch::async оно не пахало) g++4.9.1 отложенные вычисления все дела... 
    auto result = async(launch::async,[&processed, &finished]() -> string{
        int step = 0;
        while(step < 100) {
            this_thread::sleep_for(chrono::milliseconds(500));
            step+=10;
            processed.store(step);
        }
        finished.store(true);
        return "hello";
    });
    while(!finished.load()) {
        int tmp = processed.load();
        if(process != tmp) {
            cout << '*';
            process = tmp;
        }
        this_thread::sleep_for(chrono::milliseconds(10));
    }
    cout << result.get() << endl;
    return 0;
}

#include "Win32Project4Buttons.h"
#include <math.h>
#include <time.h>
#include <string>
#include "windows.h"
#include <Windows.h>
#include <sstream>
#include <thread> //Файл в котором определен класс thread 
#include <future>
#include <condition_variable>
#include <queue>
#include <fstream>
using namespace std;
double calculate();
double calculate2();
static const long unsigned int NUM_POINTS = 1000;
static const double RADIUS = 0.5;
static const double CENTER_X = 0.5;
static const double CENTER_Y = 0.5;
double tempPi = -1.0;
int count = 0;
mutex mq, m;
bool isSee = false;
condition_variable cv;
std::queue<double> q;
 
std::atomic<int> prog1{ 0 };
std::atomic<int> prog2{ 0 };
 
std::atomic<double> tempRes1{ 0 };
std::atomic<double> tempRes2{ 0 };
 
#define MAX_LOADSTRING 100
 
// Global Variables:
HINSTANCE hInst;                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
 
// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
 
HWND hWnd;
std::string strTmp;
//ifstream file;
typedef double(*calcul)(void);
void func2promise(calcul f, std::promise<double> &p)
{
    p.set_value(f());
}
std::future<double> res1;
std::future<double> res2;
int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPTSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    //file.open("test.txt", std::ios_base::)
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
    // TODO: Place code here.
    MSG msg;
    HACCEL hAccelTable;/*
    */thread th(calculate);
    // Initialize global strings
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_WIN32PROJECT4BUTTONS, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WIN32PROJECT4BUTTONS));
    CreateWindowEx(NULL,
        "button",
        "Push Me",
        WS_CHILD| WS_VISIBLE | BS_DEFPUSHBUTTON,
        10, 10, 100, 24,
        hWnd,
        (HMENU)100,
        hInst,
        NULL);
 
    // std::promise<double> p1, p2;
    //std::future<double> f1 = p1.get_future(), f2 = p2.get_future();
    //std::thread t1(&func2promise, calculate, std::ref(p1)),
    //  t2(&func2promise, calculate, std::ref(p2));
    //
    //double pi;
    // Main message loop:
    res1 = std::async(std::launch::async, calculate);
    res2 = std::async(std::launch::async, calculate2);
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    
    //t1.join(); t2.join();
    //std::stringstream strm;
    //strm << pi;
    ////
    //strm >> strTmp;
    return (int) msg.wParam;
}
 
 
 
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WIN32PROJECT4BUTTONS));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_WIN32PROJECT4BUTTONS);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
 
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
  
 
   hInst = hInstance; // Store instance handle in our global variable
 
   hWnd = CreateWindow(szWindowClass, "Windows Thread C++11", WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
   return TRUE;
}
 
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc;
    switch (message)
    {
    case WM_COMMAND:
    {
                       hdc = GetDC(hWnd);
                       if (LOWORD(wParam) == 100)
                       {
                           if (HIWORD(wParam) == BN_CLICKED)
                           {
                               SetTextColor(hdc, RGB(0, 255, 0));
                               SetBkColor(hdc, RGB(0, 0, 0));
                               SetBkMode(hdc, OPAQUE);
                               stringstream sts;
 
                               stringstream sts1;
                               double tmp = prog1 / (double)(NUM_POINTS / 2) * 100;
                               sts << "First Thread is progress " << tmp << " %." << endl;
 
                               double tmp2 = prog2 / (double)(NUM_POINTS / 2) * 100;
                               sts1 << "Second Thread is progress " << tmp2 << " %." << endl;
 
                               TextOut(hdc, 20, 60, sts.str().c_str(), strlen(sts.str().c_str()));
 
                               TextOut(hdc, 20, 100, sts1.str().c_str(), strlen(sts1.str().c_str()));
                               if (tempRes1 != 0.0)
                               {
                                   stringstream sts3;
                                  
                                   double tmpResFromFirstThread = tempRes1;
                                   sts3 << "We send temp result from first thread is =  " << tmpResFromFirstThread << "  !!!" << endl;
                                   TextOut(hdc, 20, 130, sts3.str().c_str(), strlen(sts3.str().c_str()));
                               }
                               if (tempRes1 != 0.0)
                               {
                                   stringstream sts2;
 
                                   double tmpResFromFirstThread1 = tempRes2;
                                   sts2 << "We send temp result from Second thread is =  " << tmpResFromFirstThread1 << "  !!!" << endl;
                                   TextOut(hdc, 20, 150, sts2.str().c_str(), strlen(sts2.str().c_str()));
                               }
                               if ((prog1 >= prog2) && (prog2 >= NUM_POINTS / 2))
                               {
                                   stringstream sts5;
 
                                   double Pi = (res1.get() + res2.get() )/ 2;
                                   sts5 << "Pi Is Found  =  " << Pi << "  !!!" << endl;
                                   TextOut(hdc, 20, 180, sts5.str().c_str(), strlen(sts5.str().c_str()));
                               }
                           }
                           }
                       ReleaseDC(hWnd, hdc);
                      
    }break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
     
        EndPaint(hWnd, &ps);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
 
 
 
 
 
bool inCircle(float x1, float y1) //функция проверки находится ли точка в круге
{
    //если расстояние от точки до центра окружности (см. Т.Пифагора) меньше радиуса окружности, 
    //то точка в круге, возврат результата TRUE, иначе FALSED:\учёба\университет\5Семестр\ПП\лаба2\monteCarlo\monteCarlo\monteCarlo.cpp
    return sqrt((CENTER_X - x1)*(CENTER_X - x1) + (CENTER_Y - y1)*(CENTER_Y - y1)) <= RADIUS;
}
double calculate()
{
    int mumInCircle = 0;
    srand(time(NULL));
    while (prog1 < (NUM_POINTS / 2)) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        ++prog1;
        double x = (double)rand() / (double)RAND_MAX;
        double y = (double)rand() / (double)RAND_MAX;
        if (inCircle(x, y))
        {
            ++mumInCircle;
        }
        if (prog1 == (NUM_POINTS / 20))
        {
            tempRes2 = 4.0 * mumInCircle / prog1;
        }
    }
    double PI = 4.0 * mumInCircle / (NUM_POINTS / 2);
    return PI;
}
 
double calculate2()
{
    int mumInCircle = 0;
    srand(time(NULL));
    while (prog2 < ( NUM_POINTS / 2)) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        ++prog2;
        double x = (double)rand() / (double)RAND_MAX;
        double y = (double)rand() / (double)RAND_MAX;
        if (inCircle(x, y))
        {
            ++mumInCircle;
        }
        if (prog2 == (NUM_POINTS / 10))
        {
            tempRes1 = 4.0 * mumInCircle / prog1;
        }
    }
    double PI = 4.0 * mumInCircle / (NUM_POINTS / 2);
    return PI;
}