线程

认识线程

什么是线程

是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。线程也就是一个轻量级进程，每个线程都有自己的线程控制块，即一个进程至少有一个轻量级进程，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在线程组里面，所有的线程都是对等的关系，没有父线程的概念。

线程与进程关系

轻量级进程(light-weight process)，也有PCB,创建线程使用的底层函数和进程一样，都是clone
从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的
进程可以蜕变成线程
在linux下，线程最是小的执行单位；进程是最小的分配资源单位

线程间资源共享情况

共享资源：

文件描述符表
每种信号的处理方式
当前工作目录
用户ID和组ID
内存地址空间

非共享资源：

线程id
处理器现场和栈指针(内核栈)
独立的栈空间(用户空间栈)
errno变量
信号屏蔽字
调度优先级

线程优缺点

优点：①提高程序的并发性；②开销小，不用重新分配内存；③通信和共享数据方便。

缺点：①线程不稳定（库函数实现）；②线程调试比较困难（gdb支持不好）；③线程无法使用unix经典事件，例如信号；

线程原语

pthread_create

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

/*参数释义：
pthread_t *thread:传递一个pthread_t变量地址进来，用于保存新线程的tid（线程ID）
const pthread_attr_t *attr:线程属性设置，如使用默认属性，则传NULL
void *(*start_routine) (void *):函数指针，指向新线程应该加载执行的函数模块
void *arg:指定线程将要加载调用的那个函数的参数
返回值:成功返回0，失败返回错误号。以前学过的系统函数都是成功返回0，失败返回-1，而错误号保存在全局变量errno中，而pthread库的函数都是通过返回值返回错误号，虽然每个线程也都有一个errno，但这是为了兼容其它函数接口而提供的，pthread库本身并不使用它，通过返回值返回错误码更加清晰。*/
//注（1）：创建线程时，没什么特殊情况我们都是使用默认属性的，不过有时候需要做一些特殊处理，碧如调整优先级啊这些的。

pthread_self

获取调用线程tid

#include<pthread.h>

pthread_t pthread_self(void);

代码示例：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
pthread_t ntid;
void printids(const char *s)
{
    
    
	pid_t pid;
	pthread_t tid;
	pid = getpid();
	tid = pthread_self();
	printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,
	(unsigned int)tid, (unsigned int)tid);
}
void *thr_fn(void *arg)
{
    
    
	printids(arg);
	return NULL;
}
int main()
{
    
    
	int err;
	pthread_t ntid;
	err = pthread_create(&ntid, NULL, thr_fn, "new thread: ");
	if (err != 0) 
	{
    
    
		fprintf(stderr, "can't create thread: %s\n", strerror(err));
		exit(1);
	}
	printids("main thread:");
	sleep(1);
	return 0;
}
结果：
new thread:  pid 4721 tid 3087018896 (0xb8002b90)
main thread: pid 4721 tid 3087021760 (0xb80036c0)

pthread_exit

调用线程退出函数，注意和exit函数的区别，任何线程里exit导致进程退出，其他线程
未工作结束，主控线程退出时不能return或exit。

需要注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是
用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函
数已经退出了

#include <pthread.h>

void pthread_exit(void *retval);

参数释义
retval:线程退出时传递出的参数，可以是退出值或地址，如是地址时，不能是线程内部申请的局部地址。

pthread_join

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);

参数释义：
thread:回收线程的tid
retval:接收退出线程传递出的返回值
返回值：成功返回0，失败返回错误号

函数阻塞调用线程直到thread所指定的线程终止。
如果在目标线程中调用pthread_exit()，程序员可以在主线程中获得目标线程的终止状态。

连接线程只能用pthread_join()连接一次。若多次调用就会发生逻辑错误。

说了这么多为什么要使用pthread_join()？
在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到pthread_join()方法了。
可以这么简单的理解：主线程等待子线程的终止。也就是想调用pthread_join()方法后面的代码，只有等到子线程结束了才能继续执行。

pthread_cancel

在进程内某个线程可以取消另一个线程

#include <pthread.h>

int pthread_cancel(pthread_t thread);

代码实例：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
void *thr_fn1(void *arg)
{
    
    
	printf("thread 1 returning\n");
	return (void *)1;
}
void *thr_fn2(void *arg)
{
    
    
	printf("thread 2 exiting\n");
	pthread_exit((void *)2);
}
void *thr_fn3(void *arg)
{
    
    
	while(1) 
	{
    
    
		printf("thread 3 writing\n");
		sleep(1);
	}
}
int main(void)
{
    
    
	pthread_t tid;
	void *tret;
	pthread_create(&tid, NULL, thr_fn1, NULL);
	pthread_join(tid, &tret);
	printf("thread 1 exit code %d\n", (int)tret);
	pthread_create(&tid, NULL, thr_fn2, NULL);
	pthread_join(tid, &tret);
	printf("thread 2 exit code %d\n", (int)tret);
	pthread_create(&tid, NULL, thr_fn3, NULL);
	sleep(3);
	pthread_cancel(tid);
	pthread_join(tid, &tret);
	printf("thread 3 exit code %d\n", (int)tret);
	return 0;
}

结果：
thread 1 returning
thread 1 exit code 1
thread 2 exiting
thread 2 exit code 2
thread 3 writing
thread 3 writing
thread 3 writing
thread 3 exit code -1

pthread_detach

分离线程

#include <pthread.h>

int pthread_detach(pthread_t tid);

参数释义
tid:分离线程tid
返回值：成功返回0，失败返回错误号。

注意：一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL。如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。

代码实例：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
void *thr_fn(void *arg)
{
    
    
	int n = 3;
	while (n--)
	{
    
    
		printf("thread count %d\n", n);
		sleep(1);
	}
	return (void *)1;
}
int main(void)
{
    
    
	pthread_t tid;
	void *tret;
	int err;
	pthread_create(&tid, NULL, thr_fn, NULL);
	//第一次运行时注释掉下面这行，第二次再打开，分析两次结果
	pthread_detach(tid);
	while (1)
	{
    
    
	err = pthread_join(tid, &tret);
	if (err != 0)
		fprintf(stderr, "thread %s\n", strerror(err));
	else
		fprintf(stderr, "thread exit code %d\n", (int)tret);
	sleep(1);
	}
	return 0;
}
1、注释:pthread_detach(tid);
结果：
thread count 2
thread count 1
thread count 0
thread exit code 1
thread No such process
thread No such process
2、不注释：pthread_detach(tid);
结果：
thread count 2
thread Invalid argument
thread count 1
thread Invalid argument
thread count 0
thread Invalid argument
thread Invalid argument

pthread_equal

比较两个线程是否相等

#include <pthread.h>
int pthread_equal(pthread_t t1, pthread_t t2);

线程终止方式

如果需要只终止某个线程而不终止整个进程，可以有三种方法：

①从线程主函数return。这种方法对主控线程不适用，从main函数return相当于调用exit。

②一个线程可以调用pthread_cancel终止同一进程中的另一个线程。

③线程可以调用pthread_exit终止自己。

线程同步

线程为什么要同步

共享资源，多个线程都可对共享资源操作
线程操作共享资源的先后顺序不确定
处理器对存储器的操作一般不是原子操作

互斥量

临界区（Critical Section）

保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

临界区选定

临界区的选定因尽可能小，如果选定太大会影响程序的并行处理性能。

mutex操作原语

pthread_mutex_t mutex = PTHREAD_MUREX_INITALIZER //用于初始化互斥锁，后面简称锁

int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr); //初始化锁，和上面那个一个意思。
//初始化一个互斥锁（互斥量）–>初值可看做1
int pthread_mutex_destroy(pthread_mutex_t *mutex); //销毁锁
int pthread_mutex_lock(pthread_mutex_t *mutex); //上锁
int pthread_mutex_unlok(pthread_mutex_t *mutex); //解锁
int pthread_mutex_trylock(pthread_mutex_t *mutex); //尝试上锁

扩展：

restrict关键字：只用于限制指针，告诉编译器，所有修改该指针指向内存中内容的操作，只能通过本指针完成。不能通过除本指针以外的其他变量或指针修改。
静态初始化：如果互斥锁mutex是静态分配的(定义在全局，或加了static关键字修饰），可以直接使用宏进行初始化。pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
动态初始化：局部变量应采用动态初始化。pthread_mutex_init(&mutex, NULL);
attr对象用于设置互斥量对象的属性，使用时必须声明为pthread_mutextattr_t类型，默认值可以是NULL。Pthreads标准定义了三种可选的互斥量属性：
①协议（Protocol）：指定了协议用于阻止互斥量的优先级改变
② 优先级上限（Prioceiling）：指定互斥量的优先级上限
③进程共享（Process-shared）：指定进程共享互斥量

互斥锁有什么作用？
采用互斥锁保护临界区，从而防止竞争条件。也就是说，一个进程在进入临界区时应得到锁；它在退出临界区时释放锁。

互斥量实例

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define NLOOP 5
int counter; /* incremented by threads */
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
void *doit(void *);
int main(int argc, char **argv)
{
    
    
	pthread_t tidA, tidB;
	pthread_create(&tidA, NULL, doit, NULL);
	pthread_create(&tidB, NULL, doit, NULL);
	/* wait for both threads to terminate */
	pthread_join(tidA, NULL);
	pthread_join(tidB, NULL);
	return 0;
}
void *doit(void *vptr)
{
    
    
	int i, val;
	for (i = 0; i < NLOOP; i++) 
	{
    
    
		pthread_mutex_lock(&counter_mutex);
		val = counter;
		printf("%x: %d\n", (unsigned int)pthread_self(), val + 1);
		counter = val + 1;
		pthread_mutex_unlock(&counter_mutex);
	}
	return NULL;
}
//从运行结果不难看出，线程tidA首先进行循环打印，等到tidA完成释放资源后才轮到线程tidB
运行结果：
b7f80b90: 1
b7f80b90: 2
b7f80b90: 3
b7f80b90: 4
b7f80b90: 5
b757fb90: 6
b757fb90: 7
b757fb90: 8
b757fb90: 9
b757fb90: 10

死锁

死锁问题是多线程特有的问题，它可以被认为是线程间切换消耗系统性能的一种极端情况。在死锁时，线程间相互等待资源，而又不释放自身的资源，导致无穷无尽的等待，其结果是系统任务永远无法执行完成。死锁问题是在多线程开发中应该坚决避免和杜绝的问题。

线程死锁的原因

（1）互斥条件：一个资源每次只能被一个线程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
（4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

解决方法：如果发生了死锁，那么只要破坏死锁 4 个必要条件之一中的任何一个，死锁问题就能被解决。

条件变量

条件变量提供了另一种同步的方式。互斥量通过控制对数据的访问实现了同步，而条件变量允许根据实际的数据值来实现同步。
没有条件变量，程序员就必须使用线程去轮询（可能在临界区），查看条件是否满足。这样比较消耗资源，因为线程连续繁忙工作。条件变量是一种可以实现这种轮询的方式。
条件变量往往和互斥一起使用

条件变量控制原语

//初始化条件变量：
//方法一：静态初始化
pthread_cont_t cont = PTHREAD_COND_INITIALIZER;
//方法二：动态初始化
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
//参数释义：cond:用于接收初始化成功管道条件变量
//attr:通常为NULL,且被忽略

//销毁
int pthread_cond_destroy(pthread_cond_t *cond);

//等待
int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);  //无条件等待

int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t mutex,const struct timespec *abstime);  //计时等待

//等待唤醒
int pthread_cond_signal(pthread_cond_t *cptr); //唤醒一个等待该条件的线程。存在多个线程是按照其队列入队顺序唤醒其中一个
int pthread_cond_broadcast(pthread_cond_t * cptr); //广播，唤醒所有等待线程

实例:

生产者消费者模型：

#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>
struct msg 
{
    
    
	struct msg *next;
	int num;
};
struct msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *p)
{
    
    
	struct msg *mp;
	for(;;) 
	{
    
    
		pthread_mutex_lock(&lock);
		while (head == NULL)
			pthread_cond_wait(&has_product, &lock);
		mp = head;
		head = mp->next;
		pthread_mutex_unlock(&lock);
		printf("Consume %d\n", mp->num);
		free(mp);
		sleep(rand() % 5);
	} 
}
void *producer(void *p)
{
    
    
	struct msg *mp;
	for (;;) 
	{
    
    
		mp = malloc(sizeof(struct msg));
		mp->num = rand() % 1000 + 1;
		printf("Produce %d\n", mp->num);
		pthread_mutex_lock(&lock);
		mp->next = head;
		head = mp;
		pthread_mutex_unlock(&lock);
		pthread_cond_signal(&has_product);
		sleep(rand() % 5);
	}
}
int main(int argc, char *argv[])
{
    
    
	pthread_t pid, cid;
	srand(time(NULL));
	pthread_create(&pid, NULL, producer, NULL);
	pthread_create(&cid, NULL, consumer, NULL);
	pthread_join(pid, NULL);
	pthread_join(cid, NULL);
	return 0;
}

运行结果：
Produce 543
Consume 543
Produce 465
Consume 465
······

线程和线程同步

目录

线程