多线程编程实例---pthread_join函数详解1

在C语言中，可以使用pthread_join函数来等待线程结束。

pthread_join函数的原型如下：```cint pthread_join(pthread_t thread, void **retval);```其中，thread是要等待的线程的标识符，retval是一个指向指针的指针，用于接收线程的返回值。

调用pthread_join函数会阻塞当前线程，直到指定的线程结束。

如果线程已经结束，pthread_join函数会立即返回。

当线程结束后，它的返回值可以通过retval参数获取。

下面是一个简单的示例代码，演示了如何使用pthread_join 函数等待线程结束：```c#include <stdio.h>#include <pthread.h>void *thread_func(void *arg) {printf("Thread is running\n");// 线程执行的代码return NULL;}int main() {pthread_t thread;pthread_create(&thread, NULL, thread_func, NULL);// 等待线程结束pthread_join(thread, NULL);printf("Thread is finished\n");return 0;}```在上面的示例中，主线程创建了一个新的线程，并调用pthread_join函数等待线程结束。

当线程结束后，主线程会继续执行，并打印"Thread is finished"。

c多线程编程实例多线程编程，也称作并行编程，是指在一个程序中存在多个执行线程，这些线程可以同时执行，但它们之间有可能发生共享变量的竞争情况。

在这种情况下，程序员必须注意这些变量的使用，以确保程序在多线程环境下正常工作。

C语言是一门流行的程序设计语言，它具有良好的可移植性和易操作性，广泛应用于大多数复杂的应用程序开发中。

它的多线程编程能力也是其受欢迎的原因之一。

在C语言中，多线程编程是通过pthread库来实现的，它提供了一系列的函数，如pthread_create()、pthread_join()、pthread_exit()等，可以让程序员更轻松地实现多线程编程。

下面，我们就来看一个具体的多线程编程实例，如何在C语言中实现一个多线程程序。

首先，需要包含pthread库中所提供的头文件，以便调用多线程函数：#include <pthread.h>接下来，需要定义线程函数，在这个例子中，我们定义两个线程函数，分别用于处理输入和输出：void* thread_input(void* arg);void* thread_output(void* arg);接下来，需要实例化线程句柄，用于将线程号和线程函数关联起来：pthread_t thread_input_handler;pthread_t thread_output_handler;接着，需要创建线程，分别将线程句柄和线程函数关联：pthread_create(&thread_input_handler, NULL, thread_input, NULL);pthread_create(&thread_output_handler, NULL,thread_output, NULL);最后，需要在主线程中等待子线程完成工作，然后再进行清理： pthread_join(thread_input_handler, NULL);pthread_join(thread_output_handler,NULL);pthread_exit(NULL);以上就是一个基本的多线程编程实例，它可以用于大多数多线程应用场景。

linux pthread 用法Linux pthread（POSIX线程）是一种多线程库，它提供了在Linux系统上创建和管理线程的API。

使用pthread库，可以编写多线程程序，实现并发执行和资源共享。

下面是一些常用的pthread函数和用法：1.pthread_create()：用于创建一个新的线程。

它接受一个指向线程属性的指针，一个指向线程函数的指针，以及传递给线程函数的参数。

函数原型为：intpthread_create(pthread_t *thread, const pthread_attr_t *attr, void*(*start_routine) (void *), void *arg);2.pthread_join()：用于等待一个线程的结束。

它接受一个指向线程标识符的指针，以及一个指向用于存储线程返回值的指针的指针。

函数原型为：intpthread_join(pthread_t thread, void **retval);3.pthread_self()：用于获取当前线程的标识符。

函数原型为：pthread_tpthread_self(void);4.pthread_detach()：用于将一个线程从系统中分离出去。

这通常用于在后台运行的任务，不需要手动等待它们完成。

函数原型为：int pthread_detach(pthread_t thread);5.pthread_equal()：用于比较两个线程标识符是否相等。

函数原型为：intpthread_equal(pthread_t thread1, pthread_t thread2);6.pthread_mutex_init()：用于初始化一个互斥锁。

函数原型为：intpthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); 7.pthread_mutex_lock()：用于获取一个互斥锁。

linux下的CC++多进程多线程编程实例详解linux下的C\C++多进程多线程编程实例详解1、多进程编程#include <stdlib.h>#include <sys/types.h>#include <unistd.h>int main(){pid_t child_pid;/* 创建⼀个⼦进程 */child_pid = fork();if(child_pid == 0){printf("child pid\n");exit(0);}else{printf("father pid\n");sleep(60);}return 0;}2、多线程编程#include <stdio.h>#include <pthread.h>struct char_print_params{char character;int count;};void *char_print(void *parameters){struct char_print_params *p = (struct char_print_params *)parameters;int i;for(i = 0; i < p->count; i++){fputc(p->character,stderr);}return NULL;}int main(){pthread_t thread1_id;pthread_t thread2_id;struct char_print_params thread1_args;struct char_print_params thread2_args;thread1_args.character = 'x';thread1_args.count = 3000;pthread_create(&thread1_id, NULL, &char_print, &thread1_args);thread2_args.character = 'o';thread2_args.count = 2000;pthread_create(&thread2_id, NULL, &char_print, &thread2_args);pthread_join(thread1_id, NULL);pthread_join(thread2_id, NULL);return 0;}3、线程同步与互斥1）、互斥pthread_mutex_t mutex;pthread_mutex_init(&mutex, NULL);/*也可以⽤下⾯的⽅式初始化*/pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&mutex);/* 互斥 */thread_flag = value;pthread_mutex_unlock(&mutex);2）、条件变量int thread_flag = 0;pthread_mutex_t mutex;pthread_cond_t thread_flag_cv;\void init_flag(){pthread_mutex_init(&mutex, NULL);pthread_cond_init(&thread_flag_cv, NULL);thread_flag = 0;}void *thread_function(void *thread_flag){while(1){pthread_mutex_lock(&mutex);while(thread_flag != 0 ){pthread_cond_wait(&thread_flag_cv, &mutex);}pthread_mutex_unlock(&mutex);do_work();}return NULL;}void set_thread_flag(int flag_value){pthread_mutex_lock(&mutex);thread_flag = flag_value;pthread_cond_signal(&thread_flag_cv);pthread_mutex_unlock(&mutex);}感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

简单的多线程编程Linux系统下的多线程遵循POSIX线程接口，称为pthread。

编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。

顺便说一下，Linux下pthread的实现是通过系统调用clone（）来实现的。

clone （）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。

下面我们展示一个最简单的多线程程序 example1.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);}我们编译此程序：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资源的结果。

pthreads使用示例pthreads是一种在多线程编程中常用的库，它提供了一系列函数和数据结构，方便程序员在多线程环境下进行线程的创建、同步与通信。

本文将以示例的方式介绍pthreads的使用。

## 示例1：线程的创建与销毁在使用pthreads创建线程之前，我们需要先包含头文件`pthread.h`。

下面的示例展示了如何创建一个简单的线程，并在线程中输出一句话。

```c#include <stdio.h>#include <pthread.h>void* thread_func(void* arg) {printf("Hello, pthreads!\n");pthread_exit(NULL);}int main() {pthread_t thread;pthread_create(&thread, NULL, thread_func, NULL);pthread_join(thread, NULL);return 0;}```在上述示例中，首先定义了一个`thread_func`函数，它是线程的入口函数。

在该函数中，我们使用`printf`函数输出一句话。

然后，在`main`函数中，我们调用`pthread_create`函数创建一个新的线程，并将`thread_func`作为线程的入口函数。

最后，我们使用`pthread_join`函数等待线程的结束。

## 示例2：线程的同步与互斥在多线程编程中，线程之间的同步与互斥是非常重要的。

pthreads 提供了一些函数和数据结构，可以帮助我们实现线程的同步与互斥。

下面的示例展示了如何使用互斥锁在多个线程之间实现数据的同步与互斥访问。

```c#include <stdio.h>#include <pthread.h>pthread_mutex_t mutex;int count = 0;void* thread_func(void* arg) {for (int i = 0; i < 1000000; i++) {pthread_mutex_lock(&mutex);count++;pthread_mutex_unlock(&mutex);}pthread_exit(NULL);}int main() {pthread_t threads[10];pthread_mutex_init(&mutex, NULL);for (int i = 0; i < 10; i++) {pthread_create(&threads[i], NULL, thread_func, NULL);}for (int i = 0; i < 10; i++) {pthread_join(threads[i], NULL);}pthread_mutex_destroy(&mutex);printf("Final count: %d\n", count);return 0;}```在上述示例中，我们首先定义了一个互斥锁`mutex`和一个全局变量`count`。

pthread多线程用法pthread（POSIX Threads）是一种线程库，它提供了用于创建和管理线程的函数。

使用pthread多线程可以便捷地实现并行计算和并发执行。

要使用pthread多线程，需要包含pthread.h头文件，并在编译时链接pthread库。

接下来，我们将介绍pthread多线程的几个常用用法。

1. 创建线程：使用pthread_create函数可以创建一个新的线程，并指定它的执行函数。

线程创建成功后，会立即开始执行。

例如：```cvoid* thread_func(void* arg) {// 线程的执行函数return NULL;}int main() {pthread_t thread_id;pthread_create(&thread_id, NULL, thread_func, NULL);// 等待线程执行完毕pthread_join(thread_id, NULL);return 0;}```在上面的例子中，`pthread_create`函数创建了一个新线程，并将其指定的执行函数设置为`thread_func`。

线程创建后，可以使用`pthread_join`函数等待线程执行完毕。

2. 线程同步：在多线程编程中，线程之间的执行往往是并发的，为了保证数据的一致性和避免竞态条件，需要使用线程同步的机制。

pthread提供了多种线程同步的方法，例如互斥锁（mutex）、条件变量（condition variable）、信号量（semaphore）等。

通过对共享资源的访问进行同步，可以避免数据错乱和线程间的竞争问题。

3. 线程间通信：多个线程之间经常需要进行数据传递和共享资源的访问，为了保证线程之间的正确通信，可以使用线程间通信的机制。

pthread提供了一些线程间通信的方法，例如消息队列、共享内存、管道等。

这些机制可以实现不同线程之间的数据传递和同步操作。

c 语言两个线程之间参数的修改一、概述在多线程编程中，线程间的参数传递是一项重要的技术。

本文档将介绍如何在C语言中实现两个线程之间参数的修改。

二、基本原理在C语言中，可以使用指针和结构体等数据类型来实现线程间的参数传递。

当一个线程需要向另一个线程传递参数时，可以将参数存储在一个变量中，并将其地址作为参数传递给另一个线程。

这样，另一个线程就可以通过该地址访问该变量的值并进行修改。

三、代码示例以下是一个简单的示例代码，展示了如何在C语言中实现两个线程之间参数的修改。

```c#include<pthread.h>#include<stdio.h>//定义一个结构体，用于存储参数typedefstruct{intparam1;intparam2;}Params;//线程函数，用于执行线程操作void*thread_func(void*arg){//获取传递进来的参数Params*params=(Params*)arg;printf("Thread%dreceivedparameters:%d,%d\n",pthread_self( ),params->param1,params->param2);//修改参数值params->param1=10;params->param2=20;printf("Thread%dmodifiedparametersto:%d,%d\n",pthread_sel f(),params->param1,params->param2);returnNULL;}intmain(){//创建两个线程，并传递参数给它们pthread_tthread1,thread2;Paramsparams={42,100};pthread_create(&thread1,NULL,thread_func,(void*)&params);pthread_create(&thread2,NULL,thread_func,(void*)&params);//等待两个线程执行完毕pthread_join(thread1,NULL);pthread_join(thread2,NULL);return0;}```在上述代码中，我们首先定义了一个结构体`Params`，用于存储传递给线程的参数。

对线程等待函数pthread_join⼆级指针参数分析分析之前先搞明⽩，这个⼆级指针其实在函数内部是承接了上个线程的返回值。

看man⼿册，发现返回值是个普通指针。

⼈家⽤⼆级指针来承接，可能准备⼲⼤事。

这个可以⾃⼰搜索⼀下。

原因嘛，⼆级指针是保存了这个地址。

⼀级指针承接的话就是这个地址。

那既然⼆级指针保存了，我们如何访问那？开始我觉得直接来个⼆级指针，然后*访问算了，但是下⾯的东西。

让你不能那么⼲了！其实⾮要那样也可以 malloc呗！线程创建函数pthread_create的函数原型如下：int pthread_create(pthread_t *restrict thread,const pthread_attr_t *restrict attr,void *(*start_routine)(void*), void *restrict arg);其中，thread是要创建的线程；attr指定线程的属性，缺省值为NULL；start_routine是线程要执⾏的函数；arg是传递给线程执⾏的函数的参数；要注意的是：start_routine是函数指针线程等待函数pthread_create的函数原型如下：int pthread_join(pthread_t thread, void **value_ptr);其中，thread是要等待的线程名；value_ptr：指针*value_ptr指向线程返回的参数在使⽤时要注意的是：针对value_ptr，应该先声明⼀个⼀级指针，然后通过取地址的⽅式传给pthread_create函数，⽽不应该直接定义⼀个⼆级指针，将这个⼆级指针直接传递给pthread_create。

如：正确的传递⽅法：void *ret;pthread_join(thread, &ret);错误的传递⽅法：void **ret；pthread_join(thread, ret);原因：pthread_join中有⼀句类型这样的语句：(* value_ptr) = arg;如果按照正确的⽅式传递参数，左边的语句实际上完成的操作是：ret = arg；⼀点问题没有。

pthread_tryjoin_np用法一、概述pthread_tryjoin_np是POSIX线程（pthread）库中的一个函数，用于尝试获取线程的退出状态，而无需等待该线程终止。

这对于某些情况下需要检查线程是否已经结束，但又不希望阻塞当前线程的执行很有用。

二、函数原型intpthread_tryjoin_np(pthread_tthread,void**ptr);三、参数说明*`thread`：要尝试获取退出的线程的标识符。

*`ptr`：一个指向要传递给线程的内存地址的指针，该地址在成功获取线程退出状态后将被返回。

如果此参数为NULL，则不会返回任何值。

四、函数返回值如果成功获取了线程的退出状态并返回目标内存地址，则函数返回0。

如果线程仍在运行，则返回一个非零值，表示操作失败。

五、注意事项*pthread_tryjoin_np与pthread_join的区别在于，前者只是尝试获取线程的退出状态，而不会等待线程终止。

因此，它不会阻塞当前线程的执行。

*如果线程已经退出，但仍然有多个线程试图获取其退出状态，则可能会发生竞态条件，这取决于系统如何处理这些尝试。

在这种情况下，应该使用其他机制来同步对线程状态的访问。

*传递给线程的内存地址必须在调用pthread_tryjoin_np之前分配，并且必须足够大以容纳返回的值。

六、示例代码下面是一个简单的示例代码，展示了如何使用pthread_tryjoin_np函数：```c#include<pthread.h>#include<stdio.h>#include<stdlib.h>intmain(){pthread_tthread;int*value;intresult;//创建并启动线程result=pthread_create(&thread,NULL,&thread_function,NULL);if(result!=0){perror("Threadcreationfailed");exit(EXIT_FAILURE);}//尝试获取线程退出状态并打印结果值value=malloc(sizeof(int));//分配内存地址result=pthread_tryjoin_np(thread,value);if(result==0){printf("Threadexitedwithvalue:%d\n",*value);}else{printf("Threadisstillrunning\n");}//等待线程结束（可选）pthread_join(thread,NULL);//不阻塞当前线程的执行free(value);//释放内存地址return0;}```上述代码中，首先创建并启动一个线程，然后尝试使用pthread_tryjoin_np 函数获取该线程的退出状态。

C语⾔多线程操作多线程是多任务处理的⼀种特殊形式，多任务处理允许让电脑同时运⾏两个或两个以上的程序。

⼀般情况下，两种类型的多任务处理：基于进程和基于线程。

基于进程的多任务处理是程序的并发执⾏。

基于线程的多任务处理是同⼀程序的⽚段的并发执⾏。

多线程程序包含可以同时运⾏的两个或多个部分。

这样的程序中的每个部分称为⼀个线程，每个线程定义了⼀个单独的执⾏路径。

本教程假设您使⽤的是 Linux 操作系统，我们要使⽤ POSIX 编写多线程 C++ 程序。

POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可⽤，⽐如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

下⾯的程序，我们可以⽤它来创建⼀个POSIX 线程：#include <pthread.h>pthread_create (thread, attr, start_routine, arg)在这⾥，pthread_create 创建⼀个新的线程，并让它可执⾏。

下⾯是关于参数的说明：参数描述thread指向线程标识符指针。

attr⼀个不透明的属性对象，可以被⽤来设置线程属性。

您可以指定线程属性对象，也可以使⽤默认值 NULL。

start_routine线程运⾏函数起始地址，⼀旦线程被创建就会执⾏。

arg运⾏函数的参数。

它必须通过把引⽤作为指针强制转换为 void 类型进⾏传递。

如果没有传递参数，则使⽤ NULL。

创建线程成功时，函数返回 0，若返回值不为 0 则说明创建线程失败。

使⽤下⾯的程序，我们可以⽤它来终⽌⼀个 POSIX 线程：#include <pthread.h>pthread_exit (status)在这⾥，pthread_exit ⽤于显式地退出⼀个线程。

通常情况下，pthread_exit() 函数是在线程完成⼯作后⽆需继续存在时被调⽤。

【C++多线程】join（）及注意基础 join()函数的作⽤是让主线程的等待该⼦线程完成，然后主线程再继续执⾏。

这种情况下，⼦线程可以安全的访问主线程中的资源。

⼦线程结束后由主线程负责回收⼦线程资源。

⼀个⼦线程只能调⽤join()和detach()中的⼀个，且只允许调⽤⼀次。

可以调⽤joinable()来判断是否可以成功调⽤join()或detach()。

1 #include <thread>2 #include <iostream>34using namespace std;56void test()7 {8 cout << "⼦线程开始执⾏！" << endl;9//do something10 cout << "⼦线程执⾏完毕！" << endl;11 }12int main()13 {14 cout << "主线程开始执⾏！" << endl;15 thread t(test);16 cout << "join()是否可调：" << boolalpha << t.joinable() << endl;17 t.join(); //主线程等待⼦线程18 cout << "join()是否可调：" << boolalpha << t.joinable() << endl;19 cout << "主线程执⾏完毕！" << endl;20return0;21 }注意 1、为了确保⼦线程程序在发送异常退出前完成，就需要对注意调⽤join()函数的位置，否则当主线发⽣异常⽽此时还没有调⽤到join()函数，那么⼦线程随主线程终⽌。

【CC++开发】多线程编程中的join函数1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22# coding: utf-8# 测试多线程中join的功能import threading, timedef doWaiting():print'start waiting1: '+ time.strftime('%H:%M:%S') +"\n" time.sleep(3)print'stop waiting1: '+ time.strftime('%H:%M:%S') +"\n" def doWaiting1():print'start waiting2: '+ time.strftime('%H:%M:%S') +"\n" time.sleep(8)print'stop waiting2: ', time.strftime('%H:%M:%S') +"\n" tsk = []thread1 = threading.Thread(target = doWaiting)thread1.start()tsk.append(thread1)thread2 = threading.Thread(target = doWaiting1) thread2.start()tsk.append(thread2)print'start join: '+ time.strftime('%H:%M:%S') +"\n"for tt in tsk:tt.join()print'end join: '+ time.strftime('%H:%M:%S') +"\n"Join的作⽤是众所周知的，阻塞进程直到线程执⾏完毕这个⼩程序使⽤了两个线程thread1和thread2，线程执⾏的动作分别是doWaiting()和doWaiting1()，函数体就是打印「开始」+休眠3秒+打印「结束」，分别附加上时间⽤来查看程序执⾏的过程。

Linux下的多线程编程实例解析1 引⾔ 线程（thread）技术早在60年代就被提出，但真正应⽤多线程到操作系统中去，是在80年代中期，solaris是这⽅⾯的佼佼者。

传统的Unix也⽀持线程的概念，但是在⼀个进程（process）中只允许有⼀个线程，这样多线程就意味着多进程。

现在，多线程技术已经被许多操作系统所⽀持，包括Windows/NT，当然，也包括Linux。

为什么有了进程的概念后，还要再引⼊线程呢？使⽤多线程到底有哪些好处？什么的系统应该选⽤多线程？我们⾸先必须回答这些问题。

使⽤多线程的理由之⼀是和进程相⽐，它是⼀种⾮常"节俭"的多任务操作⽅式。

我们知道，在Linux系统下，启动⼀个新的进程必须分配给它独⽴的地址空间，建⽴众多的数据表来维护它的代码段、堆栈段和数据段，这是⼀种"昂贵"的多任务⼯作⽅式。

⽽运⾏于⼀个进程中的多个线程，它们彼此之间使⽤相同的地址空间，共享⼤部分数据，启动⼀个线程所花费的空间远远⼩于启动⼀个进程所花费的空间，⽽且，线程间彼此切换所需的时间也远远⼩于进程间切换所需要的时间。

据统计，总的说来，⼀个进程的开销⼤约是⼀个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较⼤的区别。

使⽤多线程的理由之⼆是线程间⽅便的通信机制。

对不同进程来说，它们具有独⽴的数据空间，要进⾏数据的传递只能通过通信的⽅式进⾏，这种⽅式不仅费时，⽽且很不⽅便。

线程则不然，由于同⼀进程下的线程之间共享数据空间，所以⼀个线程的数据可以直接为其它线程所⽤，这不仅快捷，⽽且⽅便。

当然，数据的共享也带来其他⼀些问题，有的变量不能同时被两个线程所修改，有的⼦程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地⽅。

除了以上所说的优点外，不和进程⽐较，多线程程序作为⼀种多任务、并发的⼯作⽅式，当然有以下的优点： 1) 提⾼应⽤程序响应。

Linux下C多线程编程实例Linux下C多线程编程2007-08-24 10:07:56Linux系统下的多线程遵循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。

前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。

创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。