接下来讲解一下用`unshare`和`clone`来创建NetWor kNameSpace,先讲解一下这两个API:

***unshare***
`unshare`用于将当前进程分离（unshare）出指定的命名空间（namespace）。它允许进程创建独立于父进程的命名空间，从而实现进程在不同命名空间中运行的隔离。



```c

#include <sched.h>

int unshare(int flags);
```

- `flags`：指定要分离的命名空间类型，可以使用以下标志的按位或运算进行组合：
  - `CLONE_NEWNS`：分离挂载命名空间（Mount Namespace）。
  - `CLONE_NEWUTS`：分离UTS命名空间。
  - `CLONE_NEWIPC`：分离IPC命名空间。
  - `CLONE_NEWPID`：分离PID命名空间。
  - `CLONE_NEWNET`：分离网络命名空间。
  - `CLONE_NEWUSER`：分离用户命名空间。
  - `CLONE_NEWCGROUP`：分离控制组命名空间。
  - `CLONE_NEWTIME`：分离时间命名空间（自Linux 5.6起可用）。

成功调用`unshare`函数会将当前进程分离出指定的命名空间，并创建一个新的独立命名空间。在新的命名空间中，进程可以执行与父进程隔离的操作，例如挂载文件系统、更改主机名、配置网络接口等。

`unshare`函数只分离命名空间，具体的命名空间配置需要在调用`unshare`之后进行，例如使用`mount`函数挂载文件系统、`sethostname`函数设置主机名等。

***clone***

`clone`用于创建一个新的进程，并可以选择性地与父进程共享或分离多个资源，包括进程空间、文件系统、信号处理等。



```c

#include <sched.h>

int clone(int (*fn)(void *), void *child_stack, int flags, void *arg, ...);
```

- `fn`：指向子进程要执行的函数的指针。该函数应该具有 `int` 类型的返回值，接受一个 `void*` 类型的参数。
- `child_stack`：指向子进程栈的指针。子进程会在一个新的栈空间中执行，`child_stack` 指向该栈的顶部。栈应该是独立分配的，并且具有足够的空间来容纳子进程执行所需的栈帧。
- `flags`：用于指定创建子进程时的行为和资源共享方式的标志位，可以使用以下标志的按位或运算进行组合：
  - `CLONE_CHILD_CLEARTID`：子进程在调用`exec`函数或退出时，会将`tid`置为0。
  - `CLONE_CHILD_SETTID`：子进程在调用`exec`函数或退出时，会将`tid`置为子进程ID。
  - `CLONE_FILES`：子进程与父进程共享文件描述符表。
  - `CLONE_FS`：子进程与父进程共享文件系统信息。
  - `CLONE_IO`：子进程与父进程共享I/O上下文。
  - `CLONE_NEWIPC`：子进程创建一个新的IPC命名空间。
  - `CLONE_NEWNET`：子进程创建一个新的网络命名空间。
  - `CLONE_NEWNS`：子进程创建一个新的挂载命名空间。
  - `CLONE_NEWPID`：子进程创建一个新的PID命名空间。
  - `CLONE_NEWUTS`：子进程创建一个新的UTS命名空间。
  - `CLONE_NEWUSER`：子进程创建一个新的用户命名空间。
  - `CLONE_NEWCGROUP`：子进程创建一个新的控制组命名空间。
  - `CLONE_PARENT`：子进程的父进程为调用`clone`的进程。
  - `CLONE_PARENT_SETTID`：子进程的父进程ID会存储在`ptid`中。
  - `CLONE_PTRACE`：子进程与父进程共享`ptrace`。
  - `CLONE_SETTLS`：子进程的线程局部存储与父进程相同。
  - `CLONE_SIGHAND`：子进程与父进程共享信号处理程序。
  - `CLONE_SYSVSEM`：子进程与父进程共享System V信号量。
  - `CLONE_THREAD`：子进程创建为与父进程共享线程组的线程。
  - `CLONE_UNTRACED`：子进程创建后不会受到`ptrace`跟踪。
  - `CLONE_VFORK`：子进程使用父进程的页表直到调用`exec`或者调用`_exit`退出。
  - `CLONE_VM`：子进程与父进程共享内存空间。
- `arg`：传递给子进程函数的参数。


`clone` 函数创建一个新的进程，并在子进程中执行指定的函数。子进程的执行流程会从 `fn` 指向的函数开始。`child_stack` 参数指定子进程的栈空间，`flags` 参数用于指定资源的共享方式。子进程创建成功后，`clone` 函数会返回子进程的进程ID。

接下来是调用示例:

```c
#define _GNU_SOURCE
#include <stdio.h>
#include <sched.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define STACK_SIZE 65536

static int child_func(void *arg) {
    // 在子进程中，进行需要在独立网络命名空间中运行的操作
    printf("Child process: PID=%ld\n", (long) getpid());

    // 在子进程中，可以进行网络相关的操作，例如配置网络接口、设置IP地址等

    sleep(10); // 模拟子进程在网络命名空间中的操作

    printf("Child process: Exiting\n");
    return 0;
}

int main() {
    printf("Parent process: PID=%ld\n", (long) getpid());

    // 为子进程分配栈空间
    char *stack = malloc(STACK_SIZE);
    if (stack == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }

    // 使用clone创建子进程，并指定CLONE_NEWNET标志来创建独立网络命名空间
    pid_t child_pid = clone(child_func, stack + STACK_SIZE, CLONE_NEWNET | SIGCHLD, NULL);
    if (child_pid == -1) {
        perror("clone");
        exit(EXIT_FAILURE);
    }

    // 在父进程中，可以继续进行其他操作

    sleep(5); // 模拟父进程的操作

    printf("Parent process: Waiting for child process to exit...\n");
    waitpid(child_pid, NULL, 0); // 等待子进程退出

    printf("Parent process: Exiting\n");
    return 0;
}
```

```c
#define _GNU_SOURCE
#include <stdio.h>
#include <sched.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    printf("Parent process: PID=%ld\n", (long) getpid());

    printf("Parent process: Creating a new network namespace...\n");

    // 创建独立的网络命名空间
    if (unshare(CLONE_NEWNET) == -1) {
        perror("unshare");
        exit(EXIT_FAILURE);
    }

    printf("Parent process: In the new network namespace\n");

    // 在新的网络命名空间中，可以进行网络相关的操作，例如配置网络接口、设置IP地址等

    sleep(10); // 模拟在网络命名空间中的操作

    printf("Parent process: Exiting\n");
    return 0;
}
```


以上程序经过运行测试，必须要用root权限才能创建`namespace`。

关于namespace系统调用

在数据库系统中，latch（也称为轻量级锁）和lock（也称为重量级锁）是两种并发控制机制。



1. Latch（轻量级锁）：
   - Latch是一种低级别的并发控制机制，通常用于保护数据结构的一致性。它是一种自旋锁，使用忙等待的方式来实现。
   - Latch是一种短暂的锁，它的获取和释放操作不涉及上下文切换，因此开销较小。
   - Latch的目的是提供一种临时的互斥机制，以避免竞争条件和数据不一致问题。
   - Latch通常用于保护内存数据结构，如缓冲池中的页、索引树节点等。

2. Lock（重量级锁）：
   - Lock是一种高级别的并发控制机制，通常用于保护数据库中的表、行、事务等。
   - Lock是一种长时间的锁，它的获取和释放操作涉及到上下文切换，因此开销较大。
   - Lock通常用于实现事务的隔离性，保证并发事务之间的互斥和一致性。
   - Lock通常支持多种模式，如共享锁（允许多个事务同时读取数据）和排他锁（只允许一个事务修改数据）。

区别：
- Latch是一种轻量级的自旋锁，适用于保护内存数据结构的一致性，开销较小。而Lock是一种重量级的锁，适用于保护数据库中的表、行、事务等，开销较大。
- Latch的获取和释放操作不涉及上下文切换，而Lock的获取和释放操作涉及到上下文切换。
- Latch通常用于短暂的互斥操作，Lock通常用于长时间的事务隔离。

lock和latch

LRU（Least Recently Used）算法是一种常用的缓存淘汰算法，用于确定在缓存中删除哪个元素。LRU算法的基本思想是，当缓存已满时，优先删除最近最少使用的元素。

LRU算法的具体实现方式可以使用哈希表和双向链表结合的数据结构来实现。哈希表用于快速查找元素，双向链表用于记录元素的访问顺序。



当元素被访问时，如果元素已经在缓存中，则将该元素移到链表的头部，表示该元素是最近使用的。如果元素不在缓存中，则将元素加入到缓存中，并将其放置在链表的头部。如果缓存已满，则删除链表尾部的元素，同时从哈希表中删除该元素的索引。

LRU算法的优点是可以很好地利用局部性原理，即最近被访问的元素可能在将来被再次访问。因此，LRU算法通常能够提供较好的缓存命中率。

LRU算法步骤如下：
1. 当访问一个元素时，如果该元素已经在缓存中，则将其移到链表的头部。
2. 如果该元素不在缓存中，将其加入缓存，并将其放置在链表的头部。
3. 如果缓存已满，删除链表尾部的元素，并从哈希表中删除该元素的索引。

基于双向链表和哈希表的简单实现
```cpp
#include <iostream>
#include <unordered_map>
using namespace std;

struct Node {
    int key;
    int value;
    Node* prev;
    Node* next;
    
    Node(int k, int v) : key(k), value(v), prev(NULL), next(NULL) {}
};

class LRUCache {
private:
    unordered_map<int, Node*> cache;
    Node* head;
    Node* tail;
    int capacity;
    int size;
    
public:
    LRUCache(int cap) : capacity(cap), size(0) {
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head->next = tail;
        tail->prev = head;
    }
    
    ~LRUCache() {
        while (head) {
            Node* temp = head;
            head = head->next;
            delete temp;
        }
    }
    
    void removeNode(Node* node) {
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }
    
    void addToHead(Node* node) {
        node->prev = head;
        node->next = head->next;
        head->next->prev = node;
        head->next = node;
    }
    
    void moveToHead(Node* node) {
        removeNode(node);
        addToHead(node);
    }
    
    Node* removeTail() {
        Node* node = tail->prev;
        removeNode(node);
        return node;
    }
    
    int get(int key) {
        if (cache.find(key) != cache.end()) {
            Node* node = cache[key];
            moveToHead(node);
            return node->value;
        }
        return -1;
    }
    
    void put(int key, int value) {
        if (cache.find(key) != cache.end()) {
            Node* node = cache[key];
            node->value = value;
            moveToHead(node);
        } else {
            Node* newNode = new Node(key, value);
            cache[key] = newNode;
            addToHead(newNode);
            size++;
            if (size > capacity) {
                Node* removedNode = removeTail();
                cache.erase(removedNode->key);
                delete removedNode;
                size--;
            }
        }
    }
};

int main() {
    
    LRUCache cache(2);
    
    
    cache.put(1, 1);
    cache.put(2, 2);
    
    cout << cache.get(1) << endl;  // 输出 1
    
    
    cache.put(3, 3);
    
   
    cout << cache.get(2) << endl;  // 输出 -1
    
    
    cout << cache.get(3) << endl;  // 输出 3
    
    
    cache.put(4, 4);
    
   
    cout << cache.get(1) << endl;  // 输出 -1
    
    
    cout << cache.get(3) << endl;  // 输出 3
    
    
    cout << cache.get(4) << endl;  // 输出 4
    
    return 0;
}
```

![image.png](/static/img/bb723deca9649e10b30fb3253fba5ef6.image.webp)

LRU算法

![image.png](/static/img/60625104c1c213ba7328f6a868f524cf.image.webp)



![image.png](/static/img/7617ae3ef8cfd91cbf9c5eb029e8c370.image.webp)

```sql
SELECT user_id, MAX(time_stamp) AS last_stamp
FROM Logins
WHERE YEAR(time_stamp) = 2020
GROUP BY user_id;

SELECT user_id, MAX(time_stamp) as last_stamp
FROM Logins
WHERE TIMEDIFF(time_stamp,'2020-01-01 00:00:00')>0 
    and TIMEDIFF(time_stamp,'2020-12-31 23:59:59') <0
GROUP BY user_id


SELECT user_id, MAX(time_stamp) as last_stamp
FROM Logins
WHERE DATEDIFF(time_stamp,'2020-01-01 00:00:00')>=0 
    and DATEDIFF(time_stamp,'2020-12-31 23:59:59') <=0
GROUP BY user_id


```


## 二


![image.png](/static/img/4f50688ebd91a59e15402ff69cf315e9.image.webp)

![image.png](/static/img/58256c87d11ab3fb35d01c78fe10179e.image.webp)

```sql
SELECT 'Low Salary' AS category, COUNT(*) AS accounts_count
FROM Accounts
WHERE income < 20000
UNION
SELECT 'Average Salary' AS category, COUNT(*) AS accounts_count
FROM Accounts
WHERE income >= 20000 AND income <= 50000
UNION
SELECT 'High Salary' AS category, COUNT(*) AS accounts_count
FROM Accounts
WHERE income > 50000;




SELECT 
    'Low Salary' AS category,
    SUM(CASE WHEN income < 20000 THEN 1 ELSE 0 END) AS accounts_count
FROM 
    Accounts
    
UNION
SELECT  
    'Average Salary' category,
    SUM(CASE WHEN income >= 20000 AND income <= 50000 THEN 1 ELSE 0 END) 
    AS accounts_count
FROM 
    Accounts

UNION
SELECT 
    'High Salary' category,
    SUM(CASE WHEN income > 50000 THEN 1 ELSE 0 END) AS accounts_count
FROM 
    Accounts



```