Linux c++ 线程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Linux c++ 线程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9503字，纯文字阅读大概需要14分钟。

内容图文

1. 线程与进程
- 线程的概念
- 深入理解进程和线程
2. 多线程
- 什么是多线程
- 多线程模型的好处
3. 线程标识
4. 线程创建
5. 线程终止
6. 线程等待
7. 线程分离
- pthread_detach
- 以分离状态创建线程
8. 线程取消

1. 线程与进程

线程的概念

线程是进程内相对独立的一个执行流，是进程内的一个执行单元，是操作系统中一个可调度的实体。

深入理解进程和线程

在现代操作系统中，资源分配的基本单位是进程，而CPU调度执行的基本单位是线程
进程不是调度单元，线程是进程使用CPU资源的基本单位
进程有独立的地址空间，进程中可以存在多个线程共享进程资源
线程不能脱离进程单独存在，只能依附于进程运行
线程可以在不影响进程的情况下终止，但反之则不然

技术分享图片

2. 多线程

什么是多线程

多线程，是指从软件或硬件层面上实现多个线程并发执行的技术。

从软件层面看，一个进程中可以有多个线程，该程序也可以称之为多线程程序；
从硬件层面看，多核处理器能够支持在同一时间执行多个线程。

实际上，对于单核处理器，即使软件编写为多线程模型，同一时间也只能执行一个线程，但这并不代表此时多线程就没有意义，因为处理器的数量不会影响程序结构，那么多线程编程模型在程序结构上到底有哪些好处呢？

多线程模型的好处

通过为每种事件类型分配单独的处理线程，可以简化异步事件处理代码
可以直接共享进程的数据资源
将复杂问题分解为相互独立的任务，可以交叉进行，提高程序吞吐量
通过把处理用户输入输出的部分和其他部分分开，可以改善交互式程序响应时间

3. 线程标识

线程ID（Thread ID）是线程的唯一标识
线程ID只有在它所属的进程上下文中才有意义
线程ID类型为pthread_t，可能实现为unsigned long或结构体，依系统而定
线程可以调用pthread_self获得自身线程ID
可移植的程序应该调用pthread_equal来比较两个线程的ID

                            
                                #include<pthread.h>
                                pthread_t pthread_self();  //返回调用线程的线程IDintpthread_equal(pthread_t tid1, pthread_t tid2); //相等返回非0数值，否则返回0

4. 线程创建

函数原型

任意线程可以通过调用pthread_create创建新线程，start_routine为新线程的启动例程，创建成功后，新线程和调用线程谁先运行是不确定的。

                            
                                //成功返回0，失败返回错误编号
int pthread_create(pthread_t *tid, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

参数说明

pthread_create成功返回后，tid指向内存即为新线程ID
attr用于定制线程属性，若使用默认属性则传NULL
start_routine是线程启动例程
arg是start_routine的参数，若参数不止一个，就把这些参数放到一个结构中，再把该结构的地址作为arg传入

使用示例-打印线程ID

                            
                                #include<pthread.h>
                                #include<stdio.h>
                                pthread_t tid;

voidprintf_tid(constchar *s){
    pid_t     pid = getpid();
    pthread_t tid = pthread_self();    
       
    printf("%s pid = %d, tid = %lu(0x%lx)\n", s, pid, tid, tid);
}

void *pthread_start(void *arg){
    printf_tid("new thread:  "); //新线程用pthread_self()获取自身ID，是因为新线程执行时pthread_create()可能还未返回，tid还未初始化完成
}

intmain(){     
    pthread_create(&tid, NULL, pthread_start, NULL);
    sleep(1); //调用线程休眠1S，让新线程先执行
    printf_tid("main thread: ");
    
    return0;
}

技术分享图片

注意：使用pthread的代码在编译时需要指定链接-lpthread

5. 线程终止

在不影响整个进程的情况下，单个线程有三种终止方式：

在线程启动例程中调用return返回
在线程启动例程中调用pthread_exit退出
被进程中的其他线程取消

                            
                                
                                    void
                                    pthread_exit
                                    (void *value_ptr)
                                ;

value_ptr是一个无类型指针，进程中的其他线程可以调用pthread_join访问到这个指针。

6. 线程等待

函数原型

                            
                                
                                    int
                                    pthread_join
                                    (pthread_t tid, void **value_ptr)
                                ; //成功返回0，失败返回错误编号

调用线程将一直阻塞，直到等待的线程以上述三种方式终止。

参数说明

tid表示等待的线程ID
value_ptr用于保存线程的退出状态
如果线程以return或pthread_exit方式终止，value_ptr指向内存就被设置为return或pthread_exit的参数
如果线程被取消，value_ptr指向内存就被设置为PTHREAD_CANCELED
如果不关心线程的返回值，就给value_ptr传NULL

使用示例-获得线程返回值

                            
                                #include<pthread.h>
                                #include<stdio.h>
                                
                                    void *thread1_start(void *arg){
    int ret = 0;
    return ((void *)ret);
}

void *thread2_start(void *arg){
    char *ret = "thread 2 exit";
    pthread_exit(ret);
}

intmain(){     
    pthread_t tid1;
    pthread_t tid2;
    void *ret;
    
    pthread_create(&tid1, NULL, thread1_start, NULL);
    pthread_create(&tid2, NULL, thread2_start, NULL);
    
    pthread_join(tid1, &ret);
    printf("thread 1: %d\n", (int)ret); 
    
    pthread_join(tid2, &ret);
    printf("thread 2: %s\n", (char *)ret);
    
    return0;
}

技术分享图片

7. 线程分离

在默认情况下，线程的终止状态会一直保存到对该线程调用pthread_join；但是，如果线程已经被分离，其占用的系统资源会在线程终止时被立即回收。
有两种方式可以使线程分离：

调用pthread_detach，该函数不会使调用线程阻塞
修改线程属性结构pthread_attr_t，以分离状态创建线程

在线程被分离后，就不能再用pthread_join等待它的终止状态了，因为对分离状态的线程调用pthread_join会产生未定义行为。

pthread_detach

                            
                                
                                    int
                                    pthread_detach
                                    (pthread_t tid)
                                ; //成功返回0，失败返回错误编号

                            
                                #include<pthread.h>
                                #include<stdio.h>
                                
                                    void *thread_start(void *arg){
    sleep(2);
    printf("new thread exit\n");
    pthread_exit(NULL);
}

intmain(){     
    pthread_t tid;
 
    pthread_create(&tid, NULL, thread_start, NULL);
    pthread_detach(tid);
    
    printf("main thread: pthread_detach() return\n");
    sleep(5);
    
    return0;
}

技术分享图片

以分离状态创建线程

                            
                                /*4个函数的返回值：成功返回0，失败返回错误编号*/
                                
                                    int
                                    pthread_attr_init
                                    (pthread_attr_t *attr)
                                ;
intpthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); 
intpthread_attr_getdetachstate(constpthread_attr_t *attr, int *detachstate); 
intpthread_attr_destroy(pthread_attr_t *attr);

可以调用pthread_attr_setdetachstate来设置线程的可分离状态：

detachstate = PTHREAD_CREATE_DETACHED，以分离状态启动线程
detachstate = PTHREAD_CREATE_JOINABLE，以正常状态启动线程

                            
                                #include<pthread.h>
                                #include<stdio.h>
                                
                                    void *thread_start(void *arg){
    sleep(2);
    printf("new thread exit\n");
    pthread_exit(NULL);
}

intmain(){     
    pthread_t tid;
    pthread_attr_t attr;

    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);   
    pthread_create(&tid, &attr, thread_start, NULL);
    pthread_attr_destroy(&attr);
    
    printf("main thread: pthread_attr_destroy() return\n");
    sleep(5);
    
    return0;
}

技术分享图片

8. 线程取消

pthread_cancel

在编写多线程代码时，经常面临线程安全退出问题，一般情况下，最好使用将标志位置位的方式；
在其他线程中将标志位置位，然后调用pthread_join等待线程退出，回收线程占用的资源。

                            
                                
                                    void *thread_start(void *arg){
    while (!quit)
    {
        //......
    }
}

intmain(){
    quit = 1;
    pthread_join(tid, NULL);
}

但是在某些应用中，线程可能正阻塞于某个函数（如pthread_cond_wait）无法被唤醒，即使设置了标志位也无法结束。
此时可以在其他线程中调用pthread_cancel请求取消线程，然后立即调用pthread_join等待线程退出。

                            
                                
                                    int
                                    pthread_cancel
                                    (pthread_t tid)
                                ; //成功返回0，失败返回错误编号

tid为要取消的线程ID，需要注意的是，pthread_cancel并不等待线程终止，它仅仅是发出请求。

                            
                                #include<pthread.h>
                                #include<stdio.h>
                                
                                    void *thread1_start(void *arg){
    sleep(10);
    pthread_exit(NULL);
}

void *thread2_start(void *arg){
    sleep(10);
    pthread_exit(NULL);
}

intmain(){     
    pthread_t tid1;
    pthread_t tid2;
    
    pthread_create(&tid1, NULL, thread1_start, NULL);
    pthread_create(&tid2, NULL, thread2_start, NULL);
    
    sleep(1);
    
    pthread_cancel(tid1);
    pthread_join(tid1, NULL);
    printf("thread 1 exit\n");
     
    sleep(1);
    
    pthread_cancel(tid2);
    pthread_join(tid2, NULL);
    printf("thread 2 exit\n");
    
    return0;
}

技术分享图片

线程取消属性

线程取消有两个属性，分别是可取消状态和可取消类型，这两个属性不在pthread_attr_t结构中，但它们影响着线程在响应取消请求时的行为。

                            
                                /*
 * 可取消状态：PTHREAD_CANCEL_ENABLE（允许取消，默认属性），PTHREAD_CANCEL_DISABLE（不允许取消，但取消请求不会丢失，而是一直处于挂起状态）
 * 可取消类型：PTHREAD_CANCEL_DEFERRED（延迟取消，到达取消点才取消，默认属性），PTHREAD_CANCEL_ASYNCHRONOUS（异步取消，可在任意时刻取消）
*/
                                
                                    int
                                    pthread_setcancelstate
                                    (int state, int *oldstate)
                                ;  //将线程可取消状态设为state，原有可取消状态通过oldstate返回，这两步是原子操作intpthread_setcanceltype(int type, int *oldtype);     //将线程可取消类型设为type，原有可取消类型通过oldtype返回

取消点

默认情况下，线程的可取消类型为延迟取消，也就是说：被取消的线程在取消请求发出后还是继续运行，直到到达某个取消点。
取消点是线程检查它是否被取消的一个位置，根据《UNIX环境高级编程第3版》P362-P363描述，POSIX.1定义的取消点和可选取消点如下。
技术分享图片

自定义取消点

如果线程在很长一段时间内都不会调用前面两张图中的取消点函数，那么可以调用pthread_testcancel在线程中添加自己的取消点。
调用pthread_testcancel时，如果有某个取消请求处于挂起状态，且可取消状态为ENABLE，那么线程就会被取消。

                            
                                
                                    void
                                    pthread_testcancel
                                    ()
                                ;

使用线程取消的风险

当线程响应取消请求而终止时，主要面临的两大风险：

线程里面的锁可能没有unlock，有可能导致死锁
线程申请的资源（如堆内存）没有释放

下面是一段由pthread_cancel引起的死锁范例代码。

                            
                                #include<pthread.h>
                                #include<stdio.h>
                                static
                                pthread_cond_t  cond;
staticpthread_mutex_t mutex;

void *thread0(void *arg){ 
    pthread_mutex_lock(&mutex);    
    printf("thread 0 lock sucess\n");
    pthread_cond_wait(&cond, &mutex); //主线程发出取消请求时，thread1阻塞于slepp(2)，thread0阻塞于此取消点，导致thread0未解锁mutex就终止printf("thread 0 pthread_cond_wait return\n"); 
    pthread_mutex_unlock(&mutex); 
    
    pthread_exit(0);
}

void *thread1(void *arg){
    sleep(2);   
    
    printf("thread 1 start lock\n");
    pthread_mutex_lock(&mutex);       //thread0终止约1S后，thread1执行到此，由于mutex已加锁，也没有其他地方能够对其解锁，从而导致死锁printf("thread 1 lock sucess\n");      
    pthread_cond_signal(&cond);    
    pthread_mutex_unlock(&mutex); 
    
    pthread_exit(0);  
}

intmain(){     
    pthread_t tid[2];
    
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);
    
    pthread_create(&tid[0], NULL, thread0, NULL);
    pthread_create(&tid[1], NULL, thread1, NULL);

    sleep(1);  
    pthread_cancel(tid[0]);
    printf("main thread request cancel thread 0\n");

    pthread_join(tid[0], NULL);
    pthread_join(tid[1], NULL);
  
    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);
    
    return0;
}

技术分享图片

线程清理程序

可以使用线程清理程序来解决线程取消的风险问题。线程可以安排它退出时需要调用的函数，这样的函数称为线程清理程序。
一个线程可以注册多个清理程序，处理程序记录在栈中，也就是说，它们的执行顺序和注册顺序是相反的。

                            void pthread_cleanup_push(void (*routine)(void *), void *arg);
void pthread_cleanup_pop(int execute);

当线程执行以下动作时，清理程序是由pthread_cleanup_push函数调度的，调用时只有一个参数arg：

调用pthread_exit结束线程
响应pthread_cancel取消请求
用非零execute参数调用pthread_cleanup_pop

注意：如果线程以return方式终止，线程清理程序不会被调用。

不管发生上述哪种情况，pthread_cleanup_pop都将删除上次pthread_cleanup_push登记的线程清理程序。
这两个函数有一个限制，由于它们经常实现为宏，所以必须在与线程启动例程相同的作用域中以配对的方式使用，否则，可能会产生编译错误。

回到线程取消的风险问题上来，我们只需要在线程清理程序中解锁和释放资源，并在线程启动例程的第一步就注册清理程序，
这样，当线程因响应取消请求而终止时，线程清理程序就会得以执行。

                            
                                #include<pthread.h>
                                #include<stdio.h>
                                static
                                pthread_cond_t  cond;
staticpthread_mutex_t mutex;

voidcleanup(void *arg){
    pthread_mutex_unlock(&mutex); 
    printf("mutex unlock in cleanup\n");
}

void *thread0(void *arg){
    pthread_cleanup_push(cleanup, NULL); //注册线程清理程序进行解锁
    
    pthread_mutex_lock(&mutex);    
    printf("thread 0 lock sucess\n");
    pthread_cond_wait(&cond, &mutex);    //主线程发出取消请求时，thread1阻塞于slepp(2)，thread0阻塞于此取消点printf("thread 0 pthread_cond_wait return\n"); 
    pthread_mutex_unlock(&mutex); 
    
    pthread_cleanup_pop(0);
    pthread_exit(0);
}

void *thread1(void *arg){
    sleep(2);   
    
    printf("thread 1 start lock\n");
    pthread_mutex_lock(&mutex);          //thread0终止约1S后，thread1执行到此printf("thread 1 lock sucess\n");      
    pthread_cond_signal(&cond);    
    pthread_mutex_unlock(&mutex); 
    
    pthread_exit(0);  
}

intmain(){     
    pthread_t tid[2];
    
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);
    
    pthread_create(&tid[0], NULL, thread0, NULL);
    pthread_create(&tid[1], NULL, thread1, NULL);

    sleep(1);  
    pthread_cancel(tid[0]);
    printf("main thread request cancel thread 0\n");

    pthread_join(tid[0], NULL);
    pthread_join(tid[1], NULL);
  
    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);
    
    return0;
}

技术分享图片

最后，引用一篇由pthread_cancel引起死锁的博客https://blog.csdn.net/xsckernel/article/details/48052425，提取核心内容如下：

“通常的说法：某某函数是Cancellation Points，这种方法是容易令人混淆的。因为函数的执行是一个时间过程，而不是一个时间点。其实真正的Cancellation Points
只是在这些函数中Cancellation Type被修改为PHREAD_CANCEL_ASYNCHRONOUS和修改回PTHREAD_CANCEL_DEFERRED中间的一段时间。”

原文：https://www.cnblogs.com/ylaoda/p/11525772.html

内容总结

以上是互联网集市为您收集整理的Linux c++ 线程全部内容，希望文章能够帮你解决Linux c++ 线程所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1124641.html

来源：【匿名】

【上一篇】教你21天学会C++【下一篇】c++有个库什么的吗?

更多 ►

【Linux c++ 线程】教程文章相关的互联网学习教程文章

在某些应用环境下面，一个类只允许有一个实例，这就是著名的单例模式。单例模式分为懒汉模式，跟饿汉模式两种。首先给出饿汉模式的实现template <class T> class singleton { private:singleton(){};singleton(const singleton&){};//禁止拷贝singleton& operator=(const singleton&){};//禁止赋值static T* m_instance; public:static T* GetInstance(); };template <class T> T* singleton<T>::GetInstance() {return m_instance...

C++多线程编程二【代码】【图】

1. 死锁与解锁：#include <iostream> #include <thread> #include <mutex>usingnamespace std;//thread引用类型函数，模板，避免类型转换，尽量指针，引用 //锁住一个变量之后，尽快操作完解锁，不要再锁，否则互锁#define COUNT 100000 mutex g_mutex1, g_mutex2;//互斥量void add1(int *p1, int *p2) {for (int i = 0; i < COUNT; i++){/*g_mutex1.lock();p1++;g_mutex2.lock();p2++;g_mutex1.unlock();g_mutex2.unlock();*/g_mu...

c++11 条件变量生产者-消费者并发线程

http://baptiste-wicht.com/posts/2012/04/c11-concurrency-tutorial-advanced-locking-and-condition-variables.html ?1234567891011121314151617181920212223242526272829303132333435363738394041424344454647structBoundedBuffer { int* buffer; intcapacity; intfront; intrear; intcount; std::mutex lock; std::condition_variable not_full; std::condition_variable not_empty; BoundedBu...

C++多线程相关【代码】

C++对多线程新加的支持操作内存池面试题1.题目：子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环 10 次，接着再回到主线程又循环 100 次，如此循环50次，试写出代码#include <iostream> // std::cout #include <mutex> #include <thread> // std::thread #include <condition_variable>usingnamespace std;mutex mu; int flag = 10; condition_variable cv; void f(int num) {for (int i ...

c++获取线程id【代码】

c++11的thread库提供了获取tid的接口：std::this_thread::get_id()这个接口返回的是一个内存地址指向表述线程的结构体（pthread也是一样）。有的时候这种方式获取的pid过长，可以使用syscall获取lwp，也就是top -H中看到的id，但也要注意syscall造成的的开销： 1 #include <iostream>2 #include <unistd.h>3 #include <sys/syscall.h>4 5usingnamespace std;6 7int main()8{9int tid = syscall(SYS_gettid); 10 cout << tid <<...

半同步半异步线程池的实现（C++11）【代码】

简介处理大量并发任务时，一个请求对应一个线程来处理任务，线程的创建和销毁将消耗过多的系统资源，并增加上下文切换代价。线程池技术通过在系统中预先创建一定数量的线程（通常和cpu核数相同），当任务到达时，从线程池中分配一个线程进行处理，线程在处理完任务之后不用销毁，等待重用。线程池包括半同步半异步和领导者追随者两种实现方式。线程池包括三部分，第一层是同步服务层，它处理来自上层的任务请求。第二层是同步队列层...

线程池原理及创建（C++实现）

http://www.cnblogs.com/lidabo/p/3328402.html 本文给出了一个通用的线程池框架，该框架将与线程执行相关的任务进行了高层次的抽象，使之与具体的执行任务无关。另外该线程池具有动态伸缩性，它能根据执行任务的轻重自动调整线程池中线程的数量。文章的最后，我们给出一个简单示例程序，通过该示例程序，我们会发现，通过该线程池框架执行多线程任务是多么的简单。为什么需要线程池目前的大多数网络服务器，包括Web服务器、Email服...

C++多线程编程（thread类）【代码】

多线程库C++11中提供了多线程的标准库，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。　　多线程库对应的头文件是#include <thread>，类名为std::thread。串行程序：#include <iostream> #include <thread>void function_1() {std::cout << "I‘m function_1()" << std::endl; }int main() {function_1();return0; }　　这是一个典型的单线程的单进程程序，任何程序都是一个进程，main()函数就是其中的主线程，...

【C/C++多线程编程之七】pthread信号量【代码】

多线程编程之信号量 Pthread是 POSIX threads 的简称。是POSIX的线程标准。相互排斥量用来处理一个共享资源的同步訪问问题，当有多个共享资源时，就须要用到信号量机制。信号量机制用于保证两个或多个共享资源被线程协调地同步使用。信号量的值相应当前可用资源的数量。 1.信号量（samaphore）: 信号量机制通过信号量的值控制可用资源的数量。线程訪问共享资源前，须要申请获取一个信号量，假...

c/c++ 多线程 std::call_once的应用【代码】【图】

多线程 std::call_once的应用std::call_once的应用：类成员的延迟初始化，并只初始化一次。和static的作用很像，都要求是线程安全的，c++11之前在多线程的环境下，static好像不是线程安全的，c++11开始，static是线程安全的了。注意：即使某一个特定的线程里，多次调用了std::call_once，实际的效果是std::call_once里的函数也只被执行一次。例子：模仿建立数据库的连接，只有在放生send_data或者receive_data的时候，才去连接数据...

linux c++ 多线程【五】【代码】【图】

看完了APUE第三版的Chapter11 Threads，跟着书上的demo走了一遍，并且参考了这个blog（http://www.cnblogs.com/chuyuhuashi/p/4447817.html）的非常好的example。下面的内容就是看书过程中记录的，可以作为一个参考，但决不能代替看APUE原著。本来想在自己的mac上跑（毕竟也叫unix系统），后来发现mac上有些pthread的库支持的不全（比如，没有barrier），就改到了centos server上跑。（一）Thread Identification　　1. 线程的id只...

c++多线程参数的传递【代码】

#include <iostream> #include <pthread.h> //多线程相关操作头文件，可移植众多平台usingnamespace std;struct mypara { int para1; //参数1 char *para2; //参数2 pthread_t wait; };void* thread1( void* args ) //本函数演示的是数据的传出{mypara *my = (mypara *)args;srand(unsigned(time(0)));my->para1 = rand()%100;my->para2 = "。";cout << "给结构体赋值结束"<< endl;return...

http线程池的设计与实现（c++）

http线程池的主要用途是异步处理使用无状态短连接的http请求，在传输层通信基于tcp协议和应用层基于http协议的基础上，达到c++服务器与web服务器通信的目的。设计上：（1）服务器启动时，初始化配置数量的线程（形成被动连接线程池）。每个线程会生成epoll描述符。（2）主线程生成监听socket，绑定端口。生成epoll描述符，注册监听socket，非阻塞接收（限定最大时间，如2s）新连接到连接队列。（2）投放主线程连接队列中的新连接到...

Linux c++ 线程【代码】【图】

目录1. 线程与进程线程的概念深入理解进程和线程2. 多线程什么是多线程多线程模型的好处3. 线程标识4. 线程创建函数原型参数说明使用示例-打印线程ID5. 线程终止6. 线程等待函数原型参数说明使用示例-获得线程返回值7. 线程分离pthread_detach以分离状态创建线程8. 线程取消pthread_cancel线程取消属性取消点自定义取消点使用线程取消的风险线程清理程序1. 线程与进程线程的概念线程是进程内相对独立的一个执行流，是进程内的一个执...

C++ 线程池【代码】

C++ 线程池基于C++11语法实现的简易线程池：/*** 线程池（C++简单实现）* @file: ThreadPool.h* @author: rancheng <rc4work@163.com>* @date: 2020-11-23*/ #pragma once#include <vector> #include <queue> #include <memory> #include <utility> #include <thread> #include <mutex> #include <condition_variable> #include <functional>namespace dev {class ThreadPool { public:using SP = std::shared_ptr<ThreadPool>;// ...

C++ - 技术教程分类

C++ 教程 C++ 简介 C++ 基本语法 C++ 注释 C++ 数据类型 C++ 变量类型 C++ 变量作用域 C++ 常量 C++ 修饰符类型 C++ 存储类 C++ 运算符 C++ 循环 C++ 判断 C++ 函数 C++ 数字 C++ 数组 C++ 字符串 C++ 指针 C++ 引用 C++ 日期 & 时间 C++ 基本的输入输出 C++ 数据结构 C++ 类 & 对象 C++ 继承 C++ 重载运算符和重载函数 C++ 多态 C++ 数据抽象 C++ 数据封装 C++ 接口（抽象类） C++ 文件和流 C++ 异常处理 C++ 动态内存 C++ 命名空间 C++ 模板 C++ 预处理器 C++ 信号处理 C++ 多线程 C++ Web 编程 C++ 标准库 C++ 有用的资源 C++ 实例 c++ 全部

C++ - 最热教程

C++通过共享内存实现进程间通信（windo...C++基于EasyX制作贪吃蛇游戏（一）文档 C++中的分治算法及常见题目汇总【C++】stringstream的str() 和 string...c++中内置函数qsort（快速排序）和bsea...VS2019 C++创建一个简单项目demo [C++]VS2015用动态链接(MD/MDd)方式编译...C/C++编程学习 - 第15周 ⑥ 药房管理万维考试系统检测不到VC++ 6.0环境解决...C/C++ QT自定义对话框与MID窗体

首页 / C++ / Linux c++ 线程

Linux c++ 线程

内容导读

内容图文

1. 线程与进程

线程的概念

深入理解进程和线程

2. 多线程

什么是多线程

多线程模型的好处

3. 线程标识

4. 线程创建

函数原型

参数说明

使用示例-打印线程ID

5. 线程终止

6. 线程等待

函数原型

参数说明

使用示例-获得线程返回值

7. 线程分离

pthread_detach

以分离状态创建线程

8. 线程取消

pthread_cancel

线程取消属性

取消点

自定义取消点

使用线程取消的风险

线程清理程序

内容总结

内容备注

内容手机端

【Linux c++ 线程】教程文章相关的互联网学习教程文章

线程 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程