目录
一.什么是线程
1. 概念
线程是一个轻量级的进程，为了提高系统的性能引入线程。
线程和进程是参与统一的调度。
在同一个进程中可以创建的多个线程, 共享进程资源。
(Linux里同样用task_struct来描述一个线程）
2. 进程和线程区别
相同点：
都为系统提供了并发执行的能力
不同点：
调度和资源: 线程是系统调度的最小单位; 进程是资源分配的最小单位。
地址空间方面: 同一个进程创建的多个线程共享该进程的资源；进程的地址空间相互独立。
通信方面: 线程通信相对简单，只需要通过全局变量可以实现，但是需要考虑临界资源访问的问题；进程通信比较复杂，需要借助进程间的通信机制(借助3g-4g内核空间)
安全性方面: 线程安全性差一些，当进程结束时会导致所有线程退出；进程相对安全。
面试题：程序什么时候该使用线程？什么时候用进程？（深圳棱镜空间智能科技有限公司）（北京明朝万达）
对资源的管理和保护要求高，不限制开销和效率时，使用多进程。
要求效率高、速度快的高并发环境时，需要频繁创建、销毁或切换时，资源的保护管理要求不是很高时，使用多线程。
3. 线程资源
共享的资源：可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户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 链接动态库
例子:
#include <stdio.h>
#include <pthread.h>
void *handler_thread(void *arg)
{
printf("in handler_thread\n");
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;
}
printf("in main\n");
while(1); //让主线程不要结束
return 0;
}
2. 退出线程: pthread_exit
void pthread_exit(void *value_ptr)
功能：用于退出线程的执行
参数：value_ptr：线程退出时返回的值#include <stdio.h>
#include <pthread.h>
void *handler_thread(void *arg)
{
printf("in handler_thread\n");
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;
}
printf("in main\n");
while (1)
; //让主线程不要结束
return 0;
}
3. 回收线程资源 pthread _ join
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结束
通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。
- 全局变量进行通信
- 加上标志位(flag)，实现主线程输入一次，线程函数打印一次， int flag = 0;
#include <stdio.h>
#include <pthread.h>
#include <string.h>
char s[32];
int flag = 0; //为了进行线程间通讯，保证主线程先输入然后从线程再输出
void *handler_thread(void *arg)
{
while (1)
{
if (flag == 1) //主线程输入完将flag置1从线程再输出
{
if (strcmp(s, "quit") == 0)
break;
printf("%s\n", s);
flag--;
}
}
return NULL;
}
int main(int argc, char const *argv[])
{
pthread_t tid;
if (pthread_create(&tid, NULL, handler_thread, NULL) != 0)
{
perror("err");
return -1;
}
while (1)
{
//scanf前也可以不加if判断，利用阻塞时间让从线程输出
// if (flag == 0) //从线程输出完将flag置0主线程再输入
// {
scanf("%s", s);
flag++;
if (strcmp(s, "quit") == 0)
break;
// }
}
}
三.同步
1. 概念
同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情
(异步：异步则反之，并非一定需要一件事做完再做另一件事。）
2. 同步机制
通过信号量实现线程间同步。
信号量：通过信号量实现同步操作；由信号量来决定线程是继续运行还是阻塞等待。
信号量代表某一类资源，其值表示系统中该资源的数量:
信号量的值>0, 表示有资源可以用, 可以申请到资源。
信号量的值<=0, 表示没有资源可以用, 无法申请到资源, 阻塞。
信号量还是一个受保护的变量，只能通过三种操作来访问：初始化、Ｐ操作(申请资源)、Ｖ操作(释放资源)
sem_init: 信号量初始化
sem_wait: 申请资源，P操作，如果没有资源可以用会阻塞等待，直到有资源可用结束阻塞资源-1。
sem_post: 释放资源，V操作，非阻塞，资源+1。
3. 函数接口
int sem_init(sem_t *sem, int pshared, unsigned int value)
功能：初始化信号量
参数：sem：初始化的信号量对象
pshared：信号量共享的范围(0: 线程间使用 非0:1进程间使用)
value：信号量初值
返回值：成功 0
失败 -1
int sem_wait(sem_t *sem)
功能：申请资源 P操作
参数：sem：信号量对象
返回值：成功 0
失败 -1
注：此函数执行过程，当信号量的值大于0时，表示有资源可以用，则继续执行，同时对信号量减1；当信号量的值等于0时，表示没有资源可以使用，函数阻塞
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. 概念
互斥：多个线程在访问临界资源时，同一时间只能一个线程访问
临界资源：一次仅允许一个线所使用的资源
临界区：指的是一个访问共享资源的程序片段
互斥锁（mutex）：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。
pthread_mutex_init
pthread_mutex_lock
pthread_mutex_unlock
2. 函数接口
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
注：和pthread_mutex_trylock区别：pthread_mutex_lock是阻塞的；pthread_mutex_trylock不阻塞，如果申请不到锁会立刻返回
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)
{
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;
}
补充：死锁
是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。
死锁产生的四个必要条件
1. 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
2. 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
3. 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
4. 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。
五.条件变量
条件变量(cond)用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。
一般和互斥锁搭配使用，实现同步机制:
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); //销毁条件变量
注意： 必须保证让pthread_cond_wait先执行，pthread_cond_signal再产生条件
例如：打印和转置数组实现同步
#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;
}