【Linux多线程编程和资源同步源码示例】

已于 2024-04-18 21:56:47 修改
阅读量1.1k 收藏 10
点赞数 21
文章标签： linux 运维 服务器
于 2024-04-18 21:44:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42723793/article/details/137937851
版权

文章目录

前言

多线程编程是一种利用操作系统的多任务处理机制，以实现程序并发执行的编程模型。在Linux环境下，使用线程可以充分利用多核处理器的优势，提高程序的性能。然而，多线程编程涉及到共享资源的访问，需要特别注意资源同步问题，以避免竞态条件和数据不一致性。

提示：以下是本篇文章正文内容，下面案例可供参考

一、线程创建与基本概念

在Linux中，线程是通过pthread库来实现的。线程的创建和管理都是通过pthread库提供的函数完成的。以下是一个简单的线程创建示例：

#include <pthread.h>
#include <stdio.h>
void* thread_function(void* arg)
 {
    printf("Hello from the thread!\n");
    return NULL;
}

int main() {
    pthread_t my_thread;
    pthread_create(&my_thread, NULL, thread_function, NULL);
    // 等待线程结束
    pthread_join(my_thread, NULL);
    return 0;
}

二、资源同步问题

1.互斥锁（Mutex）

互斥锁是一种最基本的线程同步机制，它用于保护共享资源，确保在任意时刻只有一个线程可以访问。以下是一个简单的互斥锁使用示例：

#include <pthread.h>
#include <stdio.h>

pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;

void* thread_function(void* arg)
 {
    pthread_mutex_lock(&my_mutex);
    // 访问共享资源
    pthread_mutex_unlock(&my_mutex);
    return NULL;
}

int main() {
    pthread_t my_thread;
    pthread_create(&my_thread, NULL, thread_function, NULL);
    pthread_mutex_lock(&my_mutex);
    // 访问共享资源
    pthread_mutex_unlock(&my_mutex);
    pthread_join(my_thread, NULL);
    return 0;
}

2.信号量（Semaphore）

信号量是一种用于控制对共享资源的访问的更为灵活的机制，可以允许多个线程同时访问。以下是一个简单的信号量使用示例：

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>

sem_t my_semaphore;

void* thread_function(void* arg)
 {
    sem_wait(&my_semaphore);
    // 访问共享资源
    sem_post(&my_semaphore);
    return NULL;
}

int main() 
{
    sem_init(&my_semaphore, 0, 1);
    pthread_t my_thread;
    pthread_create(&my_thread, NULL, thread_function, NULL);
    sem_wait(&my_semaphore);
    // 访问共享资源
    sem_post(&my_semaphore);
    pthread_join(my_thread, NULL);
    sem_destroy(&my_semaphore);
    return 0;
}

3.条件变量（Condition Variable）

条件变量用于线程之间的通信和同步，它允许一个线程等待某个条件的发生，而其他线程可以在满足条件时通知等待的线程。以下是一个简单的条件变量使用示例：

#include <pthread.h>
#include <stdio.h>

pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t my_condition = PTHREAD_COND_INITIALIZER;
int shared_data = 0;

void* producer_function(void* arg) {
    pthread_mutex_lock(&my_mutex);

    // 修改共享资源
    shared_data = 42;
    // 发送信号通知等待的线程
    pthread_cond_signal(&my_condition);
    pthread_mutex_unlock(&my_mutex);
    return NULL;
}

void* consumer_function(void* arg) 
{
    pthread_mutex_lock(&my_mutex);
    // 等待条件满足
    while (shared_data == 0) 
    {
        pthread_cond_wait(&my_condition, &my_mutex);
    }
    // 处理共享资源
    printf("Consumer: %d\n", shared_data);
    pthread_mutex_unlock(&my_mutex);
    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;
    pthread_create(&producer_thread, NULL, producer_function, NULL);
    pthread_create(&consumer_thread, NULL, consumer_function, NULL);
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    return 0;
}

三、线程安全性与性能优化

在多线程编程中，除了使用锁和其他同步机制确保数据的一致性外，还应考虑性能优化的问题。例如，避免不必要的锁竞争、减小锁的粒度、使用无锁数据结构等都是提高多线程程序性能的重要手段。

四、线程池与任务调度

线程池是一种管理和复用线程的机制，它可以有效地减少线程的创建和销毁开销。在Linux环境下，可以使用pthread库结合队列实现一个简单的线程池。
以下是一个基本的线程池示例：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define THREAD_POOL_SIZE 4

typedef struct 
{
    pthread_t thread;
    int id;
} WorkerThread;

WorkerThread thread_pool[THREAD_POOL_SIZE];

typedef struct 
{
    void (*function)(void*);
    void* arg;
} Task;

Task task_queue[100];
int task_count = 0;

pthread_mutex_t task_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t task_condition = PTHREAD_COND_INITIALIZER;

void* worker_function(void* arg)
 {
    WorkerThread* worker = (WorkerThread*)arg;
    while (1) 
    {
        pthread_mutex_lock(&task_mutex);
        while (task_count == 0)
         {
            pthread_cond_wait(&task_condition, &task_mutex);
        }
        Task task = task_queue[--task_count];
        pthread_mutex_unlock(&task_mutex);
        task.function(task.arg);
    }
    return NULL;
}

void submit_task(void (*function)(void*), void* arg)
 {
    pthread_mutex_lock(&task_mutex);

    if (task_count < 100) 
    {
        task_queue[task_count].function = function;
        task_queue[task_count].arg = arg;
        task_count++;
        pthread_cond_signal(&task_condition);
    }
    pthread_mutex_unlock(&task_mutex);
}

int main()
 {
    for (int i = 0; i < THREAD_POOL_SIZE; ++i) 
    {
        thread_pool[i].id = i;
        pthread_create(&thread_pool[i].thread, NULL, worker_function, &thread_pool[i]);
    }
    // 提交任务
    for (int i = 0; i < 10; ++i) {
        submit_task((void (*)(void*))printf, "Hello from task %d\n");
        usleep(100000);  // 等待一段时间，模拟任务的产生过程
    }
    // 等待所有线程结束
    for (int i = 0; i < THREAD_POOL_SIZE; ++i) {
        pthread_join(thread_pool[i].thread, NULL);
    }
    return 0;
}

五、C++11及以上的多线程支持

C++11引入了头文件，提供了更便捷的多线程编程支持。以下是一个简单的C++11多线程示例：

#include <iostream>
#include <thread>

void thread_function()
 {
    std::cout << "Hello from thread!" << std::endl;
}

int main() 
{
    std::thread my_thread(thread_function);
    // 等待线程结束
    my_thread.join();
    return 0;
}

C++11还引入了头文件，提供了std::mutex等同步机制。使用C++11的线程和同步机制能够更方便地进行多线程编程。

六、读写锁（Read-Write Lock）

读写锁是一种特殊的锁机制，允许多个线程同时读取共享资源，但在写操作时需要独占锁。这有助于提高读操作的并发性，适用于读多写少的场景。
以下是一个简单的读写锁示例：

#include <pthread.h>
#include <stdio.h>

pthread_rwlock_t my_rwlock = PTHREAD_RWLOCK_INITIALIZER;
int shared_data = 0;

void* reader_function(void* arg) 
{
    pthread_rwlock_rdlock(&my_rwlock);
    // 读取共享资源
    printf("Reader: %d\n", shared_data);
    pthread_rwlock_unlock(&my_rwlock);
    return NULL;
}

void* writer_function(void* arg) 
{
    pthread_rwlock_wrlock(&my_rwlock);
    // 修改共享资源
    shared_data++;
    pthread_rwlock_unlock(&my_rwlock);
    return NULL;
}

int main() {
    pthread_t reader_thread, writer_thread;
    pthread_create(&reader_thread, NULL, reader_function, NULL);
    pthread_create(&writer_thread, NULL, writer_function, NULL);
    pthread_join(reader_thread, NULL);
    pthread_join(writer_thread, NULL);
    return 0;
}

七、C++中的std::mutex和std::unique_lock

在C++中，使用std::mutex和std::unique_lock可以更方便地进行线程同步。std::unique_lock提供了对std::mutex的封装，使得锁的管理更加灵活。
以下是一个简单的使用std::mutex和std::unique_lock的示例：

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

std::mutex my_mutex;
int shared_data = 0;

void thread_function()
 {
    std::unique_lock<std::mutex> lock(my_mutex);
    // 访问共享资源
    std::cout << "Hello from thread! Shared data: " << shared_data << std::endl;
}

int main() 
{
    std::thread my_thread(thread_function);
    {
        std::unique_lock<std::mutex> lock(my_mutex);
        // 修改共享资源
        shared_data++;
    }
    // 等待线程结束
    my_thread.join();
    return 0;
}

八、原子操作

原子操作是不可中断的操作，能够确保在多线程环境中对共享数据的操作是原子的。C++11引入了std::atomic类型，提供了原子操作的支持。
以下是一个简单的使用std::atomic的示例：

#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> shared_data(0);

void thread_function() 
{
    // 原子操作，无需额外的锁
    shared_data++;
    std::cout << "Hello from thread! Shared data: " << shared_data <<std::endl;
}

int main() 
{
    std::thread my_thread(thread_function);
    // 原子操作，无需额外的锁
    shared_data++;
    // 等待线程结束
    my_thread.join();
    return 0;
}

九、死锁与避免策略

死锁是多线程编程中常见的问题，它指的是一组线程因争夺资源而陷入无限等待的状态。死锁通常发生在多个线程之间循环等待对方释放资源的情况下。避免死锁的策略包括：
按序加锁（Lock Ordering）：规定所有线程必须按照相同的顺序获取锁。这样，所有线程就不会形成循环等待的情况。
加锁超时（Lock Timeout）：在获取锁时设置一个超时时间，如果超过这个时间仍未获取到锁，则放弃锁，避免死锁的发生。
死锁检测（Deadlock Detection）：周期性地检测系统中是否存在死锁，如果检测到，则采取相应的措施解除死锁。

十、线程安全的数据结构

在多线程编程中，使用线程安全的数据结构能够简化同步的工作。例如，C++11引入了std::atomic和std::mutex，同时提供了std::shared_mutex用于读写锁。
以下是一个简单的使用std::shared_mutex的示例：

#include <iostream>
#include <shared_mutex>
#include <vector>
#include <thread>

std::vector<int> shared_vector;
std::shared_mutex my_mutex;

void read_function(int id) 
{
    std::shared_lock<std::shared_mutex> lock(my_mutex);
    std::cout << "Reader " << id << ": " << shared_vector.size() << " elements" << std::endl;
}

void write_function(int id)
 {
    std::unique_lock<std::shared_mutex> lock(my_mutex);
    shared_vector.push_back(id);
}

int main() 
{
    std::vector<std::thread> threads;

    for (int i = 0; i < 5; ++i) 
    {
        threads.emplace_back(read_function, i);
        threads.emplace_back(write_function, i);
    }
    for (auto& thread : threads) 
    {
        thread.join();
    }
    return 0;
}

十一、可重入锁与递归锁

可重入锁允许同一线程多次获取同一把锁，而不会发生死锁。C++11中的std::recursive_mutex就是一种可重入锁。递归锁是一种特殊的可重入锁，允许同一线程多次获取锁，但需要相同次数的解锁操作。
以下是一个使用std::recursive_mutex的示例：

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

std::recursive_mutex my_mutex;

void recursive_function(int depth) 
{
    std::lock_guard<std::recursive_mutex> lock(my_mutex);
    if (depth > 0)
     {
        recursive_function(depth - 1);
    }
    std::cout << "Depth: " << depth << std::endl;
}

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

十二、 内存模型与原子性操作

在多线程编程中，理解内存模型和原子性操作是至关重要的。C++11引入了std::memory_order枚举类型，允许开发者指定原子操作的内存顺序。
以下是一个简单的使用原子操作的示例：

#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> shared_data(0);

void atomic_function()
 {
    shared_data.fetch_add(1, std::memory_order_relaxed);
}

int main() 
{
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) 
    {
        threads.emplace_back(atomic_function);
    }
    for (auto& thread : threads) 
    {
        thread.join();
    }
    std::cout << "Shared data: " << shared_data.load(std::memory_order_relaxed) << std::endl;
    return 0;
}

十三、性能优化与线程局部存储

性能优化是多线程编程中一个不可忽视的方面。线程局部存储（Thread Local Storage，TLS）允许每个线程拥有独立的变量实例，避免了线程间共享变量的性能开销。
以下是一个简单的使用线程局部存储的示例：

#include <iostream>
#include <thread>

thread_local int thread_local_data = 0;

void thread_function()
 {
    thread_local_data++;
    std::cout << "Thread local data: " << thread_local_data << std::endl;
}

int main() 
{
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i)
     {
        threads.emplace_back(thread_function);
    }
    for (auto& thread : threads) 
    {
        thread.join();
    }
    return 0;
}

总结

深入理解Linux多线程编程和资源同步是编写高性能、可靠多线程应用程序的关键。在选择合适的同步机制、处理死锁、使用线程安全的数据结构、了解原子操作和内存模型、进行性能优化等方面，都需要仔细考虑。同时，利用C++11及以上版本提供的多线程支持，能够更便捷地编写多线程程序。希望这些深入的内容能够帮助开发者更好地掌握多线程编程和资源同步的技术。
该文章参考Linux兵工厂公众号。

Render_me
关注
  • 21
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【Linux】线程（附源码）
weixin_64593595的博客
06-05 366
线程是轻量级的进程（LWP：light weight process），在Linux环境下线程的本质仍是进程。在计算机上运行的程序是一组指令及指令参数的组合，指令按照既定的逻辑控制计算机运行。操作系统会以进程为单位，分配系统资源，可以这样理解，进程是资源分配的最小单位，线程是操作系统调度执行的最小单位。特性进程线程地址空间进程有自己独立的地址空间多个线程共享同一个地址空间资源利用进程资源开销较大线程更加节省系统资源，效率较高独享资源每个线程有属于自己的栈区和寄存器（由内核管理）共享资源。
Linux多线程编程和资源同步详解
公众呺:Linux兵工厂, 加关+私信获取海量Linux干货资料和代码
02-02 902
在多线程编程中，除了使用锁和其他同步机制确保数据的一致性外，还应考虑性能优化的问题。例如，避免不必要的锁竞争、减小锁的粒度、使用无锁数据结构等都是提高多线程程序性能的重要手段。死锁是多线程编程中常见的问题，它指的是一组线程因争夺资源而陷入无限等待的状态。条件变量用于线程之间的通信和同步，它允许一个线程等待某个条件的发生，而其他线程可以在满足条件时通知等待的线程。线程池是一种管理和复用线程的机制，它可以有效地减少线程的创建和销毁开销。原子操作是不可中断的操作，能够确保在多线程环境中对共享数据的操作是原子的。
C++11 - thread多线程编程，线程互斥和同步通信，死锁问题分析解决
热门推荐
大秦坑王的专栏
04-01 1万+
c++11 thread线程库使用，线程互斥，互斥锁，死锁问题分析定位
Linux 多线程（附带线程池代码加注释）
原来45的博客
12-18 774
线程，进程，互斥，同步，生产者消费者模型，锁，信号量，可重入与线程安全，POSIX线程库，线程池代码加注释等
【C++ 多线程编程|并发编程】
weixin_41919587的博客
05-06 989
一个程序只有一个进程，该进程拥有至少一个线程。不同进程的地址空间不同，互不相关。同一进程下的不同线程共享同一个地址空间。C++11中引入了thread类和asyn函数来实现多线程。
Linux——线程同步（条件变量、POSIX信号量）和线程池
weixin_61857742的博客
02-15 937
thrmgr防止线程长期得不到调度的方式也很简单，当线程没有任务时，采用pthread_cond_timedwait函数阻塞等待，该函数第三个参数为设定的timespec时间类型结构体，当检测超时后自动停止阻塞并返回特定值，根据返回值就能判断线程是否是因为超时而停止阻塞，一旦判断超时，线程跳出等待任务的循环然后结束本线程。首先简单说一下什么是循环队列，本质就是长度固定的数组，从头开始插入资源，当插入资源位于最后一个位置的下一个时，再从头开始插入资源，也就是把线性的数组“头尾相连”，变成逻辑上的环形结构。
C++高性能服务器框架muduo，与配套书籍《Linux多线程服务端编程》解读
weixin_40355471的博客
12-10 659
muduo开源代码解析，多线程服务器模型，《Linux多线程服务端编程》阅读笔记，来自作者陈硕。
Linux多线程编程讲解之系列一
职场里拉开差距的不是知识，而是认知！
11-17 1221
Linux多线程概述 了解如何正确运用线程是每一个优秀程序员必备的素质。线程类似于进程。如同进程，线程由内核按时间分片进行管理。在单处理器系统中，内核使用时间分片来模拟线程的并发执行，这种方式和进程的相同。而在多处理器系统中，如同多个进程，线程实际上一样可以并发执行。 那么为什么对于大多数合作性任务，多线程比多个独立的进程更优越呢？这是因为，线程共享相同的内存空间。不同的线程可
Linux 多线程 Pthread 互斥量
Nick_Di的博客
06-17 573
阅读了《Unix/Linux系统编程》中关于Pthread的内容，并查阅相关资料，进行了总结 本文介绍了Pthread多线程基本操作与互斥量基本操作 1. POSIX和Pthread线程概念 1.1 POSIX： POSIX表示可移植操作系统接口（Portable Operating System Interface of UNIX，缩写为 POSIX ），POSIX标准定义了操作系统应该为应用程序提供的接口标准。 一般情况下，应用程序通过应用编程接口(API)而不是直接通过系统调用来编程(即并不需要和内核
linux_code.rar_linux 多线程_linux 线程_多线程编程
09-14
"linux_code.rar"这个压缩包包含了一些关于Linux多线程编程的源码示例，这对于初学者来说是一份宝贵的教育资源。 1. **线程概念**： 线程是操作系统分配处理器时间的基本单元，它是程序中的执行流。与进程相比，...
嵌入式Linux多线程编程.zip
09-06
在压缩包中的"第13章_Linux多线程编程"文件中，可能会包含具体的C语言源码示例，展示如何创建、管理线程，以及如何使用同步机制解决并发问题。通过学习这些示例，开发者可以更深入地理解如何在嵌入式Linux系统上进行...
linux上实现多进程和多线程实现同步互斥（源代码）
04-18
总结，Linux上的多进程和多线程编程涉及复杂的同步互斥操作，开发者需要理解各种同步机制，根据具体需求选择合适的方法。通过阅读和学习提供的源代码，可以加深对这些概念的理解，提升实际开发能力。
Linux多线程服务端编程：使用muduo C++网络库
08-17
《Linux多线程服务端编程：使用muduo C++网络库》主要讲述采用现代C++在x86-64 Linux上编写多线程TCP网络服务程序的主流常规技术，重点讲解一种适应性较强的多线程服务器的编程模型，即one loop per thread。...
POSIX API多线程程序设计中文版和源码
02-01
POSIX（Portable Operating System Interface）是为类Unix操作系统定义的一套标准接口，它包括了用于创建和管理多线程的...因此，这份资料对于希望在Linux或类Unix环境中进行多线程编程的开发者来说是一份宝贵的资源。
Linux：基础命令学习
最新发布
qq_55038440的博客
07-20 533
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
Linux中的环境变量
qhy850716的博客
07-17 422
我们思考这样一个问题：指令也是可执行程序，我们写好的编译好的c语言也是程序，为什么我们在执行c语言程序时要./a.out带上当前路径，而ls这种指令就不要带路径呢？这就是环境变量PATH的作用，Linux中存在一些全局设置，表明命令行解释器应该去哪个路径下寻找可执行程序。系统中的很多配置在我们登录Linux时就已经被加载到bash中了，也就是内存。
LINUX:懒汉单例模式线程池
W2155的博客
07-16 474
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
Linux多线程编程同步技术详解
"《Linux多线程编程手册》是一本深入讲解Linux系统下多线程编程的实用指南，由Sun Microsystems, Inc....《Linux多线程编程手册》是一本极具价值的参考资料，对于理解和掌握Linux平台上的多线程编程具有重要意义。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值