线程处理 c++ linux OS

Posted 2023-02-22

【中文标题】线程处理 c++ linux OS

【英文标题】：thread handling c++ linux OS

【发布时间】：2014-06-26 08:08:33

【问题描述】：

我的项目中有三个用 c++ 编写的函数。它们在同一个 .cpp 文件中，我有两个头文件。

现在，我有三个相应的线程，因此，第二个线程从第一个线程获取输出，最后一个线程等待直到第二个线程结束其操作。请注意，线程处于“永远循环”中，即while(1)....

source.cpp 看起来像这样：

#include <iostream>
#include "source.h"
#include "glob_variables.h"
#include "armadillo"
#include <vector>
using namespace arma;
using namespace std;

void source::first_function(int size)

  for(int i=0;i<size;i++)
  
   container.push_back(i);//container is global variable vector of type int declared in glob_variables.h
  

//~~~~~~~~~~~~~~~~~~~~~~
void source::second_function()

   //sleep until the first function fills the the vector to set set its size to matrix.n_rows 
  matrix.set_size(container.size(),33);
   for(int i=0;i<container.size();i++)
   
    for(int j=0;j<50;j++)
     
       matrix(i,j)=i+j;//matrix is also a global variable in glob_variables.h
     
   

//~~~~~~~~~~~~~~~~~~~~~~
void source::third_function()

//sleep untill the second function fills the matrix, then print
cout<<matrix;//print out the matrix

source.h:

#include "glob_variables.h"
#include "armadillo"
#include <vector>
using namespace arma;
using namespace std;
class source

public:
 void first_function(int size);
 void second_function();
 void third_function();
;

glob_variables.h：

#include "armadillo"
#include <vector>
using namespace arma;
using namespace std;

extern mat matrix;
extern vector<int> container;

Main.cpp：

    #include <iostream>
    #include <stdio.h>
    #include <pthread.h>
    #include "source.h"
    #include "glob_variables.h"
    #include "armadillo"
    #include <vector>
    using namespace arma;
    using namespace std;

//thread functions
     void* first_reader(void* id1)
     
       source mysource;
       while(1)
       
         mysource.first_function(80);
       
     

     void* second_reader(void* id2)
     
       source mysource;
       while(1)
       
         mysource.second_function();
       
     

     void* third_reader(void* id3)
     
       source mysource;
       while(1)
       
        mysource.third_function();
       
     

   int main()
   
    pthread_t first;
    pthread_t second;
    pthread_t third;

    int hndl_first;
    int hndl_second;
    int hndl_third;

    hndl_first = pthread_create(&first, NULL, first_reader, NULL);
    hndl_second= pthread_create(&second, NULL, second_thread, NULL);
    hndl_third;= pthread_create(&third, NULL,third_thread, NULL);

   pthread_exit(NULL);
   return 0; 
   

我可以有任何技术来做到这一点，或者任何简单的例子。谢谢。

【问题讨论】：

您为什么使用 pthreads 而不是 boost？

【参考方案1】：

尝试使用以下链接。 AutoResetEvent 满足您的要求。链接中的代码正是您所期望的。

What is the C++ equivalent for AutoResetEvent under Linux?

【参考方案2】：

我认为您想按顺序播放线程。 在第一个线程中做某事 -> 在第二个线程中做某事 -> 在第三个线程中做某事。

对吗？ 在这种情况下，您可以使用信号。

示例：

pthread_cond_t cond;
pthread_mutex_t mtx;

typedef enum 
    ready1,
    ready2,
    ready3
 thread_ready;

thread_ready t_ready;

void* first_reader(void* id1)

    //source mysource;
    while(1)
    
        pthread_mutex_lock(&mtx);
        while(t_ready != ready1)
            pthread_cond_wait(&cond, &mtx);
        pthread_mutex_unlock(&mtx);

        std::cout << "first" << std::endl;
        //mysource.first_function(80);

        pthread_mutex_lock(&mtx);
        t_ready = ready2;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mtx);

        sleep(1);

    



void* second_reader(void* id2)

    //source mysource;
    while(1)
    
        pthread_mutex_lock(&mtx);
        while(t_ready != ready2)
            pthread_cond_wait(&cond, &mtx);
        pthread_mutex_unlock(&mtx);

        std::cout << "second" << std::endl;
        //mysource.second_function();

        pthread_mutex_lock(&mtx);
        t_ready = ready3;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mtx);

        sleep(1);
    


void* third_reader(void* id3)

    //source mysource;
    while(1)
    
        pthread_mutex_lock(&mtx);
        while(t_ready != ready3)
            pthread_cond_wait(&cond, &mtx);
        pthread_mutex_unlock(&mtx);

        std::cout << "third" << std::endl;
        //mysource.third_function();

        pthread_mutex_lock(&mtx);
        t_ready = ready1;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mtx);

        sleep(1);
    



int main()

    pthread_t first;
    pthread_t second;
    pthread_t third;

    int hndl_first;
    int hndl_second;
    int hndl_third;

    pthread_cond_init(&cond,NULL);
    pthread_mutex_init(&mtx,NULL);

    t_ready = ready1;

    hndl_first = pthread_create(&first, NULL, first_reader, NULL);
    hndl_second = pthread_create(&second, NULL, second_reader, NULL);
    hndl_third = pthread_create(&third, NULL,third_reader, NULL);

    pthread_join(first, NULL);
    pthread_join(second, NULL);
    pthread_join(third, NULL);

    return 0;

其实这个case不需要做3个线程。如果你想喜欢我的代码，你最好只做 1 个线程。