linux进程与线程汇总

合集下载

linux进程、线程与cpu的亲和性（affinity）

linux进程、线程与cpu的亲和性（affinity）最近的⼯作中对性能的要求⽐较⾼，下⾯简单做⼀下总结：⼀、什么是cpu亲和性（affinity） CPU的亲和性，就是进程要在指定的 CPU 上尽量长时间地运⾏⽽不被迁移到其他处理器，也称为CPU关联性；再简单的点的描述就将制定的进程或线程绑定到相应的cpu上；在多核运⾏的机器上，每个CPU本⾝⾃⼰会有缓存，缓存着进程使⽤的信息，⽽进程可能会被OS调度到其他CPU上，如此，CPU cache命中率就低了，当绑定CPU后，程序就会⼀直在指定的cpu跑，不会由操作系统调度到其他CPU上，性能有⼀定的提⾼。

软亲和性（affinity）: 就是进程要在指定的 CPU 上尽量长时间地运⾏⽽不被迁移到其他处理器，Linux 内核进程调度器天⽣就具有被称为软 CPU 亲和性（affinity）的特性，这意味着进程通常不会在处理器之间频繁迁移。

这种状态正是我们希望的，因为进程迁移的频率⼩就意味着产⽣的负载⼩。

硬亲和性（affinity）：简单来说就是利⽤linux内核提供给⽤户的API，强⾏将进程或者线程绑定到某⼀个指定的cpu核运⾏。

解释：在linux内核中，所有的进程都有⼀个相关的数据结构，称为 task_struct。

这个结构⾮常重要，原因有很多；其中与亲和性（affinity）相关度最⾼的是 cpus_allowed 位掩码。

这个位掩码由 n 位组成，与系统中的 n 个逻辑处理器⼀⼀对应。

具有 4 个物理 CPU 的系统可以有 4 位。

如果这些CPU 都启⽤了超线程，那么这个系统就有⼀个 8 位的位掩码。

如果为给定的进程设置了给定的位，那么这个进程就可以在相关的 CPU 上运⾏。

因此，如果⼀个进程可以在任何 CPU 上运⾏，并且能够根据需要在处理器之间进⾏迁移，那么位掩码就全是 1。

实际上，这就是 Linux 中进程的缺省状态；（这部分内容在这个博客中有提到⼀点：） cpus_allowed⽤于控制进程可以在哪⾥处理器上运⾏sched_set_affinity()（⽤来修改位掩码）sched_get_affinity()（⽤来查看当前的位掩码）⼆、进程与cpu的绑定 sched_setaffinity可以将某个进程绑定到⼀个特定的CPU。

关于linux的进程中的各个线程cpu占用情况的分析和查看

关于linux的进程中的各个线程cpu占⽤情况的分析和查看我们常常会在新开的服搭建⼀个游戏的server，有时候要进⾏压⼒測试，那么怎样来看呢，⼀般我们会通过top命令查看各个进程的cpu和内存占⽤情况，获得到了我们的进程id，然后我们或许会通过pstack命令查看⾥边的各个线程id以及相应的线程如今正在做什么事情，分析多组数据就能够获得哪些线程⾥有慢操作影响了server的性能，从⽽得到解决⽅式。

⽐⽅这种以组数据：[root@AY130816144542124256Z bin]# pstack 30222Thread 9 (Thread 0x7f729adc1700 (LWP 30251)):#0 0x00007f72a429b720 in sem_wait () from /lib64/libpthread.so.0#1 0x0000000000ac5eb6 in Semaphore::down() ()#2 0x0000000000ac5cac in Queue::get() ()#3 0x00000000009a583f in DBManager::processUpdate(Queue*) ()#4 0x00000000009a4bfb in dbUpdateThread(void*) ()#5 0x00007f72a4295851 in start_thread () from /lib64/libpthread.so.0#6 0x00007f72a459267d in clone () from /lib64/libc.so.6Thread 8 (Thread 0x7f727c579700 (LWP 30252)):#0 0x00007f72a429b720 in sem_wait () from /lib64/libpthread.so.0#1 0x0000000000ac5eb6 in Semaphore::down() ()#2 0x0000000000ac5cac in Queue::get() ()#3 0x00000000009a5799 in DBManager::processQuery(Queue*) ()#4 0x00000000009a4c3a in dbQueryThread(void*) ()#5 0x00007f72a4295851 in start_thread () from /lib64/libpthread.so.0#6 0x00007f72a459267d in clone () from /lib64/libc.so.6Thread 7 (Thread 0x7f7257fff700 (LWP 30253)):#0 0x00007f72a42997bb in pthread_cond_timedwait@@GLIBC_2.3.2 () from /lib64/libpthread.so.0#1 0x00007f72a549ee08 in utils::thread::condition_impl::timed_wait(int) () from /usr/local/utils-0.0.1/lib/libutils.so.0.0.1#2 0x00007f72a549ebd3 in utils::thread::Condition::timed_wait(int) () from /usr/local/utils-0.0.1/lib/libutils.so.0.0.1#3 0x00000000009d5f57 in utils::MessageQueue<FightInfo*>::pop() ()#4 0x00000000009d5557 in FightReport::svc() ()#5 0x00007f72a5494b45 in utils::Task_Base::thread_proc(void*) () from /usr/local/utils-0.0.1/lib/libutils.so.0.0.1#6 0x00007f72a4295851 in start_thread () from /lib64/libpthread.so.0#7 0x00007f72a459267d in clone () from /lib64/libc.so.6Thread 6 (Thread 0x7f72397b7700 (LWP 30254)):#0 0x00007f72a4588fc3 in poll () from /lib64/libc.so.6#1 0x00007f72a0fbded4 in __libc_res_nsend () from /lib64/libresolv.so.2#2 0x00007f72a0fba76a in __libc_res_nquery () from /lib64/libresolv.so.2#3 0x00007f72a0fbad29 in __libc_res_nquerydomain () from /lib64/libresolv.so.2#4 0x00007f72a0fbb9cf in __libc_res_nsearch () from /lib64/libresolv.so.2#5 0x00007f729adc37a7 in _nss_dns_gethostbyname4_r () from /lib64/libnss_dns.so.2#6 0x00007f72a457a4c3 in gaih_inet () from /lib64/libc.so.6#7 0x00007f72a457cb20 in getaddrinfo () from /lib64/libc.so.6#8 0x00007f72a56fc782 in Curl_getaddrinfo_ex () from /usr/lib64/libcurl.so.4#9 0x00007f72a56f1d42 in Curl_getaddrinfo () from /usr/lib64/libcurl.so.4#10 0x00007f72a56c9e77 in Curl_resolv () from /usr/lib64/libcurl.so.4#11 0x00007f72a56ca138 in Curl_resolv_timeout () from /usr/lib64/libcurl.so.4#12 0x00007f72a56d8d88 in ?() from /usr/lib64/libcurl.so.4#13 0x00007f72a56ddb79 in ?() from /usr/lib64/libcurl.so.4#14 0x00007f72a56de76e in Curl_connect () from /usr/lib64/libcurl.so.4#15 0x00007f72a56e69b0 in Curl_perform () from /usr/lib64/libcurl.so.4#16 0x0000000000ae6e3d in HttpClient::svc() ()#17 0x00007f72a5494b45 in utils::Task_Base::thread_proc(void*) () from /usr/local/utils-0.0.1/lib/libutils.so.0.0.1#18 0x00007f72a4295851 in start_thread () from /lib64/libpthread.so.0#19 0x00007f72a459267d in clone () from /lib64/libc.so.6Thread 5 (Thread 0x7f721af6f700 (LWP 30255)):#0 0x00007f72a455691d in nanosleep () from /lib64/libc.so.6#1 0x000000000098cb8a in Sleep(unsigned long) ()#2 0x000000000098b87d in DynResource::svc() ()#3 0x00007f72a5494b45 in utils::Task_Base::thread_proc(void*) () from /usr/local/utils-0.0.1/lib/libutils.so.0.0.1#4 0x00007f72a4295851 in start_thread () from /lib64/libpthread.so.0#5 0x00007f72a459267d in clone () from /lib64/libc.so.6Thread 4 (Thread 0x7f71fc727700 (LWP 30256)):#0 0x00007f72a455691d in nanosleep () from /lib64/libc.so.6#1 0x000000000098cb8a in Sleep(unsigned long) ()#2 0x0000000000a61516 in PlayerOpLogThread::svc() ()#3 0x00007f72a5494b45 in utils::Task_Base::thread_proc(void*) () from /usr/local/utils-0.0.1/lib/libutils.so.0.0.1#4 0x00007f72a4295851 in start_thread () from /lib64/libpthread.so.0#5 0x00007f72a459267d in clone () from /lib64/libc.so.6Thread 3 (Thread 0x7f71ddedf700 (LWP 30257)):#0 0x00007f72a4592c73 in epoll_wait () from /lib64/libc.so.6#1 0x00007f72a51f334f in Epoll_Reactor::run_reactor_event_loop() () from /usr/local/net_manager-0.0.2/lib/libnet_manager.so.0.0.2#2 0x00007f72a51f2523 in Net_Thread::svc() () from /usr/local/net_manager-0.0.2/lib/libnet_manager.so.0.0.2#3 0x00007f72a5494b45 in utils::Task_Base::thread_proc(void*) () from /usr/local/utils-0.0.1/lib/libutils.so.0.0.1#4 0x00007f72a4295851 in start_thread () from /lib64/libpthread.so.0#5 0x00007f72a459267d in clone () from /lib64/libc.so.6Thread 2 (Thread 0x7f71bf697700 (LWP 30258)):#0 0x00007f72a4592c73 in epoll_wait () from /lib64/libc.so.6#1 0x00007f72a51f334f in Epoll_Reactor::run_reactor_event_loop() () from /usr/local/net_manager-0.0.2/lib/libnet_manager.so.0.0.2#2 0x00007f72a51f2523 in Net_Thread::svc() () from /usr/local/net_manager-0.0.2/lib/libnet_manager.so.0.0.2#3 0x00007f72a5494b45 in utils::Task_Base::thread_proc(void*) () from /usr/local/utils-0.0.1/lib/libutils.so.0.0.1#4 0x00007f72a4295851 in start_thread () from /lib64/libpthread.so.0#5 0x00007f72a459267d in clone () from /lib64/libc.so.6Thread 1 (Thread 0x7f72a60ae7e0 (LWP 30222)):#0 0x00007f72a4584c95 in _xstat () from /lib64/libc.so.6#1 0x00007f72a45483e0 in __tzfile_read () from /lib64/libc.so.6#2 0x00007f72a4547864 in tzset_internal () from /lib64/libc.so.6#3 0x00007f72a4547b20 in tzset () from /lib64/libc.so.6#4 0x00007f72a4546699 in timelocal () from /lib64/libc.so.6#5 0x0000000000b0b08d in Achieve::GetRemainTime(AchieveTemplate*) ()#6 0x0000000000b115ca in Achieve::update() ()#7 0x0000000000a197ce in Player::update() ()#8 0x0000000000b1b272 in PlayerMng::Tick() ()#9 0x0000000000a73105 in GameServer::FrameTick(unsigned int) ()#10 0x0000000000a6ff80 in GameServer::run() ()#11 0x0000000000a773a1 in main ()[root@AY130816144542124256Z gameserver]# ps -eLo pid,lwp,pcpu | grep 3022230222 30222 31.430222 30251 0.030222 30252 0.030222 30253 0.030222 30254 0.030222 30255 0.030222 30256 1.230222 30257 1.230222 30258 1.0多组数据显⽰表明我们的主逻辑线程的确占⽤的cpu⾮常⾼，发现事实上在Achieve::update() 的时候做了太多没实⽤的推断，⽽且能够降低循环进⼊的次数的。

多线程知识点总结归纳

多线程知识点总结归纳多线程知识点总结归纳如下：1. 线程和进程的区别- 进程是程序的一个执行实例，每个进程都有自己的独立内存空间、代码和数据，相互之间不会直接共享资源。

线程是在进程内部运行的一段代码，多个线程可以共享同一个进程的资源。

2. 多线程的优势- 提高程序的并发性和响应性，能够更有效地利用 CPU 资源。

- 使得程序能够更轻松地实现并发处理和多任务处理。

- 能够通过多线程实现一些复杂任务，如网络编程、图形界面等。

3. 多线程的基本概念- 线程调度：操作系统通过调度算法决定哪个线程应当运行，哪个线程应当阻塞或唤醒。

- 线程同步：多个线程访问共享数据时需要进行同步操作，以避免数据竞争和死锁等问题。

- 线程通信：多个线程之间需要进行通信，以进行资源共享或协作完成任务。

4. 多线程的创建和启动- 使用线程类：在 Java 中，可以通过继承 Thread 类或实现 Runnable 接口来创建线程。

- 线程生命周期：线程的生命周期包括新建、就绪、运行、阻塞和死亡等状态。

5. 线程的安全性- 多线程程序需要考虑线程安全性，以避免数据竞争和死锁等问题。

- 常用的线程安全性方法包括加锁、使用线程安全的数据结构和对象等。

6. 线程的调度- 多线程程序的运行顺序由操作系统的调度算法决定，而且在不同的操作系统上可能有不同的调度策略。

- 线程的调度策略包括抢占式调度和协作式调度等。

7. 线程的优先级- 线程的优先级决定了它在被调度时的优先级，可以通过设置线程的优先级来影响它的调度顺序。

8. 线程的阻塞和唤醒- 线程在执行过程中可能会因为某些原因而阻塞，需要等待一定的条件满足后才能被唤醒继续执行。

- 一些常见的线程阻塞和唤醒操作包括等待、通知、等待超时等。

9. 线程同步的方法- 使用锁机制：在多线程程序中通常使用锁来保护共享资源，以避免数据竞争和执行顺序问题。

- 使用同步代码块：通过 synchronized 关键字或 ReentrantLock 类等来创建同步代码块，保护共享资源的访问。

Linux下查看进程和线程

在Linux中查看线程数的三种方法1、top -H手册中说：-H : Threads toggle加上这个选项启动top，top一行显示一个线程。

否则，它一行显示一个进程。

2、ps xH手册中说：H Show threads as if they were processes这样可以查看所有存在的线程。

3、ps -mp <PID>手册中说：m Show threads after processes这样可以查看一个进程起的线程数。

查看进程1. top 命令top命令查看系统的资源状况load average表示在过去的一段时间内有多少个进程企图独占CPUzombie 进程：不是异常情况。

一个进程从创建到结束在最后那一段时间遍是僵尸。

留在内存中等待父进程取的东西便是僵尸。

任何程序都有僵尸状态，它占用一点内存资源，仅仅是表象而已不必害怕。

如果程序有问题有机会遇见，解决大批量僵尸简单有效的办法是重起。

kill是无任何效果的stop模式：与sleep进程应区别，sleep会主动放弃cpu，而stop 是被动放弃cpu ，例单步跟踪，stop(暂停)的进程是无法自己回到运行状态的。

cpu states：nice：让出百分比irq：中断处理占用idle：空间占用百分比iowait：输入输出等待(如果它很大说明外存有瓶颈，需要升级硬盘(SCSI))Mem：内存情况设计思想：把资源省下来不用便是浪费，如添加内存后free值会不变，buff值会增大。

判断物理内存够不够，看交换分区的使用状态。

交互命令：[Space]立即刷新显示[h]显示帮助屏幕[k] 杀死某进程。

你会被提示输入进程ID 以及要发送给它的信号。

一般的终止进程可以使用15信号;如果不能正常结束那就使用信号9强制结束该进程。

默认值是信号15。

在安全模式中此命令被屏蔽。

[n] 改变显示的进程数量。

你会被提示输入数量。

[u] 按用户排序。

[M] 按内存用量排序。

Linux系统如何查看进程的线程数

Linux系统如何查看进程的线程数Linux系统如何查看进程的线程数Linux系统的进程是由线程组成的，当然Linux进程下的线程数是不固定的，可以是一个进程，也可以是多个进程。

本文就来教大家Linux系统如何查看进程的线程数？一、使用命令查看Linux进程的线程数1、使用top命令，具体用法是 top -H加上这个选项，top的每一行就不是显示一个进程，而是一个线程。

2、使用ps命令，具体用法是 ps -xH这样可以查看所有存在的线程，也可以使用grep作进一步的过滤。

3、使用ps命令，具体用法是 ps -mq PID这样可以看到指定的进程产生的线程数目。

二、Linux系统工具查看Linux进程看看这个目录吧，/proc/5000/ 这里面有你所有想要的。

其实stat代表着当前的一些信息。

使用ps命令来查看进程的时候，进程状态分别对应的含义如下：D 不可中断睡眠（通常是在IO操作）收到信号不唤醒和不可运行，进程必须等待直到有中断发生R 正在运行或可运行（在运行队列排队中）S 可中断睡眠（休眠中，受阻，在等待某个条件的形成或接受到信号）T 已停止的` 进程收到SIGSTOP，SIGSTP，SIGTIN，SIGTOU 信号后停止运行W 正在换页（2.6.内核之前有效）X 死进程（未开启）Z 僵尸进程进程已终止，但进程描述符存在，直到父进程调用wait4（）系统调用后释放BSD风格的《高优先级（not nice to other users）N 低优先级（nice to other users）L 页面锁定在内存（实时和定制的IO）s 一个信息头l 多线程（使用 CLONE_THREAD，像NPTL的pthreads的那样）+ 在前台进程组以上就是Linux查看进程的线程数的方法了，Linux进程的线程数是进程的一个重要参数，也是管理Linux进程应该要知道的信息。

【Linux系统如何查看进程的线程数】。

操作系统必备基础知识

操作系统必备基础知识今天给大家推荐两份大佬们总结的PDF，一份是计算机基础知识，一份是操作系统，反正帅地看完之后，和面试官聊天，都有点飘了，废话不多说,下面就让小编带你去看看哪些操作系统必备基础知识，希望能帮助到大家!操作系统基础知识操作系统是计算机体系中必不可少的核心系统软件，其他软件(如编辑程序、汇编程序、编译程序、数据库管理系统等系统软件，以及大量应用软件)是建立在操作系统的基础上，并在操作系统的统一管理和支持下运行。

操作系统是用户与计算机之间的桥梁，用户可以通过操作系统提供的功能访问计算机系统中的软硬件资源。

操作系统的作用是通过资源管理提高计算机系统的效率，改善人机界面，为用户提供有好的工作环境。

有效地组织和管理系统中的各种软硬件资源，合理的组织计算机系统工作流程，控制程序的执行，并且向用户提供一个良好的工作环境和友好的接口。

简单的说，操作系统就是运行在计算机硬件和软件(其他系统软件和应用软件)之间的一个系统软件，它的主要作用就是让计算机能够运行的很好的同时让你觉得也不错。

操作系统分为这么几种：批处理操作系统、分时操作系统、实时操作系统、网络操作系统、分布式操作系统、嵌入式操作系统、微机操作系统(这个我们就比较常见了，比如Linux、Windows、Unix、手机上的基于Unix的安卓系统等等)。

操作系统的功能可分为5大部分：处理机(CPU)管理、文件管理、存储管理、设备管理和作业管理。

下面说说处理机管理中的一些基础知识。

三态模型五态模型在多道程序环境的系统中，存在多个可以一起进行(并发执行)的进程，因此必然会存在进程之间的通信问题。

进程间的通信主要有同步、互斥、调度、死锁、信号量机制等问题进程间的同步多个进程都是独立进行的，有的时候需要在某些地方协调一下，比如进程A在生产一个原件，进程B要加工这个原件，这时候就需要进程B等待进程A完成后才能开始进行，这就是进程之间的同步。

进程间的互斥这就是指两个进程都想用同一个资源，但是这个资源同时只能被一个进程使用。

linux下的CC++多进程多线程编程实例详解

linux下的CC++多进程多线程编程实例详解linux下的C\C++多进程多线程编程实例详解1、多进程编程#include <stdlib.h>#include <sys/types.h>#include <unistd.h>int main(){pid_t child_pid;/* 创建⼀个⼦进程 */child_pid = fork();if(child_pid == 0){printf("child pid\n");exit(0);}else{printf("father pid\n");sleep(60);}return 0;}2、多线程编程#include <stdio.h>#include <pthread.h>struct char_print_params{char character;int count;};void *char_print(void *parameters){struct char_print_params *p = (struct char_print_params *)parameters;int i;for(i = 0; i < p->count; i++){fputc(p->character,stderr);}return NULL;}int main(){pthread_t thread1_id;pthread_t thread2_id;struct char_print_params thread1_args;struct char_print_params thread2_args;thread1_args.character = 'x';thread1_args.count = 3000;pthread_create(&thread1_id, NULL, &char_print, &thread1_args);thread2_args.character = 'o';thread2_args.count = 2000;pthread_create(&thread2_id, NULL, &char_print, &thread2_args);pthread_join(thread1_id, NULL);pthread_join(thread2_id, NULL);return 0;}3、线程同步与互斥1）、互斥pthread_mutex_t mutex;pthread_mutex_init(&mutex, NULL);/*也可以⽤下⾯的⽅式初始化*/pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&mutex);/* 互斥 */thread_flag = value;pthread_mutex_unlock(&mutex);2）、条件变量int thread_flag = 0;pthread_mutex_t mutex;pthread_cond_t thread_flag_cv;\void init_flag(){pthread_mutex_init(&mutex, NULL);pthread_cond_init(&thread_flag_cv, NULL);thread_flag = 0;}void *thread_function(void *thread_flag){while(1){pthread_mutex_lock(&mutex);while(thread_flag != 0 ){pthread_cond_wait(&thread_flag_cv, &mutex);}pthread_mutex_unlock(&mutex);do_work();}return NULL;}void set_thread_flag(int flag_value){pthread_mutex_lock(&mutex);thread_flag = flag_value;pthread_cond_signal(&thread_flag_cv);pthread_mutex_unlock(&mutex);}感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

linux的进程管理实验总结

linux的进程管理实验总结Linux的进程管理实验总结1. 引言Linux中的进程管理是操作系统的核心功能之一，在实际的系统运行中起着重要的作用。

进程管理能够有效地分配系统资源、管理进程的运行状态和优先级，以及监控进程的行为。

本文将以Linux的进程管理实验为主题，分步骤介绍实验过程及总结。

2. 实验目的本次实验的目的是理解Linux中进程的概念，掌握进程的创建、运行和终止的基本操作，以及进程的状态转换过程。

3. 实验环境本次实验使用的是Linux操作系统，可以选择使用虚拟机安装Linux或者使用Linux主机进行实验。

4. 实验步骤4.1 进程的创建在Linux中，可以使用系统调用fork()来创建一个新的子进程。

在实验中，可以编写一个简单的C程序来调用fork()系统调用，实现进程的创建。

具体步骤如下：（1）创建一个新的C程序文件，例如"process_create.c"。

（2）在C程序文件中，包含必要的头文件，如<stdio.h>和<unistd.h>。

（3）在C程序文件中，编写main()函数，调用fork()函数进行进程的创建。

（4）编译并运行该C程序文件，观察控制台输出结果。

实验中，可以通过观察控制台输出结果，判断新的子进程是否被成功创建。

4.2 进程的运行在Linux中，通过调用系统调用exec()可以用一个新的程序替换当前进程的执行。

可以使用exec()函数来实现进程的运行。

具体步骤如下：（1）创建一个新的C程序文件，例如"process_run.c"。

（2）在C程序文件中，包含必要的头文件和函数声明，如<stdio.h>和<unistd.h>。

（3）在C程序文件中，编写main()函数，调用execl()函数来执行一个可执行程序。

（4）编译并运行该C程序文件，观察控制台输出结果。

实验中，可以通过观察控制台输出结果，判断新的程序是否被成功执行。

linux,pthread（转）

linux,pthread（转）1.“线程”进程与线程之间是有区别的，不过内核只提供了轻量进程的⽀持，未实现线程模型。

Linux是⼀种“多进程单线程”的。

Linux本⾝只有进程的概念，⽽其所谓的“线程”本质上在内核⾥仍然是进程。

⼤家知道，进程是资源分配的单位，同⼀进程中的多个线程共享该进程的资源（如作为共享内存的全局变量）。

Linux中所谓的“线程”只是在被创建时clone了⽗进程的资源，因此clone出来的进程表现为“线程”，这⼀点⼀定要弄清楚。

因此，Linux“线程”这个概念只有在打冒号的情况下才是最准确的。

⽬前Linux中最流⾏的线程机制为LinuxThreads，所采⽤的就是线程－进程“⼀对⼀”模型，调度交给核⼼，⽽在⽤户级实现⼀个包括信号处理在内的线程管理机制。

LinuxThreads由Xavier Leroy (Xavier.Leroy@inria.fr)负责开发完成，并已绑定在GLIBC中发⾏，它实现了⼀种BiCapitalized⾯向Linux的Posix 1003.1c “pthread”标准接⼝。

Linuxthread可以⽀持Intel、Alpha、MIPS等平台上的多处理器系统。

按照POSIX 1003.1c 标准编写的程序与Linuxthread 库相链接即可⽀持Linux平台上的多线程，在程序中需包含头⽂件pthread. h，在编译链接时使⽤命令：gcc -D -REENTRANT -lpthread xxx. c其中-REENTRANT宏使得相关库函数(如stdio.h、errno.h中函数) 是可重⼊的、线程安全的(thread-safe)，-lpthread则意味着链接库⽬录下的libpthread.a或libpthread.so⽂件。

使⽤Linuxthread库需要2.0以上版本的Linux内核及相应版本的C库(libc 5.2.18、libc 5.4.12、libc 6)。

linux查看线程名称的方法

linux查看线程名称的方法在Linux环境下，要查看线程名称，可以使用以下方法：1.通过ps命令查看线程名称：在Linux中，可以使用ps命令（process status）来查看进程的状态信息，包括进程的名称、PID（进程ID）、线程数量等。

使用如下命令来查看所有线程的信息：```ps -eLf```输出结果中，第一个列是线程的ID（LWP），第四列是进程ID （PID），第七列是线程的名称（COMM）。

通过查看该列的内容，就可以获取线程的名称。

除了使用-eLf选项，还可以使用其他选项，如-a（显示终端上的所有进程）、-A（显示所有进程）、u（显示用户相关的进程）等。

2.通过top命令查看线程名称：top命令是一个实时的动态监视工具，可以显示系统的整体状态和各个进程的资源使用情况。

默认情况下，top命令会按照CPU使用率降序排序，展示前几个消耗CPU资源最多的进程信息。

我们可以使用以下命令来查看所有线程的信息：```top -H```在top命令的输出结果中，PID、USER、PR、NI、VIRT、RES、SHR、S、%CPU、%MEM、TIME+、COMMAND等列，可以查看到线程的ID（PID）、进程的名称（COMMAND）等信息。

top命令支持交互式操作，可以通过按键进行排序和筛选操作，如按下P键按照CPU使用率排序。

3.通过pstree命令查看线程名称：pstree命令可以以树状结构显示进程和子进程之间的关系。

可以使用如下命令来查看指定进程及其所有子进程的信息：pstree -p <PID>```这个命令输出了树状结构的进程和子进程，通过查看输出结果，可以获取线程的名称信息。

-p选项可以显示进程的PID。

4.通过/proc文件系统查看线程名称：在Linux系统中，每个进程都可以在/proc目录下找到一个以其PID为名称的目录，例如/proc/1234。

这个目录中包含了与该进程相关的各种信息。

Linux下查看线程数的几种方法汇总

⼀.Linux下查看某个进程的线程数量 pstree命令以树状图显⽰进程间的关系（display a tree of processes）。

ps命令可以显⽰当前正在运⾏的那些进程的信息，但是对于它们之间的关系却显⽰得不够清晰。

在Linux系统中，系统调⽤fork可以创建⼦进程，通过⼦shell也可以创建⼦进程，Linux系统中进程之间的关系天⽣就是⼀棵树，树的根就是进程PID为1的init进程。

1>.安装pstree命令⾏⼯具，包名为：“psmisc”[root@yinzhengjie bin]# yum -y install psmiscLoaded plugins: fastestmirrorLoading mirror speeds from cached hostfileResolving Dependencies--> Running transaction check---> Package psmisc.x86_64 0:22.20-15.el7 will be installed--> Finished Dependency ResolutionDependencies Resolved==================================================================================================================================================================== Package Arch Version Repository Size==================================================================================================================================================================== Installing:psmisc x86_64 22.20-15.el7 base 141 kTransaction Summary==================================================================================================================================================================== Install 1 PackageTotal download size: 141 kInstalled size: 475 kDownloading packages:psmisc-22.20-15.el7.x86_64.rpm | 141 kB 00:00:00Running transaction checkRunning transaction testTransaction test succeededRunning transactionInstalling : psmisc-22.20-15.el7.x86_64 1/1Verifying : psmisc-22.20-15.el7.x86_64 1/1Installed:psmisc.x86_64 0:22.20-15.el7Complete![root@yinzhengjie bin]#[root@yinzhengjie bin]# yum -y install psmisc2>.相关参数介绍Usage: pstree [ -a ] [ -c ] [ -h | -H PID ] [ -l ] [ -n ] [ -p ] [ -g ] [ -u ][ -A | -G | -U ] [ PID | USER ]pstree -VDisplay a tree of processes.-a, --arguments 显⽰命令时候,并显⽰其参数的完整内容-A, --ascii 各进程树之间的连接以ASCII码字符来连接-c, --compact 取消同名兄弟进程的合并(默认会将同名的兄弟进程合并)-h, --highlight-all 突出当前进程及其祖先-H PID,--highlight-pid=PID 突出这个过程和它的祖先-g, --show-pgids 显⽰进程组ID；-G, --vt100 使⽤VT100线绘制字符-l, --long 不要截断长线。

第6章 linux进程控制开发及多线程编程

进程的状态
进程是程序的执行过程，根据它的生命周期可以划分成3种状态。执行态：该进程正在运行，即进程正在占用CPU。就绪态：进程已经具备执行的一切条件，正在等待分配 CPU的处理时间片。等待态：进程不能使用CPU，若等待事件发生（等待的资源分配到）则可将其唤醒。
Linux下进程地址空间（1）
互斥锁线程控制（1）
在同一时刻只能有一个线程掌握某个互斥锁，拥有上锁状态的线程能够对共享资源进行操作。若其他线程希望上锁一个已经被上锁的互斥锁，则该线程就会挂起，直到上锁的线程释放掉互斥锁为止。
互斥锁机制主要包括下面的基本函数。互斥锁初始化： pthread_mutex_init() 互斥锁上锁： pthread_mutex_lock() 互斥锁判断上锁：pthread_mutex_trylock() 互斥锁解锁： pthread_mutex_unlock() 消除互斥锁： pthread_mutex_destroy()
示例
阅读并执行示例7-2-4 开始
教材P216-P217
fork()
程序功能：（1）使用fork创建一个子进程，然后让其子进程暂停5s（sleep函数）。（2）父进程使用waitpid，参数 WNOHANG使进程不会阻塞；（3）若子进程退出，则waitpid返回子进程号，若没有则waitpid返回0，并且父进程每隔一秒循环判断。
因此，可以通过返回值来判定该进程是父进程还是子进程。
fork示例
1.Fork返回两个值返回到哪里？？
int main(void)
{

pid_t result;
2.怎样区分是父、子进程？？

result = fork();

LINUX查看进程的4种方法（小结）

LINUX查看进程的4种⽅法（⼩结）进程是在 CPU 及内存中运⾏的程序代码，⽽每个进程可以创建⼀个或多个进程（⽗⼦进程）。

**查看进程⽅法：**第⼀种：ps auxps命令⽤于报告当前系统的进程状态。

可以搭配kill指令随时中断、删除不必要的程序。

ps命令是最基本同时也是⾮常强⼤的进程查看命令，使⽤该命令可以确定有哪些进程正在运⾏和运⾏的状态、进程是否结束、进程有没有僵死、哪些进程占⽤了过多的资源等等，总之⼤部分信息都是可以通过执⾏该命令得到的。

a：显⽰当前终端下的所有进程信息，包括其他⽤户的进程。

u：使⽤以⽤户为主的格式输出进程信息。

x：显⽰当前⽤户在所有终端下的进程。

⽰例：**上图中各字段解释：**USER：启动该进程的⽤户账号名称PID：该进程的ID号，在当前系统中是唯⼀的%CPU：CPU占⽤的百分⽐%MEM：内存占⽤的百分⽐VSZ：占⽤虚拟内存（swap空间）的⼤⼩RSS：占⽤常驻内存（物理内存）的⼤⼩TTY：该进程在哪个终端上运⾏。

“？”表未知或不需要终端STAT：显⽰了进程当前的状态，如S（休眠）、R（运⾏）、Z（僵死）、<（⾼优先级）、N（低优先级）、s（⽗进程）、+（前台进程）。

对处于僵死状态的进程应予以⼿动终⽌。

START：启动该进程的时间TIME：该进程占⽤CPU时间COMMAND：启动该进程的命令的名称**总结：ps aux 是以简单列表的形式显⽰出进程信息。

**第⼆种：ps -elf-e：显⽰系统内的所有进程信息。

-l：使⽤长（long）格式显⽰进程信息。

-f：使⽤完整的（full）格式显⽰进程信息。

上图字段解释：⼤部分跟第⼀种⼀样，PPID为⽗进程的PID。

第三种：top以全屏交互式的界⾯显⽰进程排名，及时跟踪包括CPU、内存等系统资源占⽤情况，默认情况下每三秒刷新⼀次，其作⽤基本类似于Windows系统中的任务管理器。

上图解释：Tasks（系统任务）信息：total，总进程数；running，正在运⾏的进程数；sleeping，休眠的进程数；stopped，中⽌的进程数；zombie，僵死⽆响应的进程数。

Linux学习知识点--进程和线程有什么区别进程和线程的区别

Linux学习知识点--进程和线程有什么区别进程和线程的区别学习Linu某来说并不是一件简单的事情，之前作为一个非常的网管大神，遇到Linu某的时候还是表示胡一脸的蒙蔽，真正系统学习了之后才知道这个非常乏味却又充满未知的领域是多么的吸引我的注意。

线程是进程的一个执行流，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。

一个进程由几个线程组成（拥有很多相对独立的执行流的用户程序共享应用程序的大部分数据结构），线程与同属一个进程的其他的线程共享进程所拥有的全部资源。

"进程——资源分配的最小单位，线程——程序执行的最小单位"进程从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。

是程序执行时的一个实例，即它是程序已经执行到课中程度的数据结构的汇集。

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。

线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。

但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

（下面的内容摘自Linu某下的多线程编程）使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。

我们知道，在Linu某系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。

而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。

linux多线程的实现方式

linux多线程的实现方式Linux是一种支持多线程的操作系统，它提供了许多不同的方式来实现多线程。

本文将介绍Linux多线程的几种实现方式。

1. 线程库Linux提供了线程库，包括POSIX线程库（Pthreads）和LinuxThreads。

Pthreads是一种由IEEE组织制定的标准线程库，它提供了一组线程API，可以在不同的操作系统上实现。

LinuxThreads 是Linux内核提供的线程实现，不同于Pthreads，它不是标准线程库，但具有更好的性能。

使用线程库可以方便地创建和管理线程，线程库提供了许多API 函数，例如pthread_create()，pthread_join()，pthread_mutex_lock()等，可以在程序中使用这些API函数来实现多线程。

2. 多进程在Linux中，多进程也是一种实现多线程的方式。

每个进程都可以有自己的线程，进程之间也可以通过IPC机制进行通信。

多进程的优点是可以更好地利用多核CPU，因为每个进程都可以在不同的CPU核心上运行。

但是，多进程的开销比多线程大，因为每个进程都需要拥有自己的地址空间和运行环境。

3. 线程池线程池是一种常见的多线程实现方式。

线程池中有多个线程可以处理任务，任务可以通过任务队列来进行分发。

当任务到达时，线程池中的线程会从任务队列中取出任务并处理。

线程池的优点是可以重复利用线程，减少创建和销毁线程的开销。

线程池还可以控制线程的数量，避免过多线程导致的性能下降。

4. 协程协程是一种轻量级线程，它不需要操作系统的支持，可以在用户空间中实现。

协程基于线程，但是不需要线程上下文切换的开销，因为协程可以在同一个线程内进行切换。

协程的优点是可以更好地利用CPU，因为不需要线程上下文切换的开销。

协程还可以更好地控制并发性，因为协程的切换是由程序员控制的。

总结Linux提供了多种实现多线程的方式，每种方式都有其优点和缺点。

在选择多线程实现方式时，需要考虑到应用程序的特点和需求，选择最适合的实现方式。

在Linux中查看所有正在运行的进程的方法

在Linux中查看所有正在运⾏的进程的⽅法可以使⽤ps命令。

它能显⽰当前运⾏中进程的相关信息，包括进程的PID。

Linux和UNIX都⽀持ps命令，显⽰所有运⾏中进程的相关信息。

ps命令能提供⼀份当前进程的快照。

如果想状态可以⾃动刷新，可以使⽤top命令。

ps命令输⼊下⾯的ps命令，显⽰所有运⾏中的进程：# ps aux | less其中，-A：显⽰所有进程a：显⽰终端中包括其它⽤户的所有进程x：显⽰⽆控制终端的进程任务：查看系统中的每个进程。

# ps -A# ps -e任务：查看⾮root运⾏的进程# ps -U root -u root -N任务：查看⽤户vivek运⾏的进程ps -u vivek任务：top命令top命令提供了运⾏中系统的动态实时视图。

在命令提⽰⾏中输⼊top：# top输出：按q退出，按h进⼊帮助。

任务：显⽰进程的树状图。

pstree以树状显⽰正在运⾏的进程。

树的根节点为pid或init。

如果指定了⽤户名，进程树将以⽤户所拥有的进程作为根节点。

$ pstree输出⽰例：任务：使⽤ps列印进程树# ps -ejH# ps axjf任务：获得线程信息输⼊下列命令：# ps -eLf# ps axms任务：获得安全信息输⼊下列命令：# ps -eo euser,ruser,suser,fuser,f,comm,label# ps axZ# ps -eM任务：将进程快照储存到⽂件中输⼊下列命令：# top -b -n1 > /tmp/process.log你也可以将结果通过邮件发给⾃⼰：# top -b -n1 | mail -s 'Process snapshot' you@使⽤pgrep命令。

pgrep能查找当前正在运⾏的进程并列出符合条件的进程ID。

例如显⽰firefox的进程ID：任务：查找进程$ pgrep firefox下⾯命令将显⽰进程名为sshd、所有者为root的进程。

通用技术相关知识点汇总

通用技术相关知识点汇总一、操作系统1. 操作系统的定义与作用操作系统是计算机系统中管理、控制和协调各种硬件和软件资源的程序集合。

它的主要作用是为用户提供简单易用的界面，管理计算机系统的硬件和软件资源，以及实现对计算机系统的有效控制。

2. 常见的操作系统类型- Windows操作系统：由Microsoft开发，主要应用于个人计算机。

- macOS操作系统：由Apple开发，主要应用于苹果电脑和移动设备。

- Linux操作系统：开源的操作系统，广泛应用于服务器和嵌入式系统。

- Android操作系统：由Google开发，用于移动设备。

3. 进程与线程的区别- 进程：是计算机中正在运行的程序的实例。

它具有独立的内存空间和资源，可以与其他进程并发执行。

- 线程：是进程中的执行单元，一个进程可以包含多个线程。

线程共享进程的内存资源，可以并发执行，提高程序的运行效率。

4. 存储管理技术- 虚拟内存：通过将内存空间划分为若干个固定大小的页面，实现虚拟内存与物理内存的映射，扩大了可用内存空间。

- 页面置换算法：当内存不足时，通过页面置换算法将不常用的页面从内存中换出，从而为新的页面腾出空间。

5. 文件系统- 文件系统是操作系统用于管理存储设备中文件和目录的一种组织方式。

- 常见的文件系统有FAT32、NTFS（Windows系统）、HFS+（macOS系统）和Ext4（Linux系统）等。

二、计算机网络1. 网络协议- TCP/IP协议：是互联网的基础协议，包括TCP（传输控制协议）和IP（互联网协议）两部分。

- HTTP协议：是用于Web浏览器和服务器之间传输超文本的协议，是互联网上最常用的协议之一。

- FTP协议：是用于文件传输的协议，可实现文件的上传和下载。

2. 网络拓扑结构- 总线型：所有设备通过一根总线连接，数据在总线上传输。

- 星型：设备通过独立的链路与中央设备（如交换机）相连，数据通过中央设备进行传输。

Linux下查看进程和线程的方法

Linux下查看进程和线程的方法Linux下查看进程和线程的方法大家想知道在Linux下怎么查看进程和线程吗？下面店铺为大家整理了Linux下查看进程和线程的方法，希望能帮到大家！在Linux中查看线程数的三种方法1、top -H手册中说：-H : Threads toggle加上这个选项启动top，top一行显示一个线程。

否则，它一行显示一个进程。

2、ps xH手册中说：H Show threads as if they were processes这样可以查看所有存在的线程。

3、ps -mp手册中说：m Show threads after processes这样可以查看一个进程起的线程数。

查看进程1. top 命令top命令查看系统的资源状况load average表示在过去的一段时间内有多少个进程企图独占CPUzombie 进程：不是异常情况。

一个进程从创建到结束在最后那一段时间遍是僵尸。

留在内存中等待父进程取的东西便是僵尸。

任何程序都有僵尸状态，它占用一点内存资源，仅仅是表象而已不必害怕。

如果程序有问题有机会遇见，解决大批量僵尸简单有效的办法是重起。

kill是无任何效果的stop模式：与sleep进程应区别，sleep会主动放弃cpu，而stop是被动放弃cpu ，例单步跟踪，stop(暂停)的进程是无法自己回到运行状态的。

判断物理内存够不够，看交换分区的使用状态。

交互命令：[Space]立即刷新显示[h]显示帮助屏幕[k] 杀死某进程。

你会被提示输入进程ID 以及要发送给它的信号。

一般的终止进程可以使用15信号;如果不能正常结束那就使用信号9强制结束该进程。

Linux进程管理与调度

bitmap[BITMAP_SIZE];//优先级位图 queue[MAX_PRIO];//优先级队列
}
说明：每个运行队列有2个优先级数组，一个活跃的，一个过期的。能够提供 O(1)级算法复杂度的数据结构。
Linux进程调度实现

优先级数组的重置
通过维护2个优先级数组,active,expired, active数组上的进程还有剩余时间片， expired数组上的进程全部耗尽了时间片。
bonus = CURRENT_BONUS(p) – MAX_BONUS / 2; prio = p->static_prio – bonus; … ……
return prio;
} 说明：系统通过一系列宏计算出bonus.
bonus = （进程睡眠jiffers/HZ )*10 - 5
effective_prio()函数：计算非实时进程的优先级，主要步骤如下：算出当前进程平均睡眠时间。得到进程的动态优先级。 static int effective_prio(task_t *p) { if (rt_task(p)) return p-> prio;
Linux进程实现——相关的系统调用
fork(): 创建普通进程,copy on write（要复制父进程的页表）创建后子进程和父进程指向同一内存区域，仅当子进程有 write发生时候，才会把改动的区域copy到子进程新的地址空间 vfork()：共享创建，完全无拷贝。（子进程作为父进程的一个单独线程在其地址空间运行，父进程阻塞） clone(): 介于fork()和vfork()之间，可以指定共享什么，拷贝什么。

动态优先级设置时机：
1）进程创建时 2）唤醒休眠进程时，会修正进程的优先级

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

P26
进程的创建
► Linux中的进程创建
n init_task：
u
u
Linux在启动时运行在核心态，这时只有初始化程序在执行是系统的第一个进程，因此称为初始进程。 init_task在系统初始化结束后，初始进程启动一个核心进程，称为init。然后执行空闲循环，什么也不做。当系统没有其他工作时，调度程序会运行这个空闲进程。
linux操作系统
华软软件学院电子系
P15
Linux系统中的PCB
►Linux系统中的PCB
n 在Linux中，任务和进程是同一概念 n Linux中的PCB即任务数据结构： task_strcut，也称为进程描述符PD （ Processor Descriptor） n 定义在include/linux/sched.h中
linux操作系统华软软件学院电子系
P9
进程的基本状态
►运行态（Running）
n 进程占有CPU，并在CPU上运行。在单CPU系统中，最多只有一个进程处于运行态。
►就绪态（Ready）
n 一个进程已经具备运行条件，但由于无CPU暂时不能运行的状态（当调度给其CPU时，立即可以运行）。处于就绪状态的进程可以有多个。队列的排列次序一般按优先级大小来排列。
P23
Linux中与进程相关的命令
TOP
句法：top [OPTIONS] 功能：实时显示系统中各个进程的资源占用状况 TOP命令是一个动态显示过程，可以通过用户按键来不断刷新当前状态。
TOP命令是Linux下常用的性能分析工具
linux操作系统
华软软件学院电子系
P24
操作系统内核
► CPU的两种执行状态：系统态和用户态 n 系统态/核心态（特态或管态）：该状态下，CPU能执行指令集中任何指令； n 用户态（常态或目态）：该状态下，CPU只能执行一般的指令，不能执行特权指令。 ► 操作系统内核功能 n 中断处理 n 时钟管理 n 原语操作 n 进程管理 n 存储器管理 n 设备管理
华软软件学院电子系
P18
linux操作系统
Linux PCB中的进程状态（state）
n 暂停状态
u u
u
进程暂时停止运行以接受某种特殊处理通常当进程接收到SIGSTOP、SIGTSTP、SIGTTIN 或 SIGTTOU信号后就处于这种状态（关于信号，将在以后讲述）例如，正接受调试的进程就处于这种状态
linux操作系统华软软件学院电子系
P8
进程的特性
►进程的特性：
n 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的； n 并发性：任何进程都可以同其他进程一起并发执行； n 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位； n 异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度向前推进。
linux操作系统
华软软件学院电子系
P2
单道与多道程序设计
►多道程序设计的提出
n 单道程序设计
u
u
执行特点：静态的、孤立的具体特性：顺序性、封闭性、可再现性、资源独占性
为了充分有效地利用计算机的有限资源，提出了多道程序设计
linux操作系统华软软件学院电子系
P3
n 并发执行及“与时间有关的错误” u 并发执行，是指多个程序段之间在执行时间上重叠。 u 多程序段同时在系统中运行 u 宏观上并行，微观上串行 u 资源共享 u 问题： l 资源冲突，甚至死锁 l “与时间有关的错误”
►进程控制块与进程关系：
n 每个进程有唯一的PCB。 n 操作系统（OS）根据PCB管理进程。 n 利用PCB实现进程的动态、并发。 n PCB是进程存在的唯一标志。
linux操作系统华软软件学院电子系
P14
进程控制块PCB
►PCB的内容
n 标识信息：进程标识、用户名 n 说明信息：进程状态、等待原因、进程程序和数据的存储信息 n 现场信息：记录重要寄存器、时钟等内容，用于恢复断点 n 管理调度信息：进程优先级、进程队列指针、消息队列指针、进程使用的资源清单、进程家族关系、进程当前打开的文件
单道与多道程序设计
单道程序设计
多道程序设计
linux操作系统
华软软件学院电子系
P4
进程的定义
►进程的定义：进程是可并发执行的程序在一个数据集合的运行过程。它是操作系统动态执行的基本单元，是系统进行资源分配的独立单位。
启动浏览器IE后, 得到的进程
linux操作系统
华软软件学院电子系
P5
进程与程序及其分类
linux操作系统华软软件学院电子系
P21
Linux中与进程相关的命令
PS
-A：列出所有的行程
-w：显示加宽可以显示较多的资讯
-au：显示较详细的资讯 -aux：显示所有包含其他使用者的行程
-e：显示所有进程，环境变量
-f：全格式 -h：不显示标题
-l：长格式
注意区分“ps aux”和“ps -aux”命令
n 僵死状态
进程执行了exit()函数后进入该状态，即进程被终止 u 此状态将由父进程执行wait()系统调用而“唤醒”，真正终止该进程，并回收其资源 u 处于该状态的进程是死进程，属于系统中的垃圾，必须进行相应处理以释放其占用的资源
u
n 死亡状态：僵死进程被父进程回收后的状态
linux操作系统华软软件学院电子系
唤醒
低优睡眠
高优睡眠
linux操作系统
华软软件学院电子系
P12
进程的组成
►操作系统控制结构
n n n n 内存表用来跟踪主存和辅存。 I/0表用来管理I/0设备和通道。文件表提供当前存在文件中的信息。进程表用来管理进程。
►进程的组成
n 程序段：进程所对应的可执行程序； n 数据段：程序运行过程中要用到的数据或工作区； n 进程控制块（PCB）：为管理进程设置的一个专门的数据结构，用于记录进程的外部特征，描述进程的运动变化过程。
P17
linux操作系统
Linux PCB中的进程状态（state）
n 可运行状态
u u u
进程正在运行（运行态）、或者正准备运行（就绪态）正在运行的进程就是当前进程准备运行的进程只要得到CPU就可以立即投入运行， CPU是这些进程唯一等待的系统资源
n 可中断等待态、不可中断等待态
u
进程正等待某个事件（event）或某个资源 u 一定处于系统中的某个等待队列（wait_queue）中 u 两种等待态的差异： l 可中断等待态：可被信号唤醒，被唤醒后进入可运行态,等待被调度； l 不可中断等待态：因等待硬件资源，如某个通道、端口等，在任何情况下都不能被打断，直到资源满足。资源满足后只能用特定的方式来唤醒它，例如唤醒函数wake_up（）等
linux操作系统
华软软件学院电子系
P16
Linux系统中的PCB
►Linux PCB（task_struct)
n 包含进程所有信息 n task_struct数据结构很庞大，但并不复杂，按功能将所有域划分：
u u u u u u u u
u
u u u
1、进程状态（State） 2、进程调度信息（Scheduling Information） 3、各种标识符（Identifiers） 4、进程通信有关信息（IPC：Inter_Process Communication） 5、时间和定时器信息（Times and Timers） 6、进程链接信息（Links） 7、文件系统信息（File System） 8、虚拟内存信息（Virtual Memory） 9、页面管理信息（page） 10、对称多处理器（SMP）信息 11、和处理器相关的环境（上下文）信息（Processor Specific Context） 12、其它信息华软软件学院电子系
►阻塞态（Blocked）
n 指进程因等待某种事件的发生而暂时不能运行的状态，即使CPU空闲，该进程也不可运行。处于阻塞状态的进程可以有多个。
linux操作系统华软软件学院电子系
P10
进程状态之间的转换
进程占有CPU
进程被调度获得CPU
运行
时间片用完或被抢占已获得事件或等待的资源
P19
Linux的进程状态转换模型
linux操作系统
华软软件学院电子系
P20
Linux中与进程相关的命令
PS
ps —— Processes Snapshot 句法：ps [OPTIONS]
功能：对系统中的进程进行监控
[OPTION]参数如下：
l：长格式输出 u：按用户名和启动时间顺序来显示进程 j：用任务格式来显示进程 f：用全格式来显示进程 a：显示所有用户的所有进程 x：显示无控制终端的进程
教学内容
►进程的概念
►进程的特性
►进程的状态及其转换
►进程的控制
►Linux中的进程控制 ►线程
linux操作系统华软软件学院电子系
P1
教学要求
►掌握程序、进程、线程的区别 ►掌握进程的基本状态及状态转换 ►了解进程控制块（PCB）的内容 ►重点掌握linux系统中进程相关的命令、系统调用、库函数
linux操作系统华软软件学院电子系
P22
Linux中与进程相关的命令
kill
关闭进程：kill 进程号 kill -9 进程号（强行关闭） kill -1 进程号（重启进程）结束所有进程：killall 查找服务进程号：pgrep 服务名称关闭进程：pkill 进程名称
linux操作系统
华软软件学院电子系