3.1线程概述
Linux线程是进程资源共享的一种方式，而其他操作系统，线程则是一种实现轻量、快速执行单元的抽象概念或者实体。
对于Linux操作系统而言，它对Thread的实现方式比较特殊。在Linux内核中，其实是没有线程的概念的，它把所有的线程当做标准的进程来实现，也就是说Linux内核，并没有为线程提供任何特殊的调度语义，也没有为线程实现特定的数据结构。取而代之的是，线程只是一个与其他进程共享某些资源的进程。每一个线程拥有一个唯一的task_struct结构，Linux内核它仅仅把线程当做一个正常的进程，或者说是轻量级进程，LWP(Lightweight processes)
线程的概念
线程（英語：thread）是操作系统能运算调度的最小单位。 大部分情况下，它被包含在进程之中，是进程中的实际运作单位。 一条线程指的是进程中一个单一顺序的控制流，一個进程中可以并行多個线程，每条线程并行执行不同的任务。
线程与进程的区别
- 进程拥有一个完整的资源平台，而线程只独享必不可少的资源，如寄存器和栈
- 线程系统开销小,启动速度快,轻量级,能减少并发执行的时间和空间的开销
- 进程是资源分配的单位,线程是CPU调度的单位
线程相较于进程的节省在哪呢
- 共享
- 线程终止时间比进程快,释放的资源少(栈) 独有的
- 同一进程内线程切换速度快于进程,因为线程共享虚拟内存,共享同一个页表,因此在切换线程时不用切换页表
- 线程之间进行数据传递不需要经过内核了,因此线程之间数据交换效率变高了
3.2创建线程 create
一般情况下,main函数所在的线程我们称之为主线程（main线程），其余创建的线程
称之为子线程。
程序中默认只有一个进程，fork()函数调用，2进行
程序中默认只有一个线程，pthread_create()函数调用，2个线程。
#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 : 给第三个参数使用，传参
- 返回值：
成功：0
失败：返回错误号。这个错误号和之前errno不太一样。
获取错误号的信息： char * strerror(int errnum);
3.3终止进程
#include <pthread.h>
void pthread_exit(void *retval);
功能：终止一个线程，在哪个线程中调用，就表示终止哪个线程
参数：
retval:需要传递一个指针，作为一个返回值，可以在pthread_join()中获取到。
pthread_t pthread_self(void);
功能：获取当前的线程的线程ID
int pthread_equal(pthread_t t1, pthread_t t2);
功能：比较两个线程ID是否相等
不同的操作系统，pthread_t类型的实现不一样，有的是无符号的长整型，有的
是使用结构体去实现的。
3.4连接已经终止的线程_Join
#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
- 功能: 和一个已经终止的线程进行连接
回收子线程的资源
这个函数是阻塞函数，调用一次只能回收一个子线程
一般在主线程中使用
- 参数：
- thread：需要回收的子线程的ID
- retval: 接收子线程退出时的返回值
- 返回值：
0 : 成功
非0 : 失败，返回的错误号
3.5线程的分离 detach
#include <pthread.h>
int pthread_detach(pthread_t thread);
- 功能：分离一个线程。被分离的线程在终止的时候，会自动释放资源返回给系统。
1.不能多次分离，会产生不可预料的行为。
2.不能去连接一个已经分离的线程，会报错。
- 参数：需要分离的线程的ID
- 返回值：
成功：0
失败：返回错误号
3.6线程取消
线程取消需要有线程取消点
#include <pthread.h>
int pthread_cancel(pthread_t thread);
- 功能：取消线程（让线程终止）
取消某个线程，可以终止某个线程的运行，
但是并不是立马终止，而是当子线程执行到一个取消点，线程才会终止。
取消点：系统规定好的一些系统调用，我们可以粗略的理解为从用户区到内核区的切换，这个位置称之为取消点。
设置线程是否可以被取消
#include <pthread.h>
int pthread_setcancalstate(int state, int *oldstate);
- 功能 : 设置线程是否可以被取消
- 参数 :
- state:设置是否可以被取消
- PTHREAD_CANCEL_ENABLE : 允许线程被取消,也是线程被创建的默认状态
- PTHREAD_CANCEL_DISABLE: 禁止线程被取消
- oldstate:传出参数,获取旧的状态
设置如何取消
#include <pthread.h>
int pthread_setcanceltype(int type, int *oldtype);
- 功能:设置目标线程如何被取消
- 参数 :
- type : 设置如何取消
- PTHREAD_CANCEL_ASYNCHRONOUS : 线程可以随时被取消
- PTHREAD_CANCEL_DEFERRED : 直到调用了所谓的取消点函数中的一个,才允许取消
pthread_join pthread_testcancel ...
3.7线程的属性
pthread_attr_t结构体定义了一套完整的线程属性,各种属性都被定义在一个字符数组,线程库定义了一系列函数来操作pthread_attr_t类型变量
union pthread_attr_t
{
char __size[__SIZEOF_PTHREAD_ATTR_T];
long int __align;
};
线程库提供的函数
int pthread_attr_init(pthread_attr_t *attr);
- 初始化线程属性变量
int pthread_attr_destroy(pthread_attr_t *attr);
- 释放线程属性变量的资源,被销毁后只有再次初始化才能使用
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
- 获取线程分离的状态属性
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
- 设置线程分离的状态属性
线程的属性
- detachstate : 线程的脱离状态,有PTHREAD_CREATE_JOINABLE和PTHREAD_CREATE_DETACH可选,前者指定线程可以被回收,后者指指定线程脱离与进程中其他进程同步
- stackaddr,stacksize : 线程堆栈的起始地址和大小,Linux默认大小为8MB,可以通过
ulimit -s查看或修改这么默认值 - guardsize : 保护区域大小,如果使用pthread_attr_setstackaddr或者pthread_attr_setstacksize 去设置堆栈,则该属性会被忽略
- schedparam : 线程调度参数,类型为sched_param结构体,结构体只有一个整型的成员sched_priority,该成员表示线程运行的优先级
- schedpolicy : 线程调度策略,有三个值可选
- inheritsched : 是否继承调用线程的调度属性
- scope : 线程间竞争CPU的范围
3.8线程同步
- 线程的主要优势在于，能够通过全局变量来共享信息。不过，这种便捷的共享是有代价的：必须确保多个线程不会同时修改同一变量，或者某一线程不会读取正在由其他线程 修改的变量。
- 临界区是指访问某一共享资源的代码片段，并且这段代码的执行应为原子操作，也就是同时访问同一共享资源的其他线程不应终端该片段的执行。
- 线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进 行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作，而其他线程则处 于等待状态
3.9互斥锁
互斥量
- 为避免线程更新共享变量时出现问题，可以使用互斥量（mutex 是 mutual exclusion 的缩写）来确保同时仅有一个线程可以访问某项共享资源。可以使用互斥量来保证对任意共享资源的原子访问。
- 互斥量有两种状态：已锁定（locked）和未锁定（unlocked）。任何时候，至多只有一 个线程可以锁定该互斥量。试图对已经锁定的某一互斥量再次加锁，将可能阻塞线程或者报 错失败，具体取决于加锁时使用的方法。
- 一旦线程锁定互斥量，随即成为该互斥量的所有者，只有所有者才能给互斥量解锁。一般情 况下，对每一共享资源（可能由多个相关变量组成）会使用不同的互斥量，每一线程在访问 同一资源时将采用如下协议：
1. 针对共享资源锁定互斥量
2. 访问共享资源
3. 对互斥量解锁 - 如果多个线程试图执行这一块代码（一个临界区），事实上只有一个线程能够持有该互斥 量（其他线程将遭到阻塞），即同时只有一个线程能够进入这段代码区域，如下图所示
基本api
互斥量的类型 pthread_mutex_t
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
- 初始化互斥量
- 参数 ：
- mutex ： 需要初始化的互斥量变量
- attr ： 互斥量相关的属性，NULL
- restrict : C语言的修饰符，被修饰的指针，不能由另外的一个指针进行操作。
pthread_mutex_t *restrict mutex = xxx;
pthread_mutex_t * mutex1 = mutex;
int pthread_mutex_destroy(pthread_mutex_t *mutex);
- 释放互斥量的资源
int pthread_mutex_lock(pthread_mutex_t *mutex);
- 加锁，阻塞的，如果有一个线程加锁了，那么其他的线程只能阻塞等待
int pthread_mutex_trylock(pthread_mutex_t *mutex);
- 尝试加锁，如果加锁失败，不会阻塞，会直接返回,就是lock的非阻塞版本
int pthread_mutex_unlock(pthread_mutex_t *mutex);
- 解锁
互斥锁属性
pshared
pshared指定是否允许跨进程共享互斥锁
- PTHREAD_PROCESS_SHARED : 互斥锁可以跨进程共享
- PTHREAD_PROCESS_PRIVATE : 互斥锁只能被初始化锁的线程隶属于同一进程的线程共享
type
互斥锁属性type指定互斥锁的类型
- PTHREAD_MUTEX_NORMAL : 互斥锁的默认类型,这种锁保证了资源的公平性,重复加锁解锁或者对其他线程持有的锁都会引起严重错误
- PTHREAD_MUTEX_ERRORCHECK : 检错锁,当重复加锁返回EDEADLK,重复解锁或对别的线程已经加锁的检错锁解锁返回EPERM
- PTHREAD_MUTEX_RECURSIVE : 嵌套锁,可以多次加锁,但也需要解锁对应次数,同样有如上错误同样会返回EPERM
- PTHREAD_MUTEX_DEAULT : 默认锁,和普通锁错误产生方式一样,但在实现中会被映射为上面三种锁之一
基本api
初始化互斥锁对象
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
销毁互斥锁属性
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
获取和设置互斥锁属性
int pthread_mutexattr_getshared(const pthread_mutexattr_t *attr, int *pshared);
int pthread_mutexattr_aetshared(pthread_mutexattr_t *attr, int pshared);
获取和设置互斥锁的type属性
int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
3.10 死锁
- 有时,一个线程运行需要多组共享资源,当超过一个线程加锁同一组互斥量情况就会产生死锁
- 两个或以上的线程在运行时,因互相抢夺共享资源而造成的一种互相等待的现象,若无外力作用,将无法进行下去,此时称系统处在死锁状态
- 死锁的几种场景
1.忘记释放锁
2.重复加锁
3.多线程多锁,抢占资源
3.11 读写锁
如果一个线程已经持有了互斥锁,那么就会排斥其他试图进入临界区的线程,但思考一个问题,如果只读共享资源的话是不是不会出现问题呢,由此,设计出了读写锁,当读操作比较多的话可以考虑使用
读写锁特点
- 如果有其他线程读数据,则允许执行读操作,不允许执行写操作
- 写是独占的,优先级高
// 读写锁基本操作函数
读写锁的类型 pthread_rwlock_t
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
3.12生产者和消费者模型
3.13条件变量
作用就是当某个条件满足时阻塞,满足某个条件时解除阻塞
条件变量的类型 pthread_cond_t
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
- 等待，调用了该函数，线程会阻塞。
- 调用前一定要保证mutex已经加锁
- 执行时先将调用线程放进条件变量的等待队列中,然后将mutex解锁,当成功返回时会将mutex重新上锁
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
- 等待多长时间，调用了这个函数，线程会阻塞，直到指定的时间结束。
int pthread_cond_signal(pthread_cond_t *cond);
- 唤醒一个或者多个等待的线程
int pthread_cond_broadcast(pthread_cond_t *cond);
- 唤醒所有的等待的线程
生产者,消费者模型的代码实现
/*
生产者消费者模型（粗略的版本）
*/
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
// 创建一个互斥量
pthread_mutex_t mutex;
struct Node
{
int num;
struct Node *next;
};
// 头结点
struct Node *head = NULL;
pthread_cond_t cond;
void *producer(void *arg)
{
// 不断的创建新的节点，添加到链表中
while (1)
{
pthread_mutex_lock(&mutex);
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->next = head;
head = newNode;
newNode->num = rand() % 1000;
printf("add node, num : %d, tid : %ld\n", newNode->num, pthread_self());
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
usleep(100);
}
return NULL;
}
void *customer(void *arg)
{
while (1)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
// 保存头结点的指针
struct Node *tmp = head;
// 有数据
head = head->next;
printf("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
free(tmp);
pthread_mutex_unlock(&mutex);
usleep(100);
// 等待
}
return NULL;
}
int main()
{
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
// 创建5个生产者线程，和5个消费者线程
pthread_t ptids[5], ctids[5];
for (int i = 0; i < 5; i++)
{
pthread_create(&ptids[i], NULL, producer, NULL);
pthread_create(&ctids[i], NULL, customer, NULL);
}
for (int i = 0; i < 5; i++)
{
pthread_join(ptids[i] ,NULL);
pthread_join(ctids[i], NULL);
}
pthread_cond_destroy(&cond);
pthread_mutex_destroy(&mutex);
pthread_exit(NULL);
return 0;
}
3.14 信号量
信号量的类型 sem_t
int sem_init(sem_t *sem, int pshared, unsigned int value);
- 初始化信号量
- 参数：
- sem : 信号量变量的地址
- pshared : 0 用在线程间 ，非0 用在进程间
- value : 信号量中的值
int sem_destroy(sem_t *sem);
- 释放资源
int sem_wait(sem_t *sem);
- 对信号量加锁，调用一次对信号量的值-1，如果值为0，就阻塞
- 在下面实现中,锁之前调用,阻塞,这样就不会产生死锁
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
int sem_post(sem_t *sem);
- 对信号量解锁，调用一次对信号量的值+1
int sem_getvalue(sem_t *sem, int *sval);
生产者,消费者用信号量进行实现
/*
生产者消费者模型（粗略的版本）
*/
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
// 创建一个互斥量
pthread_mutex_t mutex;
sem_t producer,consumer;
struct Node
{
int num;
struct Node *next;
};
// 头结点
struct Node *head = NULL;
void *Producer(void *arg)
{
// 不断的创建新的节点，添加到链表中
while (1){
sem_wait(&producer);
pthread_mutex_lock(&mutex);
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->next = head;
head = newNode;
newNode->num = rand() % 1000;
printf("add node, num : %d, tid : %ld\n", newNode->num, pthread_self());
pthread_mutex_unlock(&mutex);
sem_post(&consumer);
usleep(100);
}
return NULL;
}
void *Customer(void *arg)
{
while (1)
{
sem_wait(&consumer);
pthread_mutex_lock(&mutex);
// 保存头结点的指针
struct Node *tmp = head;
// 有数据
head = head->next;
printf("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
free(tmp);
pthread_mutex_unlock(&mutex);
sem_post(&producer);
usleep(100);
// 等待
}
return NULL;
}
int main()
{
pthread_mutex_init(&mutex, NULL);
sem_init(&consumer, 0, 0);
sem_init(&producer, 0, 8);
// 创建5个生产者线程，和5个消费者线程
pthread_t ptids[5], ctids[5];
for (int i = 0; i < 5; i++)
{
pthread_create(&ptids[i], NULL, Producer, NULL);
pthread_create(&ctids[i], NULL, Customer, NULL);
}
for (int i = 0; i < 5; i++)
{
pthread_join(ptids[i] ,NULL);
pthread_join(ctids[i], NULL);
}
pthread_mutex_destroy(&mutex);
pthread_exit(NULL);
return 0;
}
