프로세스에 대해 자세히 알아보기: 하위 프로세스, 스레드 정보 및 일반 상태 보기

Q&A

ps すべての子プロセスを表示しますか? pstree-pid

ps-eLf 各配列の意味は何ですか?

リーリー

プロセス下のすべてのスレッドのCPU使用率/ビデオメモリ/優先度およびその他の情報を表示しますか?トップ-H-p25120

スレッドが実行されている CPU を確認しますか? ps-eouser,pid,ppid,lwp,psr,args-L|grepl3-agent

一般的なプロセスのステータス?

リーリー

プロセスとその変換プロセスの 6 つの状態 (ライフサイクル) - 準備完了状態、実行状態、深いスリープ状態、浅いスリープ状態、停止状態、ゾンビ状態。

母子プロセスの共有とは何ですか?違いは何ですか？ ——fork後、母プロセスと子プロセスはファイルディスクリプタやmmapで構築したマッピング領域を共有しますが、プロセス空間やプロセスアドレスまでは親プロセスと全く同じです。完全に独立したスペース)

fork と vfork の違い - vfork は新しいプロセスを作成するために使用され、新しいプロセスの目的は新しいプログラムを実行することです。相違点 1: 親プロセスのアドレス空間は子プロセスにコピーされません。違い 2: vfork は、子プロセスが exec または (exit) を呼び出した後、必ず最初に実行されるようにし、親プロセスの実行をスケジュールできます。

**共有ビデオメモリのアドレス値はユーザープロセス空間の範囲内ですか? **フォーク後、子プロセスは親プロセスと同じアドレスを使用しますか?別プロセスの場合、共有ビデオメモリのプロセス空間に表示されるアドレスは同じですか？

プロセスのライフサイクル、準備完了状態と実行状態は数値的に同じであり、マクロ TASK_RUNNING によって定義されます。

Linux では Task_struct はどのように管理されますか?

ゾンビ プロセスを理解します。ゾンビ プロセスはほぼすべてのビデオ メモリ領域を放棄し、実行可能コードがなく、スケジュールすることもできません。プロセス リスト内の位置を保持するだけです (リソースは長い間解放されており、Task_struct 構造はまだ存在します)。 。親プロセスが SIGCHLD シグナル処理関数をインストールせず、wait()/waitpid() を呼び出して子プロセスが終了するのを待ち、シグナルを明示的に無視しない場合、そのプロセスはゾンビ状態のままになります。親プロセスが終了すると、init プロセスが手動でこの子プロセスを引き継ぎ、LINUX コミュニティでクリーンアップされます。それでも削除できます。親プロセスが終了しない場合、子プロセスはゾンビ状態のままになるため、システム内に多数のゾンビ プロセスが存在することがあります。システムが使用できるプロセス番号には制限があります (cat/proc/sys/kernel/pid_max)。大量のゾンビプロセスが形成されると、使用可能なプロセス番号がないため、システムは新しいプロセスを形成できなくなります。

サブプロセスのリサイクル:

親プロセスは、wait/waitpid およびその他の関数を通じて子プロセスが終了するのを待機します。これにより、親プロセスがハングします。親プロセスが非常にビジーな場合は、シグナル関数を使用して SIGCHLD のハンドラーをインストールできます。これは、子プロセスが終了した後、親プロセスがシグナルを受信し、ハンドラー内で wait を呼び出してリサイクルできるためです。親プロセスが子プロセスの終了を気にしない場合は、シグナル (SIGCHLD、SIG_IGN) を使用して、子プロセスの終了に関心がないことをカーネルに通知できます。子プロセスの終了後、カーネルはそれをリサイクルします。親プロセスにメッセージを送信しなくなります。これには、親プロセスが子プロセスをフォークしてから終了するという方法もあります。つまり、子プロセスは init によって引き継がれ、子プロセスが終了すると、init がそれをリサイクルします。ただし、子プロセスのリサイクルは自分で行う必要があります。

子プロセスが終了後にゾンビ状態になるのはなぜですか? - 親プロセスが子プロセスの終了ステータスやその他の情報を取得する必要があるためです。

Is the zombie state a state that every child process must pass through? - Any child process (except init) does not disappear immediately after exit(), but leaves a data structure called a zombie process (Zombie) (It occupies some video memory resources, that is, there is still a record in the process table), waiting for the parent process to process. If the parent process does not have time to process the child process after exit(), then you can use the ps command to see that the status of the child process is "Z". If the parent process exits before the child process ends, the child process will be taken over by init. init will process the child process in zombie state as the parent process.

How to eliminate zombie processes:

Rewrite the parent process and collect the body of the child process after its death. The specific method is to accept the SIGCHLD signal. After the child process dies, the SIGCHLD signal is sent to the parent process. After the parent process receives this signal, it executes the waitpid() function to collect the corpse of the child process. This is based on the principle that even if the parent process does not call wait, the kernel will send it a SIGCHLD message. Although the default processing is to ignore it, if you want to respond to this message, you can set a processing function. SIGCHLD signal: When the child process ends, the parent process will receive this signal. If the parent process does not handle this signal and does not wait for the child process, the child process actually terminates and will occupy an entry in the kernel process table. At this time, the child process is called a zombie process. We should avoid this kind of situation (the parent process either ignores the SIGCHILD signal, or catches it, or waits for the child process it spawns, or the parent process terminates first, and then the termination of the child process is manually taken over by the init process) .

The exit() function when the process terminates, so what are the thread terminations? ——Three situations of thread abort:

The thread just returns from the startup function, and the return value is the exit code of the thread. Threads can be canceled by other threads in the same process. The thread calls pthread_exit.

If you are not waiting for a thread and are not interested in the return value of the thread, you can set the thread to the detached state and let the system manually reclaim the resources it occupies when the thread exits. A thread cannot call pthread_detach itself to change itself to the detached state. It can only call pthread_detach by other threads.

pthread_cancel() allows one thread to cancel another thread specified by th.

Process - the smallest unit of resource allocation, thread - the smallest unit of program execution. A process has an independent address space, and a thread does not have an independent address space (threads in the same process share the address space of the process). After a process crashes, it will not affect other processes in protected mode, and a thread is only a part of a process. Different execution paths. Threads have their own stacks and local variables, but threads do not have separate address spaces. If one thread hangs up, it means that the entire process has run away. Therefore, multi-process programs are stronger than multi-thread programs, but they consume more resources when switching processes. Larger, less efficient. However, for some concurrent operations that require simultaneous execution and sharing of individual variables, only threads, not processes, can be used.

Reason for using multi-threading?

Process

Process is the basic unit of resource allocation, and thread is the basic unit of scheduling

Process information

The Linux scheduler actually identifies task_struct for scheduling. Regardless of the process thread, the bottom layer corresponds to a task_struct. The difference between a process and a thread is the number of shared resources. There are no resources shared between the two processes, and all resources are shared between the two threads.

PCB(ProcessControlBlock) process control block

task_struct is the description of a process by the Linux kernel, which can also be called "process descriptor". A description of the structure that stores all the resources required by the process. /proc/${pid} process related information. To the operating system, a process is a data structure.

struct task_struct {
longstate; // 进程状态-1为不可运行, 0为可运行, >0为已中断

struct mm_struct*mm; // 指向的是进程的虚拟内存，也就是载入资源和可执行文件的地方
	pid_t pid; // 进程标识符,用来代表一个进程
 
struct task_struct __rcu*parent; // 指向父进程的指针
struct list_headchildren; // 子进程列表
 	struct list_head sibling; // 兄弟进程
struct fs_struct*fs;// 存放文件系统信息的指针
 
struct files_struct *files; // 一个数组，包含该进程打开的文件指针
unsigned int policy; // 调度策略：一般有FIFO，RR，CFS
...
};

从2.6版本之后，Linux改用了slab分配器动态生成task_struct,只须要在栈底(向上下降的栈)或栈顶(向下下降的栈)创建一个新的结构structthread_info(这儿是栈对象的尾端)，你可以把slab分配器觉得是一种分配和释放数据结构的优化策略。通过预先分配和重复使用task_struct,可以防止动态分配和释放带来的资源消耗。

进程的地址空间ref

所谓进程地址空间（processaddressspace），就是从进程的视角听到的地址空间，是进程运行时所用到的虚拟地址的集合。

进程的显存

程序段(Text):程序代码在显存中的映射，储存函数体的二补码代码。

初始化过的数据(Data):在程序运行初早已对变量进行初始化的数据。

未初始化过的数据(BSS):在程序运行初未对变量进行初始化的数据。

栈(Stack):储存局部、临时变量，函数调用时，储存函数的返回表针，用于控制函数的调用和返回。在程序块开始时手动分配显存,结束时手动释放显存，其操作方法类似于数据结构中的栈。

堆(Heap):储存动态显存分配,须要程序员手工分配,手工释放.注意它与数据结构中的堆是两码事，分配方法类似于数组。

注：1.Text,BSS,Data段在编译时早已决定了进程将占用多少VM

可以通过size，晓得这种信息：

正常情况下，Linux进程不能对拿来储存程序代码的显存区域执行写操作，即程序代码是以只读的形式加载到显存中，但它可以被多个进程安全的共享。

创建进程后都创建了什么资源

进程创建

system()通过调用shell启动一个新进程

exec()以替换当前进程映像的方法启动一个新进程

fork()以复制当前进程映像的方法启动一个新进程

fork(2)

执行fork后，父进程的task_struck对拷给子进程，母子进程最初资源完全一样，而且是两份不同的拷贝，因而任何改动都导致两者的分裂。

兄妹进程对显存资源(mm)的管理使用了COW(Copy-On-Write,写时拷贝)技术：

在fork之前，一片显存区对应一份数学地址和一份虚拟地址，显存区的权限为RW；在fork以后，母子进程听到的显存区虚拟地址相同，化学地址也相同，母女进程使用的虽然是同一片化学显存，未发生显存拷贝，操作系统会将此显存区权限改为RO；父或子进程对显存区执行写操作将触发PageFault，操作系统此时会将显存区拷贝一份，母女进程见到的虚拟地址仍旧一样，而且化学地址早已不同。各进程虚拟地址到化学地址的映射由MMU(MemoryManagementUnit,显存管理单元)管理。fork运行在有MMU的CPU上。

MMU가 없는 CPU의 경우 COW 및 Support Fork 적용이 어렵습니다. MMU가 없는 CPU는 vfork를 사용하여 프로세스를 생성하며 상위 프로세스는 하위 프로세스가 종료되거나 실행될 때까지 항상 차단됩니다. vfork와 fork의 본질적인 차이점은 vfork의 모 프로세스와 자식 프로세스가 동일한 비디오 메모리 영역을 공유한다는 것입니다.

fork(2) 시스템 호출은 상위 프로세스와 동시에(동시) 실행되며 실행 순서가 불확실한(비동기) 하위 프로세스라는 새 프로세스를 만드는 데 사용됩니다. pid_t는 매크로 정의이며 그 본질은 int입니다. 성공하면 두 개의 값을 반환하고 하위 프로세스는 0을 반환하며 상위 프로세스는 하위 프로세스 ID를 반환합니다. 그렇지 않으면 오류가 -1

을 반환합니다.

뮤텍스 잠금 상태를 포함하여 상위 프로세스의 전체 가상 주소 공간이 하위 프로세스에 복사됩니다.

하위 프로세스는 다음 사항을 제외하고 상위 프로세스와 정확히 동일합니다.

재활용 처리 wait() 및 waitpid()

waitpid()/wait()를 통해 하위 프로세스의 task_struct 구조를 재활용합니다.

차이:

고아 프로세스와 좀비 프로세스 좀비 프로세스

좀비 프로세스: 프로세스는 자식 프로세스를 생성하기 위해 포크를 사용합니다. 자식 프로세스가 종료되고 부모 프로세스가 자식 프로세스의 상태 정보를 얻기 위해 wait 또는 waitpid를 호출하지 않으면 자식 프로세스의 프로세스 설명자가 항상 저장됩니다. 시스템. 이러한 프로세스를 좀비 프로세스라고 합니다. (자식 프로세스는 /proc/$pid를 통해 볼 수 있지만 스레드는 볼 수 없습니다)

프로세스가 수명을 종료하기 위해 종료 명령을 호출하면 실제로는 파괴되지는 않지만 좀비 프로세스(Zombie)라는 데이터 구조가 남습니다(시스템은 종료를 호출하며 그 기능은 프로세스를 종료하는 것이지만 일반 프로세스를 좀비 프로세스로 전환하는 것으로만 제한되며 완전히 파괴할 수는 없습니다.

Linux 프로세스 상태에서 좀비 프로세스는 이미 거의 모든 비디오 메모리 공간을 포기했으며 실행 가능한 코드가 없으며 프로세스 목록에서 위치만 유지할 수 있는 매우 특별한 프로세스입니다. 종료 상태 및 기타 정보는 다른 프로세스에서 수집할 수 있습니다. 또한 좀비 프로세스는 더 이상 비디오 메모리 공간을 차지하지 않습니다. 시체를 수집하려면 상위 프로세스가 필요합니다.

부모 프로세스가 SIGCHLD 신호 처리 기능을 설치하지 않고 자식 프로세스가 끝날 때까지 기다리기 위해 wait 또는 waitpid()를 호출하고 신호를 명시적으로 무시하지 않으면 부모 프로세스는 여전히 좀비 상태로 유지됩니다. 이때 프로세스가 종료되면 init 프로세스가 수동으로 이 하위 프로세스를 인계받아 해당 시체를 수집하며 여전히 제거될 수 있습니다.

그리고 상위 프로세스가 루프이고 종료되지 않으면 하위 프로세스는 여전히 좀비 상태로 유지됩니다. 이것이 시스템에 때때로 많은 좀비 프로세스가 있는 이유입니다. 시스템에서 사용할 수 있는 프로세스 번호는 제한되어 있습니다. 좀비 프로세스가 많이 형성되면 사용 가능한 프로세스 번호가 없기 때문에 시스템은 새로운 프로세스를 형성할 수 없습니다.

좀비 프로세스의 원인: 자식 프로세스가 종료된 후 부모 프로세스에 SIGCHLD 신호를 보내고 부모 프로세스는 기본적으로 이를 무시합니다. 부모 프로세스는 wait() 또는 waitpid() 함수를 호출하여 기다리지 않습니다. 자식 프로세스가 끝났습니다. 좀비 프로세스를 방지하는 방법: 상위 프로세스는 wait()/waitpid()를 호출하여 하위 프로세스가 끝날 때까지 기다립니다. 이러한 방식으로 상위 프로세스는 일반적으로 대기 시 차단되고 다른 작업을 처리할 수 없습니다. SIGCHLD 신호를 캡처하고 신호 처리 함수에서 대기 함수를 호출하면 1에서 설명한 문제를 방지할 수 있습니다. 두 번 포크하면 부모 프로세스는 father 프로세스를 생성하고, father 프로세스는 son 프로세스를 생성한 후, mother 프로세스는 자살하고, son 프로세스는 orphan 프로세스가 되어 init 프로세스에 흡수됩니다. 고아 프로세스

고아 프로세스: 상위 프로세스는 종료되지만 하나 이상의 하위 프로세스가 여전히 실행 중이므로 이러한 하위 프로세스는 고아 프로세스가 됩니다. 고아 프로세스는 init 프로세스(pid=1)에 의해 처리되고 init 프로세스는 이에 대한 상태 수집을 완료합니다. (시스템에 고아 프로세스가 나타나면 이는 종료하기 전에 기본 프로세스가 하위 프로세스를 지우지 않았다는 의미입니다.)

스레드(경량 프로세스, LWP)

同一进程的多个线程获取进程ID时得到的是惟一ID值。Linux同一进程的多线程，在内核视角实际上每位线程都有一个PID，但在用户空间须要getpid()返回惟一值，Linux使用了一个小方法，引入了TGID的概念linux进程与线程 内核，getpid()返回的的TGID值。

pthread_create()

Linux线程本质上就是进程，只是与进程间资源共享方法不同，线程间共享所有资源。每位线程都有自己的task_struct，因而每位线程都可被CPU调度。多线程间又共享同一进程资源。

在一个线程中创建了另外一个线程，主线程要等到创建的线程返回了，获取该线程的返回值后主线程才退出。这个时侯就须要用到线程挂起。pthread_join函数用于挂起当前线程，直到指定的线程中止为止。

说线程的PID，是指用户空间的进程ID，值就是TGID(threadgroupIDforthethreadgroupleader)；当非常强调，线程在内核空间的PID，则指线程在内核中task_struct里特有的PID。top–H命令从线程视角显示CPU占用率。不带参数的top命令，进程ID是主线程的PID(也就是TGID)。

Linux的进程和线程

进程是处于运行期的程序和相关资源的统称，具备一些要素：

拥有一段可执行程序代码。如同一场戏须要一个剧本。代码段可以多个进程共用，如同许多场表演都可以用一份剧本一样。拥有一段进程专用的系统堆栈空间。可以觉得是这个进程的“私有财产”，相应的，也肯定有系统空间堆栈在系统中有进程控制块(或称进程描述符,本文两种说法通用)描述这个进程的相关信息。可以觉得是进程的“户口”。系统通过这个控制块来控制进程的相关行为有独立的储存空间，也就是专有的用户空间，相应的又会有用户空间堆栈。理解各类ID

# ps -eo ppid,pid,tid,lwp,tgid,pgrp,sid,tpgid,args -L | awk '{if(NR==1) print $0; if($9~/a.out/) print $0}'
 PPID PID TID LWPTGIDPGRP SID TPGID COMMAND
 579046 2436128 2436128 2436128 2436128 2436128579046 2436128 ./a.out
 579046 2436128 2436129 2436129 2436128 2436128579046 2436128 ./a.out
 579046 2436128 2436130 2436130 2436128 2436128579046 2436128 ./a.out

pidstat-t[-ppid号]可以复印出线程之间的关系。

各类ID最后都归结到pid和lwp(tid)上。所以理解各类ID，最终归结为理解pid和lwp(tid)的联系和区别。

PID:进程ID。

LWP:线程ID。在用户态的命令(例如ps)中常用的显示方法。

TID:线程ID，等于LWP。TID在系统提供的插口函数中更常用，例如syscall(SYS_gettid)和syscall(__NR_gettid)。

TGID:线程组ID，也就是线程组leader的进程ID，等于PID。

pgid(processgroupID):进程组ID，也就是进程组leader的进程ID。

pthreadid:pthread库提供的ID，生效范围不在系统级别，可以忽视。

sid:sessionIDforthesessionleader。

TPGID:ttyprocessgroupIDfortheprocessgroupleader。

上图挺好地描述了用户视角(userview)和内核视角(kernelview)看见线程的差异：

轮询

Polling (Thread auf Benutzerebene) ist für den Kernel transparent, das heißt, das System ist sich der Existenz von Polling nicht bewusst. Da es vom Benutzerprogramm selbst gesteuert wird, ist es schwierig Ähnlich wie bei der Belegungsplanung, die die CPU-Steuerung dazu zwingt, zu anderen Prozessen/Threads zu wechseln, kann im Allgemeinen nur eine kooperative Planung durchgeführt werden. Nachdem die Abfrage selbst die Steuerung aktiv verkauft hat, können andere Abfragen ausgeführt werden.

Der Unterschied zwischen Goroutine und Interpreter

Im Wesentlichen ist Goroutine eine Umfrage. Der Unterschied besteht darin, dass Golang die Goroutine-Planung in vielen Aspekten wie Laufzeit und Systemaufrufen kapselt und verarbeitet. Wenn es auf langfristige Ausführung oder Systemaufrufe stößt, wird die CPU (P) der aktuellen Goroutine aktiv verkauft Geplante und ausgeführte Linux-Betriebs- und Wartungsrekrutierung, dh Golang unterstützt den Dolmetscher auf Sprachebene.

Unterschiedliche Prozessplanung in anderen Aspekten

Drei Hauptplanungsstrategien des Linux-Kernels:

1, SCHED_OTHER Time-Sharing-Planungsstrategie,

2, SCHED_FIFO Echtzeit-PlanungsstrategieLinux-Prozess und Thread-Kernel, wer zuerst kommt, mahlt zuerst

3, SCHED_RR Echtzeit-Planungsstrategie, Zeitscheibenrotation

Prozessplanung in Echtzeit

SCHED_FIFO: Verschiedene Prioritäten werden entsprechend der höheren Priorität zuerst in den Ruhezustand versetzt und dann entsprechend der niedrigeren Priorität ausgeführt.

SCHED_RR: Verschiedene Prioritäten werden entsprechend der höheren Priorität zuerst in den Ruhezustand versetzt und dann entsprechend der niedrigeren Priorität ausgeführt.

Kernel RT-Patch:

Die folgenden zwei Parameter

/proc/sys/kernel/sched_rt_period_us

/proc/sys/kernel/sched_rt_runtime_us

Gibt an, dass RT während des Zeitraums nur bis zur Laufzeit ausgeführt werden kann

Normale Prozessplanung

SCHED_OTHER:

CFS: Completely Fair Scheduling (neuer Kernel)

Schwarze Mangrove, der Wert des rechten Knotens ist größer als der Wert des linken Knotens

Führen Sie den bisher kleinsten Prozess von vruntime aus

Unter Berücksichtigung von CPU/IO und nett

Finden Sie immer den Thread-Zeitplan mit der kleinsten Laufzeit.

vruntime=Pruntime/Gewicht×1024;

Vruntime ist die virtuelle Laufzeit, Pruntime ist die chemische Laufzeit und das Gewicht wird durch den Nice-Wert bestimmt (je niedriger der Nice-Wert, desto höher das Gewicht. Threads mit weniger Laufzeit und niedrigem Nice-Wert haben eine kleinere Vruntime und). wird zunächst eingeplant. Dabei handelt es sich um einen Prozess, der sich im Betrieb dynamisch verändert.

Kernelraum und Benutzerraum Kernelraum und Benutzerraum

리눅스의 가상 주소 공간은 0부터 4G까지이며, 리눅스 커널은 이 4G 바이트 공간을 두 부분으로 나누고, 가장 높은 1G 바이트(가상 주소 0xCxC0000000부터 0xFFFFFFFF까지)를 커널이 사용하는데, 이를 "커널 공간"이라고 합니다. " ". 하위 3G 바이트(가상 주소 0x00000000부터 0xBFFFFFFFF까지)는 각 프로세스, 즉 "사용자 공간"에서 사용됩니다. 각 프로세스는 시스템 호출을 통해 커널에 들어갈 수 있으므로 Linux 커널은 시스템의 모든 프로세스에서 공유됩니다. 특정 프로세스 관점에서 볼 때 각 프로세스는 4GB의 가상 공간

을 가질 수 있습니다.

Linux는 2단계 보호 메커니즘을 사용합니다. 레벨 0은 커널에서 사용되고 레벨 3은 사용자 프로그램에서 사용됩니다. 각 프로세스에는 자체 개인 사용자 공간(0~3G)이 있습니다. 가장 높은 1GB의 가상 커널 공간은 모든 프로세스와 커널에서 공유됩니다.

커널 공간은 커널 코드와 데이터를 저장하고, 프로세스의 사용자 공간은 사용자 프로그램의 코드와 데이터를 저장합니다. 커널 공간이든 사용자 공간이든 모두 가상 공간에 있습니다. 실제로 커널 공간은 각 가상 공간 중 가장 높은 1GB 바이트를 차지하지만 항상 가장 낮은 주소(0x00000000)부터 케미컬 메모리로 매핑된다. 또한, 가상 주소를 사용하면 커널 공간이 파괴되는 것을 효과적으로 보호할 수 있다. 화학적 주소 변환 과정은 운영체제와 CPU가 함께 완료한다(운영체제는 CPU에 대한 페이지 테이블을 설정하고, CPU는 MMU 장치를 통해 주소 변환을 수행한다).

참고: 멀티태스킹 운영 체제의 각 프로세스는 자체 비디오 메모리 샌드박스에서 실행됩니다. 이 샌드박스는 32비트 모드에서 항상 4GB 비디오 메모리 주소입니다. 이 가상 주소는 운영 체제에 의해 유지되고 프로세서에 의해 참조되는 페이지 테이블(페이지 테이블)을 통해 화학적 메모리에 매핑됩니다. 각 프로세스에는 자체 페이지 테이블 세트가 있습니다.

프로세스 메모리 공간 분포는 오른쪽에 표시됩니다.

비디오 메모리

힙은 내려가고 스택은 올라갑니다. (내 것은 왜 반대인가요???)

스택과 메모리의 하강방향과 크고 작은 엔디안

낮음->|-----------------|

｜글로벌 수량(모두 초기화된 수량.데이터, ｜

|초기화되지 않은 수량.bss)|

힙 시작->|-----------------||

｜힙은 상위 주소를 향하여 드랍됩니다｜

｜｜

｜｜

|여유공간|

｜｜

｜｜

｜스택이 하위 주소로 내려갑니다｜

하이스택 시작->|-----------------||

위 내용은 프로세스에 대해 자세히 알아보기: 하위 프로세스, 스레드 정보 및 일반 상태 보기의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!