Question

我必须创建一个程序，使用线程来使用OpenCV精心制作10个图像。为此，我认为在3个线程中打破工作，并使用4个队列来包含初始10个图像，并在精心制作期间使用中间图像。

这是我必须做的图表：

Diagram of threads and data floyd

现在，我认为为此，我可以使用std :: queue来管理队列，因此将每个线程传递给队列对象。问题是：

1）我必须用push，pop方法创建一个类“队列”线程安全，对吧？使用互斥变量来重新规划多线程和同步...

2）Evey线程在2队列上工作：POP从一个和PUSH到另一个。所以每个线程都是消费者/生产者......我如何在输入和输出中将每个线程传递给队列类的两个对象指针？（有两个对象，所以两个指针）？

使用我的代码，第二个线程看到输入队列始终为EMPTY。有人可以帮帮我吗？让我对这个问题有所了解吗？

这是我的代码，不能与两个线程一起工作（第二个线程看到输入队列总是空的：

 #include <opencv\cv.h>
 #include <opencv\highgui.h>
 #include <stdio.h>
 #include <windows.h>
 #include <process.h>
 #include <ctime>
 #include <queue>

 using namespace std;
 using namespace cv;


/* thread safe queue*/

template<typename T>
class coda_concorr
{
private:
    std::queue<T> la_coda;
    HANDLE mutex;
    public:
    bool complete;
    coda_concorr()
    {
        mutex = CreateMutex(NULL,FALSE,NULL);
        complete = false;
    }
    void push(T& data)
    {
        WaitForSingleObject(mutex,INFINITE);
        la_coda.push(data);
        ReleaseMutex(mutex);
    }
    bool vuota() const
    {
        bool RetCode;
        WaitForSingleObject(mutex,INFINITE);
        RetCode= la_coda.empty();
        ReleaseMutex(mutex);
        return RetCode;
    }

    bool try_pop(T& popped)
    {
        WaitForSingleObject(mutex,INFINITE);
        if (la_coda.empty())
        {
            ReleaseMutex(mutex);
            return false;
        }
        popped = la_coda.front();
        la_coda.pop();
        ReleaseMutex(mutex);
        return true;
    }
};

//packet passing to threads
struct Args
{
    coda_concorr<cv::Mat> in;
    coda_concorr<cv::Mat> out;
};

//grey decrease funct
void grey (void *param){
    Mat temp1,temp2;
    Args* arg = (Args*)param;
    if(!arg->in.vuota()){
    while(arg->in.try_pop(temp1)){
    cvtColor(temp1,temp2,CV_BGR2GRAY);
    arg->out.push(temp2);
        }
    arg->out.complete=true;
    }
    else{
        Sleep(100);
    }
    _endthread();
}
//threshold funct
void soglia(void *param){
    Mat temp1a,temp2a;
    Args* arg = (Args*)param;
    if(arg->in.vuota()){
    while(arg->in.vuota()){
            cout<<endl<<"Coda vuota"<<endl;
            Sleep(100);
        }
    }
    else{
        while(arg->in.try_pop(temp1a)){
        threshold(temp1a,temp2a,128,255,THRESH_BINARY);
        arg->out.push(temp2a);
            }
     }
     arg->out.complete=true;
    _endthread();
}
int main()
{
    coda_concorr<cv::Mat> ingresso;
    coda_concorr<cv::Mat> coda1;
    coda_concorr<cv::Mat> coda2;
    coda_concorr<cv::Mat> uscita;


    //in array
    Mat inn[10];
    Mat out;

    //assing images
    inn[0]=imread("C:/OPENCV/Test/imgtest/bird1.jpg",1);
    inn[1]=imread("C:/OPENCV/Test/imgtest/bird2.jpg",1);
    inn[2]=imread("C:/OPENCV/Test/imgtest/bird3.jpg",1);
    inn[3]=imread("C:/OPENCV/Test/imgtest/pig1.jpg",1);
    inn[4]=imread("C:/OPENCV/Test/imgtest/pig2.jpg",1);
    inn[5]=imread("C:/OPENCV/Test/imgtest/pig3.jpg",1);
    inn[6]=imread("C:/OPENCV/Test/imgtest/spider1.jpg",1);
    inn[7]=imread("C:/OPENCV/Test/imgtest/spider2.jpg",1);
    inn[8]=imread("C:/OPENCV/Test/imgtest/spider3.jpg",1);
    inn[9]=imread("C:/OPENCV/Test/imgtest/Nutella.jpg",1);



    Args dati,dati2;
    //populating queue 
    for(int i=0;i<=9;i++){
        dati.in.push(inn[i]);
    }
//assing second queue   
dati.out=coda1;

    HANDLE handle1,handle2;

    handle1 = (HANDLE) _beginthread(grey,0,&dati);

    //share part that don't WORK
    dati2.in=coda1;
    dati2.out=coda2;

    handle2 = (HANDLE) _beginthread(soglia,0,&dati2);



    WaitForSingleObject(handle2,INFINITE);
    WaitForSingleObject(handle1,INFINITE);



    //output
    while (dati2.out.try_pop(out)){
        imshow("immagine",out);
        waitKey(100);
    }

    system("PAUSE");
    return 0;

}

提前感谢您的时间。

Answer 1

对于第1点/，您确实需要一些同步对象，或者使用消息传递库，如评论中所示。

对于第2点/，您的多线程库可以为您提供将参数传递给线程函数的功能。

声明一个包含两个队列引用的小类，一个 in 队列，一个 out 队列。
在你的主程序中，为你的每个线程实例化你需要的所有队列和一个小类的实例，为每个线程传递 in 和 out 队列
启动线程，将小类的实例作为回调函数参数传递。您现在可以从每个线程访问 in 和 out 队列。

编辑（因为您编辑了问题）

bool vuota() const
{
    WaitForSingleObject(mutex,INFINITE);
    return la_coda.empty();
    ReleaseMutex(mutex);
}

错了。

bool vuota() const
{
    WaitForSingleObject(mutex,INFINITE);
    bool tmp = la_coda.empty();
    ReleaseMutex(mutex);
    return tmp;
}

在bool try_pop(T& popped)中也是如此。在离开函数之前，请检查是否释放了互斥锁。

Answer 2

如果线程2等待线程1工作，并且线程3等待线程2，则没有必要使用线程。运行所有三个函数的一个线程是最好的方法。

现在，假设当线程2处理第一个图像时，T1可以处理第二个图像。但...

在这种情况下

线程2＆amp; 3必须等待第一张图片
如果任何线程比其他线程更快，它将停止等待工作。

这里正确的方法是只使用两个队列（In / Out），并有多个线程来分析不同的图像。因此，T1，T2，... Tn将从IN获取图像，完全处理它，然后将结果存储在OUT中。

甚至可以摆脱结果队列，并将它们直接发送到某个地方（文件，显示器等）。只需确保同步目标对象。

Multithreads multiqueue..how可以管理吗？

2 个答案: