在C ++中，使用一个线程从文件中读取一行，并使用另一个线程来处理（多线程）

Question

New to threading. I would like to have two separate threads that do two different things:

ThreadA: read a file, line by line from an input file

ThreadB: do things with the line that is previously read

How can I achieve this? Thanks in advance

    class A
    {
    //...
    public:
        void processFile(ifstream& input, string& s)
        {
            //read file line by line in ThreadA
            //process that line in ThreadB
        }
    };

    int main()
    {
        // ?
    }

Answer 1

For the assignment to make sense, one thread should be reading a new line of input while the other thread is processing the previously read line.

To answer the question as posed, one may use std::async. Include-file is <future>. See this near-duplicate .

I am tempted to post a correct program.

EDIT. I cannot help myself. This, like so many things, is simple once it's understood (and you know some tricks).

WARNING SPOILER ALERT You (OP) should not read on until after you have turned in the assignment.

int main() {
    std::ifstream input("foo.txt"); // Or whatever

    using std::string;
    using std::getline;
    using std::async;
    using std::move;

    // The function that processes the line ...
    // Notice that "line" is bound by value. Using a reference,
    // (const string &line) would create a conflict between threads.
    auto process = [](const string line)->bool {
        return !!(std::cout << line << std::endl); // or whatever...
    };

    string line;
    // The bang-bang !! turns the result of getline into bool
    bool line_ready = !!getline(input, line); // Read first line
    bool process_ok = true;
    while (line_ready && process_ok) {
        auto handle = async(std::launch::async, process, move(line)); // Launch thread
        line_ready = !!getline(input, line); // Fetch next line while processing previous
        process_ok = handle.get(); // Wait for processing to finish
    }
    return (process_ok && input.eof()) ? 0: -1;
}

Answer 2

Threading is a difficult concept to get your mind around.

Conceptually, threads provide parallel execution paths, which appear to execute concurrently. On a multiple core processor they may actually be running simultaneously. On a single core processor, they don't actually run concurrently, but they appear to.

To use multi-threading effectively, you have to be able to break down a problem in a way where you can imagine that having two functions running simultaneously will benefit you. In your case, you desire to read information in one function, while processing the information in another completely separate function. Once you can see how to do that, you just have to run the functions on separate threads, and figure out how to get the information safely from one function to the other.

I would suggest writing a function that reads from the file, and stores the information in a queue or buffer of some sort. Write another function that takes information from the buffer or queue, and processes the information. Adhere to the rule that the read function only writes to the queue, and the processing function only reads from the queue.

Once you have those functions constructed, tackle the issue of running the functions on threads. The general concept is that you will launch a thread with the read function, and another thread with the processing function. Then you have to 'join' the threads when they get done doing what they are doing.

For the read thread, it is straight forward. Once the file has been read, and the information is all in the queue, it is done. The processing thread is a little more difficult. It needs to figure out when the information is going to quit coming. It may be necessary for the reading function to add something to the queue to indicate that the reading is done.

There are a number of ways to create the threads and run the functions on the threads. I'm pretty sure that your instructor is recommending ways of doing that.