投稿
  1. 首页
  2. 软件运维

C++在linux下怎么多线程

美国b2b网站 • 2023-5-24 • 软件运维 • 阅读 22

C++在linux下怎么多线程,第1张

#ifndef THREAD_H_  

#define THREAD_H_  

#include <unistd.h>  

#include <pthread.h>  

class Runnable  

{  

public:  

//运行实体  

virtual void run() = 0  

}  

//线程类  

class Thread: public Runnable  

{  

private:  

//线程初始化号  

static int thread_init_number  

//当前线程初始化序号  

int current_thread_init_number  

//线程体  

Runnable *target  

//当前线程的线程ID  

pthread_t tid  

//线程的状态  

int thread_status  

//线程属性  

pthread_attr_t attr  

//线咐唯弯程优先级  

sched_param param  

//获取执行方法的指针  

static void* run0(void* pVoid)  

//内部执行方法  

void* run1()  

//获取线程序号  

static int get_next_thread_num()  

public:  

//线程的状态－新建  

static const int THREAD_STATUS_NEW = 0  

//线程的状态－正在运行  

static const int THREAD_STATUS_RUNNING = 1  

//线程的状态－运行结束  

static const int THREAD_STATUS_EXIT = -1  

//构造函数  

Thread()  

//构造函数  

Thread(Runnable *target)  

//析构  

~Thread()  

//线程的运行体  

void run()  

//开始执行线程  

bool start()  

//获取线程状态  

int get_state()  

//等待线程直至退出  

void join()  

//等待线程退出或者超时  

void join(unsigned long millis_time)  

//比较两个线程时候相同，通过current_thread_init_number判断  

bool operator ==(const Thread* other_pthread)  

//获取this线程ID  

pthread_t get_thread_id()  

//获取当前线程ID  

static pthread_t get_current_thread_id()  

//当前线程是否和某个线程相等，通过tid判断  

static bool is_equals(Thread* iTarget)  

//设置线程的类型:绑定/非绑山型定  

void set_thread_scope(bool isSystem)  

//获取线程的类型:绑定/非绑定  

bool get_thread_scope()  

//设置线程的优先级，1－99，其中99为实时，意外的为普通  

void set_thread_priority(int priority)  

//获取线程的优先级  

int get_thread_priority()  

}  

int Thread::thread_init_number = 1  

inline int Thread::get_next_thread_num()  

{  

return thread_init_number++  

}  

void* Thread::run0(void* pVoid)  

{  

Thread* p = (Thread*) pVoid  

p->run1()  

return p  

}  

void* Thread::run1()  

{  

thread_status = THREAD_STATUS_RUNNING  

tid = pthread_self()  

run()  

thread_status = THREAD_STATUS_EXIT  

tid = 0  

pthread_exit(NULL)  

}  

void Thread::run()  

{  

if (target != NULL)  

{  

  (*target).run()  

}  

}  衡闷

Thread::Thread()  

{  

tid = 0  

thread_status = THREAD_STATUS_NEW  

current_thread_init_number = get_next_thread_num()  

pthread_attr_init(&attr)  

}  

Thread::Thread(Runnable *iTarget)  

{  

target = iTarget  

tid = 0  

thread_status = THREAD_STATUS_NEW  

current_thread_init_number = get_next_thread_num()  

pthread_attr_init(&attr)  

}  

Thread::~Thread()  

{  

pthread_attr_destroy(&attr)  

}  

bool Thread::start()  

{  

return pthread_create(&tid, &attr, run0, this)  

}  

inline pthread_t Thread::get_current_thread_id()  

{  

return pthread_self()  

}  

inline pthread_t Thread::get_thread_id()  

{  

return tid  

}  

inline int Thread::get_state()  

{  

return thread_status  

}  

void Thread::join()  

{  

if (tid > 0)  

{  

  pthread_join(tid,NULL)  

}  

}  

void Thread::join(unsigned long millis_time)  

{  

if (tid == 0)  

{  

  return  

}  

if (millis_time == 0)  

{  

  join()  

}  

else  

{  

  unsigned long k = 0  

  while (thread_status != THREAD_STATUS_EXIT && k <= millis_time)  

  {  

   usleep(100)  

   k++  

  }  

}  

}  

bool Thread::operator ==(const Thread* other_pthread)  

{  

if(other_pthread==NULL)  

{  

  return false  

}if(current_thread_init_number==(*other_pthread).current_thread_init_number)  

{  

  return true  

}  

return false  

}  

bool Thread::is_equals(Thread* iTarget)  

{  

if (iTarget == NULL)  

{  

  return false  

}  

return pthread_self() == iTarget->tid  

}  

void Thread::set_thread_scope(bool isSystem)  

{  

if (isSystem)  

{  

  pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)  

}  

else  

{  

  pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS)  

}  

}  

void Thread::set_thread_priority(int priority)  

{  

pthread_attr_getschedparam(&attr,&param)  

param.__sched_priority = priority  

pthread_attr_setschedparam(&attr,&param)  

}  

int Thread::get_thread_priority(){  

pthread_attr_getschedparam(&attr,&param)  

return param.__sched_priority  

}  

#endif /* THREAD_H_ */

参考http://technet.microsoft.com/en-us//library/2kwb957d(v=vs.110).aspx

1.critical：每次允许一个线程执行

2.single：只由一个线程执行一次

3.automic：功能类似critical，不过所属指令为简单的表达式，这样减少开销

4.master：仅由主线程执行

5.omp_set_num_threads：设置线程数，用在程序中

6.omp_get_num_threads：获取线程者唯总数

7.omp_get_thread_num：获取当前线程序号id

8.OMP_NUM_THREADS：环境变量级别的线程总数限定告嫌侍，优先级最低，袜吵omp_set_num_threads是程序级别的，优先级较高；子句num_threads（i）是block级别，优先级最高

最近也在学

＃i nclude<stdio.h>

＃i nclude<iostream.h>

＃i nclude<windows.h>

#define BufferSize 15

char Buffer[BufferSize]

int head,tail=0//Buffer数组下标

int count//被使用的缓冲区数量

HANDLE hMutex

HANDLE hNotFullEvent, hNotEmptyEvent//用来同步生产者和消费者线程

////////缓冲区存储情况

display(char a[15])

{

int i

cout<<"缓冲区存储情况为:"<<endl

for (i=14i>=0i--){

cout<<"\t|----"<<a<<"----|"<<endl

}

}

//p1

void p1_Producer()

{

int i

char ch

char p1[]={'a','A','b','B','c','C','D','d','E','e'}

if(tail<15){

for(i=0i<10i++){

while(1) {

WaitForSingleObject(hMutex,INFINITE)

if(count==BufferSize){ //缓冲区满

ReleaseMutex(hMutex)

//等待直到缓冲区非满

WaitForSingleObject(hNotFullEvent,INFINITE)

continue

}

//得到互斥锁且缓冲区非满,跳出while循环

break

}

if (tail>14){

cout<<"缓冲区已满，不能再存入数据！"<<endl

ReleaseMutex(hMutex)//结束临界区

PulseEvent(hNotEmptyEvent)//唤醒消费者线程

}

else{

//得到互斥锁且缓冲区非满,开始产生新数据

cout<<"Producer p1:\t"<<p1<<endl

Buffer[tail]=p1

//tail=(tail+1)%BufferSize///存放于缓冲区的位置

display(Buffer)

tail++

count++

cout<<"按ENTER继续...."<<endl

ch=getchar()

ReleaseMutex(hMutex)//结束临界区

PulseEvent(hNotEmptyEvent)//唤醒消费者线程

}

}

}

}

//////////////////////////////////////////////态轮/////////举搭///////////

//p2

void p2_Producer()

{

int i

char ch

char p2[]={'0','1','2','3','4','5','6','7','8','9'}

if(tail<15){

for(i=0i<10i++){

while(1) {

ch=getchar()

WaitForSingleObject(hMutex,INFINITE)

if(count==BufferSize){ // 缓冲区满

ReleaseMutex(hMutex)

// 等待直到缓冲区非满

WaitForSingleObject(hNotFullEvent,INFINITE)

continue

}

// 得到互斥锁且缓冲区非满,跳出while循环

break

}

if (tail>14){

cout<<"缓冲区已满，不能再存入数正闭拿据！程序结束！"<<endl

ReleaseMutex(hMutex)//结束临界区

PulseEvent(hNotEmptyEvent)//唤醒消费者线程

}

else{

// 得到互斥锁且缓冲区非满,开始产生新数据

cout<<"Producer p2:\t"<<p2<<endl

Buffer[tail]=p2

//tail=(tail+1)%BufferSize

display(Buffer)

tail++

count++

cout<<"按ENTER继续...."<<endl

ch=getchar()

ReleaseMutex(hMutex)// 结束临界区

PulseEvent(hNotEmptyEvent)// 唤醒消费者线程

}

}

}

}

//////////////////////////////////////////////////////////////////

//p3

void p3_Producer()

{

int i

char ch

char p3[]={'!','#','$','%','&','*','+','-','.','/'}

if(tail<15){

for(i=0i<10i++){

while(1) {

ch=getchar()

WaitForSingleObject(hMutex,INFINITE)

if(count==BufferSize){ // 缓冲区满

ReleaseMutex(hMutex)

// 等待直到缓冲区非满

WaitForSingleObject(hNotFullEvent,INFINITE)

continue

}

// 得到互斥锁且缓冲区非满,跳出while循环

break

}

if (tail>14){

cout<<"缓冲区已满，不能再存入数据！程序结束！"<<endl

ReleaseMutex(hMutex)//结束临界区

PulseEvent(hNotEmptyEvent)//唤醒消费者线程

}

else{

// 得到互斥锁且缓冲区非满,开始产生新数据

cout<<"Producer p3:\t"<<p3<<endl

Buffer[tail]=p3

//tail=(tail+1)%BufferSize

display(Buffer)

tail++

count++

cout<<"按ENTER继续...."<<endl

ch=getchar()

ReleaseMutex(hMutex)// 结束临界区

PulseEvent(hNotEmptyEvent)// 唤醒消费者线程

}

}

}

}

//////////////////////////////////////////////////////////////////

//c1

void c1_Consumer()

{

int i,j,k

char result,ch

while(1){

ch=getchar()

WaitForSingleObject(hMutex,INFINITE)

if(count==0){ // 没有可以处理的数据

ReleaseMutex(hMutex)// 释放互斥锁且等待

// 等待直到缓冲区非空

WaitForSingleObject(hNotEmptyEvent,INFINITE)

}

else {if(Buffer[head]==0) {

cout<<"Consumer 0: 缓冲区的数据已全消费过一次，消费完毕！"<<endl

ReleaseMutex(hMutex)// 结束临界区

ExitThread(0)

}

else { // 获得互斥锁且缓冲区有数据,开始处理

result=Buffer[head]

if(result>64&&result<70){

result=result+32

cout<<"Consumer c1:(大写－>小写)\t "<<result<<endl

Buffer[head]='^'// '^'表示数据已被消费

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)

}

if(result>96&&result<102){

result=result-32

cout<<"Consumer c1:(小写－>大写)\t "<<result<<endl

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)

}

if(result>47&&result<58){

cout<<"Consumer c1:(显示字符)\t "<<result<<endl

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)}

if(result>32&&result<48){

cout<<"Consumer c1:(用符号打印出菱形) "<<endl

for(i=1i<=(9+1)/2i++)

{

for(j=1j<=40-ij++)

cout<<" "

for(k=1k<=2*i-1k++)

cout<<result

cout<<endl

}

for(i=1i<=9/2i++)

{

for(j=1j<=40-(9+1)/2+ij++)

cout<<" "

for(k=1k<=9-2*ik++)

cout<<result

cout<<endl

}

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)

}

head=(head+1)%BufferSize

count--

cout<<"按ENTER继续...."<<endl

ch=getchar()

ReleaseMutex(hMutex)// 结束临界区

PulseEvent(hNotFullEvent)// 唤醒生产者线程

}

}

}

}

//////////////////////////////////////////////////////////////////

//c2

void c2_Consumer()

{

int i,j,k

char result,ch

while(1){

WaitForSingleObject(hMutex,INFINITE)

if(count==0){ // 没有可以处理的数据

ReleaseMutex(hMutex)// 释放互斥锁且等待

// 等待直到缓冲区非空

WaitForSingleObject(hNotEmptyEvent,INFINITE)

}

else {if(Buffer[head]==0) {

cout<<"Consumer 0:缓冲区的数据已全消费过一次，消费完毕！"<<endl

ReleaseMutex(hMutex)// 结束临界区

ExitThread(0)

}

else { // 获得互斥锁且缓冲区有数据,开始处理

result=Buffer[head]

if(result>64&&result<90){

result=result+32

cout<<"Consumer c2:(大写－>小写)\t "<<result<<endl

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)

}

if(result>96&&result<102){

result=result-32

cout<<"Consumer c2:(小写－>大写)\t "<<result<<endl

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)}

if(result>47&&result<58){

cout<<"Consumed c2:(显示字符)\t "<<result<<endl

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)}

if(result>32&&result<48){

cout<<"Consumer c2:(用符号打印出菱形) "<<endl

for(i=1i<=(9+1)/2i++)

{

for(j=1j<=40-ij++)

cout<<" "

for(k=1k<=2*i-1k++)

cout<<result

cout<<endl

}

for(i=1i<=9/2i++)

{

for(j=1j<=40-(9+1)/2+ij++)

cout<<" "

for(k=1k<=9-2*ik++)

cout<<result

cout<<endl

}

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)

}

head=(head+1)%BufferSize

count--

cout<<"按ENTER继续...."<<endl

ch=getchar()

ReleaseMutex(hMutex)// 结束临界区

PulseEvent(hNotFullEvent)// 唤醒生产者线程

}

}

}

}

//////////////////////////////////////////////////////////////////

//c3

void c3_Consumer()

{

int i,j,k

char result,ch

while(1){

WaitForSingleObject(hMutex,INFINITE)

if(count==0){ // 没有可以处理的数据

ReleaseMutex(hMutex)// 释放互斥锁且等待

// 等待直到缓冲区非空

WaitForSingleObject(hNotEmptyEvent,INFINITE)

}

else {if(Buffer[head]==0) {

cout<<"Consumer 0: 缓冲区的数据已全消费过一次，消费完毕！"<<endl

ReleaseMutex(hMutex)// 结束临界区

ExitThread(0)

}

else { // 获得互斥锁且缓冲区有数据,开始处理

result=Buffer[head]

if(result>64&&result<70){

result=result+32

cout<<"Consumer c3:(大写－>小写)\t "<<result<<endl

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)}

if(result>96&&result<102){

result=result-32

cout<<"Consumer c3:(小写－>大写)\t "<<result<<endl

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)}

if(result>47&&result<58){

cout<<"Consumer c1:(显示字符)\t "<<result<<endl

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)

}

if(result>32&&result<48){

cout<<"Consumer c3:(用符号打印出菱形) "<<endl

for(i=1i<=(7+1)/2i++)

{

for(j=1j<=40-ij++)

cout<<" "

for(k=1k<=2*i-1k++)

cout<<result

cout<<endl

}

for(i=1i<=7/2i++)

{

for(j=1j<=40-(7+1)/2+ij++)

cout<<" "

for(k=1k<=7-2*ik++)

cout<<result

cout<<endl

}

Buffer[head]='^'

cout<<"'^'表示数据已被消费"<<endl

display(Buffer)

}

head=(head+1)%BufferSize

count--

cout<<"按ENTER继续...."<<endl

ch=getchar()

ReleaseMutex(hMutex)// 结束临界区

PulseEvent(hNotFullEvent)// 唤醒生产者线程

}

}

}

}

//////////////////////////////////////////////////////////////////

//主函数

void main()

{

HANDLE hThreadVector[6]

DWORD ThreadID

count = 0

head = 0

tail = 0

hMutex=CreateMutex(NULL,FALSE,NULL)

hNotFullEvent=CreateEvent(NULL,TRUE,FALSE,NULL)

hNotEmptyEvent=CreateEvent(NULL,TRUE,FALSE,NULL)

hThreadVector[0]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) p1_Producer,NULL, 0, (LPDWORD)&ThreadID)

hThreadVector[1]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) c1_Consumer,NULL, 0, (LPDWORD)&ThreadID)

hThreadVector[3]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) p2_Producer,NULL, 0, (LPDWORD)&ThreadID)

hThreadVector[4]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) c2_Consumer,NULL, 0, (LPDWORD)&ThreadID)

hThreadVector[5]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) p3_Producer,NULL, 0, (LPDWORD)&ThreadID)

hThreadVector[5]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) c3_Consumer,NULL, 0, (LPDWORD)&ThreadID)

WaitForMultipleObjects(2,hThreadVector,TRUE,INFINITE)

//cout<<"**********************Finish*************************"<<endl

}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/yw/12333713.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
美国b2b网站 美国b2b网站 一级用户组
0 0
上一篇 2023-05-24
下一篇 2023-05-24

发表评论

登录后才能评论

评论列表（0条）

保存