Linux系统编程多线程技术

线程

线程是轻量级的代码并行技术;线程不需要复制进程的资源,而是直接共享进程的资源;

线程只需要一个额外的栈就可以了;因此很多应用都是使用多线程技术;

主流的操作系统支持多进程,每个进程的内部支持多线程,线程可以嵌套;

JAVA语言中没有进程概念,因为Java本身是运行在虚拟机中的,而虚拟机本身就是一个进程;

大多数应用程序都是使用多线程;

如何实现代码并行?

程序代码执行至少需要CPU(中央处理器)和内存,代码的并行就需要多个CPU和多段内存;

内存可分段,CPU可分时间片;

大多系统采用CPU时间片实现代码的并行(伪并行);首先把CPU的运行时间分成极小的CPU时间片,然后每个线程拿一片,有时间片的线程就有运行的权利,但先后次序是完全无序的;一轮之后再重新分配CPU时间片;

人的感官是需要时间的,假定人的视觉需要0.1s, 0.1s = 100 ms,此时分1 ms做一个CPU时间片,有4个线程A B C D,每个线程先拿1 ms的CPU时间片,当我们看到四个线程时,每个线程都运行了25 ms;

多线程之间是乱序运行,但每个线程内部都是顺序执行;

线程和线程之间是互相独立,但又互有影响(资源有共享);

多线程可以提升程序的效率;如多线程下载工具;

每个进程的内部至少有一个线程,就是main(),叫主线程;

主线程一旦结束,进程就随之结束,其他线程就随着进程的结束而结束;

Unix有哪些关于线程的API(Application Program Interface应用编程接口);

多线程的开发定义在POSIX规范中,使用pthread.h头文件;

所有的函数放在libpthread.so共享库文件中;编译和链接要使用-pthread选项或-lpthread;双L连接法,L和l在此可以省略;

函数基本上都是以pthread_开头的;

pthread即process中的thread;线程是隶属于进程的;

创建线程的函数

pthread_create()

int pthread_create(//参数4个针(全是指针);

pthread_t *id, //线程ID;

const pthread_attr_t *attr, //线程属性,一般给0(默认);

void *(*task) (void *), //函数指针

void *argue //传给函数指针所调用函数需要使用的参数,无参数用0

);

参数id用于存储线程ID,每个线程用ID做标识;

attr是线程属性,默认给0即可;

task是函数指针,参数和返回值都可以是任意类型,没有限制;

argue是task的参数,函数指针只能传函数地址,而参数用argue传入;

成功返回0,失败返回错误码;

注意线程的函数基本都返回错误码,而不使用errno(errno是全局变量,会相互覆盖,不能确定是谁改变的),因此处理线程的错误要使用strerror(),不能使用perror();

On success, pthread_create() returns 0;

on error, it returns an error number, and the contents of *thread are undefined;

C语言用外部的全局变量errno(error number)记录错误信息;错误信息分为错误编号(int)和具体信息(字符串);每个错误编号都对应一个具体信息;errno存储的是错误编号;

函数strerror()/perror()/printf()用于错误信息的显示和转换;

strerror() //传入一个编号,返回具体信息(转换函数);

perror() //不用传入错误编号,直接打印errno对应的信息(会自动换行);

printf("%m") //直接打印errno对应的信息;

不是所有的函数都使用errno处理处理错误,比如线程的函数;

pthread_self()函数可以取得当前线程的线程ID;

/*
* 线程创建练习
*/
#include <stdio.h>
#include <pthread.h>
#include <string.h>
void *task(void *p) {
int i = 0;
for (i = 0; i <= 50; i++) {
printf("task:%02d\t", i);
}
printf("\n");
}
int main() {
pthread_t id, mid;
/* 启动一个线程,执行task()函数; */
int res = pthread_create(&id, 0, task, 0); //不会阻塞
/* 不会等待线程的运行或结束 */
if (res) {
printf("%s\n", strerror(res));
}
mid = pthread_self();    //取当前线程的ID;
printf("新启动线程id:%u,当前线程id:%u\n", id, mid);
/* 线程的id比较大,需要用%u匹配; */
int i = 0;
for (i = 0; i <= 50; i++) {
printf("M***:%02d\t", i);
}
printf("\n");
usleep(100000);        //主线程结束,进程结束;
/* 总闸关闭,所有的小开关都失效了 */
return 0;
}

/*
* 线程传参与资源共享;
*/
#include <stdio.h>
#include <pthread.h>
void *task(void *p) {
int *pi = (int *)p;
printf("*pi = %d\n", *pi);
*pi = 200;
}
int main() {
pthread_t id;
int x = 100;
pthread_create(&id, 0, task, &x);
sleep(1);
pthread_join(id, NULL); //可以等待线程(id)的结束;
printf("x = %d\n", x); //200
/* 线程不复制进程的资源,直接共享进程的资源; */
return 0;
}

在创建线程时,传参是传递地址,但直接传递整数(指针的本质也是整数)也是可行的;

在传地址时,注意保证地址是有效的;空指针/野指针/已经被free()的堆区指针都是无效的;

/*
* 线程传参练习
*/
#include <stdio.h>
#include <string.h>
#include <pthread.h>
/* 练习写一个线程,传入半径,计算圆的面积; */
void *task1(void *p) {
double r = *(double *)p;
printf("圆面积:%lg\n", 3.14 * r * r);
}
void *task2(void *p) {
/* 特殊用法,把整数当指针传入,然后再把指针当整数用 */
/* 拿指针当整数来用 */
int i = (int)p;
printf("i = %d\n", i);
}
int main() {
pthread_t id1, id2;
double r;
printf("please input r:\n");
scanf("%lf", &r);
pthread_create(&id1, 0, task1, &r);
/* pthread_join()可以让一个线程等待另外一个线程结束 */
pthread_join(id1, NULL);
int x = 100;
/*
* int *px;//野指针不可以做参数传入
* //结果不确定或段错误
* pthread_create(&id2, 0, task2, px);
*/
pthread_create(&id2, 0, task2, (void *)x);
pthread_join(id2, NULL);
printf("x = %d\n", x);
return 0;
}

pthread_join()函数可以让一个线程等待另外一个线程;

比如在线程a中调用了pthread_join(b, NULL),线程a会等待线程b结束;

线程没有父子线程之说;

线程可以有返回值,返回值由pthread_join()函数的第二个参数带回;

线程返回值类型是 void *,因此参数的类型就是 void **类型;

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

/*
* pthread_join()取线程的返回值
*/
#include <stdio.h>
#include <pthread.h>
#include <string.h>
/*
* char *get() {
*     //return "abc";//可以,返回一个有效的地址;
*     char *s1 = "abc";    ///返回指向字面值的指针可以;
*     return s1;
*     //char s2[] = "abc";//指向栈区的指针,不可以;
*     //return s2;
*     //返回值类型可以是指针;不能是数组,不能确定大小;
* }
* int *test() {
*     //int x = 100; return &x; //不可以返回局部变量的地址;
*     static int x = 100;
*     return &x;
* }
*/
void *task1(void *p) {
static int sum = 0;
int i = 0;
for (i = 1; i <= 10; i++) {
sum += i;
}
return ∑ //pp = ∑//将返回值&num给pp带回
}
void *task2(void *p) {
int sum = 0;
int i = 0;
for (i = 1; i <= 100; i++) {
sum += i;
}
return (void*)sum;
}
int main() {
pthread_t id1, id2;
pthread_create(&id1, 0, task1, NULL);
int *p;
pthread_join(id1, (void **)&p);    //p不再是野指针
//p是一级指针,&p是二级指针;join函数中要转换成void**;
//只要保持p和函数return后面类型一致即可;
printf("sum is %d\n", *p);
int num;
pthread_create(&id2, 0, task2, NULL);
pthread_join(id2, (void **)&num);
printf("sum is %d\n", num);
/*
* printf("可以取到%s\n", get());
* int *pi = test();
* printf("可以取到%d\n", *pi);
*/
return 0;
}

关于返回值的一些常识

1-> 返回值类型不能是数组,但可以是指针;

2-> 可以返回局部变量,但不能返回指向局部变量的地址;

3-> static 修饰的局部变量地址可以返回;//在全局区;

线程的退出

1.正常退出

在线程的函数中执行了return;语句;

执行了void pthread_exit(void* retval)函数;

2.非正常退出

被其他线程用int pthread_cancel(pthread_t thread)取消;

自身运行出了问题;

注:exit()退出的是进程,不能用于退出线程;否则所有线程全结束;

信号退出的是进程,也不能用于退出线程;

/*
* pthread_exit()
*/
#include <stdio.h>
#include <pthread.h>
#include <string.h>
void *task1(void *p) {
int i = 0;
while (++i) {
printf("1");
if (i >= 1000) {
pthread_exit((void*)i);
/* 退出进程并返回指针的值; */
}
}
}
void *task2(void *p) {
while (1) printf("2");
}
int main() {
pthread_t id1, id2;
pthread_create(&id1, 0, task1, NULL);
pthread_create(&id2, 0, task2, NULL);
int *p;
pthread_join(id1, (void **)&p);
printf("thread 1 return: %d\n", p);
if (!pthread_cancel(id2)) {
/* 取消一个线程的执行,成功结束返回0 */
printf("thread 2 has been canceled\n");
}
return 0;
}

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

功能

调用这将挂起并等待新进程终止;

当新线程调用pthread_exit()退出或者return时,进程中的其他线程可通过pthread_join()获得进程的提出状态;

使用约束

一个新线程仅仅允许一个线程使用该函数等待它终止;

被等待线程应处于可join状态,即非DETACHED状态;

返回值

成功返回0,失败返回错误码;

说明

类似于waitpid()函数;

线程执行轨迹

同步方式(非分离状态)

等待新创建线程结束;

只有当pthread_join()函数返回时,创建的线程才终止,才可释放自己占用的系统资源;

异步方式(分离状态)

未被其他线程等待,自己运行结束即可终止线程并释放系统资源(自爆);

返回值是无法被pthread_join()拿到的;

还有一种既不pthread_join()也不分离的,没人回收;

线程的状态:分离和非分离

线程同步技术:互斥量/互斥锁/信号量;

线程虽然共享了资源,但还是有自己的栈区内存;

线程资源的回收有以下三种可能

1.非分离的线程:调用了pthread_join(),资源在pthread_join()函数结束时立即回收;(有人监护);

2.分离的线程;线程一结束立即回收资源;(不设监护人,自觉型的);

3.非分离的线程,也没有被pthread_join();资源不一定何时回收;应尽量避免;(没人看护,也不够自觉);

因此,线程最好处于分离状态或被pthread_join(),资源才会正常回收;

如果把线程设置为join状态,只需在创建线程以后调用pthread_join()即可;

如果把线程设置为分离状态,只需在创建线程以后调用pthread_detach(id)即可;处于detach状态的线程pthread_join()函数无效;

/*
* pthread_detach()函数演示
*/
#include <stdio.h>
#include <pthread.h>
void *task(void *p) {
int i;
for (i = 0; i < 10; i++) {
printf("task:%d\t", i);
usleep(10000);
}
}
int main() {
pthread_t id;
pthread_create(&id, 0, task, 0);
pthread_detach(id);
//分离状态join无效;
/* pthread_join(id, 0); */
/* 主线程不会等待id线程结束; */
int i;
for (i = 0; i < 10; i++) {
printf("main:%d\n", i);
usleep(10000);
}
printf("The program over\n");
return 0;
}

如果先pthread_join()再pthread_detach()的话,detach是无效的废代码,因为pthread_join()会等待线程结束,这是pthread_join()已经没有意义了;

请继续浏览下一篇，多线程同步技术