05实验五 Linux环境下多线程应用程序实验
实验五 多线程编程
编译运行程序,观察程序的运行结果。若把源程序中加黑体的语句注释掉,程序的运行结果 和以前有什么不同,为什么? 程序 2:同步信号量的使用 1 //psy1.c #include <stdio.h> #include <stdlib.h> #include <semaphore.h> #include <pthread.h>
int rt; pthread_t pthread_t pt_dsp; pt_ctrl;
rt = sem_init (&smt, 0, 0); if (rt){ printf ("semaphore initialization failed"); } pthread_create (&pt_dsp, NULL, ThreadFuncDisplay, NULL); pthread_create (&pt_ctrl, NULL, ThreadFuncControl, NULL); sleep(20); return 0; }
printf("thread is working\n"); sleep(1); printf("thread is finished\n"); return NULL; } int main(void) { pthread_t mythread; if(pthread_create(&mythread,NULL,thread_function,NULL)) { printf("creating thread is failed\n"); abort(); } printf("main is joining thread\n"); sleep(6); if(pthread_join(mythread,NULL)) { printf("error joining thread\n"); abort(); //sleep(6); printf(“thread end!!”); } }
多线程程序实验报告(3篇)
第1篇一、实验目的1. 理解多线程的概念和作用。
2. 掌握多线程的创建、同步和通信方法。
3. 熟悉Java中多线程的实现方式。
4. 提高程序设计能力和实际应用能力。
二、实验环境1. 操作系统:Windows 102. 开发工具:IntelliJ IDEA3. 编程语言:Java三、实验内容本次实验主要完成以下任务:1. 创建多线程程序,实现两个线程分别执行不同的任务。
2. 使用同步方法实现线程间的同步。
3. 使用线程通信机制实现线程间的协作。
四、实验步骤1. 创建两个线程类,分别为Thread1和Thread2。
```javapublic class Thread1 extends Thread {@Overridepublic void run() {// 执行Thread1的任务for (int i = 0; i < 10; i++) {System.out.println("Thread1: " + i);}}}public class Thread2 extends Thread {@Overridepublic void run() {// 执行Thread2的任务for (int i = 0; i < 10; i++) {System.out.println("Thread2: " + i);}}}```2. 创建一个主类,在主类中创建两个线程对象,并启动它们。
```javapublic class Main {public static void main(String[] args) {Thread thread1 = new Thread1();Thread thread2 = new Thread2();thread1.start();thread2.start();}```3. 使用同步方法实现线程间的同步。
```javapublic class SynchronizedThread extends Thread {private static int count = 0;@Overridepublic void run() {for (int i = 0; i < 10; i++) {synchronized (SynchronizedThread.class) {count++;System.out.println(Thread.currentThread().getName() + ": " + count);}}}}public class Main {public static void main(String[] args) {Thread thread1 = new SynchronizedThread();Thread thread2 = new SynchronizedThread();thread1.start();thread2.start();}```4. 使用线程通信机制实现线程间的协作。
实验五 多线程程序设计 实验报告
实验五多线程程序设计实验报告一、实验目的1. 熟悉利用Thread 类建立多线程的方法。
2. 熟悉利用Runnable 接口建立多线程的方法。
二、实验原理1. 通过继承Thread 类实现多线程的方法:① 创建一个Thread 类的子类。
② 重写run 方法。
③ 创建这个子类的实例。
④调用子类的start 方法启动线程。
2. 通过Runnable 接口实现多线程的方法:① 创建一个线程类,实现Runnable 接口。
② 实现run 方法。
③ 通过Thread 类中的Thread(Runnable) 构造方法创建一个线程类实例。
④ 调用线程类的start 方法启动线程。
三、实验内容1. 阅读下列程序,分析并上机检验其功能。
class DelayThread extends Thread {private static int count=0;private int no;private int delay;public DelayThread() {count++;no=count;}public void run() {try {for (int i=0;i<10;i++){delay=(int)(Math.random()*5000);sleep(delay);System.out.println(“Thread ”+no+” with a delay ”+delay);} catch(InterruptedException e) { }}}public class MyThread {public static void main(String args[]) {DelayThread thread1 = new DelayThread();DelayThread thread2 = new DelayThread();thread1.start();thread2.start();try {Thread.sleep(1000);} catch (InterruptedException e) {System.out.println(“Thread wrong”);}}}2. 利用Runnable 接口修改上面的程序,使之完成同样的功能。
实验报告5Linux进程管理
实验报告5Linux进程管理实验五 Linux进程管理四、实验过程(实验步骤、记录、数据、分析、结果)(⼀)进程查看、终⽌、挂起及暂停等操作1、使⽤ps命令查看和控制进程1)显⽰本⽤户进程#ps2)显⽰所有⽤户的进程#ps–au3)在后台运⾏cat命令#cat&4)查看进程cat#ps aux |grep cat5)杀死进程cat#kill -9 cat6)再次查看进程cat,看看是否被杀死。
2、使⽤top命令查看和控制进程1)⽤top命令动态显⽰当前的进程。
2)只显⽰某⼀⽤户的进程(u)3)杀死指定进程号的进程(k)3、挂起和恢复进程1)执⾏命令cat2)按【ctrl+z】挂起进程3)输⼊jobs命令,查看作业4)输⼊bg,把cat切换到后台执⾏5)输⼊fg,把cat切换到前台执⾏6)按【ctrl+c】结束进程(⼆)通过at命令实现计划任务1、5分钟后执⾏/bin/date#at now+5minutesat>/bin/dateat>(提⽰:输⼊【ctrl+d】job任务号at 年-⽉-⽇⼩时:分钟如何查看结果?使⽤atq可以查询到已添加的at计划任务2、查找系统中任何以c为后缀名的⽂档,将结果保存到$HOME/findc⽂件中,指定时间为2016年12⽉01⽇早上8点#at 8am 12/01/16at>find / -name ‘*.c’>$HOME/findcat>job任务号at 年-⽉-⽇⼩时:分钟如何查看结果?使⽤atq可以查询到已添加的at计划任务3、2题的命令写到$HOME/findjob中,使⽤at命令执⾏,并将结果保存到$HOME/findfc⽂件中,指定时间为当前时间后5分钟#vi $HOME/findjob内容如下:find / -name ‘*.c’>$HOME/findfc存盘退出#at –f $HOME/findjob now+5minutes4、at命令实现在3天后统计/etc/inittab⽂件的⾏数,将统计结果发送⾄$HOME/initline⽂件中#at now+3daysat>wc–l /etc/inittab>>$HOME/initlineat>5.列出现有的所有at任务,并记下相关信息6、删除某at任务,并进⾏查看是否删除(三)通过cron命令实现计划任务1、使⽤cron命令实现12⽉每天下午2点系统进⾏维护状态,重新启动系统#vi $HOME/shutcron输⼊内容:00 14 * 12 * /sbin/shutdown–r存盘退出#crontab $HOME/shutcron2、使⽤cron命令实现在12⽉1号星期四的17点30分查看/etc/passwd内容,并将查看结果送⾄$HOME/passtext #vi $HOME/checkcron输⼊内容:30 17 1 12 4 more /etc/passwd>$HOME/passtext存盘退出#crontab $HOME/checkcron3、查看当前的crontab⽂件#crontab -l4、⽤户user的crontab⽂件#crontab –u user –r。
Linux并发编程实验(线程、进程)
Linux并发编程实验多线程、多进程编程一.实验目的和要求二、实验内容三、实验结果与分析1、进程实验(1)分别创立4个C文件,get.c、copy.c、put.c以及main.c分别实验读入,拷贝,输出,及前三个函数的调用;(2)定义三个缓冲区,其中一个记录对各项操作的选择,另外两个用来传输拷贝文件内容,相当于图中的缓冲区s和缓冲区t;(3)并发执行时定义了4个信号灯,分别用来控制缓冲区s是否有内容,缓冲区s是否空,缓冲区t是否有内容,缓冲区t是否为空;顺序执行时定义了三个信号灯,让get、copy、put分别其按顺序依次执行。
(4)创建三个进程分别实现get、copy、put功能;(5)并发时原理如下If(f不为空){get(s,f);while(誊抄未完成){t=s;cobeginput(t,g);get(s,f);coend;}}(6)顺序执行时原理如下:while(f不为空){input;output;}(7)创建一个字符文档如下,大小为42.4KB,内容为一连串的字符此时文件比较小用并发和顺序所得执行结果如下由此可知当文件很小时,并发执行和顺序执行比本感觉不出差距。
(8)创建一个一个较大的f.txt文档,大小为113.5KB,内容为一连串字符,如下:此时文件较大,并发执行和顺序执行的程序运行结果如下所示:此时才能看出两者之间有细小的差别,顺序执行效率小于并发执行的效率!但还是可见差距非常不明显!(9)分析:对于进程而言,顺序执行和并发执行之间的差距并不是那么明显,尤其是在拷贝文件较小时,基本感觉不出差距,只有在拷贝文件很大时才能有感觉到明显的差距。
2、线程实验(1)实验原理与进程一致,只是这次用的是一个thread。
C文件,内部有4个函数分别为get、copy、put、main来实现全部功能。
并且创建的为3个线程。
(2)创建一个f.txt文件,大小为113.5KB,内容为一串连续字符,如下所示并发和顺序的执行结果如下所示:并发执行的结果为4.83秒,而顺序执行在两分钟后还是没有完成,用ctrl+C打断,可见当要拷贝的文件很大时,线程的并发和顺序执行之间的差距是非常明显的!(3)创建一个较小的f.txt文件,大小为7.6KB,内容为一连串的字符,如下所示:此时的运行结果如下所示:可见,当拷贝的文件较小时,线程的顺序与并发执行指尖的差距也会变小。
Linux下多进程环境实验
/* journalling filesystem info */ void *journal_info;
unsigned long ptrace_message; siginfo_t *last_siginfo; /* For p *set_child_tid;
/* CLONE_CHILD_SETTID */
int *clear_child_tid;
/* CLONE_CHILD_CLEARTID */
unsigned long rt_priority; unsigned long it_real_value, it_prof_value, it_virt_value; unsigned long it_real_incr, it_prof_incr, it_virt_incr; struct timer_list real_timer; struct tms times; struct tms group_times; unsigned long start_time; long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS]; /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */ unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap; int swappable:1; /* process credentials */ uid_t uid,euid,suid,fsuid; gid_t gid,egid,sgid,fsgid; int ngroups; gid_t groups[NGROUPS]; kernel_cap_t cap_effective, cap_inheritable, cap_permitted; int keep_capabilities:1; struct user_struct *user; /* limits */ struct rlimit rlim[RLIM_NLIMITS]; unsigned short used_math; char comm[16]; /* file system info */ int link_count, total_link_count; struct tty_struct *tty; /* NULL if no tty */
2022年操作系统实验报告理解Linux下进程和线程的创建并发执行过程
操作系统上机实验报告实验名称:进程和线程实验目旳:理解unix/Linux下进程和线程旳创立、并发执行过程。
实验内容:1.进程旳创立2.多线程应用实验环节及分析:一、进程旳创立下面这个C程序展示了UNIX系统中父进程创立子进程及各自分开活动旳状况。
fork( )创立一种新进程。
系统调用格式:pid=fork( )参数定义:int fork( )fork( )返回值意义如下:0:在子进程中,pid变量保存旳fork( )返回值为0,表达目迈进程是子进程。
>0:在父进程中,pid变量保存旳fork( )返回值为子进程旳id值(进程唯一标记符)。
-1:创立失败。
如果fork( )调用成功,它向父进程返回子进程旳PID,并向子进程返回0,即fork( )被调用了一次,但返回了两次。
此时OS在内存中建立一种新进程,所建旳新进程是调用fork( )父进程(parent process)旳副本,称为子进程(child process)。
子进程继承了父进程旳许多特性,并具有与父进程完全相似旳顾客级上下文。
父进程与子进程并发执行。
2、参照程序代码/*process.c*/#include <stdio.h>#include <sys/types.h>main(int argc,char *argv[]){int pid;/* fork another process */pid = fork();if (pid < 0) { /* error occurred */fprintf(stderr, "Fork Failed");exit(-1);}else if (pid == 0) { /* child process */execlp( "/bin/ls", "ls",NULL);}else {/* parent process *//* parent will wait for the child to complete */ wait(NULL);printf( "Child Complete" );exit(0);}}3、编译和运营$gcc process.c –o processs4、运营$./process编辑如图所示:运营如图所示:思考:(1)系统是如何创立进程旳?1,申请空白PCB(进程控制块);2,为新进程分派资源;3,初始化PCB;4,将新进程插入就绪队列;(2)扩展程序,在父进程中输出1到5,在子进程中输出6-10,规定父子进程并发输出;记录实验成果,并给出简朴分析。
实验5Linux进程控制编程实验
实验5Linux进程控制编程实验实验5 Linux进程控制编程实验1、实验目的(1)熟悉多用户、多任务环境,通过实验,进一步牢固掌握进程的概念;(2)掌握Linux环境下进程的创建;(3)掌握Linux环境下进程的执行和传参要求;(4)熟悉进程间的通信。
2、实验要求1、实验必须在在Linux环境下进行操作。
2、文件名按照下面规则命名:源程序文件名最后要加学号后4位尾数。
如:f+学号最后4位.c3、实验报告中需要说明实验中在Linux环境下进行的实际操作;4、实验报告中应给出实际操作命令、所编写的程序、以及计算机输出的程序运行结果。
5、按照规定格式打印实验报告。
3、实验内容注意:(1)下面xxxx是自己学号的后4位尾数。
1、编写一个程序pxxxx.c,由它作为父进程去创建一个子进程。
并且父进程和子进程分别输出自己的进程号,同时输出你学号后4位尾数。
2、本题有两小题。
(1)运行下面程序,观察运行结果,并以下面的形式画出运行结果的进程树。
p1→p11→p111|→p12|→p13它表示进程p1创建了子进程p11、p12、p13;而p11又创建了子进程p11。
//pxxxx.c#include#includeint main(void){ int result,i;for(i=0;i<3;i++){result = fork();if(result == -1){perror("fork"); _exit(1);}if(result == 0){printf(" father's PID =%d --> child's PID =%d \n" ,getppid(),getpid() );}//waitpid(result,NULL,0);}printf("Now this is parent process, my PID = %d .\n",getpid());}(2)将循环控制变量i的值修改为2,并且去掉waitpid语句的注释,再编译并运行程序,观察运行结果并画出运行结果的进程树。
多线程编程实验报告
一、实验目的1. 理解多线程编程的基本概念和原理。
2. 掌握多线程的创建、同步、通信和调度等关键技术。
3. 通过实验加深对多线程编程的理解,提高编程能力。
二、实验环境硬件:PC机软件:VMware虚拟机、Linux系统、C/C++编译器三、实验内容1. 多线程创建与运行2. 线程同步与互斥3. 线程通信与协作4. 线程调度与优先级5. 生产者-消费者问题四、实验步骤1. 多线程创建与运行(1)创建线程:使用pthread_create函数创建线程,指定线程的入口函数、参数、线程属性等。
(2)线程运行:编写线程入口函数,实现线程需要执行的任务。
(3)线程结束:在线程入口函数中执行任务后,使用pthread_exit函数结束线程。
2. 线程同步与互斥(1)互斥锁:使用pthread_mutex_lock和pthread_mutex_unlock函数实现互斥锁,保证同一时刻只有一个线程访问共享资源。
(2)条件变量:使用pthread_cond_wait和pthread_cond_signal函数实现条件变量,实现线程间的同步与协作。
(3)读写锁:使用pthread_rwlock_rdlock和pthread_rwlock_wrlock函数实现读写锁,允许多个线程同时读取共享资源,但只有一个线程可以写入。
3. 线程通信与协作(1)线程间通信:使用pthread_cond_signal、pthread_cond_broadcast、pthread_barrier_wait等函数实现线程间的通信。
(2)线程协作:使用pthread_barrier_init、pthread_barrier_wait函数实现线程间的协作,确保所有线程到达某个点后再继续执行。
4. 线程调度与优先级(1)线程调度:了解操作系统的线程调度算法,如时间片轮转、优先级调度等。
(2)线程优先级:使用pthread_setschedparam函数设置线程的调度策略和优先级。
linux shell多线程编程实例
linux shell多线程编程实例Linux Shell是一种命令行解释器,可以通过编写Shell脚本来实现自动化任务。
在Shell脚本中,我们可以使用多线程编程来同时执行多个任务,提高程序的执行效率。
本文将介绍如何在Linux Shell中实现多线程编程,并给出一个实际的例子。
在Linux Shell中,我们可以使用`&`符号来将任务放到后台执行,实现并发执行的效果。
但是这种方式并不是真正的多线程,因为它们共享同一个进程空间,无法充分利用多核处理器的优势。
为了实现真正的多线程并发执行,我们可以使用`parallel`命令。
`parallel`命令是一个用于并行执行任务的工具,它可以将任务分成多个子任务,并在多个CPU核心上并行执行。
使用`parallel`命令,我们可以很方便地实现多线程编程。
下面是一个使用`parallel`命令实现多线程编程的例子。
假设我们有一个包含1000个文件的目录,我们需要对每个文件进行处理。
我们可以使用以下命令来并行处理这些文件:```shellls /path/to/files | parallel -j 4 --progress process_file {} ```上面的命令中,`ls /path/to/files`会列出目录中的所有文件,`parallel -j 4`表示最多同时执行4个任务,`--progress`会显示任务的进度,`process_file`是一个自定义的处理函数,`{}`表示当前文件名。
在上面的例子中,`parallel`命令会将`ls /path/to/files`的输出作为参数传递给`process_file`函数,并在后台启动多个进程来并行执行这些任务。
每个进程会处理一个文件,直到所有文件都被处理完毕。
在`process_file`函数中,我们可以编写具体的文件处理逻辑。
例如,可以使用`grep`命令来搜索文件中的关键字,或者使用`sed`命令来替换文件中的内容。
linux多线程编程实验心得
linux多线程编程实验心得在进行Linux多线程编程实验后,我得出了一些心得体会。
首先,多线程编程是一种高效利用计算机资源的方式,能够提高程序的并发性和响应性。
然而,它也带来了一些挑战和注意事项。
首先,线程同步是多线程编程中需要特别关注的问题。
由于多个线程同时访问共享资源,可能会引发竞态条件和数据不一致的问题。
为了避免这些问题,我学会了使用互斥锁、条件变量和信号量等同步机制来保护共享数据的访问。
其次,线程间通信也是一个重要的方面。
在实验中,我学会了使用线程间的消息队列、管道和共享内存等方式来实现线程间的数据传递和协作。
这些机制可以帮助不同线程之间进行有效的信息交换和协调工作。
此外,线程的创建和销毁也需要注意。
在实验中,我学会了使用pthread库提供的函数来创建和管理线程。
同时,我也了解到线程的创建和销毁是需要谨慎处理的,过多或过少的线程都可能导致系统资源的浪费或者性能下降。
在编写多线程程序时,我还学会了合理地划分任务和资源,以充分发挥多线程的优势。
通过将大任务拆分成多个小任务,并将其分配给不同的线程来并行执行,可以提高程序的效率和响应速度。
此外,我还学会了使用调试工具来分析和解决多线程程序中的问题。
通过使用gdb等调试器,我可以观察线程的执行情况,查找潜在的错误和死锁情况,并进行相应的修复和优化。
总结起来,通过实验我深刻认识到了多线程编程的重要性和挑战性。
合理地设计和管理线程,正确处理线程同步和通信,以及使用调试工具进行分析和修复问题,都是编写高效稳定的多线程程序的关键。
通过不断实践和学习,我相信我能够更好地应用多线程编程技术,提升程序的性能和可靠性。
多线程实验报告
多线程实验报告多线程实验报告引言:多线程是计算机科学中的一个重要概念,它允许程序同时执行多个任务,提高了计算机的效率和响应能力。
本实验旨在探索多线程的原理和应用,通过编写并运行多线程程序,研究多线程在不同场景下的表现和效果。
一、实验目的本实验的目的是通过编写多线程程序,深入了解多线程的工作原理和应用场景,掌握多线程编程的技巧和方法。
二、实验环境本实验使用Java语言进行多线程编程,运行环境为Windows操作系统。
三、实验过程1. 线程的创建与启动在Java中,创建一个线程可以通过继承Thread类或实现Runnable接口来实现。
本实验选择实现Runnable接口的方式来创建线程。
```javapublic class MyThread implements Runnable {public void run() {// 线程的执行逻辑}}public class Main {public static void main(String[] args) {Thread thread = new Thread(new MyThread());thread.start();}}```通过上述代码,我们创建了一个名为MyThread的线程类,并在Main类的main方法中创建并启动了一个线程。
2. 线程的同步与互斥在多线程编程中,线程的同步与互斥非常重要。
为了保证线程的安全性,我们需要使用锁机制来控制多个线程对共享资源的访问。
```javapublic class MyThread implements Runnable {private static int count = 0;private static Object lock = new Object();public void run() {synchronized (lock) {for (int i = 0; i < 100; i++) {count++;}}}}public class Main {public static void main(String[] args) {Thread thread1 = new Thread(new MyThread());Thread thread2 = new Thread(new MyThread());thread1.start();thread2.start();}}```上述代码中,我们使用了一个静态对象lock作为锁,通过synchronized关键字来实现对共享资源count的互斥访问。
linux多线程实验报告
1 / 18实验八 Linux 多线程实验报告撰写人专业班级 学号姓名 完成时间。
。
。
。
一、 实验目的1、 了解什么是多线程,熟悉LINUX 的多线程机制;2、 掌握利用信号处理Linux 多线程的同步问题;3、掌握利用信号量处理Linux 多线程的互斥问题;4、 运用Linux 多线程的同步机制和互斥机制实现生产者消费者的编程。
二、 实验内容1. “生产者-消费者”问题如下:有一个有限缓冲区和两个线程:生产者和消费者。
他们分别不停地把产品放入缓冲区、从缓冲区中拿走产品。
一个生产者在缓冲区满的时候必须等待,一个消费者在缓冲区空的时候也必须等待。
另外,因为缓冲区是临界资源,所以生产者和消费者之间必须互斥执行。
它们之间的关系如图1所示。
现在要求使用共享内存来模拟有限缓冲区,并且使用信号量来解决“生产者-消费者”问题中的同步和互斥问题。
生产者和消费者问题描述2. 问题描述:假设有五位哲学家围坐在一张圆形餐桌旁,做以下两件事情之一:吃饭,或者思考。
吃东西的时候,他们就停止思考,思考的时候也停止吃东西。
餐桌中间有一大碗意大利面,每两个哲学家之间有一只餐叉。
因为用一只餐叉很难吃到意大利面,所以假设哲学家必须用两只餐叉吃东西。
他们只能使用自己左右手边的那两只餐叉。
请用Linux 线程编程解决。
2 哲学家进餐问题示意图三、实验过程与结果操作过程错误解决方法实验1 步骤一:编写producer_customer.c的文件在不同的编译器中for循环的用法不太一样,在这里最好不要使用for(inti=0;;)最好在外声明inti在for循环里直接写i=02/ 18步骤二:编译代码并且运行代码步骤三:运行完毕后,显示以下代码:生产者消费者先后生产数据以及取出数据,此程序中设置了两个消费者两个生产者,交替进行生产数据消费数据。
实验步骤一:编写philosopher.c的文件3/ 182步骤二:编译代码并且运行代码步骤三:4/ 18实验代码实验一:#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <time.h>#include <sys/ipc.h>#include <sys/shm.h>#include <sys/sem.h>#include <sys/types.h>#define MAX_BUFFER_SIZE 105/ 18#define SHM_MODE 0600#define SEM_MODE 0600#define SEM_FULL 0#define SEM_EMPTY 1#define MUTEX 2/*#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)// union semun is defined by including <sys/sem.h>#else// according to X/OPEN we have to define it ourselvesunion semun{int val;struct semid_ds *buf;unsigned short *array;};#endifunion semun su;//sem union,用于初始化信号量*/struct my_buffer{int head;int tail;char str[MAX_BUFFER_SIZE];int num; //缓冲区里字母数量int is_empty;};const int N_CONSUMER = 2;//消费者数量const int N_PRODUCER = 2;//生产者数量const int N_BUFFER = 10;//缓冲区容量6/ 18const int N_WORKTIME = 10;//工作次数int shm_id = -1;int sem_id = -1;pid_t child;pid_t parent;//得到10以内的一个随机数int get_random(){int digit;srand((unsigned)(getpid() + time(NULL)));digit = rand() % 10;return digit;}//得到A~Z的一个随机字母char getRandChar(){char letter;srand((unsigned)(getpid() + time(NULL)));letter = (char)((rand() % 26) + 'A');return letter;}//sem_id 表示信号量集合的 id//sem_num 表示要处理的信号量在信号量集合中的索引//P操作void waitSem(int sem_id,int sem_num){struct sembuf sb;sb.sem_num = sem_num;sb.sem_op = -1;//表示要把信号量减一7/ 18sb.sem_flg = SEM_UNDO;////第二个参数是 sembuf [] 类型的,表示数组//第三个参数表示第二个参数代表的数组的大小if(semop(sem_id,&sb,1) < 0){perror("waitSem failed");exit(1);}}//V操作void sigSem(int sem_id,int sem_num){struct sembuf sb;sb.sem_num = sem_num;sb.sem_op = 1;sb.sem_flg = SEM_UNDO;//第二个参数是 sembuf [] 类型的,表示数组//第三个参数表示第二个参数代表的数组的大小if(semop(sem_id,&sb,1) < 0){perror("sigSem failed");exit(1);}}//打印进程运行结果void printTime(){//打印时间time_t now;struct tm *timenow; //实例化tm结构指针time(&now);8/ 18timenow = localtime(&now);printf("执行时间: %s ",asctime(timenow));}int main(int argc, char ** argv){shm_id = shmget(IPC_PRIVATE,MAX_BUFFER_SIZE,SHM_MODE); //申请共享内存if(shm_id < 0){perror("create shared memory failed");exit(1);}struct my_buffer *shmptr;shmptr = shmat(shm_id, 0, 0); //将申请的共享内存附加到申请通信的进程空间if (shmptr == (void*)-1){perror("add buffer to using process space failed!\n");exit(1);}if((sem_id = semget(IPC_PRIVATE,3,SEM_MODE)) < 0){ //创建三个信号量,SEM_EMPTY,SEM_FULL和MUTEXperror("create semaphore failed! \n");exit(1);}if(semctl(sem_id,SEM_FULL,SETVAL,0) == -1){ //将索引为0的信号量设置为0-->SEM_FULLperror("sem set value error! \n");9/ 18exit(1);}if(semctl(sem_id,SEM_EMPTY,SETVAL,10) == -1){ //将索引为1的信号量设置为10-->SEM_EMPTYperror("sem set value error! \n");exit(1);}if(semctl(sem_id,MUTEX,SETVAL,1) == -1){ //将索引为3的信号量设置为1-->MUTEXperror("sem set value error! \n");exit(1);}shmptr -> head = 0;shmptr -> tail = 0;shmptr -> is_empty = 1;shmptr -> num = 0;int i;for(i = 0; i < N_PRODUCER; i++){parent = fork();if(parent < 0){perror("the fork failed");exit(1);}else if(parent == 0){shmptr = shmat(shm_id, 0, 0); //将申请的共享内存附加到申请通信的进程空间10/ 18if (shmptr == (void*)-1){perror("add buffer to using process space failed!\n");exit(1);}int count = 0;int j;for(j = 0; j < N_WORKTIME; j++){waitSem(sem_id, SEM_EMPTY);waitSem(sem_id, MUTEX);sleep(get_random());printf("-------------------------------------------------------------\n");printf("我是第 %d 个生产者进程,PID = %d\n", i + 1, getpid());/*生产产品*/char c = getRandChar(); //随机获取字母shmptr -> str[shmptr->tail] = c;shmptr -> tail = (shmptr->tail + 1) % MAX_BUFFER_SIZE;shmptr -> is_empty = 0; //写入新产品shmptr -> num++;/*打印输出结果*/printTime(); //程序运行时间int p;printf("缓冲区数据(%d个):",shmptr -> num); //打印缓冲区中的数据p = (shmptr->tail-1 >= shmptr->head) ? (shmptr->tail-1) :(shmptr->tail-1 + MAX_BUFFER_SIZE);11/ 18for (p; !(shmptr -> is_empty) && p >= shmptr -> head; p--){printf("%c", shmptr -> str[p % MAX_BUFFER_SIZE]);}printf("\t 生产者 %d 放入 '%c'. \n", i + 1, c);printf("-------------------------------------------------------------\n");fflush(stdout);sigSem(sem_id, MUTEX);sigSem(sem_id, SEM_FULL);}//将共享段与进程之间解除连接shmdt(shmptr);exit(0);}}for(i = 0; i < N_CONSUMER; i++){child = fork();if(child < 0)//调用fork失败{perror("the fork failed");exit(1);}else if(child == 0){int count = 0;shmptr = shmat(shm_id, 0, 0); //将申请的共享内存附加到申请通信的12/ 18进程空间if (shmptr == (void*)-1){perror("add buffer to using process space failed!\n");exit(1);}int j;for(j = 0; j < N_WORKTIME; j++){waitSem(sem_id, SEM_FULL);waitSem(sem_id, MUTEX);sleep(get_random());printf("-------------------------------------------------------------\n");printf("我是第 %d 个消费者进程,PID = %d\n", i + 1, getpid());/*消费数据*/char lt = shmptr -> str[shmptr -> head];shmptr -> head = (shmptr -> head + 1) % MAX_BUFFER_SIZE;shmptr -> is_empty = (shmptr->head == shmptr->tail); //shmptr -> num--;/*打印输出结果*/printTime(); //程序运行时间int p;printf("缓冲区数据(%d个):",shmptr -> num); //打印缓冲区中的数据p = (shmptr -> tail - 1 >= shmptr -> head) ? (shmptr -> tail-1) :(shmptr -> tail - 1 + MAX_BUFFER_SIZE);for (p; !(shmptr -> is_empty) && p >= shmptr -> head; p--)13/ 18{printf("%c", shmptr -> str[p % MAX_BUFFER_SIZE]);}printf("\t 消费者 %d 取出 '%c'. \n", i + 1, lt);printf("-------------------------------------------------------------\n");fflush(stdout);sigSem(sem_id,MUTEX);sigSem(sem_id,SEM_EMPTY);}//将共享段与进程之间解除连接shmdt(shmptr);exit(0);}}//主进程最后退出while (wait(0) != -1);//将共享段与进程之间解除连接shmdt(shmptr);//对共享内存区执行控制操作shmctl(shm_id,IPC_RMID,0);//当cmd为IPC_RMID时,删除该共享段shmctl(sem_id,IPC_RMID,0);printf("主进程运行结束!\n");fflush(stdout);exit(0);return 0;}14/ 18实验二:#include<sys/types.h>#include<unistd.h>#include<stdlib.h>#include<stdio.h>#include<pthread.h>#include<semaphore.h>#include<time.h>#define N 5 //哲学家数量#define LEFT(i) (i+N-1)%N //左手边哲学家编号#define RIGHT(i) (i+1)%N //右手边哲家编号#define HUNGRY 0 //饥饿#define THINKING 1 //思考#define EATING 2 //吃饭#define U_SECOND 1000000 //1秒对应的微秒数pthread_mutex_t mutex; //互斥量int state[N]; //记录每个哲学家状态//每个哲学家的思考时间,吃饭时间,思考开始时间,吃饭开始时间clock_t thinking_time[N], eating_time[N], start_eating_time[N],start_thinking_time[N];//线程函数void *thread_function(void *arg);int main(){15/ 18pthread_mutex_init(&mutex, NULL);pthread_t a,b,c,d,e;//为每一个哲学家开启一个线程,传递哲学家编号pthread_create(&a,NULL,thread_function,"0");pthread_create(&b,NULL,thread_function,"1");pthread_create(&c,NULL,thread_function,"2");pthread_create(&d,NULL,thread_function,"3");pthread_create(&e,NULL,thread_function,"4");//初始化随机数种子srand((unsigned int)(time(NULL)));while(1){;}}void *thread_function(void *arg){char *a = (char *)arg;int num = a[0] - '0'; //根据传递参数获取哲学家编号int rand_time;while(1){//关键代码加锁pthread_mutex_lock(&mutex);//如果该哲学家处于饥饿并且左右两位哲学家都没有在吃饭就拿起叉子吃饭if(state[num] == HUNGRY && state[LEFT(num)] != EATING &&16/ 18state[RIGHT(num)] != EATING){state[num] = EATING;start_eating_time[num] = clock(); //记录开始吃饭时间eating_time[num] = (rand() % 5 + 5) * U_SECOND; //随机生成吃饭时间//输出状态printf("state: %d %d %d %d %d\n",state[0],state[1],state[2],state[3],state[4]);//printf("%d is eating\n",num);}else if(state[num] == EATING){//吃饭时间已到,开始思考if(clock() - start_eating_time[num] >= eating_time[num]) //{state[num] = THINKING;//printf("%d is thinking\n",num);printf("state: %d %d %d %d %d\n",state[0],state[1],state[2],state[3],state[4]);start_thinking_time[num] = clock(); //记录开始思考时间thinking_time[num] = (rand() % 10 + 10) * U_SECOND; //随机生成思考时间}}else if(state[num] == THINKING){17/ 18//思考一定时间后,哲学家饿了,需要吃饭if(clock() - start_thinking_time[num] >= thinking_time[num]){state[num] = HUNGRY;printf("state: %d %d %d %d %d\n",state[0],state[1],state[2],state[3],state[4]);// printf("%d is hungry\n",num);}}pthread_mutex_unlock(&mutex);}}四、实验小结生产者消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例。
linux操作系统-实验-Linux-多线程编程
《操作系统》实验报告用gcc编译的时候需要加-lpthread,否则会出现以下错误:五、思考题多进程编程与多线程编程有何区别?相同点:Linux下不管是多线程编程还是多进程编程,最终都是用do_fork 实现不同点:父子进程变量是互不影响的,由于父子进程地址空间是完全隔开的,变量的地址可以是完全相同的。
Linux下编程多用多进程编程少用多线程编程。
多线程比多进程成本低,但性能更低:多进程是立体交通系统,虽然造价高,上坡下坡多耗点油,但是不;多线程是平面交通系统,造价低,但红绿灯太多,老堵车。
1、多进程:子进程是父进程的复制品。
子进程获得父进程数据空间、堆和栈的复制品。
2、多线程:相对与进程而言,线程是一个更加接近与执行体的概念,它可以与同进程的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。
两者都可以提高程序的并发度,提高程序运行效率和响应时间。
3、线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源管理和保护;而进程正相反。
同时,线程适合于在5MP机器上运行,而进程则可以跨机器迁移。
代码:#include <pthread.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>char globe_buffer[100];void *read_buffer_thread(void *arg);int main(){int res,i;pthread_t read_thread;for(i=0;i<20;i++)globe_buffer[i]=i;printf("\nxiancheng thread : write buffer finish\n");sleep(3);res = pthread_create(&read_thread, NULL, read_buffer_thread, NULL);if (res != 0){printf("Read Thread creat Error!");exit(0);}sleep(1);printf("waiting for read thread to finish...\n");res = pthread_join(read_thread, NULL);if (res != 0){printf("read thread join failed!\n");exit(0);}printf("read thread xiancheng OK, have fun!! exit ByeBye\n");return 0;}void *read_buffer_thread(void *arg){int i,x;printf("Read buffer thread read data : \n");for(i=0;i<20;i++){x=globe_buffer[i];printf("%d ",x);globe_buffer[i]=0;}printf("\nread over\n");}。
Linux下的多线程编程实例解析
Linux下的多线程编程实例解析1 引⾔ 线程(thread)技术早在60年代就被提出,但真正应⽤多线程到操作系统中去,是在80年代中期,solaris是这⽅⾯的佼佼者。
传统的Unix也⽀持线程的概念,但是在⼀个进程(process)中只允许有⼀个线程,这样多线程就意味着多进程。
现在,多线程技术已经被许多操作系统所⽀持,包括Windows/NT,当然,也包括Linux。
为什么有了进程的概念后,还要再引⼊线程呢?使⽤多线程到底有哪些好处?什么的系统应该选⽤多线程?我们⾸先必须回答这些问题。
使⽤多线程的理由之⼀是和进程相⽐,它是⼀种⾮常"节俭"的多任务操作⽅式。
我们知道,在Linux系统下,启动⼀个新的进程必须分配给它独⽴的地址空间,建⽴众多的数据表来维护它的代码段、堆栈段和数据段,这是⼀种"昂贵"的多任务⼯作⽅式。
⽽运⾏于⼀个进程中的多个线程,它们彼此之间使⽤相同的地址空间,共享⼤部分数据,启动⼀个线程所花费的空间远远⼩于启动⼀个进程所花费的空间,⽽且,线程间彼此切换所需的时间也远远⼩于进程间切换所需要的时间。
据统计,总的说来,⼀个进程的开销⼤约是⼀个线程开销的30倍左右,当然,在具体的系统上,这个数据可能会有较⼤的区别。
使⽤多线程的理由之⼆是线程间⽅便的通信机制。
对不同进程来说,它们具有独⽴的数据空间,要进⾏数据的传递只能通过通信的⽅式进⾏,这种⽅式不仅费时,⽽且很不⽅便。
线程则不然,由于同⼀进程下的线程之间共享数据空间,所以⼀个线程的数据可以直接为其它线程所⽤,这不仅快捷,⽽且⽅便。
当然,数据的共享也带来其他⼀些问题,有的变量不能同时被两个线程所修改,有的⼦程序中声明为static的数据更有可能给多线程程序带来灾难性的打击,这些正是编写多线程程序时最需要注意的地⽅。
除了以上所说的优点外,不和进程⽐较,多线程程序作为⼀种多任务、并发的⼯作⽅式,当然有以下的优点: 1) 提⾼应⽤程序响应。
Linux中多线程详解及简单实例
Linux中多线程详解及简单实例Linux中多线程详解及简单实例1.概念进程:运⾏中的程序。
线程:⼀个程序中的多个执⾏路径。
更准确的定义是:线程是⼀个进程内部的⼀个控制序列。
2.为什么要有线程?⽤fork调⽤进程代价太⾼,需要让⼀个进程同时做多件事情,线程就⾮常有⽤。
3.线程的优点和缺点。
优点:(1)有时,让程序看起来是在同时做两件事是⾮常有⽤的。
⽐如在编辑⽂档时,还能统计⽂档⾥的单词个数。
(2)⼀个混杂着输⼊、计算、输出的程序,利⽤线程可以将这3个部分分成3个线程来执⾏,从⽽改变程序执⾏的性能。
(3)⼀般来说,线程之间切换需要操作系统所做的⼯作⽐进程间切换需要的代价⼩。
缺点:(1)编写线程需要⾮常仔细的设计。
(2)对多线程的调试困难程度⽐单线程调试⼤得多。
4.创建线程#include <pthread.h>(1)int pthread_create(pthread_t *thread,pthread_attr_t *attr,void *(*start_routine)(void *),void *arg);pthread_t pthread_self(void);(2)int pthread_equal(pthread_t thread1,pthread_t thread2);(3)int pthread_once(pthread_once_t *once_control,void(*init_routine)(void));Linux系统⽀持POSIX多线程接⼝,称为pthread。
编写linux下的多线程程序,需要包含头⽂件pthread.h,链接时需要使⽤库libpthread.a。
如果在主线程⾥⾯创建线程,程序就会在创建线程的地⽅产⽣分⽀,变成两个部分执⾏。
线程的创建通过函数pthread_create来完成。
成功返回0。
1.线程创建:int pthread_create(pthread_t thread,pthread_attr_t *attr,void (start_routine)(void ),void *arg);pthread_t pthread_self(void);参数说明:thread:指向pthread_create类型的指针,⽤于引⽤新创建的线程。
试验5:多线程程序设计
6.加入一个新的线程用于处理键盘的输入,并在按键为ESC时终止所有线程。
四、实验结果
1.进入root/test/02_pthread目录,使用vi编辑器或其他编辑器阅读理解源代码。
2.运行make产生pthread可执行文件。
1.进入exp/basic/02_pthread目录,使用vi编辑器或其他编辑器阅读理解源代码。
2.运行make产生pthread可执行文件。
3.切换到minicom终端窗口,使用NFS mount开发主机的/up-techpxa270到/mnt目录。
4.进入/mnt/exp/basic/pthread目录,运行./pthread,观察运行结果的正确性,若显示结果太快,可以用以下命令输出显示结果到pthread.txt文件./pthread >pthread.txt,然后再用cat pthread.txt察看文件内容,结合程序分析结果。
硬件:PC机;PXA270试验箱
软件:PC机操作系统linux
三、实验内容与步骤
读懂pthread.c的源代码,熟悉几个重要的PTHREAD库函数的使用。掌握共享锁和信号量的使用方法。进入/up-techpxa270/exp/basic/02_pthread目录,运行make产生pthread程序,使用NFS方式连接开发主机进行运行实验。
修改BUFFER_SIZE值后,可以看出运行的结果产生了变化
6.加入一个新的线程用于处理键盘的输入,并在按键为ESC时终止所有线程。
Pthread.c的代码如下:Hale Waihona Puke 五、教师评语签名:
日期:
成绩
Linux下多进程环境实验
(1)用户在终端输入 Linux 命令时,对应的 shell 通常会建立子进程来运行该命令。通 过 ps 命令可以查看用户空间的当前进程。
执行格式: # ps [-auf] -a 列出当前终端上启动的所有进程; -u 按用户名和启动时间的顺序来显示进程; -e 列出系统中所有进程; -f 以全格式列出; -l 以 long 格式列出; 例:ps -af|grep apa 找出当前终端上启动的进程中所有名称中带有"apa"串的进程 (2)top 命令和 ps 命令的基本作用是相同的,显示系统当前的进程和其他状况;但 top 是一个动态显示过程,提供了实时的对系统处理器的状态监视。 执行格式: # top 每隔 5s 统计显示一次系统中的进程状态 -q 不断地更新、显示系统中的进程状态; -d 指定每两次屏幕信息刷新之间的时间间隔。 第一行显示的项目依次为当前时间、系统启动时间、当前系统登录用户数目、平均负载。 第二行为进程情况,依次为进程总数、休眠进程数、运行进程数、僵死进程数、终止进 程数。 第三行为 CPU 状态,依次为用户占用、系统占用、优先进程占用、闲置进程占用。 第四行为内存状态,依次为平均可用内存、已用内存、空闲内存、共享内存、缓存使用 内存。 第五行为交换状态,依次为平均可用交换容量、已用容量、闲置容量、高速缓存容量。 PID 每个进程的 ID。 PPID 每个进程的父进程 ID。 UID 每个进程所有者的 UID 。 USER 每个进程所有者的用户名。
与传统的进程一致,Linux 进程也主要有 3 部分组成:程序段、数据段和进程控制块。 程序段存放进程执行的指令代码,具有可读、可执行、不可修改属性,但允许系统中多 个进程共享这一代码段,因此程序与进程具有一对多的属性。 数据段是进程执行时直接操作的所有数据(包括变量在内),具有可读、可写、不可执行 属性。 Linux 中每个进程 PCB 的具体实现用一个名为 task_struct 的数据结构来表示,在 Linux 内核中有个默认大小为 512B 的全局数组 task,该数组的元素为指向 task_struct 结构的指针。 在创建新进程时,Linux 将会在系统空间中分配一个 task_struct 结构,并将其首地址加入到 task 数组。当前正在运行的进程的 task_struct 结构由一个 current 指针来指示。 Linux 2.4.20 内核版本中的 task_struct 结构在 include/linux/sched.h 中定义如下: struct task_struct { /*
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
在这一节里,我们编写了一个最简单的线程,并掌握了最常用的三个函数 pthread_create,pthread_join 和 pthread_exit。下面,我们来了解线程的一些常用属性以及 如何设置这些属性。
2、修改线程的属性
在上一节的例子里,我们用 pthread_create 函数创建了一个线程,在这个线程中,我 们使用了默认参数,即将该函数的第二个参数设为 NULL。的确,对大多数程序来说,使 用默认属性就够了,但我们还是有必要来了解一下线程的有关属性。
2) 使多 CPU 系统更加有效。操作系统会保证当线程数不大于 CPU 数目时,不同的 线程运行于不同的 CPU 上。
3) 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程,成为几个独立或 半独立的运行部分,这样的程序会利于理解和修改。
六、实验说明
1、简单的多线程编程 Linux 系统下的多线程遵循 POSIX 线程接口,称为 pthread。编写 Linux 下的多线程 程序,需要使用头文件 pthread.h,连接时需要使用库 libpthread.a。顺便说一下,Linux 下 pthread 的实现是通过系统调用 clone()来实现的。clone()是 Linux 所特有的系统调用, 它的使用方式类似 fork,关于 clone()的详细情况,有兴趣的读者可以去查看有关文档 说明。下面我们展示一个最简单的多线程程序 example.c。 /* example.c*/ #include <stdio.h> #include <pthread.h> void thread(void) { int i; for(i=0;i<3;i++) printf("This is a pthread.\n"); } int main(void) { pthread_t id; int i,ret; ret=pthread_create(&id,NULL,(void *) thread,NULL); if(ret!=0){ printf ("Create pthread error!\n"); exit (1); } for(i=0;i<3;i++) printf("This is the main process.\n"); pthread_join(id,NULL); return (0); } 我们编译此程序:
pthread_attr_t attr;
pthread_t tid; /*初始化属性值,均设为默认值*/
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, (void *) my_function, NULL); 线程的分离状态决定一个线程以什么样的方式来终止自己。在上面的例子中,我们采 用了线程的默认属性,即为非分离状态,这种情况下,原有的线程等待创建的线程结束。 只有当 pthread_join()函数返回时,创建的线程才算终止,才能释放自己占用的系统资 源。而分离线程不是这样子的,它没有被其他的线程所等待,自己运行结束了,线程也就 终止了,马上释放系统资源。程序员应该根据自己的需要,选择适当的分离状态。设置线 程分离状态的函数为 pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)。第二 个 参 数 可 选 为 PTHREAD_CREATE_DETACHED ( 分 离 线 程 ) 和 PTHREAD _CREATE_JOINABLE(非分离线程)。这里要注意的一点是,如果设置一个线程为分离线 程,而这个线程运行又非常快,它很可能在 pthread_create 函数返回之前就终止了,它终 止以后就可能将线程号和系统资源移交给其他的线程使用,这样调用 pthread_create 的线 程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施,最简单的方法之一 是可以在被创建的线程里调用 pthread_cond_timewait 函数,让这个线程等待一会儿,留出 足够的时间让函数 pthread_create 返回。设置一段等待时间,是在多线程编程里常用的方 法。但是注意不要使用诸如 wait()之类的函数,它们是使整个进程睡眠,并不能解决线 程同步的问题。 另外一个可能常用的属性是线程的优先级,它存放在结构 sched_param 中。用函数 pthread_attr_getschedparam 和函数 pthread_attr_setschedparam 进行存放,一般说来,我们 总是先取优先级,对取得的值修改后再存放回去。下面即是一段简单的例子。
属性结构为 pthread_attr_t,它同样在头文件/usr/include/pthread.h 中定义,喜欢追根问 底的人可以自己去查看。属性值不能直接设置,须使用相关函数进行操作,初始化的函数 为 pthread_attr_init,这个函数必须在 pthread_create 函数之前调用。属性对象主要包括是 否绑定、是否分离、堆栈地址、堆栈大小、优先级。默认的属性为非绑定、非分离、缺省 1M 的堆栈、与父进程同样级别的优先级。
设置线程绑定状态的函数为 pthread_attr_setscope,它有两个参数,第一个是指向属性 结构的指针,第二个是绑定类型,它有两个取值:PTHREAD_SCOPE_SYSTEM(绑定的) 和 PTHREAD_SCOPE_PROCESS(非绑定的)。下面的代码即创建了一个绑定的线程。
#include <pthread.h>
gcc example1.c -lpthread -o example1 运行 example1,我们得到如下结果:
This is the main process. This is a pthread. This is the main process. This is the main process. This is a pthread. This is a pthread. 再次运行,我们可能得到如下结果:
This is a pthread. This is the main process. This is a pthread. This is the main process. This is a pthread. This is the main process. 前后两次结果不一样,这是两个线程争夺 CPU 资源的结果。上面的示例中,我们使 用到了两个函数,pthread_create 和 pthread_join,并声明了一个 pthread_t 型的变量。 pthread_t 在头文件/usr/include/bits/pthreadtypes.h 中定义: typedef unsigned long int pthread_t; 它是一个线程的标识符。函数 pthread_create 用来创建一个线程,它的原型为: extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr, void *(*__start_routine) (void *), void *__arg)); 第一个参数为指向线程标识符的指针,第二个参数用来设置线程属性,第三个参数是 线程运行函数的起始地址,最后一个参数是运行函数的参数。这里,我们的函数 thread 不需要参数,所以最后一个参数设为空指针。第二个参数我们也设为空指针,这样将生成 默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时,函 数返回 0,若不为 0 则说明创建线程失败,常见的错误返回代码为 EAGAIN 和 EINVAL。 前者表示系统限制创建新的线程,例如线程数目过多了;后者表示第二个参数代表的线程 属性值非法。创建线程成功后,新创建的线程则运行参数三和参数四确定的函数,原来的 线程则继续运行下一行代码。 函数 pthread_join 用来等待一个线程的结束。函数原型为: extern int pthread_join __P ((pthread_t __th, void **__thread_return)); 第一个参数为被等待的线程标识符,第二个参数为一个用户定义的指针,它可以用来 存储被等待线程的返回值。这个函数是一个线程阻塞的函数,调用它的函数将一直等待到 被等待的线程结束为止,当函数返回时,被等待线程的资源被收回。一个线程的结束有两 种途径,一种是象我们上面的例子一样,函数结束了,调用它的线程也就结束了;另一种 方式是通过函数 pthread_exit 来实现。它的函数原型为: extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__)); 唯一的参数是函数的返回代码,只要 pthread_join 中的第二个参数 thread_return 不是 NULL,这个值将被传递给 thread_return。最后要说明的是,一个线程不能被多个线程等 待,否则第一个接收到信号的线程成功返回,其余调用 pthread_join 的线程则返回错误代 码 ESRCH。