多线程编程（上）

最新推荐文章于 2024-11-03 00:42:08 发布
最新推荐文章于 2024-11-03 00:42:08 发布
阅读量141 收藏
点赞数 1
分类专栏： Linux环境C语言编程 文章标签： c语言 操作系统 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/STX19980909/article/details/120485256
版权

1.什么是线程？
源代码 -编译和链接-> 程序 -加载到内存中-> 进程
                                       |                                  |
                                    文件                             内存
                                                                        /   \
                                                                 代码 <- 执行
                                                                 数据 <- 处理
                                                                    |            | <- CPU
                                                                 静态      动态
                                                                    |            |
                                                                 资源      线程
线程就是进程的执行过程，即进程内部的控制序列，或者说是进程中的一个任务。
一个进程可以同时拥有多个线程，即同时被系统调度的多个执行路径，但至少要有一个主线程——main函数及被其调用的其它函数。
一个进程的所有线程都共享进程的代码区、数据区、BSS区、堆区、环境变量和命令行参数区、文件描述符表、信号处理函数、当前工作目录、用户和组的各种ID等。但是栈区不是共享的，一个进程的每个线程都拥有自己独立的栈区。

线程调度：
1)系统内核中专门负责线程调度的处理单元被称为调度器；
2)调度器将所有处于就绪状态(没有阻塞在任何系统调用上)的线程排成一个队列，即所谓就绪队列；
3)调度器从就绪队列中获取队首线程，为其分配一个时间片，并令处理器执行该线程，过了一段时间：
A.该线程的时间片耗尽，调度器立即终止该线程，并将其排到就绪队列的尾端，接着从队首获取下一个线程；
B.该线程的时间片未耗尽，但需阻塞于某系统调用，比如等待I/O或者睡眠。调度器会中止该线程，并将其从就绪队列中移至等待队列，直到其等待的条件满足后，再被移回就绪队列；
4)在低优先级线程执行期间，有高优先级线程就绪，后者会抢占前者的时间片；
5)若就绪队列为空，则系统内核进入空闲状态，直至其非空；
6)象Linux这样的多任务分时系统，基本的调度单位是线程；
7)为线程分配的时间片不宜过长，因为时间片太长会导致没有获得处理机的线程等候时间过久，降低系统运行的并行性，用户会感觉到明显的响应延迟；时间片也不宜过短，因为过短的时间片会增加在线程之间切换上下文的频率，降低系统的运行性能。

2.线程的基本特点
1)线程是进程中的独立实体，可以拥有自己的资源，可以被独立标识——线程ID，同时也被作为基本调用单元，参与时间片的分配。
2)线程有不同的状态，如创建、运行、终止、暂停、恢复、取消等。
3)线程可以使用的大部分资源还是隶属于进程的，因此线程作为进程的一部分不能脱离进程独立存在。
4)一个进程可以同时执行多个线程，这些线程可以执行相同的代码，完成相同的任务，也可以执行不同的代码，完成不同的任务。
5)创建一个线程所花费的开销远小于创建进程的开销。线程也称为轻量级进程。因此在解决诸如并发问题等问题时，优先考虑多线程，其次才是多进程。
6)多线程的问题在于因为太多的资源被共享，极易导致冲突，为了解决冲突可能需要增加额外的开销，因此多进程仍然有它的优势。
进程，内存壁垒，通信。
线程，内存共享，同步。

3.POSIX线程
#include <pthread.h>
链接时要加上-lpthread    -lpthread -> libpthread.so

4.创建线程
线程过程函数：在一个线程中被内核调用的函数，对该函数的调用过程就是线程的执行过程，从该函数中返回就意味着线程的结束。因此，main函数其实就是一个进程的主线程的线程过程函数。所有自创建的线程都必须有一个对应线程过程函数。
void* 线程过程函数(void*arg) {
    线程的执行过程
}
arg - 线程参数指针

int pthread_create(pthread_t* tid, const pthread_attr_t* attr, void* (*start_routine)(void*), void* arg);
成功返回0，失败返回错误码。
tid - 输出线程标识(TID)。
attr - 线程属性，NULL表示缺省属性。
start_routine - 线程过程函数指针
arg - 线程参数指针
pthread_create
    ->1、创建一个新线程
        ->2、调用线程过程函数(start_routine)并传入线程参数指针(arg)
被创建的子线程和创建该子线程的父线程是并行的关系，其调度顺序无法预知，因此当pthread_create函数返回时子线程执行的位置无从确定，其线程过程函数可能尚未被调用，也可能正在执行，甚至可能已经返回。传递给线程的参数对象，一定要在线程过程函数不再使用它的情况下才能被释放。
代码：create.c

/* create.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void* thread_proc(void* arg) {
    printf("%lu线程：%s\n", pthread_self(), (char*)arg);
    return NULL;
}
int main(void) {
    pthread_t tid;
    int error = pthread_create(&tid, NULL, thread_proc, "我是子线程！");
    if (error) {
        fprintf(stderr, "pthread_create: %s\n", strerror(error));
        return -1;
    }
    printf("%lu线程：我是主线程，创建%lu线程。\n", pthread_self(), tid);
    sleep(1);
    return 0;
}

使用pthread_self()可查看线程自己的TID

主线程和通过pthread_create函数创建的多个子线程，在时间上“同时”运行，如果不附加任何同步条件，则它们每一个执行步骤的先后顺序完全无法预知，这就叫做自由并发。
为了让线程过程函数的实现更加灵活，可以通过线程参数传递特定的信息，帮助线程过程函数执行不同的任务。
代码：arg.c

/* arg.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <pthread.h>
#define PI 3.14159
void* thread_area(void* arg) {
    double r = *(double*)arg;
    *(double*)arg = PI * r * r;
    return NULL;
}
struct Pyth {
    double a, b, c;
};
void* thread_pyth(void* arg) {
    struct Pyth* pyth = (struct Pyth*)arg;
    pyth->c = sqrt((pyth->a * pyth->a + pyth->b * pyth->b));
    return NULL;
}
void* thread_aver(void* arg) {
    double* d = (double*)arg;
    d[2] = (d[0] + d[1]) / 2;
    return NULL;
}
void* thread_show(void* arg) {
    printf("%d\n", *(int*)arg);
    return NULL;
}
int main(void) {
    pthread_t tid;
    double r = 10;
    pthread_create(&tid, NULL, thread_area, &r);
    usleep(100000);
    printf("%g\n", r);
    struct Pyth pyth = {3, 4};
    pthread_create(&tid, NULL, thread_pyth, &pyth);
    usleep(100000);
    printf("%g\n", pyth.c);
    double d[3] = {123, 456};
    pthread_create(&tid, NULL, thread_aver, d);
    usleep(100000);
    printf("%g\n", d[2]);
    int* n = malloc(sizeof(int));
    *n = 1234;
    pthread_create(&tid, NULL, thread_show, n);
    usleep(100000);
    free(n);
    return 0;
}

gcc -o arg arg.c -lpthread -lm

5.汇合线程
       创建点       汇合点
--------+---------+-------> 主线程
             \________/ 子线程
int pthread_join(pthread_t tid, void** retval);
成功返回0，失败返回错误码。
tid - 线程标识
retval - 线程退出码
当调用pthread_join函数时：
tid线程已经终止，立刻返回，返回线程退出码。
tid线程尚未终止，阻塞等待，直到被汇合线程终止。
void* 线程过程函数(void* 线程参数指针) {
    线程的执行过程
    return p;
}
功能：等待子线程终止，清理线程的资源，获得线程过程函数的返回值
代码：join.c

/* join.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <pthread.h>
#define PI 3.14159
void* thread_area(void* arg) {
    double r = *(double*)arg;
    double* s = malloc(sizeof(double));
    *s = PI * r * r;
    return s;
}
int main(void) {
    pthread_t tid;
    double r = 10;
    pthread_create(&tid, NULL, thread_area, &r);
    double* s;
    pthread_join(tid, (void**)&s);
    printf("%g\n", *s);
    free(s);
    return 0;
}

6.分离线程
在有些时候作为子线程的创建者，父线程可能并不关心子线程何时终止，同时父线程也不需要获得子线程的返回值。这种情况下，就可将子线程设置为分离线程，这样的线程一旦终止，它们的资源会被系统自动回收，而无需在其父线程中调用pthread_join函数。
int pthread_detach(pthread_t tid);
成功返回0，失败返回错误码。
tid - 线程标识
代码：detach.c

/* detach.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void* thread_proc(void* arg) {
    for (int i = 0; i < 200; ++i) {
        putchar('-');
        usleep(50000);
    }
    return NULL;
}
int main(void) {
    setbuf(stdout, NULL);
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_t tid;
    pthread_create(&tid, /*NULL*/&attr, thread_proc, NULL);
    pthread_attr_destroy(&attr);
    //pthread_detach(tid);
    int error = pthread_join(tid, NULL);
    if (error)
        fprintf(stderr, "pthread_join: %s\n", strerror(error));
    for (int i = 0; i < 200; ++i) {
        putchar('+');
        usleep(100000);
    }
    printf("\n");
    return 0;
}

pthread_attr_t  attr;
pthread_attr_init(&attr); // 用缺省值初始化线程属性
pthread_attr_setdetachstat(&attr,PTHREAD_CREATE_DETACHED);
pthread_create(..., &attr, ...);
pthread_attr_destroy(&attr);

7.线程ID
pthread_t tid;
pthread_create(&tid, ...);—>输出子线程的TID
pthread_self(); -> 返回调用线程的TID
if (tid1 == tid2) // 对于结构体来说兼容性不好
    ...
int pthread_equal(pthread_t tid1, pthread_t tid2);
两个TID相等返回非零，否则返回0。
if (pthread_equal(tid1, tid2)) // 兼容性好
代码：equal.c

/* equal.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <syscall.h>
#include <pthread.h>
pthread_t g_main; // 主线程的TID
void foo(void) {
    if (pthread_equal(pthread_self(), g_main))
        printf("foo函数在主线程中被调用了。\n");
    else
        printf("foo函数在子线程中被调用了。\n");
}
void* thread_proc(void* arg) {
    printf("系统内核的子线程TID：%ld\n", syscall(SYS_gettid));
    foo();
    return NULL;
}
int main(void) {
    g_main = pthread_self();
    printf("POSIX库的主线程TID：%lu\n", g_main);
    printf("系统内核的主线程TID：%ld\n", syscall(SYS_gettid));
    printf("进程的PID：%d\n", getpid());
    foo();
    pthread_t tid;
    pthread_create(&tid, NULL, thread_proc, NULL);
    pthread_join(tid, NULL);
    return 0;
}

通过pthread_self函数返回的线程ID和pthread_create函数输出的线程ID一样都是由PTHREAD库内部维护的虚拟(伪)线程ID，可用于其它需要提供线程ID的PTHREAD函数。系统内核维护的真实线程ID，可通过syscall(SYS_gettid)获得：
#include <unistd.h> // 声明syscall函数
#include <syscall.h> // 定义SYS_gettid宏
在Linux系统中，一个进程的PID实际上就是其主线程的TID。

8.终止线程(自己)
1)从线程过程函数中返回，执行该过程函数的线程即终止。其返回值可通过pthread_join函数的第二参数输出给调用者。
2)在线程过程函数及被其调用的任何函数中都可以调用pthread_exit函数终止当前线程：
void pthread_exit(void* retval);
该函数的参数retval就相当于线程过程函数的返回值，同样可被pthread_join的第二个参数输出给调用者。
代码：exit.c

/* exit.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <pthread.h>
#define PI 3.14159
void calc_area(double r) {
    double* s = malloc(sizeof(double));
    *s = PI * r * r;
    pthread_exit(s);
}
void* thread_area(void* arg) {
    printf("调用calc_area函数...\n");
    calc_area(*(double*)arg);
    printf("从calc_area函数返回。\n");
    return NULL;
}
int main(void) {
    pthread_t tid;
    double r = 10;
    pthread_create(&tid, NULL, thread_area, &r);
    //pthread_exit(NULL);
    double* s;
    pthread_join(tid, (void**)&s);
    printf("%g\n", *s);
    free(s);
    return 0;
}

注意：在子线程中调用pthread_exit，只会终止调用线程自己，对其其它兄弟线程和主线程没有影响。但如果在主线程中调用pthread_exit，被终止的将是整个进程及其所包含的全部线程。

9.取消(其它)线程
int pthread_cancel(pthread_t tid);
成功返回0，失败返回错误码。
tid - 被取消线程的TID。
该函数只是向特定线程发出取消请求，并不等待其终止运行。缺省情况下，线程在收到取消请求以后，并不会立即终止，而是仍继续运行，直到达到某个取消点。在取消点处，线程检查其自身是否已被取消，若是则立即终止。取消点通常出现在一些特定的系统调用中。
设置调用线程的取消状态为接受或忽略取消请求：
int pthread_setcancelstate(int state, int* oldstate);
state - 取消状态，可取以下值：
PTHREAD_CANCEL_ENABLE - 接受取消请求(缺省)
PTHREAD_CANCEL_DISABLE - 忽略取消请求
old_state - 输出原取消状态，可取NULL。
设置调用线程的取消类型为延迟取消或立即取消：
int pthread_setcanceltype(int type, int* oldtype);
type - 取消类型，可取以下值：
PTHREAD_CANCEL_DEFERRED - 延迟取消(缺省)，接到取消请求，如果不是忽略的话，继续运行一段时间，直到执行取消点时再终止。
PTHREAD_CANCEL_ASYNCHRONOUS - 立即取消，接到取消请求，如果不是忽略的话，立刻终止运行。
old_type - 输出原取消类型，可取NULL。
代码：cancel.c

/* cancel.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
void elapse(void) {
    for (unsigned int i = 0; i < 800000000; ++i);
}
void* thread_proc(void* arg) {
    /*
    // 禁止接受取消请求
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
    */
    // 取消类型立即取消
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    for (;;) {
        printf("线程：子在川上曰，逝者如斯夫。\n");
        elapse();
    }
    return NULL;
}
int main(void) {
    setbuf(stdout, NULL);
    pthread_t tid;
    pthread_create(&tid, NULL, thread_proc, NULL);
    getchar();
    printf("向线程发送取消请求...\n");
    pthread_cancel(tid);
    printf("等待线程终止...\n");
    pthread_join(tid, NULL);
    printf("线程已终止。\n");
    return 0;
}

10.线程冲突
g = 0
线程1                                   线程2
把内存(g=0)中的值读入寄存器(eax=0)
把寄存器(eax=0->1)中的值加1
把寄存器(eax=1)中的值存入内存(g=1)
                                  把内存(g=1)中的值读入寄存器(eax=1)
                                  把寄存器(eax=1->2)中的值加1
                                  把寄存器(eax=2)中的值存入内存(g=2)
线程1                                   线程2
把内存(g=0)中的值读入寄存器(eax=0)
                                  把内存(g=0)中的值读入寄存器(eax=0)
把寄存器(eax=0->1)中的值加1
                                  把寄存器(eax=0->1)中的值加1
把寄存器(eax=1)中的值存入内存(g=1)
                                  把寄存器(eax=1)中的值存入内存(g=1)
当两个或两个的线程同时以非原子化的方式访问同一个对象时，极有可能导致对象的最终状态不稳定，这就是所谓的线程冲突。解决冲突的基本原则就是敏感操作的原子化，即保证一个线程完成这组敏感操作以后，再允许另个线程执行类似的操作，位于与共享资源有关的操作代码，在任何时候都只允许一个线程执行。
代码：vie.c

/* vie.c */
#include <stdio.h>
#include <string.h>
#include <pthread.h>
unsigned int g = 0;
void* thread_proc(void* arg) {
    for (unsigned int i = 0; i < 100000000; ++i)
        ++g;
    return NULL;
}
int main(void) {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, thread_proc, NULL);
    pthread_create(&t2, NULL, thread_proc, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("g = %u\n", g);
    return 0;
}

暗里い着迷
关注
专栏目录
进程与线程
azgtjj5942的博客
09-17 162
目录 计算机的核心是CPU，CPU承担了所有的计算任务 一个CPU核心一次只能执行一个任务，多个CPU核心可以同时执行多个任务 一个CPU一次只能执行一个进程，其他进程处于非运行状态 进程中包含的执行单元叫线程，一个进程可以包含多个线程。 一个线程中内存空间是共享的，每个进程里的线程都可以使用这个共享空间，一个线程在使用这个共享空间的时...
进程和线程
qq_41821743的博客
09-15 123
学习篇UC-进程和线程 进程 什么是进程 （进程是程序在CPU中运行时的整个生命周期的动态记录） 进程是系统中正在运行的一个程序，程序一旦运行就是进程。 进程可以看成程序执行的一个实例。进程是系统资源分配的独立实体，每个进程都拥有独立的地址空间。一个进程无法访问另一个进程的变量和数据结构，如果想让一个进程访问另一个进程的资源，需要使用进程间通信，比如管道，文件，套接字等。 线程 什么是线程 线程就是进程的执行过程，即进程的内部控制序列，或者说是进程中的一个任务。 一个进程可以同时拥有多个线程，并且同时可以系
进程与线程的概念
独行Freedom的博客
03-15 306
（1）程序和进程是不同的。 进程：是一个程序之后得到的一个实体，没有程序就没有进程，有了程序不见得有进程。 广义概念： 进程是程序关于某个数据集合的一次运行活动。 狭义概念： 程序被加载到内存中执行后得到进程。 （2）联系 2.1一个程序可能对应多个进程 2.2一个进程可能包含多个程序 注意点： 在当代操作系统中，资源分配的基本单元是进程；而CPU调度执行的基本单位是线程。 ...
72、进程与线程
WS857707645的博客
07-30 756
72、进程与线程的概念 值得深思的问题：什么是程序？什么是进程？程序和进程有什么关系？ 程序是计算机存储系统中的数据文件： 源代码程序：文本文件，描述程序行为和功能。不能直接运行 可执行程序：二进制文件，直接加载并执行。 源代码程序-&gt;编译器-&gt;可执行程序（二进制） 进程的概念：有了程序不见得有进程，执行程序得到的 广义概念：程序关于某个数据集合的一次运行活动。 狭义概念：程序被加...
多线程环境下，主线程先退出，子线程会被强制退出吗？
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
09-01 3464
1、进程中线程之间的关系 线程不像进程，一个进程中的线程之间是没有父子之分的，都是平级关系。即线程都是一样的, 退出了一个不会影响另外一个。 但是所谓的"主线程"main,其入口代码是类似这样的方式调用main的：exit(main(…))。 main执行完之后, 会调用exit()。 exit() 会让整个进程over终止，那所有线程自然都会退出。 2、主线程先退出，子线程继续运行的方法 在进程...
Linux系统下的多线程编程入门.pdf
12-20
多线程编程需考虑性能优化，包括减少上下文切换、合理分配工作负载、使用合适的同步机制等。调试多线程程序通常较复杂，gdb等调试器提供了线程查看和控制功能，帮助开发者定位问题。 总结，Linux系统的多线程编程为...
C++多线程编程.pdf
09-05
C++多线程编程
C#多线程编程实例实战.pdf
10-24
C#多线程编程实例实战 C#多线程编程实例实战是指在C#语言中实现多线程编程的实例和实战经验。多线程编程是指在同一个进程中创建多个线程，以便提高程序的执行效率和响应速度。在C#语言中，可以使用Thread类和线程池...
Linux下的多线程编程.pdf
09-06
"Linux下的多线程编程" Linux下的多线程编程是一种高效的程序设计方法，它可以将一个程序的任务划分为多个部分，每个部分是一个顺序控制流。多线程编程可以实现并行计算，高效利用多处理器，并且具有许多优点，如...
【arduino多线程编程】arduino竟然还能多线程编程？确定不进来夸一下嘛……
01-06
  看了上一篇《arduino面向对象编程》是不是感觉arduino已经到极限了？NO,NO,NO,arduino远远不止如此，不信你往下看：   理解了单线程就很容易理解多线程了吧，举个例子，假设有语文作文和数学试卷两个任务等你...
有了多线程后，多线程是否可以完全取代多进程编程了？
正月看雪花的博客
03-25 976
一：什么是线程， 什么是进程 进程：是执行中一段程序，即一旦程序被载入到内存中并准备执行，它就是一个进程。进程是表示资源分配的的基本概念，又是调度运行的基本单位，是系统中的并发执行的单位。 线程：单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。 关系： 一个线程只能属于一个进程，但是一个进程可以拥有多个线程。多线程处理就是允许一个进程中在同一时刻执行多个任务。 线程没有地址...
（八）C线程
GSX
11-27 797
1.线程为什么能弥补进程的缺点 为什么线程切换的开销很低 但是使用多线程来实现多线任务时，由于线程本质上它只是程序（进程）的一个函数，只不过线程函数 与普通函数的区别是，普通函数时单线的运行关系，而线程函数被注册为线程后，是多线并发运行。 对于普通函数来说，只有相互调动时才会涉及函数间的切换，但是对于线程函数来说，只要运行时间片到了就会切换，...
进程、线程和协程之间的区别和联系
热门推荐
青萍之末的博客
10-06 11万+
一、进程   进程，直观点说，保存在硬盘上的程序运行以后，会在内存空间里形成一个独立的内存体，这个内存体有自己的地址空间，有自己的堆，上级挂靠单位是操作系统。操作系统会以进程为单位，分配系统资源，所以我们也说，进程是资源分配的最小单位。 【进程间通信（IPC）】： 管道(Pipe) 所有的 POSIX systems, Windows； 命名管道(FIFO) 所有的 POSIX 系统...
C++线程的封装
好好学习，天天向上
07-19 1629
在C中创建线程一般是差不多以下这种形式: void* thread_proc(void* arg){ //线程执行过程 } int main(void){ pthread_t tid; pthread_create(&tid,NULL,thread_proc,...); return 0; } 当我们要用C++把其封装成类的时候，可能会写出这样的程序： class Thread{...
【内核调度、负载计算】【update_curr】
勿于浮沙筑高台
07-08 1442
1、update_curr Update the current task's runtime statistics. /* * Update the current task's runtime statistics. */ static void update_curr(struct cfs_rq *cfs_rq) { struct sched_entity *curr = cfs_rq->curr; u64 now = rq_clock_task(rq_of(cfs_rq));
Linux 下的信号量
zaishaoyi的专栏
04-30 2105
linux下的posix有名信号量的几个要点---博客园 最全面的linux信号量解析 csdn blog Semaphore信号量总结——博客园 sem_timedwaitcsdn blog 一、信号量的概念 信号量的使用主要是用来保护共享资源，使得资源在一个时刻只有一个进程（线程） 所拥有。 信号量的值为正的时候，说明它空闲。所测试的线程可以锁定而使用它。若为0，说明 它被占用
Fork（）非常好的例子
SimonChowChun的专栏
06-28 1099
#include int main(void) { int p1; putchar(x); while((p1=fork())==-1); if(p1==0) printf("b"); else printf("a"); printf("y"); }结果不是xxbyay，而是xbyxay，为什么呀。。 因为标准输出是line buffered程序真正分支的开始是fork以后的代
多项式加法——C语言
最新发布
2301_80163571的博客
11-03 267
【代码】多项式加法——C语言。
Windows CE多线程编程详解
Windows CE是一个实时操作系统，它与Windows XP等桌面版本在多线程编程上存在一些差异。在Windows CE中，不支持SYS格式的设备驱动，而使用DLL来实现。此外，系统启动时会创建四个核心进程：NK.exe、FileSys.exe、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

暗里い着迷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值