Linux学习之多线程编程（线程的基本控制）

最新推荐文章于 2022-09-25 23:40:19 发布
最新推荐文章于 2022-09-25 23:40:19 发布
阅读量273 收藏
点赞数 2
分类专栏： Linux线程编程 文章标签： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42994525/article/details/83142095
版权

言之者无罪，闻之者足以戒。 ——《诗序》

二、线程的基本控制

1、终止进程：

如果进程中的任意一个进程调用了exit、_exit、_Exit，那么整个进程就会终止

普通的单个进程有以下3种退出方式，这样不会终止进程：

（1）从启动例程中返回，返回值是线程的退出码

（2）线程可以被同一个进程中的其他进程取消

（3）线程调用pthread_exit（void *rval）函数,rval是退出码

下面我们写一个程序用一下三种返回方式：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
void *thread_fun(void *arg)
{
        if(strcmp("1",(char *)arg)==0)
        {
                printf("new thread return \n");
                return (void *)1;

        }
        if(strcmp("2",(char *)arg)==0)
        {
                printf("new thread pthread_exit \n");
                pthread_exit((void *)2);

        }
        if(strcmp("3",(char *)arg)==0)
        {
                printf("new thread exit \n");
                exit(3);
        }
}
int main(int argc,char *argv[])
{
        int err;
        pthread_t tid;
        err=pthread_create(&tid,NULL,thread_fun,(void *)argv[1]);
        if(err!=0)
        {
                printf("create new thread failure\n");
                return 0;
        }
        sleep(1);
        printf("main thread\n");
        return 0;
}

2、线程连接：

（1）pthread_join线程连接函数

int pthread_join(pthread_t tid,void **rval)

第一个参数：tid 就是指定线程的id

 第二个参数：rval就是指定线程的返回码，如果线程被取消，那么rval被置为PTHREAD_CANCELED

返回值：调用成功返回0，失败返回错误码

调用该函数的线程会一直阻塞，直到指定的线程tid调用pthread_exit，从启动例程返回或者被取消；调用该函数会使指定的线程处于分离状态，如果指定的线程已经处于分离状态，那么调用就会失败。

（2）pthread_detach分离线程函数

int pthread_detach(pthread_t thread)

参数：线程的id

返回值：成功返回0，失败返回错误码

调用该函数可以分离一个线程，线程也可以自己分离自己。

下面来看一下程序：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
void *thread_fun1(void *arg)
{
        printf("I am thread 1\n");
        return (void *)1;
}
void *thread_fun2(void *arg)
{
        printf("I am thread 2\n");
        //自己分离自己，如果再用join链接它，就会阻塞
        pthread_detach(pthread_self());
        pthread_exit((void *)2);
}
int main()
{
        int err1,err2;
        pthread_t tid1,tid2;
        void *rval1,*rval2;

        err1=pthread_create(&tid1,NULL,thread_fun1,NULL);
        err2=pthread_create(&tid2,NULL,thread_fun2,NULL);

        if(err1 || err2)
        {
                printf("creatr new thread failure\n");
                return -1;
        }
        printf("I am is main thread\n");
        printf("jion1 rval is %d\n",pthread_join(tid1,&rval1));
        printf("jion2 rval is %d\n",pthread_join(tid2,&rval2));

        printf("thread 1 exit code is%d\n",(int *)rval1);
        printf("thread 2 exit code is%d\n",(int *)rval2);
        printf("I am main thread\n");
        return 0;
}

3、线程的取消：

（1）pthread_cancel取消线程函数

int pthread_cancel(pthread_t tid)

参数：需要取消的线程的id

返回值：成功返回0，失败返回错误码

取消tid指定的线程，所谓的取消只是发送一个请求，并不意味着等待线程终止，而且发送成功也不代表线程一定会终止。该函数需要被取消线程的配合，线程在很多时候会查看自己是否有取消请求，如果有就主动退出，这个查看是否有取消的地方称为取消点。

（2）pthread_setcancelstate设置线程对取消信号的反应

int pthread_setcancelstate(int state,int *oldstate)

第一个参数：有两个值：PTHREAD_CAMCEL_ENABLE(响应取消信号)和PTHREAD_CANCEL_DISABLE（忽略取消信号）

第二个参数：如果不为NULL则是存储原来的取消状态以便恢复

返回值：成功返回0 ，失败返回错误码

取消状态，就是线程对取消信号的处理方式，忽略或者响应。线程创建时默认的是响应取消信号。

（3）pthread_setcanceltype设置线程取消动机的执行时机

int pthread_setcanceltype(int type, int *oldtype)

第一个参数：有两个值：PTHREAD_CANCEL_DEFERRED(收到取消信号后继续运行至下一个取消点再退出)和PTHREAD_CANCEL_ASYNCHRONOUS（收到取消信号后立即退出）。注意：这两个参数是在线程响应取消信号的时候才有作用（PTHREAD_CAMCEL_ENABLE）

第二个参数：oldtype如果不设置为NULL则存储运来的取消动作类型值。

返回值：成功返回0，失败返回错误码

取消类型，是线程对取消信号的响应方式，立即取消或者延时取消。线程创建时默认是延时取消。 

下面先看一下程序的框架：

程序代码：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
void *thread_fun(void *arg)
{
        int stateval;
        int typeval;
        //设置不响应取消信号
        stateval=pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
        if(stateval != 0)
        {
                printf("set cancel state failure\n");
        }
        printf("I am xiaoyi\n");
        //睡眠，返回执行主线程
        sleep(4);

        printf("about to cancel\n");
        //设置为响应取消信号
        stateval=pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
        if(stateval != 0)
        {
                printf("set cancel state failure\n");
        }
        //取消方式为延迟取消
        typeval=pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);
        if(typeval != 0)
        {
                printf("set cancel type failure\n");
        }
        //因为设置的是延迟取消，所以在第一个取消点到来时就会取消，所以看不到第二句话的打印信息
        printf("first cancel point\n");
        printf("second cancel point\n");
        return (void *)10;
}
int main()
{
        pthread_t tid;
        int err,cval,jval;
        void *rval;
        //创建新的线程
        err=pthread_create(&tid,NULL,thread_fun,NULL);
        if(err != 0)
        {
                printf("create thread failure\n");
                return -1;
        }
        //睡眠，执行新的线程
        sleep(2);
        //发送取消信号
        cval=pthread_cancel(tid);
        if(cval != 0)
        {
                printf("cancel thread failure\n");
        }
        jval=pthread_join(tid,&rval);

        printf("new thread exit code is %d\n",(int *)rval);
        return 0;
}

4、向线程发送信号：

（1）pthread_kill发送信号函数

int pthread_kill(pthread_t thread,int sig)

第一个参数：线程的id

第二个参数：要发送的信号

返回值：成功返回0，失败返回错误码

作用：向指定ID的线程发送sig信号，如果线程代码内不做处理，则按照信号默认的行为影响整个进程，也就是说，如果你给一个线程发送了SIGQUIT信号，但线程却没有实现signal处理函数，则整个进程会退出

如果第二个参数不是0 ，那就一定要清楚到底要干什么，而且一定要实现线程的信号处理，否则就会影响整个进程；如果第二个参数是0 ，这就是一个保留信号，其实并没有发送信号，作用是用来判断线程是不是还活着。

下面给出一段代码熟悉一下知识：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

void *thread_fun(void *arg)
{
//      sleep(1);
        printf("I am xiaoyi\n");

        return (void *)0;
}

int main()
{
        pthread_t tid;
        int err;
        int s;
        void *rval;
        err=pthread_create(&tid,NULL,thread_fun,NULL);
        if(err != 0)
        {
                printf("create new thread failure\n");
                return -1;
        }
        sleep(1);

        s=pthread_kill(tid,0);
//      s=pthread_kill(tid,SIGQUIT);
//      if(s == ESRCH)
//      {
//              printf("thread tid is not found\n");
//      }
        if(s != 0)
        {
                printf("thread tid is not found\n");
        }
//      pthread_join(tid,&rval);
        printf("I am main thread\n");
        return 0;
}

（2）sigaction设置一个信号的处理函数

int sigaction(int signum, const struct sigaction *act , struct sigaction *oldact)

第一个参数：信号的名字

第二个参数：传入新的处理方式

第三个参数：传出旧的处理方式

返回值：成功返回0，失败返回错误码

struct sigaction {
               void     (*sa_handler)(int);
               void     (*sa_sigaction)(int, siginfo_t *, void *);
               sigset_t   sa_mask;
               int        sa_flags;
               void     (*sa_restorer)(void);
           }

sa_handler：指定信号捕捉后的处理函数名，也可以赋值为SIG_IGN表示忽略或SIG_DFT表示执行默认操作

sa_mask：调用信号处理函数时，所要屏蔽的信号集合（信号屏蔽字）。注意：仅在处理函数被调用期间屏蔽生效，是临时性设置。用sigaddset函数添加需要被捕捉的信号。

 sa_flags：通常设置为0，表示使用默认属性，为0的时候，可以屏蔽正在处理的信号（若在处理二号信号的时候又有二号信号，则此时传来的二号信号就会被屏蔽）

（3）sigemptyset清空信号集

int sigemptyset(sigset_t *set)

参数：信号集

返回值：成功返回0，失败返回-1

（4）sigfillset将所有信号加入信号集

int sigfillset(sigset_t *set)

参数：信号集

返回值：成功返回0，失败返回-1

（5）sigaddset增加一个信号到信号集

int sigaddset(sigset_t *set , int signum)

第一个参数：信号集

第二个参数：要增加的信号

返回值：成功返回0，失败返回-1

（6）sigdelset将指定信号从信号集中删除

int sigdelset(sigset_t *set , int signum)

第一个参数：信号集

第二个参数：要删除的信号

返回值：成功返回0，失败返回-1

（7）pthread_sigmask在主线程中控制信号掩码

int pthread_sigmask(int show ,const sigset_t set, sigset_t *oldset)

第一个参数： SIG_BLOCK：向当前的信号掩码中添加set，其中set表示要阻塞的信号组。

                         SIG_UNBLOCK：向当前的信号掩码中删除set，其中set表示要取消阻塞的信号组。

                          SIG_SETMASK：将当前的信号掩码替换为set，其中set表示新的信号掩码。

第二个参数：信号组

第三个参数：以前的信号组

返回值：成功返回0 ，失败返回错误码

在多线程中，新线程的当前信号掩码会继承创造它的信号掩码。

一般情况下被阻塞的信号将不能中断此线程的执行，除非此信号的产生是因为程序运行出错；如SIGSEGV，另外不能被忽略处理的信号 SIGKILL 和 SIGSTOP 也无法被阻塞。

我们写一个程序学习一下上面的这些函数：

先看一下程序的框架：

再看一下程序的代码：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

void sig_handler1(int arg)
{
        printf("thread1 get signal\n");
        return;
}
void sig_handler2(int arg)
{
        printf("thread2 get signal\n");
        return;
}
void *thread_fun1(void *arg)
{
        printf("new thread 1\n");
        struct sigaction act;
        //清空结构体变量
        memset(&act,0,sizeof(act));
        //添加一个信号到信号集
        sigaddset(&act.sa_mask,SIGQUIT);
        //设置信号的处理函数名
        act.sa_handler = sig_handler1;
        //设置一个信号的处理函数
        sigaction(SIGQUIT,&act,NULL);
        //添加要阻塞的信号
//      pthread_sigmask(SIG_BLOCK,&act.sa_mask,NULL);
        sleep(2);
}
void *thread_fun2(void *arg)
{
        printf("new thread 2\n");
        struct sigaction act;
        //清空结构体变量
        memset(&act,0,sizeof(act));
        //添加一个信号到信号集
        sigaddset(&act.sa_mask,SIGQUIT);
        //设置一个信号的处理函数名
        act.sa_handler = sig_handler2;
        //设置一个信号的处理函数
        sigaction(SIGQUIT,&act,NULL);
        //添加要阻塞的信号
        pthread_sigmask(SIG_BLOCK,&act.sa_mask,NULL);
        sleep(2);
}
int main()
{
        pthread_t tid1,tid2;
        int err;
        int s;
        //创建新的线程 1
        err = pthread_create(&tid1,NULL,thread_fun1,NULL);
        if(err != 0)
        {
                printf("create new thread 1 failure\n");
                return ;
        }
        //创建新的线程 2
        err = pthread_create(&tid2,NULL,thread_fun2,NULL);
        if(err != 0)
        {
                printf("create new thread 2 failure\n");
                return ;
        }
        //主线程睡眠，执行新的线程
        sleep(1);
        //向新的线程 1 发送信号
        s=pthread_kill(tid1,SIGQUIT);
        if(s != 0)
        {
                printf("send signal to thread1 faailure\n");
        }
        //向新的线程 2 发送信号
        s=pthread_kill(tid2,SIGQUIT);
        if(s != 0)
        {
                printf("send signal to thread2 faailure\n");
        }
        //链接两个新的线程
        pthread_join(tid1,NULL);
        pthread_join(tid2,NULL);

        return 0;


}

5、清除操作

线程可以安排它退出时的清理操作，这与进程可以用atexit函数安排进程退出时需要调用的函数类似。这样的函数称为线程清理处理程序。线程可以建立多个清理处理程序，处理程序记录在栈中，所以这些处理程序执行的顺序与他们注册的顺序相反（先注册的后执行）。

 （1）pthread_cleanup_push注册处理程序

void pthread_cleanup_push(void (*routine)(void *), void *arg)

第一个参数：一个处理函数

第二个的参数：处理函数的入口参数

返回值：无

（2）pthread_cleanup_pop清除处理程序

void pthread_cleanup_pop(int execute)
            参数：非零即调用

返回值：无

当执行以下操作时调用清理函数，清理函数的参数由arg传入：

1）调用pthread_exit
             2）响应取消请求
             3）用非零参数调用pthread_cleanup_pop

下面来看一下程序：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

void *first_clean(void *arg)
{
        printf("%s first clean\n",arg);
        return (void *)0;
}
void *second_clean(void *arg)
{
        printf("%s second clean\n",arg);
        return (void *)0;
}
void *thread_fun1(void *arg)
{
        printf("new thread 1 \n");
        //注册处理程序
        pthread_cleanup_push(first_clean,"xiaoyi1");
        pthread_cleanup_push(second_clean,"xiaoyi1");
        //调用清除处理程序函数（入口参数非零即调用）
        pthread_cleanup_pop(1);
        pthread_cleanup_pop(1);

        return (void *)1;
}
void *thread_fun2(void *arg)
{
        printf("new thread 2 \n");
        //注册处理程序
        pthread_cleanup_push(first_clean,"xiaoyi2");
        pthread_cleanup_push(second_clean,"xiaoyi2");
        //调用清除处理程序函数（入口参数非零即调用）
        pthread_cleanup_pop(0);
        pthread_cleanup_pop(1);

        pthread_exit((void *)2);
}
int main()
{
        pthread_t tid1,tid2;
        int err;
        //创建新的线程 1
        err =pthread_create(&tid1, NULL, thread_fun1, NULL);
        if(err != 0)
        {
                printf("create new thread 1failed\n");
                return;
        }
        //创建新的线程 2
        err =pthread_create(&tid2, NULL, thread_fun2, NULL);
        if(err != 0)
        {
                printf("create new thread 2failed\n");
                return;
        }
        //主线程休眠，执行新线程
        sleep(2);

        return 0;

}

到这里为止线程的基本操作就说完了。

不怨天，不尤人
关注
专栏目录
Linux多线程学习
09-15
学习文档包括线程的创建和退出、线程属性设置、互斥锁线程控制和信号量线程控制。
linux多线程学习（一）
阿堂的专栏
01-13 3499
进程是系统中程序执行和资源分配的基本单位。每个进程都有自己的数据段，代码段和堆栈段，这就导致了进程在进行切换等操作起到了现场保护作用。但是为了进一步减少处理机的空转时间支持多处理器和减少上下文切换开销，进程演化中出现了另外一个概念，这就是线程，也被人称为轻量级的进程。它是一个进程内的基本调度单位。线程是在共享的内存空间中并发的多道执行路径，它们共享一个进程的资源，比如文件描述符和信号处理等。因此，
Linux 多线程学习
阿修罗道
09-14 1832
一、多线程 VS 多进程      和进程相比，线程有很多优势。在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护代码段和数据。而运行于一个进程中的多个线程，他们之间使用相同的地址空间。正是这样，同一进程下的线程之间共享数据空间，数据可以
Linux学习之多线程编程（线程的同步）
键盘上的手艺人
10-20 348
言之者无罪，闻之者足以戒。 ——《诗序》 （三）、线程的同步 1、互斥量 当多个线程共享相同的内存时，需要每一个线程看到相同的视图。当一个线程修改变量时，而其他线程也可以读取或者修改这个变量，就需要对这些线程同步，确保他们不会访问到无效的变量。 在变量修改时间多于一个存储器访问周期的处理器结构中，当存储器的读和写这两个周期交叉时，这种潜在的不一致性就会出现。当然这与处理器相关，但是在可移植...
Linux——多线程学习
m0_49830036的博客
09-25 252
因此我们举个例子来描述，如果此时有一个线程A，按照先锁a再获得锁b的的顺序获得锁，而在此同时又有另外一个线程B，按照先锁b再锁a的顺序获得锁。主要知道进程有独立的地址空间，而线程没有独立的地址空间（同一进程内线程共享地址空间），所以一个进程奔溃后，在保护模式下不会对其他进程产生影响，但一个线程死掉等于整个进程死掉，因此多进程的程序要比多线程的程序健壮。下面demo验证线程之间是共享地址空间的，如果没有加锁，线程之间是存在竞争的 ，加锁之后能保证拿到锁的线程先只执行完，再执行其他线程。
Linux系统下的多线程编程入门.pdf
最新发布
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
Linux下的多线程编程.pdf
09-06
Linux下的多线程编程是一种高效的程序设计方法，它可以将一个程序的任务划分为多个部分，每个部分是一个顺序控制流。多线程编程可以实现并行计算，高效利用多处理器，并且具有许多优点，如节约系统资源、方便的线程...
linux_code.rar_linux 多线程_linux 线程_多线程编程
09-14
在Linux系统中，多线程编程是实现高效并发执行任务的一...总的来说，这份压缩包为学习Linux多线程编程提供了宝贵的实践材料，通过深入研究这些源码，你可以更好地理解和掌握多线程在Linux环境中的工作原理和最佳实践。
Linux多线程服务端编程，高清无水印！~
03-05
Linux多线程服务端编程，高清无水印！~
linux多线程学习
qq_46399246的博客
05-11 273
学习笔记 1、多线程 多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。 在操作系统原理的术语中，线程是进程的一条执行路径。线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可
linux 多线程学习
CNMNMSL1的博客
02-25 490
LESSON1 目标：掌握线程下基本改进 了解线程的优势 进程：一个正在执行的程序 ，它是资源分配的最小单位 进程中的事情需要按照一定的顺序逐个进行 线程：有时又称轻量级进程，程序执行的最小单位，系统独立调度和分派CPU的基本单位，它是进程的一个实体。一个进程中可以有多个线程，这些线程共享进程的所有资源，线程本身只包含了一点必不可少的资源。进程只是为了申请资源，真正执行的是线程，例如一个程序中 的...
Linux多线程学习------01
h593245631的博客
05-28 194
1.什么是线程 进程： 资源的管理（管理内存，管理打开的文件等。。。） 线程： 线程是运行在进程之中的，一个进程包含若干线程，和进程相似，也是抢先式的调度（Linux也把线程叫做轻量级进程LWP） ps：进程是资源分配的基本单位，线程是调度的基本单位 2.线程的优点 创建一个线程要比创建一个进程的开销小的多（线程之间共用一个虚拟地址空间） 线程之间切换比进程之间切换的工作要少的多 线程占用...
多线程linux学习,linux多线程学习(1)
weixin_30686891的博客
05-09 97
首先，编写一个耗时的单线程程序：#include#includeintmain(){sleep(5);printf("program exited.\n");}编译并运行这段程序，该程序5秒后输出，sleep期间不再响应其它消息或执行其他操作。为了更好地处理这种耗时的操作，我们需要使用多线程编程。先从书上抄些东西：进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空...
Linux多线程学习------03
h593245631的博客
06-04 194
1.Linux线程互斥 进程线程间的互斥相关背景概念 临界资源：多线程执行流共享的资源就叫做临界资源 临界区：每个线程内部，访问临界资源的代码，就叫做临界区 互斥： 任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用 原子性： 不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成 1.1互斥量mutex 大部分情况，线程使用的数据都是局...
Linux多线程编程学习（1）
weixin_42145502的博客
07-15 210
1.学习路线 2.开始多线程之旅 2.1 啥是线程 回顾：进程是一个正在执行的程序，它是资源分配的最小单位； 进程中的事情需要按照一定的顺序逐个进行，那么如何让一个进程中的一些事情同时执行呢？ 例子：服务器---需要用多线程 线程又称作是轻量级进程，是程序执行的最小的单位，系统独立调度和分配CPU的基本单位。他是进程中的一个实体。一个进程有...
Linux多线程编程之线程控制
zyh_helen的专栏
03-08 882
函数预览 pthread_t pthread_id;int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg); //线程创建   thread指向存放创建线程的id attr设置创建线程的属性 start_rout
Linux系统编程——线程控制（一）
无夜之凛冬的博客
03-06 493
一 线程的基本概念 线程是在共享内存空间中并发的多道执行路径，它们共享一个进程的资源，如文件描述符和信号处理。操作系统在两个进程间进行切换时，要对前一个进程进行保护现场操作，对后一个进程进行还原现场操作。反复进行上下文切换会带来极大的开销。线程则无需进行上下文切换，因为多个线程共享同一个进程的上下文。多个线程也共享同一个进程的CPU时钟周期，进程的状态并未因线程切换而改变。 二线程的实现 1.用户...
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值