Обикновено C++ Threading

C++11, наличен с по-нови компилатори като Visual Studio 2013, има нишки като част от езика заедно с доста други хубави части и парчета като ламбда.

Включващият файл threads предоставя класа на нишката, който е набор от шаблони. Функционалността на нишката е в пространството от имена std::. Някои функции за синхронизиране на нишки използват std::this_thread като пространство от имена (вижте Защо std::this_thread пространство от имена? за малко обяснение).

Следният пример за конзолно приложение, използващо Visual Studio 2013, демонстрира част от функционалността на нишката на C++11, включително използването на ламбда (вижте Какво е ламбда израз в C++11?). Забележете, че функциите, използвани за заспиване на нишка, като std::this_thread::sleep_for(), използват продължителност от std::chrono.

// threading.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>

int funThread(const char *pName, const int nTimes, std::mutex *myMutex)
{
    // loop the specified number of times each time waiting a second.
    // we are using this mutex, which is shared by the threads to
    // synchronize and allow only one thread at a time to to output.
    for (int i = 0; i < nTimes; i++) {
        myMutex->lock();
        std::cout << "thread " << pName << " i = " << i << std::endl;
        // delay this thread that is running for a second.  
        // the this_thread construct allows us access to several different
        // functions such as sleep_for() and yield().  we do the sleep
        // before doing the unlock() to demo how the lock/unlock works.
        std::this_thread::sleep_for(std::chrono::seconds(1));
        myMutex->unlock();
        std::this_thread::yield();
    }

    return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
    // create a mutex which we are going to use to synchronize output
    // between the two threads.
    std::mutex  myMutex;

    // create and start two threads each with a different name and a
    // different number of iterations. we provide the mutex we are using
    // to synchronize the two threads.
    std::thread myThread1(funThread, "one", 5, &myMutex);
    std::thread myThread2(funThread, "two", 15, &myMutex);

    // wait for our two threads to finish.
    myThread1.join();
    myThread2.join();

    auto  fun = [](int x) {for (int i = 0; i < x; i++) { std::cout << "lambda thread " << i << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); } };

    // create a thread from the lambda above requesting three iterations.
    std::thread  xThread(fun, 3);
    xThread.join();
    return 0;
}

CreateThread (Win32) и AfxBeginThread (MFC) са два начина да го направите.

Така или иначе вашият подпис MyMethod ще трябва да се промени малко.

Редактиране: както е отбелязано в коментарите и от други респонденти, CreateThread може да е лошо.

_beginthread и _beginthreadex са функциите на C библиотеката по време на изпълнение и според документи са еквивалентни на System::Threading::Thread: :Старт

Помислете за използване на пула от нишки на Win32, вместо да създавате нови нишки за работни елементи. Разпръскването на нови нишки е разточително - всяка нишка получава 1 MB запазено адресно пространство за своя стек по подразбиране, изпълнява кода за стартиране на системната нишка, кара известията да се доставят до почти всяка DLL във вашия процес и създава друг обект на ядрото. Пуловете от теми ви позволяват да използвате повторно нишки за фонови задачи бързо и ефективно и ще нарастват или намаляват в зависимост от това колко задачи изпращате. Като цяло, помислете за завъртане на специални нишки за безкрайни фонови задачи и използвайте пула от нишки за всичко останало.

Преди Vista можете да използвате QueueUserWorkItem. Във Vista, новите API за набор от нишки са по-надеждни и предлагат няколко по-разширени опции. Всеки от тях ще накара вашия фонов код да започне да се изпълнява в някоя нишка от пул от нишки.

// Vista
VOID CALLBACK MyWorkerFunction(PTP_CALLBACK_INSTANCE instance, PVOID context);

// Returns true on success.
TrySubmitThreadpoolCallback(MyWorkerFunction, context, NULL);

// Pre-Vista
DWORD WINAPI MyWorkerFunction(PVOID context);

// Returns true on success
QueueUserWorkItem(MyWorkerFunction, context, WT_EXECUTEDEFAULT);

Простата нишка в C++ е противоречие!

Разгледайте нишките за усилване за най-близкото нещо до прост подход, наличен днес.

За минимален отговор (който всъщност няма да ви предостави всички неща, от които се нуждаете за синхронизация, но отговаря буквално на въпроса ви) вижте:

http://msdn.microsoft.com/en-us/library/kdzttdcb(VS.80).aspx

Също така static означава нещо различно в C++.

Това безопасно ли е:

unsigned __stdcall myThread(void *ArgList) {
//Do stuff here
}

_beginthread(myThread, 0, &data);

Трябва ли да направя нещо, за да освободя паметта (като CloseHandle) след това повикване?

Друга алтернатива е pthreads - те работят както на windows, така и на linux!

CreateThread (Win32) и AfxBeginThread (MFC) са два начина да го направите.

Все пак внимавайте да използвате _beginthread, ако трябва да използвате библиотеката за изпълнение на C (CRT).

Само за win32 и без допълнителни библиотеки можете да използвате функцията CreateThread http://msdn.microsoft.com/en-us/library/ms682453(VS.85).aspx

Ако наистина не искате да използвате библиотеки на трети страни (бих препоръчал boost::thread, както е обяснено в другите отговори), трябва да използвате Win32API:

static void MyMethod(int data)
{

    int data = 3;

    HANDLE hThread = ::CreateThread(NULL,
        0,
        &RunStuff,
        reinterpret_cast<LPVOID>(data),
        0,
        NULL);


    // you can do whatever you want here

    ::WaitForSingleObject(hThread, INFINITE);
    ::CloseHandle(hThread);
}

static DWORD WINAPI RunStuff(LPVOID param)
{  

     int data = reinterpret_cast<int>(param);

     //long running operation here

     return 0;
}