Implement thread programming using C++

With the continuous development of computer technology, multi-core processors and multi-thread programming have become increasingly important and common technologies. As a widely used object-oriented programming language, C has unique advantages in realizing multi-threaded programming. This article will introduce how to use C to implement thread programming, including thread creation, synchronization and mutual exclusion.

1. Basic concept of thread

Thread is the basic execution unit of the process. A process can contain multiple threads. Threads have the following characteristics:

(1) Threads are part of the process and therefore share the memory space of the process.

(2) Threads can be executed concurrently, which improves the running efficiency of the program.

(3) Data can be shared between threads, but they also face data competition problems.

(4) Threads have independent execution processes and can have their own stacks and registers, etc.

2. Creation of threads

C provides a variety of methods to create threads, the most commonly used of which is to use the thread class.

(1) Create a thread object

Use the constructor of the thread class to create a thread object, such as the following code:

#include <iostream>
#include <thread>

void func()
{
    std::cout << "hello from thread" << std::endl;
}

int main()
{
    std::thread t(func);
    t.join();
    return 0;
}

In the above code, the func function is threaded To execute the function, use std::thread t(func) to create a thread object, and call t.join() in the main function to execute the thread, and wait for the thread to complete execution before exiting the program.

(2) Pass parameters

If you need to pass parameters in the thread, you can pass in the parameters when creating the thread object, such as the following code:

#include <iostream>
#include <thread>

void func(int num)
{
    std::cout << "hello from thread " << num << std::endl;
}

int main()
{
    std::thread t(func, 3);
    t.join();
    return 0;
}

In the above code , the func function has an int type parameter num, and parameter 3 is passed in when creating the thread object.

3. Thread synchronization

When multiple threads are executed at the same time, some problems may occur, such as data competition, deadlock, etc. In order to avoid these problems, the concept of thread synchronization must be introduced.

(1) Mutex

Mutex is the most commonly used thread synchronization mechanism, which can prevent multiple threads from accessing shared resources at the same time. C provides the std::mutex class to implement mutexes, such as the following code:

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mtx;

void func()
{
    mtx.lock();
    std::cout << "hello from thread" << std::endl;
    mtx.unlock();
}

int main()
{
    std::thread t(func);
    mtx.lock();
    std::cout << "hello from main" << std::endl;
    mtx.unlock();
    t.join();
    return 0;
}

In the above code, mtx.lock() and mtx.unlock() are used to lock and unlock the mutex respectively. quantity. Mutexes are used in both the func function and the main function to lock and unlock the output statements, which ensures that the output statements are executed in the specified order.

(2) Condition variable

Condition variable is a thread synchronization mechanism that can be used to wait for a certain condition to be met before continuing execution. C provides the std::condition_variable class to implement condition variables, such as the following code:

#include <iostream>
#include <condition_variable>
#include <mutex>
#include <thread>

std::mutex mtx;
std::condition_variable cv;
bool flag = false;

void func1()
{
    std::unique_lock<std::mutex> ul(mtx);
    while(!flag)
    {
        cv.wait(ul);
    }
    std::cout << "hello from thread1" << std::endl;
}

void func2()
{
    std::unique_lock<std::mutex> ul(mtx);
    flag = true;
    cv.notify_one();
}

int main()
{
    std::thread t1(func1);
    std::thread t2(func2);

    t1.join();
    t2.join();
    return 0;
}

In the above code, cv.wait(ul) is used to wait for the condition variable flag to be satisfied before continuing execution, cv.notify_one () is used to notify threads waiting for the condition variable. Set flag to true in the func2 function and notify the thread waiting for the condition variable to reset.

4. Summary

This article introduces how to use C to implement thread programming, including thread creation, synchronization and mutual exclusion. By studying this article, you will learn how to use thread synchronization mechanisms such as mutexes and condition variables to avoid problems that may arise when multiple threads execute concurrently.

The above is the detailed content of Implement thread programming using C++. For more information, please follow other related articles on the PHP Chinese website!