进程线程笔记

合集下载

大一计算机知识点笔记手写

大一计算机知识点笔记手写计算机网络1. OSI七层模型1. 物理层2. 数据链路层3. 网络层4. 传输层5. 会话层6. 表示层7. 应用层2. TCP/IP四层模型1. 网络接口层2. 网络层3. 传输层4. 应用层3. IP地址和子网掩码- IPv4地址格式：xxx.xxx.xxx.xxx- 子网掩码用于划分网络和主机部分4. HTTP和HTTPS- HTTP（Hypertext Transfer Protocol）是一种用于传输超文本的协议- HTTPS（Hypertext Transfer Protocol Secure）是在HTTP的基础上加入了安全性功能的协议5. DNS解析- DNS（Domain Name System）用于将域名转换为IP地址6. IP协议和MAC地址- IP协议用于在网络中传输数据包- MAC地址是网卡的物理地址，用于唯一标识网络设备数据结构与算法1. 数组和链表- 数组是一组连续存储的元素，可随机访问- 链表是一组通过指针连接的节点，插入和删除操作效率高2. 栈和队列- 栈是一种后进先出（LIFO）的数据结构- 队列是一种先进先出（FIFO）的数据结构3. 树和二叉树- 树是由节点和边组成的层次结构- 二叉树每个节点最多有两个子节点4. 排序算法- 冒泡排序、插入排序、选择排序、快速排序、归并排序等5. 查找算法- 顺序查找、二分查找、哈希查找等6. 图算法- 广度优先搜索（BFS）、深度优先搜索（DFS）等操作系统1. 进程和线程- 进程是程序在操作系统中的执行实例- 线程是进程的执行单元2. 内存管理- 虚拟内存、分页系统、页面置换算法等3. 文件系统- 文件的存储和管理方式4. 进程调度算法- 先来先服务（FCFS）、短作业优先（SJF）、时间片轮转（RR）等5. 同步和互斥- 信号量、互斥锁、条件变量等数据库1. 关系型数据库和非关系型数据库- 关系型数据库使用表格结构进行数据存储和管理- 非关系型数据库使用键值对、文档、列族等方式进行数据存储和管理2. SQL语言- 结构化查询语言，用于操作关系型数据库3. 数据库索引- 提高数据检索效率的数据结构4. 数据库事务- 保证数据的一致性和完整性的操作单元编程语言1. C语言基础- 语法、变量和数据类型、运算符、控制流语句等2. Java语言基础- 类和对象、继承和多态、异常处理、输入输出等3. Python语言基础- 列表和字典、条件和循环、函数和模块等4. 编程范式- 面向过程、面向对象、函数式等5. 数据库编程- 使用编程语言操作数据库的方法总结：以上是大一计算机知识点的笔记手写，涵盖了计算机网络、数据结构与算法、操作系统、数据库和编程语言等多个方面的基础知识。

计算机操作系统笔记第一章

------------- ——第一章 --------- ——-------操作系统是配置在计算机硬件上的第一层软件，是对硬件系统的首次扩充，其主要作用是管理好这些设备。

操作系统的目标与应用环境有关。

操作系统的目标：1. 方便性 2. 有效性：提高系统资源的利用率，系统的吞吐量 3. 可扩充性4. 开放性：系统能遵循世界标准规范。

操作系统是一组能有效地组织和管理计算机硬件和软件资源，合理地堆各类作业进行调度，以及方便用户使用的程序的集合。

OS作为用户与计算机硬件系统之间接口的含义是：OS处于用户与计算机硬件系统之间，用户通过OS来使用计算机系统。

或者说，用户在OS帮助下能够方便、快捷、可靠地操纵计算机硬件和运行自己的程序。

OS是铺设在计算机硬件上的多层软件的集合，它们不仅增强了系统的功能，还隐藏了对硬件操作的具体细节，实现了对计算机硬件操作的多个层次的抽象模型。

用户通过命令方式，系统调用方式，图标-窗口方式来实现与操作系统的通信。

处理机管理是用于分配和控制处理机。

主要功能：创建和撤销进程，对诸进程的运行进行协调，实现进程之间的信息交换，以及按照一定的算法把处理机分配给进程。

进程控制。

进程同步：主要任务是为多个进程(含线程)的运行进行协调，进程互斥式，进程同步式。

进程通信：任务是实现相互合作进程之间的信息交换。

存储器管理主要负责内存的分配和回收。

主要任务：为多道程序的运行提高良好的环境，提高存储器的利用率，方便用户使用，并能从逻辑上扩充内容。

功能：内存分配：主要任务是：(1) 为每道程序分配内存空间，使它们“各得其所”。

(2) 提高存储器的利用率，尽量减少不可用的内存空间( 碎片)。

(3) 允许正在运行的程序申请附加的内存空间，以适应程序和数据动态增长的需要。

(静态分配方式：固定内存大小位置，动态分配方式) 内存保护：主要任务是：①确保每道用户程序都仅在自己的内存空间内运行，彼此互不干扰。

②绝不允许用户程序访问操作系统的程序和数据，也不允许用户程序转移到非共享的其它用户程序中去执行。

C#线程学习笔记七：Task详细用法

C#线程学习笔记七：Task详细⽤法⼀、Task类简介Task类是在.NET Framework 4.0中提供的新功能，主要⽤于异步操作的控制。

它⽐Thread和ThreadPool提供了更为强⼤的功能，并且更⽅便使⽤。

Task和Task<TResult>类：前者接收的是Action委托类型；后者接收的是Func<TResult>委托类型。

任务Task和线程Thread的区别：1、任务是架构在线程之上。

也就是说任务最终还是要抛给线程去执⾏，它们都是在同⼀命名空间System.Threading下。

2、任务跟线程并不是⼀对⼀的关系。

⽐如说开启10个任务并不⼀定会开启10个线程，因为使⽤Task开启新任务时，是从线程池中调⽤线程，这点与ThreadPool.QueueUserWorkItem类似。

⼆、Task的创建2.1创建⽅式1：调⽤构造函数class Program{static void Main(string[] args){#region⼯作者线程：使⽤任务实现异步ThreadPool.SetMaxThreads(1000, 1000);PrintMessage("Main thread start.");//调⽤构造函数创建Task对象Task<int> task = new Task<int>(n => AsyncMethod((int)n), 10);//启动任务task.Start();//等待任务完成task.Wait();Console.WriteLine("The method result is: " + task.Result);Console.ReadLine();#endregion}///<summary>///打印线程池信息///</summary>///<param name="data"></param>private static void PrintMessage(string data){//获得线程池中可⽤的⼯作者线程数量及I/O线程数量ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber);Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n",data,Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsBackground.ToString(),workThreadNumber.ToString(),ioThreadNumber.ToString());}///<summary>///异步⽅法///</summary>///<param name="n"></param>///<returns></returns>private static int AsyncMethod(int n){Thread.Sleep(1000);PrintMessage("Asynchoronous method.");int sum = 0;for (int i = 1; i < n; i++){//运算溢出检查checked{sum += i;}}return sum;}}View Code2.2创建⽅式2：任务⼯⼚class Program{static void Main(string[] args){#region⼯作者线程：使⽤任务⼯⼚实现异步////⽆参⽆返回值//ThreadPool.SetMaxThreads(1000, 1000);//Task.Factory.StartNew(() => PrintMessage("Main thread."));//Console.Read();//有参有返回值ThreadPool.SetMaxThreads(1000, 1000);PrintMessage("Main thread start.");var task = Task.Factory.StartNew(n => AsyncMethod((int)n), 10);//等待任务完成task.Wait();Console.WriteLine("The method result is: " + task.Result);Console.ReadLine();#endregion}///<summary>///打印线程池信息///</summary>///<param name="data"></param>private static void PrintMessage(string data){//获得线程池中可⽤的⼯作者线程数量及I/O线程数量ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber);Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n", data,Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsBackground.ToString(),workThreadNumber.ToString(),ioThreadNumber.ToString());}///<summary>///异步⽅法///</summary>///<param name="n"></param>///<returns></returns>private static int AsyncMethod(int n){Thread.Sleep(1000);PrintMessage("Asynchoronous method.");int sum = 0;for (int i = 1; i < n; i++){//运算溢出检查checked{sum += i;}}return sum;}}View Code2.3创建⽅式3：Run⽅法class Program{static void Main(string[] args){#region⼯作者线程：使⽤Task.Run实现异步ThreadPool.SetMaxThreads(1000, 1000);PrintMessage("Main thread start.");var task = Task.Run(() => AsyncMethod(10));//等待任务完成task.Wait();Console.WriteLine("The method result is: " + task.Result);Console.ReadLine();#endregion}///<summary>///打印线程池信息///</summary>///<param name="data"></param>private static void PrintMessage(string data){//获得线程池中可⽤的⼯作者线程数量及I/O线程数量ThreadPool.GetAvailableThreads(out int workThreadNumber, out int ioThreadNumber);Console.WriteLine("{0}\n CurrentThreadId is:{1}\n CurrentThread is background:{2}\n WorkerThreadNumber is:{3}\n IOThreadNumbers is:{4}\n", data,Thread.CurrentThread.ManagedThreadId,Thread.CurrentThread.IsBackground.ToString(),workThreadNumber.ToString(),ioThreadNumber.ToString());}///<summary>///异步⽅法///</summary>///<param name="n"></param>///<returns></returns>private static int AsyncMethod(int n){Thread.Sleep(1000);PrintMessage("Asynchoronous method.");int sum = 0;for (int i = 1; i < n; i++){//运算溢出检查checked{sum += i;}}return sum;}}View Code三、Task的简略⽣命周期可通过Status属性获取。

多线程知识点总结归纳

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

作业、进程、线程

作业、进程、线程1. 基本概念作业：⽤户在⼀次解决或是⼀个事务处理过程中要求计算机系统所做的⼯作的集合，它包括⽤户程序、所需要的数据集控制命令等。

作业是由⼀系列有序的步骤组成的。

作业的完成要经过作业提交、作业收容、作业执⾏和作业完成4个阶段。

在执⾏⼀个作业可能会运⾏多个不同的进程。

进程：程序在⼀个数据集上的⼀次运⾏过程。

是操作系统资源分配的基本单位。

在Windows下,进程⼜被细化为线程,也就是⼀个进程下有多个能独⽴运⾏的更⼩的单位. 进程还拥有⼀个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。

线程：是进程中的⼀个实体，是被操作系统独⽴调度和执⾏的基本单位。

⼀个进程包含⼀个或多个线程。

线程只能归属于⼀个进程并且它只能访问该进程所拥有的资源。

当操作系统创建⼀个进程后，该进程会⾃动申请⼀个名为主线程或⾸要线程的线程。

主线程将执⾏运⾏时宿主, ⽽运⾏时宿主会负责载⼊CLR。

简单总结：作业是向计算机提交任务的任务实体，⽽进程是执⾏实体，是资源分配的基本单位，线程是处理机调度的基本单位。

2. 进程2.1 进程的概念主要有两点：第⼀，进程是⼀个实体。

每⼀个进程都有它⾃⼰的地址空间，⼀般情况下，包括⽂本区域（text region）、数据区域（data region）和堆栈（stack region）。

⽂本区域存储处理器执⾏的代码；数据区域存储变量和进程执⾏期间使⽤的动态分配的内存；堆栈区域存储着活动过程调⽤的指令和本地变量。

第⼆，进程是⼀个“执⾏中的程序”。

程序是⼀个没有⽣命的实体，只有处理器赋予程序⽣命时，它才能成为⼀个活动的实体，我们称其为进程。

2.2 进程特征动态性：进程的实质是程序在多道程序系统中的⼀次执⾏过程，进程是动态产⽣，动态消亡的。

并发性：任何进程都可以同其他进程⼀起并发执⾏独⽴性：进程是⼀个能独⽴运⾏的基本单位，同时也是系统分配资源和调度的独⽴单位；异步性：由于进程间的相互制约，使进程具有执⾏的间断性，即进程按各⾃独⽴的、不可预知的速度向前推进结构特征：进程由程序、数据和进程控制块三部分组成。

一文读懂什么是进程、线程、协程（建议收藏）

⼀⽂读懂什么是进程、线程、协程（建议收藏）进程我们都知道计算机的核⼼是CPU，它承担了所有的计算任务；⽽操作系统是计算机的管理者，它负责任务的调度、资源的分配和管理，统领整个计算机硬件；应⽤程序则是具有某种功能的程序，程序是运⾏于操作系统之上的。

进程是⼀个具有⼀定独⽴功能的程序在⼀个数据集上的⼀次动态执⾏的过程，是操作系统进⾏资源分配和调度的⼀个独⽴单位，是应⽤程序运⾏的载体。

进程是⼀种抽象的概念，从来没有统⼀的标准定义。

进程⼀般由程序、数据集合和进程控制块三部分组成。

程序⽤于描述进程要完成的功能，是控制进程执⾏的指令集；数据集合是程序在执⾏时所需要的数据和⼯作区；程序控制块(Program Control Block，简称PCB)，包含进程的描述信息和控制信息，是进程存在的唯⼀标志。

进程具有的特征：动态性：进程是程序的⼀次执⾏过程，是临时的，有⽣命期的，是动态产⽣，动态消亡的；并发性：任何进程都可以同其他进程⼀起并发执⾏；独⽴性：进程是系统进⾏资源分配和调度的⼀个独⽴单位；结构性：进程由程序、数据和进程控制块三部分组成。

线程在早期的操作系统中并没有线程的概念，进程是能拥有资源和独⽴运⾏的最⼩单位，也是程序执⾏的最⼩单位。

任务调度采⽤的是时间⽚轮转的抢占式调度⽅式，⽽进程是任务调度的最⼩单位，每个进程有各⾃独⽴的⼀块内存，使得各个进程之间内存地址相互隔离。

后来，随着计算机的发展，对CPU的要求越来越⾼，进程之间的切换开销较⼤，已经⽆法满⾜越来越复杂的程序的要求了。

于是就发明了线程。

线程是程序执⾏中⼀个单⼀的顺序控制流程，是程序执⾏流的最⼩单元，是处理器调度和分派的基本单位。

⼀个进程可以有⼀个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。

⼀个标准的线程由线程ID、当前指令指针(PC)、寄存器和堆栈组成。

⽽进程由内存空间(代码、数据、进程空间、打开的⽂件)和⼀个或多个线程组成。

408考研操作系统复习知识点总结笔记

408考研操作系统复习知识点总结笔记●第一章计算机系统概述●考试大纲●一、操作系统的基本概念●操作系统是指控制和管理整个计算机系统的硬件与软件资源，合理地组织、调度计算机的工作与资源的分配，进而为用户和其他软件提供方便接口与环境的程序集合，是计算机系统中最基本的系统软件●操作系统的特征●并发●共享●虚拟●异步：多道程序环境允许多个程序并发执行，但由于资源有限，进程的执行并不是一贯到底的，而是走走停停，它以不可预知的速度向前推进，这就是进程的异步性●操作系统的功能●作为计算机系统资源的管理者，负责处理机管理、存储器管理、文件管理、设备管理●作为用户与计算机硬件系统之间的接口，包括命令接口、程序接口●实现对计算机资源的扩充●二、操作系统的发展历史●手工操作阶段（还没有操作系统）●批处理阶段：解决人机矛盾及CPU和I/O设备之间速度不匹配的问题●单道批处理系统：内存中始终只存放了一个作业●多道批处理系统：允许多个程序同时进入内存并允许它们在CPU中交替的运行●分时操作系统：多个用户通过终端同时共享一台主机，用户可以同时与主机进行交互操作而互不干扰，较好地解决了人机交互问题●实时操作系统：计算机系统接收到外部信号后及时进行处理，并在严格的时限内处理完接收的事件，主要特点是及时性和可靠性●网络操作系统：把计算机网络中的各台计算机有机地结合起来，提供一种统一的，经济而有效的使用各计算机的方法，实现各台计算机之间数据的相互传送●分布式操作系统：系统中任意两台主机之间使用通信方式交换信息；系统中任意台主机都可以构成一个子系统；每台计算机地位相等；每台计算机上的资源都被所有用户共享；任务可以分布在几台计算机上由他们并行、协同完成，特点是并行性和分布性●个人计算机操作系统●●三、程序运行环境●CPU运行模式：CPU执行的程序分为操作系统内核程序和用户自编程序两种●特权命令：不允许用户直接使用的指令，如I/O指令，置中断指令等●非特权指令：允许用户直接使用的指令，不能直接访问系统的软硬件资源，只能访问用户的地址空间●内核模式与用户模式●内核的概念：是计算机上配置的底层软件，是最接近硬件的地方，包括以下内容●时钟管理●中断机制●原语●系统控制的数据结构及处理●核心态（管态、内核态）：CPU可以执行特权指令，操作系统内核程序运行在内核态●用户态（目态）：CPU只能执行非特权指令，用户自编程序运行在用户态●内核态变为用户态：执行一条特权指令，修改PSW的标志位为用户态，然后操作系统主动让出CPU使用权●用户态变为内核态：由中断引发，硬件自动完成变态过程，操作系统强行夺回CPU使用权●中断和异常的处理（见计算机组成原理的第七章）●系统调用：用户在程序中调用操作系统提供的一些子功能，在用户程序中凡是与资源相关的操作都要通过系统调用来完成，要运行在核心态。

计算机操作系统重点知识点整理

计算机操作系统重点知识点整理1. 操作系统介绍操作系统是计算机系统的核心组成部分，负责管理和控制计算机硬件及软件资源，提供良好的用户界面和服务。

操作系统是计算机科学中的重要分支，研究和理解操作系统的基本知识点对于计算机专业人员至关重要。

2. 进程与线程进程是指在计算机中正在运行的程序的实例，它拥有独立的内存空间和系统资源。

线程是进程中的一个执行单元，多线程可以提高程序的执行效率和并发性。

重点知识点包括进程与线程的区别和联系、线程同步与互斥、进程调度算法等。

3. 内存管理内存管理是操作系统中重要的部分，包括内存分配、内存回收、虚拟内存等。

其中，虚拟内存可以扩展主存容量，使得计算机可以同时运行更多的程序。

重点知识点包括内存分页、段式内存管理、页面置换算法等。

4. 文件系统文件系统是操作系统中负责管理和控制文件的组织结构和存储空间的部分，提供对文件的读写和管理功能。

重点知识点包括文件目录结构、文件存储方式、文件权限管理等。

5. 输入输出设备管理输入输出设备管理是操作系统中与外部设备交互的部分，包括对输入设备和输出设备的控制和管理。

重点知识点包括缓冲区管理、设备驱动程序、中断处理等。

6. 文件系统与磁盘管理文件系统与磁盘管理是操作系统中重要的部分，涉及到磁盘的组织和管理、文件的存取与保护等。

重点知识点包括磁盘分区、磁盘调度算法、磁盘块分配算法等。

7. 进程通信与同步进程通信与同步是操作系统中重要的内容，用于实现多个进程之间的信息交换和协作。

重点知识点包括进程间通信的方式、进程的同步与互斥机制、死锁问题等。

8. 网络操作系统网络操作系统是运行在网络环境中的操作系统，可以管理和控制分布在不同节点上的计算机资源。

重点知识点包括分布式系统的架构、网络拓扑结构、网络安全等。

9. 安全与保护安全与保护是操作系统中非常重要的内容，涉及到系统资源的权限管理、数据的保护与加密、防止未授权访问等。

重点知识点包括访问控制模型、身份验证、防火墙等。

xv6学习笔记（4）：进程调度

xv6学习笔记（4）：进程调度xv6学习笔记(4) : 进程xv6所有程序都是单进程、单线程程序。

要明⽩这个概念才好继续往下看1. XV6中进程相关的数据结构在XV6中，与进程有关的数据结构如下// Per-process statestruct proc {uint sz; // Size of process memory (bytes)pde_t* pgdir; // Page tablechar *kstack; // Bottom of kernel stack for this processenum procstate state; // Process stateint pid; // Process IDstruct proc *parent; // Parent processstruct trapframe *tf; // Trap frame for current syscallstruct context *context; // swtch() here to run processvoid *chan; // If non-zero, sleeping on chanint killed; // If non-zero, have been killedstruct file *ofile[NOFILE]; // Open filesstruct inode *cwd; // Current directorychar name[16]; // Process name (debugging)};与前述的两类信息的对应关系如下操作系统管理进程有关的信息：内核栈kstack，进程的状态state，进程的pid，进程的⽗进程parent，进程的中断帧tf，进程的上下⽂context，与sleep和kill有关的chan和killed变量。

进程本⾝运⾏所需要的全部环境：虚拟内存信息sz和pgdir，打开的⽂件ofile和当前⽬录cwd。

cs-notes面试笔记 (2)

cs-notes面试笔记引言概述：CS-Notes是一份面试笔记，旨在帮助计算机科学学习者准备面试。

该笔记内容丰富，包含了计算机科学的各个方面，从数据结构和算法到操作系统和网络，都有详细的解释和示例。

本文将以引言概述、正文内容和总结三个部分，详细介绍CS-Notes面试笔记的五个大点。

正文内容：1. 数据结构与算法1.1 数组和链表：介绍数组和链表的特点、使用场景以及它们的优缺点。

1.2 栈和队列：解释栈和队列的定义、操作和应用，包括逆波兰表达式、迷宫问题等。

1.3 树和图：讲解二叉树、平衡树和图的基本概念、遍历算法和常见的应用场景。

1.4 排序和查找：介绍常见的排序算法，如冒泡排序、快速排序以及二分查找等。

1.5 动态规划和贪心算法：详细解释动态规划和贪心算法的原理和应用，如背包问题和最短路径问题等。

2. 操作系统2.1 进程和线程：解释进程和线程的概念、区别和应用，包括同步和互斥等问题。

2.2 内存管理：介绍内存管理的基本原理，包括分页、分段和虚拟内存等。

2.3 文件系统：讲解文件系统的组织结构和操作，如文件的创建、读取和删除等。

2.4 进程调度：解释进程调度算法，如先来先服务、短作业优先和时间片轮转等。

2.5 死锁：详细讲解死锁的概念、原因以及预防和解决死锁的方法。

3. 计算机网络3.1 OSI七层模型：介绍OSI七层模型的层次结构和各层的功能。

3.2 TCP/IP协议：解释TCP/IP协议的基本原理，包括IP地址、端口号和数据传输过程等。

3.3 HTTP和HTTPS：详细讲解HTTP和HTTPS的区别、工作原理和应用场景。

3.4 DNS：介绍DNS的作用和解析过程，包括域名解析和递归查询等。

3.5 网络安全：讲解网络安全的基本概念、攻击方式和防范措施，如DDoS攻击和防火墙等。

4. 数据库4.1 关系型数据库：介绍关系型数据库的特点和常见的SQL语句，如查询、插入和更新等。

4.2 非关系型数据库：解释非关系型数据库的优点和应用场景，如键值存储和文档存储等。

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统探秘之进程与线程的原理和调度

进程进程的概念进程的状态进程的控制结构进程的控制进程的上下文切换线程为什么要使用线程？线程与进程的比较线程的上下文切换线程的实现调度调度时机调度原则调度算法进程进程的概念进程就是具有独立功能的程序关于某一数据集合的一次运行活动。

就如我下面的截图，比如WeChat（微信桌面版），这其实就是针对具体功能的运行活动称为进程，但是可以看到进程内还有很多细项在运行，所以也可以称这是一个WeChat的进程树。

进程的状态大家都知道CPU运算是非常快的，但是程序呢不一定都是一泻千里一口气运行到底的，就像我拿个热水壶烧水一样，我已经执行完“接水”==》放热水壶==》插电==》摁开关，但是烧水是需要时间的，我不能在这呆呆的等着，我还可以干点别的，一直到热水壶发出声音提醒我，我去“倒开水”这才完成。

那么我烧水这一连串的动作就可以看作一个进程，那么在这个过程中，就有个“运行”==》“暂停”==》“运行”这样的一种情况。

这种“间断”的特性，也就决定了进程有的三种基本状态：•就绪–进程准备好了除CPU之外的所有资源，就等CPU执行了。

•运行–CPU正在执行当前进程。

•阻塞–进程需要达到某种条件才可以继续执行，在条件满足之前即使得到了CPU资源也无法执行下去。

从头开始到结束呢就还有两个状态•新建–从一无所有创建一个进程，进入就绪状态。

•结束–进程活动完成（正常结束、异常结束）。

另外还有就是常说的挂起状态：进程不再占用内存空间了•就绪挂起–进程在硬盘上，除了CPU之外的资源准备好了，只要加载进内存立马进入就绪状态。

•阻塞挂起–进程在硬盘上，需要满足某种条件，满足条件后被加载进内存进入就绪状态，没有满足条件被加载进内存则进入阻塞状态。

进程的控制结构上面提到进程有这么些状态，那又是怎么控制的呢？在操作系统中，是用进程控制块（process control block，PCB）数据结构来描述进程的。

系统用PCB来记录进程的外部特征，描述进程的运动变化，是感知进程存在的唯一标志。

操作系统读书笔记

读书笔记——《操作系统》《操作系统》目录1 操作系统发展史2 进程和线程3 内存管理4 文件系统(Linux)5 设备管理1 操作系统发展史1.1引言操作系统诞生距今已经有了几十年的时间，它是计算机资源的管理者。

最初的人们是没有操作系统来对计算机加以控制的，一直都处于人工管理方式来对计算机进行操作和管理，人机交互之间出现了人工手动的低速和计算机的高速处理形成了尖锐的矛盾，资源利用率非常的低，从而导致计算机的效率十分低下。

为了解决人工干预和CPU速度不匹配的矛盾，提高计算机的使用效率，后来出现了世界上第一个的操作系统——脱机输入/输出，用户先将卡片输入到纸带机，然后通过卫星机的处理，将纸带的数据高速写入磁带，主机运行时再将磁带上的数据高速读入内存，输出也可以这样中转，由于数据的读取和写入是脱离主机运行的，所以这样的处理方式称为脱机输入/输出方式。

虽然脱机输入输出方式进一步提高了计算机的运行效率，但是在计算机工作过程中还是需要人工进行干预，后来就出现了批处理系统。

在批处理系统中，操作员将一批作业输入进磁带中，然后运行第一个程序，当第一个作业完成后自动读入下一个作业，直至所有作业全部完成。

由于该类系统的内存中只能保持一个作业运行，所以这类系统又称为单通道批处理系统。

到了20世纪60年代出现了多道批处理系统能够做到计算机内存中的作业并发执行。

直到后来出现的分时操作系统能够让多个用户共同使用一个操作系统可以随时和计算机进行交互，并且让各个用户都感受不到其他用户的存在。

随着计算机技术的发展，越来越多的用户希望操作系统能够实时地对用户进行反馈，在1980年，为了让计算机能够实时地反馈，后来又出现了实时操作系统，对冶炼、发电、炼油、化工、机械加工等的自动控制起到了重要作用。

1.2 无操作系统1)手工特点：（1）用户独占全机（2）CPU等待人工操作问题：（1）计算机处理能力低（2）计算机工作效率低2)脱机输入/输出方式特点：数据的输入输出是在脱离主机的控制下完成的，通常是在外围机的控制下完成的优点：（1）减少了CPU的空闲时间，缓和了人机矛盾（2）提高了I/O速度1.3 单道批处理系统特点：利用磁带将若干个作业分类编成作业执行序列，每个批作业由一个专门的监督程序自动依次处理。

大一计算机基础知识点笔记

大一计算机基础知识点笔记在大一学习计算机相关专业时，我们首先要掌握的是一些基础知识点。

这些知识点不仅可以帮助我们理解计算机科学的基本概念，还能为我们今后的学习奠定坚实的基础。

一、计算机硬件1. 中央处理器（CPU）：CPU是计算机的核心部件，负责执行指令、进行算术和逻辑运算。

了解CPU的基本结构和工作原理对于理解计算机的运作方式非常重要。

2. 内存（RAM）：内存是存储数据和指令的地方，CPU可以直接访问内存中的数据。

掌握内存的类型、容量以及数据存储的方式可以帮助我们优化程序的性能。

3. 磁盘存储：硬盘和固态硬盘是常见的磁盘存储介质。

了解磁盘的工作原理以及常见的文件系统对于数据管理和存储非常重要。

4. 输入输出设备：键盘、鼠标、显示器、打印机等是我们与计算机交互的主要方式。

了解这些设备的原理和工作方式有助于我们解决常见的硬件问题和提高用户体验。

二、操作系统1. 操作系统的作用：操作系统是计算机系统的核心软件，负责管理硬件资源、提供用户界面以及执行和管理应用程序。

了解操作系统的作用和基本功能是学习计算机系统的重要一步。

2. 进程与线程：进程是正在执行中的程序的实例，而线程是进程的一部分，用于执行程序的指令。

深入了解进程与线程的概念和调度机制有助于我们编写高效的并发程序。

3. 文件系统：文件系统是操作系统用于组织和管理存储设备上的文件和目录的方式。

掌握文件系统的组织结构、文件访问权限和文件操作方式是保证数据安全和高效存取的基础。

三、编程语言与算法1. 编程语言的选择：了解不同编程语言的特性和适用场景有助于我们选择合适的编程语言进行开发。

常见的编程语言包括C、C++、Java、Python等。

2. 数据结构与算法：数据结构是存储和组织数据的方式，算法是解决问题的步骤和方法。

理解常用的数据结构和算法能够提高我们解决问题的效率和质量。

3. 编程范式：面向对象编程（OOP）、函数式编程（FP）和面向过程编程（PP）是常见的编程范式。

大一计算机笔记知识点

大一计算机笔记知识点一、计算机硬件基础1. 计算机的组成部分- 中央处理器（CPU）- 内存（RAM）- 存储设备（硬盘、固态硬盘）- 输入设备（键盘、鼠标）- 输出设备（显示器、打印机）2. CPU的工作原理- 取指令- 执行指令- 存储数据3. 存储单位及其换算关系- 字节、千字节、兆字节、吉字节、太字节4. 二进制与十进制转换- 二进制转十进制- 十进制转二进制5. 内存的层次结构- 寄存器- 缓存- 主存储器6. 输入输出设备的原理和分类 - 输入设备- 键盘- 鼠标- 扫描仪- 输出设备- 显示器- 打印机- 音响二、计算机网络1. 网络的分类- 局域网（LAN）- 广域网（WAN）- 互联网（Internet）2. 网络的拓扑结构- 总线型- 星型- 环形3. IP地址与子网掩码- IP地址的分类（A类、B类、C类） - 子网掩码的作用及计算方法4. 网络协议- TCP/IP协议- HTTP协议- FTP协议5. 网络安全与常见威胁 - 防火墙- 病毒- 黑客攻击三、数据结构与算法1. 算法的基本概念- 输入- 输出- 有穷性- 确定性2. 常见数据结构 - 数组- 链表- 栈- 队列- 树- 图3. 排序算法- 冒泡排序- 插入排序- 选择排序- 快速排序4. 查找算法- 二分查找- 哈希查找四、编程语言基础1. 编程语言的分类- 低级语言（机器语言、汇编语言） - 高级语言（C、C++、Python、Java）2. 变量和数据类型- 整数- 浮点数- 字符串- 布尔值3. 运算符和表达式- 算术运算符- 关系运算符- 逻辑运算符4. 控制流程- 条件语句（if-else语句、switch语句） - 循环语句（for循环、while循环）5. 函数和模块- 定义函数- 调用函数- 模块的引入五、数据库基础1. 数据库的概念和分类- 关系型数据库（MySQL、Oracle）- 非关系型数据库（MongoDB、Redis）2. SQL语言基础- 数据库的创建和删除 - 表的创建和修改- 数据的增删改查3. 数据库索引和优化- 索引的作用和种类- SQL语句的优化4. 事务和并发控制- 事务的特性和隔离级别 - 并发控制的方法六、操作系统基础1. 操作系统的作用和分类 - Windows操作系统- Linux操作系统2. 进程和线程- 进程的概念和状态- 线程的概念和多线程编程3. 内存管理- 虚拟内存- 内存分页4. 文件系统- 文件的操作和权限- 文件系统的组织结构以上是大一计算机笔记的知识点总结，希望对你的学习有所帮助。

c++11线程池学习笔记（一）任务队列

c++11线程池学习笔记（⼀）任务队列学习内容来⾃⼀下地址主要使⽤c++11的多线程编程的互斥同步等功能编写⼀个⽣产消费者队列⽤于任务的传递将任务的接受处理进⾏分离更加简洁易于处理和扩展修改template<typename T> //队列传递的元素为了适配更多情况这⾥使⽤了模板class SyncQueue {...................}//初始化函数定义队列最⼤可容纳元素数⽬和停⽌表⽰SyncQueue(int maxSize):m_maxSize(maxSize),m_needStop(false){}//Put函数即是提价元素之所以使⽤两种函数是考虑左值和右值提⾼元素拷贝效率void Put(const T& x) {Add(x);}void Put(T&& x) {Add(std::forward<T>(x));}//查看Add函数template<typename F>void Add(F&& x) {std::unique_lock<std::mutex> locker(m_mutex); //加锁m_notFull.wait(locker, [this] {return m_needStop || NotFull(); }); // 使条件变量等待队列未满或者标记停⽌标识if (m_needStop) //停⽌退出return;m_queue.push_back(std::forward<F>(x)); //则将元素添加进容器m_notEmpty.notify_one();}//加锁情况下使条件变量等待队列未满或者标记停⽌标识则将元素添加进容器或者停⽌退出//元素取出函数⼀个是取出容器内全部元素⼀个是取出单个元素void Take(std::list<T>& list)void Take(T& t)//void Take(std::list<T>& list) 取出容器内全部元素直接将容器去除并清除队列内的容器//代码⾥直接使⽤了move函数并notify Take函数中的条件变量void Take(std::list<T>& list) {std::unique_lock<std::mutex> locker(m_mutex);m_notEmpty.wait(locker, [this] {return m_needStop || NotEmpty(); });if (m_needStop)return;list = std::move(m_queue);m_notFull.notify_one();}//void Take(T& t) 加锁情况下使⽤条件变量等待停⽌标识或者容器⾮空//将容器内元素弹出并notify Add函数中的条件变量void Take(T& t) {std::unique_lock<std::mutex> locker(m_mutex);m_notEmpty.wait(locker, [this] {return m_needStop || NotEmpty(); }); if (m_needStop)return;t = m_queue.front();m_queue.pop_front();m_notFull.notify_one();}源码如下（仅仅队列代码，测试代码将同线程池⼀同测试）1#pragma once23 #include <list>4 #include <mutex>5 #include <thread>6 #include <condition_variable>7 #include <iostream>89using namespace std;1011 template<typename T>12class SyncQueue {13public:14 SyncQueue(int maxSize):m_maxSize(maxSize),m_needStop(false){}15void Put(const T& x) {16 Add(x);17 }18void Put(T&& x) {19 Add(std::forward<T>(x));20 }21void Take(std::list<T>& list) {22 std::unique_lock<std::mutex> locker(m_mutex);23 m_notEmpty.wait(locker, [this] {return m_needStop || NotEmpty(); });24if (m_needStop)25return;26 list = std::move(m_queue);27 m_notFull.notify_one();28 }2930void Take(T& t) {31 std::unique_lock<std::mutex> locker(m_mutex);32 m_notEmpty.wait(locker, [this] {return m_needStop || NotEmpty(); });33if (m_needStop)34return;35 t = m_queue.front();36 m_queue.pop_front();37 m_notFull.notify_one();38 }3940void Stop() {41 {42 std::lock_guard<std::mutex> locker(m_mutex);43 m_needStop = true;44 }45 m_notFull.notify_all();46 m_notEmpty.notify_all();47 }4849bool Empty() {50 std::lock_guard<std::mutex> locker(m_mutex);51return m_queue.empty();52 }5354bool Full() {55 std::lock_guard<std::mutex> locker(m_mutex);56return m_queue.size() == m_maxSize;57 }5859 size_t Size() {60 std::lock_guard<std::mutex> locker(m_mutex);61return m_queue.size();62 }6364int Count() {65return m_queue.size();66 }67private:68bool NotFull()const {69bool full = m_queue.size() >= m_maxSize;70if (full)71 cout << "buffer area is full,wait..." << endl;72return !full;73 }74bool NotEmpty()const {75bool empty = m_queue.empty();76if (empty)77 cout << "buffer area is empty,wait... " <<78" threadID: " << this_thread::get_id() <<endl;79return !empty;80 }8182 template<typename F>83void Add(F&& x) {84 std::unique_lock<std::mutex> locker(m_mutex);85 m_notFull.wait(locker, [this] {return m_needStop || NotFull(); }); 86if (m_needStop)87return;88 m_queue.push_back(std::forward<F>(x));89 m_notEmpty.notify_one();90 }91private:92 std::list<T> m_queue;93 std::mutex m_mutex;94 std::condition_variable m_notEmpty;95 std::condition_variable m_notFull;96int m_maxSize;97bool m_needStop;98 };View Code。

计算机二级进程知识点总结

计算机二级进程知识点总结一、进程的概念1. 进程是计算机中的基本概念之一，它是指正在运行的程序的实例。

2. 操作系统通过进程来管理和调度程序的执行，每个进程拥有独立的内存空间和执行环境。

3. 进程的主要特性包括并发性、独立性、动态性和时序性。

二、进程的属性和状态1. 进程的属性包括进程标识符（PID）、优先级、状态、父子关系等。

2. 进程的状态包括运行态、就绪态和阻塞态等。

三、进程的创建和终止1. 进程的创建可以通过fork()系统调用来实现，它会创建一个与原进程相同的新进程。

2. 进程的终止可以通过exit()系统调用来实现，它会终止当前进程的执行并返回一个状态码。

四、进程的调度1. 进程的调度是操作系统的重要功能之一，它决定了哪个进程能够获得CPU的执行权。

2. 进程调度算法包括先来先服务（FCFS）、最短作业优先（SJF）、轮转调度（RR）等。

3. 调度算法的选择取决于系统的需求和实际情况，不同的算法有不同的特点和适用范围。

五、进程的同步和通信1. 进程的同步是指协调多个进程的执行顺序和时间，避免出现竞态条件和死锁问题。

2. 进程的通信是指多个进程之间的信息交换和数据共享，可以通过信号量、消息队列、共享内存等方式实现。

六、线程的概念1. 线程是进程的一部分，它是指进程中的执行单元，可以看作是轻量级的进程。

2. 线程共享进程的地址空间和资源，多个线程之间可以实现并发执行和数据共享。

七、多线程编程1. 多线程编程是利用多个线程来完成任务，可以提高程序的并发性和性能。

2. 多线程编程需要考虑线程的创建、同步、通信和终止等问题，避免出现竞态条件和死锁。

八、进程调度算法1. 先来先服务（FCFS）算法是最简单的调度算法，按照进程到达的先后顺序进行调度。

2. 最短作业优先（SJF）算法是根据每个进程的执行时间来进行调度，执行时间最短的进程先执行。

3. 轮转调度（RR）算法是按照时间片轮转的方式进行调度，每个进程只能执行一个时间片的时间。

自考02326操作系统考点笔记

第一章OS概论Point：1.OS的基本概念和OS的地位。

2.OS的主要特征和基本功能。

3.OS的体系结构。

4.OS的发展和分类。

5.常用OS结构设计和方法。

第一节OS的概念一、计算机系统a)定义：计算机系统是一种可以按用户的要求接受和存储信息、自动进行数据处理并输出结果信息的系统。

b)分类：广义：机械式系统和电子式系统。

电子式系统：模拟式和数字式计算机系统。

c)组成：硬件（子）系统和软件（子）系统。

计算机系统的资源：硬件资源、软件资源。

在计算机系统中，集中了资源管理功能和控制程序执行功能的一种软件，称为OS。

二、OS的定义a)定义：OS是计算机系统中的一个系统软件，它是这样一些程序模块的集合：它们能有效地组织和管理计算机系统中的硬件及软件资源，合理地组织计算机工作流程，控制程序的执行，并向用户提供各种服务功能，使得用户能够灵活、方便、有效地使用计算机，并使整个计算机系统能高效地运行。

b)解析：1)组织和管理计算机系统中的硬件和软件资源。

在OS中，设计了各种表格或数据结构，将所有的软硬件资源都加以登记。

（比如:PCB、系统设备表等）2)“有效”指OS在管理计算机资源时要考虑到系统运行的效率和资源的利用率。

要尽可能提高PU的利用率，让他尽可能少的空转，应该在保持访问效能的前提下尽可能有效利用其他资源。

（比如减少内存、硬盘空间的浪费等）3)“合理”指OS要“公平”对待不同的用户程序，保证系统不发生“死锁”和“饥饿”的现象。

4)“方便”指OS的人机界面要考虑到UI和程序接口两个方面的易用性、易学性和易维护性。

（用户使用接口：命令、GUI，如windows GUI。

程序接口：向程序员提供高效的编程接口，如API、系统调用。

）三、OS的特征1.并发性：是指计算机系统中同时存在若干个运行着的程序，从宏观上看，这些程序在同时向前推进。

2.共享性：OS需与多个用户程序共用系统中的各种资源。

比如PU、内存、外存、外部设备等。

进程与线程

一：线程与进程1.概念线程：是程序执行流的最小单元，是系统独立调度和分配CPU （独立运行）的基本单位。

【操作系统技术中的术语，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是行程中的实际运作单位。

一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并行多个线程，每条线程并行执行不同的任务。

在Unix System及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程(kernel thread)，而把用户线程称为线程。

计算机科学术语，指运行中的程序的调度单位。

】主要特点【在多线程OS中，通常是在一个进程中包括多个线程，每个线程都是作为利用CPU的基本单位，是花费最小开销的实体。

线程具有以下属性。

1）轻型实体线程中的实体基本上不拥有系统资源，只是有一点必不可少的、能保证独立运行的资源，比如，在每个线程中都应具有一个用于控制线程运行的线程控制块TCB，用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。

2）独立调度和分派的基本单位。

在多线程OS中，线程是能独立运行的基本单位，因而也是独立调度和分派的基本单位。

由于线程很“轻”，故线程的切换非常迅速且开销小。

3）可并发执行。

在一个进程中的多个线程之间，可以并发执行，甚至允许在一个进程中所有线程都能并发执行；同样，不同进程中的线程也能并发执行。

4）共享进程资源。

在同一进程中的各个线程，都可以共享该进程所拥有的资源，这首先表现在：所有线程都具有相同的地址空间（进程的地址空间），这意味着，线程可以访问该地址空间的每一个虚地址；此外，还可以访问进程所拥有的已打开文件、定时器、信号量机构等。

】线程的五大状态【线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。

1.新建状态(New)：当用new操作符创建一个线程时，例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。

计算机408笔记总结

计算机408笔记总结是指对计算机专业本科阶段四门核心课程（数据结构、计算机组成原理、操作系统、计算机网络）的学习笔记进行总结。

以下是一个可能的笔记总结大纲：一、数据结构1. 基本概念：数据结构、算法、时间复杂度、空间复杂度等。

2. 线性结构：数组、链表、栈、队列、散列表等。

3. 非线性结构：树、图、堆、优先队列等。

4. 排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序等。

5. 查找算法：线性查找、二分查找、哈希查找等。

6. 文件结构：顺序文件、链式文件、索引文件等。

二、计算机组成原理1. 计算机系统结构：CPU、内存、外存、输入输出设备等。

2. 汇编语言：指令格式、寻址方式、指令系统等。

3. 控制器原理：时序控制、指令执行流程、中断处理等。

4. 存储器原理：RAM、ROM、Flash等。

5. I/O设备原理：键盘、鼠标、显示器、打印机等。

6. CPU性能分析：CPI、吞吐量、响应时间等。

三、操作系统1. 基本概念：进程、线程、死锁等。

2. 进程管理：进程创建与终止、进程调度等。

3. 内存管理：虚拟内存、页式管理、段式管理、段页式管理等。

4. 文件系统：目录结构、文件读写操作等。

5. 设备管理：设备驱动程序、设备分配与释放等。

6. 用户接口：Shell程序、命令行界面等。

四、计算机网络1. 网络体系结构：OSI模型、TCP/IP协议族等。

2. 网络协议：HTTP、FTP、SMTP等。

3. 网络设备：路由器、交换机、网桥等。

4. 网络拓扑结构：星型拓扑、树型拓扑等。

5. 网络性能分析：带宽、吞吐量、延迟等。

6. 网络应用：Web应用、电子邮件系统等。

以上仅是一个大致的总结大纲，具体内容可能会因教材和授课老师的不同而有所差异。

在学习的过程中，应该结合教材和课堂笔记进行总结，以便更好地掌握知识点和技能。

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

DAY 1进程的基本概念：1．进程与程序的区别：程序：存储在磁盘上可执行指令的集合，是一个文件。

例如：a.out文件就是一个程序。

进程：程序一次执行的过程，伴随着资源的分配和释放。

区别：<1>进程是动态的,运行在内存中，并伴随着资源的分配与释放。

<2>程序是静态的，一般存在在磁盘上，没有执行的概念。

2.进程的标示就绪态：进程所有需要的条件已经准备完成,等待CPU的调度。

运行态(R-->running)：进程占用CPU，并在CPU上运行。

可中断等待态(S)：进程正在休眠，等待某个资源来唤醒它。

也可以被其他信号中断唤醒。

不可中断等待态(D)：进程正在休眠，等待某个资源来唤醒它。

不能被其他信号中断唤醒。

停止态（T）:进程暂停接受某种处理。

例如：gdb调试断点信息处理。

僵尸态（Z）：进程以及结束但是还没有释放进程资源。

例如：PID，PPID等未释放。

+ : 表示该进程在前台运行。

例如：S+ ,R+等,没有+表示在后台运行。

各个状态之间的转换如下图:时间片：CPU分配给一个进程所运行的时候。

实现消耗完成后，进程处于等待态。

3.进程相关命令详解（1）常用：pstree -p.<2>ps(process status) 查看当前系统进程的工具a.给当前进程截取一个快照,来查看我们的PID号ps -ef | grep “进程名/进程ID”b.查看进程第一行的信息。

ps -ef | head -1c.查看当前进程的状态ps aux | grep “进程名/进程ID”<3>kill 给指定的PID进程发送信号使用方法：kill -信号的宏名 PID 或者 kill -信号的编号 PID号常用宏：宏名编号功能SIGKILL 9 杀死进程。

SIGCONT 18 让信号继续运行。

SIGSTOP 19 让信号停止。

SIGCHLD 17 子进程结束的时候，给父进程发送该信号。

<4>bg(backgroud) 将一个挂起的进程在后台的运行。

使用方法：bg job号把挂起的进程放到后台运行。

<5>fg(foreground) 将后台的进程到前台运行。

./a.out 默认是在前台运行我们的程序。

我们可以在启动的时候让我们的程序在后台运行。

./a.out & 让程序在后台运行。

这里的&符合表示把我们的程序放到后台来运行。

fg的使用方法： fg job号把后台的进程放到前台运行。

常用概念了解：（1）ctrl + z 给当前前台执行的命令放到后台，并且将进程暂停挂起。

（2）jobs 看出当前后台运行的程序，并显示其job号4. 创建子进程函数<1>创建进程[pid_t 是int类型]#include <unistd.h>pid_t fork(void)；功能:在当前进程中，创建子进程返回值：成功给父进返回子进错的pid号给子进错返回0，失败返回-1，并且置errno,注意：<1>fork 是通过对当调用fork()的进程的复制来实现对新进程的创建子进程：新创建的进程父进程：调用fork()函数的进程。

<2>子进程创建的过程：拷贝父进程的堆，栈，rodata段，data段，bss段,系统相关信息,代码段共享。

<3>fork之后父，子进程谁先执行是不确定，取决系统的调度算法<4>fork之后，父子进程都是从fork下一条语句开始执行<5>fork之后，父子进程拥有独立的4G虚拟地址空间。

互相不影响<6>fork之后，子进程会继承父进程的打开的文件描述符集合，共用相同的文件表项。

思考：我们如何根据pid来判断当前进程是父进程还是子进程呢？pid > 0 表示此时是父进程的运行空间。

pid == 0 表示此时是子进程的运行空间僵尸子进程：子进程结束的时候，父进程没有进行收尸操作(父进程还存在),此时占用资源。

孤儿进程：父进程结束了，子进程会变成孤儿进程，会自动被init进程所收养。

5. vfork函数详解<1>写时拷贝简介详见《3.写时拷贝简介》<2>vfork#include <sys/types.h>#include <unistd.h>pid_t vfork(void);功能：创建子进程参数：无返回值：成功，对父进程而言。

返回子进程的PID好。

对子进程而言。

返回0.错误，返回-1。

fork与vfork的区别：<1>fork函数父子进程谁先运行不确定，由系统调度决定。

vfork函数子进程先运行，此时父进程会阻塞，子进程会一直运行在父进程的地址空间，直到子进程调用exit结束后才会运行，如果这时子进程修改了某个变量，这将影响到父进程的变量。

<2>fork 函数的正文段共享，其他段被子进程复制。

vfork函数的子进程直接共享父进程的虚拟地址空间。

六、exec函数簇exec函数簇函数[详见4.exec函数簇详解.doc]<1>功能简介exec函数族提供了一种在进程中启动另一个程序执行的方法。

它可以根据指定的文件名或目录名找到可执行文件，并用它来取代原调用进程的数据段、代码段、和堆栈段。

在执行完之后，原调用进程的内容除了进程号外，其他全部都被替换了。

潜规则：向函数传递指针数组的时候，一般以NULL作为结束的标志。

1)l : list [给可执行文件，以列举的方式传递文件]int execl(const char *path, const char *arg1, ...);参数：@path 包含可路径的可制作文件的名字（例如：/home/ubuntu/hello）@arg1 可执行程序的名字(hello)@arg2 可执行程序的参数等等(可省略) ....@参数最后一定要以NULL结尾。

返回值：成功返回0，失败返回-1例如：执行ls命令execl("/bin/ls","ls","-l"，NULL)；环境变量：操作系统提高的全局变量。

2)p : PATH [在PATH环境变量中搜索，在任何一个地方都可以找到PATH环境变量中的内容]int execlp(const char *path, const char *arg1, ...);int execlp(可执行文件名，可执行文件名，参数1，参数2,..,NULL);例如：“ls -l”execlp("ls","ls","-l",NULL);3)e :environment (环境变量) 可以给新运行的程序传递一个环境变量。

如果新程序需要环境变量，可以通过envp参数传递环境变量如果不需要，传NULLint execle(const char *path, const char *arg,..., char * const envp[]);参数：参数：@path 包含可路径的可制作文件的名字（例如：/home/ubuntu/hello）@arg1 可执行程序的名字(hello)arg2 ......参数最后一定要以NULL结尾。

@可以给新运行的程序传递一个环境变量. 如果新程序需要环境变量，可以通过envp参数传递环境变量如果不需要，传NULL例如：execle("/bin/ls","ls","-a",NULL,NULL)；============================================================= ===========int execv(const char *path, char *const argv[]);int execvp(const char *file, char *const argv[]);int execve(const char *file, char *const argv[],char *const envp[]);v：vector : 向量组织成一个数组。

例如：execl("/bin/ls","ls","-l",NULL);execlp("ls","ls","-l",NULL);execle("ls","ls","-l",NULL,NULL);------------------------------------------------------------------char *args[] = {"ls","-l",NULL};execv("/bin/ls",args);execvp("ls",args); //把路径添加到path环境变量中。

execve("ls",args,NULL);七、常用退出函数简介<1>return 结束一个函数的执行。

（当前程序不一定结束。

）<2>void exit(int status)[库函数]功能：结束一个进程。

结束之前会刷新缓冲区。

参数：@status 进程状态的标志。

0表示正常结束，其他表示异常结束。

<3>void _exitvoid exit(int status) [系统调用]功能：结束一个进程。

结束之前不会刷新缓冲区。