【人工智能】— 贝叶斯网络、概率图模型、全局语义、因果链、朴素贝叶斯模型、枚举推理、变量消元-CFANZ编程社区

线程操作

线程操作分线程的创建，退出，等待 3 种

1. 线程创建

#include <pthread.h>
int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
// 返回：若成功返回0，否则返回错误编号

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

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

　　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);
// 返回：若成功返回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

三段代码示例：

（1）：

#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)
{
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));

}

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

   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());

pthread_join(t1,NULL);

return 0;
}
（2）

#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 int ret = 10;

printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));

pthread_exit((void *)&ret);
}

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

int *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());

pthread_join(t1,(void **)&pret);

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

return 0;
}
（3）

#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());
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());

pthread_join(t1,(void **)&pret);

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

return 0;
}
编译结果：

线程还能共享内存空间

示例代码：

#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);
int g_data = 0;

void *func1(void *arg)
{
   printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
   printf("t1:param is %d\n",*((int *)arg));
   while(1){

printf("t1: %d\n",g_data++);
sleep(1);

       if(g_data == 3){
           pthread_exit(NULL);
       }
   }

}

void *func2(void *arg)
{
   printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
   printf("t2:param is %d\n",*((int *)arg));
   while(1){

       printf("t2: %d\n",g_data++);
       sleep(1);
   }
}

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

   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());
   while(1){

       printf("main: %d\n",g_data++);
       sleep(1);
   }

pthread_join(t1,NULL);
pthread_join(t2,NULL);

return 0;
}
编译结果：