目录
一丶概念
线程是一个轻量级的进程，为了提高系统的性能引入线程。
线程和进程是参与统一的调度。
在同一个进程中可以创建的多个线程, 共享进程资源。
(Linux里同样用task_struct来描述一个线程）
二丶进程和线程的区别
相同点：
都为系统提供了并发执行的能力
不同点：
调度和资源：线程是系统调度的最小单位，进程是资源分配的最小单位
地址空间方面：同一进程创建的多个线程共享该进程的资源，进程的地址空间相互独立
通信方面：线程间的相互通信较为简单，只需要借助全局变量实现，需要注意临界资源的问题，进程通信较为复杂，需要借助进程间共同拥有的1g的内核空间
安全性：线程安全性较差，一旦进程退出，所有的线程都会退出，进程相对安全
程序什么时候该使用线程？什么时候用进程？
对资源的管理和保护要求高，不限制开销和效率时，使用多进程。
要求效率高、速度快的高并发环境时，需要频繁创建、销毁或切换时，资源的保护管理要求不是很高时，使用多线程。
三丶资源
共享的资源：可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户ID、用户组ID
私有的资源：线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈(局部变量, 返回地址)、错误号 (errno)、信号掩码和优先级、执行状态和属性
四丶函数接口
1.创建线程 pthread_create
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
功能：创建线程
参数： thread：线程标识
attr：线程属性， NULL：代表设置默认属性
start_routine：函数名：代表线程函数（自己写的）
arg：用来给前面函数传参
返回值：成功：0
失败：错误码
编译的时候需要加 -pthread 链接动态库
2.退出线程 pthread_exit
void pthread_exit(void *value_ptr)
功能：用于退出线程的执行
参数：value_ptr：线程退出时返回的值
3.获取线程ID p_thread self
pthread_t pthread_self(void);
功能：获取线程号
返回值：线程ID
4.回收线程资源
int pthread_join(pthread_t thread, void **value_ptr)
功能：用于等待一个指定的线程结束，阻塞函数
参数：thread：创建的线程对象,线程ID
value_ptr：指针*value_ptr 用于指向线程返回的参数， 一般为NULL
返回值：成功 ： 0
失败：errno
int pthread_detach(pthread_t thread);
功能：让线程结束时自动回收线程资源,让线程和主线程分离,非阻塞函数
参数：thread：线程ID
非阻塞式的，例如主线程分离(detach)了线程T2，那么主线程不会阻塞在pthread_detach()，pthread_detach()会直接返回，线程T2终止后会被操作系统自动回收资源
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *handler_thread(void *arg)
{
printf("in handler_thread\n");
sleep(2);
pthread_exit(NULL); //退出当前线程
while (1)
; //不让线程退出
return NULL;
}
int main(int argc, char const *argv[])
{
pthread_t tid;
if (pthread_create(&tid, NULL, handler_thread, NULL) != 0) //创建线程
{
perror("phtread err");
return -1;
}
// pthread_join(tid, NULL); //阻塞等待指定的线程结束然后给其回收资源
pthread_detach(tid); //不阻塞，让指定线程结束时自动回收资源
printf("in main\n");
while (1)
; //让主线程不要结束
return 0;
}
练习：主线程循环从终端输入字符串，子线程循环将字符串打印至终端，当输入"quit"时结束
#include <stdio.h>
#include <pthread.h>
#include <string.h>
char buf[32];
int flag = 0; // 为了进行线程间通讯，保证主线程先输入然后子线程再输出
void *handler(void *arg)
{
while (1)
{
if (flag == 1)
{
if (strcmp(buf, "quit") == 0)
{
break;
}
// puts(buf);
printf("%s\n", buf); // \n刷新缓存
flag = 0;
}
}
return NULL;
}
int main(int argc, char const *argv[])
{
pthread_t tid;
if (pthread_create(&tid, NULL, handler, NULL) != 0)
{
perror("create err");
return -1;
}
while (1)
{
if (flag == 0)
{
scanf(" %s", buf);
flag = 1;
if (strcmp(buf, "quit") == 0)
{
break;
}
}
}
pthread_join(tid, NULL);
return 0;
}五丶线程同步
5.1 概念
在应用层中有这两个概念：
同步：现在有两件事都是你应该去做的事情，那么这两件事是不是有先后的顺序
异步：我在做一件事情的同时还可以去做另一件事情
5.2 信号量
通过信号量实现线程间同步。信号量：由信号量来决定线程是继续运行还是阻塞等待，信号量代表某一类资源，其值表示系统中该资源的数量，信号量是一个受保护的变量，只能通过三种操作来访问：初始化、Ｐ操作(申请资源)、Ｖ操作(释放资源)，信号量的值为非负整数
操作：
P操作(申请资源)：
当信号量的值大于0时，可以申请到资源，申请资源后信号量的值减1
当信号量的值等于0时，申请不到资源，函数阻塞
V操作(释放资源)：
不阻塞，执行到释放操作，信号量的值加1
5.3 信号量的分类
1. posix信号量：
a. 无名信号量：数据存储在内存中，通常在线程间使用或父子进程间
函数接口：sem_init\sem_wait\sem_post
b. 有名信号量：数据存储在文件中，在进程间线程间都可以使用
函数接口：sem_open\sem_wait\sem_post\sem_close
2. System V信号量
是信号量的集合，叫信号灯集，属于IPC对象
函数接口：semget\semctl\semop
5.4 函数接口
1.初始化信号量
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value)
功能：初始化信号量 (信号量的表示，在代码中可以定义多个信号量，通过它可以区分不同的信号量)
参数：sem：初始化的信号量对象
pshared：信号量共享的范围(0: 线程间使用 非0:1进程间使用)
value：信号量初值
返回值：成功 0
失败 -1
2.申请资源
int sem_wait(sem_t *sem)
功能：申请资源 P操作
参数：sem：信号量对象
返回值：成功 0
失败 -1
注：此函数执行过程，当信号量的值大于0时，表示有资源可以用，则继续执行，同时对信号量减1；当信号量的值等于0时，表示没有资源可以使用，函数阻塞3.释放资源
int sem_post(sem_t *sem)
功能：释放资源 V操作
参数：sem：信号量对象
返回值：成功 0
失败 -1
注：释放一次信号量的值加1，函数不阻塞
练习：通过信号量实现线程同步：主线程循环从终端输入字符串，子线程循环将字符串打印至终端，当输入"quit"时结束
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>
char s[32];
sem_t sem1; //信号量对象
sem_t sem2;
void *handler_thread(void *arg)
{
while (1)
{
//申请资源 sem1
sem_wait(&sem1);
if (strcmp(s, "quit") == 0)
break;
printf("%s\n", s);
//释放资源sem2
sem_post(&sem2);
}
return NULL;
}
int main(int argc, char const *argv[])
{
pthread_t tid;
//初始化信号量
if (sem_init(&sem1, 0, 0) != 0)
{
perror("sem_init err");
return -1;
}
if (sem_init(&sem2, 0, 1) != 0)
{
perror("sem_init err");
return -1;
}
if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)
{
perror("err");
return -1;
}
while (1)
{
//申请资源sem2
sem_wait(&sem2);
scanf("%s", s);
//释放资源sem1
sem_post(&sem1);
if (strcmp(s, "quit") == 0)
break;
}
}
六丶线程互斥
1.概念
多个线程访问临界资源时，同一时间只能一个线程访问
临界资源：多个线程共同访问的数据，且一次仅允许一个进程所使用的资源
2.互斥锁
通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。互斥锁的操作方式：初始化
申请锁(上锁)：阻塞，当申请不到锁时(表示锁被其他线程占用)，是阻塞
释放锁(解锁)：非阻塞
注：上锁和解锁需要成对出现
3.函数接口
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t * mutex, pthread_mutexattr_t *attr)
功能：初始化互斥锁
参数：mutex：互斥锁
attr: 互斥锁属性 // 一般设置为NULL
返回值：成功 0
失败 -1
int pthread_mutex_lock(pthread_mutex_t *mutex)
功能：申请互斥锁
参数：mutex：互斥锁
返回值：成功 0
失败 -1
int pthread_mutex_unlock(pthread_mutex_t *mutex)
功能：释放互斥锁
参数：mutex：互斥锁
返回值：成功 0
失败 -1
int pthread_mutex_destroy(pthread_mutex_t *mutex)
功能：销毁互斥锁
参数：mutex：互斥锁
练习：循环打印倒置数组
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;
void *handler_swap(void *arg)
{
while (1)
{
sleep(2);
pthread_mutex_lock(&lock); //上锁
for (int i = 0; i < 5; i++)
{
int t = a[i];
a[i] = a[9 - i];
a[9 - i] = t;
}
pthread_mutex_unlock(&lock); //解锁
}
return NULL;
}
void *handler_print(void *arg)
{
while (1)
{
pthread_mutex_lock(&lock); //上锁
for (int i = 0; i < 10; i++)
printf("%d ", a[i]);
printf("\n");
pthread_mutex_unlock(&lock); //解锁
sleep(1); //锁里面减少耗时大的操作
}
return NULL;
}
int main(int argc, char const *argv[])
{
pthread_t tid1, tid2;
//初始化互斥锁
if (pthread_mutex_init(&lock, NULL) != 0)
{
perror("lock err");
return -1;
}
if (pthread_create(&tid1, NULL, handler_swap, NULL) != 0)
{
perror("err");
return -1;
}
if (pthread_create(&tid2, NULL, handler_print, NULL) != 0)
{
perror("err");
return -1;
}
pthread_join(tid1, NULL); //为了让整个进程不要结束
pthread_join(tid2, NULL);
return 0;
}
4.死锁
是指两个或两个以上的进程/线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去死锁产生的四个必要条件：
1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。
七丶条件变量
条件变量(cond)用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t * attr);
功能：初始化条件变量
参数：cond：是一个指向结构pthread_cond_t的指针
restrict attr：是一个指向结构pthread_condattr_t的指针，一般设为NULL
返回值：成功：0 失败：非0
int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t restrict *mutex);
功能：等待条件的产生
参数：restrict cond：要等待的条件
restrict mutex：对应的锁
返回值：成功：0，失败：不为0
int pthread_cond_signal(pthread_cond_t *cond);
功能：产生条件变量
参数：cond：条件变量值
返回值：成功：0，失败：非0
pthread_cond_init(&cond,NULL); //初始化条件变量
pthread_mutex_lock(&lock); //上锁
pthread_cond_wait(&cond, &lock); //阻塞等待条件产生，没有条件产生时阻塞，同时解锁，当条件产生时结束阻塞，再次上锁
//执行任务
pthread_mutex_unlock(&lock); //解锁
pthread_cond_signal(&cond); //产生条件，不阻塞
pthread_cond_destroy(&cond); //销毁条件变量
注意：
1. 必须保证让pthread_cond_wait先执行，pthread_cond_signal再产生条件
2. 当没有条件产生时pthread_cond_wait函数会阻塞，同时会将锁解开；如果等待到条件产生，函数会结束阻塞同时进行上锁。
3. pthread_cond_wait阻塞状态是等待pthread_cond_signal唤醒
4. pthread_cond_signal只能唤醒单个cond_wait，相当于一对一；pthread_cond_broadcast可以唤醒多个cond_wait,相当于一对多
练习：打印和转置数组
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
pthread_mutex_t lock;
pthread_cond_t cond;
void *handler_swap(void *arg)
{
while (1)
{
pthread_mutex_lock(&lock); //上锁
pthread_cond_wait(&cond, &lock);//如果没条件产生解锁并阻塞，等条件产生后结束阻塞并上锁
for (int i = 0; i < 5; i++)
{
int t = a[i];
a[i] = a[9 - i];
a[9 - i] = t;
}
pthread_mutex_unlock(&lock); //解锁
}
return NULL;
}
void *handler_print(void *arg)
{
while (1)
{
sleep(2);
pthread_mutex_lock(&lock); //上锁
for (int i = 0; i < 10; i++)
printf("%d ", a[i]);
printf("\n");
pthread_cond_signal(&cond); //产生条件
pthread_mutex_unlock(&lock); //解锁
sleep(1); //锁里面减少耗时大的操作
}
return NULL;
}
int main(int argc, char const *argv[])
{
pthread_t tid1, tid2;
//初始化互斥锁
if (pthread_mutex_init(&lock, NULL) != 0)
{
perror("lock err");
return -1;
}
//初始化条件变量
if (pthread_cond_init(&cond, NULL) != 0)
{
perror("cond err");
return -1;
}
if (pthread_create(&tid1, NULL, handler_swap, NULL) != 0)
{
perror("err");
return -1;
}
if (pthread_create(&tid2, NULL, handler_print, NULL) != 0)
{
perror("err");
return -1;
}
pthread_join(tid1, NULL); //为了让整个进程不要结束
pthread_join(tid2, NULL);
pthread_mutex_destroy(&lock);
pthread_cond_destroy(&cond);
return 0;
}