多线程~~

已于 2023-03-19 10:00:39 修改
阅读量448 收藏
点赞数 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库， 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

沉默....后....的...爆发.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
线程安全~
qq_45806560的博客
07-28 1141
线程安全问题的原因以及解决~~
多线程~~简单的线程创建,C语言实现
XD
04-24 3万+
线程，是计算机中最小的执行单元。通常，在window应用程序运行时，操作系统都会为其自动创建一个线程，即主线程。通过主线程，可以创建多个线程或进程。   使用多线程，可以提高程序的执行效率。   线程创建函数CreateThread（），属于API函数；   函数原型为： HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttr
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
C++多线程详细讲解
qq_45439571的博客
03-19 4万+
本文是纯转载，觉得大佬写的非常好！如有侵权可以删除 链接: link. C++多线程基础教程 目录 1 什么是C++多线程？ 2 C++多线程基础知识 2.1 创建线程 2.2 互斥量使用 lock()与unlock(): lock_guard(): unique_lock: condition_variable: 2.3 异步线程 async与future： shared_future 2.4 原子类型automic 实例 生产者消费者问题 4 C++多线程高级知识 4.1 线程池 线程池基础知识 线程池
万字图解Java多线程
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
SpringBoot--多线程处理
IT利刃出鞘的博客
07-31 1万+
本文介绍SpringBoot多线程处理的方案。
C# 多线程详细讲解
fenglearning的博客
05-27 2万+
C#多线程 一、基本概念 1、进程 首先打开任务管理器，查看当前运行的进程： 从任务管理器里面可以看到当前所有正在运行的进程。那么究竟什么是进程呢？ 进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。一个正在运行的应用程序在操作系统中被视为一个进程，进程可以包括一个或多个线程。 线程是操作系统分配处理器时间的基本单元，在进程中可以有多个线程同时执行代码。进程之间是相对独立的，一个进程无法访问另一个进程的数据（除非利用分布式计算方式）， 一个进程运
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的<pthread.h>，或者windows下的<windows.h> 。C++11提供了语言层面上的多线程，包含在头文件<thread>中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
C语言多线程
微小冷的学习笔记
03-19 8758
在C语言中创建线程方式如下 #include <pthread.h> pthread_create (thread, attr, start_routine, arg) 其中，thread为线程指针；attr为线程属性，默认NULL；start_routine为线程运行函数起始地址；arg为运行函数的参数。无参数时使用NULL。 如果线程成功创建，函数返回0，否则说明创建失败。 当线程完成工作后，若无需继续存在，则会调用pthread_exit函数。也就是说，这个函数可以显式地退出一个线程。
stm32单片机多线程实例
12-03
stm32单片机多线程实例
arduino 多线程
09-29
arduino 多线程 内附说明，用于处理复杂的逻辑，多个线程同时使用
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
Linux多线程服务端编程，高清无水印！~
03-05
Linux多线程服务端编程，高清无水印！~
c# window服务多线程实例
08-10
c# window服务多线程实例
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 981
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 134
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 661
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1094
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
python 多线程 多线程
08-26
关于Python的多线程，我可以为你提供一些信息。在Python中，可以使用`threading`模块来实现多线程编程。 多线程是指同时运行多个线程以实现并发执行的能力。Python中的多线程可以让程序在同一时间执行多个任务，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值