当前位置：文档之家 › 多核程序设计Linux多线程编程

多核程序设计Linux多线程编程

  • 格式：ppt
  • 大小：1.30 MB
  • 文档页数：28

下载文档原格式

  / 28

合集下载

关于Linux多线程编程

关于Linux多线程编程

关于Linux多线程编程Linux线程分为两类，一是核心级支持线程，在核心级实现线程时，线程的实现依赖于内核，无论是在用户进程中的线程还是系统进程中的线程，他们的创建、撤消、切换都由内核实现。

核心只有单线程进程概念，而多线程进程由与应用程序连接的过程库实现。

另一类线程是用户级线程，在Linux众多的线程库中，大部分实现的是用户级线程。

系统创建线程的顺序如下：当一个线程启动后，它会自动创建一个线程即主线程（main thread)或者初始化线程(initial thread)，然后就利用pthread_initialize()初始化系统管理线程并且启动线程机制。

Linux线程编程基础要创建一个多线程程序，必须加载pthread.h头文件。

要掌握多线程编程常用的几个函数：1、创建新线程函数：pthread_create()2、挂起当前线程函数：pthread_join()3、线程注册的清除处理函数：pthread_exit()4、取消一个线程函数：pthread_cancel()5、挂起当前线程，直到满足某种条件：pthread_cond_init多线程的同步1、互斥锁互斥锁用来保证一段时间内只有一个线程在执行一段代码。

当在同一内存空间运行多个线程时，为保证多个线程之间不相互破坏，要创建互斥量，如果一个线程已经锁定一个互斥量，第二个线程又试图去锁定这个互斥量，则第二个线程被挂起（不占用任何CPU资源），直到第一个线程解除对这个互斥量的锁定为止。

第二个线程将被唤醒并继续执行，同时锁定这个互斥量。

创建互斥量时，必须首先声明一个类型为pthread_mutex_t的变量，然后对其进行初始化，结构pthread_mutex_t为不公开的数据类型，其中包含一个系统分配的属性对象。

函数pthread_mutex_init用来生成一个互斥锁。

锁定一个互斥量时使用函数pthread_mutex_lock()，它尝试锁定一个互斥量，如果该互斥量已经被其它线程锁定，该函数就把调用自己的线程挂起，一旦该互斥量解锁，它将恢复运行并锁定该互斥量。

linux c++ 多线程编程实例

linux c++ 多线程编程实例

linux c++ 多线程编程实例在 Linux 系统上，C++ 多线程编程通常使用 <thread> 头文件中提供的标准C++ 线程库。

下面是一个简单的C++ 多线程编程实例，演示了如何使用标准库创建和管理线程：#include <iostream>#include <thread>#include <vector>// 函数，将在多个线程中执行void printHello(int id) {std::cout << "Hello from thread " << id << std::endl;}int main() {// 定义线程数量const int numThreads = 5;// 创建一个线程数组std::vector<std::thread> threads;// 启动多个线程for (int i = 0; i < numThreads; ++i) {// 使用 Lambda 表达式作为线程函数threads.push_back(std::thread([i] {printHello(i);}));}// 等待所有线程执行完毕for (auto& thread : threads) {thread.join();}std::cout << "All threads joined!" << std::endl;return 0;}在这个例子中，我们创建了一个包含 5 个线程的线程数组。

每个线程通过Lambda 表达式调用printHello 函数，并传递一个标识符作为参数。

printHello 函数简单地在控制台输出一条消息，指示线程的标识符。

要编译这个程序，你可以使用类似以下的命令：g++ -std=c++11 -pthread filename.cpp -o output其中，-std=c++11 是用于启用C++11 标准的选项，-pthread 是用于启用 POSIX 线程库的选项。

多核软件开发技术第五讲Linux多线程编程及调优(精)

多核软件开发技术第五讲Linux多线程编程及调优(精)

线程和信号处理
• #include <signal.h> • int pthread_sigmask(int how, const sigset_t
*newmask, sigset_t *oldmask); • int pthread_kill(pthread_t thread, int signo); • int sigwait(const sigset_t *set, int *sig);
线程的撤销
• int pthread_setcancelstate(int state, int *oldstate)
• int pthread_setcanceltype(int type, int *oldtype) • void pthread_testcancel(void);
POSIX 信号量
• int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
• int pthread_mutex_lock(pthread_mutex_t *mutex); • int pthread_mutex_trylock(pthread_mutex_t *mutex); • int pthread_mutex_unlock(pthread_mutex_t *mutex); • int pthread_mutex_destroy(pthread_mutex_t *mutex);
为选择被创建的线程调度竞争范围。
线程互斥和同步
mutex
• Mutex：互斥设备(MUTual Exclusion device) • mutex有如下特性：

Linux内核多线程实现方法

Linux内核多线程实现方法

Linux内核多线程实现⽅法 —— kthread_create函数内核经常需要在后台执⾏⼀些操作，这种任务就可以通过内核线程（kernle thread）完成独⽴运⾏在内核空间的标准进程。

内核线程和普通的进程间的区别在于内核线程没有独⽴的地址空间，mm指针被设置为NULL；它只在内核空间运⾏，从来不切换到⽤户空间去；并且和普通进程⼀样，可以被调度，也可以被抢占。

实际上，内核线程只能由其他内核线程创在现有的内核线程中创建⼀个新的内核线程的⽅法：建，在现有的内核线程中创建⼀个新的内核线程的⽅法：kthread_create：创建线程。

struct task_struct *kthread_create(int (*threadfn)(void *data),void *data,const char *namefmt, ...); //注意，第⼆个参数data⽤于向线程传递参数线程创建后，不会马上运⾏，⽽是需要将kthread_create() 返回的task_struct指针传给wake_up_process()，然后通过此函数运⾏线程。

kthread_run ：创建并启动线程的函数，相当于kthread_create + wake_up_process功能;struct task_struct *kthread_run(int (*threadfn)(void *data),void *data,const char *namefmt, ...);kthread_stop：通过发送信号给线程，使之退出。

会⼀直运⾏，除⾮该线程主动调⽤do_exit函数，或者其int kthread_stop(struct task_struct *thread); 线程⼀旦启动起来后，会⼀直运⾏他的进程调⽤kthread_stop函数，结束线程的运⾏。

但如果线程函数正在处理⼀个⾮常重要的任务，它不会被中断的。

当然如果线程函数永远不返回并且不检查信号，它将永远都不会停⽌，因此，线程函数必须能让出CPU，以便能运⾏其他线程。

linux多线程编程

linux多线程编程

2.终止线程 (2)3. 等待线程终止 (2)pthread_exit和pthread_join进一步说明： (3)4.分离线程 (7)5.获取线程标识符 (8)6.比较线程ID (8)7.一次性初始化 (8)8. 设置线程的调度策略和优先级 (9)9. 获取线程的优先级 (11)10.取消线程 (12)取消线程，是否会释放线程的所有资源？例子： (14)设置取消类型 (16)11.初始化属性 (17)12.设置分离状态 (18)13.设置范围 (18)14. 设置继承的调度策略 (18)16. 设置调度参数 (19)17.初始化互斥锁 (21)18.销毁互斥锁 (21)19.锁定互斥锁 (22)20.解除锁定互斥锁 (23)21. 互斥锁的类型： (23)22. 初始化互斥锁属性对象 (23)23. 销毁互斥锁属性对象 (23)24.设置互斥锁类型的属性 (24)互斥锁动态初始化和静态初始化区别： (26)销毁互斥锁：事实上没做任何销毁操作，如下： (27)非递归类型的互斥锁解锁和加锁操作： (27)29.初始化条件变量 (27)30.基于条件变量阻塞 (27)31.解除阻塞一个线程 (28)31.解除阻塞所有线程 (29)33. 在指定的时间之前阻塞 (30)32.唤醒丢失问题 (31)33. 计数信号量概述 (31)34. 初始化信号 (31)35. 增加信号 (31)36. 基于信号计数进行阻塞 (32)37.多线程链表添加删除例子（使用条件变量实现互斥）： (32)38.为线程特定数据创建键 (34)39. 删除线程特定数据键 (35)40.设置线程特定数据 (35)41. 获取线程特定数据 (35)销毁读写锁属性对象： (36)设置读写锁共享属性： (37)初始化读写锁： (37)销毁读写锁： (37)读写锁总结： (39)获得写锁： (39)获得读锁： (40)1.创建缺省线程int pthread_create(pthread_t *tid, cons、劈劈啪啪劈劈啪啪破婆婆t pthread_attr_t *tattr,void*(*start_routine)(void *), void *arg);参数：当pthread_create() 成功时，所创建线程的ID 被存储在由tid 指向的位置中。

多线程编程之：Linux线程编程

多线程编程之：Linux线程编程

多线程编程之：Linux线程编程9.2 线程编程9.2.1 线程基本编程这里要讲的线程相关操作都是用户空间中的线程的操作。

在Linux中，普通pthread线程库是一套通用的线程库，是由POSIX提出的，因此具有很好的可移植性。

(1)函数解释。

创建线程事实上就是确定调用该线程函数的入口点，这里通常用法的函数是pthread_create()。

在线程创建以后，就开头运行相关的线程函数，在该函数运行完之后，该线程也就退出了，这也是线程退出一种办法。

另一种退出线程的办法是用法函数pthread_exit()，这是线程的主动行为。

这里要注重的是，在用法线程函数时，不能任意用法exit()退出函数举行出错处理，因为exit()的作用是使调用进程终止，往往一个进程包含多个线程，因此，在用法exit()之后，该进程中的全部线程都终止了。

因此，在线程中就可以用法pthread_exit()来代替进程中的exit()。

因为一个进程中的多个线程是分享数据段的，因此通常在线程退出之后，退出线程所占用的资源并不会随着线程的终止而得到释放。

正如进程之间可以用wait()系统调用来同步终止并释放资源一样，线程之间也有类似机制，那就是pthread_join()函数。

pthread_join()可以用于将当前线程挂起来等待线程的结束。

这个函数是一个线程堵塞的函数，调用它的函数将向来等待到被等待的线程结束为止，当函数返回时，被等待线程的资源就被收回。

前面已提到线程调用pthread_exit()函数主动终止自身线程。

但是在无数线程应用中，常常会碰到在别的线程中要终止另一个线程的执行的问题。

此时调用pthread_cancel()函数实现这种功能，但在被取消的线程的内部需要调用pthread_setcancel()函数和pthread_setcanceltype()函数设置自己的取消状态，例如被取消的线第1页共9页。

linux c++ 多线程编程实例

linux c++ 多线程编程实例多线程编程是指在一个程序中同时运行多个线程，每个线程执行不同的任务，可以充分利用多核处理器的优势，提高程序的性能和响应能力。

在Linux环境下，可以使用C++进行多线程编程，下面是一个实例，展示了如何使用C++多线程进行并发处理。

```cpp#include <iostream>#include <thread>// 模拟一个需耗时的计算任务void calculate(int id){std::cout << "Thread " << id << ": starting calculation." << std::endl;// 模拟计算任务for (int i = 0; i < 1000000000; i++) {double result = i * i;}std::cout << "Thread " << id << ": calculation completed." << std::endl;}int main(){const int numThreads = 4; // 定义线程数量std::thread threads[numThreads];// 创建并启动线程for (int i = 0; i < numThreads; i++) {threads[i] = std::thread(calculate, i+1);}// 等待所有线程执行完毕for (int i = 0; i < numThreads; i++) {threads[i].join();}std::cout << "All threads completed." << std::endl;return 0;}```上述示例中，我们首先定义了一个calculate函数，模拟了一个耗时的计算任务。

linux多线程编程


∗ 这些属性可以通过其他函数来获取和设置
线程属性
∗ 取消选项--∗ 可取消状态 ∗ int pthread_setcancelstate(int state, int *oldstate);
∗ PTHREAD_CANCEL_ENABLE 允许（默认） ∗ PTHREAD_CANCEL_DISABLE 禁止
∗ int pthread_attr_getdetachstate(const pthread_attr_t *restarict attr, int *detachstate); 默认是 PTHREAD_CREATE_JOINABLE
∗ 2、线程栈末尾的警戒缓冲区大小
∗ pthread_attr_getguardsize 3、线程栈的最低地址
进程原语和线程原语的比较
进程原语 fork exit waitpid atexit getpid abort 线程原语 pthread_create pthread_exit pthread_join pthread_cancel_push pthread_self pthread_cancel 描述 创建新的控制流 从现有控制流中退出 从控制流退出中获得状态 注册在退出控制流时调用的函数 获取控制流的ID 请求控制流的非正常退出
线程创建
∗ 获取线程标识pthread_t
int pthread_equal (pthread_t t1, pthread_t t2); 比较两线程id是否相同，不能直接用==，因为不同操 作系统下， pthread_t 的实现不同。Linux是无符号长整型，solaris 是无符号整数，FreeBSD和Mac是指向pthread结构的指针。 pthread_t pthread_self(void); 获得自身线程id 注意：linux中使用进程实现线程，所以新创建的线程和源线程进 程号可能不同

多核程序设计Linux多线程编程PPT教学课件


int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex); 初始化mutex
2020/12/10
8
POSIX 线程库对mutex提供了以下函数进行操作：
int pthread_mutex_init(pthread_mutex_t *mutex, const
pthread_mutexattr_t *mutexattr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
2020/12/10
9
线程使用mutex的简单代码如下：
pthread_mutex_t mylock; mylock= PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&mylock); /*………….*/ pthread_mutex_unlock(&mylock);
4
2020/12/10
5
2020/12/10
6
线程互斥和同步——Mutex
原子性。对mutex的加锁和解锁操作是原子的，一个 线程进行 mutex 操作的过程中，其他线程不能对同 一个 mutex 进行其他操作。
单一性。拥有mutex的线程除非释放mutex，否则其 他线程不能拥有此mutex。
void pthread_exit (void* retval);
• 除了pthread_exit() 函数，可以让当前调用pthread_exit() 的 线程显示地退出外，线程也可以使用 pthread_cancel() 函数 终止其他线程的执行。

Linux 多线程编程


线程的优点
除了以上所说的优点外，多线程程序作为一种多 任务、并发的工作方式，有如下优点： 使多CPU系统更加有效.操作系统会保证当线程 数丌大于CPU数目时，丌同的线程运行于丌同的 CPU上. 改善程序结构.一个既长又复杂的进程可以考虑分 为多个线程，成为几个独立戒半独立的运行部分， 这样的程序会利于理解和修改.
互斥量
对于这种情况，系统给我们提供了互斥 量.线程 在取出头节点前必须要等待互斥量,如果此时有其 他线程已经获得该互斥量,那么该线程将会阻塞在 这里.只有等到其他线程释放掉该互斥量后，该线 程才有可能得到该互斥量。互斥量从本质上说就 是一把锁, 提供对共享资源的保护访问
创建
在Linux中, 互斥量使用类型pthread_mutex_t表 示.在使用前, 要对它进行初始化: 对于静态分配的互斥量, 可以把它设置为默认的 mutex对象PTHREAD_MUTEX_INITIALIZER 对于劢态分配的互斥量, 在申请内存(malloc)之 后, 通过pthread_mutex_init进行初始化, 并且 在释放内存(free)前需要调用 pthread_mutex_destroy
Item * p =queue_list; Queue_list=queue_list->next; process_job(p); free(p);
当线程1处理完Item *p=queue_list后，系统停 止线程1的运行，改而运行线程2。线程2照样取 出头节点，然后进行处理，最后释放了该节点。 过了段时间，线程1重新得到运行。而这个时候， p所指向的节点已经被线程2释放掉，而线程1对 此毫无知晓。他会接着运行process_job(p)。而 这将导致无法预料的后果！
加锁
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。