En el artículo C ++ 11 Thread Library (1) Constructor y sus miembros, sabemos que tenemos los siguientes métodos de construcción:
thread() noexcept;//since c++11
thread(thread&& other) noexcept;//since c++11
template<class Function,class ...Args>
explicit thread(Function &&f,Args && ...args);//since c++11
thread(const thread&)=delete;//since c++11
Hay cuatro en total, el primero es la construcción predeterminada, que construye un objeto de hilo que no hace nada; el segundo es el constructor de movimiento que llamará std :: move (); el tercero es una plantilla de clase, lo que significa el uso de un objeto de función Genera la clase de subproceso correspondiente con varios parámetros; el cuarto es el constructor de copia, que no se puede copiar por defecto.
El tercero es el método básico para crear un objeto hilo, necesita
- Un objeto de función
- Cero o más parámetros
Los objetos de función se pueden generar a partir de plantillas de funciones, que se definen como:
template< class >
class function; /* undefined */
(since C++11)
template< class R, class... Args >
class function<R(Args...)>;//用R类实例化函数对象
Dada una clase y los parámetros correspondientes, la plantilla de clase genera una clase std :: function. El parámetro de clase R de la plantilla tiene ciertos requisitos. Las clases comunes que cumplen con los requisitos son:
- Función ordinaria
- expresión lambda
- enlazar expresión
- Otros objetos invocables (como functores)
- Puntero de función miembro
- Miembros de datos de función de miembro (¿miembros de datos de clase?)
Notas
Los argumentos de la función de subproceso se mueven o se copian por valor. Si es necesario pasar un argumento de referencia a la función de subproceso, debe ajustarse (por ejemplo, con std :: ref o std :: cref).
Se ignora cualquier valor de retorno de la función. Si la función lanza una excepción, se llama a std :: terminate. Para pasar valores de retorno o excepciones al hilo de llamada, se pueden usar std :: promise o std :: async.
Ejemplo: cree dos hilos para imprimir números pares e impares respectivamente
#include <iostream>
#include <thread>
using namespace std;
void show_even()
{
for(int i=0;i<10;i+=2)
{
cout<<i;
}
};
void show_odd()
{
for(int i=1;i<10;i+=2)
{
cout<<i;
}
}
int main()
{
thread th1(show_odd);
thread th2(show_even);
th1.join();
th2.join();
return 0;
}
Los resultados de cada carrera es diferente, tomar cualquiera de los tres resultados: 0246813579 1357902468 1350247968. La CPU solo se ejecutará en un subproceso a la vez. Si la velocidad de procesamiento es lo suficientemente simple, es posible que todo el contenido de un subproceso esté completo, pero el otro subproceso aún no se haya iniciado.
Para un contenido de ejecución simple, es más apropiado usar lambda para crear un objeto invocable:
int main()
{
thread th1([](){
for(int i=0;i<10;i+=2){
cout<<i;}});
thread th2([](){
for(int i=1;i<10;i+=2){
cout<<i;}});
th1.join();
th2.join();
return 0;
}
No es necesario pensar en el nombre de la función, no es necesario escribir una función especial, blabla.