Welcome to Codingfizz,
In C++, multithreading can be implemented using the std::thread class, which is part of the C++11 standard library. To create a new thread, an instance of `std::thread` is created and passed a function or callable object to execute.
For example:
void myFunction() {
// code to be executed by new thread
}
std::thread t1(myFunction);
This creates a new thread and runs myFunction in it. Once the thread is created, it can be started by calling `t1.join()` which waits for the thread to finish.
It is also possible to pass arguments to the function executed by the thread by using `std::bind` or by creating a `std::function` and passing it to the thread's constructor.
It's also worth noting that C++17 added the `std::jthread` class, which automatically joins the thread in its destructor, making it more convenient to use with RAII principle.
It's also worth noting that C++ thread library doesn't provide advanced features like thread pool, task queue, etc. If you need those features you may want to use a third-party libraries like Boost.Asio, Poco, etc.
Here's an example of using std::thread to create a new thread in C++:
#include <iostream>
#include <thread>
void myFunction() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
std::thread t1(myFunction);
// Wait for thread to finish
t1.join();
std::cout << "Thread finished" << std::endl;
return 0;
}
In this example, myFunction is a simple function that prints "Hello from thread!" to the console. In the main function, an instance of `std::thread` is created and passed myFunction as the function to execute in the new thread. The join method is then called on the thread object to wait for the thread to finish before the program exits.
You can also pass arguments to the function executed by the thread, for example:
#include <iostream>
#include <thread>
void myFunction(int x, std::string str) {
std::cout << "Hello from thread! x = " << x << " str = " << str << std::endl;
}
int main() {
std::thread t1(myFunction, 10, "Thread 1");
std::thread t2(myFunction, 20, "Thread 2");
// Wait for threads to finish
t1.join();
t2.join();
std::cout << "Threads finished" << std::endl;
return 0;
}
In this case, myFunction takes two arguments, an integer, and a string, and they are passed when creating the thread.
It's also worth noting that you should always check whether the thread was successfully created by checking the thread's `joinable()` method before calling `join()` or `detach()` method.
0 Comments