Linux学习笔记——进程与线程篇

e只龙

已于 2024-09-05 15:43:03 修改

阅读量779

点赞数 28

文章标签：学习笔记

于 2024-08-28 21:45:59 首次发布

本文链接：https://blog.csdn.net/m0_64432298/article/details/141638284

版权

操作系统中经常提到进程与线程的概念，但是没有提及具体操作，故在搜集资料学习后写下这篇具体操作的笔记

进程

进程的基本概念

进程由程序段，堆，栈，进程控制块（PCB）组成，其中程序段又分为代码段，数据段和BSS（Block Started by Symbol）段。

堆栈和PCB操作系统中有提到过，不多赘述，代码段顾名思义存储了程序的代码，数据段则是存储程序中已经初始化的全局变量，BSS段则是指用来存放程序中未初始化的全局变量。

Linux环境下关于进程的命令

Windows环境下可以通过任务管理器来查看进程，Linux则是通过以下命令来查询进程

ps 查看系统进程快照，其后可跟以下可选参数：

-e：显示所有进程

-l：长格式显示更加详细的信息

-f 全部列出，通常和其他选项联用

top 查看进程动态信息

/proc 查看进程详细信息

jobs 查看后台进程

bg 将挂起的进程在后台运行

fg 把后台运行的进程放到前台运行

nice 按用户指定的优先级运行进程

renice 改变正在运行进程的优先级

创建子进程

在Linux环境下，我们运行某个程序即可创建进程，但是某个进程在运行时可以再次创建另一个进程，那么被创建的进程就被称为子进程，负责创建的进程被称为它的父进程。

子进程的创建

 #include  <unistd.h>

 //原型
 pid_t  fork(void);

 //示例

 pid_t  pid;

  if ((pid = fork()) < 0) {
     perror(“fork”);  
     return -1;
  }
  else  if (pid == 0) {
     printf(“child  process :  my pid  is %d\n”, getpid());
  }
  else {
     printf(“parent  process :  my pid  is  %d\n”, getpid());
  }

fork函数创建新的进程，失败时返回-1 ，成功时父进程返回子进程的进程号，子进程返回0。通过fork的返回值区分父进程和子进程。

子进程继承了父进程的内容父子进程有独立的地址空间，互不影响若父进程先结束子进程成为孤儿进程，被init进程收养子进程变成后台进程。若子进程先结束父进程如果没有及时回收，子进程变成僵尸进程

结束进程

#include  <unistd.h>
 
void  exit(int  status);

结束当前的进程并将status返回 exit结束进程时会刷新(流)缓冲区

进程回收

前文提到了僵尸进程，僵尸进程是指已经不再运行，但仍占用空间的进程。如果进程没有及时回收，就会产生僵尸进程

 #include <sys/wait.h>
  pid_t wait(int *status);

成功时返回回收的子进程的进程号；失败时返回EOF 若子进程没有结束，父进程一直阻塞若有多个子进程，哪个先结束就先回收 status 指定保存子进程返回值和结束方式的地址 status为NULL表示直接释放子进程PCB,不接收返回值。

示例

int status;
  pid_t pid;

  if ((pid = fork()) < 0) {
     perror(“fork”);  exit(-1);
  }
  else if (pid == 0) {
     sleep(1);  exit(2);
  }
  else {
     wait(&status);  printf(“%x\n”, status);

这个方法有一个问题：如果子进程未结束，父进程就会一直阻塞，为了解决这个问题，引入了另一个函数

 #include  <sys/wait.h>
  pid_t waitpid(pid_t pid, int *status, int option);

成功时返回回收的子进程的pid或0，失败时返回EOF

pid可用于指定回收哪个子进程或任意子进程

status指定用于保存子进程返回值和结束方式的地址

option指定回收方式，0 或 WNOHANG

线程

注意！使用pthread库时编译时候要加 -lpthread

由于进程在切换时系统开销大，很多操作系统引入了轻量级进程LW，同一进程中的线程共享相同地址空间。对于Linux而言不区分进程、线程

创建线程

#include  <pthread.h>
int  pthread_create(pthread_t *thread, const
         pthread_attr_t *attr, void *(*routine)(void *), void *arg);

成功返回0，失败时返回错误码
thread 线程对象
attr 线程属性，NULL代表默认属性
routine 线程执行的函数
arg 传递给routine的参数 ，参数是void * ，注意传递参数格式，

示例

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

void *testThread(void *arg){
    printf("This is a thread test,pid=%d,tid=%lu\n",getpid(),pthread_self());
   // return NULL;
    printf("input arg=%d\n",(int)arg);
    pthread_exit(NULL);
    printf("after pthread exit\n");
}
int main(){
    pthread_t tid;
    int ret;
    int arg = 5;
   
    ret = pthread_create(&tid,NULL,testThread,(void *)arg);

    printf("This is main thread,tid=%lu\n",tid);    
    sleep(1);
}

查看自身的pid

#include <pthread.h>
pthread_t pthread_self(void);

线程的结束，分离和回收

线程在创建之后，也要面临和进程一样的问题：结束和回收

结束

 void  pthread_exit(void *retval);

回收

 int  pthread_join(pthread_t thread, void **retval);

这种方法都不常用，因为分离是更为简单的做法

分离

int pthread_detach(pthread_t thread);    成功：0；失败：错误号
指

指定该状态，线程主动与主控线程断开关系。线程结束后不会产生僵尸线程

也可以在创建线程时或单独将线程属性设为分离

 pthread_attr_t attr;            /*通过线程属性来设置游离态（分离态）*/

设置线程属性为分离
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

同步与互斥

一旦有多任务，就少不了同步与互斥的手段，以下介绍几个常用和基础的锁。

互斥锁

创建互斥锁

#include  <pthread.h>
 int  pthread_mutex_init(pthread_mutex_t *mutex,
       const pthread_mutexattr_t *  attr);

成功时返回0，失败时返回错误码

mutex 指向要初始化的互斥锁对象

attr 互斥锁属性，NULL表示缺省属性

man 函数出现 No manual entry for pthread_mutex_xxx解决办法 apt-get install manpages-posix-dev

销毁互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex)

申请互斥锁

#include  <pthread.h>
 int  pthread_mutex_lock(pthread_mutex_t *mutex);
 int pthread_mutex_trylock(pthread_mutex_t *mutex)

成功时返回0，失败时返回错误码

mutex 指向要初始化的互斥锁对象

pthread_mutex_lock 如果无法获得锁，任务阻塞

pthread_mutex_trylock 如果无法获得锁，返回EBUSY而不是挂起等待

释放互斥锁

 #include  <pthread.h>
 int  pthread_mutex_unlock(pthread_mutex_t *mutex);

成功时返回0，失败时返回错误码

mutex 指向要初始化的互斥锁对象

执行完临界区要及时释放锁

读写锁

读写锁用于解决读者写者问题

初始化一个读写锁   pthread_rwlock_init
读锁定读写锁        pthread_rwlock_rdlock
非阻塞读锁定　　pthread_rwlock_tryrdlock
写锁定读写锁      pthread_rwlock_wrlock
非阻塞写锁定      pthread_rwlock_trywrlock
解锁读写锁         pthread_rwlock_unlock
释放读写锁         pthread_rwlock_destroy

条件变量

条件变量用于解决生产者消费者问题，当生产者生产资源时，条件变量增加：消费者使用资源时，条件变量减少

注意：条件变量必须和互斥锁（量）一起使用

int pthread_cond_wait(pthread_cond_t *restrict cond,
           pthread_mutex_t *restrict mutex);
//消费者无限等待条件变量

int pthread_cond_timedwait(pthread_cond_t *restrict cond,
           pthread_mutex_t *restrict mutex,
           const struct timespec *restrict abstime);
//有限时间等待条件变量

int pthread_cond_signal(pthread_cond_t *cond);
//发送条件变量信号，即生产者信号，唤醒至少一个线程
int pthread_cond_broadcast(pthread_cond_t *cond);
//唤醒所有等待此信号的消费者线程

对于生产者而言，在生产资源之前应该先获得互斥锁，以防止生产被打断

生产资源线程：
pthread_mutex_lock(&mutex);
开始产生资源
pthread_cond_sigal(&cond);    //通知一个消费线程
或者
pthread_cond_broadcast(&cond); //广播通知多个消费线程
pthread_mutex_unlock(&mutex);

对于消费者也是同理

pthread_mutex_lock(&mutex);
while （如果没有资源）{   //防止惊群效应
pthread_cond_wait(&cond, &mutex); 
}
有资源了，消费资源
pthread_mutex_unlock(&mutex);

如果pthread_cond_signal或者pthread_cond_broadcast 早于 pthread_cond_wait ，则有可能会丢失信号。

pthead_cond_broadcast 信号会被多个线程收到，这叫线程的惊群效应。所以需要加上判断条件while循环。

线程池

概念：

通俗的讲就是一个线程的池子，可以循环的完成任务的一组线程集合

必要性：

我们平时创建一个线程，完成某一个任务，等待线程的退出。但当需要创建大量的线程时，假设T1为创建线程时间，T2为在线程任务执行时间，T3为线程销毁时间，当 T1+T3 > T2，这时候就不划算了，使用线程池可以降低频繁创建和销毁线程所带来的开销，任务处理时间比较短的时候这个好处非常显著。

线程池的基本结构：

1 任务队列，存储需要处理的任务，由工作线程来处理这些任务

2 线程池工作线程，它是任务队列任务的消费者，等待新任务的信号

线程池的实现：

1.创建线程池的基本结构：

任务队列链表

typedef struct Task;

线程池结构体

typedef struct ThreadPool;

2.线程池的初始化：

pool_init()

{

创建一个线程池结构

实现任务队列互斥锁和条件变量的初始化

创建n个工作线程

}

3.线程池添加任务

pool_add_task

{

判断是否有空闲的工作线程

给任务队列添加一个节点

给工作线程发送信号newtask

}

4.实现工作线程

workThread

{

while(1){

等待newtask任务信号

从任务队列中删除节点

执行任务

}

5.线程池的销毁

pool_destory

{

删除任务队列链表所有节点，释放空间

删除所有的互斥锁条件变量

删除线程池，释放空间

}

示例

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

#define POOL_NUM 10
//任务队列
typedef struct Task{
    void *(*func)(void *arg);
    void *arg;
    struct Task *next;
}Task;

//线程池结构体
typedef struct ThreadPool{
    pthread_mutex_t taskLock;
    pthread_cond_t newTask;

    pthread_t tid[POOL_NUM];
    Task *queue_head;
    int busywork;

}ThreadPool;

ThreadPool *pool;
void *workThread(void *arg);
void *realwork(void *arg);

//线程池初始化
void pool_init(){
    pool = malloc(sizeof(ThreadPool));
    pthread_mutex_init(&pool->taskLock,NULL);
    pthread_cond_init(&pool->newTask,NULL);         //互斥量和环境变量的动态初始化
    pool->queue_head = NULL;
    pool->busywork=0;

    for(int i=0;i<POOL_NUM;i++){
        pthread_create(&pool->tid[i],NULL,workThread,NULL);//创建了十个线程
    }
}



//线程池添加任务
void pool_add_task(int arg){
    Task *newTask;
    
    pthread_mutex_lock(&pool->taskLock);
    while(pool->busywork>=POOL_NUM){
        pthread_mutex_unlock(&pool->taskLock);
        usleep(10000);
        pthread_mutex_lock(&pool->taskLock);
    }
    pthread_mutex_unlock(&pool->taskLock);
    

    newTask = malloc(sizeof(Task));
    newTask->func =  realwork;
    newTask->arg = arg;
    

    pthread_mutex_lock(&pool->taskLock);
    Task *member = pool->queue_head;
    if(member==NULL){
        pool->queue_head = newTask;
    }else{
       while(member->next!=NULL){
            member=member->next;
       }
       member->next = newTask;

    }
    pool->busywork++;
    pthread_cond_signal(&pool->newTask);

    pthread_mutex_unlock(&pool->taskLock);


}

void *realwork(void *arg){
    printf("Finish work %d\n",(int)arg);

}


//实现工作任务
void *workThread(void *arg){
    while(1){
        pthread_mutex_lock(&pool->taskLock);
        pthread_cond_wait(&pool->newTask,&pool->taskLock);

        Task *ptask = pool->queue_head;
        pool->queue_head = pool->queue_head->next;

        pthread_mutex_unlock(&pool->taskLock);

        ptask->func(ptask->arg);
        pool->busywork--;


    }


}


//线程池销毁
void pool_destory(){
    Task *head;
    while(pool->queue_head!=NULL){
        head = pool->queue_head;
        pool->queue_head = pool->queue_head->next;
        free(head);
    }

    pthread_mutex_destroy(&pool->taskLock);
    pthread_cond_destroy(&pool->newTask);
    free(pool);

}


int main(){
   pool_init();
   sleep(20);
   for(int i=1;i<=20;i++){
       pool_add_task(i);

   }

   sleep(5);
   pool_destory();

}