【Linux系统编程】线程

目录

一、Linux线程介绍

1、进程与线程

2、使用线程的理由

3、Linux上线程开发API概要 

二、与线程自身相关API

1. 线程创建

2. 线程退出

3. 线程等待

4. 线程脱离

5. 线程ID获取及比较

三、与互斥锁相关API 

四、与条件变量相关API

---

参考：Linux多线程编程初探 - 峰子_仰望阳光 - 博客园 (cnblogs.com)

一、Linux线程介绍

1、进程与线程

        典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。　　

　　进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。

　　线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程包含了表示进程内执行环境必须的信息，其中包括进程中表示线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno常量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。在Unix和类Unix操作系统中线程也被称为轻量级进程（lightweight processes），但轻量级进程更多指的是内核线程（kernel thread），而把用户线程（user thread）称为线程。

"进程——资源分配的最小单位，线程——程序执行的最小单位"

　　进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

　　从函数调用上来说，进程创建使用fork()操作；线程创建使用clone()操作。

2、使用线程的理由

总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

　　使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。

　　使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。

　　除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：

• 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
• 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
• 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

3、Linux上线程开发API概要 

二、与线程自身相关API

1. 线程创建

#include <pthread.h>
int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
// tidp: 指向新创建线程ID的变量, 作为函数的输出.
// attr: 用于定制各种不同的线程属性, NULL为默认属性（见下）.
// start_rtn: 函数指针, 为线程开始执行的函数名.该函数可以返回一个void *类型的返回值，而这个返回值也可以是其他类型，并由 pthread_join()获取
// arg: 函数的唯一无类型(void)指针参数, 如要传多个参数, 可以用结构封装
// 返回：若成功返回0，否则返回错误编号

　　当pthread_create成功返回时，由tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。

　　新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。

因为pthread的库不是linux系统的库，所以在进行编译的时候要加上     -lpthread

2. 线程退出

　　单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：

　　1）线程只是从启动例程中返回，返回值是线程的退出码。

　　2）线程可以被同一进程中的其他线程取消。

　　3）线程调用pthread_exit：

#include <pthread.h>
int pthread_exit(void *rval_ptr);

　　rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。

3. 线程等待

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
// thread: 线程ID.
// rval_ptr: 指向返回值的指针(返回值也是个指针).
// 返回：若成功返回0，否则返回错误编号

　　调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消。

        如果例程只是从它的启动例程返回i，rval_ptr将包含返回码。

        如果线程被取消，由rval_ptr指定的内存单元就置为PTHREAD_CANCELED。

        可以通过调用pthread_join自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_join调用就会失败，返回EINVAL。

        如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并不获得线程的终止状态。

4. 线程脱离

　　一个线程或者是可汇合（joinable，默认值），或者是脱离的（detached）。当一个可汇合的线程终止时，它的线程ID和退出状态将留存到另一个线程对它调用pthread_join。脱离的线程却像守护进程，当它们终止时，所有相关的资源都被释放，我们不能等待它们终止。如果一个线程需要知道另一线程什么时候终止，那就最好保持第二个线程的可汇合状态。

　　pthread_detach函数把指定的线程转变为脱离状态。

#include <pthread.h>
int pthread_detach(pthread_t thread);
// 返回：若成功返回0，否则返回错误编号

　　本函数通常由想让自己脱离的线程使用，就如以下语句：

pthread_detach(pthread_self());

5. 线程ID获取及比较

#include <pthread.h>
pthread_t pthread_self(void);
// 返回：调用线程的ID

　　对于线程ID比较，为了可移植操作，我们不能简单地把线程ID当作整数来处理，因为不同系统对线程ID的定义可能不一样。我们应该要用下边的函数：

#include <pthread.h>
int pthread_equal(pthread_t tid1, pthread_t tid2);
// 返回：若相等则返回非0值，否则返回0

例pthread.c 

#include <stdio.h>
#include <pthread.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

void *func1(void *arg)
{
	static char *p = "t1 is run out";

	printf("t1:%ld thread is create\n",(unsigned long)pthread_self());//获取创建线程id 
	printf("t1:param is %d\n",*((int *)arg));

	pthread_exit((void *)p);//线程退出
}

int main()
{
	int ret;
	int param = 100;
	pthread_t t1;

	char *pret = NULL;

	ret = pthread_create(&t1, NULL, func1,(void *)&param);//线程创建
	if(ret == 0){
		printf("main:create t1 success\n");
	}


	printf("main:%ld\n",(unsigned long)pthread_self());//获取主线程id 

	pthread_join(t1,(void **)&pret);//线程等待

	printf("main: t1 quit: %s\n",pret);

	return 0;
}

三、与互斥锁相关API 

参考：Linux系统编程-(pthread)线程通信(互斥锁)_DS小龙哥的博客-CSDN博客_linux线程互斥锁的使用方法

互斥锁就是用来保护某一个资源不能同时被2个或者2个以上的线程使用。

为什么需要加锁？
        就是因为多个线程共用进程的资源，要访问的是公共区间时（全局变量），当一个线程访问的时候，需要加上锁以防止另外的线程对它进行访问，以实现资源的独占。在一个时刻只能有一个线程掌握某个互斥锁，拥有上锁状态的线程才能够对共享资源进行操作。若其他线程希望上锁一个已经上锁了的互斥锁，则该线程就会挂起，直到上锁的线程释放掉互斥锁为止。

#include <pthread.h>
//初始化互斥锁
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
//销毁互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex); 
//上锁: 阻塞方式
int pthread_mutex_lock(pthread_mutex_t *mutex);
//上锁: 非阻塞方式
int pthread_mutex_trylock(pthread_mutex_t *mutex);
//解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

说明:  对于Linux下的信号量/读写锁文件进行编译,需要在编译选项中指明-D_GNU_SOURCE
否则用gcc编译就会出现
PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP未声明(在此函数内第一次使用) 这样的提示。
例如: $ gcc app.c -lpthread -D_GNU_SOURCE

pthread_mutex.c

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;

pthread_mutex_t mutex;

void *func1(void *arg)
{
	printf("t1:%ld thread is create\n",(unsigned long)pthread_self());//获取线程id 
	printf("t1:param is %d\n",*((int *)arg));
	
	pthread_mutex_lock(&mutex);// 加锁
	while(1){
		printf("t1: %d\n",g_data++);	
		sleep(1);

		if(g_data == 3){
			pthread_mutex_unlock(&mutex);// 解锁
			printf("t1 quit================================\n");
//			pthread_exit(NULL); //线程t1退出
			exit(0);            //整个程序退出
		}
	}
}

void *func2(void *arg)
{
	printf("t2:%ld thread is create\n",(unsigned long)pthread_self());//获取线程id 
	printf("t2:param is %d\n",*((int *)arg));
		
	while(1){
		printf("t2: %d\n",g_data);
		pthread_mutex_lock(&mutex);// 加锁
		g_data++;
		pthread_mutex_unlock(&mutex);// 解锁	
		sleep(1);
	}
}

int main()
{
	int ret;
	int param = 100;
	pthread_t t1;
	pthread_t t2;

	pthread_mutex_init(&mutex,NULL);//创建互斥锁

	ret = pthread_create(&t1, NULL, func1,(void *)&param);//线程创建
	if(ret == 0){
		printf("main:create t1 success\n");
	}
	ret = pthread_create(&t2, NULL, func2,(void *)&param);//线程创建
	if(ret == 0){
		printf("main:create t2 success\n");
	}

	printf("main:%ld\n",(unsigned long)pthread_self());//获取主线程id 
	while(1){
		printf("main: %d\n",g_data);	
		sleep(1);
	}

	pthread_join(t1,NULL);//线程等待
	pthread_join(t2,NULL);//线程等待
	pthread_mutex_destroy(&mutex);//销毁互斥锁

	return 0;
}

#include <stdlib.h>

int main()
{
	int i = 0;
	for(i=0; i<10; i++){
		system("./pthread_mutex");
	}
}

造成死锁

进程含有两把锁及以上。。。。

四、与条件变量相关API

        条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。

　　条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。

　　条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。

1. 创建及销毁条件变量

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t cond);
// 返回：若成功返回0，否则返回错误编号

　　除非需要创建一个非默认属性的条件变量，否则pthread_cont_init函数的attr参数可以设置为NULL。

2. 等待

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, cond struct timespec *restrict timeout);
// 返回：若成功返回0，否则返回错误编号

　　pthread_cond_wait等待条件变为真。如果在给定的时间内条件不能满足，那么会生成一个代表一个出错码的返回变量。传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作都是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。

　　pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数类似，只是多了一个timeout。timeout指定了等待的时间，它是通过timespec结构指定。

3. 触发

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t cond);
int pthread_cond_broadcast(pthread_cond_t cond);
// 返回：若成功返回0，否则返回错误编号

　　这两个函数可以用于通知线程条件已经满足。pthread_cond_signal函数将唤醒等待该条件的某个线程，而pthread_cond_broadcast函数将唤醒等待该条件的所有进程。

　　注意一定要在改变条件状态以后再给线程发信号。

pthread_cond.c

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

int g_data = 0;

pthread_mutex_t mutex;
pthread_cond_t cond;

void *func1(void *arg)
{
	printf("t1:%ld thread is create\n",(unsigned long)pthread_self());// 获取线程id 
	printf("t1:param is %d\n",*((int *)arg));
	static int cnt = 0;
	
	while(1){	
		pthread_cond_wait(&cond,&mutex);// 等待条件变量
		printf("t1 run================================\n");
		printf("t1: %d\n",g_data);	
		g_data = 0;
		sleep(1);
		if(cnt++ == 3){
			exit(1);
		}
	}
}

void *func2(void *arg)
{
	printf("t2:%ld thread is create\n",(unsigned long)pthread_self());// 获取线程id 
	printf("t2:param is %d\n",*((int *)arg));
	
	while(1){
		printf("t2: %d\n",g_data);
		pthread_mutex_lock(&mutex);// 加锁
		g_data++;
		if(g_data == 3){
			pthread_cond_signal(&cond);// 触发条件变量
		}
		pthread_mutex_unlock(&mutex);// 解锁	
		sleep(1);
	}
}

int main()
{
	int ret;
	int param = 100;
	pthread_t t1;
	pthread_t t2;

	pthread_mutex_init(&mutex,NULL);// 创建互斥锁
	pthread_cond_init(&cond,NULL);// 创建条件变量


	ret = pthread_create(&t1, NULL, func1,(void *)&param);// 线程创建
	if(ret == 0){
//		printf("main:create t1 success\n");
	}

	ret = pthread_create(&t2, NULL, func2,(void *)&param);// 线程创建
	if(ret == 0){
//		printf("main:create t2 success\n");
	}

//	printf("main:%ld\n",(unsigned long)pthread_self());

	pthread_join(t1,NULL);// 线程等待
	pthread_join(t2,NULL);// 线程等待

	pthread_mutex_destroy(&mutex);// 销毁互斥锁
	pthread_cond_destroy(&cond);// 销毁条件变量
	return 0;
}

cond_con.c

#include <stdlib.h>

int main(int argc, char **argv)
{
	int time = atoi(argv[1]);
	int i=0;
	
	for(i=0;i<time;i++){
		system("./pthread_cond");
	}
}

静态初始化

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int main()
{
	
//	pthread_mutex_init(&mutex,NULL);
//	pthread_cond_init(&cond,NULL);

}