多线程~~

已于 2023-03-19 10:00:39 修改
阅读量481 收藏
点赞数 1
分类专栏： Linux 文章标签： c++ 算法 c#
于 2023-03-12 22:05:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55895496/article/details/129343193
版权
本文介绍了多线程编程的基础知识，包括如何使用pthread库创建线程，线程的join和detach状态，以及线程信息的查看。接着，展示了生产者消费者模型的实现，利用条件变量协调生产者和消费者的同步。此外，讨论了信号量在资源管理中的应用，并给出了线程池的概念和简单实现。最后，提到了C++中的单例模式，用于确保类只有一个实例并提供全局访问点。
摘要由CSDN通过智能技术生成

多线程

在这里插入图片描述
编译时要链接上pthread库， gcc thread.c -o thread -l pthread

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

void *thread_entry(void*arg)//线程运行的函数
{
  while(1){
    printf("i am child thread:%s\n",arg);
    sleep(1);
  }
  return NULL;
}
int main()
{
  //int pthread_create(pthread_t * tid, pthread_attr_t * attr, void* (*routine)(void*), void *agr)
  pthread_t tid;
  char* arg="你好！";

  int ret=pthread_create(&tid,NULL,thread_entry,(void*)arg);
  if(ret!=0)
  {
    printf("pthread create error!\n");
    return -1;
  }
  //线程一旦创建成功了，创建成出来的线程调度的是传入的线程入口函数，
  while(1)
  {
    printf("i am a main thread\n");
    sleep(1);
  }
  return 0;
}

带信息头的查看线程信息
ps -efL | head -n 1 && ps -efL|grep thread

pthread_exit
在这里插入图片描述

pthread_cancel
在这里插入图片描述
更详细的线程信息
ps -efL -l | head -n 1 && ps -efL -l | grep thread

在这里插入图片描述
等待：等待指定线程退出，获取退出返回值，回收未被完全释放的资源
在线程中，有个分离属性，默认值是joinable状态，表示线程退出后不会自动释放所有资源，需要被其他线程等待
pthread_join
等待线程指定的线程终止
在这里插入图片描述
分离：将线程的分离属性社会为detach，表示线程退出后自动释放所有资源，则这种线程退出后不需要被等待（不关心其返回值时采用）
pthread_detach
分离一个线程
在这里插入图片描述

在这里插入图片描述

生产者消费者模型

在这里插入图片描述
Product_and_consumer.cpp

#include<iostream>
using namespace std;
#include<pthread.h>
#include<queue>
template<class T>
class BlockQueue{
  public:
    BlockQueue(int capacity):_capacity(capacity){
      pthread_mutex_init(&_mutex,NULL);
      pthread_cond_init(&_cond_pro,NULL);
      pthread_cond_init(&_cond_con,NULL);
    };
    ~BlockQueue(){
      pthread_mutex_destroy(&_mutex);
      pthread_cond_destroy(&_cond_pro);
      pthread_cond_destroy(&_cond_con);
    };
    bool Push(const T & data){//push是生产者线程运行的
      pthread_mutex_lock(&_mutex);
      while(_capacity==_q.size()){//容量达到队列上限就要停止生产，唤醒消费者线程
        pthread_cond_wait(&_cond_pro,&_mutex);//阻塞生产者进程

      }
      _q.push(data);
      cout<<"+++++"<<pthread_self()<<"thread get data:"<<data<<endl;
      pthread_cond_signal(&_cond_con);//唤醒消费者进程
      pthread_mutex_unlock(&_mutex);

    };
    bool Pop(T* data){
      pthread_mutex_lock(&_mutex);
      while(_q.empty()){
        pthread_cond_wait(&_cond_con,&_mutex);
      }
      *data=_q.front();
      _q.pop();

      cout<<"-----"<<pthread_self()<<"thread get data:"<<*data<<endl;
      pthread_cond_signal(&_cond_pro);
      pthread_mutex_unlock(&_mutex);
    };
  private:
    queue<T> _q;
    int _capacity;
    pthread_mutex_t _mutex;//互斥锁
    pthread_cond_t _cond_pro;//生产者同步变量
    pthread_cond_t _cond_con;//消费者:
};

#define MAX_USER 4
void * consumer(void* arg)
{
  BlockQueue<int> *q=(BlockQueue<int> *)arg;
  while(1){
    int data;
    q->Pop(&data);
  }

  return NULL;
}

void * productor(void* arg)
{
  BlockQueue<int> *q = (BlockQueue<int> *)arg;
  int data=0;
  while(1){
    q->Push(data++);
  }
  return NULL;
}

int main()
{
  BlockQueue<int> q(5);
  pthread_t cond_tid[MAX_USER],pro_tid[MAX_USER];
  int ret;
  for(int i=0;i<MAX_USER;i++){
    ret=pthread_create(&cond_tid[i],NULL,consumer,(void*)&q);
    if(ret!=0){
      std::cout<<"pthread_create error\n";
      return -1;
    }
    ret=pthread_create(&pro_tid[i],NULL,productor,(void*)&q);
    if(ret!=0){
      std::cout<<"pthread_create error\n";
      return -1;
    }
  }
  for(int i=0;i<MAX_USER;i++){
    pthread_join(cond_tid[i],NULL);
    pthread_join(pro_tid[i],NULL);
  }
  return 0;
}

信号量

在这里插入图片描述
在这里插入图片描述

#include<iostream>
#include<vector>
#include<pthread.h>
#include<semaphore.h>

template<class T>
class RingQueue{
  private:
    std::vector<int> _arr;
    int _read_step;
    int _write_step;
    int _capacity;
    sem_t _sem_data;
    sem_t _sem_idle;
    sem_t _sem_lock;
  public:
    RingQueue(int capacity):_capacity(capacity),_arr(capacity),_read_step(0),_write_step(0){
      sem_init(&_sem_idle,0,capacity);
      sem_init(&_sem_data,0,0);
      sem_init(&_sem_lock,0,1);
    }
    ~RingQueue(){
      sem_destroy(&_sem_idle);
      sem_destroy(&_sem_data);
      sem_destroy(&_sem_lock);
    }
    bool Push(const T& data){
      sem_wait(&_sem_lock);
      sem_wait(&_sem_idle);
      _arr[_write_step]=data;
      _write_step=(_write_step+1)%_capacity;
      sem_post(&_sem_data);
      sem_post(&_sem_lock);
      return true;
    }
    bool Pop(T* data){
      sem_wait(&_sem_lock);
      sem_wait(&_sem_data);
      *data=_arr(_read_step+1)%_capacity;
      sem_post(&_sem_idle);
      sem_post(&_sem_lock);
      return true;
    }

};

线程池

在这里插入图片描述

template<class T>//线程池只是一个执行流的池子，本身并不知道一个任务该如何处理，因此设计一个任务类
class ThreadTask{
	private:
		T _data;//处理的数据
		std::function<void(T)> _handler;//任务处理方法
	public:
		void start(){ return _handler(_data) }; 
};
class ThreadPool{
	private:
		int _max_thread;//线程的数量
		BlockQueue< ThreadTask<T> > _queue;
	public:
		ThreadPool(){//完成线程的创建}
		bool Push(ThreadTask<T> & task);
};


//
// Created by AIERXUAN on 2023/3/11.
//
#include <iostream>
#include<queue>
#include <functional>
#include <utility>
#include<unistd.h>
#include<pthread.h>

#define MAX_QUEUE 5;

using namespace std;

template<class T>
class BlockQueue {
private:
    queue<T> _q;
    int _capacity;//队列容量限制
    pthread_mutex_t _mutex;
    pthread_cond_t _cond_pro;
    pthread_cond_t _cond_con;
public:
    BlockQueue(int capacity):_capacity(capacity){
            pthread_mutex_init(&_mutex, nullptr);
            pthread_cond_init(&_cond_pro, nullptr);
            pthread_cond_init(&_cond_con, nullptr);
    }

    ~BlockQueue() {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond_pro);
        pthread_cond_destroy(&_cond_con);
    }

    void Push(const T &data) {//生产者，队满停止生产
        pthread_mutex_lock(&_mutex);
        while (_capacity == _q.size()) {
            pthread_cond_wait(&_cond_pro, &_mutex);
        }
        _q.push(data);
        pthread_cond_signal(&_cond_con);
        pthread_mutex_unlock(&_mutex);
    }

    void Pop(T *data) {//出队操作，消费者，队不空才可以出队，队空阻塞唤醒生产者
        pthread_mutex_lock(&_mutex);
        while (_q.empty()) {
            pthread_cond_wait(&_cond_pro, &_mutex);
        }
        *data = _q.front();
        _q.pop();
        pthread_cond_signal(&_cond_pro);
        pthread_mutex_unlock(&_mutex);
    }
};

template<class T>
class ThreadTask {

public:
    using Handler = function<void(T)>;
    /*等价于 Handler = std::funtional<void (T)> ;  定义了一个函数类型*/

    ThreadTask() = default;

    ThreadTask(const T &data, Handler handler) : _data(data), _handler(std::move(handler)) {}

    void Start() {
        return _handler(_data);
    }

private:
    T _data{};
    Handler _handler;
};

template<class T>
class ThreadPool {
private:
    int _thread_max;
    BlockQueue<ThreadTask<T>> _queue;//线程安全的任务队列
    vector<pthread_t> _tid;//保存所有线程的tid
private:
    static void *thread_entry(void *arg) {//循环从任务队列中取出任务调用的Start接口进行任务处理
        auto *pool = (ThreadPool *) arg;
        while (1) {
            ThreadTask<T> task;
            pool->_queue.Pop(&task);//无效的静态成员函数中访问了非静态成员变量
            task.Start();
        }
        return nullptr;
    }

public:
    //完成创建指定数量的线程
    ThreadPool(int thread_max, int queue_max) : _thread_max(thread_max), _queue(queue_max) {
        int ret;
        pthread_t tid;
        for (int i = 0; i < thread_max; ++i) {
            ret = pthread_create(&tid, nullptr, thread_entry, this);
            if (ret != 0) {
                cout << "create thread failed!\n";
                exit(-1);
            }
        }
    }

    bool Push(ThreadTask<T> &task) {//任务入队
        _queue.Push(task);
        return true;
    }
};

void print_test(int data) {
    printf("%llu thread ,run data:%d\n",pthread_self(),data);
    sleep((data % 3) + 1);
}


int main() {
    ThreadPool<int> pool(5, 10);
    for (int i = 0; i < 10; ++i) {
        ThreadTask<int> task(i, print_test);
        pool.Push((task));
    }
    sleep(10);
    return 0;
}

单例模式

Ensure a class has only one instance and provide a global point of access to it.
确保类只有一个实例，并提供对它的全局访问点。

#include <iostream>
#include <mutex>

using namespace std;

//class Singleton {//饿汉模式
//private:
//    string _data;
//private:
//    static Singleton _eton;//静态成员
//
//    Singleton() {//构造函数私有化，类外无法实例化对象，保证一个类只能实例化一个对象
//        _data = “饿汉”;
//    }
//
//public:
//    string get_data() { return _data; }
//
//    static Singleton *GetInstance() {
//        return &_eton;
//    }
//};
//
//Singleton Singleton::_eton;//静态变量在类外定义


class Singleton {
private:
    string _data="懒汉";
    static Singleton *_eton;
    static std::mutex _mutex;
public:
    string get_data() { return _data; }

    static Singleton *GetInstance() {
        if (_eton == NULL)
            _mutex.lock();//保证实例化过程的线程安全问题，
        if (_eton == NULL) {
            _eton = new Singleton;
        }
        _mutex.unlock();
        return _eton;
    }
};

Singleton *Singleton::_eton = nullptr;
std::mutex Singleton::_mutex;
int main() {
    Singleton *singleton = Singleton::GetInstance();
    std::cout << singleton->get_data() << std::endl;
    return 0;
}

总结

在这里插入图片描述

替换掉每行首的所有空格及数字

VIM底行模式下

:1,$s/^\s*[0-9]\s//g

解释：1为起始行号，315为终止行号，在正则中代表行首，\s*代表若干个空格，可以没有，[0-9]*代表若干个数字，可以没有，即将\s*[0-9]\s替换为NOTHING。

或者：

:%s/^…//g

沉默....后....的...爆发.
关注
专栏目录
Java多线程~~~ScheduledThreadPoolExecutor 计划任务类的使用
技术是我的毕生追求
09-26 8837
前面我们已经学习了使用ThreadPoolExecutor类来实现自动创建和运行线程。但是na'xie
Windows多线程控制台程序
m0_50377559的博客
07-05 2261
学习笔记 Windows多线程控制台程序目的：学习和掌握如何编写Windows多线程控制台程序。通过编写程序，加深对进程和线程关系的理解，掌握多线程程序的执行和编写技巧。设计要求：写一个单进程多线程的Windows控制台程序，该程序在一个进程内建立N个线程来执行指定的任务。N由命令行传递给系统。Win32控制台程序中，主函数的格式如：Void main(int argc,char *argv[])，可以获取命令行参数。通过VC++“工程/设置”的C/C++属性页设置应用程序为“MTD”多线程。利用win32
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
C#高级--多线程详解
李宥的博客
10-03 5万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
C#多线程详解
世界既不黑也不白，而是一道精致的灰。
08-11 3379
上下文切换（Context Switching）是多线程环境中的一种操作，指的是在一个 CPU 核心上切换正在执行的线程，从当前线程的执行上下文（包括寄存器状态、程序计数器等）切换到另一个线程的执行上下文, 线程的切换需要额外的开销，因此在某些情况下，过多的线程可能会导致性能下降。因此，在设计多线程应用程序时，需要考虑如何减少上下文切换的发生，以提高程序的执行效率。是用于实现线程同步的一种机制，用于保护共享资源，避免竞态条件。上下文切换开销指的是从一个线程切换到另一个线程的过程中所涉及的时间和资源开销。
Java多线程并发
hohpower_wangJun的博客
10-25 629
多线程并发 什么是并发编程 并发历史: 早期计算机–从头到尾执行一个程序，资源浪费 操作系统出现–计算机能运行多个程序，不同的程序在不同的单独的进程中运行 一个进程，有多个线程 提高资源的利用率，公平 串行与并行的区别 串行：洗茶具、打水、烧水、等水开、冲茶 并行：打水、烧水同时洗茶具、水开、冲茶 好处：可以缩短整个流程的时间 并发编程目的 摩尔定律：当价格不变时，集成电路上可容纳的元器件的数目，约每隔18-24个月便会增加一倍，性能也将提升一倍。这一定律揭示了信息技术进步的速度。 让程序充分利
多线程结果集合并
延陵缥缈的博客
03-01 2624
package com.yanling.executor; import java.util.ArrayList; import java.util.Iterator; import java.util.Random; import java.util.concurrent.*; public class ExecutorServiceDemo { public static void main(String[] args) { ExecutorServic...
多线程原理及简单介绍
weixin_50205795的博客
09-05 4315
多线程原理和理解 （集合了一波别人的专业术语和自己的代码） 什么是多线程： · 在一个程序中，一些独立运行的程序片断叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。 多线程的基础原理 · 多线程是为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。线程是在同一时间需要完成多项任务的时候实现的。 线程 · 每个正在系统上运行的程序都是一个...
Redis 多线程
凝神遐想的博客
12-28 5650
在Redis 6.0中，非常受关注的第一个新特性就是多线程。这是因为，Redis一直被大家熟知的就是它的单线程架构，虽然有些命令操作可以用后台线程或子进程执行（比如数据删除、快照生成、AOF重写）。但是，从网络IO处理到实际的读写命令处理，都是由单个线程完成的。 随着网络硬件的性能提升，Redis的性能瓶颈有时会出现在网络IO的处理上，也就是说，单个主线程处理网络请求的速度跟不上底层网络硬件的速度。为了应对这个问题，一般有两种方法。 第一种方法是，用用户态网络协议栈（例如DPDK）取代内核网络协议栈，让网络
C++多线程以及线程池
梦的灰色边沿...
06-10 5374
1 线程 1.1 简介   线程（英语：thread）是操作系统能够进行运算调度的最小单位。大部分情况下，它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。   同一进程中的多条线程将共享该进程中的全部系统资源
Linux多线程服务端编程，高清无水印！~
03-05
Linux多线程服务端编程，高清无水印！~
python3爬虫中多线程的优势总结
01-19
有些小伙伴跟小编讨论了python中使用多线程原理的问题，就聊到了关于python多线程的弊端问题，这点可能在使用的过程中大家会能感觉到。而且之前讲过的GIL也是对python多线程的一种限制。那么，我们为什么还要用多...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
Qt界面多线程opencv调用摄像头
05-09
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论...
STL set
最新发布
hls0611的博客
11-09 120
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 80
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
C 学习（4）
search7的博客
11-05 768
C语言学习，每个模块来自工作中的？？？
常用的c++特性--＞day02
m0_69093426的博客
11-06 535
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
Windows多线程编程指南
"这份资料详细介绍了Windows环境下的多线程编程，包括Win32 API和MFC两种方式，以及线程间通信和线程同步的关键概念。适合初学者理解和实践多线程技术。" 在Windows操作系统中，多线程编程是解决程序执行效率和响应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值