Linux下多线程编程详解
https://www.doczj.com/doc/4317070872.html,/u/25975/showart_402864.htm
线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris 是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。
现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。
为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。
使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。
使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。
除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：
1) 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
2) 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU 上。
3) 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。
下面我们先来尝试编写一个简单的多线程程序。
简单的多线程编程
Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下面我们展示一个最简单的多线程程序pthread_create.c。
一个重要的线程创建函数原型：
#include
int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr, void *(*start_rtn)(void),void *restrict arg);
返回值：若是成功建立线程返回0,否则返回错误的编号
形式参数：
pthread_t *restrict tidp 要创建的线程的线程id指针
const pthread_attr_t *restrict attr 创建线程时的线程属性
void* (start_rtn)(void) 返回值是void类型的指针函数
void *restrict arg start_rtn的行参
例程1：
功能：创建一个简单的线程
程序名称：pthread_create.c
/******************************************************************************************** ** Name:pthread_create.c
** Used to study the multithread programming in Linux OS
** Author:zeickey
** Date:2006/9/16
** Copyright (c) 2006,All Rights Reserved!
******************************************************************************************** */
#include
#include
void *myThread1(void)
{
int i;
for (i=0; i<100; i++)
{
printf("This is the 1st pthread,created by zieckey.\n");
sleep(1);//Let this thread to sleep 1 second,and then continue to run }
}
void *myThread2(void)
{
int i;
for (i=0; i<100; i++)
{
printf("This is the 2st pthread,created by zieckey.\n");
sleep(1);
}
}
int main()
{
int i=0, ret=0;
pthread_t id1,id2;
ret = pthread_create(&id2, NULL, (void*)myThread1, NULL);
if (ret)
{
printf("Create pthread error!\n");
return 1;
}
ret = pthread_create(&id2, NULL, (void*)myThread2, NULL);
if (ret)
{
printf("Create pthread error!\n");
return 1;
}
pthread_join(id1, NULL);
pthread_join(id2, NULL);
return 0;
}
我们编译此程序：
# gcc pthread_create.c -lpthread
因为pthread的库不是linux系统的库，所以在进行编译的时候要加上-lpthread，否则编译不过，会出现下面错误
thread_test.c: 在函数‘create’ 中：
thread_test.c:7: 警告：在有返回值的函数中，程序流程到达函数尾
/tmp/ccOBJmuD.o: In function `main':thread_test.c:(.text+0x4f)：对‘pthread_create’未定义的引用
collect2: ld 返回1
运行，我们得到如下结果：
# ./a.out
This is the 1st pthread,created by zieckey.
This is the 2st pthread,created by zieckey.
This is the 1st pthread,created by zieckey.
This is the 2st pthread,created by zieckey.
This is the 2st pthread,created by zieckey.
This is the 1st pthread,created by zieckey.
....
两个线程交替执行。
此例子介绍了创建线程的方法。
下面例子介绍向线程传递参数。
例程2：
功能：向新的线程传递整形值
程序名称：pthread_int.c
/******************************************************************************************** ** Name:pthread_int.c
** Used to study the multithread programming in Linux OS
** Pass a parameter to the thread.
** Author:zeickey
** Date:2006/9/16
** Copyright (c) 2006,All Rights Reserved!
******************************************************************************************** */
#include
#include
#include
void *create(void *arg)
{
int *num;
num=(int *)arg;
printf("create parameter is %d \n",*num);
return (void *)0;
}
int main(int argc ,char *argv[])
{
pthread_t tidp;
int error;
int test=4;
int *attr=&test;
error=pthread_create(&tidp,NULL,create,(void *)attr);
if(error)
{
printf("pthread_create is created is not created ... \n");
return -1;
}
sleep(1);
printf("pthread_create is created ...\n");
return 0;
}
编译方法：
gcc -lpthread pthread_int.c -Wall
执行结果：
create parameter is 4
pthread_create is created is created ...
例程总结：
可以看出来，我们在main函数中传递的整行指针，传递到我们新建的线程函数中。
在上面的例子可以看出来我们向新的线程传入了另一个线程的int数据，线程之间还可以传递字符串或是更复杂的数据结构。
例程3：
程序功能：向新建的线程传递字符串
程序名称：pthread_string.c
/******************************************************************************************** ** Name:pthread_string.c
** Used to study the multithread programming in Linux OS
** Pass a ‘char*‘ parameter to the thread.
** Author:zeickey
** Date:2006/9/16
** Copyright (c) 2006,All Rights Reserved!
******************************************************************************************** */
#include
#include
#include
void *create(void *arg)
{
char *name;
name=(char *)arg;
printf("The parameter passed from main function is %s \n",name);
return (void *)0;
}
int main(int argc, char *argv[])
{
char *a="zieckey";
int error;
pthread_t tidp;
error=pthread_create(&tidp, NULL, create, (void *)a);
if(error!=0)
{
printf("pthread is not created.\n");
return -1;
}
sleep(1);
printf("pthread is created... \n");
return 0;
}
编译方法：
gcc -Wall pthread_string.c -lpthread
执行结果：
The parameter passed from main function is zieckey
pthread is created...
例程总结：
可以看出来main函数中的字符串传入了新建的线程中。
Linux下多线程编程详解2
例程4：
程序功能：向新建的线程传递字符串
程序名称：pthread_struct.c
/******************************************************************************************** ** Name:pthread_struct.c
** Used to study the multithread programming in Linux OS
** Pass a ‘char*‘ parameter to the thread.
** Author:zeickey
** Date:2006/9/16
** Copyright (c) 2006,All Rights Reserved!
******************************************************************************************** */
#include
#include
#include
#include
struct menber
{
int a;
char *s;
};
void *create(void *arg)
{
struct menber *temp;
temp=(struct menber *)arg;
printf("menber->a = %d \n",temp->a);
printf("menber->s = %s \n",temp->s);
return (void *)0;
}
int main(int argc,char *argv[])
{
pthread_t tidp;
int error;
struct menber *b;
b=(struct menber *)malloc( sizeof(struct menber) );
b->a = 4;
b->s = "zieckey";
error = pthread_create(&tidp, NULL, create, (void *)b);
if( error )
{
printf("phread is not created...\n");
return -1;
}
sleep(1);
printf("pthread is created...\n");
return 0;
}
编译方法：
gcc -Wall pthread_struct.c -lpthread
执行结果：
menber->a = 4
menber->s = zieckey
pthread is created...
例程总结：
可以看出来main函数中的一个结构体传入了新建的线程中。
线程包含了标识进程内执行环境必须的信息。他集成了进程中的所有信息都是对线程进行共享的，包括文本程序、程序的全局内存和堆内存、栈以及文件描述符。
例程5：
程序目的：验证新建立的线程可以共享进程中的数据
程序名称：pthread_share.c
/******************************************************************************************** ** Name:pthread_share_data.c
** Used to study the multithread programming in Linux OS
** Pass a ‘char*‘ parameter to the thread.
** Author:zeickey
** Date:2006/9/16
** Copyright (c) 2006,All Rights Reserved!
********************************************************************************************
#include
#include
#include
static int a=4;
void *create(void *arg)
{
printf("new pthread ... \n");
printf("a=%d \n",a);
return (void *)0;
}
int main(int argc,char *argv[])
{
pthread_t tidp;
int error;
a=5;
error=pthread_create(&tidp, NULL, create, NULL);
if(error!=0)
{
printf("new thread is not create ... \n");
return -1;
}
sleep(1);
printf("new thread is created ... \n");
return 0;
}
编译方法：
gcc -Wall pthread_share_data.c -lpthread
执行结果：
new pthread ...
a=5
new thread is created ...
例程总结：
可以看出来，我们在主线程更改了我们的全局变量a的值的时候，我们新建立的线程则打印出来了改变的值，可以看出可以访问线程所在进程中的数据信息。
2、线程的终止
如果进程中任何一个线程中调用exit，_Exit,或者是_exit，那么整个进程就会终止，
与此类似，如果信号的默认的动作是终止进程，那么，把该信号发送到线程会终止进程。
线程的正常退出的方式：
(1) 线程只是从启动例程中返回，返回值是线程中的退出码
(2) 线程可以被另一个进程进行终止
(3) 线程自己调用pthread_exit函数
两个重要的函数原型：
#include
void pthread_exit(void *rval_ptr);
/*rval_ptr 线程退出返回的指针*/
int pthread_join(pthread_t thread,void **rval_ptr);
/*成功结束进程为0,否则为错误编码*/
例程6
程序目的：线程正常退出，接受线程退出的返回码
程序名称：pthread_exit.c
/******************************************************************************************** ** Name:pthread_exit.c
** Used to study the multithread programming in Linux OS
** A example showing a thread to exit and with a return code.
** Author:zeickey
** Date:2006/9/16
** Copyright (c) 2006,All Rights Reserved!
******************************************************************************************** */
#include
#include
#include
void *create(void *arg)
{
printf("new thread is created ... \n");
return (void *)8;
}
int main(int argc,char *argv[])
{
pthread_t tid;
int error;
void *temp;
error = pthread_create(&tid, NULL, create, NULL);
if( error )
{
printf("thread is not created ... \n");
return -1;
}
error = pthread_join(tid, &temp);
if( error )
{
printf("thread is not exit ... \n");
return -2;
}
printf("thread is exit code %d \n", (int )temp);
return 0;
编译方法：
gcc -Wall pthread_exit.c -lpthread
执行结果：
new thread is created ...
thread is exit code 8
例程总结：
可以看出来，线程退出可以返回线程的int数值。线程退出不仅仅可以返回线程的int数值，还可以返回一个复杂的数据结构。
例程7
程序目的：线程结束返回一个复杂的数据结构
程序名称：pthread_return_struct.c
#include
#include
#include
struct menber
{
int a;
char *b;
}temp={8,"zieckey"};
void *create(void *arg)
{
printf("new thread ... \n");
return (void *)&temp;
}
int main(int argc,char *argv[])
{
int error;
pthread_t tid;
struct menber *c;
error = pthread_create(&tid, NULL, create, NULL);
if( error )
{
printf("new thread is not created ... \n");
return -1;
}
printf("main ... \n");
error = pthread_join(tid,(void *)&c);
if( error )
{
printf("new thread is not exit ... \n");
return -2;
}
printf("c->a = %d \n",c->a);
printf("c->b = %s \n",c->b);
sleep(1);
return 0;
}
编译方法：
gcc -Wall pthread_return_struct.c -lpthread
执行结果：
main ...
new thread ...
c->a = 8
c->b = zieckey
例程总结：
一定要记得返回的数据结构要是在这个数据要返回的结构没有释放的时候应用，
如果数据结构已经发生变化，那返回的就不会是我们所需要的，而是脏数据
3、线程标识
函数原型：
#include
pthread_t pthread_self(void);
pid_t getpid(void);
getpid()用来取得目前进程的进程识别码,函数说明
例程8
程序目的：实现在新建立的线程中打印该线程的id和进程id
程序名称：pthread_id.c
/******************************************************************************************** ** Name:pthread_id.c
** Used to study the multithread programming in Linux OS.
** Showing how to get the thread's tid and the process's pid.
** Author:zeickey
** Date:2006/9/16
** Copyright (c) 2006,All Rights Reserved!
******************************************************************************************** */
#include
#include
#include
void *create(void *arg)
{
printf("New thread .... \n");
printf("This thread's id is %u \n", (unsigned int)pthread_self());
printf("The process pid is %d \n",getpid());
return (void *)0;
}
int main(int argc,char *argv[])
{
pthread_t tid;
int error;
printf("Main thread is starting ... \n");
error = pthread_create(&tid, NULL, create, NULL);
if(error)
{
printf("thread is not created ... \n");
return -1;
}
printf("The main process's pid is %d \n",getpid());
sleep(1);
return 0;
}
编译方法：
gcc -Wall -lpthread pthread_id.c
执行结果：
Main thread is starting ...
The main process's pid is 3307
New thread ....
This thread's id is 3086347152
The process pid is 3307
实验七：Linux多线程编程(实验报告)
————————————————————————————————作者：————————————————————————————————日期：
实验七：Linux多线程编程（4课时） 实验目的：掌握线程的概念；熟悉Linux下线程程序编译的过程；掌握多线程程序编写方法。 实验原理：为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。 1 多线程概念 使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间。 使用多线程的理由之二是线程间方便的通信机制。同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。2多线程编程函数 Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义： typedef unsigned long int pthread_t; 它是一个线程的标识符。 函数pthread_create用来创建一个线程，它的原型为： extern int pthread_create((pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)); 第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。 函数pthread_join用来等待一个线程的结束。函数原型为： extern int pthread_join(pthread_t th, void **thread_return); 第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。 函数pthread_exit的函数原型为： extern void pthread_exit(void *retval); 唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。 3 修改线程的属性 线程属性结构为pthread_attr_t，它在头文件/usr/include/pthread.h中定义。属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。 设置线程绑定状态的函数为pthread_attr_setscope，它有两个参数，第一个是指向属性结构的指针，第二个是绑定类型，它有两个取值：PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS（非绑定的）。 另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。用函数pthread_attr_getschedparam和函数pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。 4 线程的数据处理
Posix线程编程指南（一） 线程创建与取消 这是一个关于Posix线程编程的专栏。作者在阐明概念的基础上，将向您详细讲述Posix线程库API。本文是第一篇将向您讲述线程的创建与取消。 线程创建 1．1 线程与进程 相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。在串行程序基础上引入线程和进程是为了提高程序的并发度，从而提高程序运行效率和响应时间。 线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。 1．2 创建线程 POSIX通过pthread_create()函数创建线程，API定义如下： 与fork()调用创建一个进程的方法不同，pthread_create()创建的线程并不具备与主线程（即调用pthread_create()的线程）同样的执行序列，而是使其运行 start_routine(arg)函数。thread返回创建的线程ID，而attr是创建线程时设置的线程属性（见下）。pthread_create()的返回值表示线程创建是否成功。尽管arg是void *类型的变量，但它同样可以作为任意类型的参数传给start_routine()函数；同时，start_routine()可以返回一个void *类型的返回值，而这个返回值也可以是其他类型，并由pthread_join()获取。 1．3 线程创建属性 pthread_create()中的attr参数是一个结构指针，结构中的元素分别对应着新线程的运行属性，主要包括以下几项： __detachstate，表示新线程是否与进程中其他线程脱离同步，如果置位则新线程不能用pthread_join()来同步，且在退出时自行释放所占用的资源。缺省为 PTHREAD_CREATE_JOINABLE状态。这个属性也可以在线程创建并运行以后用pthread_detach()来设置，而一旦设置为PTHREAD_CREATE_DETACH状态（不论是创建时设置还是运行时设置）则不能再恢复到PTHREAD_CREATE_JOINABLE状态。
Linux下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特 有的系统调用，他的使用方式类似fork. int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr, void *(*start_rtn)(void),void *restrict arg); 返回值：若是成功建立线程返回0,否则返回错误的编号 形式参数： pthread_t *restrict tidp 要创建的线程的线程id指针 const pthread_attr_t *restrict attr 创建线程时的线程属性 void* (start_rtn)(void) 返回值是void类型的指针函数 void *restrict arg start_rtn的行参 进行编译的时候要加上-lpthread 向线程传递参数。 例程2： 功能：向新的线程传递整形值 #include
关于linux线程 在许多经典的操作系统教科书中, 总是把进程定义为程序的执行实例, 它并不执行什么, 只是维护应用程序所需的各种资源. 而线程则是真正的执行实体.为了让进程完成一定的工作, 进程必须至少包含一个线程. 如图1. 进程所维护的是程序所包含的资源(静态资源), 如: 地址空间, 打开的文件句柄集, 文件系统状态, 信号处理handler, 等; 线程所维护的运行相关的资源(动态资源), 如: 运行栈, 调度相关的控制信息, 待处理的信号集, 等; 然而, 一直以来, linux内核并没有线程的概念. 每一个执行实体都是一个task_struct结构, 通常称之为进程. 如图2. 进程是一个执行单元, 维护着执行相关的动态资源. 同时, 它又引用着程序所需的静态资源.通过系统调用clone创建子进程时, 可以有选择性地让子进程共享父进程所引用的资源. 这样的子进程通常称为轻量级进程.linux上的线程就是基于轻量级进程, 由用户态的pthread库实现的.使用pthread以后, 在用户看来, 每一个task_struct就对应一个线程, 而一组线程以及它们所共同引用的一组资源就是一个进程.但是, 一组线程并不仅仅是引用同一组资源就够了, 它们还必须被视为一个整体.对此, POSIX标准提出了如下要求: 1, 查看进程列表的时候, 相关的一组task_struct应当被展现为列表中的一个节点; 2, 发送给这个"进程"的信号(对应kill系统调用), 将被对应的这一组task_struct所共享, 并且被其中的任意一个"线程"处理; 3, 发送给某个"线程"的信号(对应pthread_kill), 将只被对应的一个task_struct接收, 并且由它自己来处理; 4, 当"进程"被停止或继续时(对应SIGSTOP/SIGCONT信号), 对应的这一组task_struct 状态将改变; 5, 当"进程"收到一个致命信号(比如由于段错误收到SIGSEGV信号), 对应的这一组task_struct将全部退出; 6, 等等(以上可能不够全); linuxthreads
介绍：什么是线程，线程的优点是什么 线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可以看作是Unix进程的表亲，同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境（register context)，自己的线程本地存储(thread-local storage)。 一个进程可以有很多线程，每条线程并行执行不同的任务。 线程可以提高应用程序在多核环境下处理诸如文件I/O或者socket I/O等会产生堵塞的情况的表现性能。在Unix系统中，一个进程包含很多东西，包括可执行程序以及一大堆的诸如文件描述符地址空间等资源。在很多情况下，完成相关任务的不同代码间需要交换数据。如果采用多进程的方式，那么通信就需要在用户空间和内核空间进行频繁的切换，开销很大。但是如果使用多线程的方式，因为可以使用共享的全局变量，所以线程间的通信（数据交换）变得非常高效。 Hello World(线程创建、结束、等待） 创建线程 pthread_create 线程创建函数包含四个变量，分别为： 1. 一个线程变量名，被创建线程的标识 2. 线程的属性指针，缺省为NULL即可 3. 被创建线程的程序代码 4. 程序代码的参数 For example： - pthread_t thrd1? - pthread_attr_t attr? - void thread_function(void argument)? - char *some_argument? pthread_create(&thrd1, NULL, (void *)&thread_function, (void *) &some_argument); 结束线程 pthread_exit 线程结束调用实例：pthread_exit(void *retval); //retval用于存放线程结束的退出状态 线程等待 pthread_join pthread_create调用成功以后，新线程和老线程谁先执行，谁后执行用户是不知道的，这一块取决与操作系统对线程的调度，如果我们需要等待指定线程结束，需要使用pthread_join函数，这个函数实际上类似与多进程编程中的waitpid。 举个例子，以下假设 A 线程调用 pthread_join 试图去操作B线程，该函数将A线程阻塞，直到B线程退出，当B线程退出以后，A线程会收集B线程的返回码。 该函数包含两个参数：pthread_t th //th是要等待结束的线程的标识 void **thread_return //指针thread_return指向的位置存放的是终止线程的返回状态。 调用实例：pthread_join(thrd1, NULL); example1： 1 /************************************************************************* 2 > F i l e N a m e: t h r e a d_h e l l o_w o r l d.c 3 > A u t h o r: c o u l d t t(f y b y) 4 > M a i l: f u y u n b i y i@g m a i l.c o m 5 > C r e a t e d T i m e: 2013年12月14日 星期六 11时48分50秒 6 ************************************************************************/ 7 8 #i n c l u d e 9 #i n c l u d e 10 #i n c l u d e
11 12 v o i d p r i n t_m e s s a g e_f u n c t i o n (v o i d *p t r)? 13 14 i n t m a i n() 15 { 16 i n t t m p1, t m p2?
Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux 下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下面我们展示一个最简单的多线程程序example1.c。 /* example.c*/ #include
2.终止线程 (2) 3. 等待线程终止 (2) pthread_exit和pthread_join进一步说明： (3) 4.分离线程 (7) 5.获取线程标识符 (8) 6.比较线程ID (8) 7.一次性初始化 (8) 8. 设置线程的调度策略和优先级 (9) 9. 获取线程的优先级 (11) 10.取消线程 (12) 取消线程，是否会释放线程的所有资源？例子： (14) 设置取消类型 (16) 11.初始化属性 (17) 12.设置分离状态 (18) 13.设置范围 (18) 14. 设置继承的调度策略 (18) 16. 设置调度参数 (19) 17.初始化互斥锁 (21) 18.销毁互斥锁 (21) 19.锁定互斥锁 (22) 20.解除锁定互斥锁 (23) 21. 互斥锁的类型： (23) 22. 初始化互斥锁属性对象 (23) 23. 销毁互斥锁属性对象 (23) 24.设置互斥锁类型的属性 (24) 互斥锁动态初始化和静态初始化区别： (26) 销毁互斥锁：事实上没做任何销毁操作，如下： (27) 非递归类型的互斥锁解锁和加锁操作： (27) 29.初始化条件变量 (27) 30.基于条件变量阻塞 (27) 31.解除阻塞一个线程 (28) 31.解除阻塞所有线程 (29) 33. 在指定的时间之前阻塞 (30) 32.唤醒丢失问题 (31) 33. 计数信号量概述 (31) 34. 初始化信号 (31) 35. 增加信号 (31) 36. 基于信号计数进行阻塞 (32) 37.多线程链表添加删除例子（使用条件变量实现互斥）： (32) 38.为线程特定数据创建键 (34) 39. 删除线程特定数据键 (35) 40.设置线程特定数据 (35) 41. 获取线程特定数据 (35)
Linux 多线程编程问题 1重入问题 传统的UNIX没有太多考虑线程问题，库函数里过多使用了全局和静态数据，导致严重的线程重入问题。 1.1–D_REENTRANT /-pthread和errno的重入问题。 所先UNIX的系统调用被设计为出错返回-1，把错误码放在errno中（更简单而直 接的方法应该是程序直接返回错误码，或者通过几个参数指针来返回）。由于线程 共享所有的数据区，而errno是一个全局的变量，这里产生了最糟糕的线程重入问 题。比如： do { bytes = recv(netfd, recvbuf, buflen, 0); } while (bytes != -1 && errno != EINTR); 在上面的处理recv被信号打断的程序里。如果这时连接被关闭，此时errno应该不 等于EINTR，如果别的线程正好设置errno为EINTR，这时程序就可能进入死循环。 其它的错误码处理也可能进入不可预测的分支。 在线程需求刚开始时，很多方面技术和标准（TLS）还不够成熟，所以在为了 解决这个重入问题引入了一个解决方案，把errno定义为一个宏： extern int *__errno_location (void); #define errno (*__errno_location()) 在上面的方案里，访问errno之前先调用__errno_location()函数，线程库提供这个 函数，不同线程返回各自errno的地址，从而解决这个重入问题。在编译时加 -D_REENTRANT就是启用上面的宏，避免errno重入。另外-D_REENTRANT 还影响一些stdio的函数。在较高版本的gcc里，有很多嵌入函数的优化，比如把printf(“Hello\n”); 优化为 puts(“hello\n”); 之类的，有些优化在多线程下有问题。所以gcc引入了–pthread 参数，这个 参数出了-D_REENTRANT外，还校正一些针对多线程的优化。 因为宏是编译时确定的，所以没有加-D_REENTRANT编译的程序和库都有errno 重入问题，原则上都不能在线程环境下使用。不过在一般实现上主线程是直接使用 全局errno变量的，也就是__errno_location()返回值为全局&errno，所以那些没加 -D_REENTRANT编译的库可以在主线程里使用。这里仅限于主线程，有其它且只 有一个固定子线程使用也不行，因为子线程使用的errno地址不是全局errno变量 地址。 对于一个纯算法的库，不涉及到errno和stdio等等，有时不加_REENTRANT也是 安全的，比如一个纯粹的加密/解谜函数库。比较简单的判断一个库是否有errno问 题是看看这个库是使用了errno还是__errno_location()：
Linux多线程编程小结 愤怒的小狐狸----博客专栏 前一段时间因为开题的事情一直耽搁了我搞Linux的进度，搞的我之前学的东西都遗忘了，很烦躁的说，现在抽个时间把之前所学的做个小节。文章内容主要总结于《Linux程序设计第3版》。 1.Linux进程与线程 Linux进程创建一个新线程时，线程将拥有自己的栈（因为线程有自己的局部变量），但与它的创建者共享全局变量、文件描述符、信号句柄和当前目录状态。 Linux通过fork创建子进程与创建线程之间是有区别的：fork创建出该进程的一份拷贝，这个新进程拥有自己的变量和自己的PID，它的时间调度是独立的，它的执行几乎完全独立于父进程。 进程可以看成一个资源的基本单位，而线程是程序调度的基本单位，一个进程内部的线程之间共享进程获得的时间片。 2._REENTRANT宏 在一个多线程程序里，默认情况下，只有一个errno变量供所有的线程共享。在一个线程准备获取刚才的错误代码时，该变量很容易被另一个线程中的函数调用所改变。类似的问题还存在于fputs之类的函数中，这些函数通常用一个单独的全局性区域来缓存输出数据。 为解决这个问题，需要使用可重入的例程。可重入代码可以被多次调用而仍然工作正常。编写的多线程程序，通过定义宏_REENTRANT来告诉编译器我们需要可重入功能，这个宏的定义必须出现于程序中的任何#include语句之前。 _REENTRANT为我们做三件事情，并且做的非常优雅： （1）它会对部分函数重新定义它们的可安全重入的版本，这些函数名字一般不会发生改变，只是会在函数名后面添加_r字符串，如函数名gethostbyname 变成gethostbyname_r。 （2）stdio.h中原来以宏的形式实现的一些函数将变成可安全重入函数。 （3）在error.h中定义的变量error现在将成为一个函数调用，它能够以一种安全的多线程方式来获取真正的errno的值。
Linux多线程编程和Linux 2.6下的NPTL 这几天由于工作需要，琢磨了一下Linux下的多线程的相关资料。Linux下最常用的多线程支持库为Pthread库，它是glibc库的组成部分。但是关于Pthread的说明文档非常缺乏，特别是对POSIX多线程规范的介绍以及pthread库中多线程实现方式的介绍实在是少之又少。而多线程编程对于系统程序员而言是必须掌握的技术，因此总是让学习中的程序员觉得头痛不以。我自己也没有太多多线程编程的经验，在这里只是把自己收集到的一些关于Linux上多线程还算新的资料进行汇总来抛砖引玉，以便相互学习交流。 这里顺便提一下市面上有的一本介绍多线程的书《Posix 多线程编程》，它是英文版《Programming with POSIX Muiltthread》中译本，这也是半年前我所能找到的唯一专题介绍多线程编程的书。我个人感觉这本书的前面1/3之一的内容写的还是不错的，但是后面的东西就非常晦涩并且有很多明显的文字错误。看看这本书的翻译者是好几个人，估计每个人的翻译能力不同造成了这本书的虎头蛇尾。因此我不建议大家去买这本书作为圣经收藏。这本书前半步的内容主要围绕Posix的多线程，介绍的比较精彩的就是几个多线程编程模型，把多线程的互斥和同步机制介绍的挺酣畅的，推荐一看。这些内容并非这本书首创，早在《UNIX网络编程》第二卷进程间通信就有了这些经典的介绍，但是能系统的把这些机制结合到多线程编程中来还是有可圈可点之处的。此外毕竟《UNIX网络编程》两卷内容太老，书也太厚了，并不是大多数程序员所能坐下来细细看的。这里我还想表达一下对微软在技术上的不足斥责。在msdn中platform sdk部分中的windows多线程编程的内容真是简陋的可笑，只有傻兮兮的建立和退出线程的函数，关于互斥，条件的介绍一概全无。只能在它的sample代码中自己去找，sample 代码里面的线程同步方式居然是做一个死循环来死等，也不知道它把windows卖这么多钱是干什么吃的。MFC中多线程的封装倒是看上去像那么一回事情了，但是我想象不出在如此简陋的系统api上微软到底是如何实现出MFC上线程功能的。拥护windows的人不要在这里砸鸡蛋，最好也能写一篇windows上的多线程介绍除了。这比砸鸡蛋来得有意义多了。好了，书归正传继续说Linux上的多线程。 在Linux上，从内核角度而言，基本没有什么线程和进程的区别－－大家都是进程。一个进程的多个线程只是多个特殊的进程他们虽然有各自的进程描述结构，却共享了同一个代码上下文。在Linux上，这样的进程称为轻量级进程Light weight process。致此，就是关于线程的总体概念了，我们往往就在了解这个概念的情况下开始我们的多线程编程之旅。这对于多线程编程入门已经足够了，然而事实上线程却要复杂的多。首先多线程间的优先级调度，内存资源（栈）分配和信号投递就不是简单的共享同一个进程代码上下文所能所能解决的。其次，效率的问题：如何有效的使用多cpu资源（2.4内核的多线程就无法使用多个cpu，一个进程的线程都被限制在同一个cpu上运行）。因此多线程库Pthread的实现并不是一件简单的事情，它建立在特有的线程模型之上。 在Linux 2.4内核中，Linux内核中使用了一个内核线程来处理用户态进程中的多个线程的上下文切换（线程切换）。由于内核中并没有什么线程组的概念，即一个进程的多个线程，因此必须依靠在pthread库中实现一个额外的线程来管理其他用户线程（即用户程序生成的线程）的建立，退出，资源分配和回收以及线程的切换。由于当时硬件并没有线程寄存器之类的冬冬来支持多线程，因此线程的切换性能和低下，并且需要引入复杂的机制在进程的栈中为各个线程划分出各自的栈数据所在位置，并且在切换时进行栈数据拷贝。而最大的问题是内核中缺乏对线程间的同步机制的支持，因此pthread库不得不在底层依靠信号方式来实现同步，因此线程互斥中
声明：本文是网上整理的资料，版权属其作者本人所 有。 第一章线程基础知识 一．什么是线程在一个程序里的多个执行路线就叫做线程。更准确的定义是：线程是“一个 进程内部的一个控制序列”。 典型的unix进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程以后，在程序设计时可以把进程设计成在同一时刻能够做不止一件事，每个线程处理各只独立的任务。 二．线程的优点 （1）通过为每种事件类型的处理分配单独的线程，能够简化处理异步时间的代码。 （2）多个线程可以自动共享相同的存储地址空间和文件描述符。 （3）有些问题可以通过将其分解从而改善整个程序的吞吐量。 （4）交互的程序可以通过使用多线程实现相应时间的改善，多线程可以把程序中处理用户输入输出的部分与其它部分分开。 三．线程的缺点线程也有不足之处。编写多线程程序需要更全面更深入的思考。 在一个多线 程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的。调试一个多线程程序也比调试一个单线程程序困难得多四．线程的结构线程包含了表示进程内执行环境必需的信息，其中包括进程中标识线程的 线程ID，一组寄存器值、栈、调度优先级和策略、信号屏蔽子，errno变量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本，程序的全局内存和堆内存、栈以及文件描述符。 五．线程标识 就像每个进程有一个进程ID一样，每个线程也有一个线程ID，进程ID在 整个系统中是唯一的，但线程不同，线程ID只在它所属的进程环境中有效。线程ID用pthread_t数据类型来表示，实现的时候可以用一个结构来代表pthread_t 数据类型，所以可以移植的操作系统不能把它作为整数处理。因此必须使用函数来对来对两个线程ID进行比较。 1．
多线程同步的三种?方式: Linux 线程同步有最常?用的是：互斥锁、条件变量量和信号量量。?一、通过锁机制实现线程间的同步。初始化锁。在Linux下，线程的互斥量量数据类型是pthread_mutex_t。在使?用前,要对它进?行行初始化。静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 动态分配：int pthread_mutex_init(pthread_mutex_t mutex, const pthreadmutexattr_t mutexattr); 加锁。对共享资源的访问，要对互斥量量进?行行加锁，如果互斥量量已经上了了锁，调?用线程会阻塞，直到互斥量量被解锁。 int pthread_mutex_lock(pthread_mutex mutex); int pthread_mutex_trylock(pthread_mutex_t mutex);解锁。在完成了了对共享资源的访问后，要对互斥量量进?行行解锁。 int pthread_mutex_unlock(pthread_mutex_t mutex);销毁锁。锁在是使?用完成后，需要进?行行销毁以释放资源。 int pthread_mutex_destroy(pthread_mutex mutex); ?二、条件变量量(cond) 与互斥锁不不同，条件变量量是?用来等待?而不不是?用来上锁的。条件变量量?用来?自动阻塞?一个线程，直到某特殊情况发?生为?止。通常条件变量量和互斥锁同时使?用。条件变量量分为两部分: 条件和变量量。条件本身是由互斥量量保护的。线程在改变条件状态前先要锁住互斥量量。条件变量量使我们可以睡眠等待某种条件出现。条件变量量是利利?用线程间共享的全局变量量进?行行同步的?一种机制，主要包括两个动作：?一个线程等待"条件变量量的条件成?立"?而挂起；另?一个线程使"条件成?立"（给出条件成?立信号）。条件的检测是在互斥锁的保护下进?行行的。如果?一个条件为假，?一个线程?自动阻塞，并释放等待状态改变的互斥锁。如果另?一个线程改变了了条件，它发信号给关联的条件变量量，唤醒?一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量量可以被?用来实现这两进程间的线程同步。初始化条件变量量。静态态初始化，pthread_cond_t cond = PTHREAD_COND_INITIALIER; 动态初始化，int pthread_cond_init(pthread_cond_t cond, pthreadcondattrt cond_attr); 等待条件成?立。释放锁,同时阻塞等待条件变量量为真才?行行。timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有?一个线程wait) int pthread_cond_wait(pthread_cond_t cond, pthreadmutext mutex); int pthread_cond_timewait(pthread_cond_t cond,pthread_mutex mutex,const timespec abstime);激活条件变量量。 pthread_cond_signal,pthread_cond_broadcast（激活所有等待线程） int pthread_cond_signal(pthread_cond_t cond); int
Linux下C多线程编程 2007-08-24 10:07:56 Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux 下的多线程程序，需要使用头文件pthread.h，连接时需要使用库 libpthread.a。顺便说一下，Linux下pthread的实现是通过系统调用 clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下面我们展示一个最简单的多线程程序example1.c。 我们编译此程序： 运行example1，我们得到如下结果：
再次运行，我们可能得到如下结果： 前后两次结果不一样，这是两个线程争夺CPU资源的结果。上面的示例中，我们使用到了两个函数，pthread_create和pthread_join，并声明了一个pthread_t型的变量。 pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义： typedef unsigned long int pthread_t; 它是一个线程的标识符。函数pthread_create用来创建一个线程，它的原型为： 第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。这里，我们的函数thread不需要参数，所以最后一个参数设为空指针。第二个参数我们也设为空指针，这样将生成默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时，函数返回0，若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINVAL。前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。 函数pthread_join用来等待一个线程的结束。函数原型为： extern int pthread_join __P ((pthread_t __th, void **__thread_return));
linux下C语言多线程编程实例 学东西，往往实例才是最让人感兴趣的，老是学基础理论，不动手，感觉没有成就感，呵呵。 下面先来一个实例。我们通过创建两个线程来实现对一个数的递加。 或许这个实例没有实际运用的价值，但是稍微改动一下，我们就可以用到其他地方去拉。 下面是我们的代码： /*thread_example.c : c multiple thread programming in linux *author : falcon *E-mail : tunzhj03@https://www.doczj.com/doc/4317070872.html, */ #include
for (i = 0; i < MAX; i++) { printf("thread1 : number = %d\n",number); pthread_mutex_lock(&mut); number++; pthread_mutex_unlock(&mut); sleep(2); } printf("thread1 :主函数在等我完成任务吗？\n"); pthread_exit(NULL); } void *thread2() { printf("thread2 : I'm thread 2\n"); for (i = 0; i < MAX; i++) { printf("thread2 : number = %d\n",number); pthread_mutex_lock(&mut); number++; pthread_mutex_unlock(&mut); sleep(3); } printf("thread2 :主函数在等我完成任务吗？\n");
linux下C语言多线程编程实例 2007年11月29日星期四 10:39 学东西，往往实例才是最让人感兴趣的，老是学基础理论，不动手，感觉没有成就感，呵呵。 下面先来一个实例。我们通过创建两个线程来实现对一个数的递加。 或许这个实例没有实际运用的价值，但是稍微改动一下，我们就可以用到其他地方去拉。 下面是我们的代码： /*thread_example.c : c multiple thread programming in linux *author : falcon *E-mail : tunzhj03@https://www.doczj.com/doc/4317070872.html, */ #include
Linux下多线程并发控制的机制分析 一、Linux下并发控制原因及方法 1.1、并发控制 如果在对linux字符设备驱动实例进行分析时，我们可能会有一个疑问，当我们调用copy_to_user和copy_from_user函数完成从用户态、内核态的读写操作的时候，如果这两个操作并发执行的话会出现一个什么样的情况？那肯定是会出现问题的，这个很容易理解，那么我们怎么去解决这一类似的问题呢？这就是我现在要探讨的linux并发控制机制。 我们在设备驱动的编写过程中要解决的一个问题就是并发的控制，也就是进程对共享资源的并发访问，而在linux中，提供了多个解决并发控制的方式，比如：中断屏蔽、原子操作、互斥锁等，下面将逐一介绍。 1.2、中断屏蔽 中断屏蔽的概念实际上就是平常所说的开中断、关中断。在单cpu中使用中断屏蔽来避免竟态是很方便的一种方法，每次在进入临界区之前屏蔽所有的中断，访问完成后再打开中断。这项功能可以保障在执行的内核执行路径不被中断处理程序所抢占。它将使得中断与进程之间的并发不在发生，而且由于linux内核的进程调度都依赖于中断来实现，所以这样也就可以避免进程之间的并发。 中断对于内核的运行是非常重要的，在中断屏蔽期间，所有的中断都无法得到处理，因此长时间的屏蔽中断是很危险的，可能会造成数据丢失、系统崩溃等严重的后果。这就要求临界区的执行应该尽可能的快。 1.3、原子操作 原子操作，指的是在执行的过程中不会被中断的操作。linux内核提供了一系列的函数来完成原子操作，内核代码可以安全的调用他们而不被打断。 1.4、自旋锁
者生产产品后再取。 三、程序实现 环境：操作系统：RHEL5，语言：C++。在Linux中，使用Pthread库来操作线程。POSIX thread是一个标准线程定义，该标准定义一系列的多线程标准。pthreads线程库实现了POSIX线程标准，定义了一套C\C++语言下的线程库。 首先需要定义生产者线程、消费者线程、产品仓库等，在本例中，使用pthread 线程库，所以生产者线程和消费者线程都定义为pthread_t类型；产品仓库则使用一个先进先出的队列来实现，这个队列类型直接使用了stl库中的list 结构。 //定义生产者和消费者线程 pthread_t producer,consumer; //定义产品仓库，用List结构来保存。 list
1 实验八 Linux 多线程实验 报告撰写人 专业班级 学号 姓名 完成时间 。。。 。。。。 。 。。。 一、 实验目的 1、 了解什么是多线程，熟悉LINUX 的多线程机制； 2、 掌握利用信号处理Linux 多线程的同步问题； 3 、 掌握利用信号量处理Linux 多线程的互斥问题； 4、 运用Linux 多线程的同步机制和互斥机制实现生产者消费者的编程。 二、 实验内容 1． “生产者-消费者”问题如下：有一个有限缓冲区和两个线程：生产者和消费者。他们分别不停地把产品放入缓冲区、从缓冲区中拿走产品。一个生产者在缓冲区满的时候必须等待，一个消费者在缓冲区空的时候也必须等待。另外，因为缓冲区是临界资源，所以生产者和消费者之间必须互斥执行。它们之间的关系如图1所示。现在要求使用共享内存来模拟有限缓冲区，并且使用信号量来解决“生产者-消费者”问题中的同步和互斥问题。 生产者和消费者问题描述 2. 问题描述：假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。餐桌中间有一大碗意大利面，每两个哲学家之间有一只餐叉。因为用一只餐叉很难吃到意大利面，所以假设哲学家必须用两只餐叉吃东西。他们只能使用自己左右手边的那两只餐叉。请用Linux 线程编程解决。
2 哲学家进餐问题示意图 三、实验过程与结果 操作过程错误解决 方法 实验步骤一： 编写的文件 在不 同的编译 2
1器中for 循环的用 法不太一 样，在这 里最好不 要使用 for（int i=0；；） 最好 在外声明 int i在 for循环 里直接写 i=0 步骤二： 编译代码并且运行代码 步骤三： 运行完毕后，显示以下代码： 生产者消费者先后生产数据以及取出数据，此程序中设置了两个消费者两个生产 者，交替进行生产数据消费数据。 3