linux多线程

已于 2023-12-14 12:09:31 修改
阅读量47 收藏
点赞数
文章标签： linux 运维 服务器
于 2023-12-14 12:08:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53911216/article/details/134827816
版权

前置知识

堆区开辟空间原理

内存分割

1.exe就是一个文件

2.可执行程序是按照地址空间方式进行编译的

3.可执行程序是按照区域被划分为4KB为单位

结论：物理内存中的每个4KB的分格叫做页框，而磁盘中被分割成了4KB每个格子，那么加载进去是正好对应的，os中也要管理100w+个4KB，同样是先描述再组织。每次加载4KB的时候都会造成缺页中断，而用户却感觉不到，因为对用户是透明的。

虚拟到物理地址的转化

虚拟地址如何转到物理地址呢？那么可以地址编号32位后10位为1级页表，中间10位为2级页表，前面12位刚好为2^10=1024B=1KB再✖️4🟰4KB刚好和页框的大小相同，有多少那么就偏移多少位，所以前12位为页内偏移。

线程概念

这里的每个task_struct都可以称之为线程，这是linux特有的方案，通过一定的技术手段，将当前的资源，以一定的方式划分给不同的task_struct

用户视角：

进程=内核数据结构+该进程对的代码和数据

内核视角：

进程=承担分配系统资源的基本实体

线程在进程内部执行，是os调度的基本单位

线程在进程的地址空间内运行，cpu只关心pcb，不关心执行流水进程还是线程

进程vs线程

内部只有一个执行流的进程叫做进程，内部有多个执行流的进程叫做线程

在cpu视角中，只认task_struct,linux下的线程统称为轻量级进程，linux中说没有真正意义上的线程结构，linux用进程模拟的线程，但是linux中有原生线程库pthread

pthread_create

顾名思义创建线程

 线程demo

只要创建了线程 那么就会抢占式的并发或者并行的执行

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<cstdlib>
#include<string>
using namespace std;

void* threadrun(void* arg){
const string s=(char*)arg;
    while(true){
        cout<<"string:"<<s<<" pid:"<<getpid()<<endl;
        sleep(1);
    }
}
int main(){
    pthread_t tid[5];
    char name[64];
    for(int i=0;i<5;i++){
        snprintf(name,sizeof name,"%s-%d","thread",i);
        pthread_create(tid+i,nullptr,threadrun,(void*)name);
        cout<<endl;
        sleep(1);
    }
    while(true){
        cout<<"main thread,pid:"<<getpid()<<endl;
        sleep(3);
    }

    return 0;
}

 查看线程数量

 线程如何看待进程资源

线程中栈和寄存器是私有的，因为这代表了线程的动态属性

为什么线程切换成本更低？

首先，地址空间和页表不需要切换，cpu中有L1-L3级cache缓存，根据局部性原理对代码和数据进行预读。而进程切换需要更换cache中的预读数据，每次更换之前的数据就失效了，所以线程更有优势！

线程控制

pthread_join

pthread_join就是阻塞式等待，如果副进程不执行完毕，那么主进程就一直在这里可以不走。

 代码验证

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

using namespace std;

void* pthread_routine(void* arg){
    int i=3;
    while(true){
        cout<<"this is new pthread---"<<(char *)arg<<" "<<getpid()<<endl;
        sleep(1);
        i--;
        if(i==0){
            break;
        }
    }

    return (void*)10;
}
int main(){
        pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    void* ret=nullptr;
    pthread_join(tid,&ret);
     cout<<"ret:"<<(long long)ret<<endl;

return 0;
}

 线程异常

一旦线程异常，都可能导致整个进程整体退出。因为线程可以相当于进程的子集，进程异常了，那么线程可以认为也是异常的

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

using namespace std;

void* pthread_routine(void* arg){
    int i=3;
    while(true){
        cout<<"this is new pthread---"<<(char *)arg<<" "<<getpid()<<endl;
        sleep(1);
       
       int i=100;
       i/=0;
    }

    return (void*)10;
}
int main(){
        pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    void* ret=nullptr;
    pthread_join(tid,&ret);
    cout<<"ret:"<<(long long)ret<<endl;


return 0;
}

 可以看到浮点数异常退出。

retval

pthread_join中第二个参数retval,可以看到是一个二级指针，那么这个参数必定是一个一级执政传过来的，这个参数就是线程回调函数的返回值。

这个返回值可返回类型很多，如nullptr，常量，变量，数组等

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

using namespace std;

void* pthread_routine(void* arg){
        int *arr=new int[10];
        cout<<"this is new pthread---"<<(char *)arg<<" "<<getpid()<<endl;
            for(int i=0;i<10;i++){
                arr[i]=i;
            }
    return (void*)arr;
}
int main(){
        pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    int* ret=nullptr;
    pthread_join(tid,(void**)&ret);
    for(int i=0;i<10;i++){
       
      cout<<ret[i]<<" ";
    }
    cout<<endl;

return 0;
}

 由于这里是栈上所以要在堆区开辟出一块空间存放数据，否则可能会由于栈失效导致数据异常。

终止线程

pthread_exit

线程退出的一种方法

 线程如果正常结束退出码为1，循环中结束退出码为13

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

using namespace std;

void* pthread_routine(void* arg){
        int i=5;
        while(true){
    cout<<"this is new pthread---"<<(char *)arg<<" "<<getpid()<<endl;
        i--;
        sleep(1);
        if(i==0){
            pthread_exit((void*)13);
        }
       }          
        cout<<"this is new pthread end"<<endl;    
    return (void*)1;
}
int main(){
        pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    void* ret=nullptr;
    pthread_join(tid,&ret);
    cout<<"ret:"<<(long long)ret<<endl;
return 0;
}

显然这里走的是pthread_exit函数 。

pthread_cancel

五秒后pthread_cancel关闭副线程

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

using namespace std;

void* pthread_routine(void* arg){
        while(true){
        cout<<"this is new pthread---"<<(char *)arg<<" "<<getpid()<<endl;
        sleep(1);
        }             
    return (void*)1;
}
int main(){
        pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    void* ret=nullptr;
    int i=5;
    while(true){
        cout<<"this is main pthread"<<endl;
        sleep(1);
        i--;
        if(i==0){
            break;
        }
    }
    pthread_cancel(tid);
    pthread_join(tid,&ret);
    cout<<"ret:"<<(long long)ret<<endl;
return 0;
}

 这里线程被取消，join的时候ret为-1。

pthread_t

目前所使用的linux自带的创建线程接口是使用的pthread库中的接口，那么pthread_t定义出的变量到底是什么呢？先说结论，本质上是一个地址。

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

using namespace std;


void* pthread_routine(void* arg){
        int i=5;
        while(i--){
        cout<<"this is new pthread---"<<(char *)arg<<" "<<getpid()<<endl;
        sleep(1);
        }             
    return (void*)1;
}
int main(){

    pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    printf("%lu,%p\n",tid,tid);
    return 0;
}

 pthread_self

取自己线程号的函数

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

using namespace std;


void* pthread_routine(void* arg){
        int i=3;
     printf("%p\n",pthread_self());         
    return (void*)1;
}
int main(){

    pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    printf("%lu,%p\n",tid,tid);
   while(true)sleep(1);
    return 0;
}

 可以发现该self函数和tid的地址相同。

原理

主线程的代码存在栈区，而副线程存储在共享区。

 动态库加载到内存中，每次线程的使用就去动态库中调取里面的特定内容，而每个线程第一个地址就为tid也就是该tid的地址，往下还有一些局部存储变量，私有线程栈等。

__thread

__thread修饰全局变量，就是让每个线程各自拥有一个全局变量，这就是线性的局部存储

 加上后

线程下的全局替换

全局替换后就直接退出了进程，因为给进程全体都替换了。

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

using namespace std;

   __thread int a=100;
void* pthread_routine(void* arg){
        int i=3;
        execl("/bin/ls","ls",nullptr);
     while(true){
        cout<<"a:"<<a++<<endl;
        sleep(1);
     }      
    return (void*)1;
}
int main(){

    pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    while(true){
        cout<<"a:"<<a<<endl;
        sleep(1);
     }      
  
    return 0;
}

 pthtrad_detach

线程分离的作用就是自动回收子线程

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

using namespace std;

   int a=100;
void* pthread_routine(void* arg){
    pthread_detach(pthread_self());
        int i=3;
     while(true){
        cout<<"this is child pthread"<<endl;
        sleep(1);
        i--;
        if(i==0){
            break;
        }
     }      
    return (void*)1;
}
int main(){

    pthread_t tid;
    pthread_create(&tid,nullptr,pthread_routine,(void*)"pthread 1");
    int i=3;
    while(true){
        cout<<"this is main"<<(int *)pthread_self()<<endl;
        sleep(1);
        i--;
         if(i==0){
            break;
        }
     }      
  
    return 0;
}

线程互斥

订票问题中，当ticket数量大于0的时候才可以抢票，那么开几个线程去抢票。

#include<iostream>
#include<unistd.h>
#include<pthread.h>
#include<ctime>
#include<string>
using namespace std;

#define THREAD_NUM 5
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
int ticket=100;
void* pthread_routine(void* arg){
 
    while(true){
        // pthread_mutex_lock(&mutex);
        if(ticket>0){
            usleep(1000);
            cout<<(char*)arg<<":"<<ticket<<endl;
            ticket--;
            // pthread_mutex_unlock(&mutex);
        }else{
            // pthread_mutex_unlock(&mutex);
            break;
        }
    }

    return nullptr;
}
int main(){
    pthread_t tid[THREAD_NUM];
    for(int i=0;i<THREAD_NUM;i++){
        string* s=new string("thread-"+to_string(i));
        pthread_create(tid+i,nullptr,pthread_routine,(void*)s->c_str());
    }
    for(int i=0;i<THREAD_NUM;i++){
        pthread_join(tid[i],nullptr);
        cout<<tid[i]<<"quit"<<endl;
    }

    return 0;
}

可以发现最后的结果小于0也被输出了出来，这是由于cpu调度问题引起的。

pthread_mutex_lock和pthread_mutex_unlock

分别代表了线程中保护互斥安全问题，加锁和解锁函数

PTHREAD_MUTEX_INITIALITER

在进行全局使用锁的时候，那么可以直接申请锁，让锁的值等于该宏定义

 pthread_mutex_init和pthread_mutex_destory

如果锁不在全局使用，那么就要给锁进行初始化和销毁锁。

锁的原理

当线程A去做操作ticket--，那么翻译成汇编会执行三句指令，将ticket的值从内存取来放入cpu中，对ticket的值进行--，然后再将数值存入内存中。理论上这样是可行的，但是由于cpu采用的是均匀分配的调度算法，那么执行a线程的时候b线程可能就被调度过来执行了，这里b线程可能会将ticket的三步全部做完，然后再将a线程的操作拿过来继续做，那么这样可能刚刚ticket的操作就可能白做了。

锁的原理其实就是一条指令，不像ticket--需要执行三条指令，exchage或者swap都算是，所以这也叫做原子操作。如汇编伪代码所示lock就是将0给&%al，交换%al和上下文中的mutex的值（1），如果%al寄存器中的值大于0，那么就持有锁成功，否则就挂起等待，然后goto到lock继续等待锁的释放，unlock就是将1移入mutex中，这样其他线程就可以申请锁了。

        

 那么加锁可以有效的解决这种问题！

#include<iostream>
#include<unistd.h>
#include<pthread.h>
#include<ctime>
#include<string>
using namespace std;

#define THREAD_NUM 5
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
int ticket=100;
void* pthread_routine(void* arg){
    while(true){
        pthread_mutex_lock(&mutex);
        if(ticket>0){
            usleep(1000);
            cout<<(char*)arg<<":"<<ticket<<endl;
            ticket--;
            pthread_mutex_unlock(&mutex);
        }else{
            pthread_mutex_unlock(&mutex);
            break;
        }
    }

    return nullptr;
}
int main(){
    pthread_t tid[THREAD_NUM];
    for(int i=0;i<THREAD_NUM;i++){
        string* s=new string("thread-"+to_string(i));
        pthread_create(tid+i,nullptr,pthread_routine,(void*)s->c_str());
    }
    for(int i=0;i<THREAD_NUM;i++){
        pthread_join(tid[i],nullptr);
        cout<<tid[i]<<"quit"<<endl;
    }

    return 0;
}

 但是发现都是线程4调度，这是为什么呢？这是因为抢占式的原因，线程4刚释放资源，又锁上资源。就造就了这种情况。

为了解决这一问题可以使用一些延长时间的函数去模拟抢到票后的工作，让其他进程可以抢占该资源

#include<iostream>
#include<unistd.h>
#include<pthread.h>
#include<ctime>
#include<string>
using namespace std;

#define THREAD_NUM 5

int ticket=100;
class ThreadData{
    public:
        ThreadData(const string id,pthread_mutex_t* mutex)
        :_id(id),
        _mutex(mutex){}
public:
    string _id;
    pthread_mutex_t* _mutex;
};
void* getticket(void* arg){
    while(true){
        ThreadData* tid=(ThreadData*)arg;
        
        pthread_mutex_lock(tid->_mutex);
        if(ticket>0){
            usleep(1000);
            cout<<tid->_id<<":"<<ticket<<endl;
            ticket--;
            pthread_mutex_unlock(tid->_mutex);
        }else{
            pthread_mutex_unlock(tid->_mutex);
            break;
        }
        usleep(1000);
    }

    return nullptr;
}

int main(){
    pthread_mutex_t mutex;
  pthread_mutex_init(&mutex,nullptr);
    pthread_t t[THREAD_NUM];
    for(int i=0;i<THREAD_NUM;i++){
        const string s="pthread-"+to_string(i); 
          ThreadData* tid=new ThreadData(s,&mutex); 
        
    pthread_create(t+i,nullptr,getticket,(void*)tid);
       
    }
    for(int i=0;i<THREAD_NUM;i++){
        pthread_join(t[i],nullptr);
        cout<<t[i]<<"quit"<<endl;
    }
     pthread_mutex_destroy(&mutex);
    return 0;
}

互斥锁总结

1.加锁保护：加锁的时候，一定要保证加锁的粒度，越小越好。

2.加锁就是串行执行了吗？加锁了之后，线程在临界区中，是否会切换，会有问题吗？是的，就变成串行了，是会切换，但是由于原子性的体现，数据不会更改，所以没问题。

3.要访问临界资源，每一个线程都必须现申请锁，每一个线程都必须先看到同一把锁&&访问它，锁本身是不是就是一种共享资源？是的是共享资源。

4.谁来保证锁的安全呢？？所以，为了保证锁的安全，申请和释放锁，必须是 原子的！

线程同步

同步概念

由于上面的代码某个线程中存在一直申请锁，一直解锁的情况，导致其他线程一直申请不到资源，这不错，但是不合理，自己线程太疲劳，别的线程一直申请不到，这就造成别的线程饥饿问题。

所以就引入了同步，主要是解决访问临界资源合理性的问题，按一定的顺序就行临界资源访问，进而线程同步

方案1：条件变量

当我们申请临界资源前，先要做临界资源是否存在检测，检测的本质也是访问临界资源，所以临界资源的检测，也是一定要在加锁和解锁之间的。

有没有办法让我们线程检测到资源不就序的时候？

1.不要让线程频繁自己检测，等待阻塞线程

2.当条件就序的时候，通知等待的线程，让他们来进行资源申请和访问！

pthread_cond_init

初始化对应的条件变量

pthread_cond_destroy

销毁对应的条件变量

PTHREAD_COND_INITIALIZER

当使用全局环境变量的时候，那么就可以使环境变量直接等于该宏。

互斥和同步demo

#include<iostream>
#include <string>
#include <unistd.h>
#include <pthread.h>

using namespace std;

#define PTHREAD_NUM 4
typedef void(*func_t)(const string& name,pthread_mutex_t*& mutex, pthread_cond_t*& cond);

volatile bool quit=false;
class PthreadData{
    public:
        PthreadData(const string& name,func_t func,pthread_mutex_t* mutex, pthread_cond_t* cond)
        :_name(name),
        _func(func),
        _mutex(mutex),
        _cond(cond)
        {}
 public:
    string _name;
    func_t _func;
    pthread_mutex_t* _mutex;
    pthread_cond_t* _cond;
};


void fun1(const string& name,pthread_mutex_t*& mutex, pthread_cond_t*& cond){
        while(!quit){
            pthread_mutex_lock(mutex);
            pthread_cond_wait(cond,mutex);
           if(!quit) cout<<name<<"running --播放"<<endl;
            pthread_mutex_unlock(mutex);
        }
}


void fun2(const string& name,pthread_mutex_t*& mutex, pthread_cond_t*& cond){
     while(!quit){
            pthread_mutex_lock(mutex);
            pthread_cond_wait(cond,mutex);
         if(!quit)   cout<<name<<"running --下载"<<endl;
            pthread_mutex_unlock(mutex);
        }
}
void fun3(const string& name,pthread_mutex_t*& mutex, pthread_cond_t*& cond){
     while(!quit){
            pthread_mutex_lock(mutex);
            pthread_cond_wait(cond,mutex);
          if(!quit)  cout<<name<<"running --刷新"<<endl;
            pthread_mutex_unlock(mutex);
        }
}
void fun4(const string& name,pthread_mutex_t*& mutex, pthread_cond_t*& cond){
     while(!quit){
            pthread_mutex_lock(mutex);
            pthread_cond_wait(cond,mutex);
         if(!quit)   cout<<name<<"running --上传"<<endl;
            pthread_mutex_unlock(mutex);
        }
}

void* entry(void* arg){

    PthreadData* tid=(PthreadData*)arg;
    tid->_func(tid->_name,tid->_mutex,tid->_cond);
    delete tid;
    return nullptr;

}
int main(){
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    pthread_mutex_init(&mutex,nullptr);
    pthread_cond_init(&cond,nullptr);
    pthread_t tarry[PTHREAD_NUM];
    func_t farry[PTHREAD_NUM]={fun1,fun2,fun3,fun4};

    for(int i=0;i<PTHREAD_NUM;i++){
        string s="pthread-"+to_string(i);
        PthreadData* tid=new PthreadData(s,farry[i],&mutex,&cond);
        pthread_create(tarry+i,nullptr,entry,(void*)tid);

    }
    
    int cnt=4;
    sleep(2);
    while(cnt--){

        cout<<"running code.."<<cnt<<endl;
        // pthread_cond_broadcast(&cond);
        pthread_cond_signal(&cond);
        sleep(1);
    }
    std::cout << "ctrl done" << std::endl;
    quit = true;
    pthread_cond_broadcast(&cond);

    for(int i=0;i<PTHREAD_NUM;i++){
        pthread_join(tarry[i],nullptr);
        cout<<tarry[i]<<"quit"<<endl;

    }
    
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

 基于blockqueue cp模型

#include<iostream>
#include<pthread.h>
#include<queue>
using namespace std;
template<class T>
class BlockQueue{

public:
    BlockQueue(int capacity)
    :_capacity(capacity)
    {   //分别对锁和信号量进行初始化
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_full,nullptr);//判断是否为满
        pthread_cond_init(&_empty,nullptr);//判断是否为空
    }
    void push(T& in){
        pthread_mutex_lock(&_mutex);
        while(FUll())pthread_cond_wait(&_full,&_mutex);
        _bq.push(in);
        pthread_cond_signal(&_empty);//给空信号量发送信号
        pthread_mutex_unlock(&_mutex);
    } 

    void pop(){
        pthread_mutex_lock(&_mutex);
        while(Empty())pthread_cond_wait(&_empty,&_mutex);
        _bq.pop();
        pthread_cond_signal(&_full);//给满信号量发信号
        pthread_mutex_unlock(&_mutex);
    }
    int front(){
        return _bq.front();
    }

       ~BlockQueue()
    {   //分别对锁和信号量进行销毁
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_full);
        pthread_cond_destroy(&_empty); 
    }
private:
    bool Empty(){
        return _bq.size()==0;
    }
    bool FUll(){
        return _bq.size()==_capacity;
    }
private:
    queue<T> _bq;
    int _capacity;
    pthread_mutex_t _mutex;
    pthread_cond_t _full;
    pthread_cond_t _empty;

};
#include"BlockQueue.hpp"
#include<unistd.h>
#include<time.h>
void* consumer(void* arg){
    BlockQueue<int>* bq=(BlockQueue<int>*)arg;
  while(true){  
    cout<<"this is consumer,i will get a data"<<bq->front()<<endl;
    bq->pop();
    sleep(2);
    }


return nullptr;
}

void* producotr(void* arg){

 BlockQueue<int>* bq=(BlockQueue<int>*)arg;
 
  int flag=10;
  while(flag--){  
     int x=rand()%100;
  int y=rand()%50;
    int z=x+y;
    bq->push(z);
    cout<<"this is productor i will calculate:"<<x<<"+"<<y<<"?"<<endl;
    
    }

return nullptr;

}
int main(){
    srand(time(nullptr)%getpid());
    BlockQueue<int> *bq=new BlockQueue<int>(5);

    pthread_t con[2];
    pthread_t pro[2];
   
    pthread_create(pro,nullptr,producotr,(void*)bq);
       pthread_create(pro+1,nullptr,producotr,(void*)bq);
    pthread_create(con,nullptr,consumer,(void*)bq);
    pthread_create(con+1,nullptr,consumer,(void*)bq);
    
    pthread_join(con[0],nullptr);
    pthread_join(con[1],nullptr);
    pthread_join(pro[0],nullptr);
    pthread_join(pro[1],nullptr);
    delete bq;

    return 0;
}

锁的封装

#pragma once
#include<iostream>
#include<pthread.h>


class Mutex{

public:
    Mutex(pthread_mutex_t* mutex):_mutex(mutex){}
        
   void lock(){
    
      pthread_mutex_lock(_mutex);
        std::cout<<"加锁"<<std::endl;
    }
    void unlock(){
        pthread_mutex_unlock(_mutex);
        std::cout<<"解锁"<<std::endl;
    }
    ~Mutex(){
    }
private:
    pthread_mutex_t* _mutex;

};
class lockGuard{
   public:
    lockGuard(pthread_mutex_t* mtx):_mtx(mtx)
    {
        _mtx.lock();
    }
    ~lockGuard(){
        _mtx.unlock();
    }
private:
    Mutex _mtx;
};

线程池实现

龚超宇/demo - Gitee.com

Gong_Jason.
关注
Linux多线程
GG_Bruse的博客
02-13 8500
之前提到每个线程都有独占的栈，其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是在共享区中开辟的。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计管理模块，而是直接复用了进程控制块，即Linux中的所有执行流都是轻量级进程。Linux系统中不提供真正的线程ID，只提供LWP，即操作系统只需通过LWP对轻量级进程进行管理，而供用户使用的线程接口等其他数据，由线程库来管理，因此管理线程时的"先描述，再组织"就应该在线程库中完成。
Linux多线程概念及实现
向未来❀去探索 的博客
07-01 1994
Linux多线程概念及实现
Linux 多线程原理深剖
热门推荐
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
Linux多线程编程
C_Trip的博客
11-19 3859
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
深入理解Linux多线程
qq_49613557的博客
12-11 2815
深入理解Linux多线程 目录Linux线程概念什么是线程二级页表线程的优点线程的缺点线程异常线程用途Linux进程VS线程Linux线程控制POSIX线程库创建线程终止线程等待线程 Linux线程概念 什么是线程 1、在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列” 2、一切进程至少都有一个执行线程 3、线程在进程内部运行，本质是在进程地址空间内运行 4、在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化 5、透过进程虚拟地址空间
Linux多线程——概念
weixin_57023347的博客
09-22 1782
前言 Linux系统中并没有真正意义上的多线程，因为linux内核中并没有为线程构建数据结构。它的线程使用进程来模拟的。 一.线程的概念 1.1 什么是线程 现在再理解进程：进程是承担分配系统资源的基本实体 线程是进程里的一个执行流，CPU调度的基本单位是线程。就比如上图的一个tast_struct就是一个线程。它们共用一个进程地址空间。一个进程可以有一个或者多个执行流。 由于在Linux中没有真正意义上的线程，...
Linux多线程编程常用接口函数
jue_1xin的专栏
10-06 1851
一个进程可以包含多个线程，这些线程共享相同的代码(即应用程序的代码)、数据(包括全局变量、函数内的静态变量、堆空间的数据等)、进程空间(操作系统分配给进程的内存空间)、文件描述符(各个线程打开的文件资源，也可以为所有线程所共享)，但每个线程都有自己的堆栈。
linux 多线程服务端编程 pdf,Linux 多线程服务端编程.pdf
weixin_42246401的博客
05-04 1338
Linux 多线程服务端编程.pdfLinuxmuduoC++(giantchen@)2012-09-30C++TCPC++ x86-64Linux TCPone loopper threadLinux nativemuduoC++IT 5C++muduo2 C++C++Primer 4W.Richard Stevens UNIX Sockets APIechoSockets• • UNIX...
Linux多线程 | 线程同步
大柳_的博客。
05-28 1393
文章目录前言主要介绍四种常用的线程同步方式以及相关的函数接口。一、线程同步二、同步方法1.互斥锁2.信号量3.条件变量4.读写锁总结 前言 主要介绍四种常用的线程同步方式以及相关的函数接口。 提示：以下是本篇文章正文内容，下面案例可供参考 一、线程同步 线程同步指的是当一个线程在对某个临界资源进行操作时，其他线程都不可以对这个资源进行操作，直到该线程完成操作，其他线程才能操作，也就是协同步调，让线程按预定的先后次序进行运行。线程同步的方法有四种：互斥锁、信号量、条件变量、读写锁。 二、同步方法 1.互斥锁
linux多线程编程.pdf
10-09
Linux多线程编程是操作系统中并发程序设计的一个重要领域，它允许开发者在同一程序中创建多个线程，以实现并行执行，从而提高程序的执行效率和响应能力。Linux下的多线程编程通常基于POSIX线程（pthread）库来实现，...
嵌入式软件开发技术：第5章 嵌入式Linux多线程编程.ppt
05-31
嵌入式Linux多线程编程 嵌入式Linux多线程编程是嵌入式系统开发中的一种重要技术，能够提高系统的效率和响应速度。本章节将详细介绍嵌入式Linux多线程编程的基本概念、线程的创建、同步和互斥、线程属性、多线程...
Linux多线程服务端编程，高清无水印！~
03-05
Linux多线程服务端编程，高清无水印！~
linux_code.rar_linux 多线程_linux 线程_多线程编程
09-14
"linux_code.rar"这个压缩包包含了一些关于Linux多线程编程的源码示例，这对于初学者来说是一份宝贵的教育资源。 1. **线程概念**： 线程是操作系统分配处理器时间的基本单元，它是程序中的执行流。与进程相比，...
Linux编辑/etc/fstab文件不当，不使用快照；进入救援模式
最新发布
feng68_的博客
11-14 443
如果遇到任何问题，您可能需要进一步的故障排除，比如检查文件系统的完整性或修复文件系统错误。1)当出现以下警告时不要慌，如果文件系统默认挂载为只读模式，将其重新挂载为读写模式就好了，应该是吧。您可以选择1继续，或者选择2以只读模式挂载文件系统，或者选择3跳过直接进入shell。后面加)， 把只读模式改成读写模式 ，然后ctrl+x重启。然后会出现一串红色的字，太快了，看不清，然后就重启成功了。如果您在虚拟控制台（VC）1或VC2中，可以使用。获取root权限，这样您就可以编辑。2）挂载根文件系统为读写模式。
【Linux】多线程（中）
Eristic0618的博客
11-14 821
本篇文章围绕Linux中的多线程展开讲解，包含线程互斥的概念、互斥量mutex和相关API、互斥量原理、重入和线程安全、死锁、线程同步和条件变量等内容
SimpleScreenRecorder, a screen recording tool for Linux
likecayon的博客
11-11 359
【代码】SimpleScreenRecorder, a screen recording tool for Linux。
gdb编译教程（支持linux下X86和ARM架构）
weixin_43246170的博客
11-12 240
5、我们先开始x86版本，这个比较简单，不需要配置交叉编译工具（当然前提是系统装了gcc和g++的环境啊）。将gdb文件拷贝到对应平台下，即可使用。（或者使用gdbserver远程调试）以上这些配置都是要跟在./configure后面的。3、解压，然后进入到目录下，打开当前目录的命令行窗口。2、下载完后拷贝到linux的x86系统。先清理下编译x86残留下的临时文件。6、限制我们来编译ARM版本。4、创建一个生成目录。我下载的8.2版本。
Linux ssh 基础教程
tangPHP的博客
11-13 765
SSH是一种安全协议，用作远程连接Linux服务器的主要手段。它通过生成远程shell提供基于文本的界面。连接之后，在本地终端中键入的所有命令都将发送到远程服务器并在那里执行，一般说ssh即openssh。OpenSSH（Open Secure Shell），是一套安全的网络工具，它在不安全的网络上提供加密通信。它主要用于安全远程登录、文件传输和其他安全网络服务。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值