您的位置:

提高程序运行效率的有效方法——C++多线程编程

一、多线程基础知识

1、C++11的多线程库

C++11标准引入了对多线程的支持,它定义了<thread>头文件以及std::thread类,可以方便地进行线程创建、结束、等待等操作。下面是一个简单的示例:

#include <iostream>
#include <thread>

void hello()
{
    std::cout << "Hello World!<br>" << std::endl;
}

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

2、线程间的数据共享

多线程编程中,不同线程之间需要共享数据,但共享数据容易引起线程安全问题,需要使用互斥量std::mutex来进行保护。

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

std::mutex mu;
int g_count = 0;

void increment()
{
    mu.lock();
    ++g_count;
    mu.unlock();
}

int main()
{
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();

    std::cout << "g_count = " << g_count << std::endl;
    return 0;
}

二、多线程优化策略

1、任务分解

将大任务分成多个小任务,每个小任务由一个线程执行,通过这种方式可以提高程序的整体处理速度。

#include <iostream>
#include <thread>
#include <vector>
#include <cmath>

const int N = 1000000;

void calculate(int start, int end, double* result)
{
    for(int i = start; i < end; ++i)
    {
        result[i] = sqrt(i);
    }
}

int main()
{
    double* result = new double[N];
    std::vector<std::thread> threads;
    const int thread_count = std::thread::hardware_concurrency();
    const int block_size = N / thread_count;

    for(int i = 0; i < thread_count; ++i)
    {
        int start = i * block_size;
        int end = (i == thread_count-1) ? N : (i+1) * block_size;
        threads.push_back(std::thread(calculate, start, end, result));
    }

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

    delete[] result;
    return 0;
}

2、避免不必要的复制

多线程程序中,有时需要传递大量数据到线程执行的函数中,如果直接传递这些数据,会造成大量的复制开销,可以通过使用指针或引用的方式,减小函数参数的复制。

#include <iostream>
#include <thread>
#include <cstring>
#include <cstdlib>

void worker(const char* str)
{
    char* s = (char*)malloc(sizeof(str)+1);
    std::strcpy(s, str);
    std::cout << "Thread " << std::this_thread::get_id() << " : " << s << std::endl;
    free(s);
}

int main()
{
    const char* str = "Hello World!";
    std::thread t(worker, str);
    t.join();
    return 0;
}

三、多线程应用场景

1、网络编程

网络编程中,需要同时处理多个客户端的请求,通过多线程可以提高服务器的并发处理性能。

//Server代码
#include <iostream>
#include <thread>
#include <chrono>
#include <string>
#include <cstring>
#include <vector>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

const int PORT = 8888;
int server_fd = 0, client_fd = 0;
bool is_running = true;
std::vector<std::thread> threads;

void client_thread(int fd)
{
    char buffer[1024];
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    while(is_running)
    {
        memset(buffer, 0, sizeof(buffer));
        int n = recvfrom(fd, buffer, sizeof(buffer), 0, (struct sockaddr *)&client_addr, &client_addr_len);
        if(n == -1) continue;
        //处理客户端请求
        std::cout << "Thread " << std::this_thread::get_id() << " : receive message from " << inet_ntoa(client_addr.sin_addr) << " : " << ntohs(client_addr.sin_port) << ", message:" << buffer << std::endl;
    }
}

void init_server()
{
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
    listen(server_fd, 10);
    std::cout << "Server start ..." << std::endl;

    while(is_running)
    {
        client_fd = accept(server_fd, NULL, NULL);
        std::thread t(client_thread, client_fd);
        threads.push_back(std::move(t));
    }

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

void stop_server()
{
    is_running = false;
    close(client_fd);
    close(server_fd);
}

int main()
{
    std::thread t(init_server);
    getchar();
    stop_server();
    t.join();
    return 0;
}

2、数据处理

数据处理中,经常需要进行大量的计算、排序、查找等操作,通过多线程可以加快计算速度。

#include <iostream>
#include <thread>
#include <vector>
#include <algorithm>
#include <random>

const long long N = 100000000000;
const int block_size = 1000000;
std::vector<std::thread> threads;
double* a;

void calculate(int start, int end, double* result)
{
    for(long long i = start; i < end; ++i)
    {
        result[i] = sqrt(i);
    }
}

int main()
{
    a = new double[N];

    for(int i = 0; i < N; i += block_size)
    {
        int start = i;
        int end = (i + block_size < N) ? i + block_size : N;
        threads.push_back(std::thread(calculate, start, end, a));
    }

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

    std::sort(a, a+N);
    delete[] a;
    return 0;
}

四、结语

本文介绍了C++多线程编程的基础知识、优化策略和应用场景,但是多线程编程也有其困难和缺陷,需要开发者在使用时进行综合考虑。

提高程序运行效率的有效方法——C++多线程编程

2023-05-13
提高程序运行效率的Python多线程编程技巧

2023-05-13
多线程编程:使用C++11 thread提高程序效率

2023-05-13
提高效率之python的多线程(python 多线程效率低)

2022-11-10
提高程序效率,实现多线程操作

2023-05-12
c语言笔记讲解,c语言程序笔记

2022-11-23
Python多线程:提升程序运行效率的利器

2023-05-13
提升 Python 程序运行效率的 while 循环技巧

2023-05-13
Python多进程池:提高程序运行效率的利器

2023-05-18
使用C++进行高效编程

2023-05-13
高效利用C++语言提升程序性能

2023-05-13
C++ log:快速记录程序日志并提高调试效率

2023-05-18
提升程序效率的Python编程技巧

2023-05-12
提高Python程序执行效率的技巧之多线程应用

2023-05-12
提高代码效率,编写高性能程序

一、使用更高效的算法和数据结构 设计高效的算法和数据结构是提高代码效率的关键。在选择算法和数据结构时,我们应该考虑输入的规模、处理的速度和内存的使用情况。例如,在查找操作频繁的情况下,使用哈希表比使用

2023-12-08
提高c语言编程,如何提高c++编程能力

2022-11-24
提高Python程序的效率:使用多线程

2023-05-12
利用Visual Studio编写高效C++程序

2023-05-13
提高程序效率,Python的实用妙招!

2023-05-13
C++在线编译器-开发更高效的C++应用程序

2023-05-13