linux多线程设计

1425阅读　0评论2011-12-08　啦哆A梦
分类：

是否熟悉POSIX多线程编程技术？如熟悉，编写程序完成如下功能：

1）有一int型全局变量g_Flag初始值为0；

2） 在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1

3） 在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2

4） 线程序1需要在线程2退出后才能退出

5） 主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出

1、进程与线程

进程是程序执行时的一个实例，即它是程序已经执行到何种程度的数据结构的汇集。从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。

线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。一个进程由几个线程组成（拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构），线程与同属一个进程的其他的线程共享进程所拥有的全部资源。

"进程——资源分配的最小单位，线程——程序执行的最小单位"

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

2、使用线程的理由

从上面我们知道了进程与线程的区别，其实这些区别也就是我们使用线程的理由。总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。（下面的内容摘自）

使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。

使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。

除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：

Linux多线程编程（不限Linux）2010-10-30 20:58 by 吴秦, 25943 visits, 收藏, 编辑

——本文一个例子展开，介绍Linux下面线程的操作、多线程的同步和互斥。

前言

线程？为什么有了进程还需要线程呢，他们有什么区别？使用线程有什么优势呢？还有多线程编程的一些细节问题，如线程之间怎样同步、互斥，这些东西将在本文中介绍。我在某QQ群里见到这样一道面试题：

是否熟悉POSIX多线程编程技术？如熟悉，编写程序完成如下功能：

1）有一int型全局变量g_Flag初始值为0；

2） 在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1

3） 在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2

4） 线程序1需要在线程2退出后才能退出

5） 主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出

我们带着这题开始这篇文章，结束之后，大家就都会做了。本文的框架如下：

  • 1、进程与线程
  • 2、使用线程的理由
  • 3、有关线程操作的函数
  • 4、线程之间的互斥
  • 5、线程之间的同步
  • 6、试题最终代码
1、进程与线程

进程是程序执行时的一个实例，即它是程序已经执行到何种程度的数据结构的汇集。从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。

线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。一个进程由几个线程组成（拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构），线程与同属一个进程的其他的线程共享进程所拥有的全部资源。

"进程——资源分配的最小单位，线程——程序执行的最小单位"

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

2、使用线程的理由

从上面我们知道了进程与线程的区别，其实这些区别也就是我们使用线程的理由。总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。（下面的内容摘自）

使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。

使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。

除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：

  • 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
  • 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
  • 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

=============================

从函数调用上来说，进程创建使用fork()操作；线程创建使用clone()操作。Richard Stevens大师这样说过：

  • fork is expensive. Memory is copied from the parent to the child, all descriptors are duplicated in the child, and so on. Current implementations use a technique called copy-on-write, which avoids a copy of the parent's data space to the child until the child needs its own copy. But, regardless of this optimization, fork is expensive.

  • IPC is required to pass information between the parent and child after the fork. Passing information from the parent to the child before the fork is easy, since the child starts with a copy of the parent's data space and with a copy of all the parent's descriptors. But, returning information from the child to the parent takes more work.

Threads help with both problems. Threads are sometimes called lightweight processes since a thread is "lighter weight" than a process. That is, thread creation can be 10–100 times faster than process creation.

All threads within a process share the same global memory. This makes the sharing of information easy between the threads, but along with this simplicity comes the problem of synchronization.

=============================

3、有关线程操作的函数
#include int pthread_create(pthread_t *tid, const pthread_attr_t *attr, void *(*func) (void *), void *arg); int pthread_join (pthread_t tid, void ** status); pthread_t pthread_self (void); int pthread_detach (pthread_t tid); void pthread_exit (void *status);

pthread_create用于创建一个线程，成功返回0，否则返回Exxx（为正数）。

  • pthread_t *tid：线程id的类型为pthread_t，通常为无符号整型，当调用pthread_create成功时，通过*tid指针返回。
  • const pthread_attr_t *attr：指定创建线程的属性，如线程优先级、初始栈大小、是否为守护进程等。可以使用NULL来使用默认值，通常情况下我们都是使用默认值。
  • void *(*func) (void *)：函数指针func，指定当新的线程创建之后，将执行的函数。
  • void *arg：线程将执行的函数的参数。如果想传递多个参数，请将它们封装在一个结构体中。

pthread_join用于等待某个线程退出，成功返回0，否则返回Exxx（为正数）。

  • pthread_t tid：指定要等待的线程ID
  • void ** status：如果不为NULL，那么线程的返回值存储在status指向的空间中（这就是为什么status是二级指针的原因！这种才参数也称为“值-结果”参数）。

pthread_self用于返回当前线程的ID。

pthread_detach用于是指定线程变为分离状态，就像进程脱离终端而变为后台进程类似。成功返回0，否则返回Exxx（为正数）。变为分离状态的线程，如果线程退出，它的所有资源将全部释放。而如果不是分离状态，线程必须保留它的线程ID，退出状态直到其它线程对它调用了pthread_join。

进程也是类似，这也是当我们打开进程管理器的时候，发现有很多僵死进程的原因！也是为什么一定要有僵死这个进程状态。

pthread_exit用于终止线程，可以指定返回值，以便其他线程通过pthread_join函数获取该线程的返回值。

  • void *status：指针线程终止的返回值。


4、线程之间的互斥

上面的代码似乎很好的解决了问题的前面4点要求，其实不然！！！因为g_Flag是一个全局变量，线程thread1和thread2可以同时对它进行操作，需要对它进行加锁保护，thread1和thread2要互斥访问才行。下面我们就介绍如何加锁保护——互斥锁。

互斥锁：

使用互斥锁（互斥）可以使线程按顺序执行。通常，互斥锁通过确保一次只有一个线程执行代码的临界段来同步多个线程。互斥锁还可以保护单线程代码。

互斥锁的相关操作函数如下：

#include int pthread_mutex_lock(pthread_mutex_t * mptr); int pthread_mutex_unlock(pthread_mutex_t * mptr); //Both return: 0 if OK, positive Exxx value on error

在对临界资源进行操作之前需要pthread_mutex_lock先加锁，操作完之后pthread_mutex_unlock再解锁。而且在这之前需要声明一个pthread_mutex_t类型的变量，用作前面两个函数的参数。具体代码见第5节。

5、线程之间的同步

第5点——主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出。就需要用到线程同步技术！线程同步需要条件变量。

条件变量：

使用条件变量可以以原子方式阻塞线程，直到某个特定条件为真为止。条件变量始终与互斥锁一起使用。对条件的测试是在互斥锁（互斥）的保护下进行的。

如果条件为假，线程通常会基于条件变量阻塞，并以原子方式释放等待条件变化的互斥锁。如果另一个线程更改了条件，该线程可能会向相关的条件变量发出信号，从而使一个或多个等待的线程执行以下操作：

  • 唤醒
  • 再次获取互斥锁
  • 重新评估条件

在以下情况下，条件变量可用于在进程之间同步线程：

  • 线程是在可以写入的内存中分配的
  • 内存由协作进程共享

“使用条件变量可以以原子方式阻塞线程，直到某个特定条件为真为止。”即可用到第5点，主线程main函数阻塞于等待g_Flag从1变为2，或者从2变为1。条件变量的相关函数如下：

#include int pthread_cond_wait(pthread_cond_t *cptr, pthread_mutex_t *mptr); int pthread_cond_signal(pthread_cond_t *cptr); //Both return: 0 if OK, positive Exxx value on error

pthread_cond_wait用于等待某个特定的条件为真，pthread_cond_signal用于通知阻塞的线程某个特定的条件为真了。在调用者两个函数之前需要声明一个pthread_cond_t类型的变量，用于这两个函数的参数。

为什么条件变量始终与互斥锁一起使用，对条件的测试是在互斥锁（互斥）的保护下进行的呢？因为“某个特性条件”通常是在多个线程之间共享的某个变量。互斥锁允许这个变量可以在不同的线程中设置和检测。

通常，pthread_cond_wait只是唤醒等待某个条件变量的一个线程。如果需要唤醒所有等待某个条件变量的线程，需要调用：

int pthread_cond_broadcast (pthread_cond_t * cptr);

默认情况下面，阻塞的线程会一直等待，知道某个条件变量为真。如果想设置最大的阻塞时间可以调用：

int pthread_cond_timedwait (pthread_cond_t * cptr, pthread_mutex_t *mptr, const struct timespec *abstime);

如果时间到了，条件变量还没有为真，仍然返回，返回值为ETIME。

  1. /*
  2.  是否熟悉POSIX多线程编程技术？如熟悉，编写程序完成如下功能：
  3.   1）有一int型全局变量g_Flag初始值为0；
  4.   2）在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1
  5.   3）在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2
  6.   4）线程序1需要在线程2退出后才能退出
  7.   5）主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出
  8.    */
  9. #include<stdio.h>
  10. #include<stdlib.h>
  11. #include<pthread.h>
  12. #include<errno.h>
  13. #include<unistd.h>

  15. typedef void* (*fun)(void*);

  17. int g_Flag=0;
  18. static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  19. static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

  21. void* thread1(void*);
  22. void* thread2(void*);

  24. /*
  25.  * when program is started, a single thread is created, called the initial thread or main thread.
  26.  * Additional threads are created by pthread_create.
  27.  * So we just need to create two thread in main().
  28.  */

  30. int main(int argc, char** argv)
  31. {
  32.     printf("enter main\n");
  33.     pthread_t tid1, tid2;
  34.     int rc1=0, rc2=0;
  35.     rc2 = pthread_create(&tid2, NULL, thread2, NULL);
  36.     if(rc2 != 0)
  37.         printf("%s: %d\n",__func__, strerror(rc2));

  39.     rc1 = pthread_create(&tid1, NULL, thread1, &tid2);
  40.     if(rc1 != 0)
  41.         printf("%s: %d\n",__func__, strerror(rc1));

  43.     pthread_cond_wait(&cond, &mutex);
  44.     printf("leave main\n");
  45.     exit(0);    
  46. }

  48. /*
  49.  * thread1() will be execute by thread1, after pthread_create()
  50.  * it will set g_Flag = 1;
  51.  */
  52. void* thread1(void* arg)
  53. {
  54.     printf("enter thread1\n");
  55.     printf("this is thread1, g_Flag: %d, thread id is %u\n",g_Flag, (unsigned int)pthread_self());
  56.     pthread_mutex_lock(&mutex);
  57.     if(g_Flag == 2)
  58.         pthread_cond_signal(&cond);
  59.     g_Flag = 1;
  60.     printf("this is thread1, g_Flag: %d, thread id is %u\n",g_Flag, (unsigned int)pthread_self());
  61.     pthread_mutex_unlock(&mutex);
  62.     pthread_join(*(pthread_t*)arg, NULL);
  63.     printf("leave thread1\n");
  64.     pthread_exit(0);
  65. }

  67. /*
  68.  * thread2() will be execute by thread2, after pthread_create()
  69.  * it will set g_Flag = 2;
  70.  */
  71. void* thread2(void* arg)
  72. {
  73.     printf("enter thread2\n");
  74.     printf("this is thread2, g_Flag: %d, thread id is %u\n",g_Flag, (unsigned int)pthread_self());
  75.     pthread_mutex_lock(&mutex);
  76.     if(g_Flag == 1)
  77.         pthread_cond_signal(&cond);
  78.     g_Flag = 2;
  79.     printf("this is thread2, g_Flag: %d, thread id is %u\n",g_Flag, (unsigned int)pthread_self());
  80.     pthread_mutex_unlock(&mutex);
  81.     printf("leave thread2\n");
  82.     pthread_exit(0);
  83. }

3.设置线程的属性

pthread_create函数的第二参数为指向pthread_attr_t结构的指针，设置为NULL表示使用默认属性创建一个线程。事实上，用户完全可以通过填写该结构来创建具有相关属性的线程，POSIX提供了一系列填写该结构的函数，从而设置所有相关属性，下面介绍一些比较常用的函数。

3.1初始化属性变量、释放属性变量
pthread_attr_init函数
pthread_attr_init函数的作用是初始化pthread_attr_t结构，用户在调用其他函数设置结构中的参数前，必须先调用本函数对结构进行初始化，其原型为：
int pthread_attr_init(pthread_attr_t *attr);
参数attr：待初始化的pthread_attr_t结构；
返回值：0，成功，非0，失败；

pthread_attr_destroy函数
pthread_attr_destroy函数的作用是释放pthread_attr_t结构占用的资源，pthread_attr_t结构经过初始化和其他函数设置后可能会占用某些资源，本函数的作用就是释放这些资源，一般在pthread_attr_t结构使用完毕后调用本函数，其原型为：
void pthread_attr_destroy(pthread_attr_t *attr);
参数attr：待释放的pthread_attr_t结构；
返回值：0，成功，非0，失败；

3.2设置或获取detachedstate属性
pthread_attr_setdetachstate函数
pthread_attr_setdetachstate函数的作用是设置线程的detachedstate属性，可以取值PTHREAD_CREATE_JOINABLE和PTHREAD_CREATE_DETACHED，前者是默认值，表示其他线程可以使用pthread_join函数等待本线程结束，后者表示其他线程不可以对本线程使用pthread_join，其原型为：
int pthread_attr_setdetachstate(pthread_attr_t *attr, int state);
参数attr：待设置的pthread_attr_t结构；
参数state：取值PTHREAD_CREATE_JOINABLE或PTHREAD_CREATE_DETACHED，表示期望的属性值；
返回值：0成功，非0失败；

pthread_attr_getdetachstate函数
pthread_attr_getdetachstate函数的作用是获取pthread_attr_t结构中的detachedstate属性，原型如下：
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
参数attr：待获取属性的pthread_attr_t结构；
参数detachstate：属性的返回值；
返回值：0成功，非0失败；

3.3设置或获取调度算法属性
pthread_attr_setschedpolicy函数
pthread_attr_setschedpolicy函数的作用是设置schedpolicy属性，即线程调度算法。schedpolicy属性值可以是SCHED_RR、SCHED_FIFO、SCHED_OTHER，其中SCHED_RR表示轮训调度，SCHED_FIFO表示先进先出调度，SCHED_OTHER表示其他。拥有管理员权限的进程才可以创建具有SCHED_RR或SCHED_FIFO调度算法的线程，一般线程的默认调度算法都是SCHED_OTHER。函数原型为：
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
参数attr：待设置的pthread_attr_t结构；
参数policy：取值SCHED_RR、SCHED_FIFO或SCHED_OTHER；
返回值：0成功，非0失败；

pthread_attr_getschedpolicy函数
pthread_attr_getschedpolicy函数的作用是获取pthread_attr_t结构中的schedpolicy属性，原型如下：
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);
参数attr：待获取属性的pthread_attr_t结构；
参数detachstate：属性的返回值；
返回值：0成功，非0失败；

pthread_attr_setschedparam函数
pthread_attr_setschedparam函数的作用是设置某调度算法下的具体调度参数，原型如下：
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
参数attr：待设置的pthread_attr_t结构；
参数param：调度参数，具体参见相关手册；
返回值：0成功，非0失败；

pthread_attr_getschedparam函数
pthread_attr_getschedparam函数的作用是获取pthread_attr_t结构中的调度参数，原型如下：
int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
参数attr：待获取属性的pthread_attr_t结构；
参数param：调度参数的返回值；
返回值：0成功，非0失败；

pthread_attr_setinheritsched函数
pthread_attr_setinheritsched函数的作用是设置线程调度算法的继承特性，可以取值PTHREAD_EXPLICIT_SCHED或PTHREAD_INHERIT_SCHED，前者表示使用结构pthread_attr_t指定的调度算法，后者表示继承父线程使用的调度算法，默认为前者，原型如下：
int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit);
参数attr：待设置的pthread_attr_t结构；
参数policy：取值PTHREAD_EXPLICIT_SCHED或PTHREAD_INHERIT_SCHED；
返回值：0成功，非0失败；

pthread_attr_getinheritsched函数
pthread_attr_getinheritsched函数的作用是获取pthread_attr_t结构中的继承属性，原型如下：
int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit);
参数attr：待获取属性的pthread_attr_t结构；
参数inherit：继承属性的返回值；
返回值：0成功，非0失败；

pthread_attr_setscope函数
pthread_attr_setscope函数的作用是设置线程的在什么范围内竞争CPU资源，可以取值PTHREAD_SCOPE_SYSTEM或PTHREAD_SCOPE_PROCESS，前者表示在整个系统内竞争CPU资源，后者表示在同一进程内竞争CPU资源，默认为前者，原型如下：
int pthread_attr_setscope(pthread_attr_t *attr, int scope);
参数attr：待设置的pthread_attr_t结构；
参数policy：取值PTHREAD_SCOPE_SYSTEM或PTHREAD_SCOPE_PROCESS；
返回值：0成功，非0失败；

pthread_attr_getscope函数
pthread_attr_getscope函数的作用是获取pthread_attr_t结构中的CPU竞争范围属性，原型如下：
int pthread_attr_getscope(const pthread_attr_t *attr, int *scope);
参数attr：待获取属性的pthread_attr_t结构；
参数scope：竞争范围的返回值；
返回值：0成功，非0失败；

3.4设置或获取线程栈的大小
某些系统可能不支持设置或获取线程栈，只有定义了_POSIX_THREAD_ATTR_STACKSIZE宏的系统才支持上述功能，具体由两个函数提供：
pthread_attr_setstacksize函数
pthread_attr_setstacksize函数的作用是设置线程栈的大小，单位是字节，在默认情况下线程的栈是比较大的，原型如下：
int pthread_attr_setstacksize(pthread_attr_t *attr, int size);
参数attr：待设置的pthread_attr_t结构；
参数size：栈的大小，单位为字节；
返回值：0成功，非0失败；

pthread_attr_getstacksize函数
pthread_attr_getstacksize函数的作用是获取pthread_attr_t结构中的栈的大小，原型如下：
int pthread_attr_getstacksize(const pthread_attr_t *attr, int *size);
参数attr：待获取属性的pthread_attr_t结构；
参数size：栈大小的返回值；
返回值：0成功，非0失败；

设置线程分离例子：

  1. pthread_t id1;
  2.   pthread_attr_t attr;
  3.   pthread_attr_init(&attr);
  4.   pthread_attr_setdetachstate(&attr ,PTHREAD_CREATE_DETACHED);

  6.   int ret;
  7.   ret=pthread_create(&id1 ,&attr ,(void *)load_pix_path,dphoto);
  8.   pthread_attr_destroy(&attr);

线程属性综合设置例子：

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <stdlib.h>
  4. #include <pthread.h>
  5. void *thread_function(void *arg);
  6. char message[] = "Hello World";
  7. int thread_finished = 0;
  8. int main() {
  9.     int res;
  10.     pthread_t a_thread;
  11.     pthread_attr_t thread_attr;
  12.     struct sched_param scheduling_value； // 线程调度算法的调度参数
  13.     res = pthread_attr_init(&thread_attr);
  14.     if (res != 0) {
  15.         perror("Attribute creation failed");
  16.         exit(EXIT_FAILURE);
  17.     }
  18.     res = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED); //设置线程分离
  19. if (res != 0) {
  20.         perror("Setting detached attribute failed");
  21.         exit(EXIT_FAILURE);
  22.     }
  23. res = pthread_attr_setschedpolicy(&thread_attr, SCHED_OTHER); //设置线程的调度算法为“其他”
  24.     if (res != 0) {
  25.         perror("Setting scheduling policy failed");
  26.         exit(EXIT_FAILURE);
  27.     }
  28.     scheduling_value.sched_priority = sched_get_priority_min(SCHED_OTHER);
  29.     res = pthread_attr_setschedparam(&thread_attr, &scheduling_value);
  30.     if (res != 0) {
  31.         perror("Setting scheduling priority failed");
  32.         exit(EXIT_FAILURE);
  33.     }
  34.     res = pthread_create(&a_thread, &thread_attr, thread_function, (void *)message);
  35.     if (res != 0) {
  36.         perror("Thread creation failed");
  37.         exit(EXIT_FAILURE);
  38.     }
  39.     (void)pthread_attr_destroy(&thread_attr); // 销毁线程属性，线程结束后会自动回收
  40.     while(!thread_finished) {
  41.         printf("Waiting for thread to say it's finished...\n");
  42.         sleep(1);
  43.     }
  44.     printf("Other thread finished, bye!\n");
  45.     exit(EXIT_SUCCESS);
  46. }
  47. void *thread_function(void *arg) {
  48.     printf("thread_function is running. Argument was %s\n", (char *)arg);
  49.     sleep(4);
  50.     printf("Second thread setting finished flag, and exiting now\n");
  51.     thread_finished = 1;
  52.     pthread_exit(NULL);
  53. }

4.1相关函数
pthread_cancel函数
pthread_cancel函数的作用是关闭另外一个线程，原型如下：
int pthread_cancel(pthread_t thread);
thread参数：线程标识，描述关闭哪一个线程；
返回值：0成功，非0失败；

pthread_setcancelstate函数
pthread_setcancelstate函数的作用是设置本线程是否允许被其他线程关闭，原型如下：
int pthread_setcancelstate(int state, int *oldstate);
参数state：可以取值PTHREAD_CANCEL_ENABLE或PTHREAD_CANCEL_DISABLE，前者表示允许被其他线程关闭，后者表示不允许，默认为前者；
参数oldstate：返回设置之前的本属性值；
返回值：0成功，非0失败；

pthread_setcanceltype函数
pthread_setcanceltype函数的作用是设置本线程被其他线程关闭时，以什么方式关闭，原型如下：
int pthread_setcanceltype(int type, int *oldtype);
参数type：PTHREAD_CANCEL_ASYNCHRONOUS或PTHREAD_CANCEL_DEFERRED，前者表示被立刻关闭，后者表示等线程被阻塞时再关闭，默认为后者；
参数oldtype：返回设置之前的本属性值；
返回值：0成功，非0失败；

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <stdlib.h>
  4. #include <pthread.h>
  5. void *thread_function(void *arg);
  6. int main() {
  7.     int res;
  8.     pthread_t a_thread;
  9.     void *thread_result;
  10.     res = pthread_create(&a_thread, NULL, thread_function, NULL);
  11.     if (res != 0) {
  12.         perror("Thread creation failed");
  13.         exit(EXIT_FAILURE);
  14.     }
  15.     sleep(1);
  16.     printf("Cancelling thread...\n");
  17.     res = pthread_cancel(a_thread);
  18.     if (res != 0) {
  19.         perror("Thread cancelation failed");
  20.         exit(EXIT_FAILURE);
  21.     }
  22.     printf("Waiting for thread to finish...\n");
  23.     res = pthread_join(a_thread, &thread_result);
  24.     if (res != 0) {
  25.         perror("Thread join failed");
  26.         exit(EXIT_FAILURE);
  27.     }
  28.     exit(EXIT_SUCCESS);
  29. }
  30.  
  31. void *thread_function(void *arg) {
  32.     int i, res;
  33.     res = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
  34.     if (res != 0) {
  35.         perror("Thread pthread_setcancelstate failed");
  36.         exit(EXIT_FAILURE);
  37.     }
  38.     res = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
  39.     if (res != 0) {
  40.         perror("Thread pthread_setcanceltype failed");
  41.         exit(EXIT_FAILURE);
  42.     }
  43.     printf("thread_function is running\n");
  44.     for(i = 0; i < 10; i++) {
  45.        printf("Thread is still running (%d)...\n", i);
  46.        sleep(1);
  47.     }
  48.     pthread_exit(0);
  49. }

5.1通过旗语同步
旗语同步是通过旗语变量及两个相关的原子操作来完成的，具体包含下面的四个函数。

sem_init函数
sem_init函数的作用是生成一个旗语变量，并初始化该变量，原型为：
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数sem：返回指向旗语变量的指针；
参数pshared：0用于本进程内，非0用于进程间，所以在线程间使用时一般设置为0；
参数value：旗语的初始值；
返回值：0成功，非0失败；

sem_wait函数
sem_wait函数是一个原子操作，如果旗语变量大于0，则将旗语变量减1，然后立刻返回；如果旗语变量小于等于0，则将线程阻塞，直到旗语变量大于0，原型为：
int sem_wait(sem_t * sem);
参数sem：指向待操作的旗语变量；
返回值：0成功，非0失败；

sem_post函数
sem_post函数也是一个原子操作，将旗语变量加1，如果旗语变量大于0，则唤醒对应的阻塞线程，原型为：
int sem_post(sem_t * sem);
参数sem：指向待操作的旗语变量；
返回值：0成功，非0失败；

sem_destroy函数
sem_destroy函数的作用是释放一个旗语变量，原型为：
int sem_destroy(sem_t * sem);
参数sem：指向待释放的旗语变量；
返回值：0成功，非0失败，如果有线程阻塞在该旗语变量上，释放函数会失败；

下面通过一个例子来解释旗语在线程中的应用：

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6. #include <semaphore.h>
  7.  
  8. void *thread_function(void *arg);
  9. sem_t bin_sem;
  10. #define WORK_SIZE 1024
  11. char work_area[WORK_SIZE];
  12.  
  13. int main() {
  14.     int res;
  15.     pthread_t a_thread;
  16.     void *thread_result;
  17.     res = sem_init(&bin_sem, 0, 0); // 初始化同步信号灯为0
  18.     if (res != 0) {
  19.         perror("Semaphore initialization failed");
  20.         exit(EXIT_FAILURE);
  21.     }
  22.     res = pthread_create(&a_thread, NULL, thread_function, NULL);
  23.     if (res != 0) {
  24.         perror("Thread creation failed");
  25.         exit(EXIT_FAILURE);
  26.     }
  27.     printf("Input some text. Enter 'end' to finish\n");
  28.     while(strncmp("end", work_area, 3) != 0) {
  29.         fgets(work_area, WORK_SIZE, stdin);
  30.         sem_post(&bin_sem); // 信号灯+1
  31.     }
  32.     printf("\nWaiting for thread to finish...\n");
  33.     res = pthread_join(a_thread, &thread_result);
  34.     if (res != 0) {
  35.         perror("Thread join failed");
  36.         exit(EXIT_FAILURE);
  37.     }
  38.     printf("Thread joined\n");
  39.     sem_destroy(&bin_sem);
  40.     exit(EXIT_SUCCESS);
  41. }
  42. void *thread_function(void *arg) {
  43.     sem_wait(&bin_sem); // 信号灯-1,此处柱塞
  44.     while(strncmp("end", work_area, 3) != 0) {
  45.         printf("You input %d characters\n", strlen(work_area) -1);
  46.         sem_wait(&bin_sem);
  47.     }
  48.     pthread_exit(NULL);
  49. }

5.2通过互斥量同步
互斥量(MUTEX)的方法是使用锁的概念。线程在使用临界资源前先对某个互斥量加锁，使用完毕后再对该互斥量解锁，这样就可以防止多个线程同时操作临界资源。具体包括四个函数：

pthread_mutex_init函数
pthread_mutex_init函数的作用是生成一个互斥量，原型为：
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
参数mutex：返回指向互斥量的指针；
参数mutexattr：设置互斥量的属性，NULL表示使用默认属性，在默认属性下，系统不会检查是否存在死锁，例如同一个线程连续两次调用上锁函数就会发生死锁；
返回值：0成功，非0失败；

pthread_mutex_lock函数
pthread_mutex_lock函数的作用是对一个互斥量上锁，原型为：
int pthread_mutex_lock(pthread_mutex_t *mutex));
参数mutex：指向待上锁的互斥量；
返回值：0成功，非0失败；

pthread_mutex_unlock函数
pthread_mutex_unlock函数的作用是对一个互斥量解锁，原型为：
int pthread_mutex_unlock(pthread_mutex_t *mutex);
参数mutex：指向待解锁的互斥量；
返回值：0成功，非0失败；

pthread_mutex_destroy函数
pthread_mutex_destroy函数的作用是释放一个互斥量，原型为：
int pthread_mutex_destroy(pthread_mutex_t *mutex);
参数mutex：指向待释放的互斥量；
返回值：0成功，非0失败；

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <pthread.h>
  6. #include <semaphore.h>
  7.  
  8. void *thread_function(void *arg);
  9. pthread_mutex_t work_mutex; /* protects both work_area and time_to_exit */
  10. #define WORK_SIZE 1024
  11. char work_area[WORK_SIZE];
  12. int time_to_exit = 0;
  13.  
  14. int main() {
  15.     int res;
  16.     pthread_t a_thread;
  17.     void *thread_result;
  18.     res = pthread_mutex_init(&work_mutex, NULL);
  19.     if (res != 0) {
  20.         perror("Mutex initialization failed");
  21.         exit(EXIT_FAILURE);
  22.     }
  23.     res = pthread_create(&a_thread, NULL, thread_function, NULL);
  24.     if (res != 0) {
  25.         perror("Thread creation failed");
  26.         exit(EXIT_FAILURE);
  27.     }
  28.     pthread_mutex_lock(&work_mutex);
  29.     printf("Input some text. Enter 'end' to finish\n");
  30.     while(!time_to_exit) {
  31.         fgets(work_area, WORK_SIZE, stdin);
  32.         pthread_mutex_unlock(&work_mutex);
  33.         while(1) {
  34.             pthread_mutex_lock(&work_mutex);
  35.             if (work_area[0] != '\0') {
  36.                 pthread_mutex_unlock(&work_mutex);
  37.                 sleep(1);
  38.             }
  39.             else {
  40.                 break;
  41.             }
  42.         }
  43.     }
  44.     pthread_mutex_unlock(&work_mutex);
  45.     printf("\nWaiting for thread to finish...\n");
  46.     res = pthread_join(a_thread, &thread_result);
  47.     if (res != 0) {
  48.         perror("Thread join failed");
  49.         exit(EXIT_FAILURE);
  50.     }
  51.     printf("Thread joined\n");
  52.     pthread_mutex_destroy(&work_mutex);
  53.     exit(EXIT_SUCCESS);
  54. }
  55. void *thread_function(void *arg) {
  56.     sleep(1);
  57.     pthread_mutex_lock(&work_mutex);
  58.     while(strncmp("end", work_area, 3) != 0) {
  59.         printf("You input %d characters\n", strlen(work_area) -1);
  60.         work_area[0] = '\0';
  61.         pthread_mutex_unlock(&work_mutex);
  62.         sleep(1);
  63.         pthread_mutex_lock(&work_mutex);
  64.         while (work_area[0] == '\0' ) {
  65.             pthread_mutex_unlock(&work_mutex);
  66.             sleep(1);
  67.             pthread_mutex_lock(&work_mutex);
  68.         }
  69.     }
  70.     time_to_exit = 1;
  71.     work_area[0] = '\0';
  72.     pthread_mutex_unlock(&work_mutex);
  73.     pthread_exit(0);
  74. }



上一篇：项目进度计划的一些问题
下一篇：nios DMA的原理