【进程】快速上手进程操作

news2024/11/16 18:34:30

目录

0. 进程概述

1. 创建进程

1.1 进程的创建：fork函数

1.2 进程的等待：wait()、waitpid()

1.3 特殊进程：僵尸进程、孤儿进程、守护进程

1.4 进程的终止：exit和_exit函数

1.5 进程退出清理：atexit函数

1.6 进程的创建 ：vfork函数

2. 进程的替换：exec函数族

3. system函数：

总结：

0. 进程概述

进程的定义

程序和进程的区别：

  •         程序：是静态的，存放在磁盘上的可执行文件。
  •         进程：是动态的，是运行在内存中的程序的执行实例。
  •         程序是一些指令的有序集合，而进程是程序执行的过程，进程是程序的一次执行过程。
  •         进程的状态是变化的，其包括进程的创建、调度和消亡。
  •         程序只要运行，此时就是进程，程序没运行一次，就会创建一个进程。

在Linux系统中，进程是管理事务的基本单元。

进程拥有自己独立的处理环境和系统资源（处理器、存储器、I/O设备、数据、程序）。

进程的状态及转换：

进程整个生命周期可以简单的划分为三种状态：

就绪态：

        进程已经具备执行的一切条件，正在等待分配CPU的处理时间。

执行态：

        该进程正在占用CPU运行。

等待态：

        进程因不具备某些执行条件而暂时无法继续执行的状态。

进程的调度机制：

        时间片轮转，上下文切换。

        多进程不是说一个进程执行完再执行另一个进程，而是交替执行的，一个进程执行一段时间，然后下一个进程再执行一段时间，依次类推，所有进程执行完之后再回到第一个进程继续执行，依次类推。

进程三个状态的转换关系：

 进程控制块：

        进程控制块就是用于保存一个进程信息的结构体，又称之为PCB。

        OS是根据PCB来对并发执行的进程进行控制和管理的。系统在创建一个进程的时候会开辟一段内存空间存放与此进程相关的PCB数据结构。

        PCB是操作系统中最重要的记录型数据结构。PCB中记录了用于描述进程进展情况及控制进程运行所需的全部信息。

        PCB是进程存在的唯一标志，在Linux中PCB存放在task_struct结构体中。

        /usr/src/linux-heads....generic/include/linux/sched.h

PCB结构体中的部分数据：

调度数据：

        进程的状态、标志、优先级、调度策略等。

时间数据：

        创建该进程的时间、在用户态的运行时间、在内核态的运行时间等。

文件系统数据：

        umask掩码、文件描述符表等。

内存数据、进程上下文、进程标识（进程号）

。。。

进程控制：

进程号：

        每一个进程都是由一个进程号来标识，其类型为pid_t，进程号的范围：0-32767。

        进程号总是唯一的，但是进程号可以重用。当一个进程终止后，其进程号就可以再次使用了。

在ubuntu中查看当前系统中所有的开启的进程：

ps ajx

PPID：当前进程的父进程的进程号。

PID：当前进程的进程号。

PGID：当前进程所在的组的进程组ID。

COMMAND：当前进程的名字

特殊的进程号：

  •         在Linux系统中进程号由0开始。
  •         进程号为0及1的进程由内核创建。
  •         进程号为0的进程通常是调度进程，常被称为交换进程（swapper）。
  •         进程号为1的进程通常是init进程，init进程是所有进程的祖先。
  •         除调度进程外，在Linux下面所有的进程都由init进程直接或间接创建。

进程号（PID）

        标识进程的一个非负整型数。

父进程号（PPID）

        任何进程（除Init进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（PPID）。

进程组号（PGID）

        进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（PGID）。

Linux操作系统中提供了三个获得进程号的函数getpid()、getpgid()、getppid()。

#include<sys/types.h>

#include<unistd.h>

pid_t getpid(void);

功能：获取当前进程的进程号。

pid_t getppid(void);

功能：获取当前进程的父进程的进程号。

pid_t getpgid(pid_t pid);

功能：获取当前进程所在进程组的进程号。

代码示例：

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

int main()
{
    printf("pid = %d\n", getpid());
    printf("ppid = %d\n", getppid());
    printf("pgid = %d\n", getpgid(getpid()));
    while (1);
    return 0;
}

执行截图：

1. 创建进程

1.1 进程的创建：fork函数

fork函数：

#include<unistd.h>

pid_t fork(void);

功能：在已有的进程基础上创建一个子进程。

参数：

        无

返回值：

        成功：

                >0：子进程的进程号，标识父进程的代码区。

              ==0：子进程的代码区。

        失败：

                -1：返回给父进程，子进程不会创建。

        使用fork函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间。

地址空间：

        包括进程上下文、进程堆栈、打开的文件描述符、信号控制设定、进程优先级、进程组号等。子进程所独有的只有它的进程号，计时器等。因此，使用fork函数的代价是很大的。 

fork函数执行完毕后父子进程的空间示意图：

创建子进程

不区分父子进程（不推荐）

代码示例：

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

int main()
{
    //通过fork函数创建一个子进程
    //注意：只要执行了一次fork，就会在原有的进程基础上创建一个新的子进程
    //而且如果fork之后不区分父子进程的代码区，则后面的所有代码都会执行
    fork();
    printf("hadj{\n");
    while (1);
    return 0;
}

执行截图：

区分父子进程（推荐）

代码示例：

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


int main()
{
    //父子进程是来回交替执行的，谁先谁后不一定。
    pid_t pid;
    pid = fork();
    if (pid < 0)    //创建子进程失败
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)   //父进程代码区
    {
        while (1)
        {
            printf("in parent process\n");
            sleep(1);
        }
    }
    else   //子进程代码区（pid == 0)
    {
        while (1)
        {
            printf("in son process\n");
            sleep(1);
        }
    }
    return 0;
}

执行截图：

父进程拥有独立的地址空间、

代码示例：

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

int a = 555;

int main()
{
    pid_t pid;
    pid = fork();
    static int  b = 777;
    int c = 888;
    //子进程会复制父进程fork之前的所有内容
    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("in partent process\n");
        a++;
        b++;
        c++;
        printf("a = %d, b = %d, c = %d\n", a, b, c);
    }
    else
    {
        sleep(1);
        printf("in son process\n");
        printf("a = %d, b = %d, c = %d\n", a, b, c);
    }
    while (1);

    return 0;
}

执行截图：

 代码示例：

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


int main()
{

    int fd;
    if ((fd = open("file.txt", O_RDONLY)) == -1)
    {
        perror("fail to open");
        exit(1);
    }
    //子进程会继承父进程的一些共有的区域，例如磁盘空间，内核空间。
    //文件描述符的偏移量保存在内核空间中，所以父进程改变偏移量，子进程获取的偏移量是改变之后的。
    pid_t pid;
    pid = fork();

    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("in parent process\n");
        char  buf[32] = "";
        if (read(fd, buf, 30) == -1)
        {
            perror("fail to read");
            exit(1);
        }
        printf("buf = [%s]\n", buf);
    }
    else
    {
        sleep(1);
        printf("in son process\n");

        char buf[32] = "";
        if (read(fd, buf, 30) == -1)
        {
            perror("fail to read");
            exit(1);
        }
        printf("buf = [%s]\n", buf);

    }
    while (1);
    return 0;
}

执行截图：

子进程继承父进程的空间

进程的挂起：

进程在一定的时间内没有任何动作，称为进程的挂起。

#include<unistd.h>

unsigned int sleep(unsigned in sec);

功能：

        进程挂起指定的秒数，知道指定的时间用完或受到信号才解除挂起。

返回值：

        若进程挂起到sec指定的时间则返回0，中断则返回剩余秒数。

注意：

        进程挂起指定的秒数后程序并不会立即执行，系统只是将此进程切换到就绪态。

代码示例：

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

int main()
{
        while(1)
        {
                printf("hello world\n");
                sleep(2);
        }
        return 0;
}

执行截图：

 

1.2 进程的等待：wait()、waitpid()

父子进程有时需要简单的进程间同步，如父进程等待子进程的结束。

Linux下提供了两个等待函数wait()、waitpid()。

wait函数

#include<sys/types.h>

#include<sys/wait.h>

pid_t wait(int *status);

功能：

        等待子进程终止，如果子进程终止了，此函数会回收子进程的资源。

        调用wait函数的进程会挂起，直到它的一个子进程退出或收到一个不能被忽视的信号时才被启用

        若调用进程没有子进程或它的子进程已经结束，该函数立即返回。

参数：

        status：函数返回时，参数status中包含子进程退出时的状态信息。

                        子进程的退出信息在一个int中包含了多个字段，

                        用宏定义可以取出其中的每个字段。

                        子进程可以通过exit或_exit函数发送退出状态。

返回值：

        成功：子进程的进程号。

        失败：-1

代码示例：

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


int main()
{
    pid_t pid;
    pid = fork();

    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    if (pid > 0)
    {
        //不接收子进程的退出状态
        wait(NULL);
        //接收子进程退出状态，子进程中必须用exit或_exit函数退出进程时发送退出状态
        int status = 0;
        wait(&status);
        if (WIFEXITED(status) != 0)
        {
            printf("son process return status:%d\n", WEXITSTATUS(status));
        }
        printf("in pratent proces\n");

    }
    else
    {
        int i = 0;
        for (i = 0; i < 5; i++)
        {
            printf("in son process\n");
            sleep(1);
        }
        exit(2);
    }
    return 0;
}

执行截图：

waitpid函数

#include<sys/types.h>

#include<sys/wait.h>

pid_t waitpid(pid_t pid, int *status, int options);

功能：

        等待子进程终止，如果子进程终止了，此函数会回收子进程的资源。

参数：

        pid：指定的进程或者进程组。

                pid>0：等待进程ID等于PID的子进程

                pid+0：等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会等待它。

                pid=-1：等待任一子进程，此时waitpid和wait作用一样。

                pid<-1：等待指定进程组中的任何子进程，这个子进程组的ID等于pid的绝对值

        status：保存子进程退出时的状态信息。

        options：选项

                0：同wait，阻塞父进程，等待子进程退出。

                WNOHANG：没有任何已经结束的子进程，则立即返回。

                WUNTRACED：如果子进程暂停了则此函数马上返回，并且不予以理会子进程的结束状态。（跟踪调试，很少使用）

返回值：

        成功：返回状态改变了的子进程的进程号；如果设置了选项WNOHANG并且pid指定的进程存在，返回0。

        失败：返回-1。当pid指示的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid 就会出错返回，这时 errno 被设置为 ECHILD。

wait(status)  <==> waitpid(-1, status, 0)

代码示例：

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


int main()
{

    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        waitpid(pid, NULL, 0);
        printf("in father process\n");
    }
    else
    {
        int i = 0;
        for (i = 0; i < 5; i++)
        {
            printf("in son  process\n");
            sleep(1);
        }
    }
    return 0;
}

 执行截图：

1.3 特殊进程：僵尸进程、孤儿进程、守护进程

  • 僵尸进程（Zombie Process） 进程已运行结束，但进程的占用的资源未被回收，这样的进程称为僵尸进程。 子进程已运行结束，父进程未调用 wait 或 waitpid 函数回收子进程的资源是子进 程变为僵尸进程的原因。
  • 孤儿进程（Orphan Process） 父进程运行结束，但子进程未运行结束的子进程。
  • 守护进程（精灵进程）（Daemon process） 守护进程是个特殊的孤儿进程，这种进程脱离终端，在后台运行。

1.4 进程的终止：exit和_exit函数

exit函数：

#include<stdlib.h>

void exit(int value)

参数：

        status：返回给父进程的参数(低 8 位有效)。

                        一般失败设置为非0，成功设置为0

_exit函数：

#include void _exit(int value)

参数:

        status:返回给父进程的参数(低 8 位有效)。

                一般失败设置为非0，成功设置为0

exit和_exit函数的区别：

  •         exit为库函数，而_exit为系统调用。
  •         exit会刷新缓冲区，但是_exit不会刷新缓冲区
  •         一般使用exit

 代码示例：

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

void fun()
{
    printf("nihao hangzhou");
    //测试return是带换行\n
   // printf("nihao hangzhou\n");
    
    //主函数中退出进程，子函数中退出当前函数。
    //      return  ;
    //退出一个进程，刷新缓冲区
    //exit(0);  
    //退出一个进程，不刷新缓冲区    
    _exit(0);
    printf("welcoom to binjiang\n");
}
int main()
{
    printf("hello world\n");
    fun();
    printf("hello kitty\n");
    return 0;
}

执行截图：

return截图：

exit截图：

 

_exit截图：

 

1.5 进程退出清理：atexit函数

进程在退出前可以使用atexit函数注册退出函数

#include<stdlib.h>

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

功能：

        注册进程正常结束前调用的函数，进程退出执行注册函数。

参数：

        function：进程结束前，调用函数的入口地址。

        一个进程中可以多次调用atexit函数注册清理函数，正常结束前调用函数的顺序和注册时的顺序相反。 

代码示例：

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


void clear_fun1(void)
{
    printf("perform clear fun1 \n");
}
void clear_fun2(void)
{
    printf("perform clear fun2 \n");
}
void clear_fun3(void)
{
    printf("perform clear fun3 \n");
}
int main()
{
    //atexit在进程结束时才会执行对应的回调函数
    //注意调用顺序是反的
    atexit(clear_fun1);
    atexit(clear_fun2);
    atexit(clear_fun3);
    printf("process exit 3 sec later!!!\n");
    sleep(3);
    return 0;
}

执行截图：

1.6 进程的创建 ：vfork函数

vfork函数

#include<sys/types.h>

#include<unistd.h>

pid_t vfork(void)

功能：

        vfork函数和fork函数一样都是在已有的进程中创建一个新的进程，但它们创建的子进程是有区别的。

返回值：

        创建子进程成功，则在子进程中返回0，父进程中返回子进程ID。

        出错返回-1.

fork和vfork函数的区别：

        vfork保证子进程先运行，在它调用exec或exit之后，父进程才可能被调度运行。

        vfork和fork一样都创建一个子进程，但它并不将父进程的地址空间完全复制到子进程中，因为子进程会立即调用exec(或exit),于是也就不访问该地址空间。

        相反，在子进程中调用exec或exit之前，它在父进程的地址空间中运行，在exec之后子进程会有自己的进程空间。

子进程在父进程之前运行

代码示例：

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

int main()
{
    //使用vfork，子进程会先执行，直到子进程执行exit或exec后，父进程才会执行。
    pid_t pid;
    pid = vfork();
    if (pid < 0)
    {
        perror("fail to  vfork");
        exit(1);
    }
    else if (pid > 0)
    {
        while (1)
        {
            printf("in father process\n");
            sleep(1);
        }
    }
    else
    {
        int i = 0;
        for (i = 0; i < 5; i++)
        {
            printf("in son process\n");
            sleep(1);
        }
        exit(0);
    }
    return 0;
}

执行截图：

 子进程与父进程共享一个空间

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

int a = 10;
int main()
{
//父子进程共享一个空间
    pid_t pid;
    int b = 9;
    pid = vfork();
    if (pid < 0)
    {
        perror("fail to vfork");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("in father process a = %d b = %d\n", a, b);
    }
    else
    {
        a++;
        b++;
        printf("in son process a = %d b = %d\n", a, b);
        exit(0);
    }
    return 0;
}

 执行截图：

2. 进程的替换：exec函数族

exec函数族，是由六个exec函数组成的

  1. exec函数族提供了六种在进程中启动另一个进程的方法
  2. exec函数族可以根据指定的文件名或目录名找到可执行文件
  3. 调用exec函数的进程并不创建新的进程，故调用exec前后，进程的进程号并不会改变，其执行的程序完全由新的程序替换，而新的程序则从其main函数开始执行。

exec函数族取代调用进程的数据段、代码段和堆栈段。

 #include<unistd.h>

int execl(const char *path, const char *arg, .../*(char *) NULL */);

int execlp(const char *file, const char *arg, .../* (char *) NULL */);

int execlv(const char *path, char *const argv[]);

int execvp(const char *file, char *const argv[]);

int execle(const char *path, const char *arg, .../*, (char *) NULL*/, char *const envp[]);

int execvpe(const char *file, char *const argv[], char *const envp[]);

功能：

        在一个进程里面执行另一个程序，主要用于执行命令。

参数：

        path：命令或者程序的路径。

        l：如果是带l的函数，对应的命令或者程序是通过每一个参数进行传递的，最后一个为NULL表示结束。

                例如："ls","-l",NULL

        v：如果是带v的函数，对应的命令或者程序是通过一个指针数组来传递的，指针数组的最后一个元素为NULL标志结束。

                char *str[] = {"ls", "-l", NULL}；

        p：如果是不带p的函数，第一个参数必须传当前命令或者程序的绝对路径，

              如果是带p的函数，第一个参数既可以是绝对路径，也可以是相对路径。

返回值：

        失败：-1

代码示例：

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


int main()
{
    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("in father process\n");
        wait(NULL);
        printf("the soon process has quied\n");
    }
    else
    {
        printf("in son process\n");
#if 0
        if (execl("/bin/ls", "ls", "-l", NULL) == -1)
        {
            perror("fail to execl");
            exit(1);
        }
#endif
#if 0
        if (execlp("ls", "ls", "-l", NULL) == -1)
        {
            perror("fail to execlp");
            exit(1);
        }
#endif
#if 0
        char* str[] = { "ls", "-l",NULL };
        if (execv("/bin/ls", str) == -1)
        {
            perror("fail to execv");
            exit(1);
        }
#endif
#if 0
        if (execlp("./myshell.sh", "./myshell.sh", NULL) == -1)
        {
            perror("fail to execlp");
            exit(1);
        }
#endif
#if 1
        if (execlp("./myshell.sh", "./myshell.sh", NULL) == -1)
        {
            perror("fail to execlp");
            exit(1);
        }
#endif
#if 0
        if (execlp("./hello", "./hello", NULL) == -1)
        {
            perror("fail to execl");
            exit(1);
        }
#endif
#if 0
        if (execl("./hello", "./hello", NULL) == -1)
        {
            perror("fail to execl");
            exit(1);
        }
#endif

        printf("hello world\n");
    }
    return 0;
}
80, 1          Bot

一个进程调用exec后，除了进程ID，进程还保留了下列特征不变：

  • 父进程号
  • 进程组号
  • 控制终端
  • 根目录
  • 当前工作目录
  • 进程信号屏蔽集
  • 未处理信号
  • .....

3. system函数：

#include<stdlib.h>

int system(const char *command);

功能：

        system会调用fork函数产生子进程，子进程调用exec启动/bin/sh -c string来执行参数string字符串所代表的命令，此命令执行完后返回调用进程。

参数：

        要执行的命令的字符串。

返回值：

        如果command为NULL,则system（）函数返回非0，一般为1.

        如果system（）在调用/bin/sh时失败则返回127，其他失败原因返回-1。

注意：

        system调用成功后会返回执行shell命令后的返回值。其返回值可能为1、127也可能为-1，故最好应再检查errno来确认执行成功。

代码示例：

#include<stdio.h>
#include<stlib.h>

int main()
{
    system("clear");
    system("ls -l");
    system("./hello");
    system(. / myshell.sh");

        return 0;
}

总结：

        本章介绍了进程的概念、创建和使用。通过了解进程管理的核心原理，我们可以更好地利用和控制系统资源，实现并发操作，并构建高效的应用程序。深入了解进程的概念和技术，将使我们能够设计出更稳定、可扩展的系统架构，并解决多进程之间的通信和同步问题。

        希望这篇博客能帮助您在应用程序开发过程中更好地理解和应用进程管理的重要性。谢谢阅读！        

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

自动部署代码导致接口访问404

自动部署代码导致接口访问404

问题原因&#xff1a;.user.ini文件中open_basedir与线上服务器中不同导致 由于.user.ini文件特殊性质 需要修改其中文件需要root权限也无法完成 推荐文章(linux系统中文件有哪些隐藏属性_帮助中心_文汇软件_山东文汇信息【官方网站】) 即可解决
阅读更多...
【elementplus】body设置zoom后，el-table开启show-overflow-tooltip后，表格的tooltip显示会错位的解决方案

【elementplus】body设置zoom后，el-table开启show-overflow-tooltip后，表格的tooltip显示会错位的解决方案

由于我的项目是无法避免使用zoom&#xff0c;所以只记录zoom后的解决方案 示例&#xff1a;明明划过的是第一行&#xff0c;tooltip却显示到了第四行的位置&#xff1b; 正确显示&#xff1a;划过第一行&#xff0c;tooltip显示在第一行的位置 代码&#xff1a;使用transfor…
阅读更多...
关于 Asyncio，别再使用run_until_complete了

关于 Asyncio，别再使用run_until_complete了

熟悉Python 的 Asyncio 进行异步编程的小伙伴肯定对下面的写法不陌生&#xff1a; import asyncioasync def test():await asyncio.sleep(3)print("Test rersult")loop asyncio.get_event_loop() loop.run_until_complete(test())这种写法也是在网上搜到的最多的协…
阅读更多...
VUE小白学习-官方网站资料学习-2023年5月22日

VUE小白学习-官方网站资料学习-2023年5月22日

VUE小白学习-官方网站资料学习-2023年5月22日 VUE干啥的&#xff1f;单文件组件&#xff1f;官方说&#xff0c;VUE前端万金油。 日期&#xff1a;2023年5月22日 VUE干啥的&#xff1f; 是一个前端框架&#xff0c;有自己的一套规则&#xff0c;方便前端开发。 单文件组件&am…
阅读更多...
企业微信扫码登陆-详细案例

企业微信扫码登陆-详细案例

以下是实现的pc端企微扫码登陆&#xff0c;话不多时&#xff0c;直接上代码。。。 第1步&#xff1a;企业微信自建应用 第二步&#xff1a;获取到之后拿到 整体流程&#xff1a; 1.企业发起授权登录请求&#xff0c;企业微信用户允许授权后&#xff0c;企业微信会重定向到企业…
阅读更多...
Windows基于WSL搭建Python数据分析环境

Windows基于WSL搭建Python数据分析环境

最近配置了一台较为不错的台式机&#xff0c;记录下自己配置环境的过程。 安装WSL&#xff0c;提供Linux环境 如果你发现后续的命令无法运行或者说软件商城中找不到&#xff0c;这可能意味着你的操作系统不符合要求。WSL安装要求 Windows 10 version 2004&#xff08;Build 19…
阅读更多...
C++之H数回信

C++之H数回信

void H数(int 数) {int Lin 数;while (Lin>1){if (!(Lin % 2) || !(Lin % 3) || !(Lin % 5) || !(Lin % 7)){if (!(Lin % 2))Lin / 2;else if (!(Lin % 3))Lin / 3;else if (!(Lin % 5))Lin / 5;else if (!(Lin % 7))Lin / 7;}else return;}cout << 数 << ends…
阅读更多...
Proxmox 8.0 “Virtual Environment”发布

Proxmox 8.0 “Virtual Environment”发布

导读Proxmox发布新产品Proxmox VE8.0&#xff0c;基于Debian 12.该版本集成了新的Linux内核6.2、QEMU 8.0.2、LXC 5.0.2和OpenZFS 2.1.12&#xff0c;并且还有其他一些新功能和改进。 更新的部分包括更新的Ceph服务器、安装程序ISO增加基于文本的用户界面、整合主机网络桥和VN…
阅读更多...
STM32 Proteus UCOSII系统DS1302万年历时钟秒表控制系统-0056

STM32 Proteus UCOSII系统DS1302万年历时钟秒表控制系统-0056

STM32 Proteus UCOSII系统DS1302万年历时钟秒表控制系统-0056 Proteus仿真小实验&#xff1a; STM32 Proteus UCOSII系统DS1302万年历时钟秒表控制系统-0056 功能&#xff1a; 硬件组成&#xff1a;STM32F103R6单片机 LCD1602显示器多个按键DS1302北京时间 1.单片机程序使…
阅读更多...
java 分布式事务seata的使用

java 分布式事务seata的使用

首先创建一个seata的springboot模块并引入seata的起步依赖 <dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-seata</artifactId> </dependency>模块的目录结构如下 seata.yaml中的内容为&…
阅读更多...
vscode高亮插件——highlight-words（高亮代码、高亮变量、突出显示）

vscode高亮插件——highlight-words（高亮代码、高亮变量、突出显示）

文章目录 官方教程高亮文字使用方法配置 演示变量高亮&#xff08;Highlight Toggle Current&#xff09;选择高亮&#xff08;Highlight Selection with Options&#xff09;删除高亮&#xff08;Highlight Remove&#xff09;侧边栏&#xff08;Highlight Toggle Sidebar&…
阅读更多...
软件测试用例编写规范文档，模板都给你了我看谁还不会写测试用例

软件测试用例编写规范文档，模板都给你了我看谁还不会写测试用例

目录 前言 一 概述 1.1目的 1.2使用范围 二 测试用例编写原则 2.1系统性 2.2连贯性 2.3全面性 三 测试用例设计方法 3.1 等价类划分法&#xff1a; 3.2 边界值分析法&#xff1a; 3.3 因果图法&#xff1a; 3.4功能图法 3.5错误推测法 四 测试用例编写规范 4.1…
阅读更多...
【ARM】-指令预取中止异常中断处理程序的返回

【ARM】-指令预取中止异常中断处理程序的返回

文章目录 处理流程示例 处理流程 在指令预取时&#xff0c;如果目标地址是非法的&#xff0c;该指令被标记成有问题的指令。这时&#xff0c;流水线上该指令之前的指令继续执行。当执行到该被标记成有问题的指令时&#xff0c;处理器产生指令预取中止异常中断。 当发生指令预取…
阅读更多...
解决进入虚拟环境venv后pip路径仍然是在全局路径usr/bin下的问题

解决进入虚拟环境venv后pip路径仍然是在全局路径usr/bin下的问题

问题 解决方法 尝试手动安装pip到你的虚拟环境中。首先&#xff0c;确保在虚拟环境中运行以下命令&#xff1a; python -m ensurepip然后&#xff0c;使用以下命令安装pip到你的虚拟环境中&#xff1a; python -m pip install --upgrade pip
阅读更多...
XR-FRAME 开始

XR-FRAME 开始

目录 新建一个XR组件在页面中使用这个组件添加一个物体来点颜色和灯光有点寡淡&#xff0c;加上图像让场景更丰富&#xff0c;环境数据动起来&#xff0c;加入动画还是不够&#xff0c;放个模型再来点交互组件通信&#xff0c;加上HUD虚拟 x 现实&#xff0c;追加AR能力识别人脸…
阅读更多...
ChatGLM6B LORA微调

ChatGLM6B LORA微调

ChatGLM6B&ChatGLM2-6B微调 目录 ChatGLM6B&ChatGLM2-6B微调 微调硬件需求 3.1. LoRA概述 3.2. LoRA微调ChatGLM步骤 3.2.1. 项目和环境搭建 3.2.2. 数据集处理 3.2.3. 微调 3.2.4. 推理 3.2.5. 完整过程 3.3. LoRA微调ChatGLM步骤-——huggingface PEFT 3.3.1. 项目和…
阅读更多...
通过动态地址解决网络数据采集问题

通过动态地址解决网络数据采集问题

动态地址的作用 说到Python网络爬虫&#xff0c;很多人都会遇到困难。最常见的就是爬取过程中IP地址被屏蔽。虽然大部分都是几个小时内自动解封的&#xff0c;但这对于分秒必争的python网络爬虫来说&#xff0c;是一个关键性的打击&#xff01;当一个爬虫被阻塞时&#xff0c;…
阅读更多...
Qt项目环境构建

Qt项目环境构建

工欲善其事必先利其器&#xff0c;使用Qt来进行开发&#xff0c;得先配置好一个合适的环境。下面是我关于Qt项目环境构建的一些小结 Qt的项目构建主要依赖.pro文件&#xff08;和.pri文件&#xff1a;include包含文件&#xff0c;提供pro的复用性高的东西给多个项目包含) 所以新…
阅读更多...
【企业架构框架】Mitre 架构联邦

【企业架构框架】Mitre 架构联邦

定义&#xff1a; 架构联合是用于企业架构开发、维护和使用的框架&#xff0c;它对齐、定位和链接分离但相关的架构和架构信息&#xff0c;以向用户提供无缝的外观。 关键词&#xff1a; 企业架构&#xff0c;联邦架构&#xff0c;适合联邦&#xff0c;语义对齐&#xff0c;分层…
阅读更多...
想要做好联络口译，需要掌握哪些技能？

想要做好联络口译，需要掌握哪些技能？

据了解&#xff0c;联络口译员经常需要陪在外宾或者委托人身边出席各种各样的活动&#xff0c;除了翻译工作之外&#xff0c;有时还要兼任接待、导游等工作。那么&#xff0c;想要做好联络口译工作&#xff0c;需要掌握哪些技能&#xff1f; 首先&#xff0c;熟悉中外文化差异及…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023