如何动态创建具有多个对应类的多个线程来解决许多数独谜题

Question

My task is to write a multi threaded program that solves a set of sudoku puzzles by dynamically determining the maximum number of threads that can run on the machine, then allocate that many threads to grab single puzzles from the file with all the sudoku puzzles.

Something like: we have determined that 8 threads can run on this machine, so we'll allocate 8 threads. Then these 8 threads take turns grabbing individual sudoku puzzles from the pile and solving them, and writing them to a new file with the solutions

What I currently have so far is a fully working code to grab the first puzzle, solve, and write it to the solution file. But I need to make it multi threaded and have it do this for all the rest of the puzzles too. I have a class that holds the sudoku puzzle data called SudokuGrid, which has the 9x9 array.

I'm struggling with the concept of allocating the threads and allocating a class for each thread, I think I can generate an array to hold the threads but how do I allocate corresponding class instances? I believe I'll need one instance for each thread since they'll be working on their own different puzzles. I'm supposed to use std::thread for this.

Answer 1

To address your question directly (ie. not helping you with the logic of solving the puzzle, but just helping you with allocating and managing threads to methods), this is a minimalistic example of how to set up objects to do some work on different threads:

#include <iostream>
#include <random>
#include <thread>

struct Foo
{
    int count;

    void Bar (int n)
    {
        count = 0;
    
        for (int i = 0; i < n; ++i)
            count += std::rand() % n;
    }
};

void SetUpMultiThreading (std::vector<Foo> & foo)
{
    int n = foo.size();

    std::vector<std::thread> threads(n); 
    
    // the below (2*i+5) is just some mock data input

    for (int i = 0; i < n; ++i)
        threads[i] = std::thread(&Foo::Bar, std::ref(foo[i]), 2*i+5); 
        
    // Note that without std::ref (or a custom wrapper instead)
    // then the foo element would be copied to the std::thread
    // function, so you'd lose access to the results

    for (auto & t : threads)
        t.join();
}

void CheckWork (const std::vector<Foo> & foo)
{
    for (auto & f : foo)
        std::cout << f.count << std::endl;
}

int main ()
{
    srand(time(NULL));

    const int n = 8;
    
    std::vector<Foo> foo(n);
    SetUpMultiThreading(foo);
    CheckWork(foo);
}