线程
概念
轻量级的进程，为了提高系统的性能 而引入了线程。线程和进程都参与统一的调度。
进程与线程的区别
共同点：
都为操作系统提供了并发执行能力，都参与统一调度。
不同点：
调度和资源方面：线程是系统调度的最小单位，进程是资源分配的最小单位。
地址空间方面：同一个进程创建的多个线程共享进程的资源；进程的地址空间相互独立。
通信方面：线程通信相对简单，只需要通过全局变量可以实现，但是需要考虑临界资源访问的问题；
进程通信比较复杂，需要借助进程间的通信机制（借助3g-4g内核空间）。
安全性方面：线程安全性差一些，当进程结束时会导致所有线程退出；进程相对安全。
线程资源
共享的资源：
可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户ID、用户组ID
私有的资源：
线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈、错误号 (errno)、信号掩码和优先级、执行状态和属性
函数接口
创建线程（ 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_join / detach）
int pthread_join(pthread_t thread, void **value_ptr);
功能：用于等待一个指定的线程结束，阻塞函数
参数：thread：创建的线程对象
value_ptr：指针*value_ptr指向线程返回的参数
返回值：成功： 0
失败：errno
int pthread_detach(pthread_t thread);
功能：子线程退出，自动回收资源，不阻塞
参数：thread：创建的线程对象
返回值：成功： 0
失败：errno
退出线程（ pthread_exit ）
int pthread_exit(void *value_ptr);
功能：用于退出线程的执行
参数：value_ptr：线程退出时返回的值（任意类型）
返回值： 成功 ： 0
失败：errno
以上代码中 “end” 一定在最后输出。
练习：通过线程实现数据的交互
主线程循环从终端输入，线程函数将数据循环输出，当输入 “quit” 结束程序。
#include <stdio.h>
#include <pthread.h>
#include <string.h>
char buffer[64];
int flag = 0;
void *handler(void *arg){
while (1){
if (flag != 0){
if (!strcmp(buffer, "quit"))
break;
printf("%s\n", buffer);
flag = 0;
}
}
pthread_exit(0);
}
int main(int argc, char const *argv[])
{
pthread_t tid;
if (pthread_create(&tid, NULL, handler, NULL)){
perror("Failed: ");
return -1;
}
while (1){
scanf("%s", buffer);
// scanf有阻塞机制，不需要判断flag==0，线程函数一定能抢到时间片
// fgets也有阻塞
flag = 1;
if (!strcmp(buffer, "quit"))
break;
}
pthread_join(tid, NULL);
return 0;
}
同步
同步（synchronization）指的是多个任务（线程）按照约定的顺序相互配合完成一件事情。
同步机制
1、信号量
通过信号量实现同步操作；由信号量来决定线程继续运行还是阻塞等待。
信号量代表某一类资源，其值表示系统中该资源的数量：
信号量值 > 0，表示有资源可以用，可以申请到资源，继续执行程序；
信号量值<=0，表示没有资源可以用，无法申请到资源，阻塞。
信号量是一个受保护的变量，只能通过三种操作来访问：
初始化 sem_init、Ｐ操作（申请资源）sem_wait、Ｖ操作（释放资源）sem_post
函数（ sem_init、sem_wait、sem_post ）
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>
#include <stdlib.h>
char buffer[64];
sem_t sem;
void *handler(void *arg){
while (1){
sem_wait(&sem); // 若线程一直阻塞，程序不能退出
if (!strcmp(buffer, "quit"))
exit(0);
printf("%s\n", buffer);
}
pthread_exit(0);
}
int main(int argc, char const *argv[])
{
sem_init(&sem, 0, 0); // 若不 post，则将不能结束 wait，线程阻塞
pthread_t tid;
if (pthread_create(&tid, NULL, handler, NULL)){
perror("Failed: ");
return -1;
}
while (1){
scanf("%s", buffer);
// fgets(buffer, 64, stdin);
// if (buffer[strlen(buffer)-1] == '\n')
// buffer[strlen(buffer)-1] = '\0';
if (!strcmp(buffer, "quit"))
exit(0); // 如果用 break; 将此 if 放到 post 后才行，不然下一句不执行
sem_post(&sem);
}
pthread_join(tid, NULL);
return 0;
}
练习：开启两个线程分别打印A、B，每个线程打印10遍
要求输出必须按照AB的顺序显示，即：ABABAB…
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <semaphore.h>
#include <stdlib.h>
char buffer[64];
sem_t sem1, sem2;
void *print1(void *arg){
for (int i = 1; i < 11; i++){
sem_wait(&sem1);
printf("%d: A\t", i);
sem_post(&sem2);
}
pthread_exit(0);
}
void *print2(void *arg){
for (int i = 1; i < 11; i++){
sem_wait(&sem2);
printf("%d: B\t", i);
sem_post(&sem1);
}
putchar(10);
pthread_exit(0);
}
int main(int argc, char const *argv[])
{
sem_init(&sem1, 0, 1);
sem_init(&sem2, 0, 0);
pthread_t tid1, tid2;
if (pthread_create(&tid1, NULL, print1, NULL)){
perror("Failed: ");
return -1;
}
if (pthread_create(&tid2, NULL, print2, NULL)){
perror("Failed: ");
return -1;
}
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}
运行结果如下：
2、互斥锁 + 条件变量
如下“条件变量”。
互斥
临界资源： 一次仅允许一个进程/线程所使用的资源
临界区： 指的是一个访问共享资源的程序片段
概念
多个线程在访问某临界资源时，同一时间只能一个线程进行访问。
信号量也可实现线程间互斥
多个线程抢夺同一信号量即可。
互斥锁：
通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护。
线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。
函数
pthread_mutex_init
int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr);
功能：初始化互斥锁
参数：mutex：互斥锁
attr: 互斥锁属性 // NULL表示缺省属性
返回值：成功 0
失败 -1
pthread_mutex_lock
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：申请互斥锁
参数：mutex：互斥锁
返回值：成功 0
失败 -1
注：和pthread_mutex_trylock区别：
pthread_mutex_lock是阻塞的；
pthread_mutex_trylock不阻塞，如果申请不到锁会立刻返回
pthread_mutex_unlock
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：释放互斥锁
参数：mutex：互斥锁
返回值：成功 0
失败 -1
pthread_mutex_destroy
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：销毁互斥锁
参数：mutex：互斥锁
练习：两个线程实现数组倒置（part1）
线程一用于循环倒置，线程二用于循环打印（延时）。
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
char arr[10] = {};
pthread_mutex_t lock;
char temp;
void *ver(void *arg){
while (1){
pthread_mutex_lock(&lock);
for (int i = 0 ; i < 5; i++){
temp = arr[i];
arr[i] = arr[9-i];
arr[9-i] = temp;
}
pthread_mutex_unlock(&lock);
}
pthread_exit(0);
}
void *print(void *arg){
while (1){
pthread_mutex_lock(&lock);
for (int i = 0; i < 10; i++)
printf("%c\t", arr[i]);
pthread_mutex_unlock(&lock);
putchar(10);
sleep(2);
}
pthread_exit(0);
}
int main(int argc, char const *argv[])
{
for (int i = 0; i < 10; i++)
arr[i] = i + 48;
for (int i = 0; i < 10; i++)
printf("%c\t", arr[i]);
printf("\n*************\n");
pthread_mutex_init(&lock, NULL);
pthread_t tid1, tid2;
if (pthread_create(&tid1, NULL, ver, NULL)){
perror("Failed: ");
return -1;
}
if (pthread_create(&tid2, NULL, print, NULL)){
perror("Failed: ");
return -1;
}
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_mutex_destroy(&lock);
return 0;
}
实现效果如下：
条件变量
函数
pthread_cond_init
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
功能：初始化条件变量
参数：cond：是一个指向结构 pthread_cond_t 的指针
restrict attr：是一个指向结构 pthread_condattr_t 的指针，一般设为 NULL
返回值： 成功：0
失败：非0
pthread_cond_wait
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
功能：等待信号的产生
参数：restrict cond：要等待的条件
restrict mutex：对应的锁
返回值：成功：0，失败：非0
注：当没有条件产生时函数会阻塞，同时会将锁解开；如果等待到条件产生，函数会结束阻塞同时进行上锁。
pthread_cond_signal
int pthread_cond_signal(pthread_cond_t *cond);
功能：给条件变量发送信号
参数：cond：条件变量值
返回值：成功：0，失败：非0
注：必须等待 pthread_cond_wait 函数先执行，再产生条件才可以。
pthread_cond_destroy
int pthread_cond_destroy(pthread_cond_t *cond);
功能：将条件变量销毁
参数：cond：条件变量值
返回值：成功：0， 失败：非0
步骤
1）pthread_cond_init(&cond, NULL)：初始化
2）pthread_mutex_lock(&lock); // 上锁
pthread_cond_wait(&cond, &lock);
// 阻塞 等待条件产生：没有条件产生时阻塞，同时解锁；当条件产生时结束阻塞，再次上锁
3）pthread_cond_signal(&cond)：产生条件，不阻塞
须保证：pthread_cond_wait 先执行，pthread_cond_signal 再产生条件
练习：两个线程实现数组倒置（part2）
线程一用于循环倒置，线程二用于循环打印（延时）。
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
char arr[10] = {};
pthread_mutex_t lock;
char temp;
pthread_cond_t condition;
void *ver(void *arg){
while (1){
sleep(2); // 使另外一个线程先拿到锁
pthread_mutex_lock(&lock);
for (int i = 0 ; i < 5; i++){
temp = arr[i];
arr[i] = arr[9-i];
arr[9-i] = temp;
}
pthread_cond_signal(&condition); // 发送条件
pthread_mutex_unlock(&lock);
}
pthread_exit(0);
}
void *print(void *arg){
while (1){
pthread_mutex_lock(&lock);
pthread_cond_wait(&condition, &lock); // 第一次：没条件，解锁并等待
for (int i = 0; i < 10; i++) // 第二次：有条件，继续执行并上锁
printf("%c\t", arr[i]);
pthread_mutex_unlock(&lock);
putchar(10);
}
pthread_exit(0);
}
int main(int argc, char const *argv[])
{
for (int i = 0; i < 10; i++)
arr[i] = i + 48;
for (int i = 0; i < 10; i++)
printf("%c\t", arr[i]);
printf("\n*************\n");
pthread_mutex_init(&lock, NULL);
pthread_cond_init(&condition, NULL);
pthread_t tid1, tid2;
if (pthread_create(&tid1, NULL, ver, NULL)){
perror("Failed: ");
return -1;
}
if (pthread_create(&tid2, NULL, print, NULL)){
perror("Failed: ");
return -1;
}
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_mutex_destroy(&lock);
pthread_cond_destroy(&condition);
return 0;
}
实现效果如下：
练习：两个线程实现字符串循环倒序输出
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
int flag = 0;
char buf[64] = "";
pthread_mutex_t lock;
pthread_cond_t condition;
void *reverse(void *arg){
while (1){
char *p = buf;
char *head = p;
char *tail = NULL;
while (*(p+1) != '\0')
p++;
tail = p;
sleep(2);
pthread_mutex_lock(&lock);
while (head < tail){
*head ^= *tail;
*tail ^= *head;
*head++ ^= *tail--;
}
pthread_cond_signal(&condition); //
pthread_mutex_unlock(&lock);
}
pthread_exit(0);
}
void *output(void *arg){
while (1){
pthread_mutex_lock(&lock);
pthread_cond_wait(&condition, &lock);
printf("%s\n", buf);
pthread_mutex_unlock(&lock);
}
pthread_exit(0);
}
int main(int argc, char const *argv[])
{
strcpy(buf, "Welcome to my world!");
pthread_t tid1, tid2;
if (pthread_create(&tid1, NULL, output, NULL) != 0){
perror("Failed to create a thread");
return -1;
}
if (pthread_create(&tid2, NULL, reverse, NULL) != 0){
perror("Failed to create a thread");
return -1;
}
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_mutex_destroy(&lock);
pthread_cond_destroy(&condition);
return 0;
}
死锁
两个或两个以上的 进程或线程 在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。
产生的四个必要条件：
1、互斥使用，即当资源被一个线程使用（占有）时，别的线程不能使用；
2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放；
3、请求和保持，即当资源请求者在请求其他的资源的同时，保持对原有资源的占有；
4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。
注意： 当上述四个条件都成立的时候，便形成死锁。
当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
