linux多线程设计是指基于Linux操作系统下的多线程设计,包括多任务程序的设计,并发程序设计,网络程序设计,数据共享等。Linux系统下的多线程遵循POSIX线程接口,称为pthread。
一、什么是线程?
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
二、什么时候使用多线程? 当多个任务可以并行执行时,可以为每个任务启动一个线程。
三、线程的创建 使用pthread_create函数。
1
2
3
4
5
|
#include<pthread.h>
int pthread_create (pthread_t *__restrict __newthread,//新创建的线程ID
__const pthread_attr_t *__restrict __attr,//线程属性
void *(*__start_routine) (void *),//新创建的线程从start_routine开始执行
void *__restrict __arg)//执行函数的参数
|
返回值:成功-0,失败-返回错误编号,可以用strerror(errno)函数得到错误信息
四、线程的终止 三种方式线程从执行函数返回,返回值是线程的退出码线程被同一进程的其他线程取消调用pthread_exit()函数退出。这里不是调用exit,因为线程调用exit函数,会导致线程所在的进程退出。
一个小例子:
启动两个线程,一个线程对全局变量num执行加1操作,执行五百次,一个线程对全局变量执行减1操作,同样执行五百次。
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
|
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
int num=0;
void *add(void *arg) {//线程执行函数,执行500次加法
int i = 0,tmp;
for (; i <500; i++)
{
tmp=num+1;
num=tmp;
printf("add+1,result is:%d\n",num);
}
return ((void *)0);
}
void *sub(void *arg)//线程执行函数,执行500次减法
{
int i=0,tmp;
for(;i<500;i++)
{
tmp=num-1;
num=tmp;
printf("sub-1,result is:%d\n",num);
}
return ((void *)0);
}
int main(int argc, char** argv) {
pthread_t tid1,tid2;
int err;
void *tret;
err=pthread_create(&tid1,NULL,add,NULL);//创建线程
if(err!=0)
{
printf("pthread_create error:%s\n",strerror(err));
exit(-1);
}
err=pthread_create(&tid2,NULL,sub,NULL);
if(err!=0)
{
printf("pthread_create error:%s\n",strerror(err));
exit(-1);
}
err=pthread_join(tid1,&tret);//阻塞等待线程id为tid1的线程,直到该线程退出
if(err!=0)
{
printf("can not join with thread1:%s\n",strerror(err));
exit(-1);
}
printf("thread 1 exit code %d\n",(int)tret);
err=pthread_join(tid2,&tret);
if(err!=0)
{
printf("can not join with thread1:%s\n",strerror(err));
exit(-1);
}
printf("thread 2 exit code %d\n",(int)tret);
return 0;
}
|
使用g++编译该文件(g++ main.cpp -o main)。此时会报错undefined reference to `pthread_create'。
报这个错误的原因是:pthread库不是linux默认的库,所以在编译时候需要指明libpthread.a库。
解决方法:在编译时,加上-lpthread参数。
执行结果:
乍一看,结果是对的,加500次,减500次,最后结果为0。但是仔细看所有的输出,你会发现有异样的东西。
导致这个不和谐出现的原因是,两个线程可以对同一变量进行修改。假如线程1执行tmp=50+1后,被系统中断,此时线程2对num=50执行了减一操作,当线程1恢复,在执行num=tmp=51。而正确结果应为50。所以当多个线程对共享区域进行修改时,应该采用同步的方式。
五、线程同步线程同步的三种方式:
1、互斥量 互斥量用pthread_mutex_t数据类型来表示。
两种方式初始化,第一种:赋值为常量PTHREAD_MUTEX_INITIALIZER;第二种,当互斥量为动态分配是,使用pthread_mutex_init函数进行初始化,使用pthread_mutex_destroy函数销毁。
1
2
3
4
|
#include<pthread.h>
int pthread_mutex_init (pthread_mutex_t *__mutex,
__const pthread_mutexattr_t *__mutexattr);
int pthread_mutex_destroy (pthread_mutex_t *__mutex);
|
返回值:成功-0,失败-错误编号 加解锁加锁调用pthread_mutex_lock,解锁调用pthread_mutex_unlock。
1
2
3
|
#include<pthread.h>
int pthread_mutex_lock (pthread_mutex_t *__mutex);
int pthread_mutex_unlock (pthread_mutex_t *__mutex);
|
使用互斥量修改上一个程序(修改部分用红色标出):
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
|
pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;
void *add(void *arg) {
int i = 0,tmp;
for (; i <500; i++)
{
pthread_mutex_lock(&mylock);
tmp=num+1;
num=tmp;
printf("+1,result is:%d\n",num);
pthread_mutex_unlock(&mylock);
}
return ((void *)0);
}
void *sub(void *arg)
{
int i=0,tmp;
for(;i<500;i++)
{
pthread_mutex_lock(&mylock);
tmp=num-1;
num=tmp;
printf("-1,result is:%d\n",num);
pthread_mutex_unlock(&mylock);
}
return ((void *)0);
}
|
2、读写锁 允许多个线程同时读,只能有一个线程同时写。适用于读的次数远大于写的情况。 读写锁初始化:
1
2
3
4
5
|
#include<pthread.h>
int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
__const pthread_rwlockattr_t *__restrict
__attr);
int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);
|
返回值:成功--0,失败-错误编号
加锁,这里分为读加锁和写加锁。
读加锁:
int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
写加锁:
int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
解锁用同一个函数:
int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
3、条件变量条件变量用pthread_cond_t数据类型表示。条件变量本身由互斥量保护,所以在改变条件状态前必须锁住互斥量。
条件变量初始化:
第一种,赋值常量PTHREAD_COND_INITIALIZER;第二种,使用pthread_cond_init函数
int pthread_cond_init (pthread_cond_t *__restrict __cond,
__const pthread_condattr_t *__restrict
__cond_attr);int pthread_cond_destroy (pthread_cond_t *__cond);
条件等待
使用pthread_cond_wait等待条件为真。
pthread_cond_wait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex)
这里需要注意的是,调用pthread_cond_wait传递的互斥量已锁定,pthread_cond_wait将调用线程放入等待条件的线程列表,然后释放互斥量,在pthread_cond_wait返回时,再次锁定互斥量。
唤醒线程
pthread_cond_signal唤醒等待该条件的某个线程,pthread_cond_broadcast唤醒等待该条件的所有线程。
int pthread_cond_signal (pthread_cond_t *__cond);
int pthread_cond_broadcast (pthread_cond_t *__cond)
来一个例子,主线程启动4个线程,每个线程有一个参数i(i=生成顺序),无论线程的启动顺序如何,执行顺序只能为,线程0、线程1、线程2、线程3。
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
|
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#define DEBUG 1
int num=0;
pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t qready=PTHREAD_COND_INITIALIZER;
void * thread_func(void *arg)
{
int i=(int)arg;
int ret;
sleep(5-i);//线程睡眠,然最先生成的线程,最后苏醒
pthread_mutex_lock(&mylock);//调用pthread_cond_wait前,必须获得互斥锁
while(i!=num)
{
#ifdef DEBUG
printf("thread %d waiting\n",i);
#endif
ret=pthread_cond_wait(&qready,&mylock);//该函数把线程放入等待条件的线程列表,然后对互斥锁进行解锁,这两部都是原子操作。并且在pthread_cond_wait返回时,互斥量再次锁住。
if(ret==0)
{
#ifdef DEBUG
printf("thread %d wait success\n",i);
#endif
}else
{
#ifdef DEBUG
printf("thread %d wait failed:%s\n",i,strerror(ret));
#endif
}
}
printf("thread %d is running \n",i);
num++;
pthread_mutex_unlock(&mylock);//解锁
pthread_cond_broadcast(&qready);//唤醒等待该条件的所有线程
return (void *)0;
}
int main(int argc, char** argv) {
int i=0,err;
pthread_t tid[4];
void *tret;
for(;i<4;i++)
{
err=pthread_create(&tid[i],NULL,thread_func,(void *)i);
if(err!=0)
{
printf("thread_create error:%s\n",strerror(err));
exit(-1);
}
}
for (i = 0; i < 4; i++)
{
err = pthread_join(tid[i], &tret);
if (err != 0)
{
printf("can not join with thread %d:%s\n", i,strerror(err));
exit(-1);
}
}
return 0;
}
|
在非DEBUG模式,执行结果如图所示:
在DEBUG模式,执行结果如图所示:
在DEBUG模式可以看出,线程3先被唤醒,然后执行pthread_cond_wait(输出thread 3 waiting),此时在pthread_cond_wait中先解锁互斥量,然后进入等待状态。这是thread 2加锁互斥量成功,进入pthread_cond_wait(输出thread 2 waiting) ,同样解锁互斥量,然后进入等待状态。直到线程0,全局变量与线程参数i一致,满足条件,不进入条件等待,输出thread 0 is running。全局变量num执行加1操作,解锁互斥量,然后唤醒所有等待该条件的线程。thread 3 被唤醒,输出thread 3 wait success。但是不满足条件,再次执行pthread_cond_wait。如此执行下去,满足条件的线程执行,不满足条件的线程等待。
引言
条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待条件变量的条件成立而挂起(此时不再占用cpu);另一个线程使条件成立(给出条件成立信号)。为了防止竞争,条件变量的使用总是和一个互斥锁结合在一起。
函数原型
1. 定义条件变量
1
2
3
4
|
#include <pthread.h>
/* 定义两个条件变量 */
pthread_cond_t cond_pro, cond_con;
|
2. 初始化和销毁条件变量
1
2
3
4
5
6
7
8
|
#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);int pthread_cond_destroy(pthread_cond_t *cond); /* 初始化条件变量 */
pthread_cond_init(&cond_pro, NULL);
pthread_cond_init(&cond_con, NULL);
/* 销毁条件变量 */
pthread_cond_destroy(&cond_pro);
pthread_cond_destroy(&cond_pro);
|
3. 等待和激发条件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);
/* 等待条件 */
/* 注意:pthread_cond_wait为阻塞函数。解开锁,再等待。等条件满足时,需要抢到锁,才可以被唤醒*/
pthread_cond_wait(&cond_pro,&mutex);
/* 激发条件 */
/* 所有因为不满足条件的线程都会阻塞在条件变量cond_pro中的一个队列中 */
/* 以广播方式,通知所有被阻塞的所有线程 */
pthread_cond_broadcast(&cond_pro);
/* 以signal方式,只通知排在最前面的线程 */
pthread_cond_signal(&cond_pro);
|
代码
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
/*************************************************************************
> File Name: my_con.c
> Author: KrisChou
> Mail:zhoujx0219@163.com
> Created Time: Tue 26 Aug 2014 10:24:29 AM CST
************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#define CELL 10
#define FLORE 0
int i = 0; /* 所有线程共享的全局变量,此处假定至多递增至10,最小减到0 */
pthread_mutex_t mutex; /* 定义互斥锁 */
pthread_cond_t cond_pro, cond_con; /* 定义两个条件变量 */
/* 生产者线程 */
void* pro_handler(void *arg)
{
pthread_detach(pthread_self()); /* 由系统回收线程资源,而非主线程回收资源 ,此类情况主线程是个服务器,永久不会退出 */
while(1)
{
pthread_mutex_lock(&mutex);
while(i >= CELL)
{
pthread_cond_wait(&cond_pro,&mutex);
/* continue是轮询,此处是阻塞 */
/* 把锁放开再等 ,第一个参数是结构体指针,其中有成员存放被阻塞的函数 */
/*不占cpu*/
/* 不满足条件时才会等 ,需要别人告诉它,才能唤醒它*//* 当它返回时,锁也要回来了*/
}
i++;
if(i == 1)
{
/* 由空到不空,唤醒消费者 */
pthread_cond_signal(&cond_con); /*不会立马signal被阻塞的消费者线程,因为其还要等锁抢回来*/
}
printf("add i: %d \n", i);
pthread_mutex_unlock(&mutex);
sleep(rand() % 5 + 1);
}
}
/* 消费者线程 */
void* con_handler(void *arg)
{
pthread_detach(pthread_self());
while(1)
{
pthread_mutex_lock(&mutex);
while(i <= FLORE)
{
pthread_cond_wait(&cond_cno,&mutex);
}
i--;
if(i == 9) /* 由满到不满,要告诉生产者,以便将其唤醒 *//*此处,直接signal也可以,我们是为了更加精确*/
{
pthread_cond_signal(&cond_pro);
}
printf("con i: %d \n", i);
pthread_mutex_unlock(&mutex);
sleep(rand() % 5 + 1);
}
}
int main(int argc, char *argv[]) // exe +num -num
{
srand(getpid());
int con_cnt, pro_cnt;
pro_cnt = atoi(argv[1]);
con_cnt = atoi(argv[2]);
pthread_mutex_init(&mutex,NULL);
pthread_cond_init(&cond_pro,NULL);
pthread_cond_init(&cond_con,NULL);
pthread_t *arr = (pthread_t*)calloc(con_cnt + pro_cnt , sizeof(pthread_t));
int index = 0;
while(pro_cnt > 0)
{
pthread_create(arr + index, NULL, pro_handler, NULL);
index++;
pro_cnt--;
}
while(con_cnt > 0)
{
pthread_create(arr + index, NULL, con_handler, NULL);
index++;
con_cnt--;
}
while(1);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond_pro);
pthread_cond_destroy(&cond_con);
return 0;
}
|
无论是在生产者线程,还是在消费者线程中。标记黄色部分的判断条件必须用while。以生产者线程举例,当i>=CELL时,也就是i满时,此时执行pthread_cond_wait(&cond_cno,&mutex); 该生产者线程被挂起。必须等到消费者线程pthread_cond_signal(&cond_pro); 将其唤醒。但是消费者将其signal还不够,被挂其的生产者线程必须重新拿到锁,才可以被激活。但是,由于在消费者signal的同时,生产者并不能立即抢到锁,所以此时可能i值又改变变为大于等于10了。因此必须用while。不然可能导致i>10。
下面先来一个实例。我们通过创建两个线程来实现对一个数的递加。
或许这个实例没有实际运用的价值,但是稍微改动一下,我们就可以用到其他地方去拉。
下面是我们的代码:
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
86
87
88
89
|
/*thread_example.c : c multiple thread programming in linux
*author : falcon
*E-mail : tunzhj03@st.lzu.edu.cn
*/
#include <pthread.h>
#include <stdio.h>
#include <sys/time.h>
#include <string.h>
#define MAX 10
pthread_t
thread
[2];
pthread_mutex_t mut;
int
number=0, i;
void
*thread1()
{
printf
(
"thread1 : I'm thread 1/n"
);
for
(i = 0; i < MAX; i++)
{
printf
(
"thread1 : number = %d/n"
,number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&mut);
sleep(2);
}
printf
(
"thread1 :主函数在等我完成任务吗?/n"
);
pthread_exit(NULL);
}
void
*thread2()
{
printf
(
"thread2 : I'm thread 2/n"
);
for
(i = 0; i < MAX; i++)
{
printf
(
"thread2 : number = %d/n"
,number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&mut);
sleep(3);
}
printf
(
"thread2 :主函数在等我完成任务吗?/n"
);
pthread_exit(NULL);
}
void
thread_create(
void
)
{
int
temp;
memset
(&
thread
, 0,
sizeof
(
thread
));
//comment1
/*创建线程*/
if
((temp = pthread_create(&
thread
[0], NULL, thread1, NULL)) != 0)
//comment2
printf
(
"线程1创建失败!/n"
);
else
printf
(
"线程1被创建/n"
);
if
((temp = pthread_create(&
thread
[1], NULL, thread2, NULL)) != 0)
//comment3
printf
(
"线程2创建失败"
);
else
printf
(
"线程2被创建/n"
);
}
void
thread_wait(
void
)
{
/*等待线程结束*/
if
(
thread
[0] !=0) {
//comment4 pthread_join(thread[0],NULL);
printf
(
"线程1已经结束/n"
);
}
if
(
thread
[1] !=0) {
//comment5 pthread_join(thread[1],NULL);
printf
(
"线程2已经结束/n"
);
}
}
int
main()
{
/*用默认属性初始化互斥锁*/
pthread_mutex_init(&mut,NULL);
printf
(
"我是主函数哦,我正在创建线程,呵呵/n"
);
thread_create();
printf
(
"我是主函数哦,我正在等待线程完成任务阿,呵呵/n"
);
thread_wait();
return
0;
}
|
下面我们先来编译、执行一下
引文:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
falcon@falcon:~/program/c/code/ftp$ gcc -lpthread -o thread_example thread_example.c
falcon@falcon:~/program/c/code/ftp$ ./thread_example
我是主函数哦,我正在创建线程,呵呵
线程1被创建
线程2被创建
我是主函数哦,我正在等待线程完成任务阿,呵呵
thread1 : I'm
thread
1
thread1 : number = 0
thread2 : I'm
thread
2
thread2 : number = 1
thread1 : number = 2
thread2 : number = 3
thread1 : number = 4
thread2 : number = 5
thread1 : number = 6
thread1 : number = 7
thread2 : number = 8
thread1 : number = 9
thread2 : number = 10
thread1 :主函数在等我完成任务吗?
线程1已经结束
thread2 :主函数在等我完成任务吗?
线程2已经结束
|
实例代码里头的注释应该比较清楚了吧,下面我把网路上介绍上面涉及到的几个函数和变量给引用过来。
引文:
线程相关操作
一 pthread_t
pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义:
typedef unsigned long int pthread_t;
它是一个线程的标识符。
二 pthread_create
函数pthread_create用来创建一个线程,它的原型为:
extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,
void *(*__start_routine) (void *), void *__arg));
第一个参数为指向线程标识符的指针,第二个参数用来设置线程属性,第三个参数是线程运行函数的起始地址,最后一个参数是运行函数的参数。这里,我们的函数thread不需要参数,所以最后一个参数设为空指针。第二个参数我们也设为空指针,这样将生成默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时,函数返回0,若不为0则说明创建线程失败,常见的错误返回代码为EAGAIN和EINVAL。前者表示系统限制创建新的线程,例如线程数目过多了;后者表示第二个参数代表的线程属性值非法。创建线程成功后,新创建的线程则运行参数三和参数四确定的函数,原来的线程则继续运行下一行代码。
三 pthread_join pthread_exit
函数pthread_join用来等待一个线程的结束。函数原型为:
extern int pthread_join __P ((pthread_t __th, void **__thread_return));
第一个参数为被等待的线程标识符,第二个参数为一个用户定义的指针,它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数,调用它的函数将一直等待到被等待的线程结束为止,当函数返回时,被等待线程的资源被收回。一个线程的结束有两种途径,一种是象我们上面的例子一样,函数结束了,调用它的线程也就结束了;另一种方式是通过函数pthread_exit来实现。它的函数原型为:
extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
唯一的参数是函数的返回代码,只要pthread_join中的第二个参数thread_return不是NULL,这个值将被传递给 thread_return。最后要说明的是,一个线程不能被多个线程等待,否则第一个接收到信号的线程成功返回,其余调用pthread_join的线程则返回错误代码ESRCH。
在这一节里,我们编写了一个最简单的线程,并掌握了最常用的三个函数pthread_create,pthread_join和pthread_exit。下面,我们来了解线程的一些常用属性以及如何设置这些属性。
互斥锁相关
互斥锁用来保证一段时间内只有一个线程在执行一段代码。
一 pthread_mutex_init
函数pthread_mutex_init用来生成一个互斥锁。NULL参数表明使用默认属性。如果需要声明特定属性的互斥锁,须调用函数 pthread_mutexattr_init。函数pthread_mutexattr_setpshared和函数 pthread_mutexattr_settype用来设置互斥锁属性。前一个函数设置属性pshared,它有两个取值, PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用来不同进程中的线程同步,后者用于同步本进程的不同线程。在上面的例子中,我们使用的是默认属性PTHREAD_PROCESS_ PRIVATE。后者用来设置互斥锁类型,可选的类型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、 PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它们分别定义了不同的上所、解锁机制,一般情况下,选用最后一个默认属性。
二 pthread_mutex_lock pthread_mutex_unlock pthread_delay_np
pthread_mutex_lock声明开始用互斥锁上锁,此后的代码直至调用pthread_mutex_unlock为止,均被上锁,即同一时间只能被一个线程调用执行。当一个线程执行到pthread_mutex_lock处时,如果该锁此时被另一个线程使用,那此线程被阻塞,即程序将等待到另一个线程释放此互斥锁。
注意:
1 需要说明的是,上面的两处sleep不光是为了演示的需要,也是为了让线程睡眠一段时间,让线程释放互斥锁,等待另一个线程使用此锁。下面的参考资料1里头说明了该问题。但是在linux下好像没有pthread_delay_np那个函数(我试了一下,提示没有定义该函数的引用),所以我用了sleep来代替,不过参考资料2中给出另一种方法,好像是通过pthread_cond_timedwait来代替,里头给出了一种实现的办法。
2 请千万要注意里头的注释comment1-5,那是我花了几个小时才找出的问题所在。
如果没有comment1和comment4,comment5,将导致在pthread_join的时候出现段错误,另外,上面的comment2和comment3是根源所在,所以千万要记得写全代码。因为上面的线程可能没有创建成功,导致下面不可能等到那个线程结束,而在用pthread_join的时候出现段错误(访问了未知的内存区)。另外,在使用memset的时候,需要包含string.h头文件哦
linux线程分为两类:一是核心级支持线程,二是用户级的线程。一般都为用户级的线程。
一、多线程的几个常见函数
要创建多线程必须加载pthread.h文件,库文件pthread。线程的标识符pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义:typedef unsigned long int pthread_t
1.创建线程:
int pthread_create(pthread_t *restrict thread,
const pthread_attr_t *restrict attr,
void *(*start_routine)(void*), void *restrict arg);
参数:
thread输出线程id
attr 线程属性, 默认NULL
start_routine线程执行函数
arg线程执行参数
note:函数成功返回0 否则返回错误码
2.等待指定线程结束:
int pthread_join(pthread_t thread,void **value_ptr);
参数:
thread一个有效的线程id
value_ptr 接收线程返回值的指针
note:调用此函数的线程在指定的线程退出前将处于挂起状态或出现错误而直接返回,如果value_ptr非NULL则value_ptr指向线程返回值的指针,函数成功后指定的线程使用的资源将被释放。
3.退出线程:
int pthread_exit(void * value_ptr);
参数:
value_ptr 线程返回值指针
note: ptrhead_exit()退出调用此函数的线程并释放该线程占用的资源。
4.获取当前线程id:
pthread_t pthread_self(void);
参数:
note:返回当前函数的id
5.互斥
创建互斥:
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
参数:
mutex输出互斥id
attr 互斥属性, 默认NULL
note:函数成功返回0 否则返回错误码
锁住互斥:
int pthread_mutex_lock(pthread_mutex_t *mutex);
参数:
mutex互斥id
note:如果指定的互斥id已经被锁住那么呼叫线程在互斥id完全解锁前将一直处于挂起状态,否则将锁住互斥体。
int pthread_mutex_trylock(pthread_mutex_t *mutex);
参数:
mutex互斥id
note:如果指定的互斥id已经被锁住那么将直接返回一个错误,通过判断此错误来进行不同的处理。pthread_mutex_trylock和pthread_mutex_lock相似,不同的是pthread_mutex_trylock只有在互斥被锁住的情况下才阻塞。
解锁互斥:
int pthread_mutex_unlock(pthread_mutex_t *mutex);
参数:
mutex互斥id
note:如果指定的互斥id已经被锁住那么对其解锁
释放互斥:
int pthread_mutex_destroy(pthread_mutex_t *mutex);
参数:
mutex互斥id
note:释放指定的mutex占用的资源。
函数pthread_mutex_init和pthread_mutex_destroy分别是互斥锁的构造函数和析构函数。
二、多线程同步
1.互斥体
互斥量(mutex)相当于一把锁,可以保证以下三点:
◎原子性:如果一个线程锁定一个互斥量,那么临界区内的操作要么全部完成,要么一个也不执行。
◎惟一性:如果一个线程锁定一个互斥量,那么在它解除锁定之前,没有其他线程可以锁定这个互斥量。
◎非繁忙等待:如果一个线程已经锁定一个互斥量,第二个线程又试图去锁定这个互斥量,则第二个线程将被挂起(不占用任何CPU资源),直到第一个线程解除对这个互斥量的锁定为止。
2.条件变量
条件变量是一种可以使线程(不消耗CPU)等待某些事件发生的机制。某些线程可能守候着一个条件变量,直到某个其他的线程给这个条件变量发送一个信号,这时这些线程中的一个线程就会苏醒,处理这个事件。但条件变量不提供锁定,所以它必须与一个互斥量同时使用,提供访问这个环境变量时必要的锁定。
3.信号量
Dijkstra提出了信号量的概念,信号量是一种特殊的变量,只可以取正整数值,对这个正整数只能采取两种操作:P操作(代表等待,关操作)和V操作(代表信号,开操作)。
P/V操作定义如下(假设我们有一个信号量sem) :
P(sem):如果sem的值大于0,则sem减1;如果sem的值为0,则挂起该线程。
V(sem):如果有其它进程因等待sem而挂起,则让它恢复执行;如果没有线程等待sem而被挂起,则sem加上1。
信号集的创建与打开
int semget(key_t key,int nsems,int flag);
对信号量的操作
int semop(int semid,struct sembuf semoparray[],size_t nops);
对信号量的控制
int semctl(int semid,int semnum int cmd,union semun arg);
附:经典的生产者-消费者问题(Producer-Costomer)是一个著名的同步问题。
线程
线程是计算机中独立运行的最小单位,运行时占用很少的系统资源。可以把线程看成是操作系统分配CPU时间的基本单元。一个进程可以拥有一个至多个线程。它线程在进程内部共享地址空间、打开的文件描述符等资源。同时线程也有其私有的数据信息,包括:线程号、寄存器(程序计数器和堆栈指针)、堆栈、信号掩码、优先级、线程私有存储空间。
为什么有了进程的概念后,还要再引入线程呢?使用多线程到底有哪些好处?什么的系统应该选用多线程?
使用多线程的理由之一是和进程相比,它是一种非常“节俭”的多任务操作方式。我们知道,在Linux系统下,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表来维护它的代码段、堆栈段和数据段,这是一种“昂贵”的多任务工作方式。而运行于一个进程中的多个线程,它们彼此之间使用相同的地址空间,共享大部分数据,启动一个线程所花费的空间远远小于启动一个进程所花费的空间,而且,线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计,总的说来,一个进程的开销大约是一个线程开销的30倍左右,当然,在具体的系统上,这个数据可能会有较大的区别。
使用多线程的理由之二是线程间方便的通信机制。对不同进程来说,它们具有独立的数据空间,要进行数据的传递只能通过通信的方式进行,这种方式不仅费时,而且很不方便。线程则不然,由于同一进程下的线程之间共享数据空间,所以一个线程的数据可以直接为其它线程所用,这不仅快捷,而且方便。当然,数据的共享也带来其他一些问题,有的变量不能同时被两个线程所修改,有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击,这些正是编写多线程程序时最需要注意的地方。
除了以上所说的优点外,不和进程比较,多线程程序作为一种多任务、并发的工作方式,当然有以下的优点:
1)提高应用程序响应。这对图形界面的程序尤其有意义,当一个操作耗时很长时,整个系统都会等待这个操作,此时程序不会响应键盘、鼠标、菜单的操作,而使用多线程技术,将耗时长的操作(time consuming)置于一个新的线程,可以避免这种尴尬的情况。
2)使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时,不同的线程运行于不同的CPU上。
3)改善程序结构。一个既长又复杂的进程可以考虑分为多个线程,成为几个独立或半独立的运行部分,这样的程序会利于理解和修改。
线程分类
线程按照其调度者可以分为用户级线程和核心级线程两种。
(1)用户级线程
用户级线程主要解决的是上下文切换的问题,它的调度算法和调度过程全部由用户自行选择决定,在运行时不需要特定的内核支持。在这里,操作系统往往会提供一个用户空间的线程库,该线程库提供了线程的创建、调度、撤销等功能,而内核仍然仅对进程进行管理。如果一个进程中的某一个线程调用了一个阻塞的系统调用,那么该进程包括该进程中的其他所有线程也同时被阻塞。这种用户级线程的主要缺点是在一个进程中的多个线程的调度中无法发挥多处理器的优势。
(2)核心级线程
这种线程允许不同进程中的线程按照同一相对优先调度方法进行调度,这样就可以发挥多处理器的并发优势。
现在大多数系统都采用用户级线程与核心级线程并存的方法。一个用户级线程可以对应一个或几个核心级线程,也就是“一对一”或“多对一”模型。这样既可满足多处理机系统的需要,也可以最大限度地减少调度开销。
线程创建的Linux实现
我们知道,Linux的线程实现是在核外进行的,核内提供的是创建进程的接口do_fork()。内核提供了两个系统调用clone()和fork(),最终都用不同的参数调用do_fork()核内API。当然,要想实现线程,没有核心对多进程(其实是轻量级进程)共享数据段的支持是不行的,因此,do_fork()提供了很多参数,包括CLONE_VM(共享内存空间)、CLONE_FS(共享文件系统信息)、 CLONE_FILES(共享文件描述符表)、CLONE_SIGHAND(共享信号句柄表)和CLONE_PID(共享进程ID,仅对核内进程,即0号进程有效)。当使用fork系统调用时,内核调用do_fork()不使用任何共享属性,进程拥有独立的运行环境,而使用 pthread_create()来创建线程时,则最终设置了所有这些属性来调用__clone(),而这些参数又全部传给核内的do_fork(),从而创建的“进程”拥有共享的运行环境,只有栈是独立的,由__clone()传入。
Linux线程在核内是以轻量级进程的形式存在的,拥有独立的进程表项,而所有的创建、同步、删除等操作都在核外pthread库中进行。pthread 库使用一个管理线程(__pthread_manager(),每个进程独立且唯一)来管理线程的创建和终止,为线程分配线程ID,发送线程相关的信号(比如Cancel),而主线程(pthread_create())的调用者则通过管道将请求信息传给管理线程。
多线程编程
1、线程的创建和退出
pthread_create 线程创建函数
1
|
int
pthread_create (pthread_t * thread_id,__const pthread_attr_t * __attr,
void
*(*__start_routine) (
void
*),
void
*__restrict __arg);
|
线程创建函数第一个参数为指向线程标识符的指针,第二个参数用来设置线程属性,第三个参数是线程运行函数的起始地址,最后一个参数是运行函数的参数。这里,我们的函数thread 不需要参数,所以最后一个参数设为空指针。第二个参数我们也设为空指针,这样将生成默认属性的线程。当创建线程成功时,函数返回0,若不为0 则说明创建线程失败,常见的错误返回代码为EAGAIN 和EINVAL。前者表示系统限制创建新的线程,例如线程数目过多了;后者表示第二个参数代表的线程属性值非法。创建线程成功后,新创建的线程则运行参数三和参数四确定的函数,原来的线程则继续运行下一行代码。
pthread_join 函数,来等待一个线程的结束。
函数原型为:int pthread_join (pthread_t __th, void **__thread_return)
第一个参数为被等待的线程标识符,第二个参数为一个用户定义的指针,它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数,调用它的函数将一直等待到被等待的线程结束为止,当函数返回时,被等待线程的资源被收回。线程只能被一个线程等待终止,并且应处于joinable状态(非detached)。
pthread_exit 函数
一个线程的结束有两种途径,一种是线程运行的函数结束了,调用它的线程也就结束了;
另一种方式是通过函数pthread_exit 来实现。它的函数原型为:void pthread_exit (void *__retval)唯一的参数是函数的返回代码,只要pthread_join 中的第二个参数thread_return 不是NULL,这个值将被传递给thread_return。最后要说明的是,一个线程不能被多个线程等待,否则第一个接收到信号的线程成功返回,其余调用pthread_join 的线程则返回错误代码ESRCH。
2、线程属性
pthread_create函数的第二个参数线程的属性。将该值设为NULL,也就是采用默认属性,线程的多项属性都是可以更改的。这些属性主要包括绑定属性、分离属性、堆栈地址、堆栈大小、优先级。其中系统默认的属性为非绑定、非分离、缺省1M 的堆栈、与父进程同样级别的优先级。下面首先对绑定属性和分离属性的基本概念进行讲解。
绑定属性:Linux中采用“一对一”的线程机制,也就是一个用户线程对应一个内核线程。绑定属性就是指一个用户线程固定地分配给一个内核线程,因为CPU时间片的调度是面向内核线程 (也就是轻量级进程)的,因此具有绑定属性的线程可以保证在需要的时候总有一个内核线程与之对应。而与之相对的非绑定属性就是指用户线程和内核线程的关系不是始终固定的,而是由系统来控制分配的。
分离属性:分离属性是用来决定一个线程以什么样的方式来终止自己。在非分离情况下,当一个线程结束时,它所占用的系统资源并没有被释放,也就是没有真正的终止。只有当pthread_join()函数返回时,创建的线程才能释放自己占用的系统资源。而在分离属性情况下,一个线程结束时立即释放它所占有的系统资源。
这里要注意的一点是,如果设置一个线程的分离属性,而这个线程运行又非常快,那么它很可能在pthread_create 函数返回之前就终止了,它终止以后就可能将线程号和系统资源移交给其他的线程使用,这时调用pthread_create 的线程就得到了错误的线程号。
设置绑定属性:
1
2
3
|
int
pthread_attr_init(pthread_attr_t *attr)
int
pthread_attr_setscope(pthread_attr_t *attr,
int
scope)
int
pthread_attr_getscope(pthread_attr_t *tattr,
int
*scope)
|
scope:PTHREAD_SCOPE_SYSTEM:绑定,此线程与系统中所有的线程竞争
PTHREAD_SCOPE_PROCESS:非绑定,此线程与进程中的其他线程竞争
设置分离属性:
1
2
|
int
pthread_attr_setdetachstate(pthread_attr_t *attr,
int
detachstate)
int
pthread_attr_getdetachstate(
const
pthread_attr_t *tattr,
int
*detachstate)
|
detachstate PTHREAD_CREATE_DETACHED:分离
PTHREAD _CREATE_JOINABLE:非分离
设置调度策略:
1
2
|
int
pthread_attr_setschedpolicy(pthread_attr_t * tattr,
int
policy)
int
pthread_attr_getschedpolicy(pthread_attr_t * tattr,
int
*policy)
|
policy SCHED_FIFO:先入先出
SCHED_RR:循环
SCHED_OTHER:实现定义的方法
设置优先级:
1
2
|
int
pthread_attr_setschedparam (pthread_attr_t *attr, struct sched_param *param)
int
pthread_attr_getschedparam (pthread_attr_t *attr, struct sched_param *param)
|
3、线程访问控制
1)互斥锁(mutex)
通过锁机制实现线程间的同步。同一时刻只允许一个线程执行一个关键部分的代码。
1
2
3
4
|
int
pthread_mutex_init(pthread_mutex_t *mutex,
const
pthread_mutex_attr_t *mutexattr);
int
pthread_mutex_lock(pthread_mutex_t *mutex);
int
pthread_mutex_unlock(pthread_mutex_t *mutex);
int
pthread_mutex_destroy(pthread_mutex_t *mutex);
|
(1)先初始化锁init()或静态赋值pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER
(2)加锁,lock,trylock,lock阻塞等待锁,trylock立即返回EBUSY
(3)解锁,unlock需满足是加锁状态,且由加锁线程解锁
(4)清除锁,destroy(此时锁必需unlock,否则返回EBUSY)
mutex 分为递归(recursive) 和非递归(non-recursive)两种,这是POSIX 的叫法,另外的名字是可重入(Reentrant) 与非可重入。这两种mutex 作为线程间(inter-thread) 的同步工具时没有区别,它们的惟一区别在于:同一个线程可以重复对recursive mutex 加锁,但是不能重复对non-recursive mutex 加锁。
首选非递归mutex,绝对不是为了性能,而是为了体现设计意图。non-recursive 和recursive 的性能差别其实不大,因为少用一个计数器,前者略快一点点而已。在同一个线程里多次对non-recursive mutex 加锁会立刻导致死锁,我认为这是它的优点,能帮助我们思考代码对锁的期求,并且及早(在编码阶段)发现问题。毫无疑问recursive mutex 使用起来要方便一些,因为不用考虑一个线程会自己把自己给锁死了,我猜这也是Java 和Windows 默认提供recursive mutex 的原因。(Java 语言自带的intrinsic lock 是可重入的,它的concurrent 库里提供ReentrantLock,Windows的CRITICAL_SECTION 也是可重入的。似乎它们都不提供轻量级的non-recursive mutex。)
2)条件变量(cond)
利用线程间共享的全局变量进行同步的一种机制。
1
2
3
4
5
6
|
int
pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);
int
pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);
int
pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex,
const
timespec *abstime);
int
pthread_cond_destroy(pthread_cond_t *cond);
int
pthread_cond_signal(pthread_cond_t *cond);
int
pthread_cond_broadcast(pthread_cond_t *cond);
//解除所有线程的阻塞
|
(1)初始化. init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER;属性置为NULL
(2)等待条件成立. pthread_cond_wait,pthread_cond_timedwait.
wait()释放锁,并阻塞等待条件变量为真
timedwait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)
(3)激活条件变量:pthread_cond_signal,pthread_cond_broadcast(激活所有等待线程)
(4)清除条件变量:destroy; 无线程等待,否则返回EBUSY
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
一定要在mutex的锁定区域内使用。
调用 pthread_cond_signal() 释放被条件阻塞的线程时,如果没有任何线程基于条件变量阻塞,则调用pthread_cond_signal()不起作用。而对于 Windows,当调用 SetEvent 触发 Auto-reset 的 Event 条件时,如果没有被条件阻塞的线程,那么此函数仍然起作用,条件变量会处于触发状态。
使用条件变量实现“生产者消费者问题”:
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include"pthread.h"
#define BUFFER_SIZE 16
struct
prodcons
{
int
buffer[BUFFER_SIZE];
pthread_mutex_t lock;
//mutex ensuring exclusive access to buffer
int
readpos,writepos;
//position for reading and writing
pthread_cond_t notempty;
//signal when buffer is not empty
pthread_cond_t notfull;
//signal when buffer is not full
};
//initialize a buffer
void
init(
struct
prodcons* b)
{
pthread_mutex_init(&b->lock,NULL);
pthread_cond_init(&b->notempty,NULL);
pthread_cond_init(&b->notfull,NULL);
b->readpos=0;
b->writepos=0;
}
//store an integer in the buffer
void
put(
struct
prodcons* b,
int
data)
{
pthread_mutex_lock(&b->lock);
//wait until buffer is not full
while
((b->writepos+1)%BUFFER_SIZE==b->readpos)
{
printf
(
"wait for not full\n"
);
pthread_cond_wait(&b->notfull,&b->lock);
}
b->buffer[b->writepos]=data;
b->writepos++;
pthread_cond_signal(&b->notempty);
//signal buffer is not empty
pthread_mutex_unlock(&b->lock);
}
//read and remove an integer from the buffer
int
get(
struct
prodcons* b)
{
int
data;
pthread_mutex_lock(&b->lock);
//wait until buffer is not empty
while
(b->writepos==b->readpos)
{
printf
(
"wait for not empty\n"
);
pthread_cond_wait(&b->notempty,&b->lock);
}
data=b->buffer[b->readpos];
b->readpos++;
if
(b->readpos>=BUFFER_SIZE) b->readpos=0;
pthread_cond_signal(&b->notfull);
//signal buffer is not full
pthread_mutex_unlock(&b->lock);
return
data;
}
#define OVER -1
struct
prodcons buffer;
void
* producer(
void
* data)
{
int
n;
for
(n=0;n<1000;++n)
{
printf
(
"put-->%d\n"
,n);
put(&buffer,n);
}
put(&buffer,OVER);
printf
(
"producer stopped\n"
);
return
NULL;
}
void
* consumer(
void
* data)
{
int
n;
while
(1)
{
int
d=get(&buffer);
if
(d==OVER)
break
;
printf
(
"%d-->get\n"
,d);
}
printf
(
"consumer stopped\n"
);
return
NULL;
}
int
main()
{
pthread_t tha,thb;
void
* retval;
init(&buffer);
pthread_creare(&tha,NULL,producer,0);
pthread_creare(&thb,NULL,consumer,0);
pthread_join(tha,&retval);
pthread_join(thb,&retval);
return
0;
}
|
PS:如果遇到如下问题:加个编译条件'-pthread'
1
2
|
prodcons.c:(.text+0x2ab): undefined reference to `pthread_create'
prodcons.c:(.text+0x2bd): undefined reference to `pthread_join'
|
3)信号量
如同进程一样,线程也可以通过信号量来实现通信,虽然是轻量级的。
信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。
#include <semaphore.h>
int sem_init(sem_t *sem , int pshared, unsigned int value);
这是对由sem指定的信号量进行初始化,设置好它的共享选项(linux只支持为0,即表示它是当前进程的局部信号量),然后给它一个初始值VALUE。
两个原子操作函数:
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);
这两个函数都要用一个由sem_init调用初始化的信号量对象的指针做参数。
sem_post:给信号量的值加1;
sem_wait:给信号量减1;对一个值为0的信号量调用sem_wait,这个函数将会等待直到有其它线程使它不再是0为止。
int sem_destroy(sem_t *sem);
这个函数的作用是再我们用完信号量后都它进行清理。归还自己占有的一切资源。
用信号量的方法实现生产者消费者
这里使用4个信号量,其中两个信号量occupied和empty分别用于解决生产者和消费者线程之间的同步问题,pmut和cmut是用于这两个线程之间的互斥问题。其中empty初始化为N(有界缓区的空间元数),occupied初始化为0,pmut和cmut初始化为1。
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
|
typedef
struct
{
char
buf[BSIZE];
sem_t occupied;
sem_t empty;
int
nextin;
int
nextout;
sem_t pmut;
sem_t cmut;
}buffer_t;
buffer_t buffer;
void
init(buffer_t buffer)
{
sem_init(&buffer.occupied, 0, 0);
sem_init(&buffer.empty,0, BSIZE);
sem_init(&buffer.pmut, 0, 1);
sem_init(&buffer.cmut, 0, 1);
buffer.nextin = buffer.nextout = 0;
}
void
producer(buffer_t *b,
char
item)
{
sem_wait(&b->empty);
sem_wait(&b->pmut);
b->buf[b->nextin] = item;
b->nextin++;
b->nextin %= BSIZE;
sem_post(&b->pmut);
sem_post(&b->occupied);
}
char
consumer(buffer_t *b)
{
char
item;
sem_wait(&b->occupied);
sem_wait(&b->cmut);
item = b->buf[b->nextout];
b->nextout++;
b->nextout %= BSIZE;
sem_post(&b->cmut);
sem_post(&b->empty);
return
(item);
}
|