(C++) Is a thread must be written in main()?

Question

Background: So here is my problem: I have a method inside of a certain class that will take user inputs until the user enters a "stop signal", say "done". Like:

void getInput(){
    string input;
    cin >> input;
    while (input != "done") {
        cout <<"Please input a word: ";
        linkedlist.push(input);
        cin>> input;
    }
}

Now I have to add a timer to limit this user input for a certain time, like 30 seconds, and the linkedlist will only record what the user has inputted within those 30 seconds, so I just need a way to break the loop.

Sample output:

You have 30 seconds to input the words or input "done" to finish:
Please input a word: pikachu
Please input a word: kapichu
Please input a word: chupika
Please input a word: kachupi
30 seconds has reached. Your inputs are saved.

I've just learned thread, but I noticed every tutorial put threads only in main(), and I've noticed this post and tried the provided method and it works in its case: How to use a timer in C++ to force input within a given time?.

But here, if I would use thread to achieve my task, it seems I need to restructure my class entirely or run the methods from that class one by one in main()?

Question: So, can we write threads in a normal function and use them accordingly? (derivative question: If not, what would be the best solution to realize it?)

I'm very new to concurrent programming. Please elaborate. Thanks guys!

Answer 1

main() is just a function, much like any other (except its name is reserved and the CRT relies on it).

Yes, you can create threads from "any place" - be it a non-main() function, a class's static or non-static method, const or non-const, inline or not, public/protected/private, file-local, lambda, etc.

Answer 2

On OSX, I use the following to get input asynchronously with a time-out..

#include <chrono>
#include <mutex>
#include <string>
#include <iostream>

#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#else
#include <pthread.h>
#endif

#if defined(_WIN32) || defined(_WIN64)
#define THREAD_RETURN_TYPE DWORD
#else
#define THREAD_RETURN_TYPE void*
#endif

class semaphore
{
private:
    std::mutex mutex;
    std::condition_variable condition;
    uint32_t count = 0;

public:
    void signal()
    {
        std::unique_lock<std::mutex> lock(mutex);
        ++count;
        condition.notify_one();
    }

    void wait()
    {
        std::unique_lock<std::mutex> lock(mutex);
        condition.wait(lock, [&] {
            return count > 0;
        });
        --count;
    }

    bool try_wait()
    {
        std::unique_lock<std::mutex> lock(mutex);
        if (count > 0)
        {
            --count;
            return true;
        }
        return false;
    }

    template<typename Rep, typename Period>
    bool wait_for(const std::chrono::duration<Rep, Period>& relative_time)
    {
        std::unique_lock<std::mutex> lock(mutex);
        bool finished = condition.wait_for(lock, relative_time, [&] {
            return count > 0;
        });

        if (finished)
        {
            --count;
        }
        return finished;
    }

    template<typename Duration>
    bool wait_until(const std::chrono::time_point<std::chrono::high_resolution_clock, Duration>& absolute_time)
    {
        std::unique_lock<std::mutex> lock(mutex);
        bool finished = condition.wait_until(lock, absolute_time, [&] {
            return count > 0;
        });

        if (finished)
        {
            --count;
        }
        return finished;
    }

    template<typename Clock, typename Duration>
    bool wait_until(const std::chrono::time_point<Clock, Duration>& absolute_time)
    {
        return wait_until(std::chrono::high_resolution_clock::now() + (absolute_time - Clock::now()));
    }
};

class simple_thread
{
private:
    #if defined(_WIN32) || defined(_WIN64)
    HANDLE thread;
    #else
    pthread_t thread;
    #endif

public:
    simple_thread(THREAD_RETURN_TYPE (*threadFunc)(void*), void* args)
    {
        #if defined(_WIN32) || defined(_WIN64)
        thread = CreateThread(0, 0, static_cast<LPTHREAD_START_ROUTINE>(threadFunc), args, 0, 0);
        #else
        pthread_create(&thread, nullptr, threadFunc, args);
        #endif
    }

    void join()
    {
        #if defined(_WIN32) || defined(_WIN64)
        WaitForSingleObject(thread, INFINITE);
        #else
        pthread_join(thread, nullptr);
        #endif
    }

    void detach()
    {
        #if defined(_WIN32) || defined(_WIN64)
        CloseHandle(thread);
        #else
        pthread_detach(thread);
        #endif
    }

    void abort()
    {
        #if defined(_WIN32) || defined(_WIN64)
        TerminateThread(thread, 0);
        #else
        pthread_cancel(thread);
        #endif
    }
};





THREAD_RETURN_TYPE getInput(void* args)
{
    std::string* input = static_cast<std::string*>(static_cast<void**>(args)[0]);
    semaphore* sem = static_cast<semaphore*>(static_cast<void**>(args)[1]);

    getline(std::cin, *input);
    sem->signal();
    return 0;
}

int main()
{
    std::string input;
    semaphore sem;
    void* args[2] = {&input, &sem};

    simple_thread thread(getInput, args);

    if (sem.wait_for(std::chrono::seconds(5)))
    {
        std::cout<<"Input";
        thread.join();
    }
    else
    {
        std::cout<<"Invalid Input";
        thread.abort();
    }
}

You can use pthread to create a semaphore with mutex as well.. or use c++11 like above..

One other thing is that I created my own threading class because I couldn't find a way to kill an std::thread..