通过将磁盘空间用作临时的扩展内存来扩大实际内存的容量。每个程序都拥有自己的虚拟地址空间，而不需要关心实际物理内存的分配和管理。

更大的地址空间：虚拟内存可以使得每个程序拥有更大的地址空间，使得程序能够处理比实际物理内存更大的数据集。

隔离和保护：每个程序拥有自己的虚拟地址空间，这样可以有效地隔离和保护各个程序的内存空间，提高系统的安全性和稳定性。

简化内存管理：虚拟内存由操作系统负责管理，程序员无需手动管理内存，简化了内存管理的复杂度。

允许共享内存：虚拟内存使得多个程序可以共享同一个物理内存页面，从而节约内存的使用。

更好的内存管理：虚拟内存可以提供更灵活的内存分配和回收机制，能够更好地满足程序对内存的需求。

僵尸进程是指在一个进程终止后，其父进程没有及时处理该子进程的终止状态信息（称为退出状态），导致子进程的进程描述符依然存在，但是实际上已经结束了。

父进程未及时处理：当一个子进程完成任务后，如果其父进程没有显式地调用类似 wait() 或 waitpid() 的系统调用来获取子进程的退出状态信息，那么子进程就会成为僵尸进程。

父进程意外终止：如果父进程意外终止，而没有释放子进程的资源或者获取子进程的状态信息，那么子进程也有可能成为僵尸进程。

确定线程池的参数： 首先确定线程池的基本参数，包括核心线程数、最大线程数、工作队列类型、任务超时设置等。

创建工作队列： 根据需要选择合适的工作队列，例如有界队列（如 ArrayBlockingQueue）或无界队列（如 LinkedBlockingQueue），用于存储待执行的任务。

创建线程池管理器： 创建一个线程池管理器的类，在该类中初始化线程池，并提供提交任务、关闭线程池等方法。

LRU（Least Recently Used）是虚拟内存的一直页面置换算法。是一种缓存淘汰策略，根据最近使用的时间来淘汰缓存中最近最少使用的数据。

以下是一种基于哈希表和双向链表实现LRU缓存的思路：使用哈希表存储(key, value)键值对，以支持快速的查找操作。使用双向链表维护缓存中的数据顺序，链表头部表示最近访问的数据，链表尾部表示最久未被访问的数据。

如果此数据之前已经被缓存在链表中了，我们遍历得到这个数据对应的结点，并将其从原来的位置删除，然后再插入到链表的头部。

如果此数据没有在缓存链表中，又可以分为两种情况：如果此时缓存未满，则将此结点直接插入到链表的头部；如果此时缓存已满，则链表尾结点删除，将新的数据结点插入链表的头部。

class DLinkedNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None
class LRUCache:
    def __init__(self, capacity: int):
        self.cache = {}
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head
        self.capacity = capacity
        self.size = 0
    def _add_node(self, node):
        # 添加节点到头部
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node
    def _remove_node(self, node):
        # 从链表中移除节点
        prev = node.prev
        new = node.next
        prev.next = new
        new.prev = prev
    def _move_to_head(self, node):
        # 移动节点到头部
        self._remove_node(node)
        self._add_node(node)
    def _pop_tail(self):
        # 弹出尾部节点
        res = self.tail.prev
        self._remove_node(res)
        return res
    def get(self, key: int) -> int:
        # 获取节点的值并将其移到头部
        node = self.cache.get(key, None)
        if not node:
            return -1
        self._move_to_head(node)
        return node.value
    def put(self, key: int, value: int) -> None:
        # 若key存在，则更新value，并移到头部；若key不存在，插入新节点到头部
        node = self.cache.get(key)
        if not node:
            newNode = DLinkedNode(key, value)
            self.cache[key] = newNode
            self._add_node(newNode)
            self.size += 1
            if self.size > self.capacity:
                tail = self._pop_tail()
                del self.cache[tail.key]
                self.size -= 1
        else:
            node.value = value
            self._move_to_head(node)
    

在多线程环境下，当多个线程竞争同一个锁时，可能会出现锁的升级过程。锁的升级是指从低级别的锁升级为高级别的锁，这个过程通常是为了提高并发性能。

1. 偏向锁：初始状态下，锁处于偏向锁状态，即被第一个获取锁的线程所偏向。如果有其他线程尝试获取该锁，会触发偏向锁撤销，将锁升级到轻量级锁。
2. 轻量级锁：当多个线程竞争同一个锁时，偏向锁会升级到轻量级锁。此时，各个线程会通过自旋操作来尝试获取锁，避免进入操作系统的阻塞状态。如果自旋操作仍然无法获取到锁，则锁会升级到重量级锁。
3. 重量级锁：如果自旋操作不断尝试后仍未获取到锁，锁会最终升级为重量级锁。这时候线程会进入阻塞状态，等待操作系统的调度来解除阻塞并获取锁。

I/O多路复用是一种通过单一线程处理多个I/O操作的机制。它允许一个程序可以同时监听多个文件描述符（sockets、pipes等）上的I/O事件，当其中任何一个文件描述符准备好进行I/O操作时，就通知程序进行相应的读取或写入操作。

常见的I/O多路复用技术包括select、poll和epoll等，在不同的操作系统上有不同的实现方式。

通过I/O多路复用，程序可以避免使用多线程或多进程来同时监听多个I/O事件，从而降低了系统资源的开销，并提高了程序的并发性能。这种机制在网络编程中特别有用，因为一个服务器经常需要同时处理多个客户端的连接请求，以及读写操作。

总之，I/O多路复用允许一个程序可以高效地管理多个I/O事件，提高了程序对并发请求的处理效率，是提升系统性能的重要技术之一。

前台进程、后台进程、守护进程、孤儿进程、僵尸进程

I/O阻塞：当进程需要进行I/O操作（如读取文件、从网络接收数据等）时，如果所需的I/O资源尚未就绪，进程将被阻塞，直到I/O操作完成或者数据可用。

同步阻塞：当进程等待某个条件的满足时，如果条件尚未满足，则进程会被阻塞。例如，一个进程请求获取一个信号量，但是当前信号量的值不满足进程的请求，这时候进程就会被阻塞。

计算阻塞：在进行复杂的计算任务时，如果任务执行时间较长，会导致进程在执行过程中处于阻塞状态，无法执行其他操作。

管道阻塞：当使用管道进行进程间通信时，如果管道已满（写端写入速度快于读端读取速度），写入端的进程将被阻塞。

• 阻塞 I/O：当应用程序发起一个I/O操作后，如果操作没有完成，程序将会被阻塞，直到I/O操作完成。在此期间，程序无法执行其他任务。
• 非阻塞 I/O：应用程序通过设置为非阻塞模式后，可以立即返回，而不必等待I/O操作完成。如果I/O操作尚未完成，则程序可以执行其他任务。但是，非阻塞I/O需要持续轮询状态以检查I/O是否完成，这可能会导致CPU资源浪费。
• I/O 多路复用：通过使用select、poll、epoll等机制，一个线程可以同时监视多个文件描述符（sockets、pipes等）上的I/O事件。当其中任何一个文件描述符准备好进行I/O操作时，通知程序进行相应的读取或写入操作，从而避免了持续轮询状态的缺点。
• 信号驱动 I/O：应用程序在发起一个I/O操作后，可以继续执行其他任务。当I/O操作完成时，内核发送一个信号通知应用程序完成了I/O操作。
• 异步 I/O：应用程序发起一个I/O操作后，可以继续执行其他任务，当I/O操作完成时，应用程序会得到通知，这种模型需要操作系统和硬件的支持。

• 阻塞 I/O：Python 中的常规 I/O 操作（如文件读写、套接字通信）默认是阻塞的。当调用类似 file.read() 或 socket.recv() 的方法时，程序将会等待 I/O 完成后再继续执行。
• 非阻塞 I/O：可以通过设置文件描述符或套接字为非阻塞模式来实现非阻塞 I/O。例如，使用 fcntl 模块或 setblocking() 方法将文件描述符设置为非阻塞模式。
• I/O 多路复用：Python 提供了 select、selectors 模块以及第三方库 gevent、eventlet 来实现 I/O 多路复用。这些工具允许程序同时监听多个文件描述符上的 I/O 事件，并在有事件发生时进行处理。
• 信号驱动 I/O：在 Python 中，可以使用 signal 模块来处理信号。然而，Python 并没有直接提供信号驱动 I/O 的功能，因此需要结合其他机制来实现。
• 异步 I/O：Python 3.4 引入了 asyncio 标准库，它提供了对异步 I/O 的完整支持。使用 async 和 await 关键字，可以编写基于协程的异步 I/O 代码。此外，还有一些第三方库（如 Tornado、Twisted 等）也提供了异步 I/O 支持。

在计算机系统中，用户态和内核态是操作系统管理和控制硬件资源的两种不同特权级别。

用户态：在用户态下运行的程序或进程只能访问有限的系统资源，并且无法直接操作系统底层的硬件设备。

内核态：内核态是操作系统的特权模式，具有对全部系统资源和硬件设备的完全访问权限。

用户态和内核态之间的转换是通过系统调用和异常中断来实现的。

系统调用：当运行在用户态下的程序需要访问操作系统提供的特权指令或资源时，它会通过系统调用向操作系统发起请求。系统调用是一种特殊的函数调用，它将控制权从用户态切换到内核态，使得操作系统可以代表应用程序执行需要特权级别的操作。通常，系统调用的触发是通过调用类似于 int 0x80 或 syscall 指令。

异常/中断处理：在硬件层面，当发生诸如缺页错误、除零错误、时钟中断等异常或中断事件时，CPU 会自动切换到内核态，并跳转到相应的异常处理程序或中断服务例程。这样，操作系统在内核态下可以对异常或中断进行处理。

无论是通过系统调用还是异常/中断处理，从用户态切换到内核态都需要经过以下步骤：

• 保存当前用户态的上下文信息（如寄存器状态、栈指针等
• 将 CPU 的特权级别设置为内核态
• 跳转到操作系统内核的特定入口点（如系统调用处理程序或异常处理程序）
• 在内核态下执行相关操作；
• 最后返回用户态时，恢复之前保存的用户态上下文信息，将 CPU 的特权级别设置回用户态。

线程安全（Thread Safety）指的是当多个线程同时访问某个对象或变量时，不会出现意外的、不可预知的结果。具体来说，线程安全通常包括以下两个方面：

• 原子性：要么一个操作完全执行并且对其他线程隐藏这个操作，要么就不执行这个操作。在并发环境中，如果一个操作是不可分割的，那它就是原子的。
• 可见性：当一个线程修改了共享变量的值时，其他线程能够立即看到这个改动。

使用同步机制（如锁、信号量等）来控制对共享资源的访问，确保在同一时间只有一个线程可以访问共享资源。

使用原子操作或原子数据类型，确保针对共享资源的操作是不可分割的，从而避免竞态条件的发生。

使用线程安全的数据结构，如线程安全的队列、Map等，以减少需要手动处理同步的工作。

饥饿进程是指在多任务系统中，由于资源分配不合理或调度算法不公平，导致某些进程长时间无法获得所需的资源而无法执行的情况。具体来说，饥饿进程通常表现为以下几个特征：长时间等待资源：某些进程长时间无法获得所需的 CPU 时间、内存、I/O 资源等，处于等待状态。优先级逆置：高优先级的进程总是能够获得资源，而低优先级的进程却长时间无法获得资源，这种情况称为优先级逆置。持续性问题：饥饿进程所面临的问题通常是持续性的，而不是偶发性的。

造成饥饿进程的原因可能包括不公平的调度算法、资源分配策略不当、进程优先级设置不合理等。

使用公平的调度算法，确保每个进程都有机会获得CPU时间和其他所需资源。例如，在操作系统的进程调度中，可以使用轮转调度算法（Round-Robin Scheduling）或者基于优先级的调度算法来避免某些进程长时间占用资源。

匿名管道（pipe）、具名管道（FIFO）、POSIX消息队列、共享内存、信号、Sockets

互斥锁、条件变量、信号量、事件等待

多线程编程对共享资源进行并发访问，需要加锁。死锁就是线程陷入僵局状态，一直等待资源被释放。

为避免死锁的发生，可以采取一些措施，如尽量减少互斥资源的使用时间、按序申请资源、破坏循环等待条件等。在实际编程和系统设计中，需要谨慎考虑资源的分配和进程间的同步，以避免死锁的发生。

进程共享变量就是可以使用共享内存。线程本就是共享整个地址空间的，要对共享变量加锁。

# 伪代码示例，可能导致死锁
lock1 = Lock()
lock2 = Lock()
def function1():
    lock1.acquire()
    # 假设这里需要访问共享资源 A
    lock2.acquire()  # 尝试获取另一个锁
    # 进行一些操作
    lock2.release()
    lock1.release()
def function2():
    lock2.acquire()
    # 假设这里需要访问共享资源 B
    lock1.acquire()  # 尝试获取另一个锁
    # 进行一些操作
    lock1.release()
    lock2.release()
# 创建两个线程分别调用 function1 和 function2
thread1 = Thread(target=function1)
thread2 = Thread(target=function2)
# 启动线程
thread1.start()
thread2.start()
# 等待两个线程结束
thread1.join()
thread2.join()
    

上面的示例展示了两个线程分别尝试获取两个不同的锁，但是由于获取锁的顺序不同，可能会导致死锁的发生。在实际编程中，需要避免出现这样的情况，例如通过统一获取锁的顺序、避免嵌套锁等方式来预防死锁的发生。

协程是轻量级线程,全部都在用户态,因此系统消耗资源非常低,协程没有了线程切换的开销，非常高效。不像线程一样是内核线程,由cpu调度,造成上下文切换,浪费资源。协程的效率比较高。

线程实现数据共享的方式是共享内存,需要加锁，避免线程安全问题。而协程是单一个线程,不会有线程安全问题,不需要加锁，避免了锁竞争。

协程更加轻量，一个线程栈可能要1M左右，创建一个协程可能只要几K或者几十K。

协程不好控制

跳表（Skip List）是一种数据结构，它通过在有序链表的基础上增加多层索引来实现快速的查找。以下是跳表的简单实现思路：

• 节点结构：跳表由一个或多个层级组成，每个节点包含一个值和多个指向下一个节点的指针数组。最底层的节点形成一个普通的有序链表。
• 插入操作：为了插入一个新元素，首先从顶层开始，按照链表中的顺序找到合适的位置，并且在插入的同时决定是否要将这个元素“升级”到更高层的索引中。这种“升级”的概率是可以调控的，一般通过随机算法来决定节点是否会升级到更高的索引层。
• 删除操作：删除操作需要在所有层级上进行更新，以保证数据结构的完整性。
• 查找操作：从最顶层的节点开始，根据索引逐层向下查找目标元素，直到找到目标元素或者确定它不存在为止。

跳表的实现相对较为复杂，需要处理节点之间的关系、节点的插入、删除、查找等操作，并且需要考虑索引的更新策略。通过合理的索引设计，跳表可以达到与平衡二叉树类似的时间复杂度，具有较好的查找性能。