C++ multithreading multithreading is a special form of multitasking that allows a computer to run two or more programs simultaneously. In general, there are two types of multitasking: process-based and thread-based.
Process-based multitasking is the concurrent execution of programs. Thread-based multitasking is the concurrent execution of pieces of the same program. A multithreaded program consists of two or more parts that can be run simultaneously. Each part of such a program is called a thread, and each thread defines a separate execution path.
This tutorial assumes that you are using a Linux operating system, and we will write multithreaded C++ programs using POSIX. POSIX Threads or Pthreads provide apis that are available on many Unix POSIX systems, such as FreeBSD, NetBSD, GNU/Linux, Mac OS X, and Solaris.
Create thread The following program, which we can use to create a POSIX thread:
#include <pthread.h>
pthread_create (thread, attr, start_routine, arg)
Copy the codeHere, pthread_create creates a new thread and makes it executable. Here is a description of the parameters:
| parameter | describe |
|---|---|
| thread | Pointer to thread identifier. |
| attr | An opaque property object that can be used to set thread properties. You can specify thread property objects or use the default value NULL. |
| start_routine | The starting address of a thread to run a function that will be executed once the thread is created. |
| arg | Arguments to run a function. It must be passed by casting the reference as a pointer to void. If no argument is passed, NULL is used. |
When the thread is successfully created, the function returns 0. If the value is not 0, the thread failed to be created.
Terminating a POSIX thread using the following program:
#include <pthread.h>
pthread_exit (status)
Copy the codeIn this case, pthread_exit is used to explicitly exit a thread. Normally, the pthread_exit() function is called when the thread has finished its work and no longer needs to exist.
If main() ends before the thread it created and exits via pthread_exit(), the other threads continue. Otherwise, they are automatically terminated at the end of main().
The following simple example code uses the pthread_create() function to create five threads, each of which prints “Hello Runoob!” :
The instance
#include <iostream>
// Mandatory header file
#include <pthread.h>
using namespace std;
#define NUM_THREADS 5
// The thread's running function
void* say_hello(void* args)
{
cout << "Hello Runoob！" << endl;
return 0;
}
int main(a)
{
// Define the thread ID variable. Multiple variables use arrays
pthread_t tids[NUM_THREADS];
for(int i = 0; i < NUM_THREADS; ++i)
{
// The arguments are: the id of the created thread, the argument of the thread, the function called, the argument of the function passed
int ret = pthread_create(&tids[i], NULL, say_hello, NULL);
if(ret ! =0)
{
cout << "pthread_create error: error_code="<< ret << endl; }}// Wait for each thread to exit before the process terminates, otherwise the process is forced to end, the thread may not respond;
pthread_exit(NULL);
}
Copy the codeCompile the following program using the -lpThread library:
$ g++ test.cpp -lpthread -o test.o
Copy the codeNow, executing the program produces the following results:
$./test.o Hello Runoob! Hello Runoob! Hello Runoob! Hello Runoob! Hello Runoob!Copy the codeThe following simple example code creates five threads using the pthread_create() function and receives the parameters passed in. Each thread prints a “Hello Runoob!” Message, output the received arguments, and call pthread_exit() to terminate the thread.
The instance
// File name: test.cpp
#include <iostream>
#include <cstdlib>
#include <pthread.h>
using namespace std;
#define NUM_THREADS 5
void *PrintHello(void *threadid)
{
// Cast the passed argument from an untyped pointer to an integer pointer, and then read
int tid = *((int*)threadid);
cout << "Hello Runoob! Thread ID," << tid << endl;
pthread_exit(NULL);
}
int main (a)
{
pthread_t threads[NUM_THREADS];
int indexes[NUM_THREADS];// Use an array to hold the value of I
int rc;
int i;
for( i=0; i < NUM_THREADS; i++ ){
cout << "Main () : Create thread," << i << endl;
indexes[i] = i; // Save the value of I
// When passed, it must be cast to void*, i.e., no type pointer
rc = pthread_create(&threads[i], NULL,
PrintHello, (void *)&(indexes[i]));
if (rc){
cout << "Error: could not create thread," << rc << endl;
exit(- 1); }}pthread_exit(NULL);
}
Copy the codeNow compile and execute the program, which produces the following results:
$ g++ test.cpp -lpthread -o test.o
$ ./test.o
main(a): Create a thread,0Main () : Creates a thread,1Hello Runoob! The thread ID,0Main () : Create thread, Hello Runoob! The thread ID,21Main () : Creates a thread,3Hello Runoob! The thread ID,2Main () : Creates a thread,4Hello Runoob! The thread ID,3Hello Runoob! The thread ID,4
Copy the codePassing parameters to a thread this example demonstrates how to pass multiple parameters through a structure. You can pass any data type in the thread callback because it points to void, as shown in the following example:
The instance
#include <iostream>
#include <cstdlib>
#include <pthread.h>
using namespace std;
#define NUM_THREADS 5
struct thread_data{
int thread_id;
char *message;
};
void *PrintHello(void *threadarg)
{
struct thread_data *my_data;
my_data = (struct thread_data *) threadarg;
cout << "Thread ID : " << my_data->thread_id ;
cout << " Message : " << my_data->message << endl;
pthread_exit(NULL);
}
int main (a)
{
pthread_t threads[NUM_THREADS];
struct thread_data td[NUM_THREADS];
int rc;
int i;
for( i=0; i < NUM_THREADS; i++ ){
cout <<"main() : creating thread, " << i << endl;
td[i].thread_id = i;
td[i].message = (char*)"This is message";
rc = pthread_create(&threads[i], NULL,
PrintHello, (void *)&td[i]);
if (rc){
cout << "Error:unable to create thread," << rc << endl;
exit(- 1); }}pthread_exit(NULL);
}
Copy the codeWhen the above code is compiled and executed, it produces the following results:
$ g++ -Wno-write-strings test.cpp -lpthread -o test.o
$ ./test.o
main(a) : creating thread, 0
main() : creating thread, 1
Thread ID : 0 Message : This is message
main() : creating thread, Thread ID : 21
Message : This is message
main() : creating thread, 3
Thread ID : 2 Message : This is message
main() : creating thread, 4
Thread ID : 3 Message : This is message
Thread ID : 4 Message : This is message
Copy the codeJoin and detach threads We can use two functions to join or detach threads:
Pthread_join (threaDID, status) pthread_detach (threaDID) The pthread_join() subroutine prevents calling the program until the specified threaDID thread terminates. When you create a thread, one of its properties defines whether it is joinable or detached. Only threads defined as connectable at creation time can be connected. If a thread is defined as separable when it is created, it can never be joined.
This example demonstrates how to use the pthread_join() function to wait for a thread to complete.
The instance
#include <iostream>
#include <cstdlib>
#include <pthread.h>
#include <unistd.h>
using namespace std;
#define NUM_THREADS 5
void *wait(void *t)
{
int i;
long tid;
tid = (long)t;
sleep(1);
cout << "Sleeping in thread " << endl;
cout << "Thread with id : " << tid << "... exiting " << endl;
pthread_exit(NULL);
}
int main (a)
{
int rc;
int i;
pthread_t threads[NUM_THREADS];
pthread_attr_t attr;
void *status;
// Initialize and set the thread to joinable.
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
for( i=0; i < NUM_THREADS; i++ ){
cout << "main() : creating thread, " << i << endl;
rc = pthread_create(&threads[i], NULL, wait, (void *)&i );
if (rc){
cout << "Error:unable to create thread," << rc << endl;
exit(- 1); }}// Delete attributes and wait for other threads
pthread_attr_destroy(&attr);
for( i=0; i < NUM_THREADS; i++ ){
rc = pthread_join(threads[i], &status);
if (rc){
cout << "Error:unable to join," << rc << endl;
exit(- 1);
}
cout << "Main: completed thread id :" << i ;
cout << " exiting with status :" << status << endl;
}
cout << "Main: program exiting." << endl;
pthread_exit(NULL);
}
Copy the codeWhen the above code is compiled and executed, it produces the following results:
main() : creating thread, 0
main() : creating thread, 1
main() : creating thread, 2
main() : creating thread, 3
main() : creating thread, 4
Sleeping in thread
Thread with id : 4. exiting Sleeping in thread Thread with id :3. exiting Sleeping in thread Thread with id :2. exiting Sleeping in thread Thread with id :1. exiting Sleeping in thread Thread with id :0. exiting Main: completed thread id :0 exiting with status :0
Main: completed thread id :1 exiting with status :0
Main: completed thread id :2 exiting with status :0
Main: completed thread id :3 exiting with status :0
Main: completed thread id :4 exiting with status :0
Main: program exiting.
Copy the code