盒子
盒子
文章目录
  1. 第14章 线程机制:并发函数的使用
  2. code

Unix-Linux编程实践教程-chapter14-thread

第14章 线程机制:并发函数的使用

执行线路即为程序的控制流程.pthreads的线程库允许程序在同一时刻运行多个函数

同时执行的各函数都拥有自己的局部变量,但共享所有的全局变量和动态分配的数据空间

当线程共享变量时,必须保证他们不会发生共享冲突.线程使用互斥锁保证在某一时刻只有
一个线程在对共享变量访问

线程间通过条件变量来互相通知和同步数据.一个线程挂起并等待着条件变量按照某种特定
方式变化,而另一个线程则发出信号使得条件变量发生变化

线程需要使用互斥量来避免对于共享资源操作函数的访问冲突.非重入的函数必须按照
这种方式进行保护

进程间可以通过管道 socket 信号 退出/等待以及运行环境来进行会话.线程因为是在
一个单独的进程中运行,共享全局变量,因此线程可以通过设置和读取这些全局变量来
进行通信,对共享内存的访问,既有用也危险

code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/*
* test_mutex.c
*/

#include <stdio.h>
#include <pthread.h>

int total = 0;
int times = 100;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

struct arg_set
{
int count;
};

int main()
{
pthread_t t1, t2;

/*
void * add();

pthread_create(&t1, NULL, add, NULL);
pthread_create(&t2, NULL, add, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);

printf("%d\n", total);
*/

void * add2(void *);


struct arg_set a1, a2;
a1.count = 0;
a2.count = 0;
pthread_create(&t1, NULL, add2, (void *)&a1);
pthread_create(&t2, NULL, add2, (void *)&a2);
pthread_join(t1, NULL);
pthread_join(t2, NULL);

printf("%d\n", a1.count + a2.count);

return 0;
}

// First method: add mutex
void * add()
{
for (int i = 0; i < times; i++)
{
pthread_mutex_lock(&lock);
total++;
pthread_mutex_unlock(&lock);
}
}

// Second method: cal single
void * add2(void * a)
{
struct arg_set *arg = a;
for (int i = 0; i < times; i++)
{
arg->count++;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/*
* test_mutex.c
*
* pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex)
* 使线程挂起直到另一个线程通过条件变量发出消息.先自动释放指定的锁,
* 然后等待条件变量的变化
* pthread_cond_signal(pthread_cond_t * cond)
* 通过条件变量cond 发消息
*/

#include <stdio.h>
#include <pthread.h>

int times = 100000000;
int total = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;

struct arg_set
{
int count;
int times;
};

struct arg_set * mailbox;

int main()
{
pthread_t t1, t2;

void * add2(void *);

int reports_in = 0;

struct arg_set a1, a2;

pthread_mutex_lock(&lock);

a1.count = 0;
a1.times = 10000000;
a2.count = 0;
a2.times = 1000;
pthread_create(&t1, NULL, add2, (void *)&a1);
pthread_create(&t2, NULL, add2, (void *)&a2);

while (reports_in < 2)
{
printf("MAIN: waiting for flag\n");
pthread_cond_wait(&flag, &lock);
printf("MAIN: I have the lock\n");
printf("%d\n", mailbox->count);
total += mailbox->count;
if (mailbox == &a1)
pthread_join(t1, NULL);
if (mailbox == &a2)
pthread_join(t2, NULL);
mailbox = NULL;
pthread_cond_signal(&flag);
reports_in ++;
}

printf("total %d\n", total);

return 0;
}

void * add2(void * a)
{
struct arg_set *arg = a;
for (int i = 0; i < arg->times; i++)
{
arg->count++;
}

printf("COUNT: waiting to get lock\n");
pthread_mutex_lock(&lock);
printf("COUNT: have lock\n");
if (mailbox != NULL)
pthread_cond_wait(&flag, &lock);
mailbox = arg;
pthread_cond_signal(&flag);
pthread_mutex_unlock(&lock);

return NULL;
}