Linux线程笔记
文章目录
引言
进程是分配硬件资源的最小单位，而线程是调度的最小单位。一个进程里可以有多个线程。
创建线程（pthread_create）
线程创建函数：int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg)
返回值：成功-0；失败-错误号。
thread：存储新建线程的线程号tid。同一进程的线程线程号都不同
attr：该结构体指定了线程的各种属性，一般为NULL设为默认属性。
start_routine：指定线程所运行函数指针（函数名），该函数（以下均成为start函数）的输入参数和返回参数均为void *，该数据类型可以通过后续程序强转为其它类型，如：int。返回值要注意别与PTHREAD_CANCELED相同，否则会让线程误终止，具体内容与线程的终止相关。
若要传入或多个参数，可以把参数封装为结构体，把结构体指针强转为void*传入或传出。
arg：线程执行函数的传入参数，可为NULL。
线程的终止与释放
新建的线程要先终止，再由另一线程获取返回值并释放。
任意线程调用了exit()或主线程return会导致所有进程中的线程立即终止释放。
pthread_exit()
在线程的start函数中调用pthread_exit()或return指定值以终止当前线程
void pthread_exit(void *retval)
其中retval用于存储线程需要返回的返回值。
pthread_join()
int pthread_join(pthread_t thread, void **retval)
作用：等待指定的线程终止，然后获取线程返回值，并释放该线程所占用的资源。（该操作也被称作连接 joining）
注意：一个线程只能被连接一次，不能连接一个已经连接过的线程。分离连接用pthread_detch()
参数：
thread：指定的线程号。
retval：存储线程的返回值。
与进程waitpid()的区别：
- 进程的关系是对等的，没有父子线程这一说，所以任意线程都能调用join函数去连接其它未被连接的线程。而
waitpid()则只能由父进程执行。 pthread_join()无法连接"任意线程"，且无法实现非阻塞连接，需借助条件变量(condition)实现，而waitpid()能直接实现。
其它函数
pthread_self()查看自己的tid。
pthread_equal()对比两tid是否相同。
多线程的原子性
由于多线程间是并发执行的，调度也是随机的，所以，多线程程序中在操作共享资源（如：全局变量）时，要确保操作的原子性，即，操作资源前后不能被其它线程同时操作到该资源。
例：简易支付app进行多线程扣钱代码：nomutex.c
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int money = 500;//钱包有500块
void* pay_func(void* p)//用于消费money的线程
{
int amt = *(int *)p;
if(amt <= money)
{
usleep(1);
money -= amt;
}
return 0;
}
int main(int argc, char **argv)
{
int ret;
int cost = 500;
pthread_t pay1, pay2;
ret = pthread_create(&pay1, NULL, pay_func, (void*)&cost);
if(ret != 0)
{
perror("pthread1_create error:");
}
ret = pthread_create(&pay2, NULL, pay_func, (void*)&cost);
if(ret != 0)
{
perror("pthread2_create error:");
}
pthread_join(pay1, NULL);
pthread_join(pay2, NULL);
printf("money= %d\n", money);
return 0;
}
编写Makefile文件：
cc=gcc
TARGET1=nomutex
OBJS1=nomutex.c
all:${TARGET1}
${TARGET1}:${OBJS1}
${cc} $^ -lpthread -o $@
.PHONY:clean
clean:
rm ${TARGET1}
编写重复运行50次的shell脚本：
#!bin/bash
for (( i=1; i<=50; i++ ))
do
./nomutex
done
编译并利用shell脚本重复运行该程序，会看到大部分的输出值都是负值，只有少数的输出值为0，这是因为：例如，当线程1运行完usleep(1)后，money的值仍为500，若此时调度到的线程2恰好执行到判断语句if(amt < money)，那么判断为真，便会进入到if分支中扣钱，这样，相当于线程1和线程2各扣了500，扣多了，则int money便会变为一个负数。
为了避免非原子性所带来的程序执行的混乱，就需要对多线程进行同步。
原子操作(略)
xchg(int *a, int value)：一个宏，作用为：原子地把value的值存入到a所指向的内存中，返回值为原来a所指向的值；在存入过程中，其他线程对*a操作都要阻塞地等待。后续的同步操作的底层多少都有借助原子操作实现。
多线程的同步
为了避免多线程处理共享资源（全局变量）是发生竞争，以及使得相关线程能按先后顺序执行，就需要进行线程的同步。
互斥量（mutex）
为了避免多线程操作共享资源发生冲突，必须使用互斥量来确保同一时间只有一个线程可以访问到共享资源，也就是确保共享资源操作的原子性。
在Linux中，互斥量用pthread_mutex_t类型的变量来表示。
互斥量的静态分配
静态分配：静态分配互斥量变量，直接赋值一个宏来初始化成默认参数。
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER
互斥量的动态分配
动态分配其实就是通过初始化函数可以自由设置互斥量的相关属性。
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
返回值：0-成功
mutex：分配好内存的互斥量指针。
attr：该结构体用于设置结构体属性，NULL会设置为默认值。
以下情况适用于动态分配：
- 通过malloc动态创建的互斥量
- 静态定义的变量
pthread_mutex_t mtx，未使用静态分配初始化的互斥量
对于动态分配初始化的互斥量要使用以下函数将其销毁：
int pthread_mutex_destroy(pthread_mutex_t *mutex)
返回值：0-成功。
互斥量的上锁与解锁
上锁：int pthread_mutex_lock(pthread_mutex_t *mutex)
返回值：0-上锁成功成功
若其他线程已上锁，则该上锁函数会阻塞线程。
解锁：int pthread_mutex_unlock(pthread_mutex_t *mutex)
返回值：0-解锁成功
该函数不能解开其它线程上的锁，只能解开自己线程上的锁。
pthread_mutex_trylock()：当锁被占用无法上锁时会立刻返回EBUSY错误，不会阻塞，其它功能与lock函数相同。
pthread_mutex_timedlock()该函数可以指定等待锁的时间，若超过设定时间仍没获得锁，则返回ETIMEDOUT错误。
在上文的支付代码加入互斥量后，最终输出值都为0，没有赋值，改动部分如下：
int money = 500;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void* pay_func(void* p)
{
int amt = *(int *)p;
pthread_mutex_lock(&mtx);
if(amt <= money)
{
usleep(1);
money -= amt;
}
pthread_mutex_unlock(&mtx);
return 0;
}
条件变量（condition）
条件变量必须搭配互斥量来使用，下文所描述的条件变量默认包含了互斥量。
条件变量的作用类似于进程间通信中信号的作用，当中的互斥量充当信号。
它的工作模型可以看作是生产者和消费者模型。生产者线程会先把互斥量上锁，然后当对共享资源的操作完成后，通过signal或broadcast函数发送一个“信号”，发送信号后立刻unlock互斥量；而消费者线程会先用lock上锁，然后用while判断共享资源是否满足条件，不满足会通过wait函数解锁然后休眠，直到有信号到来时，wait函数自动上锁然后不再阻塞，再回到while的判断里，此时，若满足，便不会执行while里的wait()。
注意：生产者线程要先用lock函数上锁，再用signal函数发送信号；而消费者线程在wait()函数抢到锁后，访问完共享资源后要用unlock函数去解锁，否则生产者没法发送下一次信号。
创建条件变量
条件变量与互斥量类似，分为静态和动态。
静态：
pthread_cond_t cond = PTHREAD_COND_INITALIZER
动态：
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
成功返回0；
参数attr是设置条件变量属性的结构体，当NULL时则设置为默认属性。
当不再使用动态创建的调节变量时，应调用以下函数进行销毁：
int pthread_cond_destory(pthread_cond_t *cond);
成功返回0。
发送条件变量
发送条件变量的有两个：
int pthread_cond_sinal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
成功返回0；
signal函数保证唤醒至少一条遭到wait()阻塞，而broadcast()会唤醒所有遭到阻塞的线程。
等待条件变量
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
成功返回0；
当没有收到条件变量时，会解锁等待，当收到条件变量会上锁并继续执行。
生产者-消费者例子：
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int food=0;
void* produce(void *p)
{
int i;
char *a = (char*)p;
printf("%s run\n", a);
for(i=100; i>0; i--)
{
usleep(1);
pthread_mutex_lock(&mtx);
food += 2;
printf("food = %d\n", food);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mtx);
}
printf("pro exit\n");
return 0;
}
void* comsue(void *p)
{
char *a = (char*)p;
while(1)
{
usleep(1);
//printf("%s run\n", a);
pthread_mutex_lock(&mtx);
while(food <= 0)
{
printf("%s wait\n", a);
pthread_cond_wait(&cond, &mtx);
}
printf("%s eat\n", a);
food--;
pthread_mutex_unlock(&mtx);
}
return 0;
}
int main(int argc, char **argv)
{
pthread_t produce1, comsue1, comsue2;
int ret;
char *p1 = "pro";
char *c1 = "com1";
char *c2 = "com2";
ret = pthread_create(&produce1, NULL, produce, (void*)p1);
if(ret != 0)
{
perror("create p1 error:");
exit(1);
}
ret = pthread_create(&comsue1, NULL, comsue, (void*)c1);
if(ret != 0)
{
perror("create c1 error:");
exit(1);
}
ret = pthread_create(&comsue2, NULL, comsue, (void*)c2);
if(ret != 0)
{
perror("create c2 error:");
exit(1);
}
pthread_join(produce1, NULL);
pthread_join(comsue1, NULL);
pthread_join(comsue2, NULL);
//fflush(stdout);
return 0;
}
在线程中加入一点延时，可以更好的从打印结果看到线程调度的过程，看出线程调度的随机性。
其它同步方式
线程间的其它同步方式还有读写锁、自旋锁、信号量，本文就不再展开了。
375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
