【Linux】进程控制详解

目录

前言

进程创建

认识fork

写时拷贝

 再谈fork

 进程终止

进程退出码 

用代码来终止进程

常见的进程终止的方式

exit 

_exit

进程等待

进程等待的必要性

进程等待的方式

wait 

waitpid

详解status参数

详解option参数

前言

本文适合有一点基础的人看的，否则的话有点难以理解，如果有问题，可以在评论区将你的问题打出来，我会一一解答的。

关于本文可以先去看看上篇的进程地址空间可以更好的理解这里的内容

进程创建

认识fork

fork函数是从已存在进程中创建一个新进程，新进程为子进程，原进程为父进程

 

返回值

  • 创建成功，在父进程中返回子进程的PID，并在子进程中返回0
  • 创建失败，父进程返回-1，子进程不返回，并设置错误码

 当进程中调用了fork，那么内核就会做以下事情

  • 分配新的内存块和内核数据结构给子进程
  • 将父进程部分数据结构内容拷贝至子进程
  • 添加子进程到系统进程列表中
  • fork返回，开始调度器调度
#include <stdio.h>
#include <unistd.h>

int main()
{
  printf("这是父进程, pid:%d\n", getpid());

  pid_t id = fork();
  if(id < 0)
  {
    printf("创建子进程失败!!!");
    return 1;
  }
  else if(id == 0)
  {
    //子进程
    while(1)
    {
      printf("我是子进程, pid:%d, ppid:%d\n", getpid(), getppid());
      sleep(1);
    }
  }
  else 
  {
    //父进程
    while(1)
    {
      printf("我是父进程, pid:%d, ppid:%d\n", getpid(), getppid());
      sleep(1);
    }
  }
  return 0;
}

 

fork之前只有父进程在执行，fork之后，父子进程分别执行。注：fork之后，父子进程谁先执行是由调度器决定的。

写时拷贝

从上面的内容我们知道，子进程也有自己的数据和代码，但是一般而言，我们的代码和数据没有在磁盘加载的过程，也就是说，子进程没有自己的代码和数据，所以子进程和父进程的共享代码和数据。对于代码而言，都是不可写的只能读取，所以父子共享没有问题；但对于数据而言可能会被修改，所以父子进程的数据必须分离。

那么数据分离是创建进程的时候就直接拷贝分离，还是修改数据时才拷贝分离呢？

答案肯定是需要修改数据时才拷贝分离

因为当你创建子进程时，可能其中的数据根本不会用到，即使用到了，也只是读取，那么这样的话在创建进程时就将数据直接拷贝分离是非常浪费空间的，所以操作系统选择了，当你需要对数据进行修改时才拷贝一份，这样父子进程的数据进行了分离且互不影响。而这个技术就叫做写时拷贝。

看一下下面代码的结果

从结果可以看出，编译器编译程序的时候，尚且知道节省空间何况是操作系统呢

那么操作系统为何要选择写时拷贝技术对父子进程进行分离呢？

  • 当用到数据时，再将数据进行分离是高效使用内存的一种表现
  • 操作系统在代码执行前无法预知哪些空间会被访问，也就无法对数据进行分离

 再谈fork

在重新回到认识fork的图中，fork之后，父子进程代码共享，是after共享，还是所有的共享？

答案是：所有的啦

那么子进程为什么不会从before之后在执行代码，而是直接从after开始执行代码呢？也就是说子进程是怎么知道代码执行到哪里了呢？

答案是：通过进程的上下文数据

我们的代码形成汇编之后，会有很多行代码，并且每行代码加载到内存之后都有对应的地址。但是进程由于一些原因随时可能会被中断（还没执行完），那么当进程下次回来时，还必须从当前中断的位置继续向后执行，这时就必须要求CPU随时记录下当前进程执行的位置，所以CPU内会有对应的寄存器（EIP，也叫PC指针）用来记录当前进程执行的位置，寄存器在CPU内只有一份，但是寄存器内的数据可以有多份。而这个寄存器中的数据就叫做进程的上下文数据，是数据就会发生写时拷贝。虽然父子进程各自会调度，各自会修改EIP，但是子进程已经认为自己EIP起始值就是fork之后的代码。

fork的常规用法

  • 父子进程同时执行不同的代码段。例如父进程等待客户端请求，子进程处理请求。
  • 一个进程要执行一个不同的程序。例如子进程从fork返回后调用exec函数。

fork调用失败的原因

  1. 系统中有太多的进程
  2. 用户的进程数超过了限制 

 进程终止

进程退出码 

进程退出的三种情况

  1. 代码运行完，结果正确
  2. 代码运行完，结果错误
  3. 代码没有运行完，程序崩溃了

当我们写代码时总是在main函数的最后return 0，那么main函数返回的意义是什么呢，return 0的含义又是什么，为什么返回的总是0呢？

下面就让我来一一解答这些问题吧

其实main函数返回的并不总是0，也可以是其它数字，而main函数返回的这个值其实是叫做进程的退出码。例如下面代码

int main()
{
    printf("hello world");
    return 10;
}

echo $?：用于获取最近一个进程执行完毕的退出码

我们返回的这个10的作用其实是用来标识代码执行完毕，结果是正确的，所以我们return 0的含义是：0表示代码执行完毕，结果正确；非0表示的是运行的结果不正确。非0值有无数个，不同的非0值可以标识不同的错误原因。所以我们也就可以根据这个返回值来判定代码运行完后的正确性。

因此我们也就明白了main函数返回的意义就是返回给上一级进程用来评判该进程的执行结果，如果结果不正确方便我们定位错误的原因细节。

在Linux下就定义了134个退出码，分别标识了不同的错误原因。

可以用strerror函数将这些退出码对应的错误原因打印出来

#include <stdio.h>
#include <string.h>

int main()
{

  for(int number = 0; number <= 134; number++)
  {
    printf("%d:%s\n", number, strerror(number));
  }

  return 0;
}

当然我们也可以使用这些退出码和含义，但是如果我们想自己定义也可以自己设计一套退出方案来。

上面的分析都是针对进程退出的前两种情况，那么第三种情况呢？

 程序崩溃而导致的退出其退出码没有任何意义，因为崩溃退出没有执行对应的rreturn语句。

#include <stdio.h>

int main()
{
  int* ptr= NULL;
  *ptr = 10;//野指针
  printf("hello world\n");
  return 0;
}

用代码来终止进程

常见的进程终止的方式

  1. 在main函数内使用return语句
  2. 调用exit函数，可以在代码的任何地方调用都表示终止进程。
  3. 调用系统接口_exit

exit 

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

void Func()
{
  //打印1-10
  for(int i = 1; i <= 10; i++)
  {
    printf("%d ", i);
  }
  printf("\n");
  exit(22);
}

int main()
{
  printf("hello world\n");
  printf("hello world\n");
  Func();
  printf("hello world\n");
  exit(11);
  printf("hello world\n");
  return 0;
}

_exit

 

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

int main()
{
  printf("hello world\n");
  sleep(3);
  exit(22);
}

上面这个代码是先打印hello world还是先sleep呢？

很显然是先打印hello world再sleep，那么我们把\n去掉呢？

很显然是先sleep再打印hello world。\n其实就是将我们打印的内容从缓冲区刷新到我们的屏幕上。

那么我们换用系统接口_exit试一试

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

int main()
{
  printf("hello world");
  sleep(3);
  _exit(22);
}

可以看出它执行了sleep但是为什么最后没有将hello world给我们打印出来呢？

因为exit()函数是C标准库给我们提供的库函数，它最后也会调用_exit，但在调用_exit之前还做了其它工作

  1. 执行用户通过atexit或者on_exit定义的清理函数
  2. 关闭所有打开的流，所有的缓冲区数据均被写入
  3. 调用_exit

而其中的缓冲区其实是C标准库在给我们维护的而不是操作系统，它在操作系统的上层，所以_exit最后不会将hello world刷新出来

进程等待

进程等待的必要性

当我们用fork创建子进程时，子进程退出，父进程如果不管子进程，就可能造成僵尸进程的问题，进而造成内存泄漏。另外，进程一旦变成僵尸状态，就连kill -9号命令也拿它没办法，因为谁也没办法杀死一个已经死去的进程。最后由于子进程变成僵尸，那么父进程指派给子进程完成的任务我们也无法知道是否已经完成，所以我们必须让父进程通过进程等待的方式回收子进程的资源，获取子进程的退出信息。

进程等待的方式

wait 

 没调wait之前

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>


int main()
{
  pid_t id = fork();
  if(id < 0)
  {
    perror("fork");
    exit(0);//创建子进程失败
  }
  else if(id == 0)
  {
    //子进程
    int cnt = 5;
    while(cnt)
    {
      printf("cnt:%d,我是子进程,pid:%d,ppid:%d\n", cnt, getpid(),getppid());
      sleep(1);
      cnt--;
    }
    exit(1);//子进程退出
  }
  else 
  {
    //父进程
    while(1)
    {
      printf("我是父进程,pid:%d,ppid:%d\n", getpid(), getppid());
      sleep(1);
    }
  }

  return 0;
}

 

5秒之后子进程变僵尸，那么我们调用wait看看现象

返回值：成功则返回被等待进程的pid，失败则返回-1

参数：输出型参数，获取子进程退出状态，不关心其状态则可以设置为NULL

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>


int main()
{
  pid_t id = fork();
  if(id < 0)
  {
    perror("fork");
    exit(0);//创建子进程失败
  }
  else if(id == 0)
  {
    //子进程
    int cnt = 5;
    while(cnt)
    {
      printf("cnt:%d,我是子进程,pid:%d,ppid:%d\n", cnt, getpid(),getppid());
      sleep(1);
      cnt--;
    }
    exit(1);//子进程退出
  }
  else 
  {
    //父进程
    printf("我是父进程,pid:%d,ppid:%d\n", getpid(), getppid());
    sleep(7);
    pid_t ret = wait(NULL);
    if(ret > 0)
    {
      printf("等待子进程成功,ret:%d\n",ret);
    }
    while(1)
    {
      printf("我是父进程,pid:%d,ppid:%d\n", getpid(), getppid());
      sleep(1);
    }
  }

  return 0;
}

 

从结果很容易看出，5秒后子进程进入僵尸状态，7秒后父进程将子进程回收掉了。

waitpid

 

返回值：正常返回子进程的进程ID，如果设置了选项WNOHANG并且子进程均已退出，则返回0；如果调用失败则返回-1，并且error会被设置相应的错误码

参数：

  • pid==-1，等待任意一个子进程；pid > 0，等待其进程ID与pid相等的子进程。
  • 输出型参数，WIFEXITED(status)：若为正常终止子进程返回的状态则为真。（可以用来查看进程是否是正常退出），WEXITSTATUS(status)： 若WIFEXITED非零，提取子进程的退出码。（查看进程的退出码）。若不关心status可以设置为NULL和wait一样。
  • WNOHANG： 若pid指定的子进程没有结束则函数返回0，不予以等待；若正常结束则返回该子进程的ID，这种方式也叫做非阻塞等待。默认为0表示阻塞等待。

 将上面代码中的wait换成waipid即可，现象都是一样的

详解status参数

wait和waitpid都有一个status参数，该参数是一个输出型参数，由操作系统填充，如果设置为NULL则表示不关心子进程的退出状态信息，否则操作系统会根据该参数，将子进程的退出信息反馈给父进程。

那么我们用代码实际验证一下status吧

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>


int main()
{
  pid_t id = fork();
  if(id < 0)
  {
    perror("fork");
    exit(0);//创建子进程失败
  }
  else if(id == 0)
  {
    //子进程
    int cnt = 5;
    while(cnt)
    {
      printf("cnt:%d,我是子进程,pid:%d,ppid:%d\n", cnt, getpid(),getppid());
      sleep(1);
      cnt--;
    }
    exit(100);//子进程退出
  }
  else 
  {
    //父进程
    printf("我是父进程,pid:%d,ppid:%d\n", getpid(), getppid());
    int status = 0;
    pid_t ret = waitpid(id, &status, 0);//阻塞式等待
    if(ret > 0)
    {
      printf("等待子进程成功,ret:%d,子进程的退出码:%d\n",ret, status);
    }
  }

  return 0;
}

上面的代码中子进程的退出码明明是100，为什么打印出来的却是比100大的多的25600呢？

原因是：status并不是按照整数来整体使用的，而是按照比特位的方式将32个比特位进行划分，这里我们只分析低16位

所以我们要获取子进程的退出码就要右移8位并与上0xff

当我们的进程（程序）异常退出或者崩溃，本质上是操作系统杀掉了我们的进程，那么操作系统是通过什么方式来杀掉我们的进程的呢？

答：通过向进程发送信号的方式来杀掉进程。 

一共有以下信号 

 

将上面代码进行如下改造

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>


int main()
{
  pid_t id = fork();
  if(id < 0)
  {
    perror("fork");
    exit(0);//创建子进程失败
  }
  else if(id == 0)
  {
    //子进程
    int cnt = 5;
    while(cnt)
    {
      printf("cnt:%d,我是子进程,pid:%d,ppid:%d\n", cnt, getpid(),getppid());
      sleep(1);
      cnt--;
    }
    exit(100);//子进程退出
  }
  else 
  {
    //父进程
    printf("我是父进程,pid:%d,ppid:%d\n", getpid(), getppid());
    int status = 0;
    pid_t ret = waitpid(id, &status, 0);//阻塞式等待
    if(ret > 0)
    {
      printf("等待子进程成功,ret:%d,子进程收到的信号编号:%d,子进程的退出码:%d\n",ret, status & 0x7f, (status >> 8)&0xff);
    }
 
  }

  return 0;
}

0表示正常跑完，100表示结果正确

在代码中加个除0操作

8表示收到了8号信号，代码是异常退出，那么我们的退出码也就无意义了。这里也验证了上面退出码的内容

在代码中加个野指针

11表示收到了11号信号，也就是段错误。使用kill -9杀掉进程也是类似的，这里就不在演示了。

所以程序（进程）异常不光是内部代码有问题，也可能是外力因素将进程直接干掉了，那么子进程是否跑完，我们也不确定。

知道了上面这些那么让我们来思考一下下面的问题

1、父进程通过wait/waitpid可以拿到子进程的退出结果，那么为什么要用wait/waitpid函数，直接全局变量不行吗？

code为全局变量

很显然是不行的，因为进程具有独立性，全局变量也是数据，那么是数据就要发生写时拷贝，父进程也就无法拿到。

2、既然信号具有独立性，子进程退出的信息也是子进程的数据，那么为什么父进程调用了wait/waitpid就能拿到子进程退出的信息呢？

子进程退出会变成僵尸进程，但是即使变成了僵尸进程也会保留该进程的PCB（task_struct）信息（就跟人死亡后身上会保留死亡的原因），task_struct里面就保留了任何进程退出时的退出信息，所以wait和waitpid本质上就是读取了子进程的task_struct里面相关信息。

3、wait/waitpid有这个权利从PCB中拿到相关信息吗？

肯定有这个权利啊，它们可是系统调用的接口，娘胎里自带的就有这个权利。

我们在获取子进程的退出码时也可以不用位运算，可以使用宏也就是下面的这种写法。

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
  pid_t id = fork();
  if(id < 0)
  {
    perror("fork");
    exit(0);//创建子进程失败
  }
  else if(id == 0)
  {
    //子进程
    int cnt = 5;
    while(cnt)
    {
      printf("cnt:%d,我是子进程,pid:%d,ppid:%d\n", cnt, getpid(),getppid());
      sleep(1);
      cnt--;
      int* p =NULL;
      *p = 100;
      }
    exit(100);//子进程退出
  }
  else 
  {
    //父进程
    printf("我是父进程,pid:%d,ppid:%d\n", getpid(), getppid());
    int status = 0;
    pid_t ret = waitpid(id, &status, 0);//阻塞式等待
    if(ret > 0)
    {
      if(WIFEXITED(status))
      {
        printf("子进程执行完毕,子进程的退出码:%d\n", WEXITSTATUS(status));
      }
      else
      {
        printf("子进程异常退出:%d,退出信号为:%d\n", WIFEXITED(status), WTERMSIG(status));
      }
  }

  return 0;
}

详解option参数

 option为0，默认是阻塞式等待；WNOHANG选项，代表父进程非阻塞式等待

WNOHANG其实是一个宏定义

非阻塞式等待的意思是：父进程通过调用waitpid来进行等待，如果子进程没有退出，则立马返回。

举个例子：你家冰箱坏了，你要打电话叫师傅上你家来维修，当你打通了电话，可是师傅说没有空这时你就立马挂断了电话去处理自己的事情了；过了一段时间，你再次去拨打师傅的电话，可是师傅还在忙，你又立马挂断了电话去处理别的事情了；又过了一段时间，你又拨通了师傅的电话，师傅这时有空了，说立马上门维修。在这个例子中你每次拨打电话的过程其实就是非阻塞调用，非阻塞调用采用的是轮询检测的方案。而如果你在第一次拨打师傅电话时，你一直不挂断电话，等到师傅有空了你才挂断电话，而这就是阻塞等待。

阻塞的本质其实是进程阻塞在系统调用的内部 

废话不多说上代码演示

#include <iostream>
#include <vector>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>

typedef void (*handler_t)(); //函数指针类型

std::vector<handler_t> handlers; //函数指针数组

void fun_one()
{
  int a = 10;
  int b = 20;
   printf("这是一个加法: %d + %d = %d\n", a, b, a + b);
}
void fun_two()
{
  int a = 10;
  int b = 20;
   printf("这是一个减法: %d - %d = %d\n", b, a, b - a);
}

// 设置对应的方法回调
void Load()
{
   handlers.push_back(fun_one);
   handlers.push_back(fun_two);
}


int main()
{
  pid_t id = fork();
  if(id < 0)
  {
    perror("fork");
    exit(0);//创建子进程失败
  }
  else if(id == 0)
  {
    //子进程
    int cnt = 5;
    while(cnt)
    {
      printf("cnt:%d,我是子进程,pid:%d,ppid:%d\n", cnt--, getpid(),getppid());
      sleep(1);
      }
    exit(100);//子进程退出
  }
  else 
  {
    //父进程
    int quit = 0;
    while(!quit)
    {
      int status = 0;
      pid_t res = waitpid(-1, 0, WNOHANG);
      if(res > 0)
      {
        //等待成功并且子进程退出
        printf("等待子进程退出成功,退出码:%d\n", WEXITSTATUS(status));
        quit = 1;
      }
      else if(res == 0)
      {
        //等待成功并且子进程还未退出
        printf("子进程还在运行,暂时还没有退出,父进程在等等,先处理其它事情吧!!\n");
        if(handlers.empty()) Load();
        for(auto iter : handlers)
        {
          //执行其它任务
          iter();
        }
      }
      else
      {
        //等待失败
        printf("wait失败\n");
        quit = 1;
      }
      sleep(1);
    }
  }
  return 0;
}

 

今天的分享就到这里，如果内容有错的话，还望指出谢谢！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/513725.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【JavaScript】函数 ⑥ ( 使用 arguments 获取所有实参 | arguments 内置对象 | 伪数组概念 )

【JavaScript】函数 ⑥ ( 使用 arguments 获取所有实参 | arguments 内置对象 | 伪数组概念 )

文章目录 一、使用 arguments 获取所有实参1、arguments 内置对象2、伪数组概念3、arguments 实参遍历4、arguments 代码示例 - 基本使用5、arguments 代码示例 - 遍历实参 一、使用 arguments 获取所有实参 1、arguments 内置对象 在 定义 JavaScript 函数 时 , 有时 不确定 形…
阅读更多...
Spring定义Bean对象笔记（二）

Spring定义Bean对象笔记（二）

前言&#xff1a;上一篇记录了通过XML文件来定义Bean对象&#xff0c;这一篇将记录通过注解和配置类的方式来定义Bean对象。 核心注解&#xff1a; 定义对象&#xff1a;Component,Service,Repository,Controller 依赖注入&#xff1a; 按类型&#xff1a;Autowired 按名称&am…
阅读更多...
cesium 加载mapbox底图 黑色主题底图 84底图

cesium 加载mapbox底图 黑色主题底图 84底图

cesium提供MapboxStyleImageryProvider&#xff0c;加载mapbox的影像图层&#xff0c;底图是84坐标系。 viewer.imageryLayers.addImageryProvider(new Cesium.MapboxStyleImageryProvider({styleId: dark-v11,accessToken: mapbox的token})); 效果图&#xff1a;加载mapbox黑…
阅读更多...
简单使用bootstrap-datepicker日期插件

简单使用bootstrap-datepicker日期插件

目录 下载datepicker 方式一&#xff1a; 方式二&#xff1a; 下载依赖 下载bootstarp.js 下载jquery 使用示例 日期选择 单独选择年 单独选择月 单独选择日 设置截止日期 设置默认日期 总结 下载datepicker 方式一&#xff1a; 下载地址 GitHub - uxsolution…
阅读更多...
java运行时内存

java运行时内存

从jdk1.7以及以后&#xff0c;静态变量和常量池存在堆空间。
阅读更多...
关于搭建电商独立站跨境电商接入主流电商平台API商品接口对于商品功能模块的巨大应用

关于搭建电商独立站跨境电商接入主流电商平台API商品接口对于商品功能模块的巨大应用

功能设计 首先我们来看下mall项目中商品功能的设计&#xff0c;主要包括商品管理、添加\编辑商品、商品分类、商品类型、品牌管理等功能&#xff0c;这里的功能同时涉及前台商城和后台管理系统。 商品管理【接入主流电商平台商品API接口丰富自建商城商品】 在mall项目的后台管…
阅读更多...
JavaScript基础(5)之对象的方法和调用

JavaScript基础(5)之对象的方法和调用

JavaScript基础5之对象的方法和调用 对象对象使用语法属性和访问方法和调用null遍历对象 内置对象Math属性方法 基本数据类型和引用数据类型堆栈空间分配区别&#xff1a;简单类型的内存分配复杂类型的内存分配 对象 对象是 JavaScript 数据类型的一种&#xff0c;之前已经学习…
阅读更多...
填谷式无源PFC电路

填谷式无源PFC电路

目录&#xff1a; 1、概述 2、原理 1、概述 如果不采用PFC&#xff0c;那么典型开关模式电源的功率因数约为0.6&#xff0c;因而会有相当大的奇次谐波失真(第三谐波有时和基本谐波一样大)。令功率因数小于1以及来自峰值负载的谐波减少了运行设备可用的实际功率。为运行这些低…
阅读更多...
书生·浦语2.0体系技术报告

书生·浦语2.0体系技术报告

前言 本文是书生浦语二期实战营课程视频笔记&#xff0c;如果需要详细视频教程可自行搜索。 InternLM2 InternLM2-Base 高质量和具有很强可塑性的模型基座&#xff0c;是模型进行深度领域适配的高质量起点InternLM2 在Base基础上&#xff0c;在多个能力方向进行了强化&#x…
阅读更多...
WSL安装与使用

WSL安装与使用

开启之后&#xff0c;会提示你重启电脑才能使配置生效&#xff0c;我们重启即可。 电脑重启后&#xff0c;打开Microsoft Store搜索WSL&#xff0c;既可以看到支持的操作系统&#xff0c;我们选择Ubuntu即可&#xff0c;我们选择第一个就可以。 随后我们打开&#xff0c;发现报…
阅读更多...
提升办公效率，一起了解流程自定义表单优势

提升办公效率，一起了解流程自定义表单优势

提高办公效率&#xff0c;可以一起了解低代码技术平台。对于很多中小型企业而言&#xff0c;低代码技术平台及流程自定义表单优势突出&#xff0c;是助力企业实现流程化办公&#xff0c;实现数字化转型的得力助手。流辰信息是专业研发开发平台、数据治理、数据分析等产品的服务…
阅读更多...
软考 系统架构设计师系列知识点之云原生架构设计理论与实践（13）

软考 系统架构设计师系列知识点之云原生架构设计理论与实践（13）

接前一篇文章&#xff1a;软考 系统架构设计师系列知识点之云原生架构设计理论与实践&#xff08;12&#xff09; 所属章节&#xff1a; 第14章. 云原生架构设计理论与实践 第3节 云原生架构相关技术 14.3.2 云原生微服务 1. 微服务发展背景 过去开发一个后端应用最为直接的方…
阅读更多...
软件架构风格_4.虚拟机体系结构风格

软件架构风格_4.虚拟机体系结构风格

虚拟机体系结构风格的基本思想是人为构建一个运行环境&#xff0c;在这个环境之上&#xff0c;可以解析与运行自定义的一些语言&#xff0c;这样来增加架构的灵活性。虚拟机体系结构风格主要包括解释器风格和规则系统风格。 1.解释器体系结构风格 一个解释器通常包括完成解释工…
阅读更多...
Win11 绕过 TPM 或 CPU 检测

Win11 绕过 TPM 或 CPU 检测

方法 1&#xff1a;修改注册表绕过 TPM 或 CPU 检测&#xff08;升级安装&#xff09; 如果你的硬件不完全符合安装 Windows 11 的基本硬件要求&#xff0c;可以通过修改注册表&#xff0c;在至少拥有 TPM 1.2 和不支持的 CPU 上升级安装 Windows 11 系统. 适用场景&#xff…
阅读更多...
Nginx是什么？

Nginx是什么？

一、什么是Nginx? Nginx是一个高性能的HTTP和反向代理Web服务器 二、Nginx有什么优点 Nginx稳定性好、资源消耗低、配置简单、功能丰富 1、作为Web服务器&#xff0c;Nginx处理静态文件、索引文件&#xff0c;自动索引的效率非常高 2、作为代理服务器&#xff0c;Nginx可以…
阅读更多...
知识产权与标准化

知识产权与标准化

根据希赛相关视频课程汇总整理而成&#xff0c;是个人软考的复习笔记&#xff0c;仅供参考 知识产权概述 知识产权类型&#xff1a; ①著作权&#xff08;版权、文学产权&#xff09; ② 工业产权&#xff08;产业产权&#xff09; 知识产权的特点&#xff1a; 无形性、独占性…
阅读更多...
C++的并发世界（五）——线程状态切换

C++的并发世界（五）——线程状态切换

0.线程状态 初始化&#xff1a;该线程正在被创建&#xff1b; 就绪&#xff1a;该线程在列表中就绪&#xff0c;等待CPU调度&#xff1b; 运行&#xff1a;该线程正在运行&#xff1b; 阻塞&#xff1a;该线程被阻塞挂机&#xff0c;Blocked状态包括&#xff1a;pend&#xff…
阅读更多...
win11安装wsl报错：无法解析服务器的名称或地址

win11安装wsl报错：无法解析服务器的名称或地址

一 说明 项目开发中&#xff0c;需要用到wsl&#xff0c;因此根据wsl官方&#xff08;WSL安装教程&#xff09;命令 wsl --install 进行wsl的安装。而本文主要是记录自己在安装wsl中遇到的问题 “无法解析服务器的名称或地址” 的解决办法。 二 方法一&#xff1a;更改DNS&…
阅读更多...
回溯算法|47.全排列II

回溯算法|47.全排列II

力扣题目链接 class Solution { private:vector<vector<int>> result;vector<int> path;void backtracking (vector<int>& nums, vector<bool>& used) {// 此时说明找到了一组if (path.size() nums.size()) {result.push_back(path);r…
阅读更多...
Java基于微信小程序的电子竞技信息交流系统，附源码(V2.0)

Java基于微信小程序的电子竞技信息交流系统，附源码(V2.0)

博主介绍&#xff1a;✌IT徐师兄、7年大厂程序员经历。全网粉丝15W、csdn博客专家、掘金/华为云//InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;&#x1f3…
阅读更多...
最新文章

Copyright @ 2022~2023