一直对多线程编程这一块很陌生,决定花一点时间整理一下。
os:ubuntu 10.04 c++
1.最基础,进程同时创建5个线程,各自调用同一个函数
-
#include <iostream>
-
#include <pthread.h> //多线程相关操作头文件,可移植众多平台
-
-
using
namespace
std;
-
-
#define NUM_THREADS 5 //线程数
-
-
void* say_hello( void* args )
-
{
-
cout <<
"hello..." <<
endl;
-
}
//函数返回的是函数指针,便于后面作为参数
-
-
int main()
-
{
-
pthread_t tids[NUM_THREADS];
//线程id
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
{
-
int ret = pthread_create( &tids[i],
NULL, say_hello,
NULL );
//参数:创建的线程id,线程参数,线程运行函数的起始地址,运行函数的参数
-
if( ret !=
0 )
//创建线程成功返回0
-
{
-
cout <<
"pthread_create error:error_code=" << ret <<
endl;
-
}
-
}
-
pthread_exit(
NULL );
//等待各个线程退出后,进程才结束,否则进程强制结束,线程处于未终止的状态
-
}
输入命令:g++ -o muti_thread_test_1 muti_thread_test_1.cpp -lpthread
注意:
1)此为c++程序,故用g++来编译生成可执行文件,并且要调用处理多线程操作相关的静态链接库文件pthread。
2)-lpthread 编译选项到位置可任意,如g++ -lpthread -o muti_thread_test_1 muti_thread_test_1.cpp
3)注意gcc和g++的区别,转到此文:点击打开链接
测试结果:
-
wq@wq-
desktop:~
/coding/muti_thread$ ./muti_thread_test_1
-
hello...hello...
-
hello...
-
hello...
-
-
hello...
-
wq@wq-
desktop:~
/coding/muti_thread$ ./muti_thread_test_1
-
hello...hello...hello...
-
-
hello...
-
hello...
可知,两次运行的结果会有差别,这不是多线程的特点吧?这显然没有同步?还有待进一步探索...
多线程的运行是混乱的,混乱就是正常?
2.线程调用到函数在一个类中,那必须将该函数声明为静态函数函数
因为静态成员函数属于静态全局区,线程可以共享这个区域,故可以各自调用。
-
#include <iostream>
-
#include <pthread.h>
-
-
using
namespace
std;
-
-
#define NUM_THREADS 5
-
-
class Hello
-
{
-
public:
-
static void* say_hello( void* args )
-
{
-
cout <<
"hello..." <<
endl;
-
}
-
};
-
-
int main()
-
{
-
pthread_t tids[NUM_THREADS];
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
{
-
int ret = pthread_create( &tids[i],
NULL, Hello::say_hello,
NULL );
-
if( ret !=
0 )
-
{
-
cout <<
"pthread_create error:error_code" << ret <<
endl;
-
}
-
}
-
pthread_exit(
NULL );
-
}
测试结果:
-
wq@wq-
desktop:~
/coding/muti_thread$ ./muti_thread_test_2
-
hello...
-
hello...
-
hello...
-
hello...
-
hello...
-
wq@wq-
desktop:~
/coding/muti_thread$ ./muti_thread_test_2
-
hello...hello...hello...
-
-
-
hello...
-
hello...
3.如何在线程调用函数时传入参数呢?
先看下面修改的代码,传入线程编号作为参数:
-
#include <iostream>
-
#include <pthread.h> //多线程相关操作头文件,可移植众多平台
-
-
using
namespace
std;
-
-
#define NUM_THREADS 5 //线程数
-
-
void* say_hello( void* args )
-
{
-
int i = *( (
int*)args );
//对传入的参数进行强制类型转换,由无类型指针转变为整形指针,再用*读取其指向到内容
-
cout <<
"hello in " << i <<
endl;
-
}
//函数返回的是函数指针,便于后面作为参数
-
-
int main()
-
{
-
pthread_t tids[NUM_THREADS];
//线程id
-
cout <<
"hello in main.." <<
endl;
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
{
-
int ret = pthread_create( &tids[i],
NULL, say_hello, (
void*)&i );
//传入到参数必须强转为void*类型,即无类型指针,&i表示取i的地址,即指向i的指针
-
cout <<
"Current pthread id = " << tids[i] <<
endl;
//用tids数组打印创建的进程id信息
-
if( ret !=
0 )
//创建线程成功返回0
-
{
-
cout <<
"pthread_create error:error_code=" << ret <<
endl;
-
}
-
}
-
pthread_exit(
NULL );
//等待各个线程退出后,进程才结束,否则进程强制结束,线程处于未终止的状态
-
}
测试结果:
-
wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_3
-
hello
in main..
-
Current pthread
id =
3078458224
-
Current pthread
id =
3070065520
-
hello
in hello
in
2
-
1
-
Current pthread
id = hello
in
2
-
3061672816
-
Current pthread
id =
3053280112
-
hello
in
4
-
Current pthread
id = hello
in
4
-
3044887408
显然不是想要的结果,调用顺序很乱,这是为什么呢?
这是因为多线程到缘故,主进程还没开始对i赋值,线程已经开始跑了...?
修改代码如下:
-
#include <iostream>
-
#include <pthread.h> //多线程相关操作头文件,可移植众多平台
-
-
using
namespace
std;
-
-
#define NUM_THREADS 5 //线程数
-
-
void* say_hello( void* args )
-
{
-
cout <<
"hello in thread " << *( (
int *)args ) <<
endl;
-
}
//函数返回的是函数指针,便于后面作为参数
-
-
int main()
-
{
-
pthread_t tids[NUM_THREADS];
//线程id
-
int indexes[NUM_THREADS];
//用来保存i的值避免被修改
-
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
{
-
indexes[i] = i;
-
int ret = pthread_create( &tids[i],
NULL, say_hello, (
void*)&(indexes[i]) );
-
if( ret !=
0 )
//创建线程成功返回0
-
{
-
cout <<
"pthread_create error:error_code=" << ret <<
endl;
-
}
-
}
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
pthread_join( tids[i],
NULL );
//pthread_join用来等待一个线程的结束,是一个线程阻塞的函数
-
}
测试结果:
-
wq@wq-
desktop:~
/coding/muti_thread$ ./muti_thread_test_3
-
hello
in thread hello
in thread hello
in thread hello
in thread hello
in thread
30124
这是正常的吗?感觉还是有问题...待续
代码中如果没有pthread_join主线程会很快结束从而使整个进程结束,从而使创建的线程没有机会开始执行就结束了。加入pthread_join后,主线程会一直等待直到等待的线程结束自己才结束,使创建的线程有机会执行。
4.线程创建时属性参数的设置pthread_attr_t及join功能的使用
线程的属性由结构体pthread_attr_t进行管理。
typedef struct
{
int detachstate; 线程的分离状态
int schedpolicy; 线程调度策略
struct sched_param schedparam; 线程的调度参数
int inheritsched; 线程的继承性
int scope; 线程的作用域
size_t guardsize; 线程栈末尾的警戒缓冲区大小
int stackaddr_set; void * stackaddr; 线程栈的位置
size_t stacksize; 线程栈的大小
}pthread_attr_t;
-
#include <iostream>
-
#include <pthread.h>
-
-
using
namespace
std;
-
-
#define NUM_THREADS 5
-
-
void* say_hello( void* args )
-
{
-
cout <<
"hello in thread " << *((
int * )args) <<
endl;
-
int status =
10 + *((
int * )args);
//线程退出时添加退出的信息,status供主程序提取该线程的结束信息
-
pthread_exit( (
void* )status );
-
}
-
-
int main()
-
{
-
pthread_t tids[NUM_THREADS];
-
int indexes[NUM_THREADS];
-
-
pthread_attr_t attr;
//线程属性结构体,创建线程时加入的参数
-
pthread_attr_init( &attr );
//初始化
-
pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
//是设置你想要指定线程属性参数,这个参数表明这个线程是可以join连接的,join功能表示主程序可以等线程结束后再去做某事,实现了主程序和线程同步功能
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
{
-
indexes[i] = i;
-
int ret = pthread_create( &tids[i], &attr, say_hello, (
void* )&( indexes[i] ) );
-
if( ret !=
0 )
-
{
-
cout <<
"pthread_create error:error_code=" << ret <<
endl;
-
}
-
}
-
pthread_attr_destroy( &attr );
//释放内存
-
void *status;
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
{
-
int ret = pthread_join( tids[i], &status );
//主程序join每个线程后取得每个线程的退出信息status
-
if( ret !=
0 )
-
{
-
cout <<
"pthread_join error:error_code=" << ret <<
endl;
-
}
-
else
-
{
-
cout <<
"pthread_join get status:" << (
long)status <<
endl;
-
}
-
}
-
}
测试结果:
-
wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_4
-
hello
in thread hello
in thread hello
in thread hello
in thread
0hello
in thread
321
-
-
-
-
4
-
pthread_join
get status:
10
-
pthread_join
get status:
11
-
pthread_join
get status:
12
-
pthread_join
get status:
13
-
pthread_join
get status:
14
5.互斥锁的实现
互斥锁是实现线程同步的一种机制,只要在临界区前后对资源加锁就能阻塞其他进程的访问。
-
#include <iostream>
-
#include <pthread.h>
-
-
using
namespace
std;
-
-
#define NUM_THREADS 5
-
-
int sum =
0;
//定义全局变量,让所有线程同时写,这样就需要锁机制
-
pthread_mutex_t sum_mutex;
//互斥锁
-
-
void* say_hello( void* args )
-
{
-
cout <<
"hello in thread " << *((
int * )args) <<
endl;
-
pthread_mutex_lock( &sum_mutex );
//先加锁,再修改sum的值,锁被占用就阻塞,直到拿到锁再修改sum;
-
cout <<
"before sum is " << sum <<
" in thread " << *( (
int* )args ) <<
endl;
-
sum += *( (
int* )args );
-
cout <<
"after sum is " << sum <<
" in thread " << *( (
int* )args ) <<
endl;
-
pthread_mutex_unlock( &sum_mutex );
//释放锁,供其他线程使用
-
pthread_exit(
0 );
-
}
-
-
int main()
-
{
-
pthread_t tids[NUM_THREADS];
-
int indexes[NUM_THREADS];
-
-
pthread_attr_t attr;
//线程属性结构体,创建线程时加入的参数
-
pthread_attr_init( &attr );
//初始化
-
pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
//是设置你想要指定线程属性参数,这个参数表明这个线程是可以join连接的,join功能表示主程序可以等线程结束后再去做某事,实现了主程序和线程同步功能
-
pthread_mutex_init( &sum_mutex,
NULL );
//对锁进行初始化
-
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
{
-
indexes[i] = i;
-
int ret = pthread_create( &tids[i], &attr, say_hello, (
void* )&( indexes[i] ) );
//5个进程同时去修改sum
-
if( ret !=
0 )
-
{
-
cout <<
"pthread_create error:error_code=" << ret <<
endl;
-
}
-
}
-
pthread_attr_destroy( &attr );
//释放内存
-
void *status;
-
for(
int i =
0; i < NUM_THREADS; ++i )
-
{
-
int ret = pthread_join( tids[i], &status );
//主程序join每个线程后取得每个线程的退出信息status
-
if( ret !=
0 )
-
{
-
cout <<
"pthread_join error:error_code=" << ret <<
endl;
-
}
-
}
-
cout <<
"finally sum is " << sum <<
endl;
-
pthread_mutex_destroy( &sum_mutex );
//注销锁
-
}
测试结果:
-
wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_5
-
hello
in thread hello
in thread hello
in thread
410
-
before sum
is hello
in thread
0
in thread
4
-
after sum
is
4
in thread
4hello
in thread
-
-
-
2
-
3
-
before sum
is
4
in thread
1
-
after sum
is
5
in thread
1
-
before sum
is
5
in thread
0
-
after sum
is
5
in thread
0
-
before sum
is
5
in thread
2
-
after sum
is
7
in thread
2
-
before sum
is
7
in thread
3
-
after sum
is
10
in thread
3
-
finally sum
is
10
可知,sum的访问和修改顺序是正常的,这就达到了多线程的目的了,但是线程的运行顺序是混乱的,混乱就是正常?
6.信号量的实现
信号量是线程同步的另一种实现机制,信号量的操作有signal和wait,本例子采用条件信号变量pthread_cond_t tasks_cond;
信号量的实现也要给予锁机制。
-
#include <iostream>
-
#include <pthread.h>
-
#include <stdio.h>
-
-
using
namespace
std;
-
-
#define BOUNDARY 5
-
-
int tasks =
10;
-
pthread_mutex_t tasks_mutex;
//互斥锁
-
pthread_cond_t tasks_cond;
//条件信号变量,处理两个线程间的条件关系,当task>5,hello2处理,反之hello1处理,直到task减为0
-
-
void* say_hello2( void* args )
-
{
-
pthread_t pid = pthread_self();
//获取当前线程id
-
cout <<
"[" << pid <<
"] hello in thread " << *( (
int* )args ) <<
endl;
-
-
bool is_signaled =
false;
//sign
-
while(
1)
-
{
-
pthread_mutex_lock( &tasks_mutex );
//加锁
-
if( tasks > BOUNDARY )
-
{
-
cout <<
"[" << pid <<
"] take task: " << tasks <<
" in thread " << *( (
int*)args ) <<
endl;
-
--tasks;
//modify
-
}
-
else
if( !is_signaled )
-
{
-
cout <<
"[" << pid <<
"] pthread_cond_signal in thread " << *( (
int* )args ) <<
endl;
-
pthread_cond_signal( &tasks_cond );
//signal:向hello1发送信号,表明已经>5
-
is_signaled =
true;
//表明信号已发送,退出此线程
-
}
-
pthread_mutex_unlock( &tasks_mutex );
//解锁
-
if( tasks ==
0 )
-
break;
-
}
-
}
-
-
void* say_hello1( void* args )
-
{
-
pthread_t pid = pthread_self();
//获取当前线程id
-
cout <<
"[" << pid <<
"] hello in thread " << *( (
int* )args ) <<
endl;
-
-
while(
1)
-
{
-
pthread_mutex_lock( &tasks_mutex );
//加锁
-
if( tasks > BOUNDARY )
-
{
-
cout <<
"[" << pid <<
"] pthread_cond_signal in thread " << *( (
int* )args ) <<
endl;
-
pthread_cond_wait( &tasks_cond, &tasks_mutex );
//wait:等待信号量生效,接收到信号,向hello2发出信号,跳出wait,执行后续
-
}
-
else
-
{
-
cout <<
"[" << pid <<
"] take task: " << tasks <<
" in thread " << *( (
int*)args ) <<
endl;
-
--tasks;
-
}
-
pthread_mutex_unlock( &tasks_mutex );
//解锁
-
if( tasks ==
0 )
-
break;
-
}
-
}
-
-
-
int main()
-
{
-
pthread_attr_t attr;
//线程属性结构体,创建线程时加入的参数
-
pthread_attr_init( &attr );
//初始化
-
pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
//是设置你想要指定线程属性参数,这个参数表明这个线程是可以join连接的,join功能表示主程序可以等线程结束后再去做某事,实现了主程序和线程同步功能
-
pthread_cond_init( &tasks_cond,
NULL );
//初始化条件信号量
-
pthread_mutex_init( &tasks_mutex,
NULL );
//初始化互斥量
-
pthread_t tid1, tid2;
//保存两个线程id
-
int index1 =
1;
-
int ret = pthread_create( &tid1, &attr, say_hello1, (
void* )&index1 );
-
if( ret !=
0 )
-
{
-
cout <<
"pthread_create error:error_code=" << ret <<
endl;
-
}
-
int index2 =
2;
-
ret = pthread_create( &tid2, &attr, say_hello2, (
void* )&index2 );
-
if( ret !=
0 )
-
{
-
cout <<
"pthread_create error:error_code=" << ret <<
endl;
-
}
-
pthread_join( tid1,
NULL );
//连接两个线程
-
pthread_join( tid2,
NULL );
-
-
pthread_attr_destroy( &attr );
//释放内存
-
pthread_mutex_destroy( &tasks_mutex );
//注销锁
-
pthread_cond_destroy( &tasks_cond );
//正常退出
-
}
测试结果:
先在线程2中执行say_hello2,再跳转到线程1中执行say_hello1,直到tasks减到0为止。
-
wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_6
-
[
3069823856] hello
in thread
2
-
[
3078216560] hello
in thread
1[
3069823856] take task:
10
in thread
2
-
-
[
3069823856] take task:
9
in thread
2
-
[
3069823856] take task:
8
in thread
2
-
[
3069823856] take task:
7
in thread
2
-
[
3069823856] take task:
6
in thread
2
-
[
3069823856] pthread_cond_signal
in thread
2
-
[
3078216560] take task:
5
in thread
1
-
[
3078216560] take task:
4
in thread
1
-
[
3078216560] take task:
3
in thread
1
-
[
3078216560] take task:
2
in thread
1
-
[
3078216560] take task:
1
in thread
1
到此,对多线程编程有了一个初步的了解,当然还有其他实现线程同步的机制,有待进一步探索。