C++ 11 thread join detach move swap

刚自学了thread发现网上的资料比较分散，现在这里统一整理一下，不是很深入，只介绍一般用法。

首先创建thread对象，把thread当作一个类，创建类对象，括号中放入要执行的函数名，函数名后紧跟函数参数，用逗号分开。

void fun1(int x){
    Sleep(3000);
    cout<<"这里是fun1 x=="<<x<<endl;
}
void fun2(){
    cout<<"这里是fun2"<<endl;
}
int main(){
    thread haha(fun2);
    thread xixi(fun1,12345);
    haha.join();
    xixi.join();
    return 0;
}

 

一般某一线程B是由其主进程A创建的。除了创建，A还要负责B的回收，回收的操作就是join()，意即B加入到A中被回收，可以推测join()操作只有一次。如果A在程序某处有B.join()，则A进程会阻塞，直到B进程结束，A才继续执行。

如果线程A既希望被创建的线程B资源回收，又不会被阻塞在join，那怎么办呢，将线程B分离，即detach。A将B分离后B由库接管，并自动回收。分离后的B不可再join到A中，即B不再joinable。

join：主线程被阻塞detach：会分离，子线程自动回收资源

void fun1(){
    cout<<"这里是B线程"<<endl;
}
int main(){
    thread haha(fun1);
    cout<<"这里是A线程"<<endl;
    haha.join();
    return 0;
}

B被创建后调用fun1（）输出“这里是B线程”，而A线程输出“这里是A线程”，A、B并发执行，竞争输出窗口。如果这里是单线程的话，结果肯定是先输出B，再输出A，但在我的机子上测试结果是先输出A，再输出B。可能是因为B还要创建操作所以慢了。

现在换一下join位置

void fun1(){
    cout<<"这里是B线程"<<endl;
}
int main(){
    thread haha(fun1);
    haha.join();
    cout<<"这里是A线程"<<endl;
    return 0;
}

测试结果是先输出B，再输出A，可见join是有影响的，它的作用就是让A等B结束了再执行。

然后将join换成detach

void fun1(){
    cout<<"这里是B线程"<<endl;
}
int main(){
    thread haha(fun1);
    haha.detach();
    cout<<"这里是A线程"<<endl;
    return 0;
}

测试结果又变成了先输出A，再输出B，因为A将B分离后就继续执行了。这里B不是joinable的。

move操作是将一个进程转移给另一个进程，注意进程只能被转移不能被复制

void fun1(){
    Sleep(3000);
    cout<<"这里是fun1"<<endl;
}
void fun2(){}
int main(){
    thread haha(fun1);
    cout<<"haha的初始id "<<haha.get_id()<<endl;
    thread xixi(move(haha));
    cout<<"xixi的初始id "<<xixi.get_id()<<endl;
    xixi.join();
    return 0;
}

swap交换两个线程

void fun1(){
    Sleep(3000);
    cout<<"这里是fun1"<<endl;
}
void fun2(){}
int main(){
    thread haha(fun1);
    cout<<"haha的初始id "<<haha.get_id()<<endl;
    thread xixi(fun2);
    cout<<"xixi的初始id "<<xixi.get_id()<<endl;
    xixi.swap(haha);
    cout<<"swap后haha的id "<<haha.get_id()<<endl;
    cout<<"swap后xixi的id "<<xixi.get_id()<<endl;
    haha.join();
    xixi.join();
    return 0;
}