线程并行编程

并行编程 和 串行编程

现在, 想使单个内核运行的更快已经很难, 但多添加一个内核要容易的多.
如果程序不能很好的利用多核, 他的运行速度和单核运行就有可能是一样的.
如果一个程序专门用于多核运算, 称为并行程序, 否则称为串行程序.
并行程序可以实现同时运行多个操作.

并行编程的三种方式

SIMD
单指令多数据, 常用于信号处理.
如, 两个数组相加, 同一指令( 加) 同时用于操作所有的数组元素.

MISD
多指令单数据, 多条指令对同一片数据进行操作, 同一数据被不同的执行线程同时处理.
如, 同时计算一组数据的 平均值 和 中位数.

MIMD
多指令多数据, 最常见的情况.
多条指令同时操作多片数据.

多任务处理

并行程序充分利用计算机的多核处理能力, 但并不意味着不能在单核处理器中运行, 因为操作系统.
操作系统是运行程序和内核之间的联系层, 提供了一层抽象, 保证每个程序都会及时得到机会运行各自的代码.
他会为每个程序提供一个短暂的时间区间( 通常是几毫秒), 此时程序可以在内核中运行.
这个时间区间后, 他会挂起程序, 让下一个程序运行, 这就给用户一种所有程序在同时运行的错觉( 这就是多任务处理).

为提高整体性能, 操作系统可能根据每个程序的运行情况, 改变时间区间的长度.
如, 程序读取文件数据等待硬盘响应时, 等待用户输入时, 等待网络时, 操作系统可以缩短该程序的时间区间, 保证其他程序的运行.
这种机制下, 程序在运行时无需知道系统内核的数量.

POSIX 线程

线程设计是并行程序设计的一种方法, 可以认为串行程序是单线程运行, 并行程序是多线程运行.
POSIX, Portable Operating System Interface, 大多数操作系统都支持的一种标准.
POSIX 线程, 也称 pthread.
典型的多线程程序由一个线程开始运行, 该线程称为主线程.
主线程调用 pthread_create 来产生其他线程.
如果系统有多个内核, 主线程和新线程可以同时运行.
对于单内核系统, 两个线程轮流运行.
主线程应该在第二个线程终止时调用 pthread_join.
该函数将使主线程处于等待状态, 直到另一个线程终止.
调用 pthread_join 之后, 将只有一个线程处于运行状态.
如果主线程没有等待新线程结束, 那么主线程将终止, 新线程同样被终止.

1. /* thread.c */
2.  
3. /*
4. 编译时添加 -lpthread, 将 pthread 库与可运行程序连接
5.  
6. **$ gcc thread.c -o thd -lpthread
7. **$ ./thd
8. Hello, world!
9. ---- From Thread 2
10. */
11.  
12. #include <pthread.h>
13. #include <stdio.h>
14. #include <stdlib.h>
15.  
16. void * printHello(void * arg) {
17. int * pi = (int *) arg;
18. int v = *pi;
19. printf("Hello world!\n---- From Thread %i\n", v);
20. return NULL;
21. }
22.  
23. int main(int argc, char ** argv) {
24. pthread_t sec;
25. int ret;
26. int arg = 2;
27.  
28. /*
29. pthread_create 被调用, 第一个参数是 24 行中创建的 pthread_t 对象的地址
30. 第二个参数是 NULL, pthread_t 对象 sec 将被初始化为默认值
31. 第三个参数是 printHello 函数的地址
32. 该函数的返回值类型是 void *, 有且仅有一个参数
33. 线程通过该函数地址执行 16 ~ 21 行的 printHello 函数
34. 第四个参数, 调用 printHello 函数时, 该参数被传递给 printHello 函数
35. 此时, 有两个线程在并行运行
36. */
37. ret = pthread_create(&sec, NULL, printHello, (void *) &arg);
38. if ( ret != 0 ) {
39. fprintf(stderr, "Error: pthread_create() returned %i\n", ret);
40. return EXIT_FAILURE;
41. }
42.  
43. /*
44. 主线程调用 pthread_join 以等待第二线程运行直到结束
45. 如果没有调用 pthread_join, 主线程可能终止, 并在第二线程打印信息前将第二线程终止
46. */
47. ret = pthread_join(sec, NULL);
48. if ( ret != 0 ) {
49. fprintf(stderr, "Error: pthread_join() returned %i\n", ret);
50. return EXIT_FAILURE;
51. }
52.  
53. return EXIT_SUCCESS;
54. }

多线程的交叉处理

1. /* unsyn.c */
2.  
3. #include <pthread.h>
4. #include <stdio.h>
5. #include <stdlib.h>
6.  
7. #define THREADS 16
8.  
9. void * thd_func(void * arg) {
10. int * pint = (int *) arg;
11. while ( 1 ) {
12. (*pint)++;
13. (*pint)--;
14. if ( *pint != 0 ) {
15. printf("value = %i\n", *pint);
16. return NULL;
17. }
18. }
19. }
20.  
21. int main(int argc, char ** argv) {
22. pthread_t thd_id[THREADS];
23. int ret;
24. int i;
25. int arg = 0;
26.  
27. for ( i = 0; i < THREADS; i++ ) {
28. ret = pthread_create(&thd_id[i], NULL, thd_func, (void *) &arg);
29. if ( ret != 0 ) {
30. fprintf(stderr, "pthread_create() returned %i\n", ret);
31. return EXIT_FAILURE;
32. }
33. }
34.  
35. for ( i = 0; i < THREADS; i++ ) {
36. ret = pthread_join(thd_id[i], NULL);
37. if ( ret != 0 ) {
38. fprintf(stderr, "pthread_join() returned %i\n", ret);
39. return EXIT_FAILURE;
40. }
41. }
42.  
43. return EXIT_SUCCESS;
44. }

不同线程之间内存共享是线程编程的一个特性, 但偶尔会出问题.
unsyn.c 程序创建了几个线程, 这些线程共享同一个 int 型变量的地址.
试问, 线程有可能打印输出信息吗? 打印出的值是多少? 会不会返回 NULL 并终止呢?
该程序的运行无法预测.
操作系统提供给每个线程一个短暂的时间区间, 供其执行一些代码.
当程序有多个线程, 每个线程都享有一定的时间区间.
操作系统会根据很多因素的变化来决定是否将一个线程挂起, 让其他线程运行并取得一些进展.
然而, 并没有办法去确定一个线程什么时候被挂起.
操作系统负责管理所有线程, 并防止某个线程占用过多的处理器时间.
对于多核处理器, 成百上千个不同线程在不同时间运行.
产生的微秒级差异, 使得我们不可以根据一般方法来预测给定线程在给定时间运行的内容.

对于 unsyn.c, 程序在运行下面的指令时发生了什么?
(*pint)++;

• 读取 arg 的值
• 值加 1
• 将新值写入 arg

arg 的值只在第三步才改变, 前两步将 arg 的值暂时保存在 CPU 内部一个临时位置 ( 寄存器).
线程共享内存空间, 但不共享寄存器, 而操作系统可能在三步的任意一个地方将线程挂起.

两个线程交叉运行时, 几种可能的情况 ( 当然, 还存在别的可能)

线程设计者允许这样的情况, 并不是设计过程中的瑕疵.
交给操作系统管理所有线程, 可以更加有效的利用系统资源.

原子级操作( atomic)

计算机的最小操作, 不允许再被细分, 不能再被简化.
当有两个原子级操作申请同时提交时, 一个请求必须等待, 直到另一个请求结束其运行周期.

线程同步

当线程之间不共享内存或只共享只读内存时, 不会出现线程交叉运行带来的问题.
当多线程对同一片内存执行写入操作( 或读取再写入), 线程交叉运行将会带来一些问题.
进行程序测试时, 问题有时会出现, 有时又不出现.
如果意识到线程交叉运行会带来问题, 可以指定哪些操作必须为原子级的( 临界段).
这些操作不允许被交叉运行, 一次只有一个线程可以进入临界段, 线程之间必须是同步的.
这由互斥锁来实现, 互斥锁一般带有锁定和解锁语句, 锁定和解锁语句之间的代码就是临界段.

线程需要从操作系统获得钥匙才能进入临界段.
一次只有一个线程可以进入临界段, 当线程进入临界段就立刻上锁, 运行临界段代码时保留钥匙.
线程离开临界段时, 执行解锁并将钥匙归还操作系统.
如果线程想进入临界段又没有钥匙, 只能排队等待.

1. /* syn.c */
2.  
3. /*
4. 该程序没有输出
5. 所有线程将会不停的运行
6. */
7.  
8. #include <pthread.h>
9. #include <stdio.h>
10. #include <stdlib.h>
11.  
12. #define THREADS 16
13.  
14. typedef struct {
15. int * pi;
16. pthread_mutex_t * mlock;
17. } ThdData;
18.  
19. void * thd_func(void * arg) {
20. ThdData * td = (ThdData *) arg;
21. int * pi = td -> pi;
22. pthread_mutex_t * mlock = td -> mlock;
23.  
24. while ( 1 ) {
25. int rv;
26. /* 锁定 */
27. rv = pthread_mutex_lock(mlock);
28. /* 临界段起点 */
29. if ( rv != 0 ) {
30. fprintf(stderr, "Error: mutex_lock failed\n");
31. return NULL;
32. }
33.  
34. (*pi)++;
35. (*pi)--;
36. if ( (*pi) != 0 ) {
37. printf("Value is %i\n", *pi);
38. return NULL;
39. }
40. /* 临界段终点 */
41. rv = pthread_mutex_unlock(mlock);
42. if ( rv != 0 ) {
43. fprintf(stderr, "Error: mutex_unlock failed\n");
44. return NULL;
45. }
46. }
47. return NULL;
48. }
49.  
50. int main(int argc, char ** argv) {
51. pthread_mutex_t mlock;
52. pthread_mutex_init(&mlock, NULL);
53. ThdData arg;
54. int v = 0;
55. arg.pi = &v;
56. arg.mlock = &mlock;
57.  
58. pthread_t thd_id[THREADS];
59. int rv, i;
60.  
61. for ( i = 0; i < THREADS; i++ ) {
62. rv = pthread_create(&thd_id[i], NULL, thd_func, (void *) &arg);
63. if ( rv != 0 ) {
64. fprintf(stderr, "Error: pthread_create() failed\n");
65. return EXIT_FAILURE;
66. }
67. }
68.  
69. for ( i = 0; i < THREADS; i++ ) {
70. rv = pthread_join(thd_id[i], NULL);
71. if ( rv != 0 ) {
72. fprintf(stderr, "Error: pthread_join() failed\n");
73. return EXIT_FAILURE;
74. }
75. }
76.  
77. pthread_mutex_destroy(&mlock);
78. return EXIT_SUCCESS;
79. }

阿姆达尔定律

多线程程序一般从主线程开始, 做一些工作, 然后其他线程被创建用于计算结果.
多线程的结果再被整合成最后的结果.
这样的程序编排有个明显的问题, 初始化和终结都是串行的, 这将成为性能瓶颈.
阿姆达尔定律, 递增的线程将带来递减的回报.
即是说, 程序总的运行时间随着线程数增加而递减, 但是线程数量翻倍却难以将总运行时间减少一半.

《 C 语言程序设计进阶教程》