关于线程和C++11的线程类

最新推荐文章于 2024-09-26 22:27:31 发布
最新推荐文章于 2024-09-26 22:27:31 发布
阅读量1.1k 收藏
点赞数
分类专栏： C++基础 文章标签： c++ c语言 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41646522/article/details/123532407
版权

单核cpu需要对多线程访问共享资源加锁吗
需要。时间片完，也会引起线程的调度，需要对共享资源加锁。
线程参考

线程创建

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg);

参数:
thread: 传出参数，是无符号长整形数，线程创建成功，会将线程 ID 写入到这个指针指向的内存中
attr: 线程的属性，一般情况下使用默认属性即可，写 NULL
start_routine: 函数指针，创建出的子线程的处理动作，也就是该函数在子线程中执行。
arg: 作为实参传递到 start_routine 指针指向的函数内部

返回值：线程创建成功返回 0，创建失败返回对应的错误号

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
void *working(void *args){
printf("i am child thread%ld",pthread_self());
for(int i=0;i<10;i++)
    printf("num:%d\n", i);
return NULL;
}
int main(){
    pthread_t tid;
    pthread_create(&tid,NULL,working,NULL);
    printf("thread create %ld\n",tid);
    
    //
    printf("i am father thread %ld\n",pthread_self());
    for(int i=0;i<3;i++)
    printf("num:%d\n",i);
    //sleep(1);

    return 0;
}

输出

thread create 139716524607232
i am father thread 139716524611392
num:0
num:1
num:2

子线程的并不输出，原因：
子线程被创建出来后，抢cpu时间片，抢不到就不运行。在子线程运行期间如果主线程退出，子线程会一并被销毁。
因为子线程使用的是主线程的虚拟地址空间。
解决方案：让子线程执行完毕，主线程再退出，可以在主线程中添加挂起函数 sleep();
进一步：

线程退出

加上这行 主线程调用退出函数退出, 地址空间不会被释放
pthread_exit(NULL);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
void *working(void *args){
printf("i am child thread%ld",pthread_self());
for(int i=0;i<10;i++)
    printf("num:%d\n", i);
return NULL;
}
int main(){
    pthread_t tid;
    pthread_create(&tid,NULL,working,NULL);
    printf("thread create %ld\n",tid);
    
    //
    printf("i am father thread %ld\n",pthread_self());
    for(int i=0;i<3;i++)
    printf("num:%d\n",i);
    加上这行   主线程调用退出函数退出, 地址空间不会被释放
    pthread_exit(NULL);

    return 0;
}

pthread_exit()
线程退出但是不会导致虚拟地址空间的释放，针对于主线程，可以使用pthread_exit();

#include <pthread.h>
void pthread_exit(void *retval);

参数：线程退出的时候携带的数据，当前子线程的主线程会得到该数据。如果不需要使用，指定为 NULL

线程回收

子线程与主线程之间的通信

子线程退出的时候其内核资源由主线程回收
pthread_join();子线程还在运行则改函数阻塞直到子线程完成，调用一次回收一个，回收所有需要循环进行回收。第二个参数获取传递出来的数据（由pthread_exit（void** retvl）传出来的返回值）。

使用线程自己的栈传数据：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
void *working(void *args)
{
    int num=2;
    pthread_exit(&num);
    return NULL;
}
int main()
{
    pthread_t tid[10];
    for(int i=0;i<10;i++){
    
    pthread_create(&tid[i], NULL, working, NULL);
    printf("thread create %ld\n", tid[i]);
    }
    
    for(int i=0;i<10;i++){
    void *N=NULL;
    pthread_join(tid[i],&N);
    printf("N:%d\n",*(int*)N);
    }
    //
    printf("i am father thread %ld\n", pthread_self());
    for (int i = 0; i < 3; i++)
        printf("num:%d\n", i);
    pthread_exit(NULL);

    return 0;
}

输出：

N:32747
N:32767
N:32767
N:32767
N:32767
N:32767
N:32767
N:32767
N:32767
N:32767

数据保存在子线程自己的栈区，因为子线程销毁了，子线程的栈空间也归还给主线程，因此获取不到。

使用全局变量：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
int num=1;
void *working(void *args)
{
    num*=2;
    pthread_exit(&num);
    return NULL;
}
int main()
{
    pthread_t tid[10];
    for(int i=0;i<10;i++){
    pthread_create(&tid[i], NULL, working, NULL);
    printf("thread create %ld\n", tid[i]);
    }
    
    for(int i=0;i<10;i++){
    void *N=NULL;
    pthread_join(tid[i],&N);
    printf("N:%d\n",*(int*)N);
    }
    //
    printf("i am father thread %ld\n", pthread_self());
    for (int i = 0; i < 3; i++)
        printf("num:%d\n", i);
    pthread_exit(NULL);

    return 0;
}

thread create 140322816030464
thread create 140322807637760
thread create 140322799245056
thread create 140322790741760
thread create 140322782349056
thread create 140322773956352
thread create 140322765563648
thread create 140322688464640
thread create 140322680071936
thread create 140322671679232
N:512
N:512
N:512
N:512
N:1024
N:1024
N:1024
N:1024
N:1024
N:1024
i am father thread 140322816034624
num:0
num:1
num:2

访问的是共享变量。void可以使用任意类型数据 void*为数据地址，void为指向数据地址的指针。

使用主线程的栈

创建子线程的时候传参数

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
void *working(void *args)
{
    int *num=(int*)args;
    *num*=2;
    pthread_exit(num);
    return NULL;
}
int main()
{
    int num=1;
    pthread_t tid[10];
    for(int i=0;i<10;i++){
    pthread_create(&tid[i], NULL, working, &num);
    printf("thread create %ld\n", tid[i]);
    }
    
    for(int i=0;i<10;i++){
    void *N=NULL;
    pthread_join(tid[i],&N);
    printf("N:%d\n",*(int*)N);
    }
    //
    printf("i am father thread %ld\n", pthread_self());
    for (int i = 0; i < 3; i++)
        printf("num:%d\n", i);
    pthread_exit(NULL);

    return 0;
}

N:512
N:512
N:512
N:512
N:1024
N:1024
N:1024
N:1024
N:1024
N:1024

线程分离

一般情况下，主线程有自己的业务逻辑，如果主线程负责子线程的资源回收，调用pthread_join()只要子线程不退出，主线程就会一直被阻塞加粗样式，主线程就也被阻塞。
pthread_detach（）线程分离函数，子线程就可以和主线程分离，当子线程退出的时候，其占用的内核资源就被系统的其他进程接管并回收了。线程分离之后在主线程中使用 pthread_join() 就回收不到子线程资源了。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
void *working(void *args)
{
    printf("i am child thread%ld", pthread_self());
    sleep(3);
    for (int i = 0; i < 10; i++)
        printf("num:%d\n", i);
    return NULL;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, working, NULL);
    printf("thread create %ld\n", tid);
    pthread_detach(tid);
    //
    printf("i am father thread %ld\n", pthread_self());
    for (int i = 0; i < 3; i++)
        printf("num:%d\n", i);
    pthread_exit(NULL);

    return 0;
}

线程取消

在一个线程中杀死另一个线程。使用这个函数杀死一个线程需要分两步
1.A中调用pthread_cancel指定杀死线程B，B不死
2.B进行一次系统调用，被杀死

#include <pthread.h>
// 参数是子线程的线程ID
int pthread_cancel(pthread_t thread);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
void *working(void *args)
{
    printf("i am child thread%ld", pthread_self());
    sleep(10);
    for (int i = 0; i < 10; i++)
        printf("num:%d\n", i);
    return NULL;
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, NULL, working, NULL);
    printf("thread create %ld\n", tid);
    pthread_cancel(tid);
    //
    printf("i am father thread %ld\n", pthread_self());
    for (int i = 0; i < 3; i++)
        printf("num:%d\n", i);
    pthread_exit(NULL);

    return 0;
}

子线程中cout进行了系统调用

thread create 140093522048768
i am child thread140093522048768i am father thread 140093522052928
num:0
num:1
num:2

线程 ID 比较

在 Linux 中线程 ID 本质就是一个无符号长整形，因此可以直接使用比较操作符比较两个线程的 ID，但是线程库是可以跨平台使用的，在某些平台上 pthread_t 可能不是一个单纯的整形，这中情况下比较两个线程的 ID 必须要使用比较函数，函数原型如下：

#include <pthread.h>
int pthread_equal(pthread_t t1, pthread_t t2);

参数：t1 和 t2 是要比较的线程的线程 ID
返回值：如果两个线程 ID 相等返回非 0 值，如果不相等返回 0

c++线程类

c++11后增加了线程类
std::thread

  1. 构造函数
// ①
thread() noexcept;
// ②
thread( thread&& other ) noexcept;
// ③
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );
// ④
thread( const thread& ) = delete;

1.构造函数：默认构造函数，构造一个线程对象，不执行任何处理动作
2.移动构造函数，把other的线程所有权转移给新的thread对象，之后other不再表示执行线程
3.创建线程对象，并在该线程中执行函数f中的业务逻辑，args是参数
f可以是，普通函数，类成员函数，匿名函数，仿函数，也可以是可调用对象包装器类型。
4.使用delete显示删除拷贝构造，不允许线程对象之间的拷贝。

成员函数：

  1. get_id（） 获取线程id
std::thread::id get_id() const noexcept;

#include<iostream>
#include<thread>
#include<chrono>
using namespace std;

void func(int num,string str){
for(int i=0;i<10;i++){
    cout<<"child thread i="<<i<<"num:"
    <<num<<",str"<<str<<endl;
}
}

void func1(){
    for(int i=0;i<10;i++){
        cout<<"child thread i="<<i<<endl;
    }
}

int main(){
    cout<<this_thread::get_id()<<endl;
    thread t(func,520,"i love u");
    thread t1(func1);
    t.join();
    t1.join();
    cout<<t.get_id()<<endl;
    cout<<t1.get_id()<<endl;
    
    return 0;
}

线程分离函数 detach () 不会阻塞线程，子线程和主线程分离之后，在主线程中就不能再对这个子线程做任何控制了，比如：通过 join () 阻塞主线程等待子线程中的任务执行完毕，或者调用 get_id () 获取子线程的线程 ID。有利就有弊，鱼和熊掌不可兼得，建议使用 join ()。

  • joinable()

joinable() 函数用于判断主线程和子线程是否处理关联（连接）状态，一般情况下，二者之间的关系处于关联状态，该函数返回一个布尔类型：
返回值为 true：主线程和子线程之间有关联（连接）关系
返回值为 false：主线程和子线程之间没有关联（连接）关系

#include<iostream>
#include<thread>
#include<chrono>
using namespace std;

void foo(){
this_thread::sleep_for(std::chrono::seconds(1));
}

int main(){

    thread t;
    cout<<"before starting joinable"<<t.joinable()<<endl;
    t=thread(foo);
    cout << "before starting joinable" << t.joinable() << endl;
    t.join();
    cout << "before starting joinable" << t.joinable() << endl;

    thread t1(foo);
    cout << "before starting joinable" << t1.joinable() << endl;
    t1.detach();
    cout << "before starting joinable" << t1.joinable() << endl;

    return 0;
}

//输出
0 1 0 1 0
  • 创建时，未指定任务函数，子线程不启动也不绑定。
  • 启动任务时，自动绑定。
  • join()任务完成，子线程自动销毁也自动解除绑定。
  • detach()父子线程分离，也就解除绑定。

operator
线程中的资源是不能被复制的，因此通过 = 操作符进行赋值操作最终并不会得到两个完全相同的对象

// move (1)	
thread& operator= (thread&& other) noexcept;
// copy [deleted] (2)	
thread& operator= (const other&) = delete;

通过以上 = 操作符的重载声明可以得知：
如果 other 是一个右值，会进行资源所有权的转移
如果 other 不是右值，禁止拷贝，该函数被显示删除（=delete），不可用

宅宅宅宅
关注
专栏目录
C++ Multithreading(3) -- passing arguments to threads
DDelphine的博客
06-12 339
线程传参passing arguments to threadscaveat:pass stack-located local variable to threadspass heap-located variable to threadshow to pass by reference：pass pointer to member function of a class as thread function passing arguments to threads 给thread传参很简单，直接将call
c++11 线程类
weixin_34246551的博客
08-20 150
2019独角兽企业重金招聘Python工程师标准>>> ...
【C++11】线程库
最新发布
qq_55317476的博客
09-26 958
​ 在C++11之前，涉及到多线程的问题，都是和平台相关的，比如windows和Linux下各自有自己的接口，这使得代码的可移植性比较差，C++11中最重要的特性就是对线程进行了支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库的线程，必须包含 头文件。
C++线程类
AllKillMan的专栏
11-22 1518
C++多线程，C++线程类
c++ 线程类
tianyexing2008的博客
09-15 1550
可以看到在 createThread() 成员函数里调用了 pthread_create() 进行线程的创建，而且线程函数是此类的一个 static 函数 startThread(void* arg)，为什么是 static 类型函数呢？现在C++11及之后版本已经提供了线程类来使用线程，但我们在编译的时候还是需要添加 -lpthread 链接（也许其线程类实现还是得依赖 pthread 库吧，没看过源码还不清楚），那如果不使用c++提供的线程类，我们在实际项目中是如何封装的线程类呢？
C++11/14 线程调用类对象和线程传参的方法
08-26
C++11/14 线程调用类对象和线程传参的方法 C++11/14 中引入了 std::thread 类，允许开发者创建和管理线程。然而，在使用 std::thread 时，需要注意线程调用类对象和线程传参的方法。 线程调用类对象 在 C++11/14 ...
C++11 线程的中断，继续以及停止
03-18
C++11关于thead的应用，利用std::condition std::mutex提供如何中断，停止和继续功能，
C++多线程封装成类使用示例
12-19
C++11标准引入了内置的`<thread>`库，使得多线程编程变得更加简单。本示例将详细介绍如何将C++的多线程功能封装成一个类，以便在实际项目中更加灵活地使用。 首先，我们需要了解C++11中的`std::thread`类。`std::...
C++ 实现 暂停、继续、停止线程的线程类 和 Demo
11-04
简单的说就是用开辟一个线程用来监测两个事件（while 循环，循环内包含了你想要处理的动作，比如此例中的更新进度条），通过控制两个事件的状态来控制循环的启动、暂停和继续。 有个小Bug： BOOL CFThread::...
c++ 线程类
u010442009的专栏
12-16 547
利用c++11特性 做的一个线程类 基类#pragma once #include #include #include /* * 工作线程 */ class CxWorkThread { public: CxWorkThread(); ~CxWorkThread(); public: /* * 初始化 */ virtual int Init(); /* * 开始 *
C++ 线程函数是类的成员函数
05-09
C++ 线程函数是类的成员函数 C++ 线程函数是类的成员函数
c++11 线程
dr526
10-06 1168
c++11并发与多线程（1）并发、进程、线程的基本概念和综述并发的实现方法c++11标准库基础线程之间的数据共享 并发、进程、线程的基本概念和综述 并发 两个或者更多的任务（独立的活动）同时发生（进行） 单核cpu：某一个时刻只能执行一个任务，由操作系统调度，进行上下文切换，从而让任务在同一段时间交替执行。这是一种并发的假象 多核cpu：当任务数少于cpu核数，就能够实现真正的并发，也称为硬件并发 使用并发的原因：同时执行多个任务，提高性能 可执行程序 磁盘上的一个文件。例如：windows
C++线程类实现
yinhua405的博客
05-27 231
#ifndef THREAD_VITO_H #define THREAD_VITO_H #ifdef _WIN32 #include<windows.h> #else #include <pthread.h> #endif class ThreadVito { #ifdef _WIN32 typedef unsigned(__stdcall* func)(void*); #else typedef void* (* func)(void*); #endif ...
C++ 线程-类方式
代码人生
01-24 419
C++ 线程-类方式
类行为和线程处理
celinessl_csdn的博客
08-11 278
C++多线程编程(10)  类行为和线程处理   1.C++对象4种作用域类型:局部作用域、函数作用域、文件作用域、类作用域 程序分成多个进程，每个进程有自己的文本、数据和堆栈片段。每个程序有自己的堆。为了让进城访问另 一个进程的数据或命令，必须进行进程间通信。进程间通信位于每个进程外部，并且充当进程间数据流的 通道。 局部:只能在声明它所在块内部使用的名字，活声
[C++ 11多线程编程] --- std::thread
M2嵌入式
10-25 509
C++11 之前，C++ 语言没有对并发编程提供语言级别的支持，这使得我们在编写可移植的并发程序时，存在诸多的不便。现在 C++11 中增加了线程以及线程相关的类，很方便地支持了并发编程，使得编写的多线程程序的可移植性得到了很大的提高。 C++11 中提供的线程类叫做 std::thread，基于这个类创建一个新的线程非常的简单，只需要提供线程函数或者函数对象即可，并且可以同时指定线程函数的参数。我们首先来了解一下这个类提供的一些常用 API： 1. 线程类构造函数 // ① thread() noexce
在C++中实现多线程类
有梦，有追求
12-11 589
在C++中实现多线程类    在JAVA中，实现多线程有两种方式，一种是继承自Thread类，一种是Runnable，在MFC中也有CWinThread类，但是我们如何利用已有的多线程的机制来实现一个多线程类呢？ 在Windows中使用C语言做多线程编程，我们可以使用两个函数，一个是 CreateThread()，该函数是一个Win32 API函数，另一个是_beginthread()，
C++多线程类Thread（C++11）
热门推荐
ouyangfushu的博客
05-04 7万+
C++多线程类Thread（C++11）C++11中std命名空间将Boost库中的Thread加入，Boost的多线程从准标准变为标准，在深度学习以及应用程序开发中经常用到多线程，这里将其用法整理复习，以demo的形式复习，每次遇到问题或者忘记了总是百度，用完了就是忘记，好记性不如烂笔头，Goahead!头文件为#include&lt;thread&gt;,通过std::thread应用。就以H...
C++11并发与多线程编程实战指南
"《C++并发编程(中文版)》基于C++11新标准，深入探讨了并发和多线程编程，由Anthony Williams著，适用于C++开发者、测试...通过阅读本书，读者将能够写出高效、安全的多线程C++应用程序，以适应多核时代的编程需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值