线程同步:Back &两个文本文件的四读

问题描述

我正在编写一个创建两个线程的程序.每个线程负责读取一个文本文件，每行一个字符.

I'm writing a program that creates two threads. Each thread is responsible for reading through one text file, with one char on each line.

第一个格式如下:

h
0
h
0
...

第二个格式如下:

0
i
0
i
0
i

有时可以有多个字母一个接一个，或者多个零一个接一个.但是，可以肯定的是，如果一个文件的一行有一个字母，那么第二个文件的对应行就会有一个0，反之亦然.

Sometimes there can be multiple letters after each other, or multiple zeros after each other. However, the one certainty is that if there is a letter on one line of one file, the corresponding line of the second file will have a 0, and vice versa.

线程应该继续读取文件输入到全局字符数组中，直到它们达到零.此时，它们允许另一个线程接管.并且它们不断来回，直到两个文件都被完全读取.

The threads are supposed to keep reading the file input into a global char array until they reach a zero. At this point, they allow the other thread to take over. And they keep going back and forth until both files are completely read.

此时，当我跑步时，我会得到以下变化:(1) 多个 h 后跟多个 i 或 (2)(正确答案)连续的 hihihi 流，或(3) 有时很多 i 后面跟着很多 h.所以，我知道我的同步方法已关闭.

At this point, when I run, I get variations of either (1) many h's followed by many i's or (2) (the correct answer) a continuous stream of hihihi's, or (3) sometimes many i's followed by many h's. So, I know that my synchronization methods are off.

这是我的一个线程的示例:(注意两个线程完全一样，除了打开的文件.)

Here is an example of one of my threads:(Note both threads are exactly the same, except for the file being opened.)

void *getMessage1()
{
FILE *studentOne = fopen("Student1", "r");

size_t howManyChars;
char *placeHolderChars;
int count = 1;
while (count < 501)
{
    placeHolderChars = NULL;
    getline(&placeHolderChars, &howManyChars, studentOne);

    if(strcmp(placeHolderChars, "0\n") == 0) //if we've reached a zero
    {

         pthread_mutex_unlock(&lock);
    }
    else
    {   while(1)
        {
            if(pthread_mutex_trylock(&lock) == 0)
            {

                break;
            }
        }

        if(strlen(placeHolderChars)>0)
        {
             placeHolderChars[1] = '\0';
        }

        strcat(message,placeHolderChars);
    }

    free(placeHolderChars);

    if(feof(studentOne))
    {

        pthread_mutex_unlock(&lock); //unlock
        fclose(studentOne);
        break;
    }
    count++;

 }

return 0;
}

这是我的主要方法:

int main(void)
{
pthread_t id1;
pthread_t id2;

pthread_create((&id1), NULL, getMessage1, NULL);
pthread_create((&id2), NULL, getMessage2, NULL);

pthread_join(id1, NULL);
pthread_join(id2, NULL);

int j;

for (j = 0; j < 1001; j++)
{
     printf ("%c ",message[j]);
}

return 0;
}

我希望得到有关如何更好地使用锁定、解锁、等待和/或信号来创建具有一致结果的工作同步技术的任何指导.

推荐答案

这里是对可以执行您想要的程序的一次尝试.测试不充分，但 ;)

Here is one attempt at a program that does what you want. Insufficiently tested, though ;)

#include <iostream>
#include <fstream>
#include <string>

#include <cassert>
#include <pthread.h>



using std::cout;
using std::ifstream;
using std::string;

const string FILE1("file1.txt");
const string FILE2("file2.txt");

enum State
{
    UNINITIALIZED,
    THREAD_ONE_READS,
    THREAD_TWO_READS
};

struct ThreadInfo
{
    State state;
    string filename;
};

State state = UNINITIALIZED;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* thread_func(void* arg)
{
    // Open file 'h'.

    ThreadInfo ti = *reinterpret_cast<ThreadInfo*>(arg);
    ifstream infile;
    infile.open (ti.filename.c_str(), std::ifstream::in);

    // while (not EOF)
    //    Read 'h' or 'i': until 0 reached. Wake up other thread.

    string line;
    getline(infile, line);
    while (infile.good())
    {
        cout << "Thread " << pthread_self() << " read " << line << '\n';
        pthread_mutex_lock(&mut);
        while (state == ti.state)
        {
            pthread_cond_wait(&cond, &mut);
        }
        pthread_mutex_unlock(&mut);

        assert(line.length() == 1);
        if (line[0] == '0')
        {
            pthread_mutex_lock(&mut);
            state = ti.state;
            cout << "Got 0, transferring, setting state to " << state << '\n';
            pthread_cond_signal(&cond);
            pthread_mutex_unlock(&mut);
        }
        else
        {
            cout << "Read char: " << line << '\n';
        }
        getline(infile, line);
    }

    pthread_mutex_lock(&mut);
    state = ti.state;
    cout << "Finishing thread, transferring, setting state to " << state << '\n';
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mut);
}

int main()
{
    // Create thread 1
    // Create thread 2

    pthread_t thread_one_handle;
    pthread_t thread_two_handle;
    state = THREAD_ONE_READS;
    int result;

    ThreadInfo info1 = { THREAD_TWO_READS, FILE1 };
    result = pthread_create(&thread_one_handle, NULL, thread_func, &info1);
    assert(result == 0);

    ThreadInfo info2 = { THREAD_ONE_READS, FILE2 };
    result = pthread_create(&thread_two_handle, NULL, thread_func, &info2);
    assert(result == 0);

    result = pthread_join(thread_one_handle, NULL);
    assert(result == 0);
    result = pthread_join(thread_two_handle, NULL);
    assert(result == 0);
    cout << "main(): joined both worker threads, ending program.\n";

    return 0;
}

这篇关于线程同步:Back &两个文本文件的四读的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！