Linux 进程（终止、创建、僵尸进程、多进程与信号）

最新推荐文章于 2024-06-12 10:23:54 发布
最新推荐文章于 2024-06-12 10:23:54 发布
阅读量950 收藏 13
点赞数 29
分类专栏： Linux编程基础 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41885018/article/details/139091426
版权

Linux 进程

1. 进程终止

1.1 八种终止进程的情况

有8种方式可以中止进程，其中 5 种为正常终止，它们是：

  1. 在main()函数用return返回；
  2. 在任意函数中调用exit()函数；
  3. 在任意函数中调用_exit()或_Exit()函数；
  4. 最后一个线程从其启动例程（线程主函数）用return返回；
  5. 在最后一个线程中调用pthread_exit()返回；

异常终止有3种方式，它们是：

  1. 调用abort()函数中止；
  2. 接收到一个信号；
  3. 最后一个线程对取消请求做出响应。

1.2 进程终止的状态

在main()函数中，return的返回值即终止状态，如果没有return语句或调用exit()，那么该进程的终止状态是0。

在Shell中，查看进程终止的状态：echo $?

正常终止进程的3个函数（ exit() 和 _Exit() 是由 ISO C 说明的，_exit() 是由 POSIX 说明的 ）。

void exit(int status);
void _exit(int status);
void _Exit(int status);

status也是进程终止的状态。

如果进程被异常终止，终止状态为非0。 服务程序的调度、日志和监控

1.3 资源释放的问题

  1. retun 表示函数返回，会调用局部对象的析构函数，main() 函数中的 return 还会调用全局对象的析构函数。
  2. exit()表示终止进程，不会调用局部对象的析构函数，只调用全局对象的析构函数。
  3. exit()会执行清理工作，然后退出，_exit() 和 _Exit() 直接退出，不会执行任何清理工作。

例程：

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

struct AA
{
  string name;// 用于区分不同的对象
  AA(const string & str):name(str){
  }
  ~AA(){
    cout << name << "调用了析构函数\n" ; 
  }
};

AA a1("对象a1");  // 全局变量

int main(int argc,char *argv[])
{
  AA a2("对象a2"); // 局部变量
  return 0;
}
  • return 时候，两个对象都调用了析构函数
    在这里插入图片描述
  • 用exit(0)时候：只调用了全局变量的析构函数
    在这里插入图片描述
    在这里插入图片描述

1.4 进程的终止函数

进程可以用atexit() 函数登记终止函数（最多32个），这些函数将由exit()自动调用。

int atexit(void (*function)(void));

exit()调用终止函数的顺序与登记时相反。 进程退出前的收尾工作

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

void func1(){
  cout << "调用了func1()" << endl;
}

void func2(){
  cout << "调用了func2()" << endl;
}

int main(int argc,char *argv[])
{
  atexit(func1); // 登记第一个进程终止函数
  atexit(func2); // 登记第二个进程终止函数
  return 0;
  // exit(0);
  //_exit(1);

}
  • 第一种情况：return 0
    在这里插入图片描述
  • 第二种情况：exit(1) , 没有变化
    在这里插入图片描述
  • 第三种情况：_exit(1)： _exit()和_Exit()直接退出，不会执行任何清理工作
    在这里插入图片描述

2. 调用可执行程序

Linux提供了system()函数和exec函数族，在C++程序中，可以执行其它的程序（二进制文件、操作系统命令或Shell脚本）。

2.1 system()函数

system()函数提供了一种简单的执行程序的方法，把需要执行的程序和参数用一个字符串传给system()函数就行了。

函数的声明：
int system(const char * string); // 一般调用全路径

system()函数的返回值比较麻烦。

  1. 如果执行的程序不存在，system()函数返回非0；
  2. 如果执行程序成功，并且被执行的程序终止状态是0，system()函数返回0；
  3. 如果执行程序成功，并且被执行的程序终止状态不是0，system()函数返回非0。

2.2 exec函数族

exec函数族提供了另一种在进程中调用程序（二进制文件或Shell脚本）的方法。

exec函数族的声明如下：

int execl(const char *path, const char *arg, ...); // 重点1
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg,...,char * const envp[]);
int execv(const char *path, char *const argv[]); // 重点2
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],char *const envp[]);

注意：

  1. 如果执行程序失败则直接返回 -1，失败原因存于 errno 中。
  2. 新进程的进程编号与原进程相同，但是，新进程取代了原进程的代码段、数据段和堆栈。
  3. 如果执行成功则函数不会返回，当在主程序中成功调用exec后，被调用的程序将取代调用者程序，也就是说，exec函数之后的代码都不会被执行。
  4. 在实际开发中，最常用的是execl()和execv()，其它的极少使用。

3. 创建进程

3.1 Linux的0、1和2号进程

整个linux系统全部的进程是一个树形结构。

0号进程（系统进程）是所有进程的祖先，它创建了1号和2号进程。

1号进程（systemd）负责执行内核的初始化工作和进行系统配置。

2号进程（kthreadd）负责所有内核线程的调度和管理。

用pstree命令可以查看进程树（yum -y install psmisc）

pstree-p 进程编号

在这里插入图片描述

3.2 进程标识

每个进程都有一个非负整数表示的唯一的进程ID。虽然是唯一的，但是进程ID可以复用。

当一个进程终止后，其进程ID就成了复用的候选者。

Linux采用延迟复用算法，让新建进程的 ID 不同于最近终止的进程所使用的 ID 。这样防止了新进程被误认为是使用了同一ID的某个已终止的进程。

pid_t getpid(void);     // 获取当前进程的ID。
pid_t getppid(void);    // 获取父进程的ID。

3.3 fork()函数

一个现有的进程可以调用 fork()函数 创建一个新的进程。

pid_t fork(void);

由fork()创建的新进程被称为子进程。子进是父进程的副本，父进程和子进程都从调用fork()之后的代码开始执行。

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


int main(int argc,char *argv[])
{
  int bh = 12;
  string message = "这是一个进程";

  fork();
  cout << "程序执行编号:"<< bh << message << endl;
  sleep(20);
  cout << "程序结束" << endl;

  //return 0;
}
  • 执行代码，发现main里的内容，fork()后的cout都被执行了两次
    在这里插入图片描述
  • 运行的同时用命令观察进程： ps -ef |grep demo
    在这里插入图片描述
    fork()创建了子进程，7415是父进程，7416是子进程

fork()函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是子进程的进程ID。

  • 定义一个变量存储fork（）的返回值，观察是否不同
#include <iostream>
#include <unistd.h>
using namespace std;

int main(int argc,char *argv[])
{
  int bh = 12;
  string message = "这是一个进程";

  pid_t pid = fork(); // 定义一个变量存储fork（）的返回值
  
  cout << "pid = " << pid << endl;
  cout << "程序执行编号:"<< bh << message << endl;
}
  • 9392是父进程显示的，0是子进程显示的
    在这里插入图片描述
  • 所以我们可以利用这个fork()返回值不同的性质，让父进程和子进程执行不同的内容

例：

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

int main(int argc,char *argv[])
{
  int bh = 12;
  string message = "这是一个进程";
  pid_t pid = fork();
  if (pid > 0){
    // 父进程执行这段代码
    cout << "pid = " << pid <<"执行父进程代码" << endl;
  }else{
    // 子进程执行这段代码
    cout << "pid = " << pid <<"执行子进程代码" << endl;
  }
}

在这里插入图片描述

  • 子进程获得了父进程数据空间、堆和栈的副本（注意：子进程拥有的是副本，不是和父进程共享）。
    演示：
    更新代码，输出 &bh 和 &message
#include <iostream>
#include <unistd.h>
using namespace std;
int main(int argc,char *argv[])
{
  int bh = 12;
  string message = "这是一个进程";
  pid_t pid = fork();
  if (pid > 0){
    // 父进程执行这段代码
    cout << "pid = " << pid <<"执行父进程代码" << endl;
    cout << "&bh = " << &bh <<" &message = " << &message << endl;
  }else{
    // 子进程执行这段代码
    cout << "pid = " << pid <<"执行子进程代码" << endl;
    cout << "&bh = " << &bh <<" &message = " << &message << endl;
  }
}

在这里插入图片描述
地址值相同，这里的地址值是虚拟地址，而不是物理地址，

如果让父类延迟一秒再运行(sleep(1))，在这个过程中先运行子进程，并添加修改子进程变量的代码，会发现子进程中的值被修改了，而父进程中的变量值还是最开始的初始化值

这就说明物理地址是不同的，他们是两个变量

fork()之后，父进程和子进程的执行顺序是不确定的。

3.4 fork()的两种用法

  1. 父进程复制自己，然后，父进程和子进程分别执行不同的代码。这种用法在网络服务程序中很常见，父进程等待客户端的连接请求，当请求到达时，父进程调用fork()，=让子进程处理些请求，而父进程则继续等待下一个连接请求。（这个例子可以参考3.3）
  2. 进程要执行另一个程序。这种用法在Shell中很常见，子进程从fork()返回后立即调用exec。

例：

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


int main(int argc,char *argv[])
{
  pid_t pid = fork();
  if (pid > 0){
    // 父进程执行这段代码
    while(true){
      sleep(1);
      cout << "pid = " << pid <<"执行父进程代码" << endl;
    } 
  }else{
    // 子进程执行这段代码
    sleep(10);
    cout << "pid = " << pid <<"执行子进程代码" << endl;
    execl("/bin/ls", "/bin/ls","-lt","/tmp",0); // 取代子进程
    cout << "子进程执行任务结束" << endl;
  }
}

在这里插入图片描述
可以看到，最开始的子进程被 execl("/bin/ls", "/bin/ls","-lt","/tmp",0); 这行子进程打断了，这个子进程结束后也没有再回到最开始的子进程中（说法可能不太准确）

3.5 共享文件

fork()的一个特性是在父进程中打开的文件描述符都会被复制到子进程中，父进程和子进程共享同一个文件偏移量。

如果父进程和子进程写同一描述符指向的文件，但又没有任何形式的同步，那么它们的输出可能会相互混合。

3.6 vfork()函数

vfork()函数的调用和返回值与fork()相同，但两者的语义不同。

vfork()函数用于创建一个新进程，而该新进程的目的是exec一个新程序，它不复制父进程的地址空间，因为子进程会立即调用exec，于是也就不会使用父进程的地址空间。如果子进程使用了父进程的地址空间，可能会带来未知的结果。

vfork()和fork()的另一个区别是：vfork()保证子进程先运行，在子进程调用exec或exit()之后父进程才恢复运行。

4. 僵尸进程

如果父进程比子进程先退出，子进程将被1号进程托管（这也是一种让程序在后台运行的方法）。
如果子进程比父进程先退出，而父进程没有处理子进程退出的信息，那么，子进程将成为僵尸进程。

  • 僵尸进程有什么危害？

内核为每个子进程保留了一个数据结构，包括进程编号、终止状态、使用CPU时间等。父进程如果处理了子进程退出的信息，内核就会释放这个数据结构，父进程如果没有处理子进程退出的信息，内核就不会释放这个数据结构，子进程的进程编号将一直被占用。系统可用的进程编号是有限的，如果产生了大量的僵尸进程，将因为没有可用的进程编号而导致系统不能产生新的进程。

例：

#include <iostream>
#include <unistd.h>
#include <fstream>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;


int main(int argc,char *argv[])
{
  pid_t pid = fork();
  if (pid == 0) return 0;

  while(true){
    cout << "父进程运行中" << endl;
    sleep(1);
  }
    
}

这段代码就会产生一个僵尸进程

  • 僵尸进程的避免:

    1. 子进程退出的时候，内核会向父进程发头SIGCHLD信号，如果父进程用 signal(SIGCHLD,SIG_IGN) 知内核，表示自己对子进程的退出不感兴趣，那么子进程退出后会立即释放数据结构。
signal(SIGCHLD,SIG_IGN) // 在main（）最前面加上这一行代码，表示忽略子进程退出的信号
    1. 父进程通过wait()/waitpid() 等函数等待子进程结束，在子进程退出之前，父进程将被阻塞待。
pid_t wait(int *stat_loc);  // 最常用，下面的三个是第一个的补充和完善，但比较复杂，接收参数是子进程的编号
pid_t waitpid(pid_t pid, int *stat_loc, int options);
pid_t wait3(int *status, int options, struct rusage *rusage);
pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage);

返回值是子进程的编号。

stat_loc是子进程终止的信息：
a）如果是正常终止，宏**WIFEXITED(stat_loc)**返回真，宏**WEXITSTATUS(stat_loc)**可获取终止状态；
b）如果是异常终止，宏**WTERMSIG(stat_loc)**可获取终止进程的信号。

#include <iostream>
#include <unistd.h>
#include <fstream>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

int main(int argc,char *argv[])
{
  pid_t pid = fork();
  if (pid > 0){
    // 父进程的流程
    int sts;
    pid_t pid = wait(&sts);

    cout << "已终止的子进程编号是：" << endl;

    if(WIFEXITED(sts)){
      cout << "子进程是正常退出的，退出的状态是:" << WEXITSTATUS(sts) << endl;
    }else{
      cout << "子进程是异常退出的，退出的状态是:" << WTERMSIG(sts) << endl;
    }
  }else{
    // 子进程的流程
    sleep(5);
	// int *p = 0; *p = 10; // 这种空指针的写法会造成内存泄漏
    exit(0);
  }
}

在这里插入图片描述

3）如果父进程很忙，可以捕获SIGCHLD信号，在信号处理函数中调用wait()/waitpid()。

例：

#include <iostream>
#include <unistd.h>
#include <fstream>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

void func(int sig){ // 子进程退出的信号处理函数
  int sts;
  pid_t pid = wait(&sts);
  cout << "已终止的子进程编号是：" << endl;

  if(WIFEXITED(sts)){
      cout << "子进程是正常退出的，退出的状态是:" << WEXITSTATUS(sts) << endl;
    }else{
      cout << "子进程是异常退出的，退出的状态是:" << WTERMSIG(sts) << endl;
    }
}

int main(int argc,char *argv[])
{
  pid_t pid = fork();
  if (pid > 0){
    // 父进程的流程
    while (true){
      cout << "父进程执行中..." << endl;
      sleep(1);
    }
  }else{
    // 子进程的流程
    sleep(5);
    int *p = 0; *p = 10;
    exit(1);
  }
}

在这里插入图片描述
去其他窗口查看后台，只有父进程，没有出现僵尸进程，成功避免僵尸进程出现
在这里插入图片描述

5. 多线程与信号

在多进程的服务程序中，如果子进程收到退出信号，子进程自行退出，如果父进程收到退出信号，则应该先向全部的子进程发送退出信号，然后自己再退出。

#include <iostream>
#include <unistd.h>
#include <signal.h>
using  namespace std;

void FathEXIT(int sig);  // 父进程的信号处理函数。
void ChldEXIT(int sig);  // 子进程的信号处理函数。

int main()
{
  // 忽略全部的信号，不希望被打扰。
  for (int ii=1;ii<=64;ii++) signal(ii,SIG_IGN);

  // 设置信号,在shell状态下可用 "kill 进程号" 或 "Ctrl+c" 正常终止些进程
  // 但请不要用 "kill -9 +进程号" 强行终止
  signal(SIGTERM,FathEXIT); signal(SIGINT,FathEXIT);  // SIGTERM 15 SIGINT 2

  while (true)
  {
    if (fork()>0) // 父进程的流程。
    {
      sleep(5); continue;
    }
    else          // 子进程的流程。
    {
      // 子进程需要重新设置信号。
      signal(SIGTERM,ChldEXIT);   // 子进程的退出函数与父进程不一样。
      signal(SIGINT ,SIG_IGN);    // 子进程不需要捕获SIGINT信号。

      while (true)
      {
        cout << "子进程" << getpid() << "正在运行中。\n"; sleep(3); continue;
      }
    }
  }
}

// 父进程的信号处理函数。
void FathEXIT(int sig)
{
  // 以下代码是为了防止信号处理函数在执行的过程中再次被信号中断。
  signal(SIGINT,SIG_IGN); signal(SIGTERM,SIG_IGN);

  cout << "父进程退出，sig=" << sig << endl;

  kill(0,SIGTERM);     // 向全部的子进程发送15的信号，通知它们退出。

  // 在这里增加释放资源的代码（全局的资源）。

  exit(0);
}

// 子进程的信号处理函数。
void ChldEXIT(int sig)
{
  // 以下代码是为了防止信号处理函数在执行的过程中再次被信号中断。
  signal(SIGINT,SIG_IGN); signal(SIGTERM,SIG_IGN);

  cout << "子进程" << getpid() << "退出，sig=" << sig << endl;

  // 在这里增加释放资源的代码（只释放子进程的资源）。

  exit(0);
}
王十二er
关注
  • 29
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux-进程创建，进程终止，进程等待
HanMeng的博客
03-28 1243
文章目录：1.进程创建1.1 fork()函数1.2 vfork()函数2.进程终止2.1 进程终止的场景2.2 进程常见的终止方法正常终止(可以通过 echo $? 查看进程退出码)异常退出：Ctrl + c，信号终止扩展-->[刷新缓冲区的方式]扩展-->[库函数在哪一步冲刷缓冲区，关闭流]3. 进程等待3.1 进程等待的作用3.2 wait函数wait函数的使用问题一：如下代码我们如何证明父进程没有先退出，而是一直在等待子进程先退出问题二：僵尸进程，子进程在退出的时候会告知父进程，是怎么实
Linux 进程信号深剖
qq_61500888的博客
11-28 6876
带你一命通关 Linux 进程信号原理 三十分钟手撕底层内涵
Linux进程概念&&僵尸进程&&孤儿进程
喜欢C/C++/Linux/网络/数据库/数据结构
03-11 1699
Linux进程概念&&僵尸进程&&孤儿进程
Linux 进程终止 程序内调用其他可执行程序 创建进程 僵尸进程 多进程与信号（c++）
2301_76320385的博客
01-12 1031
父进程如果处理了子进程退出的信息，内核就会释放这个数据结构，父进程如果没有处理子进程退出的信息，内核就不会释放这个数据结构，子进程的进程编号将一直被占用。1）父进程复制自己，然后，父进程和子进程分别执行不同的代码。这种用法在网络服务程序中很常见，父进程等待客户端的连接请求，当请求到达时，父进程调用 fork()，让子进程处理些请求，而父进程则继续等待下一个连接请求。在多进程的服务程序中，如果子进程收到退出信号，子进程自行退出，如果父进程收到退出信号，则应该先向全部的子进程发送退出信号，然后自己再退出。
【Linux进程控制】进程创建 | 进程终止 | 进程等待 | 进程替换
wh128341的博客
06-17 2309
本文主要学习理解 fork 的返回值、写时拷贝的工作细节、为什么要存在写时拷贝；进程退出码、进程退出的场景及常见的退出方法、对比 man 2 _exit 和 man 3 exit；进程终止、操作系统怎么进行释放资源、池的概念；进程等待的价值、进程等待的方法 wait 和 waitpid(常用)、int* status、阻塞和非阻塞、如何理解等待、W IFEXITED、WEXITSTATUS、WTERMSIG;什么是进程替换 && 为什么要进程替换、替换原理、7个exec系列的替换函数、模拟shell解释器；
Linux进程控制【创建、终止、等待】
北 海的博客
03-16 6678
进程创建后，需要对其进行合理管理，光靠OS是无法满足我们的需求的，此时可以运用进程控制相关知识，对进程进行手动管理，如创建进程、终止进制、等待进程等，其中等待进程可以有效解决僵尸进程问题
【Linux】进程控制（进程创建、进程终止、进程等待、进程替换）
codewinter的博客
07-31 1141
进程创建、进程终止、进程等待、进程替换
【Linux系统编程】僵尸进程与孤儿进程
m0_70980326的博客
10-01 642
僵尸进程与孤儿进程
【Linux】进程创建、进程终止、进程等待
Brant_zero的博客
12-20 1323
关于Linux中的进程创建、进程终止、进程等待。fork函数的深入了解，写时拷贝，进程退出码与进程退出；wait函数与waitpid函数的详解使用，关于其阻塞等待和非阻塞等待。
linux 找出僵尸进程,linux 查看僵尸进程
weixin_39920629的博客
05-04 872
top -b -i -n 1查看僵死进程命令ps -A -o stat,ppid,pid,cmd | grep -e '^[Zz]'查看apache 当前进程数ps -ef | grep httpd | wc -l实时检测HTTPD连接数：watch -n 1 -d "pgrep httpd|wc -l"netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a ...
Linux中僵尸进程和孤儿进程详解
01-10
本文主要给大家介绍了关于Linux中僵尸进程和孤儿进程的相关内容，分享给出来供大家参考学习，下面来看看详细的介绍： 1、僵尸进程 一个子进程在其父进程没有调用wait()或waitpid()的情况下退出，这个子进程就是僵尸...
Linux 僵尸进程产生原因及解决方法
01-20
例如，进程可以创建一个子进程来执行特定的任务，然后调用诸如 wait() 这样的一些库函数检查子进程是否终止。如果子进程已经终止，那么，它的终止代号将告诉父进程这个任务是否已成功地完成。 为了遵循这些设计原则...
详解linux下避免僵尸进程的几种方法
01-09
linux下我们可以调用fork函数创建子进程，创建的子进程将会得到父进程的数据空间、堆、栈……副本(采用写时复制机制)，子进程将会继承父进程的信号掩码、信号处理方式、当前工作目录、会话id、组id……。当子进程...
解决 Linux 和 Java 1.8 中上传中文名称图片报错问题
最新发布
appearappear的博客
06-12 273
在 Linux 系统和 Java 1.8 中，当尝试上传含有中文名称的图片时，可能会遇到以下错误提示：为了解决这个问题，可以采取以下方法：在 Docker 的 中添加如下参数：Dockerfile使用以下命令启动 Java 程序，添加 参数：通过以上配置，确保了在启动 Java 程序时，使用了 UTF-8 编码，这样可以正确处理含有中文名称的文件，避免了报错问题的发生。3.5
Linux基础命令
威桑的博客
06-11 1191
常见基础Linux命令
【Linux下的动态链接和静态链接 及 调用libevent库函数的可执行文件无法正常运行情况剖析】
一起学习进步！
06-09 345
静态链接是指在编译时，将程序所依赖的函数或数据直接复制到最终的可执行文件中。这意味着可执行文件包含了程序运行所需的所有代码和数据。动态链接是指在运行时，程序所依赖的函数或数据从外部的共享库（shared library）中加载。这意味着可执行文件只包含了必要的引用信息，而实际的代码和数据则存储在外部的共享库中。
NVIDIA Jetson Linux 35.3.1-开发指南-Jetson软件架构
FREEDOM_X的专栏
06-11 774
下图显示了NVIDIA®Jetson™Linux架构。以下部分描述了每个模块的组件。在本开发人员指南或其他地方，许多组件的名称是指向组件主留档的链接。一些组件具有带有附加描述的单独链接。
MySQl基础----Linux下搭建mysql软件及登录和基本使用（附实操图超简单一看就会）
溟洵的博客
06-10 793
本章非常基础包括如何在Linux上搭建（==当然上面的SQL语句你在其他能执行SQL语句的软件上也能正常执行，并非一定要在Linux环境下==）和mysql的基本使用
【Linux】生产者消费者模型——阻塞队列BlockQueue
AAlykk的博客
06-11 974
Linux有两个重要的模型，一个是生产者消费者模型——阻塞队列BlockQueue，另一个则是生产者消费者模型——环形队列RingQueue。今天我们学习其中一个模型：【Linux】生产者消费者模型——阻塞队列BlockQueue。⭐主体生产者消费模型高效在哪里？高效体现在一个线程拿出来任务可能正在做计算，它在做计算的同时，其他线程可以继续从队列中拿，继续做运算，高效并不是体现在从队列中拿数据高效！而是我们可以让一个、多个线程并发的同时计算多个任务！
linux查询及处理僵尸进程
07-11
在Linux中，可以使用以下命令来查询和处理僵尸进程： 1. 查询僵尸进程： ```bash ps aux | grep 'Z' ``` 这个命令将列出所有状态为"Z"（僵尸）的进程。 2. 处理僵尸进程： 僵尸进程通常是由于父进程没有正确...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值