diff --git "a/2022/10/04/\345\223\210\345\267\245\345\244\247\346\223\215\344\275\234\347\263\273\347\273\237\345\256\236\351\252\214/index.html" "b/2022/10/04/\345\223\210\345\267\245\345\244\247\346\223\215\344\275\234\347\263\273\347\273\237\345\256\236\351\252\214/index.html" index 35c74ab8..0e474d5b 100644 --- "a/2022/10/04/\345\223\210\345\267\245\345\244\247\346\223\215\344\275\234\347\263\273\347\273\237\345\256\236\351\252\214/index.html" +++ "b/2022/10/04/\345\223\210\345\267\245\345\244\247\346\223\215\344\275\234\347\263\273\347\273\237\345\256\236\351\252\214/index.html" @@ -45,7 +45,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

哈工大操作系统实验

-
labs
+};

哈工大操作系统实验

-
labs

实验入口
主要参考文章
lseek()函数:用于移动打开文件的指针
linux系统调用之write源码解析（基于linux0.11）
get_fs_bytes解析
VIM与系统剪贴板的复制粘贴
操作系统实验六 信号量的实现和应用(哈工大李治军)
哈工大操作系统实验6 信号量的实现 pc.c 编译时报错 对‘sem_open‘未定义的引用
Linux 文件编程 open函数
哈工大-操作系统-HitOSlab-李治军-实验5-信号量的实现和应用

地址映射与共享

diff --git "a/2022/10/16/\351\230\205\350\257\273JDK\345\256\271\345\231\250\351\203\250\345\210\206\346\272\220\347\240\201\347\232\204\345\277\203\345\276\227\344\275\223\344\274\2321\343\200\220Collection\351\203\250\345\210\206\343\200\221/index.html" "b/2022/10/16/\351\230\205\350\257\273JDK\345\256\271\345\231\250\351\203\250\345\210\206\346\272\220\347\240\201\347\232\204\345\277\203\345\276\227\344\275\223\344\274\2321\343\200\220Collection\351\203\250\345\210\206\343\200\221/index.html" index 6a466f7e..b4df034b 100644 --- "a/2022/10/16/\351\230\205\350\257\273JDK\345\256\271\345\231\250\351\203\250\345\210\206\346\272\220\347\240\201\347\232\204\345\277\203\345\276\227\344\275\223\344\274\2321\343\200\220Collection\351\203\250\345\210\206\343\200\221/index.html" +++ "b/2022/10/16/\351\230\205\350\257\273JDK\345\256\271\345\231\250\351\203\250\345\210\206\346\272\220\347\240\201\347\232\204\345\277\203\345\276\227\344\275\223\344\274\2321\343\200\220Collection\351\203\250\345\210\206\343\200\221/index.html" @@ -48,7 +48,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

阅读JDK容器部分源码的心得体会1【Collection部分】

-
Java
+};

阅读JDK容器部分源码的心得体会1【Collection部分】

-
Java

idea 替换注释正则表达式/\*{1,2}[\s\S]*?\*/

typora 替换图片asset

\!\[.*\]\(D:\\aWorkStorage\\hexo\\blog\\source\\_posts\\阅读JDK容器部分源码的心得体会1【Collection部分】\\(.*)\.png\)，

diff --git "a/2022/10/22/\351\230\205\350\257\273JDK\345\256\271\345\231\250\351\203\250\345\210\206\346\272\220\347\240\201\347\232\204\345\277\203\345\276\227\344\275\223\344\274\2322\343\200\220Map\351\203\250\345\210\206\343\200\221/index.html" "b/2022/10/22/\351\230\205\350\257\273JDK\345\256\271\345\231\250\351\203\250\345\210\206\346\272\220\347\240\201\347\232\204\345\277\203\345\276\227\344\275\223\344\274\2322\343\200\220Map\351\203\250\345\210\206\343\200\221/index.html" index 0127707b..5144a550 100644 --- "a/2022/10/22/\351\230\205\350\257\273JDK\345\256\271\345\231\250\351\203\250\345\210\206\346\272\220\347\240\201\347\232\204\345\277\203\345\276\227\344\275\223\344\274\2322\343\200\220Map\351\203\250\345\210\206\343\200\221/index.html" +++ "b/2022/10/22/\351\230\205\350\257\273JDK\345\256\271\345\231\250\351\203\250\345\210\206\346\272\220\347\240\201\347\232\204\345\277\203\345\276\227\344\275\223\344\274\2322\343\200\220Map\351\203\250\345\210\206\343\200\221/index.html" @@ -43,7 +43,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

阅读JDK容器部分源码的心得体会2【Map部分】

-
Java
+};

阅读JDK容器部分源码的心得体会2【Map部分】

-
Java

idea 替换注释正则表达式/\*{1,2}[\s\S]*?\*/

typora 替换图片asset

\!\[.*\]\(D:\\aWorkStorage\\hexo\\blog\\source\\_posts\\阅读JDK容器部分源码的心得体会2【Map部分】\\(.*)\.png\)，

diff --git "a/2022/11/06/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/index.html" "b/2022/11/06/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/index.html" index 602deacf..ce3cd971 100644 --- "a/2022/11/06/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/index.html" +++ "b/2022/11/06/Java\345\271\266\345\217\221\347\274\226\347\250\213\345\256\236\346\210\230/index.html" @@ -382,7 +382,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

Java并发编程实战

-
books
+};

Java并发编程实战

-
books

idea 替换注释正则表达式/\*{1,2}[\s\S]*?\*/

第一章 简介

线程的作用

diff --git a/2022/12/21/JavaWeb/index.html b/2022/12/21/JavaWeb/index.html index 9118fb07..0cbab8c7 100644 --- a/2022/12/21/JavaWeb/index.html +++ b/2022/12/21/JavaWeb/index.html @@ -152,7 +152,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

JavaWeb

-
Java

第一部分 Java基础

JUnit单元测试

JUnit是白盒测试。

+};

JavaWeb

-
Java

第一部分 Java基础

JUnit单元测试

JUnit是白盒测试。

简要使用步骤

定义测试类

包含各种测试用例。

一般放在包名xxx.xxx.xx.test里，类名为“被测试类名Test”。

定义测试方法

测试方法可以独立运行。

diff --git a/2023/01/10/xv6$chap1/index.html b/2023/01/10/xv6$chap1/index.html index 36f8ae3a..f3991270 100644 --- a/2023/01/10/xv6$chap1/index.html +++ b/2023/01/10/xv6$chap1/index.html @@ -48,7 +48,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

Operating system interface

-

Operating system interface

本节大概是在讲操作系统的接口，系统调用占了很大一部分。

+};

Operating system interface

-

Operating system interface

本节大概是在讲操作系统的接口，系统调用占了很大一部分。

diff --git a/2023/01/10/xv6$chap2/index.html b/2023/01/10/xv6$chap2/index.html index 7f2bb7eb..1f5a3265 100644 --- a/2023/01/10/xv6$chap2/index.html +++ b/2023/01/10/xv6$chap2/index.html @@ -43,7 +43,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

Operating system oganization

-

Operating system oganization

+};

Operating system oganization

-

Operating system oganization

Before you start coding, read Chapter 2 of the xv6 book, and Sections 4.3 and 4.4 of Chapter 4, and related source files:

1
2
3
4
5
6
7
8
9
10
11
12
for(int i=0;i<NFILEMAP;i++){
  np->filemaps[i].isused = p->filemaps[i].isused;
  np->filemaps[i].va = p->filemaps[i].va;
  np->filemaps[i].okva = p->filemaps[i].okva;
  np->filemaps[i].file = p->filemaps[i].file;
  np->filemaps[i].length = p->filemaps[i].length;
  np->filemaps[i].flags = p->filemaps[i].flags;
  np->filemaps[i].offset = p->filemaps[i].offset;
  np->filemaps[i].prot = p->filemaps[i].prot;
  if(np->filemaps[i].file)
    filedup(np->filemaps[i].file);
}

修改uvmcopy和uvmunmap

1
2
3
4
5
6
7
8
9
// in uvmunmap()
    if((*pte & PTE_V) == 0){
      *pte = 0;
      continue;
    }
// in uvmcopy()
    if((*pte & PTE_V) == 0)
      //panic("uvmcopy: page not present");
      continue;
-
I'm so cute. Please give me money.
© 2019 – 2023 修年
由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
\ No newline at end of file +
I'm so cute. Please give me money.
© 2019 – 2023 修年
由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
\ No newline at end of file diff --git a/2023/01/10/xv6$chap9/index.html b/2023/01/10/xv6$chap9/index.html index 50ae6316..56381d7c 100644 --- a/2023/01/10/xv6$chap9/index.html +++ b/2023/01/10/xv6$chap9/index.html @@ -52,7 +52,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

其他的对实验未涉及的思考

-

其他的对实验未涉及的思考

由mkfs引发的对虚拟机的学习

+};

其他的对实验未涉及的思考

-

其他的对实验未涉及的思考

由mkfs引发的对虚拟机的学习

懂了！VMware/KVM/Docker原来是这么回事儿这篇文章对虚拟化、虚拟机技术讲解很到位，写得通俗易懂，非常值得一看

KVM 的「基于内核的虚拟机」是什么意思？这篇文章对QEMU-KVM架构进行了详细的介绍。还有这篇文章对应的知乎问题下面的高赞回答有机会也可以去看看。

QEMU/KVM原理概述这篇文章前面的原理和上面那个差不多，后面有使用kvm做一个精简内核的实例，有兴趣/有精力/有需要可以看看。

@@ -328,4 +328,4 @@

I'm so cute. Please give me money.

© 2019 – 2023 修年
由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
\ No newline at end of file +
I'm so cute. Please give me money.
© 2019 – 2023 修年
由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
\ No newline at end of file diff --git a/2023/01/10/xv6/index.html b/2023/01/10/xv6/index.html index ebd92eed..2fba6779 100644 --- a/2023/01/10/xv6/index.html +++ b/2023/01/10/xv6/index.html @@ -38,7 +38,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

xv6

-
labs
+};

xv6

-
labs

总耗时：120h 约27天

部分地方的翻译和表格来源参考：xv6指导书翻译

部分文本来自：操作系统实验指导书 - 2023秋季 | 哈工大（深圳）

diff --git a/2023/02/25/cs144$else/index.html b/2023/02/25/cs144$else/index.html index 1cfb13db..a95e710a 100644 --- a/2023/02/25/cs144$else/index.html +++ b/2023/02/25/cs144$else/index.html @@ -40,7 +40,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

其他的对实验未涉及的思考

-

其他的对实验未涉及的思考

网络层实现

在我们的协议栈实现中，我们负责了运输层的TCP协议、网络层的ARP协议以及数据链路层的ETH协议的编写，剩下的网络层的IP协议则由官方给定。接下来我们就来探究下网络层的实现。

+};

其他的对实验未涉及的思考

-

其他的对实验未涉及的思考

网络层实现

在我们的协议栈实现中，我们负责了运输层的TCP协议、网络层的ARP协议以及数据链路层的ETH协议的编写，剩下的网络层的IP协议则由官方给定。接下来我们就来探究下网络层的实现。

总体架构

You’ve done this already.

In Lab 4, we gave:

diff --git a/2023/02/25/cs144$lab0/index.html b/2023/02/25/cs144$lab0/index.html index 95ca1316..47f04d8b 100644 --- a/2023/02/25/cs144$lab0/index.html +++ b/2023/02/25/cs144$lab0/index.html @@ -44,7 +44,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

Lab0

-

Lab0

+};

Lab0

-

Lab0

本次实验一直在强调的一点就是，TCP的功能是将底层的零散数据包，拼接成一个reliable in-order的byte stream。这个对我来说非常“振聋发聩”（夸张了233），以前只是背诵地知道TCP的可靠性，这次我算是第一次知道了所谓“可靠”究竟可靠在哪：一是保证了序列有序性，二是保证了数据不丢失（从软件层面）。

还有一个就是大致了解了cs144的主题：实现TCP协议。也就是说，运输层下面的那些层是不用管的吗？不过这样也挺恰好，我正好在学校的实验做过对下面这些层的实现了，就差一个TCP23333这样一来，我的协议栈就可以完整了。

diff --git a/2023/02/25/cs144$lab1/index.html b/2023/02/25/cs144$lab1/index.html index d1f204a0..d1fb2e29 100644 --- a/2023/02/25/cs144$lab1/index.html +++ b/2023/02/25/cs144$lab1/index.html @@ -39,7 +39,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

Lab1 StreamReassembler

-

Lab1 StreamReassembler

+};

Lab1 StreamReassembler

-

Lab1 StreamReassembler

TCP managed to produce a pair of reliable in-order byte streams (one from you to the server, and one in the opposite direction), even though the underlying network only delivers “best-effort” datagrams.

You also implemented the byte-stream abstraction yourself, in memory within one computer.

Over the next four weeks, you’ll implement TCP, to provide the byte-stream abstraction between a pair of computers separated by an unreliable datagram network.

diff --git a/2023/02/25/cs144$lab2/index.html b/2023/02/25/cs144$lab2/index.html index f6c8463d..b9764f50 100644 --- a/2023/02/25/cs144$lab2/index.html +++ b/2023/02/25/cs144$lab2/index.html @@ -48,7 +48,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

Lab2 TCPReceiver

-

Lab2 TCPReceiver

前置学习

Overview

承上启下

在前两个实验中，我们可以说只是做了点算法上的抽象工作，跟TCP协议还是没什么显著的关系的。但来到了本次实验，一切就都不一样了。

+};

Lab2 TCPReceiver

-

Lab2 TCPReceiver

前置学习

Overview

承上启下

在前两个实验中，我们可以说只是做了点算法上的抽象工作，跟TCP协议还是没什么显著的关系的。但来到了本次实验，一切就都不一样了。

image-20230226194708398

依然还是这张图。相信此时做过前两个实验之后，看到这张图就会有了不一样的发现。

我们对TCP协议的实现是由内向外的，先实现里面再实现最外层。前两节实验，我们由内而外实现了ByteStream和StreamReassembler；在这次实验中，我们会实现更外层一点的TCPReceiver。

diff --git a/2023/02/25/cs144$lab3/index.html b/2023/02/25/cs144$lab3/index.html index f25cbf70..40f17bd2 100644 --- a/2023/02/25/cs144$lab3/index.html +++ b/2023/02/25/cs144$lab3/index.html @@ -38,7 +38,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

Lab3 TCPSender

-

Lab3 TCPSender

前置知识

在TCP协议中，TCPSender负责对ack进行处理，将字节流封装为TCP报文，根据拥塞窗口的大小传输数据，以及管理超时重传。

+};

Lab3 TCPSender

-

Lab3 TCPSender

前置知识

在TCP协议中，TCPSender负责对ack进行处理，将字节流封装为TCP报文，根据拥塞窗口的大小传输数据，以及管理超时重传。

我们的TCPSender需要做的是：

  1. 维护拥塞窗口

    diff --git a/2023/02/25/cs144$lab4/index.html b/2023/02/25/cs144$lab4/index.html index 7c5cc447..e54323cd 100644 --- a/2023/02/25/cs144$lab4/index.html +++ b/2023/02/25/cs144$lab4/index.html @@ -61,7 +61,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    Lab4 TCPConnection

    -

    Lab4 TCPConnection

    心得

    耗时情况

    【长舒一口气】

    +};

    Lab4 TCPConnection

    -

    Lab4 TCPConnection

    心得

    耗时情况

    【长舒一口气】

    最开始先记录下总体耗时情况吧。本次实验共耗费我16h+【不包括接下来写笔记的时间23333】，共耗费三个工作日。第一天看完了指导书，写完了代码，过掉了#45 reorder之前的所有测试。第二天过掉了#55 t_ucS_1M_32k之前的所有测试，直到第三天才过完了所有测试。

    我觉得这整个过程还是挺有意义的，每天都有新的进展，看到test case越过越多是真的很高兴。但是可以说第二天以来就都是面向测试用例改bug了，非常折磨非常坐牢，既要去再次理清之前写过的shit山，又得搞清楚很多让人一头雾水不知从何下手的地方。但总之，这三天很充实，并不会让人觉得心累。

    放个通关截图吧，感人至深。

    diff --git a/2023/02/25/cs144$lab5/index.html b/2023/02/25/cs144$lab5/index.html index 59473fe4..c99cc7b2 100644 --- a/2023/02/25/cs144$lab5/index.html +++ b/2023/02/25/cs144$lab5/index.html @@ -39,7 +39,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    Lab5 NetworkInterface

    -

    Lab5 NetworkInterface

    Overview

    在前面的lab0-4中，我们实现了TCP协议。而在本次实验，以及接下来的实验6中，我们会将目光从顶层转移到底层——我们将着眼于运输层以下的协议。在本次实验中，我们将实现ETH协议，实现对IP数据报的封装以及对物理地址的查询转发；在下一次实验中，我们将实现网络层的路由转发算法。

    +};

    Lab5 NetworkInterface

    -

    Lab5 NetworkInterface

    Overview

    在前面的lab0-4中，我们实现了TCP协议。而在本次实验，以及接下来的实验6中，我们会将目光从顶层转移到底层——我们将着眼于运输层以下的协议。在本次实验中，我们将实现ETH协议，实现对IP数据报的封装以及对物理地址的查询转发；在下一次实验中，我们将实现网络层的路由转发算法。

    承上启下

    协议栈架构

    我们在前面的实验已经实现了TCP协议，那么，TCP报文究竟是如何进行封装，最终到达peer那边的？我们的协议栈架构究竟是怎么样的？对于这个过程的实现协议栈，我们可以有如下三种选择。

    TCP-UDP-IP

    在此架构中，TCP不由操作系统的内核实现，而是运行在用户态。【事实上这三种选择TCP都是运行在用户态的，正如我们实现的这样】

    用户态会将上层app传来的数据封装在TCP报文段中，用户态只需向操作系统提供的一个接口传入TCP报文段以及目的地址进入该接口就行。在此接口中，操作系统会给用户传进来的数据报文增加UDP、IP、ETH等等协议头，添加端口号等等等。

    diff --git a/2023/02/25/cs144$lab6/index.html b/2023/02/25/cs144$lab6/index.html index 362f3073..21f11201 100644 --- a/2023/02/25/cs144$lab6/index.html +++ b/2023/02/25/cs144$lab6/index.html @@ -39,7 +39,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    Lab6 Router

    -

    Lab6 Router

    心得

    要做什么

    本次实验要实现的是IP层的路由工作，但是只用实现对路由表进行操作的部分，比如说增加表项以及查询路由表等，其他的什么RIP、OSPF都不用我们实现，所以这样一来其实就简单非常多了（）

    +};

    Lab6 Router

    -

    Lab6 Router

    心得

    要做什么

    本次实验要实现的是IP层的路由工作，但是只用实现对路由表进行操作的部分，比如说增加表项以及查询路由表等，其他的什么RIP、OSPF都不用我们实现，所以这样一来其实就简单非常多了（）

    有一点需要注意的是，它一直在强调一个“最长前缀匹配”。也就是：

    image-20230309142032359

    image-20230309141949757

    diff --git a/2023/02/25/cs144/index.html b/2023/02/25/cs144/index.html index f89413f7..c1412709 100644 --- a/2023/02/25/cs144/index.html +++ b/2023/02/25/cs144/index.html @@ -36,7 +36,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    cs144

    -
    labs
    +};

    cs144

    -
    labs

    总耗时：65h 约17天

    实验官网

    感恩

    diff --git "a/2023/03/10/\345\257\271moore\345\236\213\345\222\214mealy\345\236\213\347\212\266\346\200\201\346\234\272\347\232\204\347\220\206\350\247\243/index.html" "b/2023/03/10/\345\257\271moore\345\236\213\345\222\214mealy\345\236\213\347\212\266\346\200\201\346\234\272\347\232\204\347\220\206\350\247\243/index.html" index b8cc74d3..97e01ef7 100644 --- "a/2023/03/10/\345\257\271moore\345\236\213\345\222\214mealy\345\236\213\347\212\266\346\200\201\346\234\272\347\232\204\347\220\206\350\247\243/index.html" +++ "b/2023/03/10/\345\257\271moore\345\236\213\345\222\214mealy\345\236\213\347\212\266\346\200\201\346\234\272\347\232\204\347\220\206\350\247\243/index.html" @@ -41,7 +41,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    状态机

    -

    复习数电时，一道密码锁题令我十分不解：

    +};

    状态机

    -

    复习数电时，一道密码锁题令我十分不解：

    image-20230213201519568

    看到题目时，我首先联想到的是mealy型状态机，因为我联想到了序列检测。课内的序列检测讲的时候是把它当做mealy型的。但看了标准作答之后，才发现它其实应该是moore型。这让我对这二者的区别产生了深深的不解。

    diff --git a/2023/03/13/cmu15445$lab0/index.html b/2023/03/13/cmu15445$lab0/index.html index 98776360..3f663731 100644 --- a/2023/03/13/cmu15445$lab0/index.html +++ b/2023/03/13/cmu15445$lab0/index.html @@ -54,7 +54,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    Project0 C++ Primer

    -

    Project0 C++ Primer

    相比于fall2022（Trie），spring2023（COW-Trie）的难度更大，算法更复杂【毕竟是要实现一个cow的数据结构】，我认为两个都很有意义，故而两个都做了。

    +};

    Project0 C++ Primer

    -

    Project0 C++ Primer

    相比于fall2022（Trie），spring2023（COW-Trie）的难度更大，算法更复杂【毕竟是要实现一个cow的数据结构】，我认为两个都很有意义，故而两个都做了。

    其中在Trie中，由于我是第一次接触cpp，所以遇到了很多麻烦。好在经过18h+的cpp拷打后，cow-trie虽然难度大，语法也更复杂一些，但我还是很快（话虽如此也花了7、8小时23333）就完美pass了。不过效率可能还是不大高，毕竟我不熟悉cpp，很多地方可能都直接拷贝了emm希望后续学习可以加把劲。

    Trie

    In this project, you will implement a key-value store backed by a concurrent trie. 实现并发安全的trie

    diff --git a/2023/03/13/cmu15445$lab1/index.html b/2023/03/13/cmu15445$lab1/index.html index 1061f538..aba138f2 100644 --- a/2023/03/13/cmu15445$lab1/index.html +++ b/2023/03/13/cmu15445$lab1/index.html @@ -54,7 +54,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    Project1 Buffer Pool

    -

    Project1 Buffer Pool

    先放个通关记录~

    +};
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file +
    I'm so cute. Please give me money.
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file diff --git a/2023/03/13/cmu15445$lab2/image-20231203165014734.png b/2023/03/13/cmu15445$lab2/image-20231203165014734.png new file mode 100644 index 00000000..26a7aaee Binary files /dev/null and b/2023/03/13/cmu15445$lab2/image-20231203165014734.png differ diff --git a/2023/03/13/cmu15445$lab2/image-20231203181652821.png b/2023/03/13/cmu15445$lab2/image-20231203181652821.png new file mode 100644 index 00000000..9b954c96 Binary files /dev/null and b/2023/03/13/cmu15445$lab2/image-20231203181652821.png differ diff --git a/2023/03/13/cmu15445$lab2/image-20231204001136531.png b/2023/03/13/cmu15445$lab2/image-20231204001136531.png new file mode 100644 index 00000000..bdaa419c Binary files /dev/null and b/2023/03/13/cmu15445$lab2/image-20231204001136531.png differ diff --git a/2023/03/13/cmu15445$lab2/image-20231204161729128.png b/2023/03/13/cmu15445$lab2/image-20231204161729128.png new file mode 100644 index 00000000..c4afcf45 Binary files /dev/null and b/2023/03/13/cmu15445$lab2/image-20231204161729128.png differ diff --git a/2023/03/13/cmu15445$lab2/image-20231204163052528.png b/2023/03/13/cmu15445$lab2/image-20231204163052528.png new file mode 100644 index 00000000..91b337ce Binary files /dev/null and b/2023/03/13/cmu15445$lab2/image-20231204163052528.png differ diff --git a/2023/03/13/cmu15445$lab2/image-20231204170030245.png b/2023/03/13/cmu15445$lab2/image-20231204170030245.png new file mode 100644 index 00000000..96adc2fa Binary files /dev/null and b/2023/03/13/cmu15445$lab2/image-20231204170030245.png differ diff --git a/2023/03/13/cmu15445$lab2/index.html b/2023/03/13/cmu15445$lab2/index.html index aeefd711..2004a552 100644 --- a/2023/03/13/cmu15445$lab2/index.html +++ b/2023/03/13/cmu15445$lab2/index.html @@ -22,8 +22,14 @@ + + + + + + - +

    Project2 B+Tree

    -

    Project2 B+Tree

    +};

    Project2 B+Tree

    -

    Project2 B+Tree

    In this programming project you will implement a B+Tree index in your database system.

    Your implementation will support thread-safe search, insertion, deletion (including splitting and merging nodes包括分裂和合并结点), and an iterator to support in-order leaf scans.

    @@ -164,4 +170,28 @@

    我服了。

    不过可能有更好的解决方法？可惜我c++水平不大够，所以暂时想不出来了。

    +

    Task4 Remove

    感想

    由于有了insert的沉淀，remove的实现便相较不大困难了，写完代码到通过内置的delete测试只花了一天的时间。

    +

    思路

    Task5 Concurrency

    感想

    这位可更是重量级，足足花了我三天的时间。

    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    auto BufferPoolManager::FetchPage(page_id_t page_id, [[maybe_unused]] AccessType access_type) -> Page * {
      latch_.lock();

      auto it = page_table_.find(page_id);
      if (it != page_table_.end()) {
        frame_id_t fid = it->second;

        pages_latch_[fid].lock();
        replacer_->RecordAccess(fid, access_type);
        replacer_->SetEvictable(fid, false);
        latch_.unlock();

        pages_[fid].pin_count_++;

        auto res = &(pages_[fid]);

        pages_latch_[fid].unlock();

        return res;
      }
      
      if (free_list_.empty()) {
        frame_id_t fid;
        if (!replacer_->Evict(&fid)) {
          latch_.unlock();
          return nullptr;
        }
        
        pages_latch_[fid].lock();
        page_table_.erase(page_table_.find(pages_[fid].GetPageId()));
        page_table_.insert(std::make_pair(page_id, fid));

        replacer_->RecordAccess(fid, access_type);
        replacer_->SetEvictable(fid, false);

        if (pages_[fid].IsDirty()) {
          disk_manager_->WritePage(pages_[fid].GetPageId(), pages_[fid].GetData());
        }
        latch_.unlock();

        Page *res = &(pages_[fid]);
        res->ResetMemory();
        // read from disk
        disk_manager_->ReadPage(page_id, res->GetData());

        res->is_dirty_ = false;
        res->page_id_ = page_id;
        res->pin_count_ = 1;

        pages_latch_[fid].unlock();
        return res;
      }
    }
    + + + +

    这个并发问题是这样的，我原来是先evict，然后再写回，写回过程中磁盘没加bpm锁。这就会出现这样一个情况：

    +

    一个page被进程A evict，进程A还没执行写回的时候这个page又被进程B捡回来了，因为还没写入所以磁盘空空如也。这时候pages_latch_这个细粒度锁不能防范这种情况，是因为此时这个page对应的container不是同一个，所以fid不同，细粒度锁不同导致寄。

    +

    解决方法是要么写的时候持有bpm锁，但是这太太慢了。另一个就是干脆直接在unpin的时候不带bpm锁顺便写回了。

    +

    https://zhuanlan.zhihu.com/p/661208232

    +

    image-20231203165014734

    +

    这种情况我的做法是持有header page的读锁

    +

    image-20231203181652821

    +

    现在是这样，root即将分裂，两个进程同时插入一个key。一个进程A先得到header page的读锁和root的写锁，另一个B只得到header page读锁，等待写锁。

    +

    此时，A缩小了旧root结点，造了新结点，把root drop掉，再去获取header page的写锁；B获取了root的写锁，检查到它并非max size，插入，从而导致错误。

    +

    这时候修改header page和root的锁释放顺序会导致死锁，所以很遗憾我们只能先拿着header page的写锁，检测到无需分裂root再拿读锁了。

    +

    目前应该是算把insert的锁整好了，接下来修下delete的bug和锁应该也就差不多了

    +

    牛逼，接下来就只剩个remove的并发了

    +

    image-20231204001136531

    +

    image-20231204163052528

    +

    我服了。。。。。。。。。

    +

    image-20231204170030245

    +

    好像还是有点垃圾乐，算了先这样吧

    +

    out

    I'm so cute. Please give me money.
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file diff --git a/2023/03/13/cmu15445$lab2/out.png b/2023/03/13/cmu15445$lab2/out.png new file mode 100644 index 00000000..094d5703 Binary files /dev/null and b/2023/03/13/cmu15445$lab2/out.png differ diff --git a/2023/03/13/cmu15445/index.html b/2023/03/13/cmu15445/index.html index 746dac19..3e0d9561 100644 --- a/2023/03/13/cmu15445/index.html +++ b/2023/03/13/cmu15445/index.html @@ -36,7 +36,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    CMU15445

    -
    labs
    +};

    CMU15445

    -
    labs

    实验官网

    代码

    diff --git "a/2023/06/17/\345\257\271GRUB\345\222\214initramfs\347\232\204\345\260\217\346\216\242\347\251\266/index.html" "b/2023/06/17/\345\257\271GRUB\345\222\214initramfs\347\232\204\345\260\217\346\216\242\347\251\266/index.html" index 67a62778..c32301eb 100644 --- "a/2023/06/17/\345\257\271GRUB\345\222\214initramfs\347\232\204\345\260\217\346\216\242\347\251\266/index.html" +++ "b/2023/06/17/\345\257\271GRUB\345\222\214initramfs\347\232\204\345\260\217\346\216\242\347\251\266/index.html" @@ -42,7 +42,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    对GRUB和initramfs的小探究

    -
    os竞赛

    竞赛时对操作系统启动过程产生了些疑问，于是问题导向地浅浅探究了下GRUB和initramfs相关机制，相关笔记先放在这里了。

    +};

    对GRUB和initramfs的小探究

    -
    os竞赛

    竞赛时对操作系统启动过程产生了些疑问，于是问题导向地浅浅探究了下GRUB和initramfs相关机制，相关笔记先放在这里了。

    内核启动流程

    在传统的BIOS系统中，计算机具体的启动流程如下：

    1. 电源启动：当计算机的电源打开时，电源供电给计算机的硬件设备。
      2. diff --git a/2023/06/21/comporgan/index.html b/2023/06/21/comporgan/index.html index c40c6a87..cd78eca0 100644 --- a/2023/06/21/comporgan/index.html +++ b/2023/06/21/comporgan/index.html @@ -365,7 +365,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

      计算机组成原理

      概述

      架构

      冯诺依曼

      以运算器为中心，指令和数据同等地位（不满足摩尔定律）

      +};

      计算机组成原理

      概述

      架构

      冯诺依曼

      以运算器为中心，指令和数据同等地位（不满足摩尔定律）

      image-20230617133555268

      存储器为中心

      image-20230617133840406

      哈佛架构

      哈佛结构数据空间和程序空间是分开的

      diff --git "a/2023/06/21/\350\257\276\347\250\213\345\255\246\344\271\240/index.html" "b/2023/06/21/\350\257\276\347\250\213\345\255\246\344\271\240/index.html" index 2a8101d9..615a505e 100644 --- "a/2023/06/21/\350\257\276\347\250\213\345\255\246\344\271\240/index.html" +++ "b/2023/06/21/\350\257\276\347\250\213\345\255\246\344\271\240/index.html" @@ -38,7 +38,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

      课程学习

      -

      卷学分绩的过程中，从应试的角度学习这些基础课，也给我带来了不少收获。因而，我选择将课内复习的笔记包含在这里，并且除去一些非必要的糟粕，仅保留最精华的部分，以供以后学习参考使用。

      +};

      课程学习

      -

      卷学分绩的过程中，从应试的角度学习这些基础课，也给我带来了不少收获。因而，我选择将课内复习的笔记包含在这里，并且除去一些非必要的糟粕，仅保留最精华的部分，以供以后学习参考使用。

      计算机组成原理

      编译原理

      yysy，感觉编译原理这门课应该能算大三学了之后收获最大的专业课。理论课从形式化的原理出发，讲述了编译器的构成：词法分析、语法分析、语义分析、中间代码生成、代码优化、目标代码生成。实验课又实现了一个简单的具有基本功能的编译器。这二者相辅相成，学完这门课之后真的对编译系统的构造有了一个较为全面的了解。

      1. 词法分析

        diff --git a/2023/08/12/kernel_compile/index.html b/2023/08/12/kernel_compile/index.html new file mode 100644 index 00000000..de45c138 --- /dev/null +++ b/2023/08/12/kernel_compile/index.html @@ -0,0 +1,211 @@ +内核编译 | 修年 + + + + + + + + + +

        内核编译

        -

        我们在开发过程中所用的具体硬件配置如下：

        +
        +

        CPU: Intel(R) Core(TM) i7-8700 CPU @ 3 with hyper-threading

        +

        Memory: 14GB

        +

        OS: Ubuntu 22.04.3 LTS

        +

        ​ with Linux kernel 6.4.0+(COS) && 6.4.0-rc3+(EXT) && 5.11.0+(ghOSt)

        +
        +

        COS环境搭建

        COS可以部署在Linux物理机和虚拟机上，但建议部署在Linux物理机以获取更好的性能效果。下文将详细介绍环境搭建的详细步骤。

        +

        COS内核

        内核编译

        安装内核编译所需包：

        +
        1
        sudo apt-get update && sudo apt-get install build-essential gcc g++ make libncurses5-dev libssl-dev bison flex bc libelf-dev
        + +

        克隆COS内核：

        +
        1
        2
        git clone https://github.com/shootfirst/cos_kernel.git
        cd cos_kernel/
        + +

        生成内核编译配置文件：

        +
        1
        make localmodconfig
        + +

        修改.config文件：

        +
        1
        vim .config
        + +
          +

        1. 删除PSI监测

          +

          查找CONFIG_PSI，将其对应行修改为：

          +
          1
          CONFIG_PSI=n
          2. +

        2. 删除系统吊销密钥

          +

          查找CONFIG_PSI，将其对应行修改为：

          +
          1
          CONFIG_SYSTEM_REVOCATION_KEYS=""
          3. +
        +

        然后就可以进行内核编译：

        +
        1
        make -j12 && sudo make modules_install && sudo make install
        + + + +

        修改grub

        打开grub配置文件：

        +
        1
        sudo vim /etc/default/grub
        + +

        进行以下修改：

        +
          +
        1. 注释GRUB_TIMEOUT_STYLE=hidden
          2. +
        2. 将GRUB_CMDLINE_LINUX_DEFAULT设置为”text”
          3. +
        3. 将GRUB_TIMEOUT修改成30
          4. +
        +

        然后保存退出，更新grub：

        +
        1
        sudo update-grub
        + + + +

        进入COS内核

        完成上述步骤后，重启虚拟机：

        +
        1
        sudo reboot
        + +

        在进入GRUB界面时选择Advanced Ubuntu，然后选择内核版本6.4.0+即可。

        +

        COS用户态

        在完成COS内核编译，并进入COS内核之后，就完成了COS的基本环境搭建。接下来，将介绍如何搭建COS用户态环境，从而运行Shinjuku Scheduler和RocksDB实验。

        +

        首先，确保所处内核正确：

        +
        1
        2
        $ uname -r
        6.4.0+
        + +

        依赖安装

        apt包

        安装编译用户态需要的包：

        +
        1
        sudo apt-get install cmake python2 python3 libtbb-dev libsnappy-dev zlib1g-dev libgflags-dev libbz2-dev liblz4-dev libzstd-dev
        + + + +

        RocksDB

        获取RocksDB 6.15.5版本release：

        +
        1
        2
        3
        wget https://github.com/facebook/rocksdb/archive/refs/tags/v6.15.5.tar.gz
        tar -xvf v6.15.5.tar.gz
        cd rocksdb-6.15.5/
        + +
        +

        注：测试得发现本RocksDB负载同最新版本RocksDB不兼容，故而建议使用上述命令对应版本，也即v6.15.5。

        +
        +

        修改CMakeLists：

        +
        1
        vim CMakeLists.txt
        + +
          +

        1. 搜索WITH_TBB，将这一项改为ON:

          +
          1
          option(WITH_TBB "build with Threading Building Blocks (TBB)" ON)
          2. +

        2. 搜索ROCKSDB_LITE ，确保这一项为OFF

          +
          1
          option(ROCKSDB_LITE "Build RocksDBLite version" OFF)
          3. +
        +

        保存退出后进行编译安装：

        +
        1
        mkdir build && cd build && cmake .. && make -j12 && sudo make install
        + + + +

        运行COS

        克隆COS用户态代码：

        +
        1
        2
        git clone https://gitlab.eduxiji.net/202318123111334/cos_userspace.git
        cd cos_userspace
        + +

        编译COS用户态：

        +
        1
        mkdir build && cd build && cmake .. && make -j($nproc)
        + +

        然后就可以开始运行COS用户态了。在此以Fifo Scheduler为例。

        +

        打开两个终端，在其中一个运行Fifo Scheduler：

        +
        1
        2
        pwd # 确保在cos_userspace/build目录下
        sudo ./fifo_scheduler
        + +

        另一个运行GTest测试：

        +
        1
        2
        pwd # 确保在cos_userspace/build目录下
        sudo ./simple_exp
        + +

        等待测试完成即可。

        +

        若要运行展示中所提到的测试，可详细见性能测试教程。

        +

        EXT环境搭建

        EXT内核

        依赖安装

        llvm

        SCHED-EXT内核由于用到新eBPF特性，故而编译需要用到还未发行到apt包管理器的clang最新版本，因此需要手动拉取并且编译一些依赖包。

        +
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        # 克隆llvm仓库
        git clone --depth=1 https://github.com/llvm/llvm-project.git

        # 编译llvm项目
        cd llvm-project
        mkdir build
        cd build
        cmake -DLLVM_ENABLE_PROJECTS=clang -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles" ../llvm
        make -j($nproc)

        # 在~/.bashrc文件添加
        export PATH=$PATH:/yourpath/llvm-project/build/bin

        # 确认
        echo $PATH
        clang --version # >= 17.0.0
        llvm-config --version # >= 17.0.0
        + + + +

        pahole

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        # 克隆pahole项目
        git clone git://git.kernel.org/pub/scm/devel/pahole/pahole.git

        # 编译pahole项目
        cd pahole/
        mkdir build
        cd build
        cmake -D__LIB=lib -DBUILD_SHARED_LIBS=OFF ..
        make
        sudo make install

        # 检查
        $ pahole --version # >= v1.25
        + + + +

        rust-nightly

        1
        2
        3
        4
        5
        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
        rustup toolchain install nightly
        rustup default nightly
        # 查看rust版本
        rustc --version
        + + + +

        内核编译

        安装内核编译所需包：

        +
        1
        sudo apt-get update && sudo apt-get install build-essential gcc g++ make libncurses5-dev libssl-dev bison flex bc libelf-dev
        + +

        克隆COS内核：

        +
        1
        2
        git clone https://gitlab.eduxiji.net/202318123111334/ext-kernel.git
        cd ext-kernel/
        + +

        生成内核编译配置文件：

        +
        1
        make localmodconfig
        + +

        对生成的.config配置文件做如下修改：

        +
          +
        1. 将CONFIG_SYSTEM_TRUSTED_KEYS="debian/canonical-certs.pem"修改为CONFIG_SYSTEM_TRUSTED_KEYS=""
          2. +
        2. 添加CONFIG_SCHED_CLASS_EXT=y
          3. +
        3. 确保CONFIG_DEBUG_INFO以及CONFIG_DEBUG_INFO_BTF为开启状态
          4. +
        +

        编译安装内核：

        +
        1
        make -j12 && sudo make modules_install && sudo make install
        + +

        修改grub

        详见COS环境搭建的对应部分。在此不做赘述。

        +

        EXT用户态

        1
        2
        pwd # 确保在ext-kernel/项目根目录下
        cd ext-kernel/tools
        + +

        随后，我们需要替换原有EXT使用示例为我们搭建的EXT用户态框架。

        +
        1
        2
        rm -rf sched_ext/
        git clone https://gitlab.eduxiji.net/202318123111334/proj134-cfs-based-userspace-scheduler.git sched_ext
        + +

        然后就可以运行EXT用户态框架了。

        +

        若要运行展示中所提到的测试，可详细见性能测试教程。

        +

        ghOSt环境搭建

        由于测试中需要以ghOSt作为比较对象，故在运行测试之前，必须搭建ghOSt环境。

        +

        ghOSt内核

        内核编译

        安装内核编译所需包：

        +
        1
        sudo apt-get update && sudo apt-get install build-essential gcc g++ make libncurses5-dev libssl-dev bison flex bc libelf-dev
        + +

        克隆ghOSt内核：

        +
        1
        2
        git clone https://github.com/google/ghost-kernel
        cd ghost-kernel/
        + +

        生成内核编译配置文件：

        +
        1
        make localmodconfig
        + +

        对生成的.config配置文件做如下修改：

        +
          +
        1. 将CONFIG_SYSTEM_TRUSTED_KEYS="debian/canonical-certs.pem"修改为CONFIG_SYSTEM_TRUSTED_KEYS=""
          2. +
        2. 添加CONFIG_SCHED_CLASS_GHOST=y
          3. +
        +

        编译安装内核：

        +
        1
        make -j12 && sudo make modules_install && sudo make install
        + + + +

        修改grub

        详见COS环境搭建的对应部分。在此不做赘述。

        +

        ghOSt用户态

        依赖安装

        bazel

        +

        详细安装可参照官方文档Installing Bazel on Ubuntu，在此仅给出其中第一种方法。

        +
        +

        将Bazel分发URL添加为软件包来源

        +
        1
        2
        3
        4
        5
        # 在~目录下
        sudo apt install apt-transport-https curl gnupg -y
        curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
        sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
        echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
        + +

        安装和更新Bazel

        +
        1
        2
        3
        sudo apt update && sudo apt install bazel
        # 将bazel升级到最新版本
        sudo apt update && sudo apt full-upgrade
        + + + +

        apt包

        1
        2
        sudo apt update
        sudo apt install libnuma-dev libcap-dev libelf-dev libbfd-dev gcc clang-12 llvm zlib1g-dev python-is-python3 libabsl-dev
        + + + +

        运行ghOSt

        克隆ghOSt用户态：

        +
        1
        2
        git clone https://gitlab.eduxiji.net/202318123111334/ghost_userspace.git
        cd ghost-userspace
        + +
        I'm so cute. Please give me money.
        © 2019 – 2023 修年
        由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
        \ No newline at end of file diff --git a/2023/08/27/2023-os-comp/index.html b/2023/08/27/2023-os-comp/index.html index 198ce2f1..a9eafe04 100644 --- a/2023/08/27/2023-os-comp/index.html +++ b/2023/08/27/2023-os-comp/index.html @@ -38,7 +38,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

        总结—2023全国大学生计算机系统能力大赛-OS功能

        -

        基本信息

          +};

          总结—2023全国大学生计算机系统能力大赛-OS功能

          -

          基本信息

          • 竞赛简介

            全国大学生计算机系统能力大赛可以说是计算机专业除了ACM以外专业性最高的比赛之一了。内分多个赛道，如CPU设计（“龙芯杯”）、编译器设计（“毕昇杯”）、数据库设计以及操作系统设计。其中操作系统设计赛又分为内核实现和功能挑战两个赛道，我这一次参加的是功能赛道。

            功能赛道的主要任务就是，从给定的265个赛题中选出一个赛题，并围绕此赛题做项目。项目周期为半年左右（其中3.28~6.07为初赛阶段，6.10~8.15为决赛阶段），并在最后有线下答辩以及代码现场检查验收。

            diff --git "a/2023/09/18/\351\235\231\346\200\201\351\223\276\346\216\245\344\270\216\345\212\250\346\200\201\351\223\276\346\216\245/index.html" "b/2023/09/18/\351\235\231\346\200\201\351\223\276\346\216\245\344\270\216\345\212\250\346\200\201\351\223\276\346\216\245/index.html" index 085310f4..9fefcb69 100644 --- "a/2023/09/18/\351\235\231\346\200\201\351\223\276\346\216\245\344\270\216\345\212\250\346\200\201\351\223\276\346\216\245/index.html" +++ "b/2023/09/18/\351\235\231\346\200\201\351\223\276\346\216\245\344\270\216\345\212\250\346\200\201\351\223\276\346\216\245/index.html" @@ -42,7 +42,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

            链接、装载与运行库

            -
            books
            +};

            链接、装载与运行库

            -
            books

            此为《程序员的自我修养：链接、装载与库》(俞甲子,石凡,潘爱民)的看书总结。

            链接前与装载

            链接前的编译阶段可以生成.o文件，.o文件是ELF文件，里面含有段表、符号表、bss段、common段等链接辅助段。

            diff --git "a/2023/09/27/\350\256\260\345\275\225\344\270\200\346\254\241vm\346\211\251\345\256\271/index.html" "b/2023/09/27/\350\256\260\345\275\225\344\270\200\346\254\241vm\346\211\251\345\256\271/index.html" index d08edaa2..408e9a50 100644 --- "a/2023/09/27/\350\256\260\345\275\225\344\270\200\346\254\241vm\346\211\251\345\256\271/index.html" +++ "b/2023/09/27/\350\256\260\345\275\225\344\270\200\346\254\241vm\346\211\251\345\256\271/index.html" @@ -38,7 +38,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

            记录一次vm扩容

            -

            扩容

            容量寄，但是df -h发现这次好像是不大一样的：

            +};

            记录一次vm扩容

            -

            扩容

            容量寄，但是df -h发现这次好像是不大一样的：

            image-20230927191332920

            查了一下，原来这是逻辑卷管理（LVM，Logical Volume Manger）。

            diff --git "a/2023/10/06/\345\255\230\345\202\250\347\256\200\345\215\225\345\205\245\351\227\250/index.html" "b/2023/10/06/\345\255\230\345\202\250\347\256\200\345\215\225\345\205\245\351\227\250/index.html" index 7019b732..a7467f3f 100644 --- "a/2023/10/06/\345\255\230\345\202\250\347\256\200\345\215\225\345\205\245\351\227\250/index.html" +++ "b/2023/10/06/\345\255\230\345\202\250\347\256\200\345\215\225\345\205\245\351\227\250/index.html" @@ -60,7 +60,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

            存储简单入门

            books
            +};

            存储简单入门

            books

            此为《信息存储与管理（第二版）：数字信息的存储、管理和保护》的看书总结，相当于是对存储技术的一个简单的名词入门。

            本书大致可以分为三部分：存储系统，存储网络技术，备份、归档与复制。

            diff --git "a/2023/10/06/\347\275\221\347\273\234\346\230\257\346\200\216\346\240\267\350\277\236\346\216\245\347\232\204/index.html" "b/2023/10/06/\347\275\221\347\273\234\346\230\257\346\200\216\346\240\267\350\277\236\346\216\245\347\232\204/index.html" index f86bf333..52f90d28 100644 --- "a/2023/10/06/\347\275\221\347\273\234\346\230\257\346\200\216\346\240\267\350\277\236\346\216\245\347\232\204/index.html" +++ "b/2023/10/06/\347\275\221\347\273\234\346\230\257\346\200\216\346\240\267\350\277\236\346\216\245\347\232\204/index.html" @@ -42,7 +42,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

            网络是怎样连接的

            -
            books
            +};

            网络是怎样连接的

            -
            books

            此为《信息存储与管理（第二版）：数字信息的存储、管理和保护》的看书总结，相当于是对存储技术的一个简单的名词入门。

            浏览器生成消息

            本章节我印象最深的还是以前就不大了解的DNS，今天看到书的描写真有种豁然开朗的感觉。

            diff --git a/2023/10/07/git/index.html b/2023/10/07/git/index.html index fa37cdde..0e218675 100644 --- a/2023/10/07/git/index.html +++ b/2023/10/07/git/index.html @@ -40,7 +40,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

            git使用记录

            -
            +};

            git使用记录

            -

            记录一些git的原理学习，以及工作学习中遇到的一些git的操作问题。

            操作

            pull request

              diff --git "a/2023/10/12/rtt\347\241\254\344\273\266\347\216\257\345\242\203\346\220\255\345\273\272/index.html" "b/2023/10/12/rtt\347\241\254\344\273\266\347\216\257\345\242\203\346\220\255\345\273\272/index.html" index 22194647..55156d79 100644 --- "a/2023/10/12/rtt\347\241\254\344\273\266\347\216\257\345\242\203\346\220\255\345\273\272/index.html" +++ "b/2023/10/12/rtt\347\241\254\344\273\266\347\216\257\345\242\203\346\220\255\345\273\272/index.html" @@ -40,7 +40,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

              rtt硬件环境搭建

              -

              SDK/内核编译

              编译内核和sdk时到没有太大问题，都能靠gpt or 修改menuconfig解决。比较棘手的果然还是只能靠自己摸索硬件hhh

              +};

              rtt硬件环境搭建

              -

              SDK/内核编译

              编译内核和sdk时到没有太大问题，都能靠gpt or 修改menuconfig解决。比较棘手的果然还是只能靠自己摸索硬件hhh

              烧录

              这个也是狠狠折磨了我许久，gpt也一直满嘴跑火车，毕竟一开始串口连错了所以一直以为自己是烧录没对，整了半天【而且还是正确的操作反反复复尝试……仿佛坐牢】。不过这其中也学到了挺多。

              f2753b5e6a40f9fea328223b197ede3

              具体要做的是：

              diff --git "a/2023/10/12/\345\220\204\347\247\215\351\205\215\347\216\257\345\242\203\344\270\255\351\201\207\345\210\260\347\232\204\351\227\256\351\242\230/index.html" "b/2023/10/12/\345\220\204\347\247\215\351\205\215\347\216\257\345\242\203\344\270\255\351\201\207\345\210\260\347\232\204\351\227\256\351\242\230/index.html" index b9e6cd15..b013df51 100644 --- "a/2023/10/12/\345\220\204\347\247\215\351\205\215\347\216\257\345\242\203\344\270\255\351\201\207\345\210\260\347\232\204\351\227\256\351\242\230/index.html" +++ "b/2023/10/12/\345\220\204\347\247\215\351\205\215\347\216\257\345\242\203\344\270\255\351\201\207\345\210\260\347\232\204\351\227\256\351\242\230/index.html" @@ -8,15 +8,15 @@ + - + - +

              各种配环境中遇到的问题

              记录一次vm扩容

              -

              开发中遇到的链接小问题

              -

              rtt硬件环境搭建

              +};
              © 2019 – 2023 修年
              由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
              \ No newline at end of file diff --git a/2023/10/19/open-source-9.19-10.19/index.html b/2023/10/19/open-source-9.19-10.19/index.html index 10a8f301..d83e5290 100644 --- a/2023/10/19/open-source-9.19-10.19/index.html +++ b/2023/10/19/open-source-9.19-10.19/index.html @@ -45,7 +45,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

              开源的第一个月

              -
              mylife
              +};

              开源的第一个月

              -
              mylife

              其实是9.10就开始了，但9.19才办理入职所以少算了几天xxxx不然这不显得我菜hh

              引言

              也许有许多programer与我一样，在初次接触到“开源”这个概念时，便对其产生了无限的向往。千万人通过共同的事业联结在一起，为了行业的进步不求回报地压缩自己的时间，贡献出自己的一份力，这是何等的浪漫。再加上听了无数遍的Linux发展历程故事，对“开源”我是愈发地憧憬。

              diff --git a/2023/10/27/driver_develop/index.html b/2023/10/27/driver_develop/index.html index a19cf0f5..65b2e2e5 100644 --- a/2023/10/27/driver_develop/index.html +++ b/2023/10/27/driver_develop/index.html @@ -41,7 +41,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

              驱动开发小记

              intern

              此为PLCT Lab BJ71实习内容，我的工作是为RT-Thread完善Milk-v Duo开发板支持。

              +};

              驱动开发小记

              intern

              此为PLCT Lab BJ71实习内容，我的工作是为RT-Thread完善Milk-v Duo开发板支持。

              GPIO

              感受之前已经详细记录过了，在此便不再赘述。这里只写一些开发流程和最终代码框架展示。

              开发流程

              10.13—概述

              是什么

              首先了解一下gpio是什么。

              芯片上的引脚一般分为 4 类：电源、时钟、控制与 I/O，I/O 口在使用模式上又分为 General Purpose Input Output（通用输入 / 输出），简称 GPIO，与功能复用 I/O（如 SPI/I2C/UART 等）。

              diff --git a/2023/11/18/compilation_principle/index.html b/2023/11/18/compilation_principle/index.html index 175fcd2e..143a5e4e 100644 --- a/2023/11/18/compilation_principle/index.html +++ b/2023/11/18/compilation_principle/index.html @@ -460,7 +460,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

              编译原理

              第一章 绪论

              概述

              picture

              +};

              编译原理

              第一章 绪论

              概述

              picture

              可重定位的代码通过linker和loader重定位这部分内容就是在之前那本书学过的。

              picture

              从中，我们也可以看到有语法分析、中间代码的影子。

              diff --git a/2023/11/26/cryptography/index.html b/2023/11/26/cryptography/index.html index 2bf1cf40..80c5f1a0 100644 --- a/2023/11/26/cryptography/index.html +++ b/2023/11/26/cryptography/index.html @@ -401,7 +401,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

              密码学基础

              +};

              密码学基础

              学习目的：顺利过考试，以及获取基本的密码学知识，数学原理不重要

              第一章 概述

              image

              diff --git a/2023/11/26/database/index.html b/2023/11/26/database/index.html index 5002b6e7..8f2a0a63 100644 --- a/2023/11/26/database/index.html +++ b/2023/11/26/database/index.html @@ -464,7 +464,7 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

              数据库原理

              第一章 绪论

              可以看到，选择题主要考了一下几个概念：

              +};

              数据库原理

              第一章 绪论

              可以看到，选择题主要考了一下几个概念：

              1. 基于文件系统的管理方法

                数据存储于文件中，由应用程序经过文件系统进行管理。

                diff --git a/about/index.html b/about/index.html index 368403fc..58e929d8 100644 --- a/about/index.html +++ b/about/index.html @@ -24,23 +24,7 @@ const setting = localStorage.getItem('darken-mode') || 'auto' if (setting === 'dark' || (prefersDark && setting !== 'light')) document.documentElement.classList.toggle('dark', true) -})() - - live2d-demo - - - - - - - - - - - - -

                about

                修年

                  +};

                  about

                  © 2019 – 2023 修年
                  由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                  -
                  - - \ No newline at end of file +
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2022/10/index.html b/archives/2022/10/index.html index 297dcec0..e8e8e475 100644 --- a/archives/2022/10/index.html +++ b/archives/2022/10/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2022/11/index.html b/archives/2022/11/index.html index 7c4e4332..11d1dd41 100644 --- a/archives/2022/11/index.html +++ b/archives/2022/11/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2022

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2022

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2022/12/index.html b/archives/2022/12/index.html index b8679e29..bb0f532b 100644 --- a/archives/2022/12/index.html +++ b/archives/2022/12/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2022

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2022

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2022/index.html b/archives/2022/index.html index faaa7b9a..016195d0 100644 --- a/archives/2022/index.html +++ b/archives/2022/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/01/index.html b/archives/2023/01/index.html index 6ff17f1f..b55e39f0 100644 --- a/archives/2023/01/index.html +++ b/archives/2023/01/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/02/index.html b/archives/2023/02/index.html index 7f47b91d..f24c088b 100644 --- a/archives/2023/02/index.html +++ b/archives/2023/02/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/03/index.html b/archives/2023/03/index.html index bf81981f..82a8e87e 100644 --- a/archives/2023/03/index.html +++ b/archives/2023/03/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/06/index.html b/archives/2023/06/index.html index 735b726a..f275c612 100644 --- a/archives/2023/06/index.html +++ b/archives/2023/06/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/08/index.html b/archives/2023/08/index.html index efb45434..783b3b43 100644 --- a/archives/2023/08/index.html +++ b/archives/2023/08/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/09/index.html b/archives/2023/09/index.html index 7e5b7aaf..53437d89 100644 --- a/archives/2023/09/index.html +++ b/archives/2023/09/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/10/index.html b/archives/2023/10/index.html index 61b45a4a..dab95d1e 100644 --- a/archives/2023/10/index.html +++ b/archives/2023/10/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/11/index.html b/archives/2023/11/index.html index ac267d83..b3d7d573 100644 --- a/archives/2023/11/index.html +++ b/archives/2023/11/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志
                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志
                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/index.html b/archives/2023/index.html index 75a4d18d..5333d75b 100644 --- a/archives/2023/index.html +++ b/archives/2023/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/page/2/index.html b/archives/2023/page/2/index.html index b1ae0696..7228de9e 100644 --- a/archives/2023/page/2/index.html +++ b/archives/2023/page/2/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/page/3/index.html b/archives/2023/page/3/index.html index e5028139..42af1a6a 100644 --- a/archives/2023/page/3/index.html +++ b/archives/2023/page/3/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/page/4/index.html b/archives/2023/page/4/index.html index 9ba457f2..ec9402ac 100644 --- a/archives/2023/page/4/index.html +++ b/archives/2023/page/4/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/2023/page/5/index.html b/archives/2023/page/5/index.html new file mode 100644 index 00000000..ae655a1e --- /dev/null +++ b/archives/2023/page/5/index.html @@ -0,0 +1,34 @@ +归档 | 修年 + + + + + +

                归档

                共计 46 篇日志

                2023

                没有更多的黑历史了_(:з」∠)_
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/index.html b/archives/index.html index 4179e227..97719901 100644 --- a/archives/index.html +++ b/archives/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/page/2/index.html b/archives/page/2/index.html index f3e766d7..c00906f1 100644 --- a/archives/page/2/index.html +++ b/archives/page/2/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/page/3/index.html b/archives/page/3/index.html index edbc2ec7..ae779e2d 100644 --- a/archives/page/3/index.html +++ b/archives/page/3/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/page/4/index.html b/archives/page/4/index.html index ff26e34f..d4566330 100644 --- a/archives/page/4/index.html +++ b/archives/page/4/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

                归档

                共计 45 篇日志

                2023

                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};

                归档

                共计 46 篇日志

                2023

                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/archives/page/5/index.html b/archives/page/5/index.html index 1e98f72c..a0c4446c 100644 --- a/archives/page/5/index.html +++ b/archives/page/5/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/index.html b/index.html index d00dcf97..a87df51c 100644 --- a/index.html +++ b/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
                喜欢您来！
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file +};
                喜欢您来！
                © 2019 – 2023 修年
                由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
                \ No newline at end of file diff --git a/search.xml b/search.xml index dfac7159..edbe77ec 100644 --- a/search.xml +++ b/search.xml @@ -413,20 +413,32 @@

                我服了。

                不过可能有更好的解决方法？可惜我c++水平不大够，所以暂时想不出来了。

                +

                Task4 Remove

                感想

                由于有了insert的沉淀，remove的实现便相较不大困难了，写完代码到通过内置的delete测试只花了一天的时间。

                +

                思路

                Task5 Concurrency

                感想

                这位可更是重量级，足足花了我三天的时间。

                +
                auto BufferPoolManager::FetchPage(page_id_t page_id, [[maybe_unused]] AccessType access_type) -> Page * {
                  latch_.lock();

                  auto it = page_table_.find(page_id);
                  if (it != page_table_.end()) {
                    frame_id_t fid = it->second;

                    pages_latch_[fid].lock();
                    replacer_->RecordAccess(fid, access_type);
                    replacer_->SetEvictable(fid, false);
                    latch_.unlock();

                    pages_[fid].pin_count_++;

                    auto res = &(pages_[fid]);

                    pages_latch_[fid].unlock();

                    return res;
                  }
                  
                  if (free_list_.empty()) {
                    frame_id_t fid;
                    if (!replacer_->Evict(&fid)) {
                      latch_.unlock();
                      return nullptr;
                    }
                    
                    pages_latch_[fid].lock();
                    page_table_.erase(page_table_.find(pages_[fid].GetPageId()));
                    page_table_.insert(std::make_pair(page_id, fid));

                    replacer_->RecordAccess(fid, access_type);
                    replacer_->SetEvictable(fid, false);

                    if (pages_[fid].IsDirty()) {
                      disk_manager_->WritePage(pages_[fid].GetPageId(), pages_[fid].GetData());
                    }
                    latch_.unlock();

                    Page *res = &(pages_[fid]);
                    res->ResetMemory();
                    // read from disk
                    disk_manager_->ReadPage(page_id, res->GetData());

                    res->is_dirty_ = false;
                    res->page_id_ = page_id;
                    res->pin_count_ = 1;

                    pages_latch_[fid].unlock();
                    return res;
                  }
                }
                + + + +

                这个并发问题是这样的，我原来是先evict，然后再写回，写回过程中磁盘没加bpm锁。这就会出现这样一个情况：

                +

                一个page被进程A evict，进程A还没执行写回的时候这个page又被进程B捡回来了，因为还没写入所以磁盘空空如也。这时候pages_latch_这个细粒度锁不能防范这种情况，是因为此时这个page对应的container不是同一个，所以fid不同，细粒度锁不同导致寄。

                +

                解决方法是要么写的时候持有bpm锁，但是这太太慢了。另一个就是干脆直接在unpin的时候不带bpm锁顺便写回了。

                +

                https://zhuanlan.zhihu.com/p/661208232

                +

                image-20231203165014734

                +

                这种情况我的做法是持有header page的读锁

                +

                image-20231203181652821

                +

                现在是这样，root即将分裂，两个进程同时插入一个key。一个进程A先得到header page的读锁和root的写锁，另一个B只得到header page读锁，等待写锁。

                +

                此时，A缩小了旧root结点，造了新结点，把root drop掉，再去获取header page的写锁；B获取了root的写锁，检查到它并非max size，插入，从而导致错误。

                +

                这时候修改header page和root的锁释放顺序会导致死锁，所以很遗憾我们只能先拿着header page的写锁，检测到无需分裂root再拿读锁了。

                +

                目前应该是算把insert的锁整好了，接下来修下delete的bug和锁应该也就差不多了

                +

                牛逼，接下来就只剩个remove的并发了

                +

                image-20231204001136531

                +

                image-20231204163052528

                +

                我服了。。。。。。。。。

                +

                image-20231204170030245

                +

                好像还是有点垃圾乐，算了先这样吧

                +

                out

                ]]> - - CMU15445 - /2023/03/13/cmu15445/ - -

                实验官网

                -

                代码

                -
              -

              Project0 C++ Primer

              Project1 Buffer Pool

              Project2 B+Tree Index

              ]]> - - labs - - Project1 Buffer Pool /2023/03/13/cmu15445$lab1/ @@ -662,5559 +674,5730 @@ ]]> - 编译原理 - /2023/11/18/compilation_principle/ - 第一章 绪论

              概述

              picture

              -

              可重定位的代码通过linker和loader重定位这部分内容就是在之前那本书学过的。

              -

              picture

              -

              从中，我们也可以看到有语法分析、中间代码的影子。

              -

              picture

              -

              词法分析相当于通过DFA NFA捉出各类符号，形成简单的符号表和token list；语法分析相当于对token list组词成句，判断该句子是否符合语言规则；语义分析相当于对词句进行类型判断和中间代码的生成，获得基本语义。

              -

              编译程序总体结构

              picture

              -

              picture

              -

              语法制导翻译：语义分析和中间代码生成集成到语法分析中

              -

              词法分析

              将结果转化为token的形式。

              -

              picture

              -

              picture

              -

              语法分析

              从token list中识别出各个短语，并且构造语法分析树。

              -

              picture

              -

              picture

              -

              相当于是通过文法来进行归约（自底向上的语法分析），从而判断给定句子是否合法。

              -

              语义分析

              picture

              -
                -
              1. 收集标识符的属性信息，并将其存入符号表
                2. -
              -

              picture

              -

              种属就是比如是函数还是数组之类的。

              -

              picture

              -
                -
              1. 语义检查
                2. -
              -

              picture

              -
                -

              1. 静态绑定

                -

                包括绑定代码相对地址（子程序）、数据相对地址（变量）

                -
                2. -
              -

              中间代码生成

              picture

              -

              picture

              -

              波兰也就是前序遍历二叉树（中左右），逆波兰也就是后序遍历二叉树（左右中）

              -

              picture

              -

              代码优化

              picture

              -
                -

              1. 无关机器

                -

                picture

                -
                2. -

              2. 有关机器

                -

                picture

                -
                3. -
              -

              目标代码生成

              picture

              -

              表格管理

              这也挺好理解，相当于管理符号表吧。

              -

              picture

              -

              错误处理

              picture

              -

              编译程序的组织

              了解了编译程序的基本结构，那么我们就可以想想该怎么实现这个编译器了。

              -

              最直观的想法是，我们有几个步骤就对代码进行多少次扫描：

              -
                -
              1. 首先扫一次，进行词法分析，将所有标识符写入到符号表中，同时进行语法分析，看看有没有错，如果出错了就转到错误处理，没有的话就进行语义分析；（三合一）
                2. -
              2. 然后再针对得出来的语义分析树进行中间代码生成；
                3. -
              3. 再对得出来的中间代码进行代码优化，最后对优化出来的代码进行翻译处理。（二合一）
                4. -
              -

              picture

              -

              picture

              -

              picture

              -

              实现编译器

              picture

              -

              T形图

              picture

              -

              自展

              picture

              -

              也就是说：

              -
                -
              1. P0是汇编语言，可以用来编译C语言子集；（P0：汇编语言，C子集→汇编）
                2. -
              2. P1是机器语言，可以用来把汇编语言翻译为机器语言；（P1：机器语言，汇编→机器）
                3. -
              3. 所以我们就得到了P2，也即一个可以用来编译C语言子集的机器语言程序；（P2：机器语言，C子集→汇编）
                4. -
              4. 然后我们就可以用C语言子集来写C语言编译程序P3，再用P2翻译P3，就可以得到工具P4。（P4：汇编语言，C→汇编）
                5. -
              -

              image-20230912153726618

              -

              帅的。

              -

              移植

              picture

              -

              picture

              -

              本机编译器的利用

              picture

              -

              编译程序的自动生成

              这大概是描述了我们到时候会怎么实现这两个阶段代码。

              -

              不过确实，词法分析可以看作是正则匹配，语法分析可以看作是产生式。

              -

              picture

              -

              picture

              -

              第二章 文法等概念

              image-20231111160656018

              -

              基本概念

                -

              1. 字母表

                -

                picture

                -

                picture

                -

                picture

                -

                picture

                -
                2. -

              2. 串

                -

                克林闭包中的每一个元素都称为是字母表Σ上的一个串

                -

                picture

                -

                picture

                -

                picture

                -
                3. -
              -

              文法

              picture

              -

              如果文法用于描述单词，基本符号就是字母；用于描述句子，基本符号就是单词

              -
                -

              1. 文法的形式化定义

                -

                picture

                -

                picture

                -

                由于可以从它们推出其他语法成分，故而称之为非终结符

                -

                picture

                -

                picture

                -

                还真是最大的语法成分

                -
                2. -

              2. 产生式

                -

                picture

                -
                3. -

              3. 符号约定

                -

                picture

                -

                picture

                -

                picture

                -

                文法符号串应该就是指既包含终结符也包含非终结符的，也可能是空串的串。

                -

                注意终结符号串也包括空串。

                -
                4. -
              -

              语言

              picture

              -

              这部分就是要讲怎么看一个串是否满足文法规则，那么我们就需要先从什么样的串是满足文法规则的串开始说起，也即引入“语言”的概念。

              -
                -

              1. 推导与归约

                -

                picture

                -

                然后也分为最左推导和最右推导，对应最右归约和最左归约。

                -

                picture

                -

                故而，如果从开始符号可以推导（派生）出该句子，或者从该句子可以归约到开始符号，那么该句子就是该语言的句子。

                -
                2. -

              2. 句子与句型

                -

                picture

                -

                句型就是可以有非终结符，句子就是只能有终结符

                -
                3. -

              3. 语言

                -

                picture

                -

                文法解决了无穷语言的有穷表示问题。

                -

                picture

                -

                picture

                -

                emm，就是好像没有∩运算

                -

                picture

                -

                有正则那味了

                -
                4. -
              -

              乔姆斯基文法体系

              picture

              -

              picture

              + CMU15445 + /2023/03/13/cmu15445/ + +

              实验官网

              +

              代码

              +
              +

              Project0 C++ Primer

              Project1 Buffer Pool

              Project2 B+Tree Index

              ]]> + + labs + + + + Java并发编程实战 + /2022/11/06/Java%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B%E5%AE%9E%E6%88%98/ + +

              idea 替换注释正则表达式/\*{1,2}[\s\S]*?\*/

              +
            +

            第一章 简介

            线程的作用

            + +

            这一段写得很好，非常易懂地概括了什么是“多线程把异步转化为同步”：把异步中的不同操作分解为一个个独立的同类型操作，然后只需实现这些相较简单的同类型操作，再异步地把它们调度起来就行。线程正是把复杂的异步工作流分解成了一组简单的同步工作流。

            +

            线程无处不在

            如果一个模块在代码中引入了并发性，那么它所有的代码路径【调用链】都得是并发的。

            + + +

            最后一句话很关键，“把线程安全性封装在共享对象内部”

            + + + + + + + + +

            这个不同于上面的方法：将共享对象包装为线程安全的。它是要求了这些共享对象仅能在事件线程中运行，这样来保证线程安全性。

            +

            第二章 线程安全性

            **线程安全的核心就是对状态的访问和操作进行管理**，特别是对那些共享（shared）的、可变（mutable）的状态。关于本句话，其中几点将在下面一一细说：

              -

            1. 0型

              -

              picture

              -
              2. -

            2. 1型

              -

              picture

              -

              之所以是上下文有关，是因为只有A的上下文为a1和a2时才能替换为β【666666，第一次懂】

              -

              CSG不包含空产生式。

              +

            3. 状态

              +

              状态是指存储在状态变量里的数据，如成员变量、静态域等等等。对象的状态还可能包括其他依赖对象的域，如HashMap的状态包括Map.Entry的状态。

              4. -

            4. 2型

              -

              picture

              -

              左部只能是一个非终结符。

              +

            5. 共享和可变

              +

              共享意味着变量可以由多个线程同时访问，可变意味着变量的值在生命周期可发生变化

              6. -

            6. 3型

              -

              picture

              -

              产生式右部最多只有一个非终结符，且要在同一侧

              -

              picture

              -

              看起来还能转（是的，自动机教的已经全忘了（））

              +

            7. 是否需要线程安全

              +

              取决于它是否被多个线程访问。比如说，如果一个局部变量仅在某个函数体中同时只被一个线程访问，那么它就不需要线程安全，不需要同步机制。

            -

            CFG

            正则文法用于判定大多数标识，但是无法判断句子构造。

            -
              -
            1. 分析树
              2. -
            -

            picture

            -

            picture

            -

            也就是说，每个句型都有自己对应的分析树。那么接下来就介绍什么是句型的短语

            -

            picture

            -

            意思就是直接短语是高度为2的子树的边缘，直接短语一定是某个产生式的右部，但是产生式右部不一定是给定句型的直接短语（因为有可能给定句型的推导用不到那个产生式）

            -
              -
            1. 二义性文法
              2. -
            -

            picture

            -

            通过自定义规则消除歧义

            -

            picture

            -

            第三章 词法分析

            正则语言

            正则表达式

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            最后两条值得注意

            -

            picture

            -

            正则定义

            picture

            -

            picture

            -

            picture

            -

            有穷自动机

            概述

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            所以真正的终止是输入带到末尾并且指向终态

            -

            分类

            DFA

            picture

            -

            NFA

            picture

            -

            NFA与DFA转化

            picture

            -

            picture

            -

            e-NFA

            picture

            -

            e-NFA与NFA转化

            picture

            -

            词法分析相关

            识别单词的DFA

            数字

            picture

            -

            picture

            -

            66666，还能这么捏起来

            -

            picture

            -

            注释

            picture

            -

            识别token

            picture

            -

            关键字是在识别完标识符之后进行查表识别的

            -

            scanner的错误处理

            说实话没太看懂

            -

            picture

            -

            picture

            -

            picture

            -

            第四章 语法分析

            根据给定文法，识别各类短语，构造分析树。所以关键就是怎么构建分析树

            -

            自顶向下LL(1)

            概念

            可以看做是推导（派生）的过程。
            如果同一非终结符的各个产生式的可选集互不相交，就可以进行确定的自顶向下分析：

            -

            picture

            -

            这两个分析也是我们的分析方法需要解决的。

            -

            picture

            -

            picture

            -

            也就是说，在自顶向下分析时，采用的是最左推导；在自底向上分析时，最左归约和最右推导才是正道！

            -

            通用算法

            例子

            picture

            -

            大概流程应该是，有产生式就展开，然后当产生式右部有多个候选式的时候再根据输入决定。

            -

            递归下降分析

            picture

            -

            如果有多个以输入终结符打头的右部候选，那就需要逐一尝试错了再回溯，因而效率较低。

            -

            预测分析

            picture

            -

            66666，这其实就可以类似于动态规划了吧

            -

            【感觉这里也能窥见一些算法设计的思想。

            -

            仔细想想，我们在引入动态规划时，也是这个说辞：对于一些回溯问题，回溯效率太低，所以我们就可以提前通过动态规划的思想构造一个状态转移表，到时候只需从零开始按照表进行状态转移即可。

            -

            仔细想想，这不就是这里这个预测分析提出的思想吗！真的牛逼，6666

            -

            我记得KMP算法一开始也是这个思想，感觉十分神奇】

            -

            文法转换

            什么情况需要改造

            picture

            -

            picture

            -

            消除左递归

            直接左递归

            picture

            -

            这个左递归及其消除方法解释得很形象

            -

            picture

            -
            间接左递归

            picture

            -

            先转化为直接左递归

            -

            消除回溯

            picture

            -

            666666这个解读可以，感觉这个就跟：

            -

            image-20231111224823978

            -

            这个“向前看”有异曲同工之妙了。

            -

            LL(1)文法

            LL(1)文法才能使用预测分析技术。判断是否是LL文法就得看具有相同左部的产生式的select集是否相交。

            -

            S_文法

            picture

            -

            S文法不包含空产生式

            -

            q_文法

            picture

            -

            也就是说，B的Follow集为{b,c}，只有当输入符号为b/c时才能使用空产生式。

            -

            picture

            -

            first集和follow集不交。

            -

            这下总算知道这两个是什么玩意了。也就是这样：

            -
              -

            1. 输入符号与B的First集元素匹配

              -

              直接用那个产生式

              -
              2. -

            2. 否则，看输入符号是否与Follow集元素匹配

              -
                -

              1. 是

                -

                若B无空产生式，报错；否则，使用B的空产生式（相当于消了一个符号但不变输入带指针）

                -
                2. -

              2. 否

                -

                报错

                -
                3. -
              -
              3. -
            -

            picture

            -

            这个感觉跟first集有点像，相当于是右部只能以终结符开始的形式，所以下面的LL文法会增强定义。

            -

            当该非终结符对应的所有SELECT集不相交，就可以进行确定的自顶向下语法分析。这个思想也将贯穿下面的LL文法

            -

            picture

            -

            LL(1)文法

            picture

            -

            picture

            -

            最后，如果同一非终结符的各个产生式的可选集互不相交，就可以进行确定的自顶向下分析：

            -

            picture

            -

            picture

            -

            总结

            这几个推理下来，真是让人感觉酣畅淋漓！

            -

            确定的自顶向下分析的核心就是，给定一个当前所处的非终结符和一个输入字符[E, a]，我们可以唯一确定一个产生式P用于构建语法分析树。

            -

            picture

            -

            也即，同一个非终结符的所有产生式的SELECT集必须是不交的【才能确保选择产生式的唯一性】。因而，问题就转化为了如何让SELECT集不交。

            -

            我们需要对空产生式和正常产生式的SELECT集计算做一个分类讨论。

            -
              -

            1. 空产生式

              -

              由于可以推导出空，相当于把该符号啥了去读下一个符号，因此我们的问题就转化为输入字符a是否能够跟该符号后面紧跟着的字符相匹配。而紧跟着的字符集我们将其成为FOLLOW集，如果a在follow集中，那么就可以接受，否则不行。

              -

              对于LL(1)文法，相当于是进一步处理了简介推出空的串：

              -

              ​ 由于α串->*空，则α串必定仅由非终结符构成。那么它能推导出的所有可能即为SELECT集。故而为First(α)∪Follow(α)

              -
              2. -

            2. 非空产生式

              -

              很简单，就是其First集。

              -
              3. -
            -

            故而，只需要让这些计算出来的First集合不交，就能进行确定的自顶向下语法分析，构造确定的语法分析树。不得不说真的牛逼。

            -

            感觉其“预测分析”的“预测”主要体现在对空产生式的处理上。

            -

            总算懂了为什么LL(1)能够解决这个回溯效率太低的问题了，太牛逼。不过问题是怎么转化为LL(1)呢（）上面的消除回溯和左递归只是一部分而已吧。

            -

            预测分析法

            picture

            -

            这个消除二义性是啥玩意？二轮的时候看看PPT怎么讲的

            -

            递归的预测分析

            picture

            -

            picture

            -

            66666，它这个计算follow集的方法就很直观

            -

            declistn有个空产生式，那么我们看得看②，而②的declistn排在最后，也就是说declistn的follow集就是其左部declist的follow集【6666】，所以我们看①，可以发现declist后面为:。

            -

            picture

            -

            如果是终结符，就直接==比较；非终结符，就把token传入到其对应的过程。

            -

            非递归的预测分析

            picture

            -

            66666

            -

            感觉从中又能窥见动态规划的同样思想了。下推自动机其实感觉就像是递归思想（或者说顺序模拟递归，因为它甚至有一个栈，出栈相当于达成条件递归return），动态规划的话可能有点像是把每个不同状态以及不同状态时的栈顶元素整成一个2x2的表，所以感觉思想类似。

            -

            picture

            -

            注意，是栈顶跟输入一样都是非终结符才会移动指针和出栈

            -

            值得注意的是，输出的产生式序列就对应了一个最左推导。

            -

            picture

            -

            picture

            -

            错误处理

            picture

            -

            picture

            -

            picture

            -

            其实也挺有道理，栈顶是非终结符，但是输入是它的follow集，那我们自然而然可以想到把这b赶跑，看看下面有没有真的它的follow集在嗷嗷待哺。

            -

            自底向上语法分析

            概述

            正确识别句柄是一个关键问题。

            -

            句柄：当前句型的最左直接短语。【最左、子树高度为2】

            -

            自底向上

            picture

            -

            picture

            -

            每次句柄形成就将它归约，因而保证一直是最左归约（recall that，句柄一定是某个产生式的右部，并且每次最左句柄一旦形成就归约）

            -

            picture

            -

            正如上面的LL分析，每次推导要选择哪个产生式是一个问题；这里的LR分析，每次归约要选择哪个产生式，也即正确识别句柄，也是一个关键问题。

            -

            所以，我们应该把句柄定义为当前句型的最左直接短语。

            -

            如下图所示，左下角是当前句型（画红线部分）的语法分析树，红字为在栈中的部分，蓝字为输入符号串剩余部分。当前句型的直接短语（相当于根节点的高度为二的子树，或者说子树前两层）有两个，一个是以<IDS>为根节点的<IDS> , iB，另一个是<T>为根节点的real。

            -

            picture

            -

            而LR分析技术的核心就是正确地识别了句柄。

            -

            LR文法

            picture

            -

            也就是说LR技术就是用来识别句柄的，识别完了句柄就可以构建类似自顶向下的预测分析那样的自动机表来进行转移。

            -

            picture

            -
              -

            1. 移进状态

              -

              ·后为终结符

              -
              2. -

            2. 待约状态

              -

              ·后为非终结符

              -
              3. -

            3. 归约状态

              -

              ·后为空

              -
              4. -
            -

            picture

            -

            picture

            -

            以前感觉一直很难理解GOTO表的作用，现在感觉稍微明白了点了，你想想，归约之后的那个结果是不是有可能是另一个产生式的右部成分之一，也即一个新的句柄？并且这个也是由你栈顶刚归约好的那个左部和下面的输入符号决定的。那么你自然而然需要切换一下当前状态，以便之后遇到那个产生式的时候能发现到了。

            -

            那么，剩下的问题就是如何构造LR分析表了：

            -

            picture

            -

            算符分析

            picture

            -

            也就是它会整一个终结符之间的优先级关系。。。

            -

            picture

            -

            picture

            -

            也就是说：

            -
              -

            1. a=b

              -

              相邻

              -
              2. -

            2. a<b

              -

              也即在A->aB时，b在FIRSTOP(B)中（理解一下，这个First指在前面。。。）

              -
              3. -

            3. a>b

              -

              也即在A->Bb时，a在LASTOP(B)中（理解一下，这个LAST指在后面。。。）

              -
              4. -
            -

            picture

            -

            picture

            -

            我服了

            -

            picture

            -

            picture

            -

            好像#这个固定都是，横的为左，竖的为右

            -

            picture

            -

            根据优先关系来判断移入和归约

            -

            picture

            -

            LR分析

            LR(0)

            每个分析方法其实都对应着一种构造LR分析表的方法。
            LR(0)通过构造规范LR0项集族，从而构造LR分析表，从而构造LR0 DFA来最终进行语法分析。

            -

            每一个项目都对应着句柄识别的一个状态。

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            而肯定不可能整那么多个状态，所以我们需要进行状态合并。（这样也就很容易理解LR的状态族构建了。）

            -

            picture

            -

            它这里也很直观解释了为什么点遇到非终结符就需要加入其对应的所有产生式，因为在等待该非终结符就相当于在等待它的对应产生式的第一个字母。

            -

            picture

            -

            picture

            -

            上面这东西就是这个所谓的规范LR(0)项集族了。

            -

            picture

            -

            picture

            -

            但是会产生移进归约冲突：

            -

            picture

            -

            picture

            -

            还有归约归约冲突：

            -

            picture

            -

            所以我们就把没有冲突的叫LR(0)文法。

            -

            image-20231112165527201

            -

            感觉上述两个问题都是因为有公共前缀【包括空产生式勉强也能算是这个情况】，导致信息不足无法判断应该怎么做，多读入一个字符（也即LR(1)）应该可以有效解决该问题。

            -

            SLR分析

            其实本质还是识别句柄问题，也即此时是归约还是移入，得看是不是句柄。故而LR0信息已经不能帮我们识别句柄了。

            -

            picture

            -

            Follow集可以帮助我们判断。由该状态I2可知，输入一个*应该跳转到I7。如果在I2把T归约为一个E，由Follow集可知E后面不可能有一个*，也就说明在这里进行归约是错误的，应该进行移入。

            -

            这种依靠Follow集和下一个符号判断的思想，就会运用在SLR分析中。

            -

            picture

            -

            picture

            -

            picture

            -

            但值得注意的是SLR分析的条件还是相对更严苛，它要求移进项目和归约项目的Follow集不相交，所以它也会产生像下图这样的冲突：

            -

            picture

            -

            LR(1)

            picture

            -

            SLR将子集扩大到了全集，显然进行了概念扩大。

            -

            含义为只有当下一个输入符号是XX时，才能运用这个产生式归约。这个XX是产生式左部非终结符的Follow子集。

            -

            picture

            -

            这玩意只有归约时会用到，这个很显然，毕竟前面提到的LR0的问题就是归约冲突。

            -

            picture

            -

            对了，值得注意的是这个FIRST(βa)，它表示的并不是FIRST(a)∪FIRST(β)，里面的βa应该取连接意，也即，当β为非空时这玩意等于FIRST(β)，当β空时这玩意等于FIRST(a)。

            -

            picture

            -

            刚刚老师对着这个状态转移图进行了一番强大的看图写话操作，我感觉还是十分地牛逼。她从这个图触发，讲述了状态I2为什么不能对R->L进行归约。

            -

            假如我们进行了归约，那么我们就需要弹出状态I2回到I0，压入符号R，I0遇到符号R进入了I3，I3继续归约回到I0，I0遇到符号S到状态I1，但1是接收状态，下一个符号是=不是$，所以错了。

            -

            picture

            -

            picture

            -

            比如说I8和I10就是同心的。左边的那个实际上是LR0项目集，所以这里的心指的是LR0。

            -

            picture

            -

            LALR分析

            然而，LR(1)会导致状态急剧膨胀，影响效率，所以又提出了个LALR分析。

            -

            picture

            -

            picture

            -

            跟前面的SLR对比可以发现，相当于它就是多了个逗号后面的条件。但是这是可以瞎合的吗？不会出啥问题不。。。

            -

            picture

            -

            好吧问题这就来了，LALR可能会产生归约归约冲突。但值得注意的是，它不可能出现归约移入冲突，因为LR1没有这个东西，而LALR只是修改右边的符号，所以也不会有这个。

            -

            picture

            -

            因为LALR实际上是合并了展望符集合，这东西与移进没有关系，所以只会影响归约，不会影响移进。

            -

            picture

            -

            LALR可能会产生归约归约冲突。但值得注意的是，它不可能出现归约移入冲突，因为LR1没有这个东西，而LALR只是修改右边的符号，所以也不会有这个。

            -

            它有可能做多余的归约动作，从而推迟错误的发现。

            -

            形式上与LR1相同；大小上与LR0/SLR相当；分析能力介于SLR和LR1之间；展望集仍为Follow集的子集。

            -

            总结

            感觉一路看下来，思路还是很流畅的。LR0会产生归约移进冲突和归约归约冲突，所以我们在归约时根据下一个符号是在移进符号还是在Follow集中来判断是要归约还是要移进。但是SLR条件严苛，对于那些移进符号集和Follow集有交的不适用，并且这种情况其实很普遍。加之，出于这个motivation：其实不应该用整个Follow集判断，而是应该用其真子集，所以我们开发出来个LR1文法。然后LR1文法虽然效果好但是状态太多了，所以我们再次折中一下，造出来个效果没有那么好但是状态少的LALR文法。

            -

            二义性文法的LR

            picture

            -

            所以我们可以用LR对二义性文法进行分析

            -

            我们可以通过自定义规则来消除二义性文法的归约移入冲突

            -

            picture

            -

            对于状态7，此时输入+ or *会面临归约移入冲突。由于有E->E+E归约式子，可以知道此时栈中为E+E。当输入*，由于*运算优先级更高，所以我们在此时进行移入动作转移到I5；当输入+，由于同运算先执行左结合，所以我们此时可以安全归约。

            -

            对于状态8，由于*运算比+优先级高，且左结合，所以始终进行归约。

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            错误检测

            picture

            -

            picture

            -

            它这个意思大概就是，符号栈和状态栈都一直pop，直到pop到一个状态，GOTO[符号栈顶，状态栈顶]有值【注意，始终保持符号栈元素+1 == 状态栈元素数+1】。然后，一直不断丢弃输入符号，直到输入符号在A的Follow集中。此时，就将GOTO值压入栈中继续分析。

            -

            【这其实也很有道理。如果输入符号在A的Follow集，说明A之后很有可能可以消耗这个输入符号。】

            -

            picture

            -

            picture

            -

            第五章 语义分析

            注意：

            -
              -
            1. 语义翻译包含语义分析和中间代码生成
              2. -
            2. 这笔包含了语法分析、语义分析、中间代码生成
              3. -
            -

            思想：

            -
              -
            1. 通过为文法符号设置语义属性，来表达语义信息
              2. -
            2. 通过与产生式（语法规则）相关联的语义规则来计算符号的语义属性值
              3. -
            -

            也可能是先入为主吧，感觉用实验的方法来理解语义分析比较便利。语义分析相当于定义一连串事件，附加在每个产生式上。当该产生式进行归约的时候，就执行对应的语义事件。而由于执行语义分析时需要的符号在语法分析栈中，所以我们也同样需要维护一个语义分析栈，在移进时也需要进栈。

            -

            SDD/SDT概念

            语义分析一般与语法分析一同实现，这一技术成为语法制导翻译。

            -

            picture

            -

            picture

            -

            picture

            -

            SDD

            picture

            -

            可以回忆一下实验，相当于对每个产生式进行一个switch-case，然后依照产生式的类别和代码规则进行出栈入栈来计算属性值。

            -

            SDT

            picture

            -

            picture

            -

            SDD

            picture

            -

            概念

            一个很简单区分综合属性和继承属性的方法，就是如果定义的是产生式左部的属性，那就是综合属性；右部，那就是继承属性

            -

            综合属性

            picture

            -

            picture

            -

            继承属性

            picture

            -

            picture

            -

            这个东西就是我们实验里写的，副作用也是更新符号表。

            -

            属性文法

            没有副作用的SDD称为属性文法。

            -

            求值顺序

            picture

            -

            而感觉语法分析这个过程的产生式归约顺序就能一定程度上表示了这个求值顺序

            -

            picture

            -
              -
            1. 继承属性放在结点左边，综合属性放在结点右边
              2. -
            2. 如果属性值A依赖于属性值B，那么就有一条从B到A的箭头【B决定A】
              3. -
            3. 对于副作用，我们将其看作一个虚综合属性【注意是综合的，虽然它看起来既由兄弟结点决定也由子节点决定】
              4. -
            4. 可行的求值序列就是拓扑排序
              5. -
            -

            picture

            -

            蛤？这不是你自己规则设计有问题吗，关我屁事

            -

            picture

            -

            其实我还是不大理解，因为这个规则不是user定义的吗？所以产生环不也是它的事，难道说自顶向下或者自底向上分析还能优化SDD定义？？

            -

            感觉它意思应该是这样的，有一个方法能绝对不产生循环依赖环，也即将自底向上/自顶向下语法分析与语义分析结合的这个方法。这个方法就是它说的真子集。

            -

            所以我们接下来要研究的就是什么样的语义分析可以用自顶向下or自底向上语法分析一起制导。

            -

            S-SDD

            picture

            -

            那确实，你自底向上想要计算继承属性好像也不大可能

            -

            L-SDD

            picture

            -

            picture

            -

            对应了自顶向下的最左推导顺序

            -

            S-SDD包含于L-SDD

            -

            picture

            -

            SDT

            picture

            -

            S-SDD -> SDT

            picture

            -

            picture

            -

            当归约发生时执行对应的语义动作

            -

            picture

            -

            还需要加个属性栈

            -

            picture

            -

            所以S-SDD+自底向上其实很简单，因为只需在归约的时候进行语义分析，在移进的时候push进属性栈就行了。

            -

            picture

            -

            具体的S-SDD结合语法分析的分析过程可以看视频。

            -

            这个例子还算简单的，毕竟只是综合属性的计算而已，只需要加个属性栈，保存值就行了。

            -

            picture

            -

            我们可以来关注一下这个SDT的设计，也很简单。可以产生式和语义规则分离看待，这也给我们以后设计提供一定的启发。

            -

            L-SDD -> SDT

            picture

            -

            picture

            -

            picture

            -

            非递归的预测分析

            picture

            -

            picture

            -

            这个是自顶向下的语法分析，本来只用一个栈就行了，现在需要进行扩展。T的综合属性存放在它的右边，继承属性存放在它的平行位置。

            -

            当属性值还没计算完时，不能出栈；当综合记录出栈时，它要将属性值借由语义动作复制给特定属性。

            -

            picture

            -

            然后语义动作也得一起进栈。

            -

            image-20231117015114181

            -

            digit是终结符，只有词法分析器提供值

            -

            此时，digit跟一个语义动作关联，所以我们需要把它的值复制给它关联的这个语义动作{a6}，然后才能出栈。

            -image-20231117015317921 - -
            -

            关联的另一个实例：

            -

            image-20231117015508123

            -

            此时由于T’.inh还要被a3用到，所以我们就得在T’出栈前把它的这个inh值复制给a3。

            -
            -

            当遇到语义动作之后，就执行动作，并且出栈语义动作。

            -

            picture

            -

            它这意思应该是遇到每个产生式的每个符号要执行什么动作都是确定的，所以代码实现是可能的。

            -

            可以看到：

            -
              -
            1. 语义动作代码就是执行
              2. -
            2. 综合属性代码就是赋给关联语义动作
              3. -
            3. 非终结符就是选一个它作为左部的产生式，然后看看要不要用到它自身的属性对右部子属性进行复制（体现了继承属性）
              4. -
            -

            递归的预测分析

            picture

            -

            666666666

            -

            感觉这个值得深思，但反正现在的我思不出啥了。。。

            -

            picture

            -

            picture

            -

            LR分析

            picture

            -

            picture

            -

            相当于把L-SDD转化为了个S-SDD。具体是这样，把原式子右边的变量替换为marker的继承属性，结果替换为marker的综合属性。那么新符号继承属性怎么算啊。。。不用担心，因为观察可知要使用的这两个非终结符一定已经在栈中了。

            -

            具体分析也看视频就好了。

            -

            第六章 中间代码生成

            中间代码的形式

            picture

            -

            逆波兰（后缀）

            picture

            -

            三地址码

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            false list就是if失败后的那个goto序号，true list是成功的那个goto序号，s.nextline是整个if的下一条指令

            -

            picture

            -

            四元式

            picture

            -

            picture

            -

            picture

            -

            增量生成

            -

            DAG图

            picture

            -

            picture

            -

            声明语句

            类型表达式

            picture

            -

            一般声明

            非嵌套

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            嵌套

            picture

            -

            picture

            -

            它这个相当于是把符号表和offset都整成了一个栈，毕竟确实过程调用就是得用栈结构的

            -

            picture

            -

            picture

            -

            记录

            picture

            -

            picture

            -

            之后用到该记录类型，就指向记录符号表即可。

            -

            picture

            -

            简单赋值语句

            定义

            这个就不用填符号表了，所以helper function都是用来产生中间代码的

            -

            picture

            -

            addr属性需要从符号表中获取

            -

            picture

            -

            临时变量处理

            picture

            -

            数组元素寻址

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            类型检查

            规则

            看个乐吧

            -

            picture

            -

            类型转换

            picture

            -

            picture

            -

            在语义动作中实现

            -

            控制流语句

            简单控制流

            picture

            -

            picture

            -

            反正意思就是用S.next这个继承属性来表示S.code执行完后的下一个三地址码地址。

            -

            picture

            -

            if-then

            picture

            -

            if-then-else

            picture

            -

            while-do

            picture

            -

            ;

            其实不大懂这什么玩意

            -

            picture

            -

            picture

            -

            picture

            -

            抽象

            -

            picture

            -

            picture

            -

            picture

            -

            布尔表达式

            布尔表达式翻译

            基本

            picture

            -

            picture

            -
            数值表示

            picture

            -

            picture

            -

            picture

            -
            控制流表示

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            混合模式布尔表达式

            picture

            -

            picture

            -

            picture

            -

            回填

            基本

            picture

            -

            picture

            -

            picture

            -

            这两个都是综合属性

            -

            相当于是一个waiting list

            -
            布尔表达式的回填

            picture

            -

            可以理解为，B这个表达式可以分为两种情况，两种情况有一个为真B就为真。那么，B的真回填list相当于也被分为了两种情况，所以要求B的就是把它们合起来。

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            原来回填是这个意思

            -
            控制流结构的回填

            nextline是一个综合属性

            -
            if-then

            picture

            -
            if-then-else

            picture

            -
            while-do

            picture

            -
            sequence

            picture

            -
            for

            picture

            -

            picture

            -
            repeat

            picture

            -
            switch-case

            TODO 这笔之后再看。。。。

            -

            picture

            -

            picture

            -

            picture

            -

            过程调用

            picture

            -

            picture

            -

            picture

            -

            输入输出语句

            TODO

            -

            picture

            -

            picture

            -

            题型1 四元序列

            picture

            -

            第七章 运行存储分配

            概念

            存储组织

            活动记录

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            静态/动态链

            picture

            -

            静态链也被称作访问链，用于访问存放于其他活动记录中的非局部数据。

            -

            动态链也被称作控制链，用于指向调用者的活动记录。

            -

            picture

            -

            picture

            -

            内存对齐

            picture

            -

            picture

            -

            作用域

            picture

            -

            picture

            -

            传参方式

            传值

            picture

            -

            传地址

            picture

            -

            传值结果

            picture

            -

            反正意思就是既要得到原来的A，又要修改A

            -

            传名

            picture

            -

            picture

            -

            静态存储分配

            picture

            -

            picture

            -

            顺序分配法

            picture

            -

            层次分配法

            picture

            -

            栈式存储分配

            概念

            picture

            -

            picture

            -

            也就是说左边及其所有子树全调完了，才能调下一个兄弟的。

            -

            picture

            -

            picture

            -

            image-20231114154150835

            -

            左边这几点设计规则都十分reasonable，很值得注意。

            -

            不过我其实挺好奇，参数存在那么后面该咋访问。。。。看xv6，似乎是fp指向前面，sp才指向local，也即用了两个栈指针。

            -

            这个控制链也是约定俗成的，具体可以想起来xv6也是类似结构：

            -

            picture

            -

            当函数返回的时候，就会进行恢复现场，从而出栈一直到ra，很合理。

            -

            调用/返回序列

            是什么

            picture

            -

            调用序列应该就是设置参数、填写栈帧一类，返回序列就是恢复现场

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            生成代码

            picture

            -
            调用序列

            传变量、改变meta data、改变top和sp指针

            -

            picture

            -

            picture

            -
            返回序列

            picture

            -

            变长数据

            picture

            -

            这段解释了下为什么不用堆，说得很好

            -

            picture

            -

            缺点

            picture

            -

            第二点，比如malloc后不free

            -

            栈中非局部数据的访问

            picture

            -

            有过程嵌套

            picture

            -

            静态作用域

            访问链

            picture

            -

            picture

            -

            picture

            -

            picture

            -
            建立访问链

            picture

            -

            picture

            -

            picture

            -
            过程参数的访问链

            picture

            -

            picture

            -

            Display表

            通俗解释

            每一个嵌套深度的分配一个Display位

            -

            S嵌套深度1，所以占据d[1]；Y和X嵌套深度2，所以占据d[2]；Z嵌套深度3，所以占据d[3]。

            -

            然后，一开始遇到个S，d1指向S；然后调用Y，d2指向Y；然后Y中调用X，就修改d2指向X；然后调用Z，就修改d3指向Z。

            -

            总之显示栈就是这个变换指针的过程。

            -

            至于控制栈，要打印这里面的display表，就是看层数。如果d1那就打印当前层，d2就打印的12层，d3就123层【不是纯显示栈，是它自己内部的未变换指针的结果】

            -

            picture

            -

            picture

            -

            picture

            -

            结果：SXZ

            -
            定义

            picture

            -

            picture

            -

            picture

            -
            访问流程

            picture

            -

            picture

            -

            picture

            -
            生成代码

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            动态作用域

            静态作用域是空间上就近原则，动态是时间上。

            -

            picture

            -

            picture

            -

            无过程嵌套

            picture

            -

            picture

            -

            也就是说这时候非局部的一定是全局变量或者静态的局部变量。

            -

            堆管理

            picture

            -

            内存管理器

            局部性

            picture

            -

            堆分配算法

            人工回收请求

            符号表

            如题

            picture

            -

            picture

            -

            如果是支持过程声明嵌套，顺着符号表就可以找到其父过程/子过程的数据。

            -

            符号表也可以用于构造访问链，因为过程名也是一种符号。

            -

            picture

            -

            符号表的建立

            picture

            -

            第九章 代码生成

            概述

            picture

            -

            目标代码形式

            picture

            -

            指令选择

            picture

            -

            寄存器分配

            picture

            -

            计算顺序选择

            picture

            -

            不讨论这个

            -

            目标语言

            定义

            picture

            -

            指令开销

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            运行时刻地址

            简单的代码生成器

            后续引用信息

            picture

            -

            picture

            -

            寄存器与地址描述符

            picture

            -

            代码生成算法

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            窥孔优化

            picture

            -

            冗余指令消除

            picture

            -

            不可达代码消除

            picture

            -

            强度削弱

            picture

            -

            特殊机器指令使用

            picture

            -

            寄存器分配指派

            picture

            -

            全局寄存器分配

            picture

            -

            引用计数

            picture

            -

            picture

            -

            picture

            -

            picture

            -

            所以这东西是用来决策寄存器分配的

            -

            外层循环的寄存器指派

            picture

            -

            picture

            -

            反正类似保护现场恢复现场

            -

            拓展阅读

            AC自动机

            在思考自动机和动态规划的关系时，胡乱搜索看到了AC自动机，于是来了解了一下。

            -
            -

            算法学习笔记(89): AC自动机 - Pecco的文章 - 知乎

            -
            -
            -

            考虑一个问题：给出若干个模式串，如何构建一个DFA，接受所有以任一模式串结尾（称为与该模式串匹配）的文本串？

            -

            可以先思考一个更简单的问题：如何构建接受所有模式串的DFA？很明显，**字典树**就可以看做符合要求的自动机。例如，有模式串"abab"、"abc"、"bca"、"cc" ，我们把它们插入字典树，可以得到：

            -

            picture

            -

            为了使它不仅接受模式串，还接受以模式串结尾的文本串，一个看起来挺正确的改动是，使每个状态接受所有原先不能接受的字符，转移到初始状态（即根节点）。

            -

            picture

            -

            但是如果我们尝试"abca"，我们会发现我们的自动机并不能接受它。稍加观察发现，我们在状态5接受a应该跳到状态8才对，而不是初始状态。某种意义上来说，状态7是状态5退而求其次的选择，因为状态7在trie上对应的字符串"bc"是状态5对应的字符串"abc"的后缀。既然状态5原本不能接受"a"，我们完全可以退而求其次看看状态7是否可以接受。这看起来很像KMP算法，确实，AC自动机常常被人称作trie上KMP。

            -

            所以我们给每个状态分配一条fail边，它连向的是该状态对应字符串在trie上存在的最长真后缀所对应的状态。我们令所有状态p接受原来不能接受的字符c，转移到 next(fail(p),c) ，特别地，根节点转移到自己。为什么不需要像KMP算法一样，用一个循环不断进行退而求其次的选择呢？因为如果我们用BFS的方式进行上面的重构，我们可以保证 fail(p) 在p重构前已经重构完成了，类似于动态规划。

            -

            picture

            -

            这样建fail边和重构完成后得到的自动机称为AC自动机（Aho-Corasick Automation）。

            -

            我们发现fail边也形成一棵树，所以其实AC自动机包含两棵树：trie树和fail树。一个重要的性质是，如果当前状态 p 在某个终止状态 s 的fail树的子树上，那么当前文本串就与 s 所对应模式串匹配。

            -
            -

            也就是说它的解决方法是加fall边（蓝色）和加新边（红色），

            -]]> - - - 密码学基础 - /2023/11/26/cryptography/ - -

            学习目的：顺利过考试，以及获取基本的密码学知识，数学原理不重要

            -
            -

            第一章 概述

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            第二章 传统密码技术

            概念

            image

            -

            image

            -

            分类

            置换密码

            image

            -

            列置换密码

            加密

            image

            -
            解密

            image

            -
            例子

            image

            -

            image

            -

            周期置换密码

            image

            -

            image

            -

            代换密码

            image

            -

            单表代换

            image

            -

            image

            -

            多表代换

            image

            -

            image

            -

            image

            -

            image

            -

            传统密码体制分析

            频率（单表代换）

            image

            -

            重合指数（多表代换）

            image

            -

            明文-密文对（hill密码）

            image

            -

            第三章 分组密码-DES

            概述

            image

            -
              -
            1. 分组密码一般指对称分组密码
              2. -
            -

            image

            -
              -
            1. 明文经编码表示后变成二进制序列
              2. -
            2. 二进制序列固定长度分组
              3. -
            3. 每组在密钥控制下转为密文分组
              4. -
            4. 本质上是明文到密文的一一映射
              5. -
            5. 一般明文长度=密文长度，密钥长度不一定
              6. -
            -

            image

            -

            image

            -

            设计思想

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            基本特点

            image

            -

            子密钥生成算法

            image

            -

            轮函数

            image

            -

            迭代轮数

            image

            -

            DES算法

            概述

            image

            -

            image

            -

            加密流程

            总体流程

            image

            -

            image

            -

            image

            -

            选择扩展置换E

            image

            -

            子密钥生成

            image

            -

            压缩替代S-盒

            image

            -

            image

            -

            image

            -

            置换p-盒

            image

            -

            解密流程

            image

            -

            image

            -

            安全性分析

            image

            -

            互补性

            image

            -

            image

            -

            弱密钥

            image

            -

            image

            -

            差分分析

            只有理论上意义

            -

            image

            -

            线性分析

            实际上不可行

            -

            image

            -

            密钥搜索

            image

            -

            image

            -

            多重DES

            image

            -

            image

            -

            二重

            image

            -

            3DES

            你也是过渡阶段？

            -

            image

            -

            第四章 有限域

            数学基础

            image

            -

            逆元：

            -

            image-20231119235319197

            -

            比如说在G(7)中，2的逆元为4。

            -

            也即，任意整数a，则存在x，a / 2 == a * 4 (mod 7)，4为2模7的乘法逆元，记为 2(-1)(mod 7) = 4。

            -

            image

            -

            求逆元的方法是求b^(m-2) mod m。如2^(5) mod 7 = 4。

            -

            群环域

            群

            image

            -

            image

            -

            image

            -

            确实封闭且结合且单位元且逆元

            -

            循环群

            image

            -

            环

            image

            -

            image

            -

            确实是环

            -

            域

            image

            -

            image

            -

            有限域GF(p)

            有限域就是阶为素数幂的域？

            -

            image

            -

            image

            -

            image

            -

            image-20231119233220659

            -

            多项式运算

            image

            -

            普通多项式运算

            image

            -

            image

            -

            image

            -

            image

            -

            系数模p运算的多项式运算

            image

            -

            确实，毕竟系数本身就是域了，除了没定义逆元外别的都满足。

            -

            image

            -

            image

            -

            有限域GF(2^n)

            image

            -

            image

            -

            image

            -

            第五章 高级加密标准-AES

            概述

            简介

            image

            -

            image

            -

            Nr=Nk的幂数x2

            -

            简化版AES

            image

            -

            image

            -

            具体算法详见PPT。

            -

            基本结构

            image

            -

            总体流程

            image

            -

            加密流程

            整体流程

            image

            -

            image

            -

            image

            -

            状态矩阵

            image

            -

            字节代替

            image

            -

            行移位

            image

            -

            列混淆

            image

            -

            image

            -

            可以关注下是怎么通过C矩阵求出这个固定多项式的：

            -

            image

            -

            轮密钥加

            image

            -

            密钥扩展

            image

            -

            image

            -

            感觉也是类似对明文做的操作

            -

            安全评估

            image

            -

            image

            -

            image

            -

            image

            -

            SM4

            image

            -

            image

            -

            第六章 分组密码的工作模式

            image

            -

            image

            -

            电码本ECB

            image

            -

            image

            -

            image

            -

            密码分组链接CBC

            image

            -

            image

            -

            密码反馈CFB

            image

            -

            image

            -

            输出反馈OFB

            image

            -

            image

            -

            计数器Counter

            image

            -

            image

            -

            image

            -

            总结

            image

            -

            第七章 序列密码

            概述

            序列密码的密钥序列是随机的。

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            总体流程

            image

            -

            image

            -

            image

            -

            密钥产生器KG

            总体构成

            image

            -

            image

            -

            线性反馈移位寄存器理论

            image

            -

            反馈移位寄存器

            image

            -

            image

            -

            线性反馈移位寄存器

            image

            -

            image

            -

            确实，感觉相比上面的这笔就是换了个反馈函数，就达到了2^n-1的周期

            -

            m序列

            特性

            image

            -

            image

            -
            生成

            image

            -

            image

            -
            分析

            image

            -
            破译

            image

            -

            image

            -

            image

            -

            image

            -

            常见序列生成算法

            Geffe序列生成器

            image

            -

            Pless生成器

            image

            -

            image

            -

            A5算法

            image

            -

            image

            -

            ZUC算法

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            RC4

            简介

            image

            -

            image

            -

            image

            -

            image

            -

            流程

            数据表S的初始状态

            image

            -

            数据表S的初始置换

            image

            -

            密钥流的生成

            image

            -

            第八章 数论基础

            整除性和带余除法，最大公因子

            image

            -

            image

            -

            素数和模运算

            image

            -

            image

            -

            也就是说求最大公因子实际上可以只求共有素数因子

            -

            image

            -

            image

            -

            image

            -

            image

            -

            欧几里得算法和扩展欧几里得算法

            欧几里得算法

            image

            -

            image

            -

            image

            -

            扩展欧几里得

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            费马小定理和欧拉定理

            费马小定理

            image

            -

            image

            -

            欧拉定理

            image

            -

            image

            -

            素性检测

            miller-rabin

            image

            -

            image

            -

            image

            -

            中国剩余定理

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            离散对数

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            第九章 公钥加密体系-RSA

            image

            -

            image

            -

            概述

            image

            -

            image

            -

            image

            -

            RSA

            组成

            image

            -

            image

            -

            image

            -

            安全性

            image

            -

            image

            -

            image

            -

            image

            -

            应用

            image

            -

            Rabin加密

            image

            -

            image

            -

            MH背包密码

            image

            -

            简介

            image

            -

            流程

            image

            -

            image

            -

            例子

            image

            -

            image

            -

            安全性分析

            image

            -

            image

            -

            EIGamal加密

            image

            -

            image

            -

            image

            -

            image

            -

            椭圆曲线密码体制

            image

            -

            数学理论

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            密码体制

            image

            -

            image

            -

            image

            -

            image

            -

            IBE算法

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            看起来意思就是公钥完全明文，用的是用户的身份ID；私钥用户自己存着。

            -

            image

            -

            image

            -

            image

            -

            后量子密码

            概述

            image

            -

            image

            -

            image

            -

            格

            image

            -

            NTRU

            流程

            image

            -

            image

            -

            image

            -

            image

            -

            举例

            image

            -

            image

            -

            安全性

            image

            -

            第十一章 哈希函数

            概述

            image

            -

            image

            -

            image

            -

            image

            -

            这个角度很有意思，确实是名字一样原理相近，但是目的完全不一样：

            -

            image

            -

            image

            -

            常见哈希函数

            SHA

            image

            -

            image

            -

            SM3

            image

            -

            image

            -

            安全性

            image

            -

            image

            -

            暴力攻击

            image

            -

            生日攻击

            image

            -

            image

            -

            攻击过程

            image

            -

            image

            -

            应用

            image

            -

            身份认证

            image

            -

            image

            -

            image

            -

            数字签名

            image

            -

            也就是中途会哈希两次吼。

            -

            第十二章 消息认证码 (MAC)

            概述

            基本思想

            image

            -

            image

            -

            一样的话就是说明消息没被篡改

            -

            image

            -

            要求

            image

            -

            基于哈希函数的MAC

            image

            -

            直观构造

            image

            -

            image

            -

            image

            -

            image

            -

            HMAC

            image

            -

            image

            -

            image

            -

            基于分组密码的MAC

            image

            -

            数据认证算法DAA

            image

            -

            image

            -

            CMAC

            image

            -

            认证加密

            概述

            image

            -

            image

            -

            CCM

            image

            -

            局限性

            image

            -

            第十三章 数字签名PKI

            概述

            简介

            image

            -

            image

            -

            对比

            image

            -

            image

            -

            安全性

            image

            -

            实现

            image

            -

            image

            -

            image

            -

            image

            -

            常见实现

            都包含签名算法、验证算法、正确性证明、举例，详细看PPT吧。

            -

            基于RSA

            image

            -

            基于离散对数

            image

            -

            ELGamal

            Schnorr

            DSA

            盲签名

            image

            -

            image

            -

            image

            -

            群（组）签名

            image

            -

            第十四章 密码协议

            概述

            image

            -

            image

            -

            分割和选择协议

            image

            -

            掷硬币协议

            image

            -

            单向函数

            image

            -

            模p指数运算

            image

            -

            零知识证明

            image

            -

            image

            -

            image

            -

            比特承诺

            image

            -

            image

            -

            image

            -

            安全多方计算

            这个有点复杂，可以看看PPT。

            -

            第十五章 密钥管理

            概述

            image

            -

            image

            -

            密钥分配

            image

            -

            image

            -

            无中心

            image

            -

            中心模式

            image

            -

            基于公钥密钥

            image

            -

            密钥协商

            image

            -

            Diffie-Hellman密钥交换方案

            image

            -

            image

            -

            PKI

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -

            SSL

            概述

            image

            -

            image

            -

            底层协议

            image

            -

            image

            -

            image

            -

            上层协议

            警告协议

            image

            -

            握手协议/密码变化协议

            image

            -

            密钥交换（四握手）

            image

            -

            image

            -

            image

            -

            image

            -

            image

            -]]> - - - Java并发编程实战 - /2022/11/06/Java%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B%E5%AE%9E%E6%88%98/ - -

            idea 替换注释正则表达式/\*{1,2}[\s\S]*?\*/

            -
            -

            第一章 简介

            线程的作用

            - -

            这一段写得很好，非常易懂地概括了什么是“多线程把异步转化为同步”：把异步中的不同操作分解为一个个独立的同类型操作，然后只需实现这些相较简单的同类型操作，再异步地把它们调度起来就行。线程正是把复杂的异步工作流分解成了一组简单的同步工作流。

            -

            线程无处不在

            如果一个模块在代码中引入了并发性，那么它所有的代码路径【调用链】都得是并发的。

            - - -

            最后一句话很关键，“把线程安全性封装在共享对象内部”

            - - - - - - - - -

            这个不同于上面的方法：将共享对象包装为线程安全的。它是要求了这些共享对象仅能在事件线程中运行，这样来保证线程安全性。

            -

            第二章 线程安全性

            **线程安全的核心就是对状态的访问和操作进行管理**，特别是对那些共享（shared）的、可变（mutable）的状态。关于本句话，其中几点将在下面一一细说：

            -
              -

            1. 状态

              -

              状态是指存储在状态变量里的数据，如成员变量、静态域等等等。对象的状态还可能包括其他依赖对象的域，如HashMap的状态包括Map.Entry的状态。

              -
              2. -

            2. 共享和可变

              -

              共享意味着变量可以由多个线程同时访问，可变意味着变量的值在生命周期可发生变化

              -
              3. -

            3. 是否需要线程安全

              -

              取决于它是否被多个线程访问。比如说，如果一个局部变量仅在某个函数体中同时只被一个线程访问，那么它就不需要线程安全，不需要同步机制。

              -
              4. -
            - - - - -

            什么是线程安全

            概念

            - - - - - -

            注意，线程安全不会违背不变性和后验条件，这句话在后面会用到。

            -

            无状态对象一定是线程安全的

            在此举例一个无状态线程：

            - - -
            @ThreadSafe
            public class StatelessFactorize implements  Servlet{
                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    BigInteger[] factors = factor(i);
                    encodeIntoResponse(resp,factors);
                }
            }
            - - - - - -

            无状态对象一定是线程安全的

            -

            原子性

            引例

            我们可以在无状态对象的基础上为它增加一个域：

            - - -

            这是线程不安全的，因为++count包含了三个动作：读取—修改—写入

            -
            mov reg,count
            add reg,1
            mov count,reg
            - -

            它并不具有原子性。

            -

            在并发编程中，这种由于时序原因产生错误的情况叫做“竞态条件”。

            -

            竞态条件

            - -

            竞态条件有两种常见的类型。两种竞态条件的本质其实都是“基于对象之前的状态来定义对象状态的转换”。对于读取-修改-写入，是先copy原值，然后对原值+1，再写回，这是基于对象之前的状态来定义对象状态的转换；对于先检查后执行，很显然就是判断原值然后再转换到下一个状态，这就不必说了。

            -

            读取-修改-写入

            如上引例

            -

            先检查后执行

            实例：懒加载，延迟初始化中的竞态条件

            -
            public class LazyInitRace {
                private ExpensiveObject instance = null;

                public ExpensiveObject getInstance() {
                    if (instance == null)
                            instance = new ExpensiveObject();
                    return instance;
                }
            }
            - - -

            竞态条件与数据竞争差别

            - - - -

            这书里讲得云里雾里的，百度了一下：

            - - -

            比如说书给例子，线程向共享对象读写数据，线程是操作对象A，共享对象是被操作对象B。则：

            -

            竞态条件：在乎的是被线程操控的共享对象的结果是否正确

            -

            数据竞争：在乎的是操作共享对象后，线程的结果是否正确。

            - - -

            确实，书里对数据竞争强调的是一个读一个写，对竞态条件更像是两个同时写

            -

            复合操作

            - - - - - -

            我们可以用一个线程安全类来解决前面的Count请求的需求：

            -
            @ThreadSafe
            public class CountingFactorizer implements Servlet{
                private final AtomicLong count = new AtomicLong(0);

                public long getCount(){ return count.get(); }

                public void service(SevletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    BigInteger[] factors = factor(i);
                    count.incrementAndGet();
                    encodeIntoResponse(resp,factors);
                }
            }
            - - - - - - - -

            加锁机制

            线程安全分析法与为什么要加锁

            上面说到，当对象内仅有一个状态时，可以通过使用线程安全类来保障原子性。但当对象里存在多个状态时，就必须用锁来进行线程同步，而非简单地用多个线程安全类。

            -

            还是以上面的实例来解释。

            - - -
            public class UnsafeCachingFactorizer implements Servlet{
                private final AtomicReference<BigInteger> lastNumber = new AtomicReference<>();
                private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<>();

                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    /*
                    此处产生了竞态条件。
                    如果一个变量在此之后，return之前修改了lastFactors，就会寄
                    */
                    if (i.equals(lastNumber.get())) encodeIntoResponse(resp,lastFactors.get());
                    else{
                        BigInteger[] factors = factor(i);
                        //本该需要瞬间一起完成的两个动作之间有时间间隔，不具原子性
                        lastNumber.set(i);
                        lastFactors.set(factors);
                        encodeIntoResponse(resp,factors);
                    }
                }
            }
            - - - - - -

            这段论述非常精彩，昭示了两个道理：1.分析线程安全性的时候，可以从“不变性条件不被破坏”开始考虑，首先考虑不变性条件应该是什么。2.在不变性条件涉及的多个变量彼此不独立，因而这些变量需要同时同步更新，上面那个例子就是因为不变性约束条件中的两个不独立变量没有同时同步更新。

            - - - - -

            确实，非常重要的一点就是在两个需要连续同时修改的变量之间有了并行的时间间隔，导致此期间并行的线程的不变性被破坏。

            -

            内置锁

            - - - -

            同步代码块包含两部分，锁的引用和保护的代码段。关键字synchronized修饰的方法就是一段同步代码段，其锁对象为当前实例【非静态方法】或者是当前class的实例【静态方法】。

            -
            -

            这个具体的“锁”是什么以前是真不知道。已知的是所有Object都有wait和什么什么notify方法。不过想想也确实。所有线程争抢着访问一个对象的某个同步方法段，这不正跟所有线程争抢着一个锁是差不多意思的吗？“锁”的定义其实是很宽泛的

            -
            - - -

            java的内置锁并非无饥饿的。当线程B永远不释放锁，A会一直等待下去。

            - - -

            我们可以用synchronized来解决上面的计数器问题，即直接给service方法设为synchronized。当然这种方法性能很糟糕，因为它极大降低了并发度。

            -

            重入

            - -

            其中关于粒度的理解：

            -

            不是“每一次调用获取一次锁，该锁属于该此调用”，而是“每个线程调用时获取一次锁，该锁属于该线程”

            - - - - - - -
            public class Widget {
                public synchronized void doSomething(){

                }
            }

            class LoggingWidget extends Widget{
                @Override
                public synchronized void doSomething() {
                    System.out.println(toString()+":calling doSomething.");
                    super.doSomething();
                }
            }
            - -

            比如上述代码，创建了一个LoggingWidget实例，然后调用该实例的dosmething方法，就会获取到该实例的锁。如果不允许重入，那么在做super.doSomething时，该实例的锁【注意，是同一个实例】已经被占用还未释放，因此产生死锁。有重入就可以避免此问题。

            -

            用锁来保护状态

            - - - -

            但这很考验人的记性。一旦你在某个地方忘了同步了就会寄。

            - - - - -

            活跃性与性能

            上面那个直接对service方法进行synchronized的改善方法粒度太粗了，可以试试如下方法：

            -
            @ThreadSafe
            public class CachedFactorizer implements Servlet{
                @GuardedBy ("this") private BigInteger lastNumber;
                @GuardedBy ("this") private BigInteger[] lastFactors;
                @GuardedBy ("this") private long hits;
                @GuardedBy ("this") private long cacheHits;

                public synchronized long getHits(){return hits;}
                public synchronized double getCacheHitRatio(){
                    return (double)cacheHits/(double) hits;
                }

                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    BigInteger[] factors = null;
                    synchronized (this){
                        ++hits;
                        if (i.equals(lastNumber)){
                            ++cacheHits;
                            factors = lastFactors.clone();
                        }
                    }
                    //局部变量无需同步保护
                    if (factors == null){
                        factors = factor(i);
                        synchronized (this){
                            lastNumber = i;
                            lastFactors = factors.clone();
                        }
                    }
                    encodeIntoResponse(resp,factors);
                }
            }
            - - - -

            毕竟因数分解的时候无需同步保护，因为这时候参与运算的都是局部变量。

            - - - - -

            第三章 安全地共享对象

            上一章讲述了，线程安全的本质就是对共享和可变状态进行管理，以及介绍了用锁来保护状态。

            -

            本章将引入同步除原子性外的另一特性——可见性，然后再介绍如何构建线程安全类，并且安全地发布和共享对象。

            -

            关键词：可见性 Volatile 线程封闭 不可变对象

            - - - - - - -

            可见性

            引例——可见性的定义

            public class Main {
                private static boolean ready;
                private static int number;

                private static class ReaderThread extends Thread{
                    public void run(){
                        while(!ready){
                            Thread.yield();
                        }
                        System.out.println(number);
                    }
                }

                public static void main(String[] args){
                    new ReaderThread().start();
                    number=42;
                    ready=true;
                }
            }
            - - - - - -
            -

            关于此程序显示出的对于内存可见性的理解，可以看这篇文章：

            -

            多线程(六):并发编程的三大特性之可见性

            - - -

            其实原因非常显而易见：主线程改了之后不会立刻把变量刷新到主存【可能默认是在ret时刷新，或者定时刷新，前者会导致相互等待的死锁，后者也会产生性能问题】，导致主线程的那个修改的flag变量对t1线程是**不可见**的，因此t1会继续循环等待。

            -
            -

            失效数据

            - - - - - - - -

            最低安全性

            - -

            注意，最低安全性不适用于非volatile类型的64位数据。

            - - - - - - -

            加锁与可见性

            - - - -

            要实现这种操作，我们可以设想一下关于内存可见性这一块内置锁的实现原理：lock时绑定指定变量，unlock时再刷新这个/些绑定变量的内存。

            - - -

            所以说得有锁，并且锁还得是对的。

            -

            看着看着有种always语句块的感觉了2333

            - - - - -

            Volatile关键字

            Volatile保证内存可见性

            到其他线程。【我想大概就是一改变了，就马上刷新内存中的旧值，然后也许通过什么嗅探检测到值变化，通知所有线程改变自己持有的旧值。】 - - - -

            注意不放在寄存器里或者线程的私有栈里

            - - - - -
            - -
            -

            Volatile不保证原子性

            - -
            -

            volatile为什么不能保证原子性？

            -

            但这个有争议：

            - - -
              -
            • 在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。
              • -
            -

            也就是说，

            -

            如果线程B在+1前知道数据无效了，就会重新载入数据然后+1然后载入内存，结果正确；

            -

            如果线程B在+1后才知道数据无效，虽然会重新载入数据，数据为A修改后的新数据，但是此时指令无法回退，因而只能继续执行下一条指令：写回内存，B写回内存的是A修改后的新数据，因而结果错误。

            -
            大致过程：
            a:mov reg 1
            b:mov reg 1
            a:add reg 1
            b:add reg 1
            a:mov reg mem
            然后b线程得到通知，重新载入数据:mov reg mem
            但是指令无法回退：mov reg mem
            因而结果是A修改后的值被写入了两遍。
            - -

            所以其实volatile仅确保单次读写的瞬时线程安全。

            - - -

            以下是别人的理解扩展：

            -

            对volatile不具有原子性的理解

            -

            volatile 无法保证原子性一个简单示例的疑问

            -

            Java并发编程：volatile关键字解析

            -
            -

            Volatile的使用方法

            - - - -

            下面给出一个volatile的典型用法：检查某个状态标记以判断是否退出循环。【也就是上文那个例子】

            -
            volatile boolean asleep;
            //...
            	while(!asleep)	countingSheep();
            - - - -

            发布与逸出

            发布与逸出的概念

            通俗地解释发布和逸出

            - - - - - - - - - -

            这个“逸出作用域”的表述非常不错。

            - - - - -

            什么时候会发生发布和逸出

            外部方法

            当把一个对象传递给某个外部方法，就相当于发布了这个对象。

            -

            外部方法：

            -
            发布内部的类实例

            “this escape”

            - - -
            public class ThisEscape{
                public final int id;
                public final String name;
                public ThisEscape(EventSource source){
                    id = 1;
                    //发布
                    source.registerListener(
                        //内部类
                    	new EventListener(){
                            public void onEvent(Event e){
                                //doSomething(e);
                            }
                        }
                    );
                    name = "escape";
                }
            }
            - -
            -

            java this 逸出_Java并发编程——this引用逸出(“this” Escape)

            -

            并发编程实践中，this引用逃逸(“this”escape)是指对象还没有构造完成，它的this引用就被发布出去了。

            -

            ThisEscape在构造函数中引入了一个内部类EventListener，而内部类会自动的持有其外部类(这里是ThisEscape)的this引用。source.registerListener会将内部类发布出去，从而ThisEscape.this引用也随着内部类被发布了出去。但此时ThisEscape对象还没有构造完成 —— id已被赋值为1，但name还没被赋值，仍然为null。这样一来，就有些线程持有不完整实例，不确定性太大了

            -
            - - -

            也就是说，如果是单线程情况下，这样做是没问题的，毕竟最后都会构造完整。但多线程情况下，这俩有时间间隔，因此会产生问题，并且不能靠简单地把这句发布对象的语句放在构造函数最后一行。

            - - -

            这段话非常值得注意

            -

            所以说上面那个例子的正确代码：

            - - -
            public class SafeListener {
                private final EventListener listener;

                private SafeListener(){
                    listener = new EventListener() {
                        public void onEvent(Event e){
                            //doSomething(e);
                        }
                    };
                }

                public static SafeListener newInstance(EventSource source){
                    SafeListener safe = new SafeListener();
                    source.registerListener(safe.listener);
                    return safe;
                }
            }
            - - - -

            线程封闭

            线程封闭是什么

            - - - -

            线程封闭一般有三种方法，这三种方法的规范性是逐级递增的。

            -

            Ad-hoc线程封闭

            - -
            -

            这里，书写得非常地抽象。通过查阅资料可得解释得更通俗的：

            -

            Ad-hoc线程封闭

            -

            Example of ad hoc thread confinement in Java

            -

            总之其实精华就这一句话：

            -

            并且都是人为约束，并且一般可能会用volatile来控制单线程写这种情况下的同步。

            -
            // Don't modify this from any other thread than Thread X.
            // So use it read-only for those other threads.
            private volatile int someNumber;
            -
            -

            栈封闭

            - -

            也就是我们前面说的，局部变量只能在该线程内访问，除非逸出了，否则是非常安全的。

            - - - - -

            对于基本类型

            - -意思就是说，java没有指针，获取不了这些不是对象的基本类型的引用，因而这些基本类型不可能通过调用外部方法之类的逸出【调用外部方法仅仅是取得它们的一份copy而非本身】，所以这些基本类型的局部变量始终封闭在线程内。 - -

            对于引用类型

            - -

            因而需要格外注意逸出问题

            -

            下面给出对基本类型和引用类型栈封闭的实例：

            -
            public int loadTheArk(Collection<Animal> candidates){
                //引用类型
                SortedSet<Animal> animals;
                //基本类型
                int numPairs = 0;
                Animal candidate = null;

                //需要详细写好注释↓
                //animals被封闭在方法中，不要使它们逸出！
                animals = new TreeSet<Animal>(new SpeciesGenderComparator());
                animals.addAll(candidates);
                for (Animal a : animals){
                    if (candidate == null || !candidate.isPotentialMate(a))
                            candidate = a;
                    else{
                        ark.load(new AnimalPair(candidate,a));
                        ++numPairs;
                        candidate = null;
                        new ThreadLocal<char[]>(){

                        };
                    }
                }
                return numPairs;
            }
            - - - -

            ThreadLocal类

            -

            史上最全ThreadLocal 详解（一）

            -
            -

            简介和应用实例

            上面介绍了使用局部变量来实现线程封闭的方法，也就是栈封闭。它只要合理地控制在调用方法时不发生逸出，就可以实现线程安全。

            -

            当有多个线程都需要同一类对象【比如Connection对象、ThreadID】，并且要求每个线程内的该对象是不一样的，并且该对象需要在多个方法中访问，栈封闭的方法就显得有些麻烦和不够优雅：需要在每个线程内都创建一个不同的对象实例，并且在调用方法的时候，都把该对象实例作为参数传进去。

            -

            这时候就需要ThreadLocal类了。

            -

            ThreadLocal类会给每个线程分配一个对象，并且仅需使用get方法，就能自动地把线程中的对象给弄出来。并且这些分配的对象对于各个线程来说都是隔离，相互不可见的，因此实现了线程封闭，具有安全性。

            - - -

            以ThreadID为例：

            -

            For example, the class below generates unique identifiers local to each thread. A thread’s id is assigned the first time it invokes ThreadId.get() and remains unchanged on subsequent calls.下面代码保证每个线程首次调用ThreadId.get方法后可以分配到一个不重ID，并且ID一旦确定，之后再调用get方法得到的ID是不会改变的。它这相当于维护了一个共有的计数器局部变量。

            -
            import java.util.concurrent.atomic.AtomicInteger;
            public class ThreadId {
                // Atomic integer containing the next thread ID to be assigned
                private static final AtomicInteger nextId = new AtomicInteger(0);
             
                // Thread local variable containing each thread's ID
                private static final ThreadLocal<Integer> threadId =
                    new ThreadLocal<Integer>() {
                        @Override protected Integer initialValue() {
                            return nextId.getAndIncrement();
                    }
                };
             
                // Returns the current thread's unique ID, assigning it if necessary
                public static int get() {
                    return threadId.get();
                }
            }
            - -

            对于每个想获取自身ThreadID的线程，在所有想用到ID的方法中，只需：

            -
            void method(){
            	AtomicInteger myID = ThreadID.get();
            	//do something
            }
            - -

            而不用：

            -
            AtomicInteger myID = getID();
            void method(AtomicInteger myID){
                //do something
            }
            - -

            这样大大简化了实现。

            -

            再比如：

            - - -
            private static final String DB_URL = "";
            private static ThreadLocal<Connection> connectionHolder
                    = new ThreadLocal<Connection>(){
                        public Connection initialValue(){
                            try {
                                return DriverManager.getConnection(DB_URL);
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
            };
            public static Connection getConnection(){
                return connectionHolder.get();
            }
            - - - -

            关于这个的大概代码猜想：

            -

            这样一来，在一个线程中使用toString，就仅需造一个buf【这个是ThreadLocal封闭】，而不用每次调用都造一个【这个是栈封闭】了

            -
            private static final ThreadLocal<char[]> buf
             	= new ThreadLocal<char[]>(){
             		@Override
             		public char[] initialValue(){
                         return new char[12];
                     }
            		};

            @Override
            public static String toString(int i) {
             //...
             //使用buf
             char[] buffer = buf.get();
             //...
            }
            - - - -

            底层实现

            大致结构

            我们可以初步猜想，ThreadLocal大概是通过一个map实现的，里面存储着<Thread,value>这样的键值对，每次就能通过Thread来取出对应的value了。Java低版本确实是这么做的。但Java的高版本对此进行了优化。

            - - -

            从本来的：ThreadLocalMap<Thread, value> ∈ ThreadLocal

            -

            变成了： ThreadLocalMap<ThreadLocal, value> ∈ Thread

            -

            并且其中的ThreadLocal这个key是以弱引用【WeakReference】的方式实现的。

            -
            -

            ThreadLocal探究

            -

            这样的结构演进有什么好处
            在旧版的ThreadLocal中，所有线程都将本地变量存在同一个ThreadLocalMap中，当并发量比较高的时候，ThreadLocalMap中的数据量会很大，而新版的ThreadLocalMap是属于线程的，也就是每个线程都操作属于自己的ThreadLocalMap，那么map中存储的变量就只有自己所存入的，数据量大大减少。

            -

            还有一个好处，旧版的ThreadLocalMap属于ThreadLocal，当Thread实例被销毁时ThreadLocalMap里该线程的数据不会被同时销毁【这也许就带来了危险性】，而新版ThreadLocalMap属于线程，线程被销毁时，ThreadLocalMap也随之销毁。

            -
            -
            源码阅读
            -

            This class provides thread-local variables.线程局部变量，也就是我们说的线程封闭手法。

            -

            These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable. 每个线程都有它自己的、独立初始化的该变量的副本。

            -

            ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).它一般用于私有静态字段，whose 状态和线程关系密切。

            -

            Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the ThreadLocal instance is accessible.

            -

            After a thread goes away, all of its copies of thread-local instances are subject to garbage collection (unless other references to these copies exist).最后会被垃圾回收

            -
            -
            public class ThreadLocal<T> {
                
                private final int threadLocalHashCode = nextHashCode();

                
                private static AtomicInteger nextHashCode =
                        new AtomicInteger();

                
                private static final int HASH_INCREMENT = 0x61c88647;

                
                private static int nextHashCode() {
                    return nextHashCode.getAndAdd(HASH_INCREMENT);
                }

                /*
                它这个初始化方法非常聪明且独特。
                一般使用它的时候是直接new然后重载一个匿名内部类的，
                于是就直接在建立匿名内部类时override此方法，在里面构造初始化的对象，
                且该方法仅在get调用的时候才会顺带调用
                有一种lazy的思想在里面。
                Normally, this method is invoked at most once per thread.
                */
                protected T initialValue() {
                    return null;
                }

                //Creates a thread local variable.
                //The initial value of the variable is determined by Supplier的get方法.
                public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
                    return new SuppliedThreadLocal<>(supplier);
                }
                
                public ThreadLocal() {
                }

                
                public T get() {
                    //也就是说，每个线程都有个ThreadLocal的map成员变量
                    //里面装的是<ThreadLocal变量，该变量在该线程的值>这样的键值对
                    Thread t = Thread.currentThread();
                    //得到线程里存储的ThreadLocalMap
                    ThreadLocalMap map = getMap(t);
                    if (map != null) {
                        //<ThreadLocal, value>
                        ThreadLocalMap.Entry e = map.getEntry(this);
                        if (e != null) {
                            @SuppressWarnings("unchecked")
                            T result = (T)e.value;
                            return result;
                        }
                    }
                    //map==null【还没有线程局部变量】或者e==null【还没有该线程局部变量】
                    return setInitialValue();
                }
                
                boolean isPresent() {
                    Thread t = Thread.currentThread();
                    ThreadLocalMap map = getMap(t);
                    return map != null && map.getEntry(this) != null;
                }
                
                private T setInitialValue() {
                    //获取初始化值
                    T value = initialValue();
                    Thread t = Thread.currentThread();
                    ThreadLocalMap map = getMap(t);
                    if (map != null) {
                        map.set(this, value);
                    } else {
                        //传入空map的第一个结点
                        createMap(t, value);
                    }
                    if (this instanceof TerminatingThreadLocal) {
                        TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
                    }
                    return value;
                }
                
                public void set(T value) {
                    Thread t = Thread.currentThread();
                    ThreadLocalMap map = getMap(t);
                    if (map != null) {
                        map.set(this, value);
                    } else {
                        createMap(t, value);
                    }
                }
                
                public void remove() {
                    ThreadLocalMap m = getMap(Thread.currentThread());
                    if (m != null) {
                        m.remove(this);
                    }
                }
                
                ThreadLocalMap getMap(Thread t) {
                    return t.threadLocals;
                }
                
                void createMap(Thread t, T firstValue) {
                    t.threadLocals = new ThreadLocalMap(this, firstValue);
                }
                
                static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
                    return new ThreadLocalMap(parentMap);
                }
                
                T childValue(T parentValue) {
                    throw new UnsupportedOperationException();
                }
                
                static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {

                    private final Supplier<? extends T> supplier;

                    SuppliedThreadLocal(Supplier<? extends T> supplier) {
                        this.supplier = Objects.requireNonNull(supplier);
                    }

                    @Override
                    protected T initialValue() {
                        return supplier.get();
                    }
                }

                /*
                ThreadLocalMap is a customized hash map suitable only for maintaining thread local values.
                To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.key【ThreadLocal】是弱引用的
                */
                static class ThreadLocalMap {

                    /*
                    Note that null keys (i.e. entry.get() == null) mean that the key is no longer referenced, so the entry can be expunged from table. Such entries are referred to as "stale entries" in the code that follows.
               		意思就是说陈旧条目【stale entry】指的是key为空的
                    */
                    static class Entry extends WeakReference<ThreadLocal<?>> {
                        //The value associated with this ThreadLocal.
                        Object value;

                        Entry(ThreadLocal<?> k, Object v) {
                            super(k);
                            value = v;
                        }
                    }

                    //The initial capacity -- MUST be a power of two.
                    private static final int INITIAL_CAPACITY = 16;
                    
                    private Entry[] table;
                    
                    private int size = 0;
                    
                    //The next size value at which to resize.
                    private int threshold; // Default to 0

                    //Set the resize threshold to maintain at worst a 2/3 load factor.
                    //默认情况下，装载因子为2/3
                    private void setThreshold(int len) {
                        threshold = len * 2 / 3;
                    }

                    //使i增加，并且让增加后的结果模len。也就是(++i)%len。
                    private static int nextIndex(int i, int len) {
                        return ((i + 1 < len) ? i + 1 : 0);
                    }
                    
                    //也就是(--i)%len。
                    private static int prevIndex(int i, int len) {
                        return ((i - 1 >= 0) ? i - 1 : len - 1);
                    }

                    //Construct a new map initially containing (firstKey, firstValue). 
                    //ThreadLocalMaps are constructed lazily,
                    //so we only create one when we have at least one entry to put in it.
                    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
                        table = new Entry[INITIAL_CAPACITY];
                        //依旧是HashMap里面经典的掩码操作，key的hashcode作为entry在table里的序号
                        //与hashmap的差别就在于，hashmap的桶table一个里面可以存放多个结点，
                        //但这里的ThreadLocal的hash显然是不冲突的，因而只能存放一个结点
                        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
                        table[i] = new Entry(firstKey, firstValue);
                        size = 1;
                        setThreshold(INITIAL_CAPACITY);
                    }
                    
                    private ThreadLocalMap(ThreadLocalMap parentMap) {
                        Entry[] parentTable = parentMap.table;
                        int len = parentTable.length;
                        setThreshold(len);
                        table = new Entry[len];

                        for (int j = 0; j < len; j++) {
                            Entry e = parentTable[j];
                            //有对应结点
                            if (e != null) {
                                @SuppressWarnings("unchecked")
                                ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                                if (key != null) {
                                    Object value = key.childValue(e.value);
                                    Entry c = new Entry(key, value);
                                    int h = key.threadLocalHashCode & (len - 1);
                                    while (table[h] != null)
                                        h = nextIndex(h, len);
                                    table[h] = c;
                                    size++;
                                }
                            }
                        }
                    }
                    
                    private Entry getEntry(ThreadLocal<?> key) {
                        int i = key.threadLocalHashCode & (table.length - 1);
                        Entry e = table[i];
                        if (e != null && e.get() == key)
                            return e;
                        else
                            return getEntryAfterMiss(key, i, e);
                    }
                    
                    private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
                        Entry[] tab = table;
                        int len = tab.length;

                        while (e != null) {
                            ThreadLocal<?> k = e.get();
                            if (k == key)
                                return e;
                            if (k == null)
                                expungeStaleEntry(i);
                            else
                                i = nextIndex(i, len);
                            e = tab[i];
                        }
                        return null;
                    }
                    
                    private void set(ThreadLocal<?> key, Object value) {

                        // We don't use a fast path as with get() because it is at
                        // least as common to use set() to create new entries as
                        // it is to replace existing ones, in which case, a fast
                        // path would fail more often than not.

                        Entry[] tab = table;
                        int len = tab.length;
                        int i = key.threadLocalHashCode & (len-1);

                        for (Entry e = tab[i];
                             e != null;
                             e = tab[i = nextIndex(i, len)]) {
                            ThreadLocal<?> k = e.get();

                            if (k == key) {
                                e.value = value;
                                return;
                            }

                            if (k == null) {
                                replaceStaleEntry(key, value, i);
                                return;
                            }
                        }

                        tab[i] = new Entry(key, value);
                        int sz = ++size;
                        if (!cleanSomeSlots(i, sz) && sz >= threshold)
                            rehash();
                    }

                    
                    private void remove(ThreadLocal<?> key) {
                        Entry[] tab = table;
                        int len = tab.length;
                        int i = key.threadLocalHashCode & (len-1);
                        for (Entry e = tab[i];
                             e != null;
                             e = tab[i = nextIndex(i, len)]) {
                            if (e.get() == key) {
                                e.clear();
                                expungeStaleEntry(i);
                                return;
                            }
                        }
                    }

                    
                    private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                                   int staleSlot) {
                        Entry[] tab = table;
                        int len = tab.length;
                        Entry e;

                        // Back up to check for prior stale entry in current run.
                        // We clean out whole runs at a time to avoid continual
                        // incremental rehashing due to garbage collector freeing
                        // up refs in bunches (i.e., whenever the collector runs).
                        int slotToExpunge = staleSlot;
                        for (int i = prevIndex(staleSlot, len);
                             (e = tab[i]) != null;
                             i = prevIndex(i, len))
                            if (e.get() == null)
                                slotToExpunge = i;

                        // Find either the key or trailing null slot of run, whichever
                        // occurs first
                        for (int i = nextIndex(staleSlot, len);
                             (e = tab[i]) != null;
                             i = nextIndex(i, len)) {
                            ThreadLocal<?> k = e.get();

                            // If we find key, then we need to swap it
                            // with the stale entry to maintain hash table order.
                            // The newly stale slot, or any other stale slot
                            // encountered above it, can then be sent to expungeStaleEntry
                            // to remove or rehash all of the other entries in run.
                            if (k == key) {
                                e.value = value;

                                tab[i] = tab[staleSlot];
                                tab[staleSlot] = e;

                                // Start expunge at preceding stale entry if it exists
                                if (slotToExpunge == staleSlot)
                                    slotToExpunge = i;
                                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                                return;
                            }

                            // If we didn't find stale entry on backward scan, the
                            // first stale entry seen while scanning for key is the
                            // first still present in the run.
                            if (k == null && slotToExpunge == staleSlot)
                                slotToExpunge = i;
                        }

                        // If key not found, put new entry in stale slot
                        tab[staleSlot].value = null;
                        tab[staleSlot] = new Entry(key, value);

                        // If there are any other stale entries in run, expunge them
                        if (slotToExpunge != staleSlot)
                            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                    }

                    
                    private int expungeStaleEntry(int staleSlot) {
                        Entry[] tab = table;
                        int len = tab.length;

                        // expunge entry at staleSlot
                        tab[staleSlot].value = null;
                        tab[staleSlot] = null;
                        size--;

                        // Rehash until we encounter null
                        Entry e;
                        int i;
                        for (i = nextIndex(staleSlot, len);
                             (e = tab[i]) != null;
                             i = nextIndex(i, len)) {
                            ThreadLocal<?> k = e.get();
                            if (k == null) {
                                e.value = null;
                                tab[i] = null;
                                size--;
                            } else {
                                int h = k.threadLocalHashCode & (len - 1);
                                if (h != i) {
                                    tab[i] = null;

                                    // Unlike Knuth 6.4 Algorithm R, we must scan until
                                    // null because multiple entries could have been stale.
                                    while (tab[h] != null)
                                        h = nextIndex(h, len);
                                    tab[h] = e;
                                }
                            }
                        }
                        return i;
                    }

                    
                    private boolean cleanSomeSlots(int i, int n) {
                        boolean removed = false;
                        Entry[] tab = table;
                        int len = tab.length;
                        do {
                            i = nextIndex(i, len);
                            Entry e = tab[i];
                            if (e != null && e.get() == null) {
                                n = len;
                                removed = true;
                                i = expungeStaleEntry(i);
                            }
                        } while ( (n >>>= 1) != 0);
                        return removed;
                    }

                    
                    private void rehash() {
                        expungeStaleEntries();

                        // Use lower threshold for doubling to avoid hysteresis
                        if (size >= threshold - threshold / 4)
                            resize();
                    }

                    
                    private void resize() {
                        Entry[] oldTab = table;
                        int oldLen = oldTab.length;
                        int newLen = oldLen * 2;
                        Entry[] newTab = new Entry[newLen];
                        int count = 0;

                        for (int j = 0; j < oldLen; ++j) {
                            Entry e = oldTab[j];
                            if (e != null) {
                                ThreadLocal<?> k = e.get();
                                if (k == null) {
                                    e.value = null; // Help the GC
                                } else {
                                    int h = k.threadLocalHashCode & (newLen - 1);
                                    while (newTab[h] != null)
                                        h = nextIndex(h, newLen);
                                    newTab[h] = e;
                                    count++;
                                }
                            }
                        }

                        setThreshold(newLen);
                        size = count;
                        table = newTab;
                    }

                    
                    private void expungeStaleEntries() {
                        Entry[] tab = table;
                        int len = tab.length;
                        for (int j = 0; j < len; j++) {
                            Entry e = tab[j];
                            if (e != null && e.get() == null)
                                expungeStaleEntry(j);
                        }
                    }
                }
            }
            - -

            注意点：

            -
              -
            1. 哈希方法和解决哈希冲突
              - -

              存在哈希冲突的话，大概是采用的线性探测方法。

              -
              2. -
            2. 解决内存泄漏

              关于其remove方法：

              -
              public void remove() {
              	ThreadLocalMap m = getMap(Thread.currentThread());
              	if (m != null)
              		m.remove(this);
              }
              //m.remove
              		private void remove(ThreadLocal<?> key) {
                          Entry[] tab = table;
                          int len = tab.length;
                          int i = key.threadLocalHashCode & (len-1);
                          //线性探测
                          for (Entry e = tab[i];
                               e != null;
                               e = tab[i = nextIndex(i, len)]) {
                              if (e.get() == key) {
                                  e.clear();
                                  expungeStaleEntry(i);
                                  return;
                              }
                          }
                      }
              - -

              两篇文章都有解释

              -
              -

              remove方法，直接将ThrealLocal 对应的值从当前相差Thread中的ThreadLocalMap中删除。为什么要删除，这涉及到内存泄露的问题。

              -

              实际上 ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用，弱引用的特点是，如果这个对象只存在弱引用，那么在下一次垃圾回收的时候必然会被清理掉。

              -

              所以如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候会被清理掉的，这样一来 ThreadLocalMap中使用这个 ThreadLocal 的 key 也会被清理掉。但是，value 是强引用，不会被清理，这样一来就会出现 key 为 null 的 value。

              -

              ThreadLocal其实是与线程绑定的一个变量，如此就会出现一个问题：如果没有将ThreadLocal内的变量删除（remove）或替换，它的生命周期将会与线程共存。通常线程池中对线程管理都是采用线程复用的方法，在线程池中线程很难结束甚至于永远不会结束，这将意味着线程持续的时间将不可预测，甚至与JVM的生命周期一致。举个例字，如果ThreadLocal中直接或间接包装了集合类或复杂对象，每次在同一个ThreadLocal中取出对象后，再对内容做操作，那么内部的集合类和复杂对象所占用的空间可能会开始持续膨胀。
              ————————————————
              版权声明：本文为CSDN博主「倔强的不服」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
              原文链接：https://blog.csdn.net/u010445301/article/details/111322569

              -
              -
              -

              ThreadLocal内存泄漏问题的解析。
              前面我们说到它虽然线程安全，但是它存在一个问题那就是内存泄漏。

              -

              首先我们要明白为什么会内存泄漏，前面也说了ThreaLocal是一个弱引用，什么是弱引用就是当它为null时候，就会被垃圾回收机制给带走，重点就是，如果我们的ThreadLocal突然为null，然后就被回收了，但此时我们的ThreadLocalMap它的生命周期是和Thread相同的，简单理解就是，裤子没了，兜还在，兜里面还有我们的数据，这就造成了内存泄漏。

              -

              如何解决那：我们必须在使用完ThreadLocal后，执行remove()方法，避免内存溢出。
              ————————————————
              版权声明：本文为CSDN博主「某刘姓男子i的码农客栈」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
              原文链接：https://blog.csdn.net/qq_20783497/article/details/107980858

              -
              -
              3. -
            -

            不变性

            不可变对象

            不可变对象的线程安全性

            满足同步需求的另一种方案就是使用不可变对象。

            - - -

            这个思路非常地简单粗暴：什么东西影响了，就直接让它消失。非常有意思2333

            -

            如果某个对象在创建后不能被修改，那么它就叫不可变对象。线程安全性是不可变对象的固有属性之一。

            - - -

            比如说final域只能在声明的成员域或者构造函数中初始化，两者本质上都是在构造函数中初始化的。

            -

            并且不可变对象也更加安全。

            - - - - -

            不可变对象与final域

            不可变性不等于将对象中的所有域都设置为final域，因为final类型的域可以是对可变对象的引用。【这就类似C语言中const指针】当且仅当满足下列条件，对象才是不可变的：

            - - -
            -

            对于这里注释提到的String类，它讲得有些让人迷惑。因而我查阅资料得到解说如下：

            -

            String中hashCode方法的线程安全

            -
            class String{
            　　//默认值是0
            　　int hash;

            　　public int hashCode() {
                 //将成员变量hash缓存到局部变量
                 int h = hash;
            　　　　 //这里使用的是局部变量，因此没有多线程修改的风险
                 if (h == 0 && value.length > 0) {
                     char val[] = value;
                     //求hashcode过程使用局部h变量防止产生静态条件
                     for (int i = 0; i < value.length; i++) {
                         h = 31 * h + val[i];
                     }

                     //把求出的hashcode缓存到局部变量，原子操作
                     //这里不需要考虑线程可见性的问题，
                     //如果其它线程未能及时看到最新修改，重新计算hash值代价也不大
                     hash = h;
               	}
               	return h;
            	}  
            }
            - -

            再回去看书中注释的描述：

            - - -

            这个的意思就是说，对每个线程来说，同一个字符串hashcode值都是一样的【每次计算都得到相同的结果】，所以就不会产生多个线程计算出不同值的情况，导致不同步的发生。

            - - -

            意思是说之所以hashcode值一样，是因为这个hashcode计算是基于不可变对象的：

            -
            private final char value[];
            - -

            并且重复计算性能代价可能远没有加锁的消耗来得大，因而这里仅使用了栈封闭来保证一定程度上的线程同步。

            -
            -

            可变对象基础上构建不可变类

            - -
            public final class ThreeStooge {
                private final Set<String> stooges = new HashSet<>();

                public ThreeStooge(){
                    stooges.add("Moe");
                    stooges.add("Larry");
                    stooges.add("Curly");
                }

                public boolean isStooge(String name){
                    return stooges.contains(name);
                }
            }
            - - - -

            也就是说，实现的核心是保证可变对象不变即可。

            - - - - -

            Final域

            - -

            final不仅保证了引用对象的不可变，还保证了不可变对象初始化过程中的线程安全性。

            - - -

            所以说还是尽量多用final。

            -

            Volatile与不可变对象提供弱原子性

            也就是这个图片中所说的：

            - - -

            使用volatile变量来发布不可变对象，不仅可以更新保存在不可变对象中的程序状态，还可以为一组操作提供弱原子性。

            - - -

            前面的代码为：

            -
            public class UnsafeCachingFactorizer implements Servlet{
                private final AtomicReference<BigInteger> lastNumber = new AtomicReference<>();
                private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<>();

                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    /*竞态条件*/
                    if (i.equals(lastNumber.get())) encodeIntoResponse(resp,lastFactors.get());
                    else{
                        BigInteger[] factors = factor(i);
                        //时间间隔
                        lastNumber.set(i);
                        lastFactors.set(factors);
                        encodeIntoResponse(resp,factors);
                    }
                }
            }
            - -

            如今，利用volatile和不可变类的相互配合，我们修改如下：

            -
            public class VolatileCachedFactorizer implements Servlet{
                //从使用两个分别原子的变量，变为使用一个volatile修饰的不可变类
                private volatile OneValueCache cache = new OneValueCache(null,null);

                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    BigInteger[] factors = cache.getFactors(i);
                    if (factors == null){
                        factors = factor(i);
                        //直接new一个新容器，利用了final域在初始化过程中的线程安全，因而保证了原子性
                        //同时也用了volatile快刷新的性质，保证了可见性，当一个线程设置为新的，其他会立即看到
                        //妙啊，这样就非常完美地达成了线程安全性
                        cache = new OneValueCache(i,factors);
                    }
                    encodeIntoResponse(resp,factors);
                }
            }

            public class OneValueCache {
                private final BigInteger lastNumber;
                private final BigInteger[] lastFactors;

                public OneValueCache(BigInteger lastNumber, BigInteger[] lastFactors) {
                    this.lastNumber = lastNumber;
                    //传递副本，保证不可变
                    this.lastFactors = Arrays.copyOf(lastFactors,lastFactors.length);
                }

                public BigInteger[] getFactors(BigInteger i){
                    if (lastNumber == null || !lastNumber.equals(i)){
                        return null;
                    }
                    else{
                        //传递副本，保证不可变
                        return Arrays.copyOf(lastFactors,lastFactors.length);
                    }
                }
            }
            - - - -

            每当需要对一组相关数据以原子方式执行某个操作时，就可以考虑创建一个不可变的类来包含这些数据，其本质就是利用不可变性消除了访问和更新多个变量的竞态条件。

            - - -

            因为依然满足该程序的不变性原理：factor数组中各个数字的乘积=lastNumber，也就是说容器对象的两个值都是正确对应的，因而容器对象处于一致的状态。又或者是因为volatile及时刷新，因此确保了各个线程的内存可见性。

            - - - - -

            安全发布

            - -

            现在，我们要来讲讲如何安全地对对象进行发布。

            -

            一个不正确程序案例

            public Holder holder;

            public void initialize(){	holder = new Holder();	}

            //以下是Holder类定义
            public class Holder{
                private int n;
                
                public Holder(int n){	this.n = n;	}
                
                public void assertSanity(){
                    if( n != n )	
                        throw new AssertionError("This statement is false.");
                }
            }
            - -

            Holder类本身是没有问题的，这段代码出问题的原因是holder没有被正确地发布。

            -

            关于holder为什么没有被正确地发布：

            -

            参考文章

            【并发编程】安全发布对象与防止对象逸出(原因与防护方法)

            -

            分析过程

            由参考文章1：

            - - -

            可知，new一个对象并非原子操作，并且很有可能先得到内存引用才初始化对象。

            -

            因而，在上面那段不安全代码的语境下可分析：

            -
            Holder的错误发布有三点如下：

            首先明确，引用，和引用的对象的状态，这两个是两个需要独立考虑的方面。前者是一个指针值，后者是指针所指的数据。下面的点1仅考虑引用的更新，点2考虑了引用对象的状态更新。

            -

            \1. 发布对象的那个线程给holder初始化之后，holder这个引用没有及时刷新到内存，因而对其他线程不可见，其他线程读到的holder引用是旧的。

            -

            \2. 又或者，发布了holder还没初始化完毕的时候，别的进程读取到未完成初始化的holder这个引用，但这个引用指向的状态却是旧的，因为它还没完成初始化，其状态值为旧值或者默认值。【发生了上面new一个对象的指令重排】

            -

            \3. 如果在assert方法中两次读取n发生了上面第二条，就可能会导致前后的n不唯一，抛出异常。

            -

            由书中表述，如果将Holder转化为不可变类，那么该发布是安全的。

            - - -

            至于为什么，可见下个标题。

            -
            -

            此处插入思考：是否可以将public Holder holder修改为public final Holder holder，或者volatile修饰，来解决上述问题呢？

            -

            java多线程关键字final和static详解

            -

            通过看该文章得知：

            - - -

            volatile和final都会禁止字段引用的对象在构造对象过程中发生指令重排，别的线程得到引用的时候构造已经完成，而不会先得到引用再完成构造，并且两个标志都可以保证可见性。

            -

            不过继续读下去，书中给出了答案：我说的这个方法也是可行的。

            - - -

            我的疑问就是第二点和第三点。

            -
            -

            不可变对象的初始化安全性

            - - - - - -

            安全发布的常用模式

            - -

            分别解说

            -

            静态初始化对象引用

            - -

            volatile、final以及AtomicReferance保护引用

            详见上面那个不正确案例最后的思考

            -

            由锁保护的区域

            这个区域除了是通过程序构造的，也可以是使用Java自带的线程安全类库。

            - - - - -

            事实不可变对象

            安全发布可以保证发布时的线程安全。所以说你如果承诺发布后可以一直保证不可变，那就一直都是线程安全的。

            - - - - - - - - -

            对象的可变性与正确发布

            - - - -

            安全地共享对象

            - - - -

            第四章 对象的组合

            - -

            也就是说上面都是在讲怎么让一个对象的共享变得安全，下面我们讲怎么依据设计模式，让一个类更容易成为线程安全的

            -

            如何设计线程安全的类

            - - - - - - - - - - - -

            收集同步需求

            本质上是找不变性条件和后验条件

            要保证不变性条件始终成立，确保后验条件符合预期。

            - - -

            讲了什么是不变性条件和后验条件：

            - - - - -

            无效的状态转换只能出现在原子序列中

            - - - - -

            依赖状态的操作

            - -

            也就是说先验条件和状态域相关。

            - - - + -

            状态的所有权

            - -

            666666

            - +

            什么是线程安全

            概念

            + + -

            实例封闭

            什么是实例封闭

            +

            注意，线程安全不会违背不变性和后验条件，这句话在后面会用到。

            +

            无状态对象一定是线程安全的

            在此举例一个无状态线程：

            + - +
            @ThreadSafe
            public class StatelessFactorize implements  Servlet{
                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    BigInteger[] factors = factor(i);
                    encodeIntoResponse(resp,factors);
                }
            }
            -

            所以需要上一章学的安全发布。

            - -
            //通过封闭机制保证线程安全
            @ThreadSafe
            public class PersonSet {
                //不安全
                //封闭在实例内部
                private final Set<Person> mySet = new HashSet<>();

                //对所有代码路径加锁访问
                public synchronized void addPerson(Person p) {
                    mySet.add(p);
                }
                public synchronized boolean containsPerson(Person p){
                    return mySet.contains(p);
                }
            }
            - + - +

            无状态对象一定是线程安全的

            +

            原子性

            引例

            我们可以在无状态对象的基础上为它增加一个域：

            + -

            阅读源码可知：

            -
            static class SynchronizedCollection<E> implements Collection<E>, Serializable {
                 private static final long serialVersionUID = 3053995032091335093L;

                 final Collection<E> c;  // Backing Collection
                 final Object mutex;     // Object on which to synchronize

                 SynchronizedCollection(Collection<E> c) {
                     this.c = Objects.requireNonNull(c);
                     mutex = this;
                 }

                 SynchronizedCollection(Collection<E> c, Object mutex) {
                     this.c = Objects.requireNonNull(c);
                     this.mutex = Objects.requireNonNull(mutex);
                 }

                 public int size() {
                     synchronized (mutex) {return c.size();}
                 }
                 public boolean isEmpty() {
                     synchronized (mutex) {return c.isEmpty();}
                 }
                 public boolean contains(Object o) {
                     synchronized (mutex) {return c.contains(o);}
                 }
                 public Object[] toArray() {
                     synchronized (mutex) {return c.toArray();}
                 }
                 public <T> T[] toArray(T[] a) {
                     synchronized (mutex) {return c.toArray(a);}
                 }

                //注意此处没用同步
                 public Iterator<E> iterator() {
                     return c.iterator(); // Must be manually synched by user!
                 }

                 public boolean add(E e) {
                     synchronized (mutex) {return c.add(e);}
                 }
                 public boolean remove(Object o) {
                     synchronized (mutex) {return c.remove(o);}
                 }

                 public boolean containsAll(Collection<?> coll) {
                     synchronized (mutex) {return c.containsAll(coll);}
                 }
                 public boolean addAll(Collection<? extends E> coll) {
                     synchronized (mutex) {return c.addAll(coll);}
                 }
                 public boolean removeAll(Collection<?> coll) {
                     synchronized (mutex) {return c.removeAll(coll);}
                 }
                 public boolean retainAll(Collection<?> coll) {
                     synchronized (mutex) {return c.retainAll(coll);}
                 }
                 public void clear() {
                     synchronized (mutex) {c.clear();}
                 }
                 public String toString() {
                     synchronized (mutex) {return c.toString();}
                 }
                 // Override default methods in Collection
                 @Override
                 public void forEach(Consumer<? super E> consumer) {
                     synchronized (mutex) {c.forEach(consumer);}
                 }
                 @Override
                 public boolean removeIf(Predicate<? super E> filter) {
                     synchronized (mutex) {return c.removeIf(filter);}
                 }
                 @Override
                 public Spliterator<E> spliterator() {
                     return c.spliterator(); // Must be manually synched by user!
                 }
                 @Override
                 public Stream<E> stream() {
                     return c.stream(); // Must be manually synched by user!
                 }
                 @Override
                 public Stream<E> parallelStream() {
                     return c.parallelStream(); // Must be manually synched by user!
                 }
                 private void writeObject(ObjectOutputStream s) throws IOException {
                     synchronized (mutex) {s.defaultWriteObject();}
                 }
             }
            +

            这是线程不安全的，因为++count包含了三个动作：读取—修改—写入

            +
            mov reg,count
            add reg,1
            mov count,reg
            -

            就是把原来的collection给实例封闭了，之后的访问都用了同步锁。

            -

            Java监视器模式

            使用内置锁

            +

            它并不具有原子性。

            +

            在并发编程中，这种由于时序原因产生错误的情况叫做“竞态条件”。

            +

            竞态条件

            -

            直白点来说，就是把所有要访问自己状态的地方/方法通通synchronized。

            - +

            竞态条件有两种常见的类型。两种竞态条件的本质其实都是“基于对象之前的状态来定义对象状态的转换”。对于读取-修改-写入，是先copy原值，然后对原值+1，再写回，这是基于对象之前的状态来定义对象状态的转换；对于先检查后执行，很显然就是判断原值然后再转换到下一个状态，这就不必说了。

            +

            读取-修改-写入

            如上引例

            +

            先检查后执行

            实例：懒加载，延迟初始化中的竞态条件

            +
            public class LazyInitRace {
                private ExpensiveObject instance = null;

                public ExpensiveObject getInstance() {
                    if (instance == null)
                            instance = new ExpensiveObject();
                    return instance;
                }
            }
            -
            //监视器模式
            @ThreadSafe
            public final class Counter {
                @GuardedBy("this")  private long value = 0;

                public synchronized long getValue(){
                    return value;
                }

                public synchronized long increment(){
                    if (value == Long.MAX_VALUE){
                        throw new IllegalStateException();
                    }
                    return ++value;
                }
            }
            -

            这样虽然简单，但缺点就是很粗暴：同步的粒度太粗了。

            -

            使用私有锁

            也跟内置锁道理差不多

            - +

            竞态条件与数据竞争差别

            -

            也就是说私有锁可以让外面的世界也参与到同步中来，但内置锁不大行。

            -

            示例：车辆追踪

            public class MutablePoint {
                public int x,y;

                public MutablePoint() {
                    x=0;y=0;
                }
                public MutablePoint(MutablePoint p){
                    //深拷贝
                    this.x=p.x;
                    this.y=p.y;
                }
            }
            -
            //基于监视器模式
            public class MonitorVehicleTracker {
                private final Map<String, MutablePoint> locations;

                public MonitorVehicleTracker(
                        Map<String,MutablePoint> locations
                ){
                    this.locations = deepCopy(locations);
                }

                public synchronized Map<String,MutablePoint> getLocations(){
                    return deepCopy(locations);
                }
                public synchronized MutablePoint getLocation(String id){
                    MutablePoint loc = locations.get(id);
                    //返回copy对象，深拷贝
                    return loc == null?null : new MutablePoint(loc);
                }
                public synchronized void setLocation(String id,int x,int y){
                    MutablePoint loc = locations.get(id);
                    if (loc == null)    throw new IllegalArgumentException();
                    loc.x = x;
                    loc.y = y;
                }

                //为什么这方法不用锁？是因为调用它的地方都锁着
                private static Map<String,MutablePoint> deepCopy(Map<String,MutablePoint> m){
                    Map<String,MutablePoint> res = new HashMap<>();
                    for (Map.Entry en : m.entrySet()){
                        //此处通过MutablePoint的构造函数重新拷贝了一个Point
                        //如果简单地使用HashMap的构造函数new HashMap(m)的拷贝来创建一个新的map是不行的
                        //因为这样只会拷贝Point对象的指针值，依然是浅拷贝
                        res.put((String) en.getKey(),new MutablePoint((MutablePoint) en.getValue()));
                    }
                    return Collections.unmodifiableMap(res);
                }
            }
            - +

            这书里讲得云里雾里的，百度了一下：

            + +

            比如说书给例子，线程向共享对象读写数据，线程是操作对象A，共享对象是被操作对象B。则：

            +

            竞态条件：在乎的是被线程操控的共享对象的结果是否正确

            +

            数据竞争：在乎的是操作共享对象后，线程的结果是否正确。

            + +

            确实，书里对数据竞争强调的是一个读一个写，对竞态条件更像是两个同时写

            +

            复合操作

            -

            将线程安全性委托给独立的状态变量

            + -

            定义

            - -

            意思就是保证一个类里面仅有一个状态，只要该状态是线程安全的，那么该类也就是线程安全的。

            -

            示例

            //线程安全
            public class Point {
                public final int x,y;

                public Point(int x, int y) {
                    this.x = x;
                    this.y = y;
                }
            }
            +

            我们可以用一个线程安全类来解决前面的Count请求的需求：

            +
            @ThreadSafe
            public class CountingFactorizer implements Servlet{
                private final AtomicLong count = new AtomicLong(0);

                public long getCount(){ return count.get(); }

                public void service(SevletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    BigInteger[] factors = factor(i);
                    count.incrementAndGet();
                    encodeIntoResponse(resp,factors);
                }
            }
            -
            //将线程安全委托给ConcurrentMap
            public class DelegatingVehicleTracker {
                //用了两个
                private final ConcurrentMap<String,Point> locations;
                private final Map<String,Point> unmodifiableMap;

                public DelegatingVehicleTracker(Map<String,Point> ps) {
                    locations = new ConcurrentHashMap<>(ps);
                    unmodifiableMap = Collections.unmodifiableMap(locations);
                }

                public Map<String,Point> getLocations(){
                    //unmodifiableMap baked by locations,所以locations变化也会反映到unmodifiableMap上
                    //目的只是为了提供外界无法修改的视图
                    //不得不说真是妙啊
                    return unmodifiableMap;
                }
                public Point getLocation(String id){
                    return locations.get(id);
                }

                public void setLocation(String id,int x,int y){
                    if (locations.replace(id,new Point(x,y)) == null){
                        throw new IllegalArgumentException();
                    }
                }
            }
            - - + -
            public Map<String,Point> getLocations(){
                return Collections.unmodifiableMap(new HashMap<>(locations));
            }
            +

            加锁机制

            线程安全分析法与为什么要加锁

            上面说到，当对象内仅有一个状态时，可以通过使用线程安全类来保障原子性。但当对象里存在多个状态时，就必须用锁来进行线程同步，而非简单地用多个线程安全类。

            +

            还是以上面的实例来解释。

            + -

            委托给多个状态变量

            +
            public class UnsafeCachingFactorizer implements Servlet{
                private final AtomicReference<BigInteger> lastNumber = new AtomicReference<>();
                private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<>();

                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    /*
                    此处产生了竞态条件。
                    如果一个变量在此之后，return之前修改了lastFactors，就会寄
                    */
                    if (i.equals(lastNumber.get())) encodeIntoResponse(resp,lastFactors.get());
                    else{
                        BigInteger[] factors = factor(i);
                        //本该需要瞬间一起完成的两个动作之间有时间间隔，不具原子性
                        lastNumber.set(i);
                        lastFactors.set(factors);
                        encodeIntoResponse(resp,factors);
                    }
                }
            }
            -

            也就是说这些对象彼此不会构成不变性条件。

            -
            //将线程安全性委托给多个状态变量
            public class VisualComponent {
                private final List<KeyListener> keyListeners = new CopyOnWriteArrayList<>();
                private final List<MouseListener> mouseListeners = new CopyOnWriteArrayList<>();
                
                public void addKeyListener(KeyListener listener){
                    keyListeners.add(listener);
                }

                public void addMouseListener(MouseListener listener){
                    mouseListeners.add(listener);
                }

                public void removeKeyListener(KeyListener listener){
                    keyListeners.remove(listener);
                }

                public void remiveMouseListener(MouseListener listener){
                    mouseListeners.remove(listener);
                }
            }
            - -

            而且键盘监听和鼠标监听彼此独立。

            -

            不独立多个状态变量不能委托

            public class NumberRange {
                //不变性条件： lower<=upper
                private final AtomicInteger lower = new AtomicInteger(0);
                private final AtomicInteger upper = new AtomicInteger(0);

                public void setLower(int i){
                    //先检查后执行
                    if (i>upper.get()){
                        throw new IllegalArgumentException();
                    }
                    lower.set(i);
                }
                public void setUpper(int i){
                    if (i<lower.get()){
                        throw new IllegalArgumentException();
                    }
                    upper.set(i);
                }
                public boolean isInRange(int i){
                    return (i>=lower.get() && i<=upper.get());
                }
            }
            + - +

            这段论述非常精彩，昭示了两个道理：1.分析线程安全性的时候，可以从“不变性条件不被破坏”开始考虑，首先考虑不变性条件应该是什么。2.在不变性条件涉及的多个变量彼此不独立，因而这些变量需要同时同步更新，上面那个例子就是因为不变性约束条件中的两个不独立变量没有同时同步更新。

            + -

            根本原因就是因为不独立。

            - + +

            确实，非常重要的一点就是在两个需要连续同时修改的变量之间有了并行的时间间隔，导致此期间并行的线程的不变性被破坏。

            +

            内置锁

            -

            发布被委托的状态变量

            什么时候可以发布

            - +

            同步代码块包含两部分，锁的引用和保护的代码段。关键字synchronized修饰的方法就是一段同步代码段，其锁对象为当前实例【非静态方法】或者是当前class的实例【静态方法】。

            +
            +

            这个具体的“锁”是什么以前是真不知道。已知的是所有Object都有wait和什么什么notify方法。不过想想也确实。所有线程争抢着访问一个对象的某个同步方法段，这不正跟所有线程争抢着一个锁是差不多意思的吗？“锁”的定义其实是很宽泛的

            +
            + -

            示例

            +

            java的内置锁并非无饥饿的。当线程B永远不释放锁，A会一直等待下去。

            + -
            package sit;
            @ThreadSafe
            public class SafePoint {
                //注意此处x和y没有用任何同步修饰词修饰
                private int x,y;
                private SafePoint(int[] a){
                    this(a[0],a[1]);
                }

                //此处为什么不直接用this(p.x,p.y)呢？
                //是因为x和y本身并没有任何线程安全的防护手段，这样做的话会发生竞态条件。况且x和y也被实例封闭了
                //私有构造函数捕获模式
                public SafePoint(SafePoint p){
                    this(p.get());
                }

                public  SafePoint(int x,int y){
                    this.x=x;
                    this.y=y;
                }

                //x、y都放入数组，保证x和y的同时读写，nb
                public synchronized int[] get(){
                    return new int[] {x,y};
                }

                public synchronized void set(int x,int y){
                    this.x=x;
                    this.y=y;
                }
            }
            +

            我们可以用synchronized来解决上面的计数器问题，即直接给service方法设为synchronized。当然这种方法性能很糟糕，因为它极大降低了并发度。

            +

            重入

            -
            //跟上面那个委托没什么差，区别只在于上面的那个SafePoint类，既是线程安全的，又是可修改的
            public class PublishingVehicleTracker {
                private final Map<String,SafePoint> locations;
                private final Map<String,SafePoint> unmodifiableMap;

                public PublishingVehicleTracker(Map<String,SafePoint> locations){
                    this.locations = new ConcurrentHashMap<>(locations);
                    this.unmodifiableMap = Collections.unmodifiableMap(this.locations);
                }

                public Map<String,SafePoint> getLocations(){
                    return unmodifiableMap;
                }

                public SafePoint getLocation(String id){
                    return locations.get(id);
                }

                public void setLocations(String id,int x,int y){
                    if (!locations.containsKey(id))
                        throw new IllegalArgumentException();
                    locations.get(id).set(x,y);
                }
            }
            +

            其中关于粒度的理解：

            +

            不是“每一次调用获取一次锁，该锁属于该此调用”，而是“每个线程调用时获取一次锁，该锁属于该线程”

            + - - -

            这仅仅是一个委托发布的实例。

            -

            在现有的线程安全类中添加功能

            引论

            + -

            比如说想给vector添加一个“put-if-absent”

            - +
            public class Widget {
                public synchronized void doSomething(){

                }
            }

            class LoggingWidget extends Widget{
                @Override
                public synchronized void doSomething() {
                    System.out.println(toString()+":calling doSomething.");
                    super.doSomething();
                }
            }
            -

            可以用子类扩展法，也可以直接加源代码。后者有时候源代码不可访问，前者的父类很多域可能不对子类开发，并且非常脆弱。因而下面介绍几种比较好的机制。

            -

            客户端加锁机制

            定义和实例

            +

            比如上述代码，创建了一个LoggingWidget实例，然后调用该实例的dosmething方法，就会获取到该实例的锁。如果不允许重入，那么在做super.doSomething时，该实例的锁【注意，是同一个实例】已经被占用还未释放，因此产生死锁。有重入就可以避免此问题。

            +

            用锁来保护状态

            -
            @NotThreadSafe
            public class NotThreadSafeListHelper<E> {
                public List<E> list = Collections.synchronizedList(new ArrayList<>());
                
                public synchronized boolean putIfAbsent(E x){
                    boolean absent = !list.contains(x);
                    if (absent)
                        list.add(x);
                    return absent;
                }
            }
            + - +

            但这很考验人的记性。一旦你在某个地方忘了同步了就会寄。

            + -

            我曹，66666666

            -

            也就是说，这里加的是ListHelper的锁，只能让别的线程不能通过putIfAbsent方法同时修改list，但别的线程完全可以直接获取list再修改。

            - -

            客户端指的是我们的ListHelper。我们正是不知道list这个对象使用的是哪一个锁才发愣的。

            -

            所以我们使用ArrayList自身的锁，也就是list自己的内置，来加锁。

            -
            //使用客户端加锁实现
            @ThreadSafe
            public class ListHelper<E> {
                public List<E> list = Collections.synchronizedList(new ArrayList<>());

                public boolean putIfAbsent(E x){
                    synchronized(list) {
                        boolean absent = !list.contains(x);
                        if (absent)
                            list.add(x);
                        return absent;
                    }
                }
            }
            -

            评价

            +

            活跃性与性能

            上面那个直接对service方法进行synchronized的改善方法粒度太粗了，可以试试如下方法：

            +
            @ThreadSafe
            public class CachedFactorizer implements Servlet{
                @GuardedBy ("this") private BigInteger lastNumber;
                @GuardedBy ("this") private BigInteger[] lastFactors;
                @GuardedBy ("this") private long hits;
                @GuardedBy ("this") private long cacheHits;

                public synchronized long getHits(){return hits;}
                public synchronized double getCacheHitRatio(){
                    return (double)cacheHits/(double) hits;
                }

                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    BigInteger[] factors = null;
                    synchronized (this){
                        ++hits;
                        if (i.equals(lastNumber)){
                            ++cacheHits;
                            factors = lastFactors.clone();
                        }
                    }
                    //局部变量无需同步保护
                    if (factors == null){
                        factors = factor(i);
                        synchronized (this){
                            lastNumber = i;
                            lastFactors = factors.clone();
                        }
                    }
                    encodeIntoResponse(resp,factors);
                }
            }
            - + -

            它非常依赖于其他类的客户端加锁机制。

            - +

            毕竟因数分解的时候无需同步保护，因为这时候参与运算的都是局部变量。

            + -

            确实，毕竟你锁被外界拿去用了。

            -

            组合

            -
            public class ImprovedList<T> implements List<T> {
                //实例封闭
                private final List<T> list;

                public ImprovedList(List<T> list){this.list=list;}

                public synchronized boolean putIfAbsent(T x){
                    boolean contains = list.contains(x);
                    if (contains)
                        list.add(x);
                    return !contains;
                }

                public synchronized void clear(){list.clear();}
                //... 按照类似的方式委托List接口其他未实现的方法
            }
            - +

            第三章 安全地共享对象

            上一章讲述了，线程安全的本质就是对共享和可变状态进行管理，以及介绍了用锁来保护状态。

            +

            本章将引入同步除原子性外的另一特性——可见性，然后再介绍如何构建线程安全类，并且安全地发布和共享对象。

            +

            关键词：可见性 Volatile 线程封闭 不可变对象

            + -

            是的，跟synchronizedList非常像

            - + -

            这也就是用的java的监视器模式了

            -

            第五章 基础构建模块

            -

            保证独立即可委托，从而构建一个线程安全类

            - -

            同步容器类

            +

            可见性

            引例——可见性的定义

            public class Main {
                private static boolean ready;
                private static int number;

                private static class ReaderThread extends Thread{
                    public void run(){
                        while(!ready){
                            Thread.yield();
                        }
                        System.out.println(number);
                    }
                }

                public static void main(String[] args){
                    new ReaderThread().start();
                    number=42;
                    ready=true;
                }
            }
            -

            差不多都是使用的监视器模式。

            -

            同步容器类：Vector、Hashtable、Collections.synchronizedXxx

            -

            同步容器类的问题

            + -

            也就是需要避免两个原子操作之间的非线程安全的时间间隔。

            -
               public static Object getLast(Vector list){
                   //复合操作
                   //先检查后执行
                   int lastIndex = list.size()-1;
                   return list.get(lastIndex);
               }

            public static void deleteLast(Vector list){
                       int lastIndex = list.size()-1;
                       list.remove(lastIndex);
               }
            + - +
            +

            关于此程序显示出的对于内存可见性的理解，可以看这篇文章：

            +

            多线程(六):并发编程的三大特性之可见性

            + -

            它这段话说得非常好。由于Vector这个类本身是线程安全的，因而它可以保证外部任何操作都不会导致该对象因为并发而被破坏。但是，我们用不加锁的复合操作虽然不会破坏Vector，但可能导致不能出现我们想要的结果。

            -

            所以我们必须用锁机制来对此复合操作进行保护：

            -
            public static Object getLast(Vector list){
                synchronized (list) {
                    //复合操作
                    //先检查后执行
                    int lastIndex = list.size()-1;
                    return list.get(lastIndex);
                }
            }

            public static void deleteLast(Vector list){
                synchronized (list){
                    int lastIndex = list.size()-1;
                    list.remove(lastIndex);
                }
            }
            +

            其实原因非常显而易见：主线程改了之后不会立刻把变量刷新到主存【可能默认是在ret时刷新，或者定时刷新，前者会导致相互等待的死锁，后者也会产生性能问题】，导致主线程的那个修改的flag变量对t1线程是**不可见**的，因此t1会继续循环等待。

            +
            +

            失效数据

            -

            除此之外，迭代也是一种经典的复合操作。我们可以通过下面这种粗粒度加锁来避免：

            -
            public static void travel(Vector list){
                synchronized (list) {
                    for (int i=0;i<list.size();i++){
                        //do something
                    }
                }
            }
            + + -

            迭代器与ConcurrentModificationException

            -

            所以才会引入fail-fast机制。

            - +

            最低安全性

            -
            -

            foreach语法糖内部是通过Iterator来实现的。

            -

            Java 的 foreach 本质

            -
            public void testIterableForEach() {
                List<String> list = new ArrayList<>();
                for (String str : list) {
                    System.out.println(str);
                }
            }
            //反编译后：
            public void testIterableForEach() {
                List<String> list = new ArrayList<>();
                Iterator i = list.iterator();
                while(i.hashNext()){
                    String str = (String)i.next();
                    System.out.println(str);
                }
            }
            -
            - +

            注意，最低安全性不适用于非volatile类型的64位数据。

            + - + -

            可见同步容器类还是有很多局限性的。

            -

            隐藏迭代器

            有时候，迭代会隐藏起来。要一个个揪出需要加锁的地方是非常麻烦的。

            -
            //隐藏在字符串连接中的迭代操作
            @NotThreadSafe
            public class HiddenIterator {
                private final Set<Integer> set = new HashSet<>();

                public synchronized void add(Integer i){    set.add(i); }
                public synchronized void remove(Integer i){ set.remove(i);  }

                public void addTenThings(){
                    Random r = new Random();
                    for (int i=0; i<10; i++) {
                        add(r.nextInt());
                    }
                    //隐式迭代
                    System.out.println("DEBUG: Added ten elements to "+ set);
                }
            }

            - - +

            加锁与可见性

            - + +

            要实现这种操作，我们可以设想一下关于内存可见性这一块内置锁的实现原理：lock时绑定指定变量，unlock时再刷新这个/些绑定变量的内存。

            + +

            所以说得有锁，并且锁还得是对的。

            +

            看着看着有种always语句块的感觉了2333

            + -

            并发容器类

            同步容器类的加锁太粗粒度了，导致并发性弱。因而引入并发容器类来解决问题。

            - -

            ConcurrentHashMap —— HashMap

            -

            CopyOnWriteArrayList —— List

            - - +

            Volatile关键字

            Volatile保证内存可见性

            到其他线程。【我想大概就是一改变了，就马上刷新内存中的旧值，然后也许通过什么嗅探检测到值变化，通知所有线程改变自己持有的旧值。】 -

            BlockingQueue

            - + -

            ConcurrentSkipListMap —— TreeMap

            -

            ConcurrentSkipListSet —— TreeSet

            -

            ConcurrentHashMap

            +

            注意不放在寄存器里或者线程的私有栈里

            + -

            使用分段锁来细粒度加锁。

            - +
            -

            关于ConcurrentHashMap的分段锁：ConcurrentHashMap

            -

            JDK1.7中，ConcurrentHashMap 类所采用的正是分段锁的思想，将 HashMap 进行切割，把 HashMap 中的哈希数组切分成小数组，每个小数组有 n 个 HashEntry 组成，其中小数组继承自ReentrantLock（可重入锁），这个小数组名叫Segment。

            -

            JDK1.8 中 ConcurrentHashMap 类取消了 Segment 分段锁，采用 CAS + synchronized 来保证并发安全，数据结构跟 jdk1.8 中 HashMap 结构类似，都是数组 + 链表（当链表长度大于 8 时，链表结构转为红黑二叉树）结构。

            -

            ConcurrentHashMap 中 synchronized 只锁定当前链表或红黑二叉树的首节点，只要节点 hash 不冲突，就不会产生并发，相比 JDK1.7 的 ConcurrentHashMap 效率又提升了 N 倍！

            +
            +

            Volatile不保证原子性

            +
            -

            关于ConcurrentHashMap的弱一致性：ConcurrentHashMap的弱一致性

            -

            get方法是弱一致的，是什么含义？可能你期望往ConcurrentHashMap底层数据结构中加入一个元素后，立马能对get可见，但ConcurrentHashMap并不能如你所愿。换句话说，put操作将一个元素加入到底层数据结构后，get可能在某段时间内还看不到这个元素，若不考虑内存模型，单从代码逻辑上来看，却是应该可以看得到的。

            -
            - +

            volatile为什么不能保证原子性？

            +

            但这个有争议：

            + -

            精确值—>估计值

            - +
              +
            • 在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。
              • +
            +

            也就是说，

            +

            如果线程B在+1前知道数据无效了，就会重新载入数据然后+1然后载入内存，结果正确；

            +

            如果线程B在+1后才知道数据无效，虽然会重新载入数据，数据为A修改后的新数据，但是此时指令无法回退，因而只能继续执行下一条指令：写回内存，B写回内存的是A修改后的新数据，因而结果错误。

            +
            大致过程：
            a:mov reg 1
            b:mov reg 1
            a:add reg 1
            b:add reg 1
            a:mov reg mem
            然后b线程得到通知，重新载入数据:mov reg mem
            但是指令无法回退：mov reg mem
            因而结果是A修改后的值被写入了两遍。
            - +

            所以其实volatile仅确保单次读写的瞬时线程安全。

            + -
            -

            关于AQS框架：重大发现，AQS加锁机制竟然跟Synchronized有惊人的相似

            -

            在并发多线程的情况下，为了保证数据安全性，一般我们会对数据进行加锁，通常使用Synchronized或者ReentrantLock同步锁。Synchronized是基于JVM实现，而ReentrantLock是基于Java代码层面实现的，底层是继承的AQS。

            -

            AQS全称**AbstractQueuedSynchronizer**，即抽象队列同步器，是一种用来构建锁和同步器的框架。

            -

            我们常见的并发锁ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier都是基于AQS实现的，所以说不懂AQS实现原理的，就不能说了解Java锁。

            -
            -
            -

            并发容器类不能实现独占访问：

            -

            类似ConcurrentHashMap的并发容器不能采用客户端加锁机制，因为并发容器没有采用synchronized内置锁而大多基于AQS框架（不是独占式的锁），所以使用客户端加锁机制来扩展并发容器的方法是不能实现的。

            -

            所以说不能客户端加锁不是不提倡，而是真的不行【】

            +

            以下是别人的理解扩展：

            +

            对volatile不具有原子性的理解

            +

            volatile 无法保证原子性一个简单示例的疑问

            +

            Java并发编程：volatile关键字解析

            -

            所以最好还是用并发容器类替代同步容器类。

            -

            对部分复合操作的支持

            +

            Volatile的使用方法

            -

            客户端加锁不能使用，就只能用它提供的东西了。

            -

            CopyOnWriteArrayList

            Copy-On-Write意为“写入时复制”，仅当要修改的时候，才会重新创建一次副本，实现可变性。犹记得第一次接触到这个思想是在操作系统的fork()创建子进程的原理那个地方，那可真是有些惊为天人23333

            - + - +

            下面给出一个volatile的典型用法：检查某个状态标记以判断是否退出循环。【也就是上文那个例子】

            +
            volatile boolean asleep;
            //...
            	while(!asleep)	countingSheep();
            -

            也就是说，COWAL内部维护的base数组是事实不可变的，因而访问它的时候不需要同步。但是，我们事实上需要一个可变的并发容器，那该怎么办呢？解决方法就是每次要修改的时候，直接把base数组换成一个新的数组，就像之前某个例子一样，这样就能实现可变性了。

            -

            与此同时，这样的方法也能保证多线程访问时的内存可见性。

            -

            由COWAL的底层代码：

            -
            //base数组，volatile保证引用一变就可以刷新
            private transient volatile Object[] array;

            final Object[] getArray() {
                return array;
            }

            final void setArray(Object[] a) {
                    array = a;
            }

            public boolean add(E e) {
                //获取锁
                final ReentrantLock lock = this.lock;
                lock.lock();
                try {
                    //getArray:直接返回base数组的引用
                    Object[] elements = getArray();
                    int len = elements.length;
                    //创建新数组再修改
                    Object[] newElements = Arrays.copyOf(elements, len + 1);
                    newElements[len] = e;
                    //直接改变base数组的引用
                    setArray(newElements);
                    return true;
                } finally {
                    lock.unlock();
                }
            }
            -

            可知，它保证可见性，是直接修改引用的，并且注意，对原数组的拷贝是浅拷贝的。这样一来，就既不会改变原数组的东西，也能保证可见性的更新迅速了。我的评价是牛逼爆了。

            - +

            发布与逸出

            发布与逸出的概念

            通俗地解释发布和逸出

            + -

            阻塞队列和生产者—消费者模式

            基本介绍

            + -

            简直就是为了生产者消费者而生的

            - + - + -

            这两段话说得非常本质，需要有个缓冲队列本质上就是因为处理数据速率的不同，生产者消费者也起到了解耦作用

            - +

            这个“逸出作用域”的表述非常不错。

            + -

            所以说用有界队列还是更好

            -

            BlockingQueue有多种实现。

            -

            ArrayBlockingQueue和LinkedBlockingQueue是FIFO队列，PriorityBlockingQueue是优先队列，最后还有一个特殊的SynhronousQueue。

            - - +

            什么时候会发生发布和逸出

            外部方法

            当把一个对象传递给某个外部方法，就相当于发布了这个对象。

            +

            外部方法：

            +
            发布内部的类实例

            “this escape”

            + +
            public class ThisEscape{
                public final int id;
                public final String name;
                public ThisEscape(EventSource source){
                    id = 1;
                    //发布
                    source.registerListener(
                        //内部类
                    	new EventListener(){
                            public void onEvent(Event e){
                                //doSomething(e);
                            }
                        }
                    );
                    name = "escape";
                }
            }
            -

            实例：桌面搜索

            +
            +

            java this 逸出_Java并发编程——this引用逸出(“this” Escape)

            +

            并发编程实践中，this引用逃逸(“this”escape)是指对象还没有构造完成，它的this引用就被发布出去了。

            +

            ThisEscape在构造函数中引入了一个内部类EventListener，而内部类会自动的持有其外部类(这里是ThisEscape)的this引用。source.registerListener会将内部类发布出去，从而ThisEscape.this引用也随着内部类被发布了出去。但此时ThisEscape对象还没有构造完成 —— id已被赋值为1，但name还没被赋值，仍然为null。这样一来，就有些线程持有不完整实例，不确定性太大了

            +
            + -
            //生产者
            public class FileCrawler implements Runnable {
                private final BlockingDeque<File> fileQueue;
                private final FileFilter fileFilter;
                private final File root;

                public FileCrawler(BlockingDeque<File> fileQueue, FileFilter fileFilter, File root) {
                    this.fileQueue = fileQueue;
                    this.fileFilter = fileFilter;
                    this.root = root;
                }

                @Override
                public void run() {
                    try{
                        crawl(root);
                    }catch (InterruptedException e){
                        //中断处理
                        Thread.currentThread().interrupt();
                    }
                }

                private void crawl(File root) throws InterruptedException{
                    File[] entries = root.listFiles(fileFilter);
                    if (entries!=null){
                        for (File entry:entries){
                            //递归打印目录
                            if (entry.isDirectory())    crawl(entry);
                            else if (!alreadyIndexed(entry))    fileQueue.put(entry);
                        }
                    }
                }
            }

            //消费者
            public class Indexer implements Runnable{
                private final BlockingDeque<File> queue;

                public Indexer(BlockingDeque<File> q){
                    this.queue=q;
                }

                @Override
                public void run() {
                    try{
                        while(true){
                            indexFile(queue.take());
                        }
                    }catch(InterruptedException e){
                        Thread.currentThread().interrupt();
                    }
                }
            }
            +

            也就是说，如果是单线程情况下，这样做是没问题的，毕竟最后都会构造完整。但多线程情况下，这俩有时间间隔，因此会产生问题，并且不能靠简单地把这句发布对象的语句放在构造函数最后一行。

            + - +

            这段话非常值得注意

            +

            所以说上面那个例子的正确代码：

            + - +
            public class SafeListener {
                private final EventListener listener;

                private SafeListener(){
                    listener = new EventListener() {
                        public void onEvent(Event e){
                            //doSomething(e);
                        }
                    };
                }

                public static SafeListener newInstance(EventSource source){
                    SafeListener safe = new SafeListener();
                    source.registerListener(safe.listener);
                    return safe;
                }
            }
            -
            //启动生产者-消费者程序
               public static void startIndexing(File[] roots){
                   BlockingDeque<File> queue = new LinkedBlockingDeque<>(BOUND);
                   FileFilter filter = new FileFilter() {
                       @Override
                       public boolean accept(File pathname) {
                           return  true;
                       }
                   };

                   for (File root : roots){
                       new Thread(new FileCrawler(queue,filter,root)).start();
                   }
                   for (int i=0; i<N_CONSUMERS;i++){
                       new Thread(new Indexer((queue))).start();
                   }
               }
            +

            线程封闭

            线程封闭是什么

            -

            串行线程封闭

            + -

            安全发布

            - +

            线程封闭一般有三种方法，这三种方法的规范性是逐级递增的。

            +

            Ad-hoc线程封闭

            - +
            +

            这里，书写得非常地抽象。通过查阅资料可得解释得更通俗的：

            +

            Ad-hoc线程封闭

            +

            Example of ad hoc thread confinement in Java

            +

            总之其实精华就这一句话：

            +

            并且都是人为约束，并且一般可能会用volatile来控制单线程写这种情况下的同步。

            +
            // Don't modify this from any other thread than Thread X.
            // So use it read-only for those other threads.
            private volatile int someNumber;
            +
            +

            栈封闭

            -

            6666666

            -

            之所以叫“串行”，想必是因为这个过程：发布-转接-放弃访问权是一个串行过程。

            - +

            也就是我们前面说的，局部变量只能在该线程内访问，除非逸出了，否则是非常安全的。

            + + +

            对于基本类型

            -

            总而言之，串行线程封闭的具体做法就是，一个线程将一个安全发布的对象的所有权完全转移给另一个线程，保证之后自己不会再使用。这样一来，该对象就相当于被另一个线程封闭了。而如何保证“自己以后不再使用”呢？最简单的方法就是安全发布完这个东西后直接把这个东西给踢出去。

            -

            阻塞队列是自动会把这个东西安全发布然后就踢出去的，所以说阻塞队列简化了这个工作。

            - +意思就是说，java没有指针，获取不了这些不是对象的基本类型的引用，因而这些基本类型不可能通过调用外部方法之类的逸出【调用外部方法仅仅是取得它们的一份copy而非本身】，所以这些基本类型的局部变量始终封闭在线程内。 +

            对于引用类型

            +

            因而需要格外注意逸出问题

            +

            下面给出对基本类型和引用类型栈封闭的实例：

            +
            public int loadTheArk(Collection<Animal> candidates){
                //引用类型
                SortedSet<Animal> animals;
                //基本类型
                int numPairs = 0;
                Animal candidate = null;

                //需要详细写好注释↓
                //animals被封闭在方法中，不要使它们逸出！
                animals = new TreeSet<Animal>(new SpeciesGenderComparator());
                animals.addAll(candidates);
                for (Animal a : animals){
                    if (candidate == null || !candidate.isPotentialMate(a))
                            candidate = a;
                    else{
                        ark.load(new AnimalPair(candidate,a));
                        ++numPairs;
                        candidate = null;
                        new ThreadLocal<char[]>(){

                        };
                    }
                }
                return numPairs;
            }
            -

            双端队列与工作密取

            - +

            ThreadLocal类

            +

            史上最全ThreadLocal 详解（一）

            +
            +

            简介和应用实例

            上面介绍了使用局部变量来实现线程封闭的方法，也就是栈封闭。它只要合理地控制在调用方法时不发生逸出，就可以实现线程安全。

            +

            当有多个线程都需要同一类对象【比如Connection对象、ThreadID】，并且要求每个线程内的该对象是不一样的，并且该对象需要在多个方法中访问，栈封闭的方法就显得有些麻烦和不够优雅：需要在每个线程内都创建一个不同的对象实例，并且在调用方法的时候，都把该对象实例作为参数传进去。

            +

            这时候就需要ThreadLocal类了。

            +

            ThreadLocal类会给每个线程分配一个对象，并且仅需使用get方法，就能自动地把线程中的对象给弄出来。并且这些分配的对象对于各个线程来说都是隔离，相互不可见的，因此实现了线程封闭，具有安全性。

            + +

            以ThreadID为例：

            +

            For example, the class below generates unique identifiers local to each thread. A thread’s id is assigned the first time it invokes ThreadId.get() and remains unchanged on subsequent calls.下面代码保证每个线程首次调用ThreadId.get方法后可以分配到一个不重ID，并且ID一旦确定，之后再调用get方法得到的ID是不会改变的。它这相当于维护了一个共有的计数器局部变量。

            +
            import java.util.concurrent.atomic.AtomicInteger;
            public class ThreadId {
                // Atomic integer containing the next thread ID to be assigned
                private static final AtomicInteger nextId = new AtomicInteger(0);
             
                // Thread local variable containing each thread's ID
                private static final ThreadLocal<Integer> threadId =
                    new ThreadLocal<Integer>() {
                        @Override protected Integer initialValue() {
                            return nextId.getAndIncrement();
                    }
                };
             
                // Returns the current thread's unique ID, assigning it if necessary
                public static int get() {
                    return threadId.get();
                }
            }
            -

            阻塞方法与中断方法

            阻塞方法

            +

            对于每个想获取自身ThreadID的线程，在所有想用到ID的方法中，只需：

            +
            void method(){
            	AtomicInteger myID = ThreadID.get();
            	//do something
            }
            -

            当某方法抛出InterruptedException时，表明该方法为阻塞方法，也即这个方法会在执行过程中由于各种原因而被阻塞。如果这个方法被中断，它将会努力提前结束阻塞状态。

            -

            中断方法

            +

            而不用：

            +
            AtomicInteger myID = getID();
            void method(AtomicInteger myID){
                //do something
            }
            - +

            这样大大简化了实现。

            +

            再比如：

            + -

            处理InterruptedException的两种选择

            +
            private static final String DB_URL = "";
            private static ThreadLocal<Connection> connectionHolder
                    = new ThreadLocal<Connection>(){
                        public Connection initialValue(){
                            try {
                                return DriverManager.getConnection(DB_URL);
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
            };
            public static Connection getConnection(){
                return connectionHolder.get();
            }
            -

            传递InterruptedException

            + -

            恢复中断

            +

            关于这个的大概代码猜想：

            +

            这样一来，在一个线程中使用toString，就仅需造一个buf【这个是ThreadLocal封闭】，而不用每次调用都造一个【这个是栈封闭】了

            +
            private static final ThreadLocal<char[]> buf
             	= new ThreadLocal<char[]>(){
             		@Override
             		public char[] initialValue(){
                         return new char[12];
                     }
            		};

            @Override
            public static String toString(int i) {
             //...
             //使用buf
             char[] buffer = buf.get();
             //...
            }
            + + + +

            底层实现

            大致结构

            我们可以初步猜想，ThreadLocal大概是通过一个map实现的，里面存储着<Thread,value>这样的键值对，每次就能通过Thread来取出对应的value了。Java低版本确实是这么做的。但Java的高版本对此进行了优化。

            + +

            从本来的：ThreadLocalMap<Thread, value> ∈ ThreadLocal

            +

            变成了： ThreadLocalMap<ThreadLocal, value> ∈ Thread

            +

            并且其中的ThreadLocal这个key是以弱引用【WeakReference】的方式实现的。

            -

            此处关于为什么如果代码是Runnable的一部分就不能抛出异常：

            -

            是因为java的异常继承体系。

            -

            在重写的run方法中,我们只能够进行异常的捕获而不能够抛出异常,原因是因为在父类Runnable接口中,run方法没有抛出异常,则实现Runnable的子类就无法抛出异常

            -

            所以实际上是语法层面上不允许。

            +

            ThreadLocal探究

            +

            这样的结构演进有什么好处
            在旧版的ThreadLocal中，所有线程都将本地变量存在同一个ThreadLocalMap中，当并发量比较高的时候，ThreadLocalMap中的数据量会很大，而新版的ThreadLocalMap是属于线程的，也就是每个线程都操作属于自己的ThreadLocalMap，那么map中存储的变量就只有自己所存入的，数据量大大减少。

            +

            还有一个好处，旧版的ThreadLocalMap属于ThreadLocal，当Thread实例被销毁时ThreadLocalMap里该线程的数据不会被同时销毁【这也许就带来了危险性】，而新版ThreadLocalMap属于线程，线程被销毁时，ThreadLocalMap也随之销毁。

            - +
            源码阅读
            +

            This class provides thread-local variables.线程局部变量，也就是我们说的线程封闭手法。

            +

            These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable. 每个线程都有它自己的、独立初始化的该变量的副本。

            +

            ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).它一般用于私有静态字段，whose 状态和线程关系密切。

            +

            Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the ThreadLocal instance is accessible.

            +

            After a thread goes away, all of its copies of thread-local instances are subject to garbage collection (unless other references to these copies exist).最后会被垃圾回收

            +
            +
            public class ThreadLocal<T> {
                
                private final int threadLocalHashCode = nextHashCode();

                
                private static AtomicInteger nextHashCode =
                        new AtomicInteger();

                
                private static final int HASH_INCREMENT = 0x61c88647;

                
                private static int nextHashCode() {
                    return nextHashCode.getAndAdd(HASH_INCREMENT);
                }

                /*
                它这个初始化方法非常聪明且独特。
                一般使用它的时候是直接new然后重载一个匿名内部类的，
                于是就直接在建立匿名内部类时override此方法，在里面构造初始化的对象，
                且该方法仅在get调用的时候才会顺带调用
                有一种lazy的思想在里面。
                Normally, this method is invoked at most once per thread.
                */
                protected T initialValue() {
                    return null;
                }

                //Creates a thread local variable.
                //The initial value of the variable is determined by Supplier的get方法.
                public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
                    return new SuppliedThreadLocal<>(supplier);
                }
                
                public ThreadLocal() {
                }

                
                public T get() {
                    //也就是说，每个线程都有个ThreadLocal的map成员变量
                    //里面装的是<ThreadLocal变量，该变量在该线程的值>这样的键值对
                    Thread t = Thread.currentThread();
                    //得到线程里存储的ThreadLocalMap
                    ThreadLocalMap map = getMap(t);
                    if (map != null) {
                        //<ThreadLocal, value>
                        ThreadLocalMap.Entry e = map.getEntry(this);
                        if (e != null) {
                            @SuppressWarnings("unchecked")
                            T result = (T)e.value;
                            return result;
                        }
                    }
                    //map==null【还没有线程局部变量】或者e==null【还没有该线程局部变量】
                    return setInitialValue();
                }
                
                boolean isPresent() {
                    Thread t = Thread.currentThread();
                    ThreadLocalMap map = getMap(t);
                    return map != null && map.getEntry(this) != null;
                }
                
                private T setInitialValue() {
                    //获取初始化值
                    T value = initialValue();
                    Thread t = Thread.currentThread();
                    ThreadLocalMap map = getMap(t);
                    if (map != null) {
                        map.set(this, value);
                    } else {
                        //传入空map的第一个结点
                        createMap(t, value);
                    }
                    if (this instanceof TerminatingThreadLocal) {
                        TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
                    }
                    return value;
                }
                
                public void set(T value) {
                    Thread t = Thread.currentThread();
                    ThreadLocalMap map = getMap(t);
                    if (map != null) {
                        map.set(this, value);
                    } else {
                        createMap(t, value);
                    }
                }
                
                public void remove() {
                    ThreadLocalMap m = getMap(Thread.currentThread());
                    if (m != null) {
                        m.remove(this);
                    }
                }
                
                ThreadLocalMap getMap(Thread t) {
                    return t.threadLocals;
                }
                
                void createMap(Thread t, T firstValue) {
                    t.threadLocals = new ThreadLocalMap(this, firstValue);
                }
                
                static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
                    return new ThreadLocalMap(parentMap);
                }
                
                T childValue(T parentValue) {
                    throw new UnsupportedOperationException();
                }
                
                static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {

                    private final Supplier<? extends T> supplier;

                    SuppliedThreadLocal(Supplier<? extends T> supplier) {
                        this.supplier = Objects.requireNonNull(supplier);
                    }

                    @Override
                    protected T initialValue() {
                        return supplier.get();
                    }
                }

                /*
                ThreadLocalMap is a customized hash map suitable only for maintaining thread local values.
                To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.key【ThreadLocal】是弱引用的
                */
                static class ThreadLocalMap {

                    /*
                    Note that null keys (i.e. entry.get() == null) mean that the key is no longer referenced, so the entry can be expunged from table. Such entries are referred to as "stale entries" in the code that follows.
               		意思就是说陈旧条目【stale entry】指的是key为空的
                    */
                    static class Entry extends WeakReference<ThreadLocal<?>> {
                        //The value associated with this ThreadLocal.
                        Object value;

                        Entry(ThreadLocal<?> k, Object v) {
                            super(k);
                            value = v;
                        }
                    }

                    //The initial capacity -- MUST be a power of two.
                    private static final int INITIAL_CAPACITY = 16;
                    
                    private Entry[] table;
                    
                    private int size = 0;
                    
                    //The next size value at which to resize.
                    private int threshold; // Default to 0

                    //Set the resize threshold to maintain at worst a 2/3 load factor.
                    //默认情况下，装载因子为2/3
                    private void setThreshold(int len) {
                        threshold = len * 2 / 3;
                    }

                    //使i增加，并且让增加后的结果模len。也就是(++i)%len。
                    private static int nextIndex(int i, int len) {
                        return ((i + 1 < len) ? i + 1 : 0);
                    }
                    
                    //也就是(--i)%len。
                    private static int prevIndex(int i, int len) {
                        return ((i - 1 >= 0) ? i - 1 : len - 1);
                    }

                    //Construct a new map initially containing (firstKey, firstValue). 
                    //ThreadLocalMaps are constructed lazily,
                    //so we only create one when we have at least one entry to put in it.
                    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
                        table = new Entry[INITIAL_CAPACITY];
                        //依旧是HashMap里面经典的掩码操作，key的hashcode作为entry在table里的序号
                        //与hashmap的差别就在于，hashmap的桶table一个里面可以存放多个结点，
                        //但这里的ThreadLocal的hash显然是不冲突的，因而只能存放一个结点
                        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
                        table[i] = new Entry(firstKey, firstValue);
                        size = 1;
                        setThreshold(INITIAL_CAPACITY);
                    }
                    
                    private ThreadLocalMap(ThreadLocalMap parentMap) {
                        Entry[] parentTable = parentMap.table;
                        int len = parentTable.length;
                        setThreshold(len);
                        table = new Entry[len];

                        for (int j = 0; j < len; j++) {
                            Entry e = parentTable[j];
                            //有对应结点
                            if (e != null) {
                                @SuppressWarnings("unchecked")
                                ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                                if (key != null) {
                                    Object value = key.childValue(e.value);
                                    Entry c = new Entry(key, value);
                                    int h = key.threadLocalHashCode & (len - 1);
                                    while (table[h] != null)
                                        h = nextIndex(h, len);
                                    table[h] = c;
                                    size++;
                                }
                            }
                        }
                    }
                    
                    private Entry getEntry(ThreadLocal<?> key) {
                        int i = key.threadLocalHashCode & (table.length - 1);
                        Entry e = table[i];
                        if (e != null && e.get() == key)
                            return e;
                        else
                            return getEntryAfterMiss(key, i, e);
                    }
                    
                    private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
                        Entry[] tab = table;
                        int len = tab.length;

                        while (e != null) {
                            ThreadLocal<?> k = e.get();
                            if (k == key)
                                return e;
                            if (k == null)
                                expungeStaleEntry(i);
                            else
                                i = nextIndex(i, len);
                            e = tab[i];
                        }
                        return null;
                    }
                    
                    private void set(ThreadLocal<?> key, Object value) {

                        // We don't use a fast path as with get() because it is at
                        // least as common to use set() to create new entries as
                        // it is to replace existing ones, in which case, a fast
                        // path would fail more often than not.

                        Entry[] tab = table;
                        int len = tab.length;
                        int i = key.threadLocalHashCode & (len-1);

                        for (Entry e = tab[i];
                             e != null;
                             e = tab[i = nextIndex(i, len)]) {
                            ThreadLocal<?> k = e.get();

                            if (k == key) {
                                e.value = value;
                                return;
                            }

                            if (k == null) {
                                replaceStaleEntry(key, value, i);
                                return;
                            }
                        }

                        tab[i] = new Entry(key, value);
                        int sz = ++size;
                        if (!cleanSomeSlots(i, sz) && sz >= threshold)
                            rehash();
                    }

                    
                    private void remove(ThreadLocal<?> key) {
                        Entry[] tab = table;
                        int len = tab.length;
                        int i = key.threadLocalHashCode & (len-1);
                        for (Entry e = tab[i];
                             e != null;
                             e = tab[i = nextIndex(i, len)]) {
                            if (e.get() == key) {
                                e.clear();
                                expungeStaleEntry(i);
                                return;
                            }
                        }
                    }

                    
                    private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                                   int staleSlot) {
                        Entry[] tab = table;
                        int len = tab.length;
                        Entry e;

                        // Back up to check for prior stale entry in current run.
                        // We clean out whole runs at a time to avoid continual
                        // incremental rehashing due to garbage collector freeing
                        // up refs in bunches (i.e., whenever the collector runs).
                        int slotToExpunge = staleSlot;
                        for (int i = prevIndex(staleSlot, len);
                             (e = tab[i]) != null;
                             i = prevIndex(i, len))
                            if (e.get() == null)
                                slotToExpunge = i;

                        // Find either the key or trailing null slot of run, whichever
                        // occurs first
                        for (int i = nextIndex(staleSlot, len);
                             (e = tab[i]) != null;
                             i = nextIndex(i, len)) {
                            ThreadLocal<?> k = e.get();

                            // If we find key, then we need to swap it
                            // with the stale entry to maintain hash table order.
                            // The newly stale slot, or any other stale slot
                            // encountered above it, can then be sent to expungeStaleEntry
                            // to remove or rehash all of the other entries in run.
                            if (k == key) {
                                e.value = value;

                                tab[i] = tab[staleSlot];
                                tab[staleSlot] = e;

                                // Start expunge at preceding stale entry if it exists
                                if (slotToExpunge == staleSlot)
                                    slotToExpunge = i;
                                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                                return;
                            }

                            // If we didn't find stale entry on backward scan, the
                            // first stale entry seen while scanning for key is the
                            // first still present in the run.
                            if (k == null && slotToExpunge == staleSlot)
                                slotToExpunge = i;
                        }

                        // If key not found, put new entry in stale slot
                        tab[staleSlot].value = null;
                        tab[staleSlot] = new Entry(key, value);

                        // If there are any other stale entries in run, expunge them
                        if (slotToExpunge != staleSlot)
                            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                    }

                    
                    private int expungeStaleEntry(int staleSlot) {
                        Entry[] tab = table;
                        int len = tab.length;

                        // expunge entry at staleSlot
                        tab[staleSlot].value = null;
                        tab[staleSlot] = null;
                        size--;

                        // Rehash until we encounter null
                        Entry e;
                        int i;
                        for (i = nextIndex(staleSlot, len);
                             (e = tab[i]) != null;
                             i = nextIndex(i, len)) {
                            ThreadLocal<?> k = e.get();
                            if (k == null) {
                                e.value = null;
                                tab[i] = null;
                                size--;
                            } else {
                                int h = k.threadLocalHashCode & (len - 1);
                                if (h != i) {
                                    tab[i] = null;

                                    // Unlike Knuth 6.4 Algorithm R, we must scan until
                                    // null because multiple entries could have been stale.
                                    while (tab[h] != null)
                                        h = nextIndex(h, len);
                                    tab[h] = e;
                                }
                            }
                        }
                        return i;
                    }

                    
                    private boolean cleanSomeSlots(int i, int n) {
                        boolean removed = false;
                        Entry[] tab = table;
                        int len = tab.length;
                        do {
                            i = nextIndex(i, len);
                            Entry e = tab[i];
                            if (e != null && e.get() == null) {
                                n = len;
                                removed = true;
                                i = expungeStaleEntry(i);
                            }
                        } while ( (n >>>= 1) != 0);
                        return removed;
                    }

                    
                    private void rehash() {
                        expungeStaleEntries();

                        // Use lower threshold for doubling to avoid hysteresis
                        if (size >= threshold - threshold / 4)
                            resize();
                    }

                    
                    private void resize() {
                        Entry[] oldTab = table;
                        int oldLen = oldTab.length;
                        int newLen = oldLen * 2;
                        Entry[] newTab = new Entry[newLen];
                        int count = 0;

                        for (int j = 0; j < oldLen; ++j) {
                            Entry e = oldTab[j];
                            if (e != null) {
                                ThreadLocal<?> k = e.get();
                                if (k == null) {
                                    e.value = null; // Help the GC
                                } else {
                                    int h = k.threadLocalHashCode & (newLen - 1);
                                    while (newTab[h] != null)
                                        h = nextIndex(h, newLen);
                                    newTab[h] = e;
                                    count++;
                                }
                            }
                        }

                        setThreshold(newLen);
                        size = count;
                        table = newTab;
                    }

                    
                    private void expungeStaleEntries() {
                        Entry[] tab = table;
                        int len = tab.length;
                        for (int j = 0; j < len; j++) {
                            Entry e = tab[j];
                            if (e != null && e.get() == null)
                                expungeStaleEntry(j);
                        }
                    }
                }
            }
            - +

            注意点：

            +
              +
            1. 哈希方法和解决哈希冲突
              +

              存在哈希冲突的话，大概是采用的线性探测方法。

              +
              2. +
            2. 解决内存泄漏

              关于其remove方法：

              +
              public void remove() {
              	ThreadLocalMap m = getMap(Thread.currentThread());
              	if (m != null)
              		m.remove(this);
              }
              //m.remove
              		private void remove(ThreadLocal<?> key) {
                          Entry[] tab = table;
                          int len = tab.length;
                          int i = key.threadLocalHashCode & (len-1);
                          //线性探测
                          for (Entry e = tab[i];
                               e != null;
                               e = tab[i = nextIndex(i, len)]) {
                              if (e.get() == key) {
                                  e.clear();
                                  expungeStaleEntry(i);
                                  return;
                              }
                          }
                      }
              +

              两篇文章都有解释

              +
              +

              remove方法，直接将ThrealLocal 对应的值从当前相差Thread中的ThreadLocalMap中删除。为什么要删除，这涉及到内存泄露的问题。

              +

              实际上 ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用，弱引用的特点是，如果这个对象只存在弱引用，那么在下一次垃圾回收的时候必然会被清理掉。

              +

              所以如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候会被清理掉的，这样一来 ThreadLocalMap中使用这个 ThreadLocal 的 key 也会被清理掉。但是，value 是强引用，不会被清理，这样一来就会出现 key 为 null 的 value。

              +

              ThreadLocal其实是与线程绑定的一个变量，如此就会出现一个问题：如果没有将ThreadLocal内的变量删除（remove）或替换，它的生命周期将会与线程共存。通常线程池中对线程管理都是采用线程复用的方法，在线程池中线程很难结束甚至于永远不会结束，这将意味着线程持续的时间将不可预测，甚至与JVM的生命周期一致。举个例字，如果ThreadLocal中直接或间接包装了集合类或复杂对象，每次在同一个ThreadLocal中取出对象后，再对内容做操作，那么内部的集合类和复杂对象所占用的空间可能会开始持续膨胀。
              ————————————————
              版权声明：本文为CSDN博主「倔强的不服」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
              原文链接：https://blog.csdn.net/u010445301/article/details/111322569

              +
              +
              +

              ThreadLocal内存泄漏问题的解析。
              前面我们说到它虽然线程安全，但是它存在一个问题那就是内存泄漏。

              +

              首先我们要明白为什么会内存泄漏，前面也说了ThreaLocal是一个弱引用，什么是弱引用就是当它为null时候，就会被垃圾回收机制给带走，重点就是，如果我们的ThreadLocal突然为null，然后就被回收了，但此时我们的ThreadLocalMap它的生命周期是和Thread相同的，简单理解就是，裤子没了，兜还在，兜里面还有我们的数据，这就造成了内存泄漏。

              +

              如何解决那：我们必须在使用完ThreadLocal后，执行remove()方法，避免内存溢出。
              ————————————————
              版权声明：本文为CSDN博主「某刘姓男子i的码农客栈」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
              原文链接：https://blog.csdn.net/qq_20783497/article/details/107980858

              +
              +
              3. +
            +

            不变性

            不可变对象

            不可变对象的线程安全性

            满足同步需求的另一种方案就是使用不可变对象。

            + -

            同步工具类

            +

            这个思路非常地简单粗暴：什么东西影响了，就直接让它消失。非常有意思2333

            +

            如果某个对象在创建后不能被修改，那么它就叫不可变对象。线程安全性是不可变对象的固有属性之一。

            + -

            实现同步的方法：使用同步容器类/并发容器类、使用锁、使用同步工具类

            - +

            比如说final域只能在声明的成员域或者构造函数中初始化，两者本质上都是在构造函数中初始化的。

            +

            并且不可变对象也更加安全。

            + -

            闭锁 CountDownLatch

            作用

            +

            不可变对象与final域

            不可变性不等于将对象中的所有域都设置为final域，因为final类型的域可以是对可变对象的引用。【这就类似C语言中const指针】当且仅当满足下列条件，对象才是不可变的：

            + - +
            +

            对于这里注释提到的String类，它讲得有些让人迷惑。因而我查阅资料得到解说如下：

            +

            String中hashCode方法的线程安全

            +
            class String{
            　　//默认值是0
            　　int hash;

            　　public int hashCode() {
                 //将成员变量hash缓存到局部变量
                 int h = hash;
            　　　　 //这里使用的是局部变量，因此没有多线程修改的风险
                 if (h == 0 && value.length > 0) {
                     char val[] = value;
                     //求hashcode过程使用局部h变量防止产生静态条件
                     for (int i = 0; i < value.length; i++) {
                         h = 31 * h + val[i];
                     }

                     //把求出的hashcode缓存到局部变量，原子操作
                     //这里不需要考虑线程可见性的问题，
                     //如果其它线程未能及时看到最新修改，重新计算hash值代价也不大
                     hash = h;
               	}
               	return h;
            	}  
            }
            +

            再回去看书中注释的描述：

            + +

            这个的意思就是说，对每个线程来说，同一个字符串hashcode值都是一样的【每次计算都得到相同的结果】，所以就不会产生多个线程计算出不同值的情况，导致不同步的发生。

            + -

            CountDownLatch

            +

            意思是说之所以hashcode值一样，是因为这个hashcode计算是基于不可变对象的：

            +
            private final char value[];
            -
            //使用CountDownLatch来进行计时测试
            public class TestHarness {
                public long timeTasks(int nThreads,final Runnable task)
                    throws InterruptedException{
                    //初始化计数器为1
                    final CountDownLatch startGate = new CountDownLatch(1);
                    final CountDownLatch endGate = new CountDownLatch(nThreads);

                    for (int i = 0; i < nThreads; i++){
                        Thread t = new Thread(){
                            @Override
                            public void run() {
                                try {
                                    startGate.await();
                                    try {
                                        task.run();
                                    } finally {
                                        endGate.countDown();
                                    }
                                } catch (InterruptedException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        };
                        t.start();
                    }
                    long start = System.nanoTime();
                    //所有线程刷拉拉往下走
                    startGate.countDown();
                    //等待所有线程结束
                    endGate.await();
                    long end = System.nanoTime();
                    return end-start;
                }

            }
            +

            并且重复计算性能代价可能远没有加锁的消耗来得大，因而这里仅使用了栈封闭来保证一定程度上的线程同步。

            +
            +

            可变对象基础上构建不可变类

            - +
            public final class ThreeStooge {
                private final Set<String> stooges = new HashSet<>();

                public ThreeStooge(){
                    stooges.add("Moe");
                    stooges.add("Larry");
                    stooges.add("Curly");
                }

                public boolean isStooge(String name){
                    return stooges.contains(name);
                }
            }
            - + -

            是的，这样测试出来的时间应该更加平均，性能更加准确。

            -

            FutureTask

            +

            也就是说，实现的核心是保证可变对象不变即可。

            + -
            -

            java的future机制原理

            -

            关于Future：

            - -

            其中get方法是阻塞的。

            -

            获取异步任务执行完后的结果。

            -

            关于FutureTask：

            -

            FutureTask既包含了Future的语义，又包含了Runnable的语义。

            -

            它其实内部封装了一个Runnable Task。调用FutureTask的run，其实本质上就是调用Task的run，只不过要多一些检查和存储结果之类的手续。

            -

            所以说它其实就是通过内部封装一个线程，然后就能获取这个线程运行的状态和运行的结果等等等，这样来实现Future语义的。

            -
            -
            -

            关于Callable

            -

            Runnable里面的run方法是不能传参，也没有返回值的。Callable相当于有返回值的Runnable，也即书中说的“有生成结果的Runnable”。

            -
            - - +

            Final域

            -
            public class Preloader {
                private final FutureTask<ProductInfo> future =
                        new FutureTask<ProductInfo>(new Callable<ProductInfo>() {
                            @Override
                            public ProductInfo call() throws Exception {
                                return loadProductInfo();
                            }
                        });
                private final Thread thread = new Thread(future);

                public void start(){thread.start();}

                public ProductInfo get()
                    throws DataLoadException,InterruptedException{
                    try {
                        //阻塞
                        return future.get();
                    } catch (ExecutionException e) {
                        Throwable cause = e.getCause();
                        if (cause instanceof DataLoadException)
                            throw (DataLoadException) cause;
                        else
                            throw launderThrowable(cause);
                    }
                }

                public static RuntimeException launderThrowable(Throwable t){
                    if (t instanceof RuntimeException)
                        return (RuntimeException) t;
                    else if (t instanceof Error) {
                        throw (Error) t;
                    }
                    else
                        throw new IllegalStateException("Not checked.",t);
                }
            }
            +

            final不仅保证了引用对象的不可变，还保证了不可变对象初始化过程中的线程安全性。

            + - +

            所以说还是尽量多用final。

            +

            Volatile与不可变对象提供弱原子性

            也就是这个图片中所说的：

            + -

            也就是调用start线程启动后，可以就去做别的事情，回来就可以拿到结果了，通过这样实现异步调用。

            - +

            使用volatile变量来发布不可变对象，不仅可以更新保存在不可变对象中的程序状态，还可以为一组操作提供弱原子性。

            + - +

            前面的代码为：

            +
            public class UnsafeCachingFactorizer implements Servlet{
                private final AtomicReference<BigInteger> lastNumber = new AtomicReference<>();
                private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<>();

                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    /*竞态条件*/
                    if (i.equals(lastNumber.get())) encodeIntoResponse(resp,lastFactors.get());
                    else{
                        BigInteger[] factors = factor(i);
                        //时间间隔
                        lastNumber.set(i);
                        lastFactors.set(factors);
                        encodeIntoResponse(resp,factors);
                    }
                }
            }
            -

            这里其实是在讲异常的事了。可以给我们一个启发式思路：

            -

            Callable抛出的Exception这种抽象的异常集合该如何分解处理：首先分解出受检查的异常【也就是说我们调用该方法就知道该方法可能会抛出的异常】，然后针对其他未检查异常，再进行处理。此例中是把这些未检查异常分成了Error和RuntimeException。

            -

            信号量 Semaphore

            +

            如今，利用volatile和不可变类的相互配合，我们修改如下：

            +
            public class VolatileCachedFactorizer implements Servlet{
                //从使用两个分别原子的变量，变为使用一个volatile修饰的不可变类
                private volatile OneValueCache cache = new OneValueCache(null,null);

                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    BigInteger[] factors = cache.getFactors(i);
                    if (factors == null){
                        factors = factor(i);
                        //直接new一个新容器，利用了final域在初始化过程中的线程安全，因而保证了原子性
                        //同时也用了volatile快刷新的性质，保证了可见性，当一个线程设置为新的，其他会立即看到
                        //妙啊，这样就非常完美地达成了线程安全性
                        cache = new OneValueCache(i,factors);
                    }
                    encodeIntoResponse(resp,factors);
                }
            }

            public class OneValueCache {
                private final BigInteger lastNumber;
                private final BigInteger[] lastFactors;

                public OneValueCache(BigInteger lastNumber, BigInteger[] lastFactors) {
                    this.lastNumber = lastNumber;
                    //传递副本，保证不可变
                    this.lastFactors = Arrays.copyOf(lastFactors,lastFactors.length);
                }

                public BigInteger[] getFactors(BigInteger i){
                    if (lastNumber == null || !lastNumber.equals(i)){
                        return null;
                    }
                    else{
                        //传递副本，保证不可变
                        return Arrays.copyOf(lastFactors,lastFactors.length);
                    }
                }
            }
            -
            -

            注意

            - -
            -

            这种情况下，其实信号量跟BlockingQueue语义十分近似：

            - + -

            信号量还可以用来将非阻塞容器包装为有界阻塞容器。

            - +

            每当需要对一组相关数据以原子方式执行某个操作时，就可以考虑创建一个不可变的类来包含这些数据，其本质就是利用不可变性消除了访问和更新多个变量的竞态条件。

            + - +

            因为依然满足该程序的不变性原理：factor数组中各个数字的乘积=lastNumber，也就是说容器对象的两个值都是正确对应的，因而容器对象处于一致的状态。又或者是因为volatile及时刷新，因此确保了各个线程的内存可见性。

            + -
            //使用信号量为容器设置边界,有界+阻塞
            public class BoundedHashSet <T>{
                //baked collection，同步容器
                private final Set<T> set;
                //信号量
                private final Semaphore sem;

                public BoundedHashSet(int bound){
                    //同步容器类
                    this.set = Collections.synchronizedSet(new HashSet<>());
                    //初始化许可数
                    sem = new Semaphore(bound);
                }

                //阻塞方法
                public boolean add(T e) throws InterruptedException{
                    //获取许可
                    sem.acquire();
                    boolean wasAdded = false;
                    try {
                        //由于是同步容器类，故而不用使用锁来保护状态
                        wasAdded=set.add(e);
                        return wasAdded;
                    } finally {
                        //try捕获异常/正常return后，finally语句都会执行。
                        if (!wasAdded)
                            sem.release();
                    }
                }

                public boolean remove(Object o){
                    boolean wasRemoved = set.remove(o);
                    if (wasRemoved)
                        sem.release();
                    return wasRemoved;
                }
            }
            -
            -

            注：try语句块正常return后，finally语句依然会执行：

            -
            public class Main{
             public static void main(String[] args) {
                 System.out.println(haha());
             }

             public static int haha(){
                 int number = 10;
                 try{
                     System.out.println("main!");
                     return number++;
                 }finally {
                     System.out.println("come!"+number);
                 }
             }
            }
            /*输出结果
            main!
            come!11
            10*/
            -
            -

            栅栏 Barrier

            -

            闭锁是某个事件发生后所有线程才能继续执行；栅栏是所有线程都在同样位置等待才能继续执行。

            -

            CyclicBarrier

            +

            安全发布

            - +

            现在，我们要来讲讲如何安全地对对象进行发布。

            +

            一个不正确程序案例

            public Holder holder;

            public void initialize(){	holder = new Holder();	}

            //以下是Holder类定义
            public class Holder{
                private int n;
                
                public Holder(int n){	this.n = n;	}
                
                public void assertSanity(){
                    if( n != n )	
                        throw new AssertionError("This statement is false.");
                }
            }
            -

            一个线程寄了，其他所有等待线程都会死。

            -

            栅栏我觉得一个很重要的点就是保证并发安全。

            - +

            Holder类本身是没有问题的，这段代码出问题的原因是holder没有被正确地发布。

            +

            关于holder为什么没有被正确地发布：

            +

            参考文章

            【并发编程】安全发布对象与防止对象逸出(原因与防护方法)

            +

            分析过程

            由参考文章1：

            + -

            常常出现那种需要等待所有线程都完成某一步操作才能进行下一步操作的情况，所以栅栏不得不说非常实用。

            -
            public class CellularAutomata {
                //细胞板
                private final Board mainBoard;
                //栅栏
                private final CyclicBarrier barrier;
                //计算线程
                private final Worker[] workers;

                public CellularAutomata(Board board){
                    this.mainBoard = board;
                    //所有可调度的CPU都被拉过来了
                    int count = Runtime.getRuntime().availableProcessors();
              		//当所有线程到达栅栏后，马上执行该run方法：提交计算得出的新值
                    this.barrier = new CyclicBarrier(count,
                            new Runnable() {
                                @Override
                                public void run() {
                                    mainBoard.commitNewValues();
                                }
                            });
                    //创建工作线程池
                    this.workers = new Worker[count];
                    for (int i = 0; i < count; i++)
                        //分治，把大的细胞板划分成多个小细胞板处理
                        workers[i] = new Worker(mainBoard,getSubBoard(count,i));
                }

                private class Worker implements  Runnable{

                    private  final Board board;

                    public Worker(Board board){this.board = board;}

                    @Override
                    public void run() {
                        while (!board.hasConverged()){
                            for (int x = 0; x < board.getMaxX(); x++)
                                for (int y = 0; y < board.getMaxY(); y++)
                                    //为二维细胞板上每个点计算新值
                                    board.setNewValue(x,y,computeValue(x,y));
                            try {
                                //计算完之后等待其它线程也计算完
                                barrier.await();
                            } catch (InterruptedException e) {
                                return;
                            } catch (BrokenBarrierException e) {
                                return;
                            }
                        }
                    }
                }

                public void start(){
                    for (int i = 0; i < workers.length; i++)
                        new Thread(workers[i]).start();
                    mainBoard.waitForConvergence();
                }
            }
            +

            可知，new一个对象并非原子操作，并且很有可能先得到内存引用才初始化对象。

            +

            因而，在上面那段不安全代码的语境下可分析：

            +
            Holder的错误发布有三点如下：

            首先明确，引用，和引用的对象的状态，这两个是两个需要独立考虑的方面。前者是一个指针值，后者是指针所指的数据。下面的点1仅考虑引用的更新，点2考虑了引用对象的状态更新。

            +

            \1. 发布对象的那个线程给holder初始化之后，holder这个引用没有及时刷新到内存，因而对其他线程不可见，其他线程读到的holder引用是旧的。

            +

            \2. 又或者，发布了holder还没初始化完毕的时候，别的进程读取到未完成初始化的holder这个引用，但这个引用指向的状态却是旧的，因为它还没完成初始化，其状态值为旧值或者默认值。【发生了上面new一个对象的指令重排】

            +

            \3. 如果在assert方法中两次读取n发生了上面第二条，就可能会导致前后的n不唯一，抛出异常。

            +

            由书中表述，如果将Holder转化为不可变类，那么该发布是安全的。

            + +

            至于为什么，可见下个标题。

            -

            注：

            -

            的目的

            - -
            -

            Exchanger

            - -

            这个“写满”大概对应着栅栏思想里的“全部到达”

            - +

            此处插入思考：是否可以将public Holder holder修改为public final Holder holder，或者volatile修饰，来解决上述问题呢？

            +

            java多线程关键字final和static详解

            +

            通过看该文章得知：

            + +

            volatile和final都会禁止字段引用的对象在构造对象过程中发生指令重排，别的线程得到引用的时候构造已经完成，而不会先得到引用再完成构造，并且两个标志都可以保证可见性。

            +

            不过继续读下去，书中给出了答案：我说的这个方法也是可行的。

            + +

            我的疑问就是第二点和第三点。

            +
            +

            不可变对象的初始化安全性

            -

            示例：构建高效且可伸缩的结果缓存

            + - -
            public interface Computable <A,V>{
                V compute(A arg) throws InterruptedException;
            }

            public class ExpensiveFunction implements Computable<String, BigInteger>{
                @Override
                public BigInteger compute(String arg) throws InterruptedException {
                    //经过长时间的计算后
                    return new BigInteger(arg);
                }
            }
            +

            安全发布的常用模式

            +

            分别解说

            +

            静态初始化对象引用

            -

            用内置锁对方法进行上锁

            //感受一下cache也是Computable的这个多态运用的巧妙性
            public class Memoizer1<A,V> implements Computable<A,V> {
                private final Map<A,V> cache = new HashMap<>();
                private final Computable<A,V> c;

                public Memoizer1(Computable<A,V> c){
                    this.c=c;
                }

                //对整个方法体进行上锁
                @Override
                public synchronized V compute(A arg) throws InterruptedException {
                    V result = cache.get(arg);
                    if (result == null){
                        result = c.compute(arg);
                        cache.put(arg,result);
                    }
                    return result;
                }
            }
            +

            volatile、final以及AtomicReferance保护引用

            详见上面那个不正确案例最后的思考

            +

            由锁保护的区域

            这个区域除了是通过程序构造的，也可以是使用Java自带的线程安全类库。

            + -

            保证了线程安全，但是可伸缩性极差，而且很有可能变成普通的串行排队计算。

            - +

            事实不可变对象

            安全发布可以保证发布时的线程安全。所以说你如果承诺发布后可以一直保证不可变，那就一直都是线程安全的。

            + -

            使用并发容器类

            public class Memoizer2 <A,V> implements Computable<A,V>{
                //并发map
                private final Map<A,V> cache = new ConcurrentHashMap<>();
                private final Computable<A,V> c;

                public Memoizer2(Computable<A,V> c){this.c = c;}
                @Override
                public V compute(A arg) throws InterruptedException {
                    V result = cache.get(arg);
                    if (result == null){
                        result = c.compute(arg);
                        cache.put(arg,result);
                    }
                    return result;
                }
            }
            + -

            确实加锁的粒度小了【没有把高耗时的compute过程锁上】，但会带来某个值重复计算的问题。

            - + -

            而且这不仅仅是性能损耗问题，还有可能会变成安全隐患。

            - +

            对象的可变性与正确发布

            -

            使用FutureTask

            -
            public class Memoizer3<A,V> implements Computable<A,V> {
                private final Map<A, Future<V>> cache
                        = new ConcurrentHashMap<>();
                private final Computable<A,V> c;

                public Memoizer3(Computable<A, V> c) {
                    this.c = c;
                }
                @Override
                public V compute(A arg) throws InterruptedException {
                    Future<V> f = cache.get(arg);
                    if (f == null){
                        Callable<V> eval = new Callable<V>() {
                            @Override
                            public V call() throws Exception {
                                return c.compute(arg);
                            }
                        };
                        FutureTask<V> ft = new FutureTask<>(eval);
                        f = ft;
                        cache.put(arg,ft);
                        //没有启动新线程，直接润
                        ft.run();
                    }
                    try {
                        return f.get();
                    } catch (ExecutionException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
            - +

            安全地共享对象

            -

            这个“判断是否开始”与“判断是否完成”的表述非常有意思。此时cache变成了arg和一个异步任务得到的未来结果的映射，而非arg和结果的映射。从此处也可好好理解感受一下“Future”的语义（一个异步执行的结果）。

            -

            只是它依然没有解决上面所说的问题，还是可能会有两个线程计算同一个值，虽然概率小得多，主要原因是因为它使用了非原子的“先检查后执行”。

            - -

            因而，我们可以通过map提供的putifabsent同步方法来解决这个问题。

            -

            使用FutureTask和putIfAbsent

            public class Memoizer<A,V> implements Computable<A,V> {
                private final Map<A, Future<V>> cache
                        = new ConcurrentHashMap<>();
                private final Computable<A,V> c;

                public Memoizer(Computable<A, V> c) {
                    this.c = c;
                }
                @Override
                public V compute(A arg) throws InterruptedException {
                    Future<V> f = cache.get(arg);
                    //一重保险，筛选线程，防止ft对象重复声明销毁
                    if (f == null){
                        Callable<V> eval = new Callable<V>() {
                            @Override
                            public V call() throws Exception {
                                return c.compute(arg);
                            }
                        };
                        FutureTask<V> ft = new FutureTask<>(eval);
                        f = cache.putIfAbsent(arg,ft);
                        //二重保险，保障仅一个线程能进入
                        //只有那个成功把ft放进map的线程才能进入。
                        if (f == null){
                            f = ft;
                            ft.run();
                        }
                    }
                    try {
                        return f.get();
                    } catch (ExecutionException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
            -

            虽然这个最终版本看起来很完美，但实际上，它还会带来其他的性能问题。

            - +

            第四章 对象的组合

            - +

            也就是说上面都是在讲怎么让一个对象的共享变得安全，下面我们讲怎么依据设计模式，让一个类更容易成为线程安全的

            +

            如何设计线程安全的类

            + + -

            运用最终方案建立cache

            public class Factorizer implements Servlet{
                private final Computable<BigInteger,BigInteger[]> c =
                        new Computable<BigInteger, BigInteger[]>() {
                            @Override
                            public BigInteger[] compute(BigInteger arg) throws InterruptedException {
                                return factor(arg);
                            }
                        };
                private final Computable<BigInteger,BigInteger[]> cache =
                        new Memoizer<>(c);
                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    try {
                        encodeIntoResponse(resp,cache.compute(i));
                    } catch (InterruptedException e) {
                        encodeError(resp,"factorization interrupted.");
                    }
                }
            }
            + + +

            收集同步需求

            本质上是找不变性条件和后验条件

            要保证不变性条件始终成立，确保后验条件符合预期。

            + -

            第六章 任务执行

            +

            讲了什么是不变性条件和后验条件：

            + - -

            在线程中执行任务

            - +

            无效的状态转换只能出现在原子序列中

            + - -

            也就是说，一个请求视为一个任务。这样做是非常reasonable的，因为每个请求间都是独立的。

            -

            串行地执行任务

            调度任务最简单粗暴的就是直接让任务串行执行。

            -
            //串行的web服务器
            public class SingleThreadWebServer {
                public static void main(String[] args) throws IOException {
                    ServerSocket socket = new ServerSocket(80);
                    while(true){
                        Socket connection = socket.accept();
                        handleRequest(connection);
                    }
                }
            }
            - +

            依赖状态的操作

            -

            这里有一个点非常棒：网络也是IO，也会造成阻塞。

            -

            为每一个任务都创建一个线程

            public class SingleThreadWebServer {
                public static void main(String[] args) throws IOException {
                    ServerSocket socket = new ServerSocket(80);
                    while(true){
                        Socket connection = socket.accept();
                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                handleRequest(connection);
                            }
                        }).start();
                    }
                }
            }
            +

            也就是说先验条件和状态域相关。

            + - -

            但是其实这种方式是不好的，因为它无限制地创建线程，这听起来就很容易寄，要知道，高并发的服务器可能会一次解决几千万个请求【当然不知道有没有那么多hhh】，每个都创建一个线程的话，很容易爆内存，而且还会有很大的性能开销。

            - - +

            状态的所有权

            - + -

            而且这样的话，要是高并发情况下，服务器会马上崩溃，做不到我们之前说的自我调节功能。

            -

            所以，我们应该为系统能创建的线程数做一个限制。如此，便引出了Executor框架。

            -

            Executor框架

            +

            666666

            + -
            /*
            An object that executes submitted Runnable tasks.
            An Executor is normally used instead of explicitly creating threads. 
            此接口提供了一种将任务的提交与每个任务将如何运行的机制解耦的方法，包括线程使用、调度等的详细信息。
            The Executor implementations provided in this package implement ExecutorService, which is a more extensive interface. The ThreadPoolExecutor class provides an extensible thread pool implementation. The Executors class provides convenient factory methods for these Executors.
            */
            public interface Executor {
                void execute(Runnable command);
            }
            - - +

            实例封闭

            什么是实例封闭

            - + +

            所以需要上一章学的安全发布。

            + +
            //通过封闭机制保证线程安全
            @ThreadSafe
            public class PersonSet {
                //不安全
                //封闭在实例内部
                private final Set<Person> mySet = new HashSet<>();

                //对所有代码路径加锁访问
                public synchronized void addPerson(Person p) {
                    mySet.add(p);
                }
                public synchronized boolean containsPerson(Person p){
                    return mySet.contains(p);
                }
            }
            -

            示例：基于Executor线程池的Web服务器

            public class TaskExecutionWebServer {
                private static final int NTHREADS = 100;
                //工厂方法创建线程池
                private static final Executor exec
                        = Executors.newFixedThreadPool(NTHREADS);

                public static void main(String[] args) throws IOException {
                    ServerSocket socket = new ServerSocket(80);
                    while (true){
                        final Socket connection = socket.accept();
                        //每次提交一个任务，自然会在某个时刻调度执行
                        exec.execute(new Runnable() {
                            @Override
                            public void run() {
                                handleRequest(connection);
                            }
                        });
                    }
                }
            }
            + - + - +

            阅读源码可知：

            +
            static class SynchronizedCollection<E> implements Collection<E>, Serializable {
                 private static final long serialVersionUID = 3053995032091335093L;

                 final Collection<E> c;  // Backing Collection
                 final Object mutex;     // Object on which to synchronize

                 SynchronizedCollection(Collection<E> c) {
                     this.c = Objects.requireNonNull(c);
                     mutex = this;
                 }

                 SynchronizedCollection(Collection<E> c, Object mutex) {
                     this.c = Objects.requireNonNull(c);
                     this.mutex = Objects.requireNonNull(mutex);
                 }

                 public int size() {
                     synchronized (mutex) {return c.size();}
                 }
                 public boolean isEmpty() {
                     synchronized (mutex) {return c.isEmpty();}
                 }
                 public boolean contains(Object o) {
                     synchronized (mutex) {return c.contains(o);}
                 }
                 public Object[] toArray() {
                     synchronized (mutex) {return c.toArray();}
                 }
                 public <T> T[] toArray(T[] a) {
                     synchronized (mutex) {return c.toArray(a);}
                 }

                //注意此处没用同步
                 public Iterator<E> iterator() {
                     return c.iterator(); // Must be manually synched by user!
                 }

                 public boolean add(E e) {
                     synchronized (mutex) {return c.add(e);}
                 }
                 public boolean remove(Object o) {
                     synchronized (mutex) {return c.remove(o);}
                 }

                 public boolean containsAll(Collection<?> coll) {
                     synchronized (mutex) {return c.containsAll(coll);}
                 }
                 public boolean addAll(Collection<? extends E> coll) {
                     synchronized (mutex) {return c.addAll(coll);}
                 }
                 public boolean removeAll(Collection<?> coll) {
                     synchronized (mutex) {return c.removeAll(coll);}
                 }
                 public boolean retainAll(Collection<?> coll) {
                     synchronized (mutex) {return c.retainAll(coll);}
                 }
                 public void clear() {
                     synchronized (mutex) {c.clear();}
                 }
                 public String toString() {
                     synchronized (mutex) {return c.toString();}
                 }
                 // Override default methods in Collection
                 @Override
                 public void forEach(Consumer<? super E> consumer) {
                     synchronized (mutex) {c.forEach(consumer);}
                 }
                 @Override
                 public boolean removeIf(Predicate<? super E> filter) {
                     synchronized (mutex) {return c.removeIf(filter);}
                 }
                 @Override
                 public Spliterator<E> spliterator() {
                     return c.spliterator(); // Must be manually synched by user!
                 }
                 @Override
                 public Stream<E> stream() {
                     return c.stream(); // Must be manually synched by user!
                 }
                 @Override
                 public Stream<E> parallelStream() {
                     return c.parallelStream(); // Must be manually synched by user!
                 }
                 private void writeObject(ObjectOutputStream s) throws IOException {
                     synchronized (mutex) {s.defaultWriteObject();}
                 }
             }
            -

            思考问题

            Executor到底什么原理

            这里感觉绕来绕去的，execute到底是会创建一个线程，还是不会创建一个线程？到底是在调用时就创建线程执行任务，还是会在将来的某一个时刻调度执行任务？它这里说得云里雾里的，我来锐评一下我的看法。

            -

            首先，我认为，它给我们的ExecutorService类的execute应该都仅仅是提交任务，放进任务队列，之所以什么时候执行得看调度情况。【Form java ThreadPoolExecutor.execute: Executes the given task sometime in the future. 】

            -

            而下面那两个类应该都是对execute进行了简单的重写，因而此处execute跟java包里的ExecuteService没有任何关系，调用execute仅相当于调用一个普通的方法。

            -
            Executor到底有什么用
            -

            参考视频：java线程池其实不难，只要搞清楚来龙去脉

            -
            -
            解耦

            Executor作为一个接口，其核心思想便是“解耦”。

            -

            如果没有Executor的话，我们要创建并运行一个任务，一般都得这样用：new Thread(....).start()，或者是比如说串行的new Runnable(...).run()。也就是我们将任务的创建和任务的执行都混在一起了。而假定说，如果以后要改变该线程池的执行方式，比如说从单任务单线程的并行改成全部任务都串行或者反之，那么就需要每个地方都改掉。但如果使用Executor框架将任务创建和任务具体执行解耦开来，那么我们就仅需修改任务具体执行了。

            -
            Java的线程管理框架

            JUC（java.util.concurrent）其实就只是分为三个部分。

            - +

            就是把原来的collection给实例封闭了，之后的访问都用了同步锁。

            +

            Java监视器模式

            使用内置锁

            -
            ThreadPoolExecutor
              -

            1. ExecutorService

              -

              ThreadPoolExecutor继承了该接口。

              -

              是Executor接口的加强版，包含了更多方法，具体为：

              -

              ① 自身生命周期的管理 shutdown、isshutdown等等

              -

              ② 对异步任务的支持 返回Future的submit方法

              -

              ③ 对批处理任务的支持 invokeall

              -
              2. -

            2. 内部原理

              -

              当空闲的线程足够多，直接执行；当线程不够多，进入阻塞队列；当阻塞队列满，使用拒绝策略。

              -

              内部的线程池分为救急线程和核心线程。核心线程一直存在，当阻塞队列和核心线程都不够用，就会新开几个救急线程。

              -
              3. -
            -

            执行策略

            +

            直白点来说，就是把所有要访问自己状态的地方/方法通通synchronized。

            + - +
            //监视器模式
            @ThreadSafe
            public final class Counter {
                @GuardedBy("this")  private long value = 0;

                public synchronized long getValue(){
                    return value;
                }

                public synchronized long increment(){
                    if (value == Long.MAX_VALUE){
                        throw new IllegalStateException();
                    }
                    return ++value;
                }
            }
            +

            这样虽然简单，但缺点就是很粗暴：同步的粒度太粗了。

            +

            使用私有锁

            也跟内置锁道理差不多

            + +

            也就是说私有锁可以让外面的世界也参与到同步中来，但内置锁不大行。

            +

            示例：车辆追踪

            public class MutablePoint {
                public int x,y;

                public MutablePoint() {
                    x=0;y=0;
                }
                public MutablePoint(MutablePoint p){
                    //深拷贝
                    this.x=p.x;
                    this.y=p.y;
                }
            }
            -

            线程池

            +
            //基于监视器模式
            public class MonitorVehicleTracker {
                private final Map<String, MutablePoint> locations;

                public MonitorVehicleTracker(
                        Map<String,MutablePoint> locations
                ){
                    this.locations = deepCopy(locations);
                }

                public synchronized Map<String,MutablePoint> getLocations(){
                    return deepCopy(locations);
                }
                public synchronized MutablePoint getLocation(String id){
                    MutablePoint loc = locations.get(id);
                    //返回copy对象，深拷贝
                    return loc == null?null : new MutablePoint(loc);
                }
                public synchronized void setLocation(String id,int x,int y){
                    MutablePoint loc = locations.get(id);
                    if (loc == null)    throw new IllegalArgumentException();
                    loc.x = x;
                    loc.y = y;
                }

                //为什么这方法不用锁？是因为调用它的地方都锁着
                private static Map<String,MutablePoint> deepCopy(Map<String,MutablePoint> m){
                    Map<String,MutablePoint> res = new HashMap<>();
                    for (Map.Entry en : m.entrySet()){
                        //此处通过MutablePoint的构造函数重新拷贝了一个Point
                        //如果简单地使用HashMap的构造函数new HashMap(m)的拷贝来创建一个新的map是不行的
                        //因为这样只会拷贝Point对象的指针值，依然是浅拷贝
                        res.put((String) en.getKey(),new MutablePoint((MutablePoint) en.getValue()));
                    }
                    return Collections.unmodifiableMap(res);
                }
            }
            - + - -

            说得非常全面

            - - +

            将线程安全性委托给独立的状态变量

            -

            66666

            - +

            定义

            + +

            意思就是保证一个类里面仅有一个状态，只要该状态是线程安全的，那么该类也就是线程安全的。

            +

            示例

            //线程安全
            public class Point {
                public final int x,y;

                public Point(int x, int y) {
                    this.x = x;
                    this.y = y;
                }
            }
            -

            Executor的生命周期

            +
            //将线程安全委托给ConcurrentMap
            public class DelegatingVehicleTracker {
                //用了两个
                private final ConcurrentMap<String,Point> locations;
                private final Map<String,Point> unmodifiableMap;

                public DelegatingVehicleTracker(Map<String,Point> ps) {
                    locations = new ConcurrentHashMap<>(ps);
                    unmodifiableMap = Collections.unmodifiableMap(locations);
                }

                public Map<String,Point> getLocations(){
                    //unmodifiableMap baked by locations,所以locations变化也会反映到unmodifiableMap上
                    //目的只是为了提供外界无法修改的视图
                    //不得不说真是妙啊
                    return unmodifiableMap;
                }
                public Point getLocation(String id){
                    return locations.get(id);
                }

                public void setLocation(String id,int x,int y){
                    if (locations.replace(id,new Point(x,y)) == null){
                        throw new IllegalArgumentException();
                    }
                }
            }
            -

            我们结束executor，可以采取或温和或粗暴的方法：可以让它不接受新的，慢慢执行完全部再结束；也可以让它直接全部结束，管它有没有执行完或者有没有还没被执行，就跟断电一样。

            - + - + - +
            public Map<String,Point> getLocations(){
                return Collections.unmodifiableMap(new HashMap<>(locations));
            }
            -
            -

            此处疑问：不应该先shutdown再awaitTermination吗？我百度了，也都是说先shutdown。毕竟awaitTermination方法是阻塞的。

            -
            - -
            //支持关闭操作的Web服务器
            public class LifecycleWebServer {
                private final ExecutorService exec = Executors.newFixedThreadPool(100);

                public void start() throws IOException {
                    ServerSocket socket = new ServerSocket(80);
                    //服务器没被关闭就一直接受请求
                    while (!exec.isShutdown()){
                        try {
                            final Socket conn = socket.accept();
                            exec.execute(new Runnable() {
                                @Override
                                public void run() {
                                    handleRequest(conn);
                                }
                            });
                        } catch (RejectedExecutionException e) {
                            if (!exec.isShutdown())
                                //异常地拒绝了
                                log("task submission rejected.",e);
                        }
                    }
                }

                public void stop(){exec.shutdown();}

                void handleRequest(Socket connection){
                    Request req = readRequest(connection);
                    //是否是代表关闭的特定HTTP请求
                    if (isShutdownRequest(req))
                        stop();
                    else
                        dispatchRequest(req);
                }
            }
            +

            委托给多个状态变量

            +

            也就是说这些对象彼此不会构成不变性条件。

            +
            //将线程安全性委托给多个状态变量
            public class VisualComponent {
                private final List<KeyListener> keyListeners = new CopyOnWriteArrayList<>();
                private final List<MouseListener> mouseListeners = new CopyOnWriteArrayList<>();
                
                public void addKeyListener(KeyListener listener){
                    keyListeners.add(listener);
                }

                public void addMouseListener(MouseListener listener){
                    mouseListeners.add(listener);
                }

                public void removeKeyListener(KeyListener listener){
                    keyListeners.remove(listener);
                }

                public void remiveMouseListener(MouseListener listener){
                    mouseListeners.remove(listener);
                }
            }
            -

            延迟任务与周期任务

            + -

            Timer类的缺陷

            单线程带来的精确性问题
            +

            而且键盘监听和鼠标监听彼此独立。

            +

            不独立多个状态变量不能委托

            public class NumberRange {
                //不变性条件： lower<=upper
                private final AtomicInteger lower = new AtomicInteger(0);
                private final AtomicInteger upper = new AtomicInteger(0);

                public void setLower(int i){
                    //先检查后执行
                    if (i>upper.get()){
                        throw new IllegalArgumentException();
                    }
                    lower.set(i);
                }
                public void setUpper(int i){
                    if (i<lower.get()){
                        throw new IllegalArgumentException();
                    }
                    upper.set(i);
                }
                public boolean isInRange(int i){
                    return (i>=lower.get() && i<=upper.get());
                }
            }
            -
            线程泄漏
            + - +

            根本原因就是因为不独立。

            + - -
            public class OutOfTime {
                public static void main(String[] args) {
                    try {
                        Timer timer = new Timer();
                        timer.schedule(new ThrowTask(),1);
                        Thread.sleep(1000);
                        timer.schedule(new ThrowTask(),1);
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

                static class ThrowTask extends TimerTask{

                    @Override
                    public void run() {
                        throw new RuntimeException();
                    }
                }
            }
            +

            发布被委托的状态变量

            什么时候可以发布

            + -

            找出可利用的并行性

            +

            示例

            -

            所以并发编程最难的其实还是建模，如何从串行中挖掘出并行性。

            - +
            package sit;
            @ThreadSafe
            public class SafePoint {
                //注意此处x和y没有用任何同步修饰词修饰
                private int x,y;
                private SafePoint(int[] a){
                    this(a[0],a[1]);
                }

                //此处为什么不直接用this(p.x,p.y)呢？
                //是因为x和y本身并没有任何线程安全的防护手段，这样做的话会发生竞态条件。况且x和y也被实例封闭了
                //私有构造函数捕获模式
                public SafePoint(SafePoint p){
                    this(p.get());
                }

                public  SafePoint(int x,int y){
                    this.x=x;
                    this.y=y;
                }

                //x、y都放入数组，保证x和y的同时读写，nb
                public synchronized int[] get(){
                    return new int[] {x,y};
                }

                public synchronized void set(int x,int y){
                    this.x=x;
                    this.y=y;
                }
            }
            -

            串行的页面渲染器

            +
            //跟上面那个委托没什么差，区别只在于上面的那个SafePoint类，既是线程安全的，又是可修改的
            public class PublishingVehicleTracker {
                private final Map<String,SafePoint> locations;
                private final Map<String,SafePoint> unmodifiableMap;

                public PublishingVehicleTracker(Map<String,SafePoint> locations){
                    this.locations = new ConcurrentHashMap<>(locations);
                    this.unmodifiableMap = Collections.unmodifiableMap(this.locations);
                }

                public Map<String,SafePoint> getLocations(){
                    return unmodifiableMap;
                }

                public SafePoint getLocation(String id){
                    return locations.get(id);
                }

                public void setLocations(String id,int x,int y){
                    if (!locations.containsKey(id))
                        throw new IllegalArgumentException();
                    locations.get(id).set(x,y);
                }
            }
            -

            这个把文字的render和图片的render都归结进图像缓存的统一化思想很有意思。

            - + -
            //串行地渲染页面元素
            public class SingleThreadRenderer {
                void renderPage(CharSequence source){
                    renderText(source);
                    List<ImageData> imageData = new ArrayList<>();
                    for (ImageInfo imageInfo : scanForImageInfo(source)){
                        imageData.add(imageInfo.downloadImage());
                    }
                    for (ImageData data : imageData){
                        renderImage(data);
                    }
                }
            }
            + -

            显而易见，图像的IO需要耗费大量时间，这段时间内CPU都处于空闲状态，可以说利用率非常低下。

            -

            携带结果的Callable与Future

            Callable

            +

            这仅仅是一个委托发布的实例。

            +

            在现有的线程安全类中添加功能

            引论

            - +

            比如说想给vector添加一个“put-if-absent”

            + -

            意思就是Callable比Runnable有时候更灵活，因为Callable可以抛出异常，也可以有返回值。

            -

            Future

            +

            可以用子类扩展法，也可以直接加源代码。后者有时候源代码不可访问，前者的父类很多域可能不对子类开发，并且非常脆弱。因而下面介绍几种比较好的机制。

            +

            客户端加锁机制

            定义和实例

            - +
            @NotThreadSafe
            public class NotThreadSafeListHelper<E> {
                public List<E> list = Collections.synchronizedList(new ArrayList<>());
                
                public synchronized boolean putIfAbsent(E x){
                    boolean absent = !list.contains(x);
                    if (absent)
                        list.add(x);
                    return absent;
                }
            }
            -

            这个Future的说法很棒，只能说比起前面那个含糊的“表示一个异步执行的结果”，这个“任务的生命周期”方法更加醍醐灌顶。

            -
            public interface Future<V> {
                boolean cancel(boolean mayInterruptIfRunning);
                boolean isCancelled();
                boolean isDone();
                V get() throws InterruptedException, ExecutionException;
                V get(long timeout, TimeUnit unit)
                    throws InterruptedException, ExecutionException, TimeoutException;
            }
            + -
            @FunctionalInterface
            public interface Callable<V> {
                V call() throws Exception;
            +

            我曹，66666666

            +

            也就是说，这里加的是ListHelper的锁，只能让别的线程不能通过putIfAbsent方法同时修改list，但别的线程完全可以直接获取list再修改。

            + -

            其中，get的方法取决于任务的状态。

            - +

            客户端指的是我们的ListHelper。我们正是不知道list这个对象使用的是哪一个锁才发愣的。

            +

            所以我们使用ArrayList自身的锁，也就是list自己的内置，来加锁。

            +
            //使用客户端加锁实现
            @ThreadSafe
            public class ListHelper<E> {
                public List<E> list = Collections.synchronizedList(new ArrayList<>());

                public boolean putIfAbsent(E x){
                    synchronized(list) {
                        boolean absent = !list.contains(x);
                        if (absent)
                            list.add(x);
                        return absent;
                    }
                }
            }
            - +

            评价

            -

            可以利用返回的Future实例来对任务线程进行管理。

            - + +

            它非常依赖于其他类的客户端加锁机制。

            + +

            确实，毕竟你锁被外界拿去用了。

            +

            组合

            -

            Future实现并行渲染

            将要求分解为两个任务：渲染文本和渲染图像。

            - +
            public class ImprovedList<T> implements List<T> {
                //实例封闭
                private final List<T> list;

                public ImprovedList(List<T> list){this.list=list;}

                public synchronized boolean putIfAbsent(T x){
                    boolean contains = list.contains(x);
                    if (contains)
                        list.add(x);
                    return !contains;
                }

                public synchronized void clear(){list.clear();}
                //... 按照类似的方式委托List接口其他未实现的方法
            }
            -
            //使用Future等待图像下载
            public class FutureRenderer {
                private final ExecutorService executor = Executors.newFixedThreadPool(80);

                void renderPage(CharSequence source){
                    final List<ImageInfo> imageInfos = scanForImageInfo(source);
                    //单独开启下载图像的任务
                    Future<List<ImageData>> future = executor.submit(new Callable<List<ImageData>>() {
                        @Override
                        public List<ImageData> call() throws Exception {
                            List<ImageData> result = new ArrayList<>();
                            for (ImageInfo imageInfo : imageInfos)
                                result.add(imageInfo.downloadImage(source));
                            return result;
                        }
                    });
                    //在本线程中执行文字的渲染任务
                    renderText(source);

                    try {
                        //阻塞方法
                        List<ImageData> imageData = future.get();
                        for (ImageData data : imageData)
                            renderImage(data);
                    } catch (InterruptedException e) {
                        //重新设置线程的中断状态
                        Thread.currentThread().interrupt();
                        //不需要结果了，因而取消任务
                        future.cancel(true);
                    } catch (ExecutionException e) {
                        throw launderThrowable(e.getCause());
                    }
                }
            }
            + +

            是的，跟synchronizedList非常像

            + +

            这也就是用的java的监视器模式了

            +

            第五章 基础构建模块

            -

            在异构任务并行化中存在的局限

            +

            保证独立即可委托，从而构建一个线程安全类

            + - +

            同步容器类

            - +

            差不多都是使用的监视器模式。

            +

            同步容器类：Vector、Hashtable、Collections.synchronizedXxx

            +

            同步容器类的问题

            -

            所以难点还是分解同构任务。

            -

            CompletionServiceExecutor和BlockingQueue

            +

            也就是需要避免两个原子操作之间的非线程安全的时间间隔。

            +
               public static Object getLast(Vector list){
                   //复合操作
                   //先检查后执行
                   int lastIndex = list.size()-1;
                   return list.get(lastIndex);
               }

            public static void deleteLast(Vector list){
                       int lastIndex = list.size()-1;
                       list.remove(lastIndex);
               }
            -

            CompletionService的思想其实和这个差不多。它主要就是多包装一层，数据结构的管理不用你写，更加方便。

            - + - +

            它这段话说得非常好。由于Vector这个类本身是线程安全的，因而它可以保证外部任何操作都不会导致该对象因为并发而被破坏。但是，我们用不加锁的复合操作虽然不会破坏Vector，但可能导致不能出现我们想要的结果。

            +

            所以我们必须用锁机制来对此复合操作进行保护：

            +
            public static Object getLast(Vector list){
                synchronized (list) {
                    //复合操作
                    //先检查后执行
                    int lastIndex = list.size()-1;
                    return list.get(lastIndex);
                }
            }

            public static void deleteLast(Vector list){
                synchronized (list){
                    int lastIndex = list.size()-1;
                    list.remove(lastIndex);
                }
            }
            - +

            除此之外，迭代也是一种经典的复合操作。我们可以通过下面这种粗粒度加锁来避免：

            +
            public static void travel(Vector list){
                synchronized (list) {
                    for (int i=0;i<list.size();i++){
                        //do something
                    }
                }
            }
            -

            也就是说ExecutorCompletionService将CompletionService的计算部分交给了传进来的线程池Executor，然后自己管理一个阻塞队列，类似生产者-消费者模式，把线程池里出来的结果放进去。

            -

            使用CompletionService实现页面渲染器

            -
            public class Renderer {
                //为什么这里的线程池要变成包内外界给的呢？
                private final ExecutorService executor;

                Renderer(ExecutorService executor){this.executor = executor;}

                void renderPage(CharSequence source){
                    List<ImageInfo> info = scanForImageInfo(source);
                    //传入委托计算的线程池
                    CompletionService<ImageData> completionService
                            = new ExecutorCompletionService<>(executor);
                    //提交任务
                    for (final ImageInfo imageInfo : info)
                        completionService.submit(new Callable<ImageData>() {
                            @Override
                            public ImageData call() throws Exception {
                                return imageInfo.downloadImage();
                            }
                        });
                    
                    renderText(source);

                    try {
                        for (int t = 0, n = info.size(); t < n; t++){
                            //得到下载结果
                            Future<ImageData> f = completionService.take();
                            ImageData imageData = f.get();
                            renderImage(imageData);
                        }
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } catch (ExecutionException e) {
                        throw launderThrowable(e.getCause());
                    }
                }
            }
            - +

            迭代器与ConcurrentModificationException

            -

            疑问

            我这里写了一个自己用list来保存Future结果的。不知道为什么这个不行，有待说明。

            -
            public class MyRenderer {
                private final ExecutorService executor = Executors.newFixedThreadPool(30);

                void renderPage(CharSequence source){
                    List<Future> res = new ArrayList<>();
                    List<ImageInfo> info = scanForImageInfo(source);
                    //提交任务
                    for (final ImageInfo imageInfo : info){
                        res.add(executor.submit(new Callable<Object>() {
                            @Override
                            public Object call() throws Exception {
                                return imageInfo.downloadImage();
                            }
                        }));
                    }

                    renderText(source);

                    try {
                        for (int t = 0, n = info.size(); t < n; t++){
                            Future<ImageData> f = res.get(t);
                            ImageData imageData = f.get();
                            renderImage(imageData);
                        }
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } catch (ExecutionException e) {
                        throw launderThrowable(e.getCause());
                    }
                }
            }
            +

            所以才会引入fail-fast机制。

            + +
            +

            foreach语法糖内部是通过Iterator来实现的。

            +

            Java 的 foreach 本质

            +
            public void testIterableForEach() {
                List<String> list = new ArrayList<>();
                for (String str : list) {
                    System.out.println(str);
                }
            }
            //反编译后：
            public void testIterableForEach() {
                List<String> list = new ArrayList<>();
                Iterator i = list.iterator();
                while(i.hashNext()){
                    String str = (String)i.next();
                    System.out.println(str);
                }
            }
            +
            + + -

            为任务设置时限

            +

            可见同步容器类还是有很多局限性的。

            +

            隐藏迭代器

            有时候，迭代会隐藏起来。要一个个揪出需要加锁的地方是非常麻烦的。

            +
            //隐藏在字符串连接中的迭代操作
            @NotThreadSafe
            public class HiddenIterator {
                private final Set<Integer> set = new HashSet<>();

                public synchronized void add(Integer i){    set.add(i); }
                public synchronized void remove(Integer i){ set.remove(i);  }

                public void addTenThings(){
                    Random r = new Random();
                    for (int i=0; i<10; i++) {
                        add(r.nextInt());
                    }
                    //隐式迭代
                    System.out.println("DEBUG: Added ten elements to "+ set);
                }
            }

            - + - + -
            Page renderPageWithAd() throws InterruptedException{
                long endNanos = System.nanoTime()+TIME_BUDGET;
                //提交下载广告的任务
                Future<Ad> f = exec.submit(new FetchAdTask());
                //在等待广告的同时显示页面
                Page page = renderPageBody();
                Ad ad;

                try {
                    //相当于timeleft=TIME_BUDGET-经过的时间，只不过进行了运算的化简
                    long timeLeft = endNanos- System.nanoTime();
                    ad=f.get(timeLeft, TimeUnit.NANOSECONDS);
                } catch (ExecutionException e) {
                    ad = DEFAULT_AD;
                } catch (TimeoutException e) {
                    //超时取消
                    ad = DEFAULT_AD;
                    f.cancel(true);
                }

                page.setAd(ad);
                return page;
            }
            + - - -
               /**
                * Attempts to cancel execution of this task.  This attempt will
                * fail if the task has already completed, has already been cancelled,
                * or could not be cancelled for some other reason.
                  If successful,
                * and this task has not started when {@code cancel} is called,
                * this task should never run.  
                
                  If the task has already started,
                * then the mayInterruptIfRunning parameter determines
                * whether the thread executing this task should be interrupted in
                * an attempt to stop the task.
                */
            /*
            也就是说，如果mayInterruptIfRunning==false，就需要等该任务完成；如果==true，就直接中断
            */
               boolean cancel(boolean mayInterruptIfRunning);
            +

            并发容器类

            同步容器类的加锁太粗粒度了，导致并发性弱。因而引入并发容器类来解决问题。

            + +

            ConcurrentHashMap —— HashMap

            +

            CopyOnWriteArrayList —— List

            + + -

            示例：旅行预定门户网站

            +

            BlockingQueue

            + - +

            ConcurrentSkipListMap —— TreeMap

            +

            ConcurrentSkipListSet —— TreeSet

            +

            ConcurrentHashMap

            - +

            使用分段锁来细粒度加锁。

            + -

            也就是说，跟前面的CompletionService的优化目的是一致的，都是为了方便管理这一组future，这也跟我上面写的那个list管理版本是一样的。只不过区别在于，CompletionService还可以共用任务池，因而功能更强。invokeAll用法更简便。

            -
            private class QuoteTask implements Callable<TravelQuote>{
                private final TravelCompany company;
                private final TravelInfo travelInfo;
                //...

                public TravelQuote call() throws Exception{
                    //solicit：征求、招揽  quote：报价
                    return company.solicitQuote(travelInfo);
                }
            }
            //得到排序的报价表
            public List<TravelQuote> getRankedTravleQuotes(
                ThravelInfo travelInfo, Set<TravelCompany> companies, Comparator<TravelQuote> ranking, long time, TimeUnit unit
            )throws InterruptedException{
                List<QuoteTask> tasks = new ArrayList<>();
                for (TravelCompany company:companies){
                    tasks.add(new QuoteTask(company,travelInfo));
                }
                
                //使用invokeAll，一键定时任务，非常方便
                List<Future<TravelQuote>> futures =
                    exec.invokeAll(tasks,time,unit);

                List<TravelQuote> quotes =
                    new ArrayList<>(tasks.size());
                Iterator<QuoteTask> taskIterator = tasks.iterator();

                for (Future<TravelQuote> f : futures){
                    QuoteTask task = taskIterator.next();
                    try {
                        //只需调用get就行，不用传时间参数
                        quotes.add(f.get());
                    } catch (ExecutionException e) {
                        quotes.add(task.getFailureQuote(e.getCause()));
                    } catch (CancellationException e){
                        quotes.add(task.getTimeoutQuote(e));
                    }
                }

                //排序
                Collections.sort(quotes,ranking);
                return quotes;

            }
            +
            +

            关于ConcurrentHashMap的分段锁：ConcurrentHashMap

            +

            JDK1.7中，ConcurrentHashMap 类所采用的正是分段锁的思想，将 HashMap 进行切割，把 HashMap 中的哈希数组切分成小数组，每个小数组有 n 个 HashEntry 组成，其中小数组继承自ReentrantLock（可重入锁），这个小数组名叫Segment。

            +

            JDK1.8 中 ConcurrentHashMap 类取消了 Segment 分段锁，采用 CAS + synchronized 来保证并发安全，数据结构跟 jdk1.8 中 HashMap 结构类似，都是数组 + 链表（当链表长度大于 8 时，链表结构转为红黑二叉树）结构。

            +

            ConcurrentHashMap 中 synchronized 只锁定当前链表或红黑二叉树的首节点，只要节点 hash 不冲突，就不会产生并发，相比 JDK1.7 的 ConcurrentHashMap 效率又提升了 N 倍！

            +
            +
            +

            关于ConcurrentHashMap的弱一致性：ConcurrentHashMap的弱一致性

            +

            get方法是弱一致的，是什么含义？可能你期望往ConcurrentHashMap底层数据结构中加入一个元素后，立马能对get可见，但ConcurrentHashMap并不能如你所愿。换句话说，put操作将一个元素加入到底层数据结构后，get可能在某段时间内还看不到这个元素，若不考虑内存模型，单从代码逻辑上来看，却是应该可以看得到的。

            +
            + +

            精确值—>估计值

            + + -

            小结

            +
            +

            关于AQS框架：重大发现，AQS加锁机制竟然跟Synchronized有惊人的相似

            +

            在并发多线程的情况下，为了保证数据安全性，一般我们会对数据进行加锁，通常使用Synchronized或者ReentrantLock同步锁。Synchronized是基于JVM实现，而ReentrantLock是基于Java代码层面实现的，底层是继承的AQS。

            +

            AQS全称**AbstractQueuedSynchronizer**，即抽象队列同步器，是一种用来构建锁和同步器的框架。

            +

            我们常见的并发锁ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier都是基于AQS实现的，所以说不懂AQS实现原理的，就不能说了解Java锁。

            +
            +
            +

            并发容器类不能实现独占访问：

            +

            类似ConcurrentHashMap的并发容器不能采用客户端加锁机制，因为并发容器没有采用synchronized内置锁而大多基于AQS框架（不是独占式的锁），所以使用客户端加锁机制来扩展并发容器的方法是不能实现的。

            +

            所以说不能客户端加锁不是不提倡，而是真的不行【】

            +
            +

            所以最好还是用并发容器类替代同步容器类。

            +

            对部分复合操作的支持

            +

            客户端加锁不能使用，就只能用它提供的东西了。

            +

            CopyOnWriteArrayList

            Copy-On-Write意为“写入时复制”，仅当要修改的时候，才会重新创建一次副本，实现可变性。犹记得第一次接触到这个思想是在操作系统的fork()创建子进程的原理那个地方，那可真是有些惊为天人23333

            + + +

            也就是说，COWAL内部维护的base数组是事实不可变的，因而访问它的时候不需要同步。但是，我们事实上需要一个可变的并发容器，那该怎么办呢？解决方法就是每次要修改的时候，直接把base数组换成一个新的数组，就像之前某个例子一样，这样就能实现可变性了。

            +

            与此同时，这样的方法也能保证多线程访问时的内存可见性。

            +

            由COWAL的底层代码：

            +
            //base数组，volatile保证引用一变就可以刷新
            private transient volatile Object[] array;

            final Object[] getArray() {
                return array;
            }

            final void setArray(Object[] a) {
                    array = a;
            }

            public boolean add(E e) {
                //获取锁
                final ReentrantLock lock = this.lock;
                lock.lock();
                try {
                    //getArray:直接返回base数组的引用
                    Object[] elements = getArray();
                    int len = elements.length;
                    //创建新数组再修改
                    Object[] newElements = Arrays.copyOf(elements, len + 1);
                    newElements[len] = e;
                    //直接改变base数组的引用
                    setArray(newElements);
                    return true;
                } finally {
                    lock.unlock();
                }
            }
            +

            可知，它保证可见性，是直接修改引用的，并且注意，对原数组的拷贝是浅拷贝的。这样一来，就既不会改变原数组的东西，也能保证可见性的更新迅速了。我的评价是牛逼爆了。

            + -

            第七章 取消与关闭

            -

            中断是个重要概念，也算是老朋友了

            - - +

            阻塞队列和生产者—消费者模式

            基本介绍

            -

            任务取消

            取消的原因

            +

            简直就是为了生产者消费者而生的

            + - + +

            这两段话说得非常本质，需要有个缓冲队列本质上就是因为处理数据速率的不同，生产者消费者也起到了解耦作用

            + +

            所以说用有界队列还是更好

            +

            BlockingQueue有多种实现。

            +

            ArrayBlockingQueue和LinkedBlockingQueue是FIFO队列，PriorityBlockingQueue是优先队列，最后还有一个特殊的SynhronousQueue。

            + -

            使用volatile标志取消

            使用方法

            Java并没有提供取消某个线程的安全抢占方法，仅有约定俗成的协作机制。

            -

            比如说，可以设置一个volatile类型的取消标志，并且让线程定期查看该标志。【这是volatile的经典用途】

            -
            public class PrimGenerator implements Runnable{
                private final List<BigInteger> prims
                        = new ArrayList<>();
                //使用volatile域保护取消状态
                private volatile boolean cancelled;

                @Override
                public void run() {
                    BigInteger p = BigInteger.ONE;
                    //任务执行时定期检查取消状态
                    while (!cancelled){
                        p=p.nextProbablePrime();
                        //这里用同步可能是因为下面的getPrim方法使用了同步
                        synchronized (this){
                            prims.add(p);
                        }
                    }
                }

                public void cancel(){cancelled = true;}

                public synchronized List<BigInteger> get(){
                    return new ArrayList<>(prims);
                }
            }
            + -

            使用实例：

            -
            PrimGenerator generator = new PrimGenerator();
            //使用Executor代替Thread
            ExecutorService exec = Executors.newFixedThreadPool(1);
            exec.execute(generator);

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                generator.cancel();
            }

            System.out.println(generator.get());
            exec.shutdown();
            - - +

            实例：桌面搜索

            +
            //生产者
            public class FileCrawler implements Runnable {
                private final BlockingDeque<File> fileQueue;
                private final FileFilter fileFilter;
                private final File root;

                public FileCrawler(BlockingDeque<File> fileQueue, FileFilter fileFilter, File root) {
                    this.fileQueue = fileQueue;
                    this.fileFilter = fileFilter;
                    this.root = root;
                }

                @Override
                public void run() {
                    try{
                        crawl(root);
                    }catch (InterruptedException e){
                        //中断处理
                        Thread.currentThread().interrupt();
                    }
                }

                private void crawl(File root) throws InterruptedException{
                    File[] entries = root.listFiles(fileFilter);
                    if (entries!=null){
                        for (File entry:entries){
                            //递归打印目录
                            if (entry.isDirectory())    crawl(entry);
                            else if (!alreadyIndexed(entry))    fileQueue.put(entry);
                        }
                    }
                }
            }

            //消费者
            public class Indexer implements Runnable{
                private final BlockingDeque<File> queue;

                public Indexer(BlockingDeque<File> q){
                    this.queue=q;
                }

                @Override
                public void run() {
                    try{
                        while(true){
                            indexFile(queue.take());
                        }
                    }catch(InterruptedException e){
                        Thread.currentThread().interrupt();
                    }
                }
            }
            + -

            缺陷

            + -

            比如下面程序：

            -
            public class BrokenPrimeProducer extends Thread{
                private final BlockingQueue<BigInteger> queue;
                private volatile boolean cancelled = false;

                BrokenPrimeProducer(BlockingQueue<BigInteger> queue){
                    this.queue=queue;
                }

                public void run(){
                    try {
                        BigInteger p = BigInteger.ONE;
                        while (! cancelled){
                            //如果一直阻塞在这，便永远不会检查cancelled标志
                            queue.put(p=p.nextProbablePrime());
                        }
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                public void cancel(){cancelled = true;}
            }
            +
            //启动生产者-消费者程序
               public static void startIndexing(File[] roots){
                   BlockingDeque<File> queue = new LinkedBlockingDeque<>(BOUND);
                   FileFilter filter = new FileFilter() {
                       @Override
                       public boolean accept(File pathname) {
                           return  true;
                       }
                   };

                   for (File root : roots){
                       new Thread(new FileCrawler(queue,filter,root)).start();
                   }
                   for (int i=0; i<N_CONSUMERS;i++){
                       new Thread(new Indexer((queue))).start();
                   }
               }
            - -

            所以解决方法其实很简单，只要让阻塞状态下我们还能知道要取消任务就行。这靠我们在表层写代码是做不到的，需要用到Java提供的另一种协作机制：线程中断。

            -

            中断

            是什么

            - +

            串行线程封闭

            -

            所以说中断其实就是为取消而量身定做的。

            - +

            安全发布

            + -
            public class Thread{
                public void interrupt();
                public boolean isInterrupted();
                public static boolean interrupted();
            }
            + - +

            6666666

            +

            之所以叫“串行”，想必是因为这个过程：发布-转接-放弃访问权是一个串行过程。

            + - -

            所以作为上层开发者，我们仅需捕获中断异常即可。

            - -

            也就是说，打断阻塞状态下的线程会清空中断状态，打断正常状态的线程会保持中断状态。而正常状态的线程如果不对中断状态处理，就会一直保持中断状态然后继续运行，也就是屏蔽中断状态。

            - +

            总而言之，串行线程封闭的具体做法就是，一个线程将一个安全发布的对象的所有权完全转移给另一个线程，保证之后自己不会再使用。这样一来，该对象就相当于被另一个线程封闭了。而如何保证“自己以后不再使用”呢？最简单的方法就是安全发布完这个东西后直接把这个东西给踢出去。

            +

            阻塞队列是自动会把这个东西安全发布然后就踢出去的，所以说阻塞队列简化了这个工作。

            + -

            具体检查方法还是定期看标记。在看到标记后可以做善后工作再决定停不停。

            - -

            程序清单5-10：

            - -

            恢复中断状态的示例：

            - +

            双端队列与工作密取

            -

            捕获睡眠时的中断异常，然后重新设置打断标志为true，进入下一次循环时再对标记进行处理。

            - + -

            程序示例

            //注意此处继承自Thread
            public class PrimeProducer extends Thread{
                private final BlockingQueue<BigInteger> queue;

                PrimeProducer(BlockingQueue<BigInteger> queue){
                    this.queue = queue;
                }

                @Override
                public void run() {
                    try {
                        BigInteger p = BigInteger.ONE;
                        //put本就可以检测中断，为啥还要外层包装一层检测的while呢？书中说是为了提高相应度。
                        while(!Thread.currentThread().isInterrupted()){
                            queue.put(p = p.nextProbablePrime());
                        }
                    } catch (InterruptedException e) {
                        //此时catch完之后自动退出
                        /* 允许线程退出 */
                    }
                }

                public void cancel(){interrupt();}

                //这个是我为了方便调试自己加的方法
                public synchronized void get(){
                    for(BigInteger i : queue){
                        System.out.println(i.toString());
                    }
                }
            }
            +

            阻塞方法与中断方法

            阻塞方法

            -

            测试主函数部分如下：

            -
            PrimeProducer generator = new PrimeProducer(new ArrayBlockingQueue<>(10));
            generator.start();

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                generator.cancel();
            }

            generator.get();
            +

            当某方法抛出InterruptedException时，表明该方法为阻塞方法，也即这个方法会在执行过程中由于各种原因而被阻塞。如果这个方法被中断，它将会努力提前结束阻塞状态。

            +

            中断方法

            + +

            处理InterruptedException的两种选择

            -

            一个有待解决的疑问

            此处编写主函数运行时，不小心产生了一个错误：Why does the ThreadpoolExecutor code never stop running?

            -
            public static void main(String[] args) {
                PrimeProducer generator = new PrimeProducer(new ArrayBlockingQueue<>(10));
                ExecutorService exec = Executors.newFixedThreadPool(1);
                exec.execute(generator);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    generator.cancel();
                }

                //generator.get();
                exec.shutdown();
            }
            +

            传递InterruptedException

            -

            这段代码跑起来的最终结果就是进程永远无法终止。至于为什么：

            -

            PrimeProducer类继承自Thread，而execute的参数是一个Runnable。也就是说，Executor会把传进来的这个Thread当成一个Runnable，然后再把它包装成一个新的Thread。所以你的generator里的cancel方法：

            -
            public void cancel(){interrupt();}
            +

            恢复中断

            -

            调用的就不是本线程的中断方法，而是一个全新的毫无关系的线程的中断方法了。

            -

            所以其实应该这么写：

            -
            public static void main(String[] args) {
                PrimeProducer generator = new PrimeProducer(new ArrayBlockingQueue<>(10));
                generator.start();

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    generator.cancel();
                }

                generator.get();
            }
            +
            +

            此处关于为什么如果代码是Runnable的一部分就不能抛出异常：

            +

            是因为java的异常继承体系。

            +

            在重写的run方法中,我们只能够进行异常的捕获而不能够抛出异常,原因是因为在父类Runnable接口中,run方法没有抛出异常,则实现Runnable的子类就无法抛出异常

            +

            所以实际上是语法层面上不允许。

            +
            + -

            但我还是有个奇思妙想。可不可以沿用一开始那个错误的主方法版本，然后修改PrimeProducer类为：

            -
            //此处修改为Runnable
            public class PrimeProducer implements Runnable {
            	//......
                
                //此处修改
                public void cancel(){Thread.currentThread().interrupt();}

                //......
            }
            + -

            结果还是跑不起来，不知道为什么，有待解答。

            -

            中断策略

            - - +

            同步工具类

            -

            意思就是，单个的任务是非线程所有者，因为它们是被分配到线程池所有的线程执行的。所以它们不能直接对中断进行处理，需要把中断异常抛给那个目前还不知道是谁的所有者线程，让调用者决定自己该怎么做。

            - +

            实现同步的方法：使用同步容器类/并发容器类、使用锁、使用同步工具类

            + - - - +

            闭锁 CountDownLatch

            作用

            + +

            CountDownLatch

            -

            以下的地方一个字也看不懂，写自己的思考也没什么意义。就附上正确代码模板吧。

            -
            //通过future定时取消任务
            private static final ScheduledExecutorService taskExec = 		
                				Executors.newScheduledThreadPool(10);

            public static void timeRun(Runnable r,
                                       long timeout, TimeUnit unit)
                throws InterruptedException {
                Future<?> task = taskExec.submit(r);
                try {
                    task.get(timeout,unit);
                } catch (ExecutionException e) {
                    throw launderThrowable(e.getCause());
                } catch (TimeoutException e) {
                    //接下来任务将被取消
                } finally {
                    task.cancel(true);
                }
            }
            +
            //使用CountDownLatch来进行计时测试
            public class TestHarness {
                public long timeTasks(int nThreads,final Runnable task)
                    throws InterruptedException{
                    //初始化计数器为1
                    final CountDownLatch startGate = new CountDownLatch(1);
                    final CountDownLatch endGate = new CountDownLatch(nThreads);

                    for (int i = 0; i < nThreads; i++){
                        Thread t = new Thread(){
                            @Override
                            public void run() {
                                try {
                                    startGate.await();
                                    try {
                                        task.run();
                                    } finally {
                                        endGate.countDown();
                                    }
                                } catch (InterruptedException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        };
                        t.start();
                    }
                    long start = System.nanoTime();
                    //所有线程刷拉拉往下走
                    startGate.countDown();
                    //等待所有线程结束
                    endGate.await();
                    long end = System.nanoTime();
                    return end-start;
                }

            }
            - + + +

            是的，这样测试出来的时间应该更加平均，性能更加准确。

            +

            FutureTask

            -]]> - - books - - - - 计算机组成原理 - /2023/06/21/comporgan/ - 概述

            架构

            冯诺依曼

            以运算器为中心，指令和数据同等地位（不满足摩尔定律）

            -

            image-20230617133555268

            -

            存储器为中心

            image-20230617133840406

            -

            哈佛架构

            哈佛结构数据空间和程序空间是分开的

            -

            大部分ROM操作部分是采用了冯诺依曼结构，

            -

            有些需要CPU与ROM之间快速的响应和交互，采用的是5级流水的哈佛结构。

            -

            早期（如X86）采用冯诺依曼

            -

            DSP和ARM用改进哈佛

            -

            image-20230617134010940

            -

            现代计算机

            image-20230617134045099

            -

            RISC-V

            数的表示

            无符号数与有符号数

            机器数与真值

            image-20230619211124996

            -

            意思就是真值有±符号，机器数把±符号换成了数字罢了

            -

            原码/补码/反码/移码

            image-20230617142534411

            -
            原码

            整数用逗号隔开，小数用小数点隔开

            -
            整数

            image-20230617140847726

            -
            小数

            image-20230617140920563

            -
            注意0的特殊情况

            image-20230617141011120

            -
            补码
            -

            对于负数，原码->补码符号位不变，数值位按位取反再加一的理论由来。神奇的是对于补码->原码，也是按位取反再加一。

            -

            简单证明一下：

            -

            设x为补码，y为原码，n为位数

            -

            已知 x = !(y - 2^n) +1

            -

            则反转一下可得 y = !(x - 1) + 2^n

            -
            -

            符号位不变，按位取反再加一

            -
            整数

            image-20230617141209384

            -
            小数

            image-20230617141232325

            -
            特殊

            [y]补连同符号位在内，每位取反末位加1，即得**[-y]补**

            -

            后面那三个是真的抽象

            -

            image-20230617141627719

            -
            反码

            对于正数，反码和原码一致；

            -

            对于负数，反码为原码的数值位取反

            -
            整数

            image-20230617141351461

            -
            小数

            image-20230617141418617

            -
            0

            image-20230617141525918

            -
            移码
            -

            注意，移码只有整数形式的定义，这与它的用途有关。计算机中，移码通常用来标识浮点数的阶码【阶码是整数】。

            -
            -

            与补码数值位计算方式相同，区别是符号位相反

            -

            image-20230617142858076

            -

            image-20230617145309340

            -

            注意，移码的0为100000，最小值为000000

            -

            浮点表示

            表示形式和范围

            image-20230617143220170

            -

            注意，这边的上溢和下溢只与阶码有关，与尾数无关。

            -

            这个溢出条件及其处理方式需要记，会考

            -

            image-20230617143328674

            -

            规格化

            image-20230617143654003

            -
            特例

            image-20230617143731873

            -
            范围

            image-20230617143912465

            -

            image-20230617145251169

            -
            题型 表示范围

            image-20230617145826541

            -

            看得我cpu快烧了

            -

            https://www.jianshu.com/p/7b9dd240685c

            -

            image-20230617145857698

            -

            之所以最小负数不一样，是因为原码不能表示-1，补码可以；

            -

            之所以规格化最大负数是那玩意，是因为最大负数本应为2^-8，为了规格化必须再加个2^-1，然后原码转补码就变成那样了

            -
            -

            IEEE754标准

            难绷，最沙比的来了

            -

            image-20230617150024955

            -

            没有阶符和数符力

            -

            image-20230617150101092

            -

            image-20230617150816446

            -

            它就相当于指数是移码表示的，并且注意到一点就是指数的0和255被征用表示特殊的数了，所以指数范围为1-254

            -

            image-20230617151013979

            -

            题型 把数转化为IEEE754

            首先背一下上面那个数的范围图，然后判断下是规格化还是非规格化，然后套公式就行了

            -

            image-20230617152014370

            -

            image-20230617152309065

            -

            算术移位与逻辑移位

            -

            来自 https://blog.csdn.net/qq_34283722/article/details/107093193 ：

            -

            img

            -

            这应该与补码的运算机制有关。

            -
            -

            image-20230617152527973

            -

            反码不论是左还是右都添1

            -

            image-20230617152938114

            -

            注意，符号位不变！！！这点在左移的时候需要尤其注意，很容易出错

            -

            RISC-V概述

            ISA

            ISA位宽：通用寄存器的宽度，决定了寻址范围大小、数据运算强弱。

            -

            CISC-RISC

            image-20230619211742901

            -

            X86 & MIPS

            相比于上述的差异，还有以下几个：

            -
              -
            1. x86有8个通用寄存器，MIPS有32个
              2. -
            2. x86有标志寄存器，MIPS没有
              3. -
            3. x86为两地址指令，MIPS为三地址
              4. -
            4. x86有堆栈指令，MIPS没有
              5. -
            5. x86有IO指令，MIPS设备统一编址
              6. -
            6. x86函数参数只用栈帧，MIPS用4寄存器+栈帧
              7. -
            7. X86的字为2字节，MIPS/RISC-V的字为4字节
              8. -
            -

            RISC-V的特点

              -

            1. RISC-V是小端，也即低字节放在低地址

              -
              2. -

            2. 支持字节（8位）、半字（16位）、字（32位）、双字（64位，64位架构）的数据传输

              -

              主存按照字节进行编址

              -
              3. -

            3. 采用哈佛结构

              -
              4. -

            4. 三种特权模式

              -

              image-20230617155657577

              -
              5. -

            5. 模块化设计

              -

              image-20230617155224429

              -
              6. -
            -

            RISC-V汇编语言

            寄存器

            image-20230619212236116

            -

            image-20230617194244388

            -

            x3的全局指的是全局的静态数据区

            -

            指令详解

            image-20230617160729611

            -

            算术指令

            RISC-V 忽略溢出问题，高位被截断，低位写入目标寄存器

            -

            如果想要保留乘法所有位：

            -

            image-20230617183814367

            -

            image-20230617183924758

            -

            image-20230617184010487

            -

            逻辑指令

            image-20230617184151843

            -

            移位指令

            image-20230617185225785

            -

            shift left logical，shift left arithmetic

            -

            数据传输

            ld/sd，lw/sw，lh/sh（半字，也即2字节），lb/sb，以及load指令对应的无符号数（+后缀u）版本。

            -

            bAddrReg+offset为4的倍数，数据传输指令除了字节指令（lb sb lbu）外都需要按字对齐。

            -

            注意，如果为有符号数取数，放入寄存器时会自动进行符号扩展。

            -

            image-20230617191543433

            -

            比较指令

            image-20230617192731684

            -

            条件跳转指令

            image-20230617193045409

            -

            无条件跳转指令

            image-20230617193346852

            -

            j：+label，用于实现无条件跳转，使用相对于当前 PC（程序计数器）的偏移量来计算目标地址，跳转范围较广

            -

            jr：+寄存器，用于实现通过寄存器的值进行跳转，跳转的目标是存储在寄存器中的地址，而不是相对于 PC 的偏移量

            -

            伪指令

            image-20230617193450180

            -

            image-20230617193521343

            -

            函数调用及栈的使用

            image-20230617195109547

            -

            六种指令格式

            image-20230617213801145

            -

            注意，jalr属于I型指令，而非J型指令！！！

            -

            image-20230617213815058

            -

            image-20230620164851924

            -

            R型指令

            image-20230617214018489

            -

            image-20230617214139338

            -

            I型指令

            image-20230617214544561

            -

            image-20230617214659517

            -

            image-20230617214735023

            -
            特例1 load

            image-20230617215007481

            -
            特例2 jalr

            image-20230617215304022

            -

            注意，jalr也属于I型指令，且其funct3为0

            -

            S型指令

            image-20230617215730749

            -

            image-20230617215842401

            -

            B型指令

            image-20230617220521906

            -

            这个计算过程很值得注意

            -

            image-20230617220833542

            -

            image-20230617220903564

            -

            image-20230617221131122

            -

            U型指令

            image-20230617221220495

            -

            image-20230617221323268

            -

            image-20230617221508473

            -

            666

            -

            J型指令

            image-20230617222154873

            -

            寻址方式（x86）

            -

            img

            -

            img

            -

            img

            -

            imgimg

            -

            尽管A很小，但可以让EA很大，从而扩展寻址范围。同时相对于上面的直接寻址，它更容易编程，因为只用修改A存储的那个地址值，而不用修改指令【比如说对数组进行循环，这个间接寻址就只用A++就行，而不用去修改指令里的那个“A”。】。

            -

            That is 指针【】

            -

            img

            -

            img至于为啥间接寻址不便于循环，也许是因为间接寻址是访存两次比较慢，要是真用来循环还了得

            -

            imgimg

            -

            程序动态定位

            -

            img循环数组时，可以用A作为数组地址，IX作为数组下标？？？【为什么不能用基址寻址？】

            -

            应该是因为基址寻址的基址是系统内定的，数组循环问题需要用户指定数组起始地址，所以不能用基址寻址，只能用面向用户的变址寻址。

            -

            img区别就在于直接寻址直接把指令参数****硬编码在内存****中，非常耗费空间。变址寻址则把指令参数作为变量了。

            -

            img更应该像是指令寻址方式。

            -

            程序浮动：程序在内存单元的位置出现变化【毕竟不可能同一个程序在每台电脑都是在同一个物理地址，相当于又减少了硬编码】

            -

            imgimg【为2002H是因为假设字长为2byte】

            -

            imgimg

            -

            一般栈顶地址最低。

            +

            java的future机制原理

            +

            关于Future：

            + + +

            其中get方法是阻塞的。

            +

            获取异步任务执行完后的结果。

            +

            关于FutureTask：

            +

            FutureTask既包含了Future的语义，又包含了Runnable的语义。

            +

            它其实内部封装了一个Runnable Task。调用FutureTask的run，其实本质上就是调用Task的run，只不过要多一些检查和存储结果之类的手续。

            +

            所以说它其实就是通过内部封装一个线程，然后就能获取这个线程运行的状态和运行的结果等等等，这样来实现Future语义的。

            -

            运算方法

            定点运算

            一位乘法运算

            原码一位乘

            -

            image-20230621195833297

            -

            大致明白了：

            -

            ①乘积一共有四位，故而需要两个寄存器来保存。

            -

            ②按照上面的原理公式，每次右移一位，被移出的那一位也是最后的结果（相当于竖式中每次相加的最后一位），需要把它存储在另一个寄存器中。

            -

            ③我们选择了存乘数的寄存器，因为乘数已经乘过的位是没用的。存乘数的那个寄存器的乘数不断被结果的低位所替代。

            -

            故****基本流程****：

            -

            ①准备阶段：清零ACC【置部分积=0】，在MQ中放乘数，X中放被乘数

            -

            ②判断MQ中乘数最低位，若为1，则ACC部分积加上X中的被乘数；若为0，则ACC不变

            -

            ③将ACC和MQ中四位数字视作一个整体，符号位也算上，进行逻辑右移，左侧补0.

            -

            ④重复上述过程，按移位次数来控制结束。

            -

            ⑤则最后，ACC中存储的就是乘法结果的高位，MQ中存储的结果就是乘法中的低位。

            -

            这其实就是我们用的列竖式一行一行加起来的一个过程。

            -

            img

            -

            S是符号位，GM是乘法标志位。

            -

            控制门：当最后一位是1时，控制门打开，X中的被乘数进入加法器。

            +
            +

            关于Callable

            +

            Runnable里面的run方法是不能传参，也没有返回值的。Callable相当于有返回值的Runnable，也即书中说的“有生成结果的Runnable”。

            -
              -

            1. 部分积 乘数

              -
              2. -

            2. 乘数不用符号位，写数值位即可

              -
              3. -

            3. 按照是0是1，要么+被乘数要么+0

              -
              4. -

            4. 右移（连符号位一起逻辑右移）

              -

              image-20230620232152706

              -
              5. -

            5. 直到乘数全部移完

              -
              6. -
            -

            Booth算法

              -

            1. 部分积 乘数 y补（一开始为0）

              -
              2. -

            2. 部分积双符号位，乘数单符号位且参与运算

              -

              image-20230620212054291

              -
              3. -

            3. 每次依据乘数和y补的关系，进行是否加被乘数的决策：

              -

              注意右移不同于原码，是算术右移

              -

              image-20230620212122222

              -
              4. -

            4. 最后一步不用移位

              -

              image-20230620212150280

              -
              5. -
            -

            除法运算

            逻辑左移

            -

            最后得到的余数还得乘个2的-n次方

            -

            恢复余数法

              -
            1. 被除数（余数） 商
              2. -
            2. 先加上 - 除数的补
              3. -
            3. 如果得到结果≥0，则上商1，左移
              4. -
            4. 如果小于0，则上商0，+除数补，左移
              5. -
            5. 左移5次（商包括符号位的所有数字被填满），最后一次上商不用移位
              6. -
            -

            不恢复余数法（加减交替法）

            -

            image-20230621200001791

            -

            总结一下，大概流程：

            -

            ①准备阶段：MQ清零【存放商】，ACC放入被除数，X放入除数

            -

            ②ACC - X中的值

            -

            ③若ACC中值【上一轮的余数】为负，则上商0；为正，则上商1.ACC左移一位。判断MQ的最后一位【上商的值】，若为负，则ACC + X中的y；为正，ACC - X中的y。【注意，若为第一次减去X，则当余数为正时，就即刻发生溢出错误退出】

            -

            ④重复③，直到移位n次。

            -

            img

            -

            V表示是否溢出。

            + + + + +
            public class Preloader {
                private final FutureTask<ProductInfo> future =
                        new FutureTask<ProductInfo>(new Callable<ProductInfo>() {
                            @Override
                            public ProductInfo call() throws Exception {
                                return loadProductInfo();
                            }
                        });
                private final Thread thread = new Thread(future);

                public void start(){thread.start();}

                public ProductInfo get()
                    throws DataLoadException,InterruptedException{
                    try {
                        //阻塞
                        return future.get();
                    } catch (ExecutionException e) {
                        Throwable cause = e.getCause();
                        if (cause instanceof DataLoadException)
                            throw (DataLoadException) cause;
                        else
                            throw launderThrowable(cause);
                    }
                }

                public static RuntimeException launderThrowable(Throwable t){
                    if (t instanceof RuntimeException)
                        return (RuntimeException) t;
                    else if (t instanceof Error) {
                        throw (Error) t;
                    }
                    else
                        throw new IllegalStateException("Not checked.",t);
                }
            }
            + + + +

            也就是调用start线程启动后，可以就去做别的事情，回来就可以拿到结果了，通过这样实现异步调用。

            + + + + +

            这里其实是在讲异常的事了。可以给我们一个启发式思路：

            +

            Callable抛出的Exception这种抽象的异常集合该如何分解处理：首先分解出受检查的异常【也就是说我们调用该方法就知道该方法可能会抛出的异常】，然后针对其他未检查异常，再进行处理。此例中是把这些未检查异常分成了Error和RuntimeException。

            +

            信号量 Semaphore

            + +
            +

            注意

            +
            -
              -

            1. 被除数（余数） 商

              -
              2. -

            2. 先加上 - 除数的补

              -
              3. -

            3. 如果得到结果≥0，则上商1，左移，下一次继续加 - 除数的补

              -
              4. -

            4. 如果小于0，则上商0，左移，下一次加除数的补

              -

              image-20230620234054088

              -

              逻辑左移

              -
              5. -

            5. 左移5次（商包括符号位的所有数字被填满），最后一次上商不用移位

              -
              6. -
            -

            浮点运算

            舍入

            -

            （1）意思是，舍去的要是1，就在保留数+1.如果是0就直接舍去。

            -

            img这意思难道是说可以一次性右移，最后再看要不要+1，而不是移一下加一次1？【不过想了一下，这两种顺序得到的结果好像是一样的。】

            +

            这种情况下，其实信号量跟BlockingQueue语义十分近似：

            + + +

            信号量还可以用来将非阻塞容器包装为有界阻塞容器。

            + + + + +
            //使用信号量为容器设置边界,有界+阻塞
            public class BoundedHashSet <T>{
                //baked collection，同步容器
                private final Set<T> set;
                //信号量
                private final Semaphore sem;

                public BoundedHashSet(int bound){
                    //同步容器类
                    this.set = Collections.synchronizedSet(new HashSet<>());
                    //初始化许可数
                    sem = new Semaphore(bound);
                }

                //阻塞方法
                public boolean add(T e) throws InterruptedException{
                    //获取许可
                    sem.acquire();
                    boolean wasAdded = false;
                    try {
                        //由于是同步容器类，故而不用使用锁来保护状态
                        wasAdded=set.add(e);
                        return wasAdded;
                    } finally {
                        //try捕获异常/正常return后，finally语句都会执行。
                        if (!wasAdded)
                            sem.release();
                    }
                }

                public boolean remove(Object o){
                    boolean wasRemoved = set.remove(o);
                    if (wasRemoved)
                        sem.release();
                    return wasRemoved;
                }
            }
            + +
            +

            注：try语句块正常return后，finally语句依然会执行：

            +
            public class Main{
             public static void main(String[] args) {
                 System.out.println(haha());
             }

             public static int haha(){
                 int number = 10;
                 try{
                     System.out.println("main!");
                     return number++;
                 }finally {
                     System.out.println("come!"+number);
                 }
             }
            }
            /*输出结果
            main!
            come!11
            10*/
            -

            快速进位链

            -

            https://www.bilibili.com/video/BV1AB4y1p7ax?spm_id_from=333.880.my_history.page.click&vd_source=ac571aae41aa0b588dd184591f27f582

            -

            以及老师在这讲的也挺好的【p88】

            -

            imgimg

            -

            当AiBi都为1时，无论Ci是什么，都必定进位1；当AiBi有一个为1时，Ci才会起决定性作用；当AiBi都为0时，无论Ci是什么，都不会进位。因此，AiBi为本地进位，Ai+Bi为传送条件。（乘号表示且，加号表示或）

            -

            img进位链是影响加法器速度的瓶颈

            -

            img但问题是电路太复杂了，因此给出折中方案：

            -

            img

            -

            4先产生进位，传给3，3再产生进位，传给4，依次下去。

            -

            img

            -

            imgimg

            -

            imgimg

            -

            相当于又套了一层并行进位链。

            -

            img实在是太强了。感受到还要再套一层分组的必要性了。

            +

            栅栏 Barrier

            + +

            闭锁是某个事件发生后所有线程才能继续执行；栅栏是所有线程都在同样位置等待才能继续执行。

            +

            CyclicBarrier

            + + + +

            一个线程寄了，其他所有等待线程都会死。

            +

            栅栏我觉得一个很重要的点就是保证并发安全。

            + + +

            常常出现那种需要等待所有线程都完成某一步操作才能进行下一步操作的情况，所以栅栏不得不说非常实用。

            +
            public class CellularAutomata {
                //细胞板
                private final Board mainBoard;
                //栅栏
                private final CyclicBarrier barrier;
                //计算线程
                private final Worker[] workers;

                public CellularAutomata(Board board){
                    this.mainBoard = board;
                    //所有可调度的CPU都被拉过来了
                    int count = Runtime.getRuntime().availableProcessors();
              		//当所有线程到达栅栏后，马上执行该run方法：提交计算得出的新值
                    this.barrier = new CyclicBarrier(count,
                            new Runnable() {
                                @Override
                                public void run() {
                                    mainBoard.commitNewValues();
                                }
                            });
                    //创建工作线程池
                    this.workers = new Worker[count];
                    for (int i = 0; i < count; i++)
                        //分治，把大的细胞板划分成多个小细胞板处理
                        workers[i] = new Worker(mainBoard,getSubBoard(count,i));
                }

                private class Worker implements  Runnable{

                    private  final Board board;

                    public Worker(Board board){this.board = board;}

                    @Override
                    public void run() {
                        while (!board.hasConverged()){
                            for (int x = 0; x < board.getMaxX(); x++)
                                for (int y = 0; y < board.getMaxY(); y++)
                                    //为二维细胞板上每个点计算新值
                                    board.setNewValue(x,y,computeValue(x,y));
                            try {
                                //计算完之后等待其它线程也计算完
                                barrier.await();
                            } catch (InterruptedException e) {
                                return;
                            } catch (BrokenBarrierException e) {
                                return;
                            }
                        }
                    }
                }

                public void start(){
                    for (int i = 0; i < workers.length; i++)
                        new Thread(workers[i]).start();
                    mainBoard.waitForConvergence();
                }
            }
            + +
            +

            注：

            +

            的目的

            + +
            +

            Exchanger

            + +

            这个“写满”大概对应着栅栏思想里的“全部到达”

            + + + + +

            示例：构建高效且可伸缩的结果缓存

            + + + +
            public interface Computable <A,V>{
                V compute(A arg) throws InterruptedException;
            }

            public class ExpensiveFunction implements Computable<String, BigInteger>{
                @Override
                public BigInteger compute(String arg) throws InterruptedException {
                    //经过长时间的计算后
                    return new BigInteger(arg);
                }
            }
            + + + +

            用内置锁对方法进行上锁

            //感受一下cache也是Computable的这个多态运用的巧妙性
            public class Memoizer1<A,V> implements Computable<A,V> {
                private final Map<A,V> cache = new HashMap<>();
                private final Computable<A,V> c;

                public Memoizer1(Computable<A,V> c){
                    this.c=c;
                }

                //对整个方法体进行上锁
                @Override
                public synchronized V compute(A arg) throws InterruptedException {
                    V result = cache.get(arg);
                    if (result == null){
                        result = c.compute(arg);
                        cache.put(arg,result);
                    }
                    return result;
                }
            }
            + +

            保证了线程安全，但是可伸缩性极差，而且很有可能变成普通的串行排队计算。

            + + + + +

            使用并发容器类

            public class Memoizer2 <A,V> implements Computable<A,V>{
                //并发map
                private final Map<A,V> cache = new ConcurrentHashMap<>();
                private final Computable<A,V> c;

                public Memoizer2(Computable<A,V> c){this.c = c;}
                @Override
                public V compute(A arg) throws InterruptedException {
                    V result = cache.get(arg);
                    if (result == null){
                        result = c.compute(arg);
                        cache.put(arg,result);
                    }
                    return result;
                }
            }
            + +

            确实加锁的粒度小了【没有把高耗时的compute过程锁上】，但会带来某个值重复计算的问题。

            + + +

            而且这不仅仅是性能损耗问题，还有可能会变成安全隐患。

            + + + + +

            使用FutureTask

            + +
            public class Memoizer3<A,V> implements Computable<A,V> {
                private final Map<A, Future<V>> cache
                        = new ConcurrentHashMap<>();
                private final Computable<A,V> c;

                public Memoizer3(Computable<A, V> c) {
                    this.c = c;
                }
                @Override
                public V compute(A arg) throws InterruptedException {
                    Future<V> f = cache.get(arg);
                    if (f == null){
                        Callable<V> eval = new Callable<V>() {
                            @Override
                            public V call() throws Exception {
                                return c.compute(arg);
                            }
                        };
                        FutureTask<V> ft = new FutureTask<>(eval);
                        f = ft;
                        cache.put(arg,ft);
                        //没有启动新线程，直接润
                        ft.run();
                    }
                    try {
                        return f.get();
                    } catch (ExecutionException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
            + + + +

            这个“判断是否开始”与“判断是否完成”的表述非常有意思。此时cache变成了arg和一个异步任务得到的未来结果的映射，而非arg和结果的映射。从此处也可好好理解感受一下“Future”的语义（一个异步执行的结果）。

            +

            只是它依然没有解决上面所说的问题，还是可能会有两个线程计算同一个值，虽然概率小得多，主要原因是因为它使用了非原子的“先检查后执行”。

            + + +

            因而，我们可以通过map提供的putifabsent同步方法来解决这个问题。

            +

            使用FutureTask和putIfAbsent

            public class Memoizer<A,V> implements Computable<A,V> {
                private final Map<A, Future<V>> cache
                        = new ConcurrentHashMap<>();
                private final Computable<A,V> c;

                public Memoizer(Computable<A, V> c) {
                    this.c = c;
                }
                @Override
                public V compute(A arg) throws InterruptedException {
                    Future<V> f = cache.get(arg);
                    //一重保险，筛选线程，防止ft对象重复声明销毁
                    if (f == null){
                        Callable<V> eval = new Callable<V>() {
                            @Override
                            public V call() throws Exception {
                                return c.compute(arg);
                            }
                        };
                        FutureTask<V> ft = new FutureTask<>(eval);
                        f = cache.putIfAbsent(arg,ft);
                        //二重保险，保障仅一个线程能进入
                        //只有那个成功把ft放进map的线程才能进入。
                        if (f == null){
                            f = ft;
                            ft.run();
                        }
                    }
                    try {
                        return f.get();
                    } catch (ExecutionException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
            + +

            虽然这个最终版本看起来很完美，但实际上，它还会带来其他的性能问题。

            + + + + + + +

            运用最终方案建立cache

            public class Factorizer implements Servlet{
                private final Computable<BigInteger,BigInteger[]> c =
                        new Computable<BigInteger, BigInteger[]>() {
                            @Override
                            public BigInteger[] compute(BigInteger arg) throws InterruptedException {
                                return factor(arg);
                            }
                        };
                private final Computable<BigInteger,BigInteger[]> cache =
                        new Memoizer<>(c);
                public void service(ServletRequest req,ServletResponse resp){
                    BigInteger i = extractFromRequest(req);
                    try {
                        encodeIntoResponse(resp,cache.compute(i));
                    } catch (InterruptedException e) {
                        encodeError(resp,"factorization interrupted.");
                    }
                }
            }
            + + + + + +

            第六章 任务执行

            + + + +

            在线程中执行任务

            + + + + + +

            也就是说，一个请求视为一个任务。这样做是非常reasonable的，因为每个请求间都是独立的。

            +

            串行地执行任务

            调度任务最简单粗暴的就是直接让任务串行执行。

            +
            //串行的web服务器
            public class SingleThreadWebServer {
                public static void main(String[] args) throws IOException {
                    ServerSocket socket = new ServerSocket(80);
                    while(true){
                        Socket connection = socket.accept();
                        handleRequest(connection);
                    }
                }
            }
            + + + +

            这里有一个点非常棒：网络也是IO，也会造成阻塞。

            +

            为每一个任务都创建一个线程

            public class SingleThreadWebServer {
                public static void main(String[] args) throws IOException {
                    ServerSocket socket = new ServerSocket(80);
                    while(true){
                        Socket connection = socket.accept();
                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                handleRequest(connection);
                            }
                        }).start();
                    }
                }
            }
            + + + +

            但是其实这种方式是不好的，因为它无限制地创建线程，这听起来就很容易寄，要知道，高并发的服务器可能会一次解决几千万个请求【当然不知道有没有那么多hhh】，每个都创建一个线程的话，很容易爆内存，而且还会有很大的性能开销。

            + + + + + + +

            而且这样的话，要是高并发情况下，服务器会马上崩溃，做不到我们之前说的自我调节功能。

            +

            所以，我们应该为系统能创建的线程数做一个限制。如此，便引出了Executor框架。

            +

            Executor框架

            + +
            /*
            An object that executes submitted Runnable tasks.
            An Executor is normally used instead of explicitly creating threads. 
            此接口提供了一种将任务的提交与每个任务将如何运行的机制解耦的方法，包括线程使用、调度等的详细信息。
            The Executor implementations provided in this package implement ExecutorService, which is a more extensive interface. The ThreadPoolExecutor class provides an extensible thread pool implementation. The Executors class provides convenient factory methods for these Executors.
            */
            public interface Executor {
                void execute(Runnable command);
            }
            + + + + + + + + + +

            示例：基于Executor线程池的Web服务器

            public class TaskExecutionWebServer {
                private static final int NTHREADS = 100;
                //工厂方法创建线程池
                private static final Executor exec
                        = Executors.newFixedThreadPool(NTHREADS);

                public static void main(String[] args) throws IOException {
                    ServerSocket socket = new ServerSocket(80);
                    while (true){
                        final Socket connection = socket.accept();
                        //每次提交一个任务，自然会在某个时刻调度执行
                        exec.execute(new Runnable() {
                            @Override
                            public void run() {
                                handleRequest(connection);
                            }
                        });
                    }
                }
            }
            + + + + + +

            思考问题

            Executor到底什么原理

            这里感觉绕来绕去的，execute到底是会创建一个线程，还是不会创建一个线程？到底是在调用时就创建线程执行任务，还是会在将来的某一个时刻调度执行任务？它这里说得云里雾里的，我来锐评一下我的看法。

            +

            首先，我认为，它给我们的ExecutorService类的execute应该都仅仅是提交任务，放进任务队列，之所以什么时候执行得看调度情况。【Form java ThreadPoolExecutor.execute: Executes the given task sometime in the future. 】

            +

            而下面那两个类应该都是对execute进行了简单的重写，因而此处execute跟java包里的ExecuteService没有任何关系，调用execute仅相当于调用一个普通的方法。

            +
            Executor到底有什么用
            +

            参考视频：java线程池其实不难，只要搞清楚来龙去脉

            -

            处理器

            RISC-V数据通路的组件选择

            image-20230617232028775

            -

            RISC CPU采用哈佛架构。

            -

            存储器

              -

            1. DM Data Memory 数据存储器

              -

              读异步，写有写使能

              +
              解耦

              Executor作为一个接口，其核心思想便是“解耦”。

              +

              如果没有Executor的话，我们要创建并运行一个任务，一般都得这样用：new Thread(....).start()，或者是比如说串行的new Runnable(...).run()。也就是我们将任务的创建和任务的执行都混在一起了。而假定说，如果以后要改变该线程池的执行方式，比如说从单任务单线程的并行改成全部任务都串行或者反之，那么就需要每个地方都改掉。但如果使用Executor框架将任务创建和任务具体执行解耦开来，那么我们就仅需修改任务具体执行了。

              +
              Java的线程管理框架

              JUC（java.util.concurrent）其实就只是分为三个部分。

              + + +
              ThreadPoolExecutor
                +

              1. ExecutorService

                +

                ThreadPoolExecutor继承了该接口。

                +

                是Executor接口的加强版，包含了更多方法，具体为：

                +

                ① 自身生命周期的管理 shutdown、isshutdown等等

                +

                ② 对异步任务的支持 返回Future的submit方法

                +

                ③ 对批处理任务的支持 invokeall

                2. -

              2. IM Instruction Memory 指令存储器

                -

                一般read only

                +

              3. 内部原理

                +

                当空闲的线程足够多，直接执行；当线程不够多，进入阻塞队列；当阻塞队列满，使用拒绝策略。

                +

                内部的线程池分为救急线程和核心线程。核心线程一直存在，当阻塞队列和核心线程都不够用，就会新开几个救急线程。

              -

              寄存器堆

              同步写异步读

              -

              image-20230617233101214

              -

              立即数扩展（生成）部件

              零扩展、符号扩展

              -

              PC（程序计数器）

              支持两种加法：+4、+立即数

              -

              ALU

              -

              【以下运算器结构适用于累加型运算器。累加器好像意思是一次最多两个输入。 】

              -

              运算器的功能是运算，因此其核心就是ALU（算术逻辑单元）。ALU是一个组合电路，组合电路的特点是，如果输入撤销了，那么输出结果也会撤销【组合逻辑电路】。因而，为了让ALU的结果能被保存，必须在输入端加上两个寄存器来保证信号持续输入。这两个寄存器一个叫做ACC，另一个叫做x，也叫做数据寄存器。

              -

              imgMQ也是寄存器，用于保存计算过程中溢出的位数。

              -

              img具体见第六章，弹幕说汇编语言也有讲。乘法要这样放是为了防止乘积低位覆盖乘数。

              -

              img

              -

              imgACC里存放着上面的操作或者与外部交流得到的被乘数，按照约定需要转移到X里。我猜M放在MQ而不是ACC，可能是因为第一二步是并行的，如果放在ACC就需要一些等待。

              -

              并且乘法做的是移位累加【可能相当于上面乘法原理的第一个图吧】，ACC用来存储这些累加的暂时交换成果，因而需要将ACC先清空为0.

              -

              这些操作的先后顺序由控制器进行控制。

              -

              img

              -

              MQ也称乘商寄存器

              -
              -

              运算类型：加、减、或、比较、slt、nor

              -

              操作数：寄存器或立即数

              -

              image-20230619214753499

              -

              RISC-V部分指令的数据通路设计

              取数指令的完成过程

              -

              image-20230621192714673

              -

              下面是取数指令的完成过程。

              -

              完成一条指令有三个阶段：取指令、分析指令、执行指令。

              -

              取指令：PC把地址送到MAR，MAR把地址送到存储体。存储体在控制器的控制下，把地址所对应的指令的内容发给MDR，MDR把取出的指令送到IR.

              -

              分析指令：IR将指令的操作码部分交予CU，CU控制IR，IR将指令中的地址码部分交予MAR，MAR给存储体，存储体在控制器控制下给MDR，MDR送给ACC。

              -

              【这个过程正像是计算机网络，只不过此处全靠硬件完成，计算机网络只能依靠协议】

              -
              -

              流水线周期

              RISC-V

              image-20230617233444017

              -

              image-20230618170512788

              -

              注意，在ID阶段还会发生读寄存器

              -

              image-20230617233433422

              -

              X86

              -

              一、指令周期

              -
                -
              1. 基本概念
                2. -
              -

              ① 指令周期

              -

              ② 每条指令的指令周期不同

              -

              imgADD取指阶段和执行阶段都需要一次访存

              -

              ③ 具有间接寻址的指令周期

              -

              img

              -

              三个周期各需要访存一次。【****现在暂时还不知道这有毛用****】

              -

              ④ 具有中断周期的指令周期

              -

              img

              -

              ⑤ 指令周期的流程

              -

              img

              -

              ⑥ CPU工作周期的标志

              -

              指令周期的不同阶段，控制器要做不同的操作，要发出不同的命令。因而，控制器需要知道当前处于指令周期的哪一个阶段。

              -

              img用四个触发器

              -
                -
              1. 指令周期的数据流
                2. -
              -

              ① 取指周期

              -

              img

              -

              首先，PC把自己里面存的地址放进MAR，再通过地址总线传输给存储器。

              -

              CU通过控制总线向存储器发出读控制信号。

              -

              存储器执行读操作，通过数据总线传输取到的指令给MDR，MDR再传给IR。

              -

              CU把加一后的地址保存在PC中，为下一条指令取指做准备。

              -

              ② 间址周期

              -

              img

              -

              如果指令的数据部分采用的是间接寻址的方式，那么此时，MDR中的地址部分不是有效地址，而是存储存储有效地址的存储单元的地址值。因而，我们需要再通过一次访存操作，把有效地址值存储在MDR中。

              -

              ③ 执行周期

              -

              img留给第九章介绍。

              -

              ④ 中断周期

              -

              做了三件事：保存断点、形成服务程序入口地址、中断返回

              -

              img

              -

              首先，保存断点。由CU来确定断电保存在内存单元的哪里。CU把地址传给MAR,MAR将其发到存储器，CU给存储器写命令。PC将自己的值【也就是下一条要执行的命令的地址值】交付给MDR，MDR传给存储器。【MDR在读写操作时都充当了缓冲区的角色。】

              -

              然后，CU形成中断服务程序入口地址，并直接把它写入到CU。

              +

              执行策略

              + + + + + +

              线程池

              + + + + + +

              说得非常全面

              + + + + +

              66666

              + + + + +

              Executor的生命周期

              + +

              我们结束executor，可以采取或温和或粗暴的方法：可以让它不接受新的，慢慢执行完全部再结束；也可以让它直接全部结束，管它有没有执行完或者有没有还没被执行，就跟断电一样。

              + + + + + + +
              +

              此处疑问：不应该先shutdown再awaitTermination吗？我百度了，也都是说先shutdown。毕竟awaitTermination方法是阻塞的。

              -

              流水线处理器

              流水线概述

              流水线

              image-20230618150003983

              -

              这点我觉得讲得挺好的。以前只知道流水线通过并行来加速指令执行，但这里给出了一个新的思路：如果是单周期处理器，则RISC-V的时钟周期受执行时间最长的指令限制；如果是流水线处理器，时钟周期就可以由某个步骤决定，主频就可以加快。这个出发点很有意思。

              -

              如果流水线各阶段平衡，也即每个阶段需要的执行时间差不多，则

              -

              image-20230618150515599

              -

              也即在理想条件和有大量指令的情况下，流水线带来的加速比约等于流水线的级数，若各阶段不完全平衡，加速比会变小。

              -

              流水线技术是通过提高指令的吞吐率来提高性能的。

              -

              RISC-V与流水线

              我们可以看到，比起X86，RISC-V是面向流水线设计的，其特性与流水线高度相关：

              -
                -

              1. 指令长度相同

                -

                简化IF和ID

                -
                2. -

              2. 只有六种指令格式，格式整齐

                -

                能在一个阶段内完成译码和读寄存器（ID）

                -
                3. -

              3. 只通过load、store访存

                -

                可以利用EX阶段计算存储器地址，然后在下一阶段访存（MEM）

                -
                4. -
              -

              流水线冒险

              image-20230618151040625

              -

              结构冒险

              image-20230618151208189

              -

              数据冒险

              image-20230618151243620

              -
              解决方法
              前递

              image-20230618151601721

              -
              编译重排

              image-20230618151706080

              -
              停顿（气泡）

              实在不行只能暂停流水线了

              -

              image-20230618151637437

              -

              控制冒险

              image-20230619220308876

              -
              解决方法
              硬件支持

              image-20230619220259945

              -
              分支预测
                -

              1. 遇到分支预测就停顿

                -
                2. -

              2. 分支预测

                + + +
                //支持关闭操作的Web服务器
                public class LifecycleWebServer {
                    private final ExecutorService exec = Executors.newFixedThreadPool(100);

                    public void start() throws IOException {
                        ServerSocket socket = new ServerSocket(80);
                        //服务器没被关闭就一直接受请求
                        while (!exec.isShutdown()){
                            try {
                                final Socket conn = socket.accept();
                                exec.execute(new Runnable() {
                                    @Override
                                    public void run() {
                                        handleRequest(conn);
                                    }
                                });
                            } catch (RejectedExecutionException e) {
                                if (!exec.isShutdown())
                                    //异常地拒绝了
                                    log("task submission rejected.",e);
                            }
                        }
                    }

                    public void stop(){exec.shutdown();}

                    void handleRequest(Socket connection){
                        Request req = readRequest(connection);
                        //是否是代表关闭的特定HTTP请求
                        if (isShutdownRequest(req))
                            stop();
                        else
                            dispatchRequest(req);
                    }
                }
                + + + +

                延迟任务与周期任务

                + +

                Timer类的缺陷

                单线程带来的精确性问题
                + +
                线程泄漏
                + + + + + +
                public class OutOfTime {
                    public static void main(String[] args) {
                        try {
                            Timer timer = new Timer();
                            timer.schedule(new ThrowTask(),1);
                            Thread.sleep(1000);
                            timer.schedule(new ThrowTask(),1);
                            Thread.sleep(5000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    static class ThrowTask extends TimerTask{

                        @Override
                        public void run() {
                            throw new RuntimeException();
                        }
                    }
                }
                + + + +

                找出可利用的并行性

                + +

                所以并发编程最难的其实还是建模，如何从串行中挖掘出并行性。

                + + +

                串行的页面渲染器

                + +

                这个把文字的render和图片的render都归结进图像缓存的统一化思想很有意思。

                + + +
                //串行地渲染页面元素
                public class SingleThreadRenderer {
                    void renderPage(CharSequence source){
                        renderText(source);
                        List<ImageData> imageData = new ArrayList<>();
                        for (ImageInfo imageInfo : scanForImageInfo(source)){
                            imageData.add(imageInfo.downloadImage());
                        }
                        for (ImageData data : imageData){
                            renderImage(data);
                        }
                    }
                }
                + +

                显而易见，图像的IO需要耗费大量时间，这段时间内CPU都处于空闲状态，可以说利用率非常低下。

                +

                携带结果的Callable与Future

                Callable

                + + + +

                意思就是Callable比Runnable有时候更灵活，因为Callable可以抛出异常，也可以有返回值。

                +

                Future

                + + + +

                这个Future的说法很棒，只能说比起前面那个含糊的“表示一个异步执行的结果”，这个“任务的生命周期”方法更加醍醐灌顶。

                +
                public interface Future<V> {
                    boolean cancel(boolean mayInterruptIfRunning);
                    boolean isCancelled();
                    boolean isDone();
                    V get() throws InterruptedException, ExecutionException;
                    V get(long timeout, TimeUnit unit)
                        throws InterruptedException, ExecutionException, TimeoutException;
                }
                + +
                @FunctionalInterface
                public interface Callable<V> {
                    V call() throws Exception;
                + +

                其中，get的方法取决于任务的状态。

                + + + + +

                可以利用返回的Future实例来对任务线程进行管理。

                + + + + +

                Future实现并行渲染

                将要求分解为两个任务：渲染文本和渲染图像。

                + + +
                //使用Future等待图像下载
                public class FutureRenderer {
                    private final ExecutorService executor = Executors.newFixedThreadPool(80);

                    void renderPage(CharSequence source){
                        final List<ImageInfo> imageInfos = scanForImageInfo(source);
                        //单独开启下载图像的任务
                        Future<List<ImageData>> future = executor.submit(new Callable<List<ImageData>>() {
                            @Override
                            public List<ImageData> call() throws Exception {
                                List<ImageData> result = new ArrayList<>();
                                for (ImageInfo imageInfo : imageInfos)
                                    result.add(imageInfo.downloadImage(source));
                                return result;
                            }
                        });
                        //在本线程中执行文字的渲染任务
                        renderText(source);

                        try {
                            //阻塞方法
                            List<ImageData> imageData = future.get();
                            for (ImageData data : imageData)
                                renderImage(data);
                        } catch (InterruptedException e) {
                            //重新设置线程的中断状态
                            Thread.currentThread().interrupt();
                            //不需要结果了，因而取消任务
                            future.cancel(true);
                        } catch (ExecutionException e) {
                            throw launderThrowable(e.getCause());
                        }
                    }
                }
                + + + +

                在异构任务并行化中存在的局限

                + + + + + +

                所以难点还是分解同构任务。

                +

                CompletionServiceExecutor和BlockingQueue

                + +

                CompletionService的思想其实和这个差不多。它主要就是多包装一层，数据结构的管理不用你写，更加方便。

                + + + + + + +

                也就是说ExecutorCompletionService将CompletionService的计算部分交给了传进来的线程池Executor，然后自己管理一个阻塞队列，类似生产者-消费者模式，把线程池里出来的结果放进去。

                +

                使用CompletionService实现页面渲染器

                + +
                public class Renderer {
                    //为什么这里的线程池要变成包内外界给的呢？
                    private final ExecutorService executor;

                    Renderer(ExecutorService executor){this.executor = executor;}

                    void renderPage(CharSequence source){
                        List<ImageInfo> info = scanForImageInfo(source);
                        //传入委托计算的线程池
                        CompletionService<ImageData> completionService
                                = new ExecutorCompletionService<>(executor);
                        //提交任务
                        for (final ImageInfo imageInfo : info)
                            completionService.submit(new Callable<ImageData>() {
                                @Override
                                public ImageData call() throws Exception {
                                    return imageInfo.downloadImage();
                                }
                            });
                        
                        renderText(source);

                        try {
                            for (int t = 0, n = info.size(); t < n; t++){
                                //得到下载结果
                                Future<ImageData> f = completionService.take();
                                ImageData imageData = f.get();
                                renderImage(imageData);
                            }
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        } catch (ExecutionException e) {
                            throw launderThrowable(e.getCause());
                        }
                    }
                }
                + + + +

                疑问

                我这里写了一个自己用list来保存Future结果的。不知道为什么这个不行，有待说明。

                +
                public class MyRenderer {
                    private final ExecutorService executor = Executors.newFixedThreadPool(30);

                    void renderPage(CharSequence source){
                        List<Future> res = new ArrayList<>();
                        List<ImageInfo> info = scanForImageInfo(source);
                        //提交任务
                        for (final ImageInfo imageInfo : info){
                            res.add(executor.submit(new Callable<Object>() {
                                @Override
                                public Object call() throws Exception {
                                    return imageInfo.downloadImage();
                                }
                            }));
                        }

                        renderText(source);

                        try {
                            for (int t = 0, n = info.size(); t < n; t++){
                                Future<ImageData> f = res.get(t);
                                ImageData imageData = f.get();
                                renderImage(imageData);
                            }
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        } catch (ExecutionException e) {
                            throw launderThrowable(e.getCause());
                        }
                    }
                }
                + + + +

                为任务设置时限

                + + + + + +
                Page renderPageWithAd() throws InterruptedException{
                    long endNanos = System.nanoTime()+TIME_BUDGET;
                    //提交下载广告的任务
                    Future<Ad> f = exec.submit(new FetchAdTask());
                    //在等待广告的同时显示页面
                    Page page = renderPageBody();
                    Ad ad;

                    try {
                        //相当于timeleft=TIME_BUDGET-经过的时间，只不过进行了运算的化简
                        long timeLeft = endNanos- System.nanoTime();
                        ad=f.get(timeLeft, TimeUnit.NANOSECONDS);
                    } catch (ExecutionException e) {
                        ad = DEFAULT_AD;
                    } catch (TimeoutException e) {
                        //超时取消
                        ad = DEFAULT_AD;
                        f.cancel(true);
                    }

                    page.setAd(ad);
                    return page;
                }
                + + + + + +
                   /**
                    * Attempts to cancel execution of this task.  This attempt will
                    * fail if the task has already completed, has already been cancelled,
                    * or could not be cancelled for some other reason.
                      If successful,
                    * and this task has not started when {@code cancel} is called,
                    * this task should never run.  
                    
                      If the task has already started,
                    * then the mayInterruptIfRunning parameter determines
                    * whether the thread executing this task should be interrupted in
                    * an attempt to stop the task.
                    */
                /*
                也就是说，如果mayInterruptIfRunning==false，就需要等该任务完成；如果==true，就直接中断
                */
                   boolean cancel(boolean mayInterruptIfRunning);
                + + + +

                示例：旅行预定门户网站

                + + + + + +

                也就是说，跟前面的CompletionService的优化目的是一致的，都是为了方便管理这一组future，这也跟我上面写的那个list管理版本是一样的。只不过区别在于，CompletionService还可以共用任务池，因而功能更强。invokeAll用法更简便。

                +
                private class QuoteTask implements Callable<TravelQuote>{
                    private final TravelCompany company;
                    private final TravelInfo travelInfo;
                    //...

                    public TravelQuote call() throws Exception{
                        //solicit：征求、招揽  quote：报价
                        return company.solicitQuote(travelInfo);
                    }
                }
                //得到排序的报价表
                public List<TravelQuote> getRankedTravleQuotes(
                    ThravelInfo travelInfo, Set<TravelCompany> companies, Comparator<TravelQuote> ranking, long time, TimeUnit unit
                )throws InterruptedException{
                    List<QuoteTask> tasks = new ArrayList<>();
                    for (TravelCompany company:companies){
                        tasks.add(new QuoteTask(company,travelInfo));
                    }
                    
                    //使用invokeAll，一键定时任务，非常方便
                    List<Future<TravelQuote>> futures =
                        exec.invokeAll(tasks,time,unit);

                    List<TravelQuote> quotes =
                        new ArrayList<>(tasks.size());
                    Iterator<QuoteTask> taskIterator = tasks.iterator();

                    for (Future<TravelQuote> f : futures){
                        QuoteTask task = taskIterator.next();
                        try {
                            //只需调用get就行，不用传时间参数
                            quotes.add(f.get());
                        } catch (ExecutionException e) {
                            quotes.add(task.getFailureQuote(e.getCause()));
                        } catch (CancellationException e){
                            quotes.add(task.getTimeoutQuote(e));
                        }
                    }

                    //排序
                    Collections.sort(quotes,ranking);
                    return quotes;

                }
                + + + +

                小结

                + + + + + +

                第七章 取消与关闭

                + +

                中断是个重要概念，也算是老朋友了

                + + + + +

                任务取消

                取消的原因

                + + + + + +

                使用volatile标志取消

                使用方法

                Java并没有提供取消某个线程的安全抢占方法，仅有约定俗成的协作机制。

                +

                比如说，可以设置一个volatile类型的取消标志，并且让线程定期查看该标志。【这是volatile的经典用途】

                +
                public class PrimGenerator implements Runnable{
                    private final List<BigInteger> prims
                            = new ArrayList<>();
                    //使用volatile域保护取消状态
                    private volatile boolean cancelled;

                    @Override
                    public void run() {
                        BigInteger p = BigInteger.ONE;
                        //任务执行时定期检查取消状态
                        while (!cancelled){
                            p=p.nextProbablePrime();
                            //这里用同步可能是因为下面的getPrim方法使用了同步
                            synchronized (this){
                                prims.add(p);
                            }
                        }
                    }

                    public void cancel(){cancelled = true;}

                    public synchronized List<BigInteger> get(){
                        return new ArrayList<>(prims);
                    }
                }
                + +

                使用实例：

                +
                PrimGenerator generator = new PrimGenerator();
                //使用Executor代替Thread
                ExecutorService exec = Executors.newFixedThreadPool(1);
                exec.execute(generator);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    generator.cancel();
                }

                System.out.println(generator.get());
                exec.shutdown();
                + + + + + + + +

                缺陷

                + +

                比如下面程序：

                +
                public class BrokenPrimeProducer extends Thread{
                    private final BlockingQueue<BigInteger> queue;
                    private volatile boolean cancelled = false;

                    BrokenPrimeProducer(BlockingQueue<BigInteger> queue){
                        this.queue=queue;
                    }

                    public void run(){
                        try {
                            BigInteger p = BigInteger.ONE;
                            while (! cancelled){
                                //如果一直阻塞在这，便永远不会检查cancelled标志
                                queue.put(p=p.nextProbablePrime());
                            }
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    public void cancel(){cancelled = true;}
                }
                + + + +

                所以解决方法其实很简单，只要让阻塞状态下我们还能知道要取消任务就行。这靠我们在表层写代码是做不到的，需要用到Java提供的另一种协作机制：线程中断。

                +

                中断

                是什么

                + + + +

                所以说中断其实就是为取消而量身定做的。

                + + +
                public class Thread{
                    public void interrupt();
                    public boolean isInterrupted();
                    public static boolean interrupted();
                }
                + + + + + +

                所以作为上层开发者，我们仅需捕获中断异常即可。

                + + +

                也就是说，打断阻塞状态下的线程会清空中断状态，打断正常状态的线程会保持中断状态。而正常状态的线程如果不对中断状态处理，就会一直保持中断状态然后继续运行，也就是屏蔽中断状态。

                + + +

                具体检查方法还是定期看标记。在看到标记后可以做善后工作再决定停不停。

                + + +

                程序清单5-10：

                + + +

                恢复中断状态的示例：

                + + +

                捕获睡眠时的中断异常，然后重新设置打断标志为true，进入下一次循环时再对标记进行处理。

                + + + + +

                程序示例

                //注意此处继承自Thread
                public class PrimeProducer extends Thread{
                    private final BlockingQueue<BigInteger> queue;

                    PrimeProducer(BlockingQueue<BigInteger> queue){
                        this.queue = queue;
                    }

                    @Override
                    public void run() {
                        try {
                            BigInteger p = BigInteger.ONE;
                            //put本就可以检测中断，为啥还要外层包装一层检测的while呢？书中说是为了提高相应度。
                            while(!Thread.currentThread().isInterrupted()){
                                queue.put(p = p.nextProbablePrime());
                            }
                        } catch (InterruptedException e) {
                            //此时catch完之后自动退出
                            /* 允许线程退出 */
                        }
                    }

                    public void cancel(){interrupt();}

                    //这个是我为了方便调试自己加的方法
                    public synchronized void get(){
                        for(BigInteger i : queue){
                            System.out.println(i.toString());
                        }
                    }
                }
                + +

                测试主函数部分如下：

                +
                PrimeProducer generator = new PrimeProducer(new ArrayBlockingQueue<>(10));
                generator.start();

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    generator.cancel();
                }

                generator.get();
                + + + +

                一个有待解决的疑问

                此处编写主函数运行时，不小心产生了一个错误：Why does the ThreadpoolExecutor code never stop running?

                +
                public static void main(String[] args) {
                    PrimeProducer generator = new PrimeProducer(new ArrayBlockingQueue<>(10));
                    ExecutorService exec = Executors.newFixedThreadPool(1);
                    exec.execute(generator);

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    } finally {
                        generator.cancel();
                    }

                    //generator.get();
                    exec.shutdown();
                }
                + +

                这段代码跑起来的最终结果就是进程永远无法终止。至于为什么：

                +

                PrimeProducer类继承自Thread，而execute的参数是一个Runnable。也就是说，Executor会把传进来的这个Thread当成一个Runnable，然后再把它包装成一个新的Thread。所以你的generator里的cancel方法：

                +
                public void cancel(){interrupt();}
                + +

                调用的就不是本线程的中断方法，而是一个全新的毫无关系的线程的中断方法了。

                +

                所以其实应该这么写：

                +
                public static void main(String[] args) {
                    PrimeProducer generator = new PrimeProducer(new ArrayBlockingQueue<>(10));
                    generator.start();

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    } finally {
                        generator.cancel();
                    }

                    generator.get();
                }
                + +

                但我还是有个奇思妙想。可不可以沿用一开始那个错误的主方法版本，然后修改PrimeProducer类为：

                +
                //此处修改为Runnable
                public class PrimeProducer implements Runnable {
                	//......
                    
                    //此处修改
                    public void cancel(){Thread.currentThread().interrupt();}

                    //......
                }
                + +

                结果还是跑不起来，不知道为什么，有待解答。

                +

                中断策略

                + + + + + +

                意思就是，单个的任务是非线程所有者，因为它们是被分配到线程池所有的线程执行的。所以它们不能直接对中断进行处理，需要把中断异常抛给那个目前还不知道是谁的所有者线程，让调用者决定自己该怎么做。

                + + + + + + + + + + + + +

                以下的地方一个字也看不懂，写自己的思考也没什么意义。就附上正确代码模板吧。

                +
                //通过future定时取消任务
                private static final ScheduledExecutorService taskExec = 		
                    				Executors.newScheduledThreadPool(10);

                public static void timeRun(Runnable r,
                                           long timeout, TimeUnit unit)
                    throws InterruptedException {
                    Future<?> task = taskExec.submit(r);
                    try {
                        task.get(timeout,unit);
                    } catch (ExecutionException e) {
                        throw launderThrowable(e.getCause());
                    } catch (TimeoutException e) {
                        //接下来任务将被取消
                    } finally {
                        task.cancel(true);
                    }
                }
                + + + + + +]]> + + books + + + + JavaWeb + /2022/12/21/JavaWeb/ + 第一部分 Java基础

                JUnit单元测试

                JUnit是白盒测试。

                +

                简要使用步骤

                定义测试类

                包含各种测试用例。

                +

                一般放在包名xxx.xxx.xx.test里，类名为“被测试类名Test”。

                +

                定义测试方法

                测试方法可以独立运行。

                +

                方法名一般为“test测试的方法”，void，空参。

                +

                给方法加@Test标签

                加入JUnit依赖包

                具体细节

                断言

                Assert.assertEquals(3,result);
                + +

                @Before @After

                @Before在所有测试方法执行前自动执行，常用于资源申请。

                +

                @After在所有测试方法执行完后自动执行，常用于释放资源。

                +

                反射

                反射是框架设计的灵魂。

                +

                Java对象创建的三个阶段

                image-20221205194807395

                +

                类加载器把硬盘中的字节流文件装载进内存，并且翻译封装为Class类对象。通过Class类对象才能创建Person对象。

                +

                而这也就是说，如果我们有了Class对象，我们就可以创建该类对象。

                +

                获取Class对象

                有三种方式。

                +

                Class.forName(“类的全名”)

                将字节码文件加载进内存，返回class对象。多用于配置文件【将类名定义在配置文件】

                +

                注意：类的全名指的是包.类，包含包名。

                +

                类型.class

                通过类名的属性class获取。多用于参数传递。

                +

                对象.getClass()

                getClass()是Object类的方法。多用于对象的获取字节码的方式。

                +
                //第一种方式
                Class class1 = Class.forName("Student");
                System.out.println(class1);
                //第二种方式
                Class class2 = Student.class;
                System.out.println(class2);
                //第三种方式
                Student stu = new Student();
                Class class3 = stu.getClass();
                System.out.println(class3);

                System.out.println((class1==class2)+"  "+(class2==class3));

                /*输出
                class Student
                class Student
                class Student
                true  true*/
                + +

                同一个字节码文件（*.class）在一次程序运行过程中只会被加载一次，不管是以哪种方式得到的Class对象，都是同一个。

                +

                使用Class对象

                可以通过class对象得到其字段、构造方法、方法等。

                +
                class Student{
                    public String name;
                    int birthday;
                    protected int money;
                    private double weight;

                    private Student() {

                    }
                    public Student(String name, int birthday, int money, double weight) {
                        this.name = name;
                        this.birthday = birthday;
                        this.money = money;
                        this.weight = weight;
                    }

                    @Override
                    public String toString() {
                        return "Student{" +
                                "name='" + name + '\'' +
                                ", birthday=" + birthday +
                                ", money=" + money +
                                ", weight=" + weight +
                                '}';
                    }

                    public static void haha(){
                        System.out.println("haha");
                    }
                    public void hello(){
                        System.out.println("hello");
                    }
                    public void hello(String name){
                        System.out.println("hello,"+name+"!");
                    }
                    private void giveMoney(){
                        System.out.println("my money is yours...");
                        money = 0;
                    }
                }
                + +
                Student stu = new Student("张三",321,1000,57.7);
                Class stuC = stu.getClass();
                + +

                字段

                获取字段

                常用方法：

                +
                //获取所有公有字段
                Field[] fs = stuC.getFields();
                //获取某个公有字段
                Filed f = stuC.getField("name");
                //获取所有字段
                Field[] fs = stuC.getDeclaredFields();
                //获取某个字段
                Filed f = stuC.getDeclaredField("name");
                /*输出
                public java.lang.String Student.name

                public java.lang.String Student.name

                public java.lang.String Student.name
                int Student.birthday
                protected int Student.money
                private double Student.weight*/
                + +
                使用字段
                Field f = stuC.getDeclaredField("money");
                //由于money protected，故应该先设置其为可访问，否则会抛出异常。
                //这是暴力反射，不推荐。
                f.setAccessible(true);
                //获取成员变量的值
                //注意此处是要用field.get(该类型对象)的。想想也有道理，Filed字段是属于Class对象的，因而你想获取某个对象的值当然得传入该对象。
                System.out.println(f.get(stu));
                //设置对象的值
                f.set(stu,0);
                System.out.println(stu);
                /* Student{name='张三', birthday=321, money=0, weight=57.7}  */
                + +

                构造方法

                获取方法跟上面格式差不多。

                +
                //获取构造方法
                //获取无参私有构造方法
                Constructor cons = stuC.getDeclaredConstructor();
                cons.setAccessible(true);
                System.out.println(cons.newInstance());
                //获取有参构造方法
                Constructor cons2 = stuC.getConstructor(String.class,int.class,int.class,double.class);
                System.out.println(cons2.newInstance("李四",102,100,90.9));
                /*输出
                Student{name='null', birthday=0, money=0, weight=0.0}
                Student{name='李四', birthday=102, money=100, weight=90.9}*/
                + +

                如果想要获取公有的无参构造器，还可以使用Class类提供的更简单的方法，不用先创造构造器：

                +
                System.out.println(stuC.newInstance());
                + +

                方法

                //获取方法
                //可以获取静态方法
                Method m = stuC.getMethod("haha");
                System.out.println(m);
                //获取带参方法，自动根据参数推断
                Method m2 = stuC.getMethod("hello");
                Method m3 = stuC.getMethod("hello",String.class);
                //调用方法
                m2.invoke(stu);
                m3.invoke(stu,"琳琳");
                //获取私有方法并调用
                Method m4 = stuC.getDeclaredMethod("giveMoney");
                m4.setAccessible(true);
                m4.invoke(stu);
                /*输出
                public static void Student.haha()
                hello
                hello,琳琳!
                my money is yours...*/
                + +

                使用反射的案例

                image-20221205205122805

                +
                public class ReflectTest {
                    public static void main(String[] args) throws Exception {
                        /* 加载配置文件 */
                        Properties pro = new Properties();
                        //获取字节码文件加载器
                        ClassLoader cl = ReflectTest.class.getClassLoader();
                        pro.load(cl.getResourceAsStream("pro.properties"));

                        /* 获取配置文件中的数据并执行 */
                        Class cla = Class.forName(pro.getProperty("className"));
                        cla.getMethod(pro.getProperty("methodName")).invoke(cla.newInstance());
                    }
                }
                + + + +

                注解

                image-20221205211932790

                +

                image-20221205212028989

                +

                ①和③都是jdk预定义的。自定义主要是②。

                +

                生成doc文档

                javadoc XXX.java
                + +

                会自动根据里面的注解生成文档

                +

                JDK预定义注解

                image-20221205212443918

                +

                自定义注解

                注解类的本质

                @Target(ElementType.METHOD)
                @Retention(RetentionPolicy.SOURCE)
                public @interface Override {
                }
                + +

                本质上

                +
                public @interface Override{}
                + +

                等价于

                +
                public interface Override extends java.lang.annotation.Annotation{}
                + +

                注解的属性

                注解的属性就是接口中的成员方法。要求无参，且返回类型有固定取值：

                +

                image-20221205213135522

                +
                public @interface MyAnno {
                    String name() default "haha";
                }
                + +
                @MyAnno(name = "haha")
                public class Student{}
                + +

                元注解

                描述注解的注解

                +

                image-20221205213324052

                +

                RetentionPolicy的三个取值：SOURCE、CLASS、RUNTIME，正对应着java对象的三个阶段。

                +

                SOURCE：不保留到字节码文件，会被编译器扔掉

                +

                CLASS：保留到字节码文件

                +

                RUNTIME：被读到

                +

                自定义的注解一般都取RUNTIME。

                +

                在程序中获取注解属性

                相当于用注解替换配置文件

                +
                @Target(ElementType.TYPE)
                @Retention(RetentionPolicy.RUNTIME)
                public @interface Pro {
                    String className();
                    String methodName();
                }
                //保留在runtime应该是因为运行时要动态获取值。我试了一下换成CLASS或者SOURCE，会有NullPointerException
                + +
                @Pro(className = "Student",methodName = "hello")
                public class ReflectTest {
                    public static void main(String[] args) throws Exception{
                        Pro pro = ReflectTest.class.getAnnotation(Pro.class);
                        
                        Class cla = Class.forName(pro.className());
                        cla.getMethod(pro.methodName()).invoke(cla.newInstance());
                    }
                }
                + +

                class.getAnnotation(Pro.class);这句话实质上是创建了一个实例，继承了Pro接口，重载了里面的抽象方法。

                +

                使用案例：测试框架

                @Target(ElementType.METHOD)
                @Retention(RetentionPolicy.RUNTIME)
                public @interface Check {
                }
                + +

                然后在要测试的每个方法上面加上此标签。

                +

                image-20221205215017285

                +

                然后编写test方法：

                +
                public class TestCheck {
                    public static void main(String[] args) throws IOException {
                        //创建对象
                        Calculator c = new Calculator();
                        //获取所有方法
                        Method[] methods = c.getClass().getMethods();

                        //写入文件
                        int number = 0;//异常次数
                        BufferedWriter bf = new BufferedWriter(new FileWriter("bug.txt"));

                        //检查每个方法是否有注解。有的话则执行。
                        for (Method m : methods){
                            if (m.isAnnotationPresent(Check.class)){
                                try {
                                    m.invoke(c);
                                } catch (Exception e) {
                                    //记录文件信息
                                    number++;
                                    bf.write(m.getName()+"出异常了。");
                                    bf.write("\n");
                                    bf.write(e.getCause().getClass().getSimpleName()+" "+e.getCause().getMessage());
                                    bf.write("\n");
                                    bf.write("-------------");
                                    bf.write("\n");
                                }
                            }
                        }
                        bf.write("共出现"+number+"次异常");
                        bf.flush();
                        bf.close();
                    }
                }
                /*
                haha出异常了。
                ArithmeticException / by zero
                -------------
                共出现1次异常
                */
                + +

                image-20221205220053258

                +

                第二部分 数据库

                Mysql

                登录方式

                mysql -h[IP地址] -u[用户名] -p
                + +

                文件结构

                本地的一个文件夹就代表一个数据库，文件夹里的一个文件代表一张表。

                +

                image-20221205221041508

                +

                image-20221205221055114

                +

                SQL语法

                image-20221205221216882

                +

                SQL有四种语句类型

                +

                image-20221205221246672

                +

                DDL 操作数据库、表

                操纵数据库

                增
                create datebase 数据库名称;
                create datebase if not exists 数据库名称;
                create datebase if not exists 数据库名称 character set gbk;
                + +
                删
                drop database 数据库名称;
                drop database if exists 数据库名称;
                + +
                改
                alter database 数据库名称 charactor set 修改后新值;
                + +
                查
                show databases;# 查询所有数据库名称
                show create database 数据库名称;# 显示指定数据库创建时的指令内容
                + +
                使用
                select database();# 查询正在使用的数据库名称
                use 数据库名称;
                + +

                操纵表

                增
                create table students(
                    name varchar(20),
                    age int,
                    score double(3,1),
                    birthday date,
                    insert_time timestamp
                );# 创建表
                create table students2 like students;# 复制表
                + +

                *注：

                  -

                1. 静态分支预测

                  -

                  image-20230618153106322

                  -
                  2. -

                2. 动态分支预测

                  -

                  image-20230618153125295

                  -
                  3. -
                +

              3. mysql的数据类型表

                +

                image-20221205222127740

                +

                其中：

                +

                ① double(3,1)表示XXX.X，最大值为99.9.

                +

                ② 关于三个时间类型

                +

                image-20221205222307284

                +

                所以timestamp常用作插入时间。

                +

                ③ varchar(20)表示二十个字符长的字符串。

                +

                注意，是“二十个字符”而不是“二十个字节”。如果使用的字符集每个字符占3个字节，则varchar(20)占60个字节。

                +

                ④ BLOB、CLOB、二进制这些用于存储大数，不常用

              -

              流水线数据通路和控制

              流水线数据通路

              流水线寄存器

              image-20230618154028950

              -

              image-20230618154608423

              -

              66666，这个帅

              -

              image-20230618154815411

              -

              流水线控制

              数据冒险：前递与停顿

              前递

              分类

              前递有两种情况：

              -

              image-20230618155952018

              -
              前递产生条件
                -
              1. RegWrite != 0（写有效）
                2. -
              2. Rd != x0
                3. -
              -
              解决方法

              流水线寄存器解决：

              -

              image-20230618160141827

              -

              并且增加前递所需硬件。

              -

              停顿

              流水线寄存器解决：

              -
                -

              1. 置ID/EX寄存器中控制信号为0（防止寄存器和存储器被写入数据），执行空指令nop

                -
                2. -

              2. 禁止PC寄存器和IF/ID寄存器内容改变

                -

                下一条指令就能重新取指

                +
                删
                drop table 表名;
                + +
                改
                # 修改表名
                alter table students rename to new_students;
                # 修改表的字符集
                alter table students character set 字符集名称;
                # 修改表的列名/类型
                alter table students change name new_name varchar(20);# 新列名 新数据类型
                alter table students modify name varchar(15);# 新数据类型
                # 添加一列
                alter table students add ID double(10);
                # 删除一列
                alter table students drop ID;
                + +
                查
                show tables;# 查询数据库中所有表的名字
                desc 表名;# 查询某个表的结构
                + + + +

                DML 增删改表中数据

                增

                insert into students(name,age,score,birthday) values('张三',15,99.9,"2022-12-5");
                insert into students values("张三",15,99.9,"2022-12-5",NULL);
                + +

                删

                如果不加条件，会把表中所有数据删除

                +
                delete from students where name="张三";
                truncate table students;# 删除表，然后创建一张一模一样的新表
                + +

                image-20221205224600869

                +

                改

                如果不加条件，会把表中所有记录全部修改

                +
                update students set name="1", age=10 where name="张三";
                + + + +

                DQL 查询表中记录

                语法

                image-20221205224802814

                +

                基础查询

                select # 多字段查询
                	name,
                	age 
                from 
                	students;
                	
                select distinct # 去重
                	address
                from
                	students;

                # 有NULL参与的计算结果都为NULL
                select name,math,english,math+english from students;
                # ifnull函数不会修改原表中的数据
                select name,math,english,IFNULL(math,0)+IFNULL(english,0) from students;

                select 
                	name,
                	math,
                	english,
                	IFNULL(math,0)+IFNULL(english,0)  total_score # 起别名
                from 
                	students;
                + +

                条件查询

                运算符
                  +

                1. 基本运算符

                  +

                  <、>、=、<=、>=、<>(不等于，也可以用!=)

                  2. -
                -

                控制冒险

                image-20230618161320779

                -

                image-20230618161333487

                -

                缩短分支延迟的方法：

                -

                硬件支持

                image-20230618161429557

                -

                动态分支预测

                image-20230618161807387

                -

                image-20230618161932429

                -

                计算目标地址

                image-20230618162114338

                -

                流水线的多发技术

                img

                -

                img

                -

                超流水技术要求一个时钟周期内不同的指令不能相互叠加干扰。

                -

                img

                -

                意思就是多条指令并成一条，有公共的取指、译码、写回阶段，但是执行阶段各不相同且并行执行，应该是这样。

                -

                例外和中断

                概述

                image-20230618162247586

                -

                内部的一定是例外，外部的只有IO请求和硬件故障是中断

                -

                image-20230618162302149

                -

                image-20230618162437636

                -

                image-20230618162500928

                -

                哦哦哦WOC!!!!!

                -

                这让我想起来在做xv6的时候，的那个kerneltrap和usertrap，应该就是这里的这个统一入口地址。

                -

                xv6是RISC-V架构，故而发生中断的时候，就会跳转到统一的kernel trap，然后再在里面通过scause进行读取。666

                -

                不过盘问了下gpt，RISC-V对于exception和interruption的处理方式是不一样的：

                -

                在RISC-V中，异常通常是由于程序执行过程中的错误或非预期事件而引起的，包括故障（faults）、陷阱（traps）和中止（aborts）。中断（interrupts）则是由外部事件触发的，例如定时器到期、外部设备请求等。中断是异步事件，与当前正在执行的指令无关，因此会在任何时候发生。

                -

                例外是通过统一入口地址处理，中断则是中断向量的方式

                -

                流水线中的例外

                image-20230618163521639

                -

                微操作（X86）

                X86将一条指令的执行分为多个微操作。

                -
                -

                一、微操作命令分析

                -

                微操作命令是控制单元在完成一大条指令时所需要细分完成的一条条微小的命令

                -

                image-20230621201435702

                -
                  -

                1. 取值周期

                  -

                  image-20230621201345807

                  +

                2. 逻辑运算符

                  +

                  AND、OR

                  3. -

                3. 间址周期

                  -

                  image-20230621201351939

                  +

                4. BETWEEN AND

                  5. -

                5. 执行周期 ①访存指令 ②非访存指令 ③转移指令 ④三类指令的指令周期

                  -

                  image-20230621201358396

                  -

                  imgimg

                  -

                  image-20230621201423245

                  +

                6. IN后跟集合

                  +

                  image-20221205230824086

                  7. -

                7. 中断周期 硬件法和软件法

                  -

                  imgimg

                  -

                  硬件和软件法。

                  +

                8. IS、IS NOT

                  +

                  image-20221205230902110

                  9. +

                9. LIKE 模糊查询

                  +

                  类似正则使用占位符匹配

                  +

                  image-20221205231037021

                  +
                  select * from students where name like "马%";
                -

                二、控制单元的功能

                -
                  -

                1. 输入信号

                  -

                  ①时钟信号 ②指令寄存器【控制信号与操作码有关】 ③标志 ④外来信号【中断请求、总线请求】

                  -
                  2. -

                2. 输出信号

                  -

                  ①CPU内各种控制信号【比如（PC）+1->PC这种】

                  -

                  ②送至控制总线的信号【比如中断响应、总线响应】

                  -
                  3. -

                3. 控制信号举例

                  -

                  ①不使用内部总线

                  -

                  ②采用内部总线

                  -
                  4. -

                4. 多级时序系统

                  +

                  各种函数一样的东西

                  排序函数
                  order by 排序字段1 排序方式1,排序字段2 排序方式2;
                  +
                    -

                  1. 机器周期

                    -

                    取指周期=机器周期=最复杂的微操作所需时间【访存】

                    -

                    在机器周期内部也需要有时钟来控制微操作的执行顺序

                    -
                    2. -

                  2. 时钟周期（节拍、状态）

                    -

                    每个指令周期都可分为若干个机器周期，每个机器周期都可分为若干个节拍（时钟周期）。一个机器周期内包含多少节拍与需要发送多少控制信号、控制信号复杂度、控制信号能否并行有关。

                    -

                    时钟产生节拍信号，不同的节拍信号有不同的先后顺序。

                    -

                    一个时钟周期产生一个或几个【并行的几个，或者是操作时间很短，虽然有一定的先后顺序，但可以在一个节拍内完成】微操作命令

                    -

                    时钟信号利用上升沿让CU发出控制命令【微操作】控制各个不同部件。

                    +

                  3. 默认升序。

                    4. -
                  +

                5. ASC、DESC

                  6. -

                6. 控制方式

                  -

                  ①同步控制方式 采用定长的机器周期、不定长的机器周期、中央控制和局部控制相结合

                  -

                  ​ 当指令大多都是可以提前确定的，就用同步。当一条微操作的时间很难控制，可以采用异步控制。

                  -

                  ②异步控制方式 等待IO读写

                  -

                  ③联合控制方式 同步与异步结合

                  -

                  ④人工控制

                  +

                7. 多关键字排序

                  +

                  image-20221205231606255

                  +

                  第二条件仅当第一条件一样才使用。

                -

                三、组合逻辑设计

                +
                聚合函数

                将一列数据作为整体，纵向计算

                +

                注意，聚合函数的计算会排除NULL值。如果不想让空置排除，可以尝试该方法：

                +
                select count(ifnull(math,0)) from students;
                +
                  -

                1. 组合逻辑控制单元框图

                  -

                  ①CU外特性 ②节拍信号

                  -
                  2. -

                2. 微操作的节拍安排

                  -

                  ①安排微操作时序的原则

                  -

                  原则一：先后顺序不更改。

                  -

                  原则二：可以并行执行的，且微操作间没有先后顺序的，就尽量把它们安排在一个节拍中。

                  -

                  原则三：时间较短微操作尽量在一个节拍内且可以有先后顺序。

                  -

                  ②取值周期间址周期执行周期的

                  -

                  image-20230621201709245

                  -

                  image-20230621201717225

                  -

                  image-20230621201722561

                  -

                  image-20230621201732549

                  -
                  3. -
                -
                -

                存储器

                概述

                分类

                image-20230618183618033

                -

                层次结构

                -

                寄存器分为两类，体系结构寄存器和非体系结构寄存器。前者可以让程序员调度使用，后者不行。

                -
                -

                image-20230618183742599

                -

                image-20230618183845067

                -

                主存储器

                概述

                基本组成

                -

                MAR中的地址需要经过译码器才能得到对应存储体中的位置。MDR中的数据是读是写需要通过读写电路控制，读写电路接收控制电路的读写信号。

                -
                -

                image-20230618184214916

                -

                与CPU连接

                image-20230618211118255

                -

                小端模式

                image-20230618211717123

                -

                技术指标

                image-20230618211918511

                -

                半导体存储芯片简介

                基本结构

                image-20230618212044462

                -

                image-20230618212116854

                -

                译码驱动方式

                线选法

                image-20230618212207454

                -
                重合法

                image-20230618212227553

                -

                RAM 随机存取存储器

                DRAM和SRAM

                image-20230618222428159

                -

                SRAM

                基本电路
                -

                image-20230621193330855

                -

                核心就是利用****触发器（T1—T4）****来表示0和1的

                -

                用T5和T6行开关来控制对触发器部件读写，用T7和T8列开关……【对应上面说的重合法？】

                -

                写入要在A段写入数据，同时在A’段写入数据的非【因为触发器是双稳态的，要求两边输入的信号相反。】对应的，写选择那边输入数据也得对称经过门和非门。

                -
                -
                经典芯片

                image-20230618212447162

                -
                读写

                img

                -

                上面的部分是64*64的基本电路矩阵。我们按列分，每十六列为一组，则分成了四组。因为2^4=16，因而我们用四位来表示地址控制信号。

                -

                对于行，当地址控制信号为0000时，表示选择存储矩阵的第一行的数据，为0001时，选择第二行的……依此类推。

                -

                对于列，当地址控制信号为0000时，表示选择每一组的第一列的数据，为0001时，选择第二列的……依此类推。

                -

                每一组只能有一列被选中，这就达到了一次读写四位的目的。【一个字节分开存】

                -

                DRAM

                基本电路
                -

                主要是通过电容的充放电实现的

                -

                img

                -

                左侧三管那个中，读数据线读出的跟存储的是相反的，存0读1，存1读0.但写入跟输入的信息是相同的。

                -

                右侧单管中，读出时数据线有电流则是1，没有则是0.写入时，对Cs充电则为1，Cs放电（输入信号为低电平）则为0.

                -
                -

                image-20230618215704699

                -
                经典芯片/读写

                image-20230618215803608

                -
                -

                img

                -

                14位的地址分了两次传，分别作为行列地址。

                -

                RAS:行选控制信号 CAS：列选控制信号 WE：读写控制信号。产生的时钟控制了芯片内部的读写操作

                -

                img

                -

                如果读放大器左边有电，那么右边输出没电；左没电右有电.这样，读放大器左边的部分，有电表示0，没电表示1 ；读放大器右边的部分，有电表示1，没电表示0.

                -
                -
                刷新

                为什么要刷新：

                -

                image-20230619224003589

                -
                集中刷新

                image-20230618221439701

                -
                分散刷新

                image-20230618221603727

                -
                异步刷新

                image-20230618222049113

                -

                ROM 只读存储器

                  -

                1. 掩膜ROM(MROM) 用户不能修改

                  -

                  image-20230618222716561

                  -
                  2. -

                2. PROM（一次性编程） 破坏性编程

                  -

                  image-20230618223116398

                  +

                3. count 计算个数

                  +
                  select count(name) from students;# 有多少条记录
                  + +

                  一般如果要看有多少记录，可以用count(主键)，因为主键不为空。

                  4. -

                4. EPROM（多次性编程）

                  -

                  image-20230618223151914

                  +

                5. max、min

                  6. -

                6. EEPROM（电可擦写）

                  -

                  image-20230618223229585

                  +

                7. sum 求和

                  8. -

                8. Flash Memory（闪速型存储器）

                  -

                  image-20230618223252821

                  +

                9. avg 平均值

                -

                存储器与CPU的连接

                存储器容量的扩展

                位扩展

                image-20230618224638384

                -
                字扩展

                image-20230618224745584

                -

                带了片选思想

                -
                位字扩展

                image-20230618224955557

                -

                存储器与CPU的连接

                存储器的校验

                image-20230620221830055

                -

                汉明码组成

                image-20230620222021345

                -

                image-20230620222133679

                -

                image-20230620222301502

                -

                n为数据的位数

                -

                image-20230620222225994

                -

                image-20230620222518156

                -

                汉明码纠错

                image-20230620222951821

                -

                跟组成的步骤是一样的

                -

                提高访存速度的措施

                image-20230618233156234

                -

                image-20230618233234559

                -

                image-20230618233325427

                -

                image-20230619224341497

                -

                image-20230618233855438

                -

                不过这里也帅得一批，非常有那种从小到大的抽象思维在。

                -

                之前的单独一块RAM芯片，一个字节是分开存；这里的一个主存堆，一个块是分主存存。

                -

                Cache 高速缓冲存储器

                概述

                image-20230618233726163

                -

                技术指标

                image-20230618233800847

                -

                image-20230618234113714

                -

                因为在一个存取周期当中，每体都可以取一个字，16体就可以取16字，因而一个存取周期可以取出16个字出来。

                -

                image-20230618234151529

                -

                但是这个公式前提是访问cache和主存并行。如果换用另一个策略，即先看cache有没有，没有再去主存，计算公式就不一样。

                -

                Cache的读写操作

                -

                img

                -

                cache接收CPU发来的地址信号。CPU发出的地址中的块内地址无需转换，而块号需要通过主存cache地址映射变换机构转化成cache内的块号。【所以说CPU访问cache的时候，传给cache的地址是主存的物理地址吧？然后再通过主存cache地址映射转化为cache的块内地址。】

                -

                如果命中，则转换机构工作，传递地址给cache存储体，存储体通过数据总线发送信号。

                -

                如果不命中，并且cache没装满，则发送信号给主存。

                -

                如果不命中，且cache装满了，则cache替换机构使用替换算法，淘汰cache中一些块，同时发送信号给主存。

                -

                主存收到信号，在数据总线上发给cpu要的东西之后，再将所在块发给cache。

                -

                image-20230621193732489

                -
                -

                读

                image-20230618234639119

                -

                写

                image-20230618234752772

                -

                Cache-主存映射

                直接映射

                image-20230618234904098

                -

                image-20230618234921789

                -

                全相联映射

                image-20230618235007647

                -

                组相联映射

                image-20230618235147739

                -

                缓存替换算法

                image-20230618235750985

                -

                改进

                -

                现在很多处理器至少有三级cache。比如每个核一个cache，多个核还有一个公用的cache。

                -

                流水线计算机很多都分了指令cache和数据cache，避免资源冲突。

                -

                注意，每个层次的cache采用的映射可能不一样。

                -

                靠近CPU采用直接相连或者路数（r）少的组相连【其实直接相连就相当于是一路的组相联了】。中间的用组相联。距离CPU较远的用全相联。

                -

                距离越远，对速度要求越低，对利用率要求越高。

                +
                分组查询

                分组之后查询的字段只能是两种：① 分组字段 ② 聚合函数。因为分组了之后再查具有个人特色的东西就没意义了。【高版本的mysql如果查询别的字段会报错】

                +
                select sex,avg(math) from students group by sex;
                + +

                image-20221207212103151

                +
                对分组结果进行条件限制

                还可以在分组前对条件限定，使用WHERE

                +
                select sex,avg(math) from students where math >= 70 group by sex;
                + +

                或者在分组后限定，使用HAVING

                +
                select sex,avg(math),count(id) from students group by sex having count(id)>2;
                # 或
                select sex,avg(math),count(id) total from students group by sex having total>2;
                + +
                WHERE和HAVING的区别
                  +
                1. WHERE在分组前限定，不满足where则不参与分组；HAVING在分组后限定，不满足having则不会被查询出来。
                  2. +
                2. WHERE条件里不能有聚合函数，HAVING可以。
                  3. +
                +
                分页查询

                image-20221207213958848

                +

                这种就是分页查询。

                +
                limit 开始的索引,每页查询的条数;
                + +

                limit只能在mysql使用。

                +

                DCL 管理用户，授权操作

                管理用户

                查询用户

                image-20221219223932789

                +

                用户表存放地点↑

                +
                USE mysql;
                SELECT * FROM USER;
                + +
                创建用户

                注意，以下出现的”用户名”@”主机名” IDENTIFIED BY “密码”，不能在@两侧加空格，否则报错。

                +
                CREATE USER "用户名"@"主机名" IDENTIFIED BY "密码";
                + +
                删除用户
                DROP USER "用户名"@"主机名";
                + +
                修改密码
                -- 使用mysql自带的密码加密函数PASSWORD
                -- 1
                UPDATE USER SET PASSWORD = PASSWORD("新密码") WHERE USER = "用户名";
                -- 2
                SET PASSWORD FOR "用户名"@"主机名" = PASSWORD("新密码");
                + +

                image-20221219225036633

                +

                授权操作

                查询权限
                SHOW GRANTS FOR "root"@"%";
                + +
                授予权限
                grant 权限列表 on 数据库名.表名 to '用户名'@'主机名';
                + +

                image-20221219225715075

                +
                撤销权限
                revoke 权限列表 on 数据库名.表名 from '用户名'@'主机名';
                + +

                约束

                非空约束

                添加非空约束

                CREATE TABLE stu(
                	id INT,
                	name VARCHAR(20) NOT NULL
                );
                ALTER TABLE stu MODIFY name VARCHAR(20) NOT NULL;
                + +

                删除非空约束

                如果要去掉该约束，可以这么做：

                +
                ALTER TABLE stu MODIFY name VARCHAR(20);
                + +

                由于我们没写“NOT NULL ”，所以非空约束就被去掉了。感觉这点的解释挺有意思的。

                +

                唯一约束

                添加唯一约束

                某列值不能重复

                +
                CREATE TABLE stu(
                	id INT,
                	phone_number VARCHAR(20) UNIQUE
                );
                ALTER TABLE stu MODIFY phone_number VARCHAR(20) UNIQUE;
                + +

                但是注意，唯一约束允许多个NULL存在。

                +

                删除唯一约束

                唯一约束的删除方法跟前面的非空约束就完全不一样了。

                +
                ALTER TABLE stu DROP INDEX phone_number;
                + +
                +

                创建唯一约束时会自动创建唯一索引，需要删除索引

                -

                虚拟存储器

                与Cache的差异

                image-20230619000944183

                -

                虚拟存储器

                image-20230618235955557

                -

                image-20230619000042556

                -

                相当于把主存-辅存（磁盘）看成另一个cache-主存。这也就类似于内存页面换入换出了。原来这玩意叫虚拟存储器啊，不过这也类似于虚拟地址空间的叫法就是了。

                -

                image-20230619000208477

                -

                image-20230619000304314

                -

                页表结构

                image-20230619000428020

                -

                访问流程

                image-20230619000542665

                -

                TLB

                image-20230619000628910

                -

                image-20230619000804374

                -

                image-20230619000827244

                -

                image-20230619000851370

                -

                辅助存储器

                硬盘、U盘、软盘、磁带、光盘

                -

                RAID

                image-20230619142112318

                -

                image-20230619142148621

                -

                image-20230619143428427

                -

                image-20230619143411577

                -

                系统总线

                概述

                是啥

                总线两个特点：分时和共享

                -

                遵循协议或标准，方便计算机系统集成、扩展和进化

                -

                总线的猝发传输方式：在一个总线周期内，传输存储地址连续的多个数据字的总线传输方式。

                -

                分类

                image-20230618173335493

                -

                image-20230618173414845

                -

                总线结构

                单总线

                注意，单总线是默认统一编址的？

                -

                image-20230618175005524

                -

                面向CPU的双总线

                image-20230618175035406

                -

                存储器为中心

                image-20230618175435591

                -

                有通道的多总线结构

                image-20230618175533637

                -

                image-20230618175631552

                -

                帅

                -

                image-20230618175705273

                -

                image-20230618175743501

                -

                总线控制

                总线判优控制

                image-20230618180345695

                -

                image-20230618180704321

                -

                注意，独立请求是最快的

                -

                链式查询

                -

                所有设备可在BR线发布总线请求，主设备通过BG线表态，争得总线的设备要通过BS线告诉其他设备总线忙。

                -

                BG线中，总线同意信号会依次遍历每一个设备，直到找到第一个提出请求的设备。

                -

                可见，这个遍历顺序就代表了各个IO设备的优先级顺序。

                -

                这样相当于分离出格外的线来控制信号。这种方式对电路故障非常敏感。

                +

                主键约束

                一张表只能有一个主键。主键非空且唯一。

                +

                添加主键约束

                CREATE TABLE stu(
                	id INT PRIMARY KEY,
                	name VARCHAR(20)
                );
                ALTER TABLE stu MODIFY id INT PRIMARY KEY;
                + +

                删除主键约束

                ALTER TABLE stu DROP PRIMARY KEY;
                + +

                自动增长

                这东西一般都跟主键结合使用。

                +

                若某一列是数值类型，可以使用auto_increment关键字来完成值的自动增长。

                +
                CREATE TABLE stu(
                	id INT PRIMARY KEY AUTO_INCREMENT,
                	NAME VARCHAR(20)
                );
                INSERT INTO stu VALUES(NULL,'111');# 设NULL或自己指派都行。
                + +

                自动增长的数据只跟上一个记录有关系。

                +

                外键约束

                引言

                image-20221207222232057

                +

                表中dep_name和dep_location有数据冗余，修改或者插入都不方便，不符合数据库设计准则，所以需要创造两张表。

                +

                image-20221207222418827

                +

                image-20221207222439652

                +

                但要是你想裁员了，直接在第二个表删研发部是没用的，第一个表数据还在，还得麻烦地一个个删。这时候外键就起作用了。

                +

                添加外键约束

                外键只能关联唯一约束或者主键约束的列。一般外键都是去关联主表的主键。

                +

                image-20221207223758950

                +
                CREATE TABLE employee(
                	id INT PRIMARY KEY AUTO_INCREMENT,
                	NAME VARCHAR(20),
                	age INT,
                	dep_id INT, -- 外键列
                	CONSTRAINT emp_dept_fk FOREIGN KEY (dep_id) REFERENCES department(id) -- 外键声明
                );

                ALTER TABLE employee ADD CONSTRAINT emp_dept_fk FOREIGN KEY (dep_id) REFERENCES department(id) -- 外键声明
                + +

                此时不能删除department的行【要是该行在employee表没出现过的话就可以删掉】，也不能在employee添加一个不存在的外键值。

                +

                删除外键约束

                ALTER TABLE employee DROP FOREIGN KEY emp_dept_fk;
                + +

                外键级联

                如果你想修改外表主键值，就需要用到级联更新。

                +
                ALTER TABLE employee ADD CONSTRAINT emp_dept_fk FOREIGN KEY (dep_id) REFERENCES department(id) ON UPDATE CASCADE ;-- 外键声明+级联更新声明
                + +

                如果你想达到删除一个主键值就能删除表中的所有与该主键值关联的数据，就需要用到级联删除。

                +
                ALTER TABLE employee ADD CONSTRAINT emp_dept_fk FOREIGN KEY (dep_id) REFERENCES department(id) ON DELETE CASCADE ;-- 外键声明+级联删除声明
                + +

                级联使用应该要谨慎。一是它不大安全，二是它涉及多表操作，效率低下

                +

                多表关系与范式

                多表关系

                image-20221219161901631

                +

                image-20221219161847190

                +

                image-20221219161853190

                +

                范式

                image-20221219162311785

                +

                image-20221219162646556

                +

                1NF

                image-20221219162034996

                +

                image-20221219162047446

                +

                2NF

                1NF中的主属性为学号和课程名称。可以看到，分数完全依赖于码，但是姓名、系名、系主任都只是部分依赖于码，这不符合2NF的条件。因而，我们就可以选择拆分表，把完全依赖的部分和部分依赖的部分分开：

                +

                由于分数->（学号，课程名称），因而可以把学号、课程名称、分数放在一张表

                +

                由于姓名、系名、系主任 ->(学号)，因而可以把学号、姓名、系名、系主任放在一张表

                +

                如下图所示。这样就消除了部分依赖。

                +

                图片2

                +

                3NF

                2NF中选课表的主属性为学号和课程名称，学生表的主属性为学号。可以看到，学生表中，存在着系主任->系名->学号这样的传递依赖，不符合3NF的规定。因而，我们需要对学生表进行进一步的拆分。

                +

                我们为了破坏系主任->系名->学号这个传递链，可以拆分成系主任->系名和系名->学号两个传递关系。

                +

                因而，可以把学生表拆分为如下图两张表：

                +

                image-20221219162231385

                +

                多表查询

                内连接查询

                隐式内连接

                使用where条件

                +
                -- 查询所有员工信息和对应的部门信息
                SELECT * FROM emp,dept WHERE emp.`dept_id` = dept.`id`;
                -- 进行去重就成为了自然连接：
                SELECT emp.*,dept.`NAME` FROM emp,dept WHERE emp.`dept_id` = dept.`id`;
                + +
                +

                此在书中称为“等值连接和非等值连接”。

                -

                image-20230618180431836

                -

                计数器定时查询

                -

                意思好像是，在BR线提出请求，主设备接收到请求后，可以响应的情况下，启动计数器，计数器初始值为零。计数器的值通过设备地址线输出。如果计数器为0，则观察接口0有没有请求，没有的话计数器++，继续看下一个，以此类推，直到找到第一个对应接口，则开始传输数据，BS线启用。

                -

                设备地址线需要给所有设备地址进行编码，因此宽度与设备数有关。

                -

                这个的优点在于，优先级的确定更加灵活了。比如说，计数器不一定从零开始而是从上一次停止的地方开始（循环优先级，这样的话每个设备的机会均等），或者用软件控制优先级初始值，或者每一次不一定++而是有其他计算规则。

                +

                显式内连接

                语法： select 字段列表 from 表名1 [inner] join 表名2 on 条件

                +
                SELECT * FROM emp INNER JOIN dept ON emp.`dept_id` = dept.`id`;
                + +

                外连接查询

                +

                关于外连接和内连接的区别，以及左外连接与右外连接的区别：

                +

                image-20221219155724391

                +

                ![屏幕截图 2022-12-19 155750](./JavaWeb/屏幕截图 2022-12-19 155750.png)

                +

                image-20221219155846157

                -

                image-20230618180602116

                -

                独立请求方式

                -

                优先级由主设备内部逻辑（排队器）规定。也可以用自适应、计数器等等等。

                +

                左外连接

                语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；

                +
                SELECT 	t1.*,t2.`name` FROM emp t1 LEFT JOIN dept t2 ON t1.`dept_id` = t2.`id`;
                + +

                右外连接

                语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；

                +
                SELECT 	* FROM dept t2 RIGHT JOIN emp t1 ON t1.`dept_id` = t2.`id`;
                + +

                子查询

                查询嵌套

                +
                +

                子查询中不允许使用ORDER BY

                +

                在实际运用中，内连接比子查询的效率更高

                -

                image-20230618180645765

                -

                总线通信控制

                image-20230618180848436

                -

                这玩意传输周期还考了

                -

                image-20230618180912414

                -

                这个通信方式有哪几种也要求默写了

                -

                image-20230618181827840

                -

                这个同步和异步的特点总结得很棒

                -

                同步、异步、半同步三者的共同点：

                -

                image-20230618181948854

                -

                同步

                -

                img定宽定距的时钟

                -

                白色菱形代表有地址、命令、数据；紫色阴影代表没有东西

                -

                数字电路中，数字电平从低电平（数字“0”）变为高电平（数字“1”）的那一瞬间（时刻）叫作上升沿。数字电平从高电平（数字“1”）变为低电平（数字“0”）的那一瞬间叫作下降沿。

                -

                有固定的时间点，和在每个固定时间点固定要做的事

                -

                第一部分：主设备要给出地址信号

                -

                第二部分：给出读命令（控制信号）

                -

                第三部分：从设备传输数据给主设备

                -

                第四部分：读命令、数据信号撤销

                -

                第五部分：地址信号撤销

                -

                img

                -

                *先给数据能保证命令到达立刻写入正确数据。菱形那段表示电平并非瞬间稳定*

                -

                *如果数据是并行就先给数据，再给读写信号，直接锁存；如果是串行数据，就先给读写信号，再给数据*

                -

                有固定的时间点，和在每个固定时间点固定要做的事

                -

                第一部分：主设备要给出地址信号

                -

                第二部分：主设备给出数据信号

                -

                第三部分：主设备给出写入信号

                -

                第四部分：写入

                -

                第五部分：读命令、数据信号撤销

                -

                第六部分：地址信号撤销

                +

                不相关子查询

                +

                image-20221219160800762

                -

                同步通信通常只适用于总线长度短的。

                -

                因为是并行总线，总线长度长了很难做到等长，到达设备后就不同步了

                -

                因为需要统一时标；总线长，需要迁就最远的设备；读写时间差距大，需要迁就最慢的设备

                -

                异步

                image-20230618181416220

                -
                不互锁

                CPU从主存读信息

                -

                主要用在单机不同设备之间的通信中

                -
                半互锁

                多机系统中，某个CPU需要访问共享存储器时

                -
                全互锁

                主要用于网络通信，如TCP三握手

                -

                半同步通信

                输入数据为例：

                -

                image-20230618181924196

                -

                分离式通信

                -

                在子周期2中，从模块实际上从从模块变成了主模板，因为它发起了占用总线的请求。

                +
                子查询结果单行单列

                可用于WHERE条件

                +
                -- 查询工资最高的员工信息
                SELECT * FROM emp WHERE emp.salary = (SELECT MAX(salary) FROM emp);
                + +
                子查询结果多行单列

                可以作为条件用IN关键字

                +
                -- 查询'财务部'和'市场部'所有的员工信息
                SELECT * FROM emp WHERE dept_id IN (SELECT id FROM dept WHERE name = "财务部" OR name = "市场部");
                + +
                子查询结果多行多列

                可以当做一个新表，可以转化为普通内连接

                +
                -- 查询员工入职日期是2011-11-11日之后的员工信息和部门信息
                -- 嵌套查询
                SELECT *
                FROM dept, (
                	SELECT *
                    FROM emp
                    WHERE emp.join_data > '2011-11-11'
                )
                WHERE dept.id = emp.dept_id;
                -- 内连接
                SELECT * FROM emp,dept WHERE emp.join_data > '2011-11-11' AND emp.dep_id = dept.id;
                + +

                相关子查询

                +

                image-20221219160653496

                +

                子查询内部使用了父查询的东西

                +

                image-20221219161626542

                +

                image-20221219161637827

                -

                image-20230618182050912

                -

                IO

                概述

                发展概况

                image-20230619144243913

                -

                image-20230619144359313

                -

                image-20230619144452679

                -

                组成

                image-20230619144602504

                +

                事务

                基本介绍

                概念

                一个包含多个步骤的业务操作被事务管理，操作要么同时成功，要么同时失败。【有种原子操作的感觉？】

                +

                image-20221219214157761

                +

                当操作失败时，会回滚到执行前的状态。

                +

                事务操作

                事实上就是类似有个缓冲区，得到commit指令就把缓冲区内容更新，得到rollback指令就把缓冲区内容丢弃。

                +
                -- 开启事务
                START TRANSACTION;

                -- 操作序列：转账500元
                UPDATE usr SET money = money - 500 WHERE uname = "Mary";
                UPDATE usr SET money = money + 500 WHERE uname = "Lily";

                -- 提交
                COMMIT;
                + +
                -- 开启事务
                START TRANSACTION;

                -- 操作序列：转账500元
                UPDATE usr SET money = money - 500 WHERE uname = "Mary";
                出错了
                UPDATE usr SET money = money + 500 WHERE uname = "Lily";

                -- 出错则回滚
                ROLLBACK;
                + +
                开启事务
                START TRANSACTION;
                + +
                回滚事务
                ROLLBACK;
                + +
                提交事务
                COMMIT;
                + +

                一条DML（增删改表中数据）语句默认会自动提交。但如果手动开启了事务，那么事务内保护的原子序列就需要手动提交。

                +

                如果想将默认提交给kill了，也即不论是否开启事务都得手动提交，那么就需要用如下语句：

                +
                SET @@autocommit = 0;
                + +

                事务的四大特征

                原子性

                持久性

                一旦事务提交/回滚，会持久性更新数据库表。

                +

                隔离性

                多个事务之间应该相互独立。为了保障这一点，需要设置事务的隔离级别。

                +

                一致性

                事务操作前后数据总量不变。

                +

                事务的隔离级别

                概念：多个事务之间隔离的，相互独立的。但是如果多个事务操作同一批数据，则会引发一些问题，设置不同的隔离级别就可以解决这些问题。【有点并发的感觉】

                +

                image-20221219221141605

                +

                隔离级别越高，安全性越高，效率越来越差。

                +

                mysql默认的是3，oracle默认的是2.

                +

                可以设置隔离级别。

                +
                set global transaction isolation level  "级别字符串";
                +
                -

                ① IO指令

                -

                操作码相当于标志，标志这个指令是IO的。命令码才算是操作码，指出对IO设备做什么。设备码给出IO设备或者设备中某一个寄存器【端口】的编址。

                -

                ② 通道指令

                -

                通道是小型DMA处理器，可以实现IO设备与主机之间进行信息交互。

                -

                通道有自己的控制器，有的通道还有存储器。

                -

                通道能够执行由通道指令组成的通道程序。

                -

                通常情况下，编程人员在应用程序当中，为了调用外部设备，应用程序中需要增加广义IO指令【这意思是封装吧】。广义IO指令要指出参加数据传输的IO设备、数据传输主存的首地址、传输数据的长度、传输方向。操作系统根据广义IO指令给出的参数以及要求的操作，会编写一个由通道指令组成的通道程序，并且会把程序放到内存或者是通道内存的指定位置，之后启动通道进行工作。

                +

                通过之后老师说的内容，感觉有了点个人的感悟：

                +

                级别1寻找数据可能优先从缓冲区找；级别2相当于不能读到缓冲区内容；级别3可能相当于在开启事务前对表做了个快照？级别4应该就是直接上了把互斥锁，同一时刻只能一个事务读写。

                -

                连接方式

                编址

                image-20230619144651480

                -

                选址和传送

                image-20230619144727325

                -

                联络方式

                image-20230619144851937

                -

                image-20230619145010236

                -

                连接方式

                image-20230619145037444

                -

                控制方式

                image-20230619145313853

                -

                程序查询方式

                image-20230619145133293

                -

                程序中断方式

                image-20230619145154206

                -

                image-20230619145214775

                -

                DMA方式

                image-20230619145252864

                -

                外部设备

                概述

                image-20230619145414624

                -

                IO接口

                概述

                image-20230619151239077

                -

                功能和组成

                image-20230619151310223

                -

                image-20230619151421396

                -

                image-20230619151442848

                -

                接口类型

                image-20230619151602920

                -

                程序查询方式

                image-20230619151713642

                -

                image-20230619152130068

                -

                image-20230619152909693

                -

                程序中断方式

                中断

                概述

                image-20230619153352974

                -

                image-20230619153557165

                -

                接口电路

                image-20230619153715848

                -
                中断请求触发器和中断屏蔽触发器

                image-20230619153949008

                -

                image-20230619154445642

                -

                中断分类

                外部中断一般是由计算机外设发出的中断请求，如：键盘中断、打印机中断、定时器中断等。

                -

                外部中断一般指io高低电平(下降沿等由寄存器配置)来触发并响应io中断函数。

                -

                接口电路

                排队器

                image-20230619155014803

                -

                image-20230619155029933

                -
                硬件实现

                image-20230619155054248

                -
                -

                以下介绍的是链式排队器

                -
                  -
                1. INTR默认为0，取非为1. 经&后整个排队电路为1
                  2. -
                2. 当i设备发出请求，INTRi=1，取非为0，经&后变为0，INTPi之后的电路清零，只有i之前的INTP为1
                  3. -
                3. 3在一连串的显示为 1 的INTP中，最后一个显示1的设备优先级最高。因为按照我们的分析，是它发出了请求
                  4. +

                  JDBC

                  概念

                  Java Database Connectivity Java语言操作数据库

                  +

                  image-20221220141025613

                  +

                  image-20221220141214259

                  +

                  快速入门

                    +

                  1. 导入驱动jar包

                    +

                    ① 新建libs目录

                    +

                    ② 把jar包复制到libs目录下

                    +

                    ③ 右键libs目录 add as library

                    +
                    2. +

                  2. 注册驱动

                    +
                    3. +

                  3. 获取数据库连接对象 Connection

                    +
                    4. +

                  4. 定义sql语句

                    +
                    5. +

                  5. 获取执行sql语句的对象 Statement

                    +
                    6. +

                  6. 执行sql，接收返回的结果

                    +
                    7. +

                  7. 处理结果

                    +
                    8. +

                  8. 释放资源

                    +
                  -

                  使用与非+非而不是直接与门是因为与非门+非更便宜。

                  -

                  我猜这个意思是，链式排队的话，越前面的优先级越高，现在我们讲的是怎么快速****找出****最高的最前面的是哪一个。之所以为什么越前面的优先级最高，可从这个电路中得知。如果一个东西发出请求，那么它后面的INTPi’都会被置零，因而它肯定比它后面的高级。因此越前面的优先级越高。

                  -

                  https://www.likecs.com/show-390301.html

                  -

                  img

                  -

                  这个可以验证我的观点。至于这个轮询方式，应该在第三章的总线那边讲过，应该用的是链式查询。

                  -
                -
                软件实现

                程序查询

                -

                image-20230619155116410

                -

                中断向量形成部件

                硬件向量法

                image-20230619155154822

                -
                软件查询法

                image-20230619161630629

                -

                接口电路组成

                image-20230619161803883

                +
                public class JdbcDemo1 {
                    public static void main(String[] args) throws ClassNotFoundException, SQLException {
                        //1 注册驱动
                        Class.forName("com.mysql.jdbc.Driver");
                        //2 获取数据库连接对象
                        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/helloworld","root","root");
                        //3 定义sql语句
                        String sql = "update usr set money = 5000 where id = 1";
                        //4 获取执行对象 Statement
                        Statement stmt = conn.createStatement();
                        //5 执行sql
                        int count = stmt.executeUpdate(sql);
                        //6 处理结果
                        System.out.println(count);
                        //7 释放资源
                        stmt.close();
                        conn.close();
                    }
                }
                + +

                优化版【增加try-catch-finally】：

                +
                public class JdbcDemo1 {
                    public static void main(String[] args) {
                        //1 注册驱动
                        //提升作用域，放在try外面
                        Connection conn = null;
                        Statement stmt = null;
                        ResultSet resultSet = null;
                        try {
                            Class.forName("com.mysql.jdbc.Driver");
                            //2 获取数据库连接对象
                            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/helloworld","root","root");
                			//3 定义sql语句
                            String sql = "select * from usr";
                			//4 获取执行对象 Statement
                            stmt = conn.createStatement();
                			//5 执行sql
                            resultSet = stmt.executeQuery(sql);
                			//6 处理结果
                            if (resultSet == null)
                                System.out.println("修改失败");
                            else {
                                while(resultSet.next()){
                                    System.out.println(resultSet.getInt(1)+" "
                                            +resultSet.getString(2)+" "
                                            +resultSet.getInt(3));
                                }
                            }

                        } catch (ClassNotFoundException e) {
                            throw new RuntimeException(e);
                        } catch (SQLException e) {
                            throw new RuntimeException(e);
                        } finally {
                            if (resultSet != null){
                                try {
                                    resultSet.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                            //为了避免空指针异常
                            if (stmt != null) {
                                try {
                                    stmt.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                            if (conn != null){
                                try {
                                    conn.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        }
                    }
                }
                + +

                详解各个类

                DriverManager

                注册驱动

                目的是告诉程序该使用哪一个数据库驱动jar包

                +

                在快速入门中，我们使用这一行来注册驱动：

                +
                Class.forName("com.mysql.jdbc.Driver");
                + +

                表面上看跟DriverManager类可以说是毫无关系。

                +

                但其实，类加载器加载类的时候，其实是会自动执行类中的静态代码块的。Driver类中有一段静态代码块如下：

                +
                static {
                    try {
                        DriverManager.registerDriver(new Driver());
                    } catch (SQLException var1) {
                        throw new RuntimeException("Can't register driver!");
                    }
                }
                + +

                可见，注册驱动其实主要任务是由DriverManager类干的。这个静态块仅仅用于简化代码书写。

                -

                应该意思就是，参照上面那个程序电路图，首先CPU先发送一个启动IO设备的命令，然后就去忙了。

                -

                与此同时，IO接口接到命令开始准备，比如说对DBR的整理【因读写而异】。

                -

                IO接口准备完之后会卡在INTR那边，等待CPU的中断查询信号。

                -

                CPU本来一直在不断边干自己的活边发送中断查询信号【在每条指令执行阶段的结束前】，终于逮到这个时候发现IO接口已经准备好了，就回复中断响应信号，CPU进入中断周期，执行中断隐指令。

                -

                IO接口发出中断请求后就排好队选好设备了，收到CPU的中断响应信号，就给CPU发向量地址，CPU根据地址去内存中找到中断服务程序并开始执行，之后就可以开始数据传输了。

                -

                可见这个过程是异步的。

                +

                注意：mysql5之后的版本，这一步注册驱动可以省略。

                +

                image-20221220151045275

                +

                配置文件里自动帮你注册了。我想原理应该是让本文件的类自动加载。

                -

                中断响应（中断处理过程）

                image-20230619162001376

                -

                image-20230619162057309

                -

                IO中断处理过程

                image-20230619162142239

                -

                image-20230619201800980

                -

                单重/多重中断服务流程（CPU）

                image-20230619201934346

                -

                image-20230619202014591

                -

                image-20230619202106846

                -

                中断屏蔽技术（CPU）

                image-20230619202207357

                -

                image-20230619202219859

                -

                image-20230619202321781

                -

                image-20230619202355070

                -

                image-20230619202434146

                -

                DMA方式

                特点

                image-20230619202548302

                -

                实现方案

                image-20230619202628150

                -

                沙比

                -

                image-20230619202708423

                -

                image-20230619202739633

                -

                功能和组成

                image-20230619202841809

                -

                image-20230619203043097

                -

                工作过程

                DMA传送过程

                预处理、数据传送、后处理

                -

                image-20230619203248171

                -

                注意还有个传送字数，看来有点安全设定。如果溢出了就需要中断

                -

                image-20230619203423482

                -

                image-20230619203535039

                -

                连接方式

                image-20230619204520342

                -

                image-20230619204537086

                -

                与程序中断比较

                image-20230619204641555

                -]]> - - - 其他的对实验未涉及的思考 - /2023/02/25/cs144$else/ - 其他的对实验未涉及的思考

                网络层实现

                在我们的协议栈实现中，我们负责了运输层的TCP协议、网络层的ARP协议以及数据链路层的ETH协议的编写，剩下的网络层的IP协议则由官方给定。接下来我们就来探究下网络层的实现。

                -

                总体架构

                -

                You’ve done this already.

                -

                In Lab 4, we gave:

                +
                获取数据库连接
                Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/helloworld","root","root");
                + +

                url的语法：”jdbc:mysql://IP地址:端口号/数据库名称”

                +

                image-20221220151425953

                +

                Connection

                数据库连接对象。

                +
                获取Statement对象
                Statement createStatement() throws SQLException;
                PreparedStatement prepareStatement(String sql) throws SQLException;
                + +
                管理事务
                开启事务
                void setAutoCommit(boolean autoCommit) throws SQLException;
                + +

                设置参数为false即开启事务。也即关闭自动提交。

                +
                提交事务
                void commit() throws SQLException;
                + +
                回滚事务
                void rollback() throws SQLException;
                + +

                Statement

                +

                The object used for executing a static SQL statement and returning the results it produces.执行静态sql

                +
                +
                执行sql
                //执行任意语句
                boolean execute(String sql) throws SQLException;
                /*
                  执行DML（增删改表中数据）和DDL（表和库）语句
                  返回值：影响到的行数。
                */
                int executeUpdate(String sql) throws SQLException;
                //执行DQL（查询表记录）语句
                ResultSet executeQuery(String sql) throws SQLException;
                + +

                ResultSet

                封装查询结果集。

                +

                具体取数方法就是类似迭代器原理。next移动迭代器指针，getXxx()方法，Xxx是数据类型，得到该行表记录中对应列对应数据类型的值。可以传入列数或者列名。

                +
                boolean next() throws SQLException;
                String getString(int columnIndex) throws SQLException;
                boolean getBoolean(int columnIndex) throws SQLException;
                //...
                long getLong(int columnIndex) throws SQLException;
                //...
                /*@param:
                columnLabel – the label for the column specified with the SQL AS clause.
                		If the SQL AS clause was not specified, then the label is the name of the column
                */
                String getString(String columnLabel) throws SQLException;
                + +

                使用实例：

                +

                image-20221220164414363

                +
                public static Collection<Client> query(){
                    ArrayList<Client> clients = new ArrayList<>();
                    Connection conn = null;
                    Statement stmt = null;
                    ResultSet resultSet = null;
                    try {
                        Class.forName("com.mysql.jdbc.Driver");
                        conn = DriverManager.getConnection("jdbc:mysql:///helloworld","root","root");
                        stmt = conn.createStatement();
                        resultSet = stmt.executeQuery("select * from usr");
                        if (resultSet == null)
                            System.out.println("查询失败");
                        else
                            while(resultSet.next())
                                clients.add(new Client(resultSet.getInt(1),
                                                       resultSet.getString(2),
                                                       resultSet.getInt(3)));
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException(e);
                    } catch (SQLException e) {
                        throw new RuntimeException(e);
                    } finally {
                        if (resultSet != null){
                            try {
                                resultSet.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        //为了避免空指针异常
                        if (stmt != null) {
                            try {
                                stmt.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        if (conn != null){
                            try {
                                conn.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                    return clients;
                }
                + +

                注意：

                  -
                1. an object that represents an Internet datagram and knows how to parse and serialize itself (tcp_helpers/ipv4_datagram.{hh,cc}) 表示了Internet datagram的数据结构，它可以自己序列化。
                  2. -
                2. the logic to encapsulate(封装) TCP segments in IP (now found in tcp_helpers/tcp_over_ip.cc).
                  3. +

                3. 这东西也得Close。

                  +
                  4. +

                4. 如果想做“查询到了结果则返回true”这样的操作，不应该使用这样的代码：

                  +
                  if (resultSet != null)  return true;
                  else return false;
                  + +

                  而应该这样：

                  +
                  return resultSet.next();
                -

                The CS144TCPSocket uses these tools to connect your TCPConnection to a TUN device.

                -
                -

                也即，IP协议主要由两个文件实现，一个是IP数据报抽象为的类ipv4_datagram.{hh,cc}，另一个是将TCP报文封装为IP报文的类tcp_helpers/tcp_over_ip.cc；除此之外，IP协议还负责与下次协议连接，在实验0-4中它通过CS144TCPSocket与TUN连接，在实验5-6则与TAN连接。

                -

                连接部分暂且先放到下一部分讲，下面来看看IP协议的具体实现。

                -

                具体实现

                ipv4_datagram.hh && ipv4_header.hh

                ipv4_datagram没什么好说的，跟TCPSegment的结构一模一样。ipv4_header也没什么好说的，就纯纯是IP数据报的报头、

                -

                tcp_over_ip

                头文件

                它的头文件很简单，只包含一个类的定义：

                -
                // A converter from TCP segments to serialized IPv4 datagrams
                class TCPOverIPv4Adapter : public FdAdapterBase {
                  public:
                    std::optional<TCPSegment> unwrap_tcp_in_ip(const InternetDatagram &ip_dgram);

                    InternetDatagram wrap_tcp_in_ip(TCPSegment &seg);
                };
                #endif  // SPONGE_LIBSPONGE_TCP_OVER_IP_HH
                +

                PreparedStatement

                简介
                //An object that represents a precompiled SQL statement.
                //表示预编译的sql语句的对象
                public interface PreparedStatement extends Statement
                -
                具体实现

                可以看到，相比于TCP和ETH/ARP协议，IP协议的实现可以说是非常简单。它作为一个中间层，只需要把上面给的东西包装下再传到下面，或者把下面给的东西解包下再传给上面，无需其他复杂的算法和数据结构（比如TCP的reliable transmission和ETH/ARP的地址自学习），也无需跟外界打交道。

                -

                除了打包解包外，它只需确保一件事，那就是一台主机只能同时拥有一个TCP连接。这样一来也能简化其实现：填写IP协议头时，它就只需从自己保存的config中取参数就行。

                -
                // 用来拆IP数据包为一个TCP数据包
                //! If this succeeds, it then checks that the received segment is related to the
                //! current connection. When a TCP connection has been established, this means
                //  如果TCP连接已建立，则会检查src和dst端口号的正确性
                //! checking that the source and destination ports in the TCP header are correct.
                //!
                //! If the TCP connection is listening 如果处于listening状态，并且参数为SYN报文
                //! and the TCP segment read from the wire includes a SYN, this function clears the
                //  就需要解除listening的flag，记录下src和dst的地址和端口号
                //! `_listen` flag and records the source and destination addresses and port numbers
                //  目的是为了 filter future reads
                //  这说明我们的sponge实现是单线程的，也就是一台主机只能同时建立一个TCP连接
                //  并且在此时会忽略其他主机发过来的数据包
                //! from the TCP header; it uses this information to filter future reads.

                //  returns a std::optional<TCPSegment> that is empty if the segment was invalid or unrelated
                optional<TCPSegment> TCPOverIPv4Adapter::unwrap_tcp_in_ip(const InternetDatagram &ip_dgram) {
                    // is the IPv4 datagram for us?
                    // Note: it's valid to bind to address "0" (INADDR_ANY) and reply from actual address contacted
                    if (not listening() and (ip_dgram.header().dst != config().source.ipv4_numeric())) {
                        return {};
                    }

                    // is the IPv4 datagram from our peer?
                    // 过滤非peer发来的其他数据包
                    if (not listening() and (ip_dgram.header().src != config().destination.ipv4_numeric())) {
                        return {};
                    }

                    // does the IPv4 datagram claim that its payload is a TCP segment?
                    // 我们只需解包TCP数据报
                    if (ip_dgram.header().proto != IPv4Header::PROTO_TCP) {
                        return {};
                    }

                    // is the payload a valid TCP segment?
                    TCPSegment tcp_seg;
                    if (ParseResult::NoError != tcp_seg.parse(ip_dgram.payload(), ip_dgram.header().pseudo_cksum())) {
                        return {};
                    }

                    // is the TCP segment for us?
                    if (tcp_seg.header().dport != config().source.port()) {
                        return {};
                    }

                    // should we target this source addr/port (and use its destination addr as our source) in reply?
                    if (listening()) {
                        // records the source and destination addresses and port numbers
                        if (tcp_seg.header().syn and not tcp_seg.header().rst) {
                            config_mutable().source = {inet_ntoa({htobe32(ip_dgram.header().dst)}), config().source.port()};
                            config_mutable().destination = {inet_ntoa({htobe32(ip_dgram.header().src)}), tcp_seg.header().sport};
                            set_listening(false);
                        } else {
                            return {};
                        }
                    }

                    // is the TCP segment from our peer?
                    if (tcp_seg.header().sport != config().destination.port()) {
                        return {};
                    }

                    return tcp_seg;
                }

                //! Takes a TCP segment, sets port numbers as necessary, and wraps it in an IPv4 datagram
                //! \param[in] seg is the TCP segment to convert
                InternetDatagram TCPOverIPv4Adapter::wrap_tcp_in_ip(TCPSegment &seg) {
                    // set the port numbers in the TCP segment
                    seg.header().sport = config().source.port();
                    seg.header().dport = config().destination.port();

                    // create an Internet Datagram and set its addresses and length
                    InternetDatagram ip_dgram;
                    ip_dgram.header().src = config().source.ipv4_numeric();
                    ip_dgram.header().dst = config().destination.ipv4_numeric();
                    // uint8_t hlen = LENGTH / 4;  //!< header length
                    // uint8_t doff = LENGTH / 4;  //!< data offset
                    ip_dgram.header().len = ip_dgram.header().hlen * 4 + seg.header().doff * 4 + seg.payload().size();

                    // set payload, calculating TCP checksum using information from IP header
                    ip_dgram.payload() = seg.serialize(ip_dgram.header().pseudo_cksum());

                    return ip_dgram;
                }
                +

                Statement的子类。可以用来解决sql注入问题。

                +

                它是预编译的sql语句，也即sql语句中的参数使用“？”占位符，需要传入参数。

                +
                使用步骤

                如下面的验证密码程序。键盘输入账号密码，从数据库查询该用户是否存在。

                +
                public class Login {
                    public static void main(String[] args) throws IOException {
                        //输入账号密码
                        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                        System.out.println("Please enter the user name.");
                        String uname = br.readLine();
                        System.out.println("Please enter the password.");
                        String password = br.readLine();
                        //验证账号密码
                        System.out.println(checkPassword(uname,password));
                    }

                    public static boolean checkPassword(String uname,String password){
                        if (uname == null | password == null)   return false;
                        
                        Connection conn = null;
                        PreparedStatement stmt = null;
                        ResultSet resultSet = null;
                        try {
                            conn = JDBCUtils.getConnection();
                            stmt = conn.prepareStatement(
                                "select * from user where name = ? and password = ?");
                            //这跟resultset的获取表值的那个是一样的，都是需要指定列数和要设定的值。
                            //并且下标都是以1开始。
                            stmt.setString(1,uname);
                            stmt.setString(2,password);
                            resultSet = stmt.executeQuery();
                //            stmt = conn.createStatement();
                //            resultSet = stmt.executeQuery("select * from user where name = '"
                //            								+uname+"' and password = '"+password+"'");
                            return resultSet.next();
                        } catch (SQLException e) {
                            throw new RuntimeException(e);
                        } finally {
                            JDBCUtils.close(conn,stmt,resultSet);
                        }
                    }
                }
                -

                Socket实现

                最top的话可以分为CS144TCPSocket和FullStackSocket。

                -

                继承关系如下图：

                -

                Inheritance graph

                -

                其中，TCPSocket是完完全全的包装类，它的所有协议栈都是在内核态中实现（也就是跟我们之后写的没半毛钱关系），它的存在意义应该是用在lab0来写webget的测试。而CS144TCPSocket就是我们在lab0-4用的了，它的数据链路层由内核实现，网络层和运输层由用户实现。FullStackSocket就是加上了我们在lab5做的用户态数据链路层。

                -

                最主要的部分是TCPSpongeSocket的实现，其他就是一些包装类没什么好说的。

                -

                FileDescriptor

                将socket看作是fd，将网络看作是IO，这一抽象简直是太伟大了，牛逼到爆。

                -

                头文件

                //! A reference-counted handle to a file descriptor
                class FileDescriptor {
                    //! \brief A handle on a kernel file descriptor.
                    //! \details FileDescriptor objects contain a std::shared_ptr to a FDWrapper.
                    class FDWrapper {
                      public:
                        int _fd;                    // file descriptor number returned by the kernel
                        bool _eof = false;          // fd是否eof
                        bool _closed = false;       // fd是否close
                        // fd被读写的次数
                        unsigned _read_count = 0;   
                        unsigned _write_count = 0; 

                        //! Construct from a file descriptor number returned by the kernel
                        explicit FDWrapper(const int fd);
                        //! Closes the file descriptor upon destruction
                        ~FDWrapper();
                        //! Calls [close(2)](\ref man2::close) on FDWrapper::_fd
                        void close();
                        //! An FDWrapper cannot be copied or moved
                        FDWrapper(const FDWrapper &other) = delete;
                        FDWrapper &operator=(const FDWrapper &other) = delete;
                        FDWrapper(FDWrapper &&other) = delete;
                        FDWrapper &operator=(FDWrapper &&other) = delete;
                    };

                    //! A reference-counted handle to a shared FDWrapper
                    std::shared_ptr<FDWrapper> _internal_fd;

                    // private constructor used to duplicate the FileDescriptor (increase the reference count)  这个构造函数会增加其参数传进来的那个fd的引用，也许相当于dump
                    explicit FileDescriptor(std::shared_ptr<FDWrapper> other_shared_ptr);

                  protected:
                    void register_read() { ++_internal_fd->_read_count; }    //!< increment read count
                    void register_write() { ++_internal_fd->_write_count; }  //!< increment write count

                  public:
                    //! Construct from a file descriptor number returned by the kernel
                    explicit FileDescriptor(const int fd);

                    //! Free the std::shared_ptr; the FDWrapper destructor calls close() when the refcount goes to zero.
                    ~FileDescriptor() = default;

                    /*  读写  */
                    std::string read(const size_t limit = std::numeric_limits<size_t>::max());
                    void read(std::string &str, const size_t limit = std::numeric_limits<size_t>::max());
                    // possibly blocking until all is written
                    size_t write(const char *str, const bool write_all = true) { return write(BufferViewList(str), write_all); }
                    size_t write(const std::string &str, const bool write_all = true) { return write(BufferViewList(str), write_all); }
                    size_t write(BufferViewList buffer, const bool write_all = true);

                    //! Close the underlying file descriptor
                    void close() { _internal_fd->close(); }

                    //! Copy a FileDescriptor explicitly, increasing the FDWrapper refcount
                    FileDescriptor duplicate() const;

                    //! Set blocking(true) or non-blocking(false)
                    void set_blocking(const bool blocking_state);
                    // ...
                +
                用PreparedStatement替代Statement

                它更安全且效率更高。

                +

                JDBC工具类

                书写

                public class JDBCUtils {
                    //获取连接时不想传参，且需要保证通用性，使用配置文件
                    //配置文件只需读取一次，可以用静态代码块完成
                    private static Properties pro;
                    private static String url;
                    private static String driver;
                    private static String user;
                    private static String password;
                    static{
                        pro = new Properties();
                        try {
                            /*
                            ClassLoader类可以获取src路径下的文件。使用ClassLoader获取文件时，只用传入相对于src的相对路径就行
                            此处如果使用FileReader，需要以下写法：
                            pro.load(new FileReader(
                                    JDBCUtils.class.getClassLoader()
                                            .getResource("jdbc.properties")
                                            .getPath())
                            );
                            */
                            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("./jdbc.properties"));
                            url = pro.getProperty("url");
                            user = pro.getProperty("user");
                            password = pro.getProperty("password");
                            driver = pro.getProperty("driver");
                            //在静态块里注册驱动
                            Class.forName(driver);
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        } catch (ClassNotFoundException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    public static Connection getConnection()  {
                        try {
                            return DriverManager.getConnection(url,user,password);
                        } catch (SQLException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    //重载机制
                    public static void close(Connection conn){
                        close(conn,null,null);
                    }

                    public static void close(Connection conn, Statement stmt){
                        close(conn,stmt,null);
                    }

                    public static void close(Connection conn, Statement stmt, ResultSet resultSet){
                        if (resultSet != null){
                            try {
                                resultSet.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        if (stmt != null){
                            try {
                                stmt.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        if (conn !=null){
                            try {
                                conn.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                }
                -

                具体实现

                差不多就是全程调用系统调用没什么好说的，记录下几个有意思的点

                -
                包装系统调用

                可以看下其调用系统调用的方式，看起来很有意思：

                -
                void FileDescriptor::set_blocking(const bool blocking_state) {
                    int flags = SystemCall("fcntl", fcntl(fd_num(), F_GETFL));
                    if (blocking_state) {
                        flags ^= (flags & O_NONBLOCK);
                    } else {
                        flags |= O_NONBLOCK;
                    }

                    SystemCall("fcntl", fcntl(fd_num(), F_SETFL, flags));
                }
                +

                使用

                public static Collection<Client> query(){
                    ArrayList<Client> clients = new ArrayList<>();
                    Statement stmt = null;
                    Connection conn = null;
                    ResultSet resultSet = null;
                    try {
                        conn = JDBCUtils.getConnection();
                        stmt = conn.createStatement();
                        resultSet = stmt.executeQuery("select * from usr");
                        if (resultSet == null)
                            System.out.println("查询失败");
                        else
                            while(resultSet.next())
                                clients.add(new Client(resultSet.getInt(1),resultSet.getString(2),resultSet.getInt(3)));
                    } catch (SQLException e) {
                        throw new RuntimeException(e);
                    } finally {
                        JDBCUtils.close(conn,stmt,resultSet);
                    }
                    return clients;
                }
                -

                比如说这里设置文件读写是否阻塞就是通过系统调用实现的。

                -

                在写os实验时，你应该就能很深刻感受到，很多时候调用完一个系统调用后，对它的返回结果进行合法性判断以及错误处理还是有点烦的（举例来说，如if(kalloc() == 0)或者if(mappages() == 0)，出错后杀死进程等等等）。在那会我们还可以直接就这么冗余地干了，但是这里不行，一是我们要用面向对象的思想，二是我们的重点事实上并不是操作系统而是网络，因而最好还是这么封装下以减少冗余代码。

                -

                而它除了会调用系统调用外，还使用了一个包装性的方法SystemCall来保障调用的安全性和合理性。看看SystemCall的具体实现方式，确实就是包了层安全检查。

                -
                int SystemCall(const char *attempt, const int return_value, const int errno_mask) {
                    if (return_value >= 0 || errno == errno_mask) {
                        return return_value;
                    }

                    throw unix_error(attempt);
                }

                // os内核看不懂c++，所以要注意转换为c-style的字符串
                int SystemCall(const string &attempt, const int return_value, const int errno_mask) {
                    return SystemCall(attempt.c_str(), return_value, errno_mask);
                }
                +

                JDBC控制事务

                使用Connection对象的管理事务的方法。

                +

                image-20221220214249168

                +

                image-20221220224401302

                +
                public class Account {
                    public static void main(String[] args) {
                        Connection conn = null;
                        PreparedStatement stmt = null;
                        PreparedStatement stmt2 = null;
                        try {
                            conn = JDBCUtils.getConnection();
                            conn.setAutoCommit(false);
                            stmt = conn.prepareStatement(
                                    "update usr set money = money - 500 where id = 1");
                            stmt.executeUpdate();
                //            int i = 3/0;
                            stmt2 = conn.prepareStatement(
                                    "update usr set money = money + 500 where id = 2");
                                stmt2.executeUpdate();
                            conn.commit();
                        } catch (Exception e) {
                            try {
                                conn.rollback();
                            } catch (SQLException ex) {
                                throw new RuntimeException(ex);
                            }
                            throw new RuntimeException(e);
                        } finally {
                            JDBCUtils.close(conn,stmt);
                        }
                    }
                }
                -

                Socket

                没什么好说的，只是操作系统socket接口的包装类。

                -

                头文件

                // Base class for network sockets (TCP, UDP, etc.)
                // Socket is generally used via a subclass. See TCPSocket and UDPSocket for usage examples.
                class Socket : public FileDescriptor {
                  private:
                    //! Get the local or peer address the socket is connected to
                    Address get_address(const std::string &name_of_function,
                                        const std::function<int(int, sockaddr *, socklen_t *)> &function) const;

                  protected:
                    Socket(const int domain, const int type);
                    Socket(FileDescriptor &&fd, const int domain, const int type);
                    
                    template <typename option_type>
                    void setsockopt(const int level, const int option, const option_type &option_value);
                  public:
                    // Bind a socket to a local address, usually for listen/accept
                    void bind(const Address &address);
                    // Connect a socket to a peer address
                    void connect(const Address &address);
                    // Shut down a socket
                    void shutdown(const int how);
                    //! Get local address of socket
                    Address local_address() const;
                    //! Get peer address of socket
                    Address peer_address() const;
                    //! Allow local address to be reused sooner
                    void set_reuseaddr();
                };

                //! A wrapper around [UDP sockets](\ref man7::udp)
                class UDPSocket : public Socket {
                  protected:
                    //! \brief Construct from FileDescriptor (used by TCPOverUDPSocketAdapter)
                    //! \param[in] fd is the FileDescriptor from which to construct
                    explicit UDPSocket(FileDescriptor &&fd) : Socket(std::move(fd), AF_INET, SOCK_DGRAM) {}

                  public:
                    //! Default: construct an unbound, unconnected UDP socket
                    UDPSocket() : Socket(AF_INET, SOCK_DGRAM) {}

                    // carries received data and information about the sender
                    struct received_datagram {
                        Address source_address;  //!< Address from which this datagram was received
                        std::string payload;     //!< UDP datagram payload
                    };
                    //! Receive a datagram and the Address of its sender
                    received_datagram recv(const size_t mtu = 65536);
                    //! Receive a datagram and the Address of its sender (caller can allocate storage)
                    void recv(received_datagram &datagram, const size_t mtu = 65536);

                    //! Send a datagram to specified Address
                    void sendto(const Address &destination, const BufferViewList &payload);
                    //! Send datagram to the socket's connected address (must call connect() first)
                    void send(const BufferViewList &payload);
                };

                //! A wrapper around [TCP sockets](\ref man7::tcp)
                class TCPSocket : public Socket {
                  private:
                    // Construct from FileDescriptor (used by accept())
                    // fd is the FileDescriptor from which to construct
                    explicit TCPSocket(FileDescriptor &&fd) : Socket(std::move(fd), AF_INET, SOCK_STREAM) {}
                  public:
                    //! Default: construct an unbound, unconnected TCP socket
                    TCPSocket() : Socket(AF_INET, SOCK_STREAM) {}
                    //! Mark a socket as listening for incoming connections
                    void listen(const int backlog = 16);
                    //! Accept a new incoming connection
                    TCPSocket accept();
                };

                //! A wrapper around [Unix-domain stream sockets](\ref man7::unix)
                class LocalStreamSocket : public Socket {
                  public:
                    // ...构造器
                };
                #endif  // SPONGE_LIBSPONGE_SOCKET_HH
                +

                数据库连接池

                其实就是上面的JDBC中的Connection的对象池。

                +

                image-20221222212904151

                +

                C3P0

                基本使用

                非常简单，就是改一下Connection的获取，写一下xml就行。

                +
                设置配置文件

                固定放在src目录下。名字必须为c3p0-config.xml或者c3p0.properties

                +
                <c3p0-config>
                    <!-- 使用默认的配置读取连接池对象 -->
                    <default-config>
                        <!--  连接参数 -->
                        <property name="driverClass">com.mysql.jdbc.Driver</property>
                        <property name="jdbcUrl">jdbc:mysql://localhost:3306/helloworld</property>
                        <property name="user">root</property>
                        <property name="password">root</property>

                        <!-- 连接池参数 -->
                        <property name="initialPoolSize">5</property>
                        <property name="maxPoolSize">10</property>
                        <!-- 如果超过此超时时间，就说明数据库连接失败 -->
                        <property name="checkoutTimeout">3000</property>
                    </default-config>

                    <named-config name="otherc3p0">
                        <!--  连接参数 -->
                        <property name="driverClass">com.mysql.jdbc.Driver</property>
                        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
                        <property name="user">root</property>
                        <property name="password">root</property>

                        <!-- 连接池参数 -->
                        <property name="initialPoolSize">5</property>
                        <property name="maxPoolSize">8</property>
                        <property name="checkoutTimeout">1000</property>
                    </named-config>
                </c3p0-config>
                + +

                可以注意到，xml文件里面可以保存多套配置，比如上面的示例代码就保存了两套配置，default-config和name=”otherc3p0”的config。

                +

                ComboPooledDataSource有一个含参构造器：

                +
                public ComboPooledDataSource(String configName) {
                    super(configName);
                }
                -

                具体实现

                构造器的参数

                参考文章

                -

                也是系统调用socket的参数，了解一下知识多多益善。

                -
                  -

                1. domain

                  -

                  在本次实验中只会取值前两个，即本地通信和IPv4网络通信

                  -

                  image-20230309232045195

                  -
                  2. -

                2. type

                  -

                  好像比如说取SOCK_DGRAM就是UDP，取SOCK_STREAM就是TCP。

                  -
                  3. -
                -
                代码
                /* Socket */
                /* 构造器 */
                // default constructor for socket of (subclassed) domain and type
                Socket::Socket(const int domain, const int type) : FileDescriptor(SystemCall("socket", socket(domain, type, 0))) {}
                // construct from file descriptor
                Socket::Socket(FileDescriptor &&fd, const int domain, const int type) : FileDescriptor(move(fd)) { ... }

                // get the local or peer address the socket is connected to
                // 此为private函数，应该是用于方便下面那两个函数的，虽然我觉得这个设计意图没什么必要（）
                Address Socket::get_address(const string &name_of_function,const function<int(int, sockaddr *, socklen_t *)> &function) const {
                    Address::Raw address;
                    socklen_t size = sizeof(address);
                	SystemCall(name_of_function, function(fd_num(), address, &size));
                    return {address, size};
                }
                Address Socket::local_address() const { return get_address("getsockname", getsockname); }
                Address Socket::peer_address() const { return get_address("getpeername", getpeername); }

                /* 
                这两个函数是用于把socket连到CS的
                将socket的一端连上本机，就需要调用bind；连上别的什么东西就要用connect
                */
                // bind socket to a specified local address (usually to listen/accept)
                // address is a local Address to bind
                void Socket::bind(const Address &address) { SystemCall("bind", ::bind(fd_num(), address, address.size())); }
                // connect socket to a specified peer address
                // address is the peer's Address
                void Socket::connect(const Address &address) { SystemCall("connect", ::connect(fd_num(), address, address.size())); }

                // shut down a socket in the specified way
                // how can be `SHUT_RD`, `SHUT_WR`, or `SHUT_RDWR`
                void Socket::shutdown(const int how) {
                    SystemCall("shutdown", ::shutdown(fd_num(), how));
                    switch (how) {
                        case SHUT_RD:
                            register_read();
                            break;
                        // ...
                    }
                }

                // set socket option，传入协议层以及要设置非选项的键和值
                template <typename option_type>
                void Socket::setsockopt(const int level, const int option, const option_type &option_value) {
                    SystemCall("setsockopt", ::setsockopt(fd_num(), level, option, &option_value, sizeof(option_value)));
                }

                // allow local address to be reused sooner, at the cost of some robustness
                // 以鲁棒性为代价，让local address可复用
                // Using `SO_REUSEADDR` may reduce the robustness of your application
                void Socket::set_reuseaddr() { setsockopt(SOL_SOCKET, SO_REUSEADDR, int(true)); }

                /* UDPSocket */
                // 从socket中接收数据并放进datagram中
                // If mtu is too small to hold the received datagram, this method throws a runtime_error
                void UDPSocket::recv(received_datagram &datagram, const size_t mtu) {
                    // receive source address and payload
                    // ...
                    const ssize_t recv_len = SystemCall(
                        "recvfrom",
                        ::recvfrom(
                            fd_num(), datagram.payload.data(), datagram.payload.size(), MSG_TRUNC, datagram_source_address, &fromlen));
                	// ...
                }
                UDPSocket::received_datagram UDPSocket::recv(const size_t mtu) {
                    received_datagram ret{{nullptr, 0}, ""};
                    recv(ret, mtu);
                    return ret;
                }

                // 向socket发送数据
                void sendmsg_helper(const int fd_num,
                                    const sockaddr *destination_address,
                                    const socklen_t destination_address_len,
                                    const BufferViewList &payload) {
                    // ...
                    const ssize_t bytes_sent = SystemCall("sendmsg", ::sendmsg(fd_num, &message, 0));
                	// ...
                }
                void UDPSocket::sendto(const Address &destination, const BufferViewList &payload) {
                    sendmsg_helper(fd_num(), destination, destination.size(), payload);
                    register_write();
                }
                void UDPSocket::send(const BufferViewList &payload) {
                    sendmsg_helper(fd_num(), nullptr, 0, payload);
                    register_write();
                }
                // ...
                +

                就可以传入config的名称指定要用的配置信息。

                +
                使用
                DataSource cpds = new ComboPooledDataSource();
                Connection conn = null;
                try{
                    conn = cpds.getConnection();
                	//正常使用......
                } catch(Exception e){
                    
                } finally{
                    if (conn != null){
                        try {
                            //正常使用关闭方法
                            conn.close();
                        } catch (SQLException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
                -

                * TCPSpongeSocket

                上面那俩类其实就是两个包装类，用来将系统调用包装为c++类，看起来很抽象很迷惑。但到这就不一样了！我们开始用上我们之前写的TCP协议的代码了！

                -

                除了跟fd以及socket一致的read、write以及close之外，TCPSocket最独特的功能，应该就是TCP连接的建立与释放了，其状态转移等逻辑已由我们在Lab0-4实现，此socket类仅实现事件的监听和TCP协议对象生命周期的管理。

                -

                双线程

                在详细说明其两个功能——事件监听和生命周期管理——之前，不妨先了解下其总体的架构。

                -

                TCPSpongeSocket需要双线程实现。其中一个线程用来招待其owner：它会执行向owner public的connect、read、write等服务。另一个线程用来运行TCPConnection：它会时刻调用connection的tick方法，并且进行事件监听。

                -
                //! \class TCPSpongeSocket
                //! This class involves the simultaneous operation of two threads.
                //!
                //! One, the "owner" or foreground thread, interacts with this class in much the
                //! same way as one would interact with a TCPSocket: it connects or listens, writes to
                //! and reads from a reliable data stream, etc. Only the owner thread calls public
                //! methods of this class.
                //!
                //! The other, the "TCPConnection" thread, takes care of the back-end tasks that the kernel would
                //! perform for a TCPSocket: reading and parsing datagrams from the wire, filtering out
                //! segments unrelated to the connection, etc.
                +

                Druid

                基本使用

                设置配置文件

                Druid的配置文件可以放在任意路径下，随便取名字。因为到时候需要指定配置文件。使用的是Properties文件。

                +
                driverClassName=com.mysql.jdbc.Driver
                url=jdbc:mysql://localhost:3306/helloworld
                username=root
                password=root
                initialSize=5
                maxActive=10
                maxWait=3000
                -

                事件监听

                完成事件监听的核心部分是方法_tcp_loop以及_initialize_TCP中对_eventloop的初始化，还有eventloop的实现。

                -

                看下来其实理解难度不大（虽然细节很多并且我懒得研究了），但我认为很值得学习。

                -
                _initialize_TCP

                主要功能是添加我们想监听的事件，有四个，分别是从app得到数据、有要向app发送的数据、从底层协议得到数据、有要向底层协议发送的数据。具体的话，代码和注释都写得很详细就不说了。

                -

                可以看到，TCP与协议栈交互【包括收发数据报】，是通过AdaptT _datagram_adapter;实现的；TCP与上层APP交互【包括传送数据】，是通过LocalStreamSocket _thread_data;实现的。

                -
                template <typename AdaptT>
                void TCPSpongeSocket<AdaptT>::_initialize_TCP(const TCPConfig &config) {
                    _tcp.emplace(config);
                    // Set up the event loop

                    // There are four possible events to handle:需要监听以下四种事件
                    //
                    // 1) Incoming datagram received (needs to be given to
                    //    TCPConnection::segment_received method)得到底层协议栈送过来的data
                    //
                    // 2) Outbound bytes received from local application via a write()
                    //    call (needs to be read from the local stream socket and
                    //    given to TCPConnection::data_written method)得到上层app送过来的data
                    //
                    // 3) Incoming bytes reassembled by the TCPConnection
                    //    (needs to be read from the inbound_stream and written
                    //    to the local stream socket back to the application)TCP协议需要向app写入data
                    //
                    // 4) Outbound segment generated by TCP (needs to be
                    //    given to underlying datagram socket)TCP需要向外界发送data

                    // rule 1: read from filtered packet stream and dump into TCPConnection得到外界data
                    _eventloop.add_rule(_datagram_adapter,
                                        Direction::In,
                                        [&] {
                                            auto seg = _datagram_adapter.read();
                                            if (seg) {
                                                _tcp->segment_received(move(seg.value()));
                                            }
                                            if (_thread_data.eof() and _tcp.value().bytes_in_flight() == 0 and not _fully_acked) { _fully_acked = true; }
                                        },
                                        [&] { return _tcp->active(); });

                    // rule 2: read from pipe into outbound buffer得到app data
                    _eventloop.add_rule(
                        // LocalStreamSocket _thread_data;
                		// 看来用户是通过socket写入的数据
                        _thread_data,
                        Direction::In,
                        [&] {
                            const auto data = _thread_data.read(_tcp->remaining_outbound_capacity());
                            const auto len = data.size();
                            const auto amount_written = _tcp->write(move(data));
                            if (amount_written != len) {
                                throw runtime_error("TCPConnection::write() accepted less than advertised length");
                            }
                            if (_thread_data.eof()) {
                                _tcp->end_input_stream();
                                _outbound_shutdown = true;
                            }
                        },
                        [&] { return (_tcp->active()) and (not _outbound_shutdown) and (_tcp->remaining_outbound_capacity() > 0); },
                        [&] {
                            _tcp->end_input_stream();
                            _outbound_shutdown = true;
                        });

                    // rule 3: read from inbound buffer into pipe向app写入data
                    _eventloop.add_rule(
                        _thread_data,
                        Direction::Out,
                        [&] {
                            ByteStream &inbound = _tcp->inbound_stream();
                            // Write from the inbound_stream into the pipe
                            const size_t amount_to_write = min(size_t(65536), inbound.buffer_size());
                            const std::string buffer = inbound.peek_output(amount_to_write);
                            // 通过向socket写实现
                            const auto bytes_written = _thread_data.write(move(buffer), false);
                            inbound.pop_output(bytes_written);

                            if (inbound.eof() or inbound.error()) {
                                _thread_data.shutdown(SHUT_WR);
                                _inbound_shutdown = true;
                            }
                        },
                        [&] {
                            return (not _tcp->inbound_stream().buffer_empty()) or
                                   ((_tcp->inbound_stream().eof() or _tcp->inbound_stream().error()) and not _inbound_shutdown);
                        });

                    // rule 4: read outbound segments from TCPConnection and send as datagrams向外界写data
                    _eventloop.add_rule(_datagram_adapter,
                                        Direction::Out,
                                        [&] {
                                            while (not _tcp->segments_out().empty()) {
                                                // 通过对adapter写实现
                                                _datagram_adapter.write(_tcp->segments_out().front());
                                                _tcp->segments_out().pop();
                                            }
                                        },
                                        [&] { return not _tcp->segments_out().empty(); });
                }
                +
                使用
                //导入配置文件
                Properties pro = new Properties();
                pro.load(Main.class.getClassLoader().getResourceAsStream("./druid.properties"));
                //使用工厂方法获取连接池对象
                DataSource cpds = DruidDataSourceFactory.createDataSource(pro);
                Connection conn = null;
                try{
                    conn = cpds.getConnection();
                	//正常使用......
                } catch(Exception e){
                    
                } finally{
                    if (conn != null){
                        try {
                            //正常使用关闭方法
                            conn.close();
                        } catch (SQLException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
                -
                _tcp_loop

                可以看到，_tcp_loop的功能就是，在condition为真的时候，一是监听我们之前塞进_event_loop的所有事件，二是调用TCPConnection的tick方法来管理时间。

                -
                // condition is a function returning true if loop should continue
                // Process events while specified condition is true
                // 周期性调用事件condition以达到监听等待事件的效果，管理TCP的tick
                template <typename AdaptT>
                void TCPSpongeSocket<AdaptT>::_tcp_loop(const function<bool()> &condition) {
                    auto base_time = timestamp_ms();
                    // 当条件一直为真时，监听event
                    while (condition()) {
                        // 持续监听eventloop中的各种event
                        auto ret = _eventloop.wait_next_event(TCP_TICK_MS);
                        // 条件为退出/丢弃
                        if (ret == EventLoop::Result::Exit or _abort) {
                            break;
                        }
                        // 如果tcp还存活，则调用其tick方法
                        if (_tcp.value().active()) {
                            const auto next_time = timestamp_ms();
                            _tcp.value().tick(next_time - base_time);
                            _datagram_adapter.tick(next_time - base_time);
                            base_time = next_time;
                        }
                    }
                }
                +

                定义工具类

                一般使用的时候还是会自定义一个工具类的

                +
                import com.alibaba.druid.pool.DruidDataSourceFactory;

                import javax.sql.DataSource;
                import java.sql.Connection;
                import java.sql.ResultSet;
                import java.sql.SQLException;
                import java.sql.Statement;
                import java.util.Properties;

                public class JDBCUtils {
                    private static DataSource ds;
                    static{
                        try {
                            Properties pro = new Properties();
                            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("./druid.properties"));
                            ds = DruidDataSourceFactory.createDataSource(pro);
                        } catch (Exception e) {
                            throw new RuntimeException(e);
                        }
                    }

                    public static Connection getConnection() throws SQLException {
                        return ds.getConnection();
                    }

                    public  static DataSource getDataSource(){
                        return ds;
                    }

                    //重载机制
                    public static void close(Connection conn){
                        close(conn,null,null);
                    }

                    public static void close(Connection conn, Statement stmt){
                        close(conn,stmt,null);
                    }

                    public static void close(Connection conn, Statement stmt, ResultSet resultSet){
                        if (resultSet != null){
                            try {
                                resultSet.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        if (stmt != null){
                            try {
                                stmt.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        if (conn !=null){
                            try {
                                conn.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                }
                -
                eventloop

                eventloop具体是通过Linux提供的poll机制来进行事件监听的。

                -
                -

                Linux poll机制

                -

                怎么说，又一次感受到了“网络就是IO”这个抽象的牛逼之处。操作系统的poll机制和poll函数本质上是针对IO读写来设计的，而正因为网络的本质是IO，正因为网络收发数据包、与上层app交互本质还是IO（因为通过文件描述符），才能在这里采用这种方式进行文件读写。

                -

                我的评价是佩服到五体投地好吧

                -

                image-20230310185319115

                -

                poll函数就是IO等待的一种实现机制。

                -
                int poll(struct pollfd *fds, nfds_t nfds, int timeout);
                +

                使用同上的JDBCUtils

                +

                Spring JDBC

                Spring框架对JDBC的简单封装，提供JDBCTemplate对象。

                +

                使用方法

                带参（PreparedStatement）

                jdbcTemplate.update("update usr set money = ? where uname = ?",10,"Mary");
                -

                事件类型events可以为下列值：

                -
                POLLIN:有数据可读
                POLLRDNORM:有普通数据可读，等效于POLLIN
                POLLRDBAND:有优先数据可读
                POLLPRI:有紧迫数据可读
                POLLOUT:写数据不会导致阻塞
                POLLWRNORM:写普通数据不会导致阻塞
                POLLWRBAND:写优先数据不会导致阻塞
                POLLMSG:SIGPOLL消息可用
                POLLER:指定的文件描述符发生错误
                POLLHUP:指定的文件描述符挂起事件
                POLLNVAL:无效的请求，打不开指定的文件描述符
                -
                -

                我们在前面的eventloop的rule初始化中：

                -
                _eventloop.add_rule(_datagram_adapter,
                                        Direction::In,
                                        [&] { ... });
                +

                DML

                update
                public static void main(String[] args) throws Exception {
                    JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
                    
                    //增
                    int count = jdbcTemplate.update("insert into usr values (null,'Jack',3000),(null,'LiMing',500000)");
                    System.out.println(count);
                    //删
                    int count2 = jdbcTemplate.update("delete from usr where uname = 'Jack'");
                    System.out.println(count2);
                    //改
                    int count3 = jdbcTemplate.update("update usr set money = ? where uname = ?",10,"Mary");
                    System.out.println(count3);
                }
                /*输出结果：
                2
                1
                1
                */
                -

                这个的意思是针对_datagram_adapter这个文件的Direction::In这个事件发生时，就会执行[&]中的事件。那么Direction::In是什么？

                -
                enum class Direction : short {
                    In = POLLIN,   //!< Callback will be triggered when Rule::fd is readable.
                    Out = POLLOUT  //!< Callback will be triggered when Rule::fd is writable.
                };
                +

                DQL

                提供了三种方法。

                +
                queryForMap

                将得到的结果（只能是一行）封装为一个Map<String,Object>，其中key为列名，value为该行该列的值。

                +

                如果得到的结果不为1行（=0 or >1），会抛出异常。

                +
                    JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());

                    Map<String,Object> m = jdbcTemplate.queryForMap("select * from usr where id = 2");
                    System.out.println(m);
                //输出：{id=2, uname=Lily, money=2000}
                -

                可见，eventloop具体是通过os提供的IO事件机制来进行监听的。

                -

                具体的监听以及执行逻辑由wait_next_event来实现。它主要干的就是，清理掉那些我们不感兴趣的或者已经似了（比如说对应的fd已经close之类的）的事件，然后找到那些触发到了的active的事件并且调用它们的caller。

                -

                具体代码还是有些微复杂的，有兴趣可以去看看，这里就不放了。

                -

                生命周期的管理

                核心部分为方法connect、listen_and_accept以及_tcp_main。

                -
                connect

                由客户端调用。

                -
                // Client调用
                // 未收到外界连接时，owner进程会阻塞
                template <typename AdaptT>
                void TCPSpongeSocket<AdaptT>::connect(const TCPConfig &c_tcp, const FdAdapterConfig &c_ad) {
                    // 初始化tcp的事件监听
                    _initialize_TCP(c_tcp);
                    // 初始化adapater
                    _datagram_adapter.config_mut() = c_ad;

                    cerr << "DEBUG: Connecting to " << c_ad.destination.to_string() << "...\n";
                    // 我们实现的：发送SYN报文
                    _tcp->connect();

                    // 统一的状态管理
                    const TCPState expected_state = TCPState::State::SYN_SENT;
                    // 等待直到条件为假，也即脱离SYN-SENT转移到ESTABLISHED
                    _tcp_loop([&] { return _tcp->state() == TCPState::State::SYN_SENT; });
                    cerr << "Successfully connected to " << c_ad.destination.to_string() << ".\n";

                    // 建立连接后开启connection进程, 执行_tcp_main，继续监听event直到死亡
                    _tcp_thread = thread(&TCPSpongeSocket::_tcp_main, this);
                }
                +
                queryForList

                将得到的结果封装为List<Map<String,Object>>，其中一个Map为一行，多个Map表示多行，存储在List中。

                +
                    List<Map<String, Object>> res = jdbcTemplate.queryForList("select * from usr");
                    for (Map<String,Object> m : res){
                        System.out.println(m.hashCode());
                        System.out.println(m.keySet().toString());
                        System.out.println(m.values().toString());
                    }
                /*输出结果：
                213151839
                [id, uname, money]
                [1, Mary, 10]
                213143443
                [id, uname, money]
                [2, Lily, 2000]
                -2022948335
                [id, uname, money]
                [4, LiMing, 500000]
                */
                -
                _tcp_main

                负责establish状态的监听以及之后关闭TCP连接的擦屁股工作

                -
                template <typename AdaptT>
                void TCPSpongeSocket<AdaptT>::_tcp_main() {
                    try {
                        if (not _tcp.has_value()) {
                            throw runtime_error("no TCP");
                        }
                        // 持续监听直到死亡
                        _tcp_loop([] { return true; });
                        shutdown(SHUT_RDWR);
                        if (not _tcp.value().active()) {
                            cerr << "DEBUG: TCP connection finished "
                                 << (_tcp.value().state() == TCPState::State::RESET ? "uncleanly" : "cleanly.\n");
                        }
                        _tcp.reset();
                    } catch (const exception &e) {
                        cerr << "Exception in TCPConnection runner thread: " << e.what() << "\n";
                        throw e;
                    }
                }
                +
                query

                可以把查询回的结果封装为自己想要的对象而不是Map。如示例就封装为了Client对象。

                +
                原始一点的

                可以看到，里面的包装内容还是得自己写，有点麻烦。

                +
                        JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());

                        List<Client> clients = jdbcTemplate.query(
                            "select * from usr where money > 1000", 
                            new RowMapper<Client>() {
                            @Override
                            public Client mapRow(ResultSet resultSet, int i) throws SQLException {
                                return new Client(
                                    resultSet.getInt(1),
                                    resultSet.getString(2),
                                    resultSet.getInt(3));
                            }
                        });
                        System.out.println(clients.toString());
                /*输出结果
                [Client{id=2, name='Lily', money=2000}, Client{id=4, name='LiMing', money=500000}, Client{id=6, name='LiMing', money=500000}]
                */
                -
                listen_and_accept

                由服务器端调用。

                -
                // Server调用
                // 未收到外界连接时，owner进程会阻塞
                template <typename AdaptT>
                void TCPSpongeSocket<AdaptT>::listen_and_accept(const TCPConfig &c_tcp, const FdAdapterConfig &c_ad) {
                     _initialize_TCP(c_tcp);
                    _datagram_adapter.config_mut() = c_ad;
                    
                    _datagram_adapter.set_listening(true);

                    cerr << "DEBUG: Listening for incoming connection...\n";
                    // 等待直到ESTABLISHED。注意下这里的状态条件
                    // 其中各种收发报文的事件由tcp_loop中的event做
                    _tcp_loop([&] {
                        const auto s = _tcp->state();
                        return (s == TCPState::State::LISTEN or s == TCPState::State::SYN_RCVD or s == TCPState::State::SYN_SENT);
                    });
                    cerr << "New connection from " << _datagram_adapter.config().destination.to_string() << ".\n";

                    // 开启connection进程
                    _tcp_thread = thread(&TCPSpongeSocket::_tcp_main, this);
                }
                +
                常用的

                使用包装好的BeanPropertyRowMapper类。

                +
                        JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());

                        List<Client> clients = jdbcTemplate.query("select * from usr where money > 1000",
                                new BeanPropertyRowMapper<Client>(Client.class));
                        System.out.println(clients.toString());
                /*输出结果：
                [Client{id=2, uname='Lily', money=2000}, Client{id=4, uname='LiMing', money=500000}, Client{id=6, uname='LiMing', money=500000}]
                */
                -

                CS144TCPSocket 和 FullStackSocket

                主菜（上面那个）已经说完了，这两个就是简单的包装类，没什么好说的，大概就做了点传参工作，主要差异还是adapter。

                -

                Adapter实现

                在我们的TCPSpongeSocket实现中，我们引入了“adapter”的概念。

                -
                  protected:
                    //! Adapter to underlying datagram socket (e.g., UDP or IP)
                    AdaptT _datagram_adapter;

                using TCPOverUDPSpongeSocket = TCPSpongeSocket<TCPOverUDPSocketAdapter>;
                using TCPOverIPv4SpongeSocket = TCPSpongeSocket<TCPOverIPv4OverTunFdAdapter>;
                using TCPOverIPv4OverEthernetSpongeSocket = TCPSpongeSocket<TCPOverIPv4OverEthernetAdapter>;

                using LossyTCPOverUDPSpongeSocket = TCPSpongeSocket<LossyTCPOverUDPSocketAdapter>;
                using LossyTCPOverIPv4SpongeSocket = TCPSpongeSocket<LossyTCPOverIPv4OverTunFdAdapter>;
                +

                注意：

                +
                  +
                1. 要求包装的class，比如说Client，必须要有public的无参构造器。
                  2. +
                2. Java的那个被包装类的字段最好不使用基本数据类型，而使用引用类型，如Integer，Double等等等。因为如果使用基本数据类型，当表中数据为null时会报错。
                  3. +
                3. 要求被包装的class的字段名称一定要与数据库的一模一样，大小写可以不一样。
                  4. +
                4. 要求被包装的class的字段一定要是可以修改的。也就是说，要么public，要么提供set方法。
                  5. +
                +
                queryForObject

                返回查到的某个东西。可以用于聚合函数的查询。

                +
                int money = jdbcTemplate.queryForObject("select money from usr where uname = 'Mary'",Integer.class);
                System.out.println(money);
                -

                它很完美地以策略模式的形式，凝结出了我们本次实验所需的各种协议栈的共同代码，放进了TCPSpongeSocket，而将涉及到协议栈差异的部分用adapter完成。

                -

                在TCPSpongeSocket中，adapter主要完成了如下操作：

                +

                第三部分 Web概述和静态网页技术

                Web概述

                  +

                • JavaWeb：

                  +
                    +
                  • 使用Java语言开发基于互联网的项目
                    • +
                  +
                  • +

                • 软件架构：

                    -

                  1. adapter的tick函数

                    -
                    // in tcp_loop
                    _tcp.value().tick(next_time - base_time);
                    _datagram_adapter.tick(next_time - base_time);
                    2. -

                  2. 作为订阅事件的IO流

                    -
                    _eventloop.add_rule(_datagram_adapter,
                                            Direction::In,
                                            [&] {
                    	// ...
                    3. -

                  3. TCP层通过对其读写来获取TCP segment

                    -
                    auto seg = _datagram_adapter.read();
                    _datagram_adapter.write(_tcp->segments_out().front());
                    4. -

                  4. 记录各类参数

                    -
                    datagram_adapter.config().destination.to_string()
                    5. +
                  5. C/S: Client/Server 客户端/服务器端
                      +
                    • 在用户本地有一个客户端程序，在远程有一个服务器端程序
                      • +
                    • 如：QQ，迅雷…
                      • +
                    • 优点：
                        +
                      1. 用户体验好
                      -

                      Inheritance graph

                      -

                      具体实现说实话没什么好说的，确实无非也就是上面那几个方法，然后在里面包装下和操作系统提供的tun和tap的接口交互罢了，代码也比较简单，此处就不说了。

                      -

                      apps

                      除了对协议栈的实现之外，在app文件夹下还有许多对我们实现的协议栈的应用实例。我认为了解下应用实例也是很重要的。

                      -

                      bidirectional_stream_copy

                      其作用就是建立stdin/stdout与socket的关联。它从stdin读输入，作为上层app的输入写入socket；从socket读输出，传给上层app，也即stdout输出。它的具体实现在stdin/stdout之间隔了两条bytestream，分别是_inbound和_outbound。

                      -

                      由于stdin、stdout、socket本质上都是fd，所以我们依然可以采用跟上面一样的事件驱动方式。我们只需在socket有输出时马上读给inbound bytestream，在inbound bytestream有输入时马上读给stdout，在stdin有输入时马上写入outbound bytestream，在outbound bytestream有输入时马上读给socket。遵守这4条rule就行了。

                      -

                      因而，具体实现就是TCPSpongeSocket::_initialize_TCP和TCPSpongeSocket::_tcp_loop的结合体，订阅事件+循环等待。由于跟前面类似，在此就不放代码了。

                      -

                      其他

                      其他都太复杂了，感觉我水平一般还不大能理解，也懒得看了【草】总之先咕咕咕

                      -]]> - - - JavaWeb - /2022/12/21/JavaWeb/ - 第一部分 Java基础

                      JUnit单元测试

                      JUnit是白盒测试。

                      -

                      简要使用步骤

                      定义测试类

                      包含各种测试用例。

                      -

                      一般放在包名xxx.xxx.xx.test里，类名为“被测试类名Test”。

                      -

                      定义测试方法

                      测试方法可以独立运行。

                      -

                      方法名一般为“test测试的方法”，void，空参。

                      -

                      给方法加@Test标签

                      加入JUnit依赖包

                      具体细节

                      断言

                      Assert.assertEquals(3,result);
                      +
                      • +
                    • 缺点：
                        +
                      1. 开发、安装，部署，维护 麻烦
                        2. +
                      +
                      • +
                    +
                    6. +
                  6. B/S: Browser/Server 浏览器/服务器端
                      +
                    • 只需要一个浏览器，用户通过不同的网址(URL)，客户访问不同的服务器端程序
                      • +
                    • 优点：
                        +
                      1. 开发、安装，部署，维护 简单
                        2. +
                      +
                      • +
                    • 缺点：
                        +
                      1. 如果应用过大，用户的体验可能会受到影响
                        2. +
                      2. 对硬件要求过高
                        3. +
                      +
                      • +
                    +
                    7. +
                  +
                  • +

                • B/S架构详解

                  +
                    +

                  • 资源分类：

                    +
                      +
                    1. 静态资源：
                        +
                      • 使用静态网页开发技术发布的资源。
                        • +
                      • 特点：
                          +
                        • 所有用户访问，得到的结果是一样的。
                          • +
                        • 如：文本，图片，音频、视频, HTML,CSS,JavaScript
                          • +
                        • 如果用户请求的是静态资源，那么服务器会直接将静态资源发送给浏览器。浏览器中内置了静态资源的解析引擎，可以展示静态资源
                          • +
                        +
                        • +
                      +
                      2. +
                    2. 动态资源：
                        +
                      • 使用动态网页及时发布的资源。
                        • +
                      • 特点：
                          +
                        • 所有用户访问，得到的结果可能不一样。
                          • +
                        • 如：jsp/servlet,php,asp…
                          • +
                        • 如果用户请求的是动态资源，那么服务器会执行动态资源，转换为静态资源，再发送给浏览器
                          • +
                        +
                        • +
                      +
                      3. +
                    +
                    • +

                  • 我们要学习动态资源，必须先学习静态资源！

                    +
                    • +

                  • 静态资源：

                    +
                      +
                    • HTML：用于搭建基础网页，展示页面的内容
                      • +
                    • CSS：用于美化页面，布局页面
                      • +
                    • JavaScript：控制页面的元素，让页面有一些动态的效果
                      • +
                    +
                    • +
                  +
                  • +
                +

                静态网页概述

                练习：用纯HTML写旅游网站首页

                代码

                <!DOCTYPE html>
                <html lang="ch">
                <head>
                    <meta charset="UTF-8">
                    <title>旅游网站</title>
                </head>
                <body>
                    <table>
                        <tr align="center">
                            <td><img src="./image/top_banner.jpg" alt="亲子周边旅游节" width="100%"></td>
                        </tr>
                        <tr>
                            <table>
                                <tr align="center">
                                    <td width="25%"><img src="./image/logo.jpg" alt="logo" width="100%"></td>
                                    <td width="50%"><img src="./image/search.png" alt="search" width="100%"></td>
                                    <td width="25%"><img src="./image/hotel_tel.png" alt="hotel" width="100%"></td>
                                </tr>
                            </table>
                        </tr>
                        <tr>
                            <table width="100%" bgcolor="orange" cellspacing="0" cellpadding="0">
                                <tr align="center" height = "45">
                                    <td>首页</td>
                                    <td>门票</td>
                                    <td>酒店</td>
                                    <td>香港车票</td>
                                    <td>出境游</td>
                                    <td>国内游</td>
                                    <td>港澳游</td>
                                    <td>抱团定制</td>
                                    <td>全球自由行</td>
                                    <td>收藏排行榜</td>
                                </tr>
                            </table>
                        </tr>
                        <tr>
                            <img src="./image/banner_3.jpg" alt="亲子周边旅游节" width="100%">
                        </tr>
                        <tr>
                            <table>
                                <tr>
                                    <td align="right" width="20%"><img src="./image/icon_5.jpg" alt="亲子周边旅游节" width="100%"></td>
                                    <td width="80%">黑马精选</td>
                                </tr>
                            </table>
                            <hr color="orange">
                        </tr>
                        <tr>
                            <table>
                                <tr>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_1.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_1.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_1.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                </tr>
                            </table>
                        </tr>
                        <tr>
                            <table>
                                <tr>
                                    <td align="right" width="20%"><img src="./image/icon_6.jpg" alt="亲子周边旅游节" width="100%"></td>
                                    <td width="80%">国内游</td>
                                </tr>
                            </table>
                            <hr color="orange">
                        </tr>
                        <tr>
                            <table align="center" width="95%">
                                <tr>
                                    <td rowspan="2" width = "25%">
                                        <img src="./image/guonei_1.jpg" alt="亲子周边旅游节">
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                </tr>
                            </table>
                        </tr>
                        <tr>
                            <table>
                                <tr>
                                    <td align="right" width="20%"><img src="./image/icon_7.jpg" alt="亲子周边旅游节" width="100%"></td>
                                    <td width="80%">境外游</td>
                                </tr>
                            </table>
                            <hr color="orange">
                        </tr>
                        <tr>
                            <table align="center" width="95%">
                                <tr>
                                    <td rowspan="2" width = "25%">
                                        <img src="./image/jiangwai_1.jpg" alt="亲子周边旅游节">
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                    <td>
                                        <div>
                                            <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                        </div>
                                    </td>
                                </tr>
                            </table>
                        </tr>
                        <tr>
                            <img src="./image/footer_service.png" alt="" width="100%">
                        </tr>
                        <tr>
                            <table bgcolor="orange" width="100%" height = 75>
                                <tr align="center">
                                    <td>
                                        <font color="gray" size = 2>江苏传智播客教育科技股份有限公司 版权所有Copyright 2006-2018&copy;, All Rights Reserved 苏ICP备16007882</font>
                                    </td>
                                </tr>
                            </table>
                        </tr>
                    </table>
                </body>
                </html>
                -

                @Before @After

                @Before在所有测试方法执行前自动执行，常用于资源申请。

                -

                @After在所有测试方法执行完后自动执行，常用于释放资源。

                -

                反射

                反射是框架设计的灵魂。

                -

                Java对象创建的三个阶段

                image-20221205194807395

                -

                类加载器把硬盘中的字节流文件装载进内存，并且翻译封装为Class类对象。通过Class类对象才能创建Person对象。

                -

                而这也就是说，如果我们有了Class对象，我们就可以创建该类对象。

                -

                获取Class对象

                有三种方式。

                -

                Class.forName(“类的全名”)

                将字节码文件加载进内存，返回class对象。多用于配置文件【将类名定义在配置文件】

                -

                注意：类的全名指的是包.类，包含包名。

                -

                类型.class

                通过类名的属性class获取。多用于参数传递。

                -

                对象.getClass()

                getClass()是Object类的方法。多用于对象的获取字节码的方式。

                -
                //第一种方式
                Class class1 = Class.forName("Student");
                System.out.println(class1);
                //第二种方式
                Class class2 = Student.class;
                System.out.println(class2);
                //第三种方式
                Student stu = new Student();
                Class class3 = stu.getClass();
                System.out.println(class3);

                System.out.println((class1==class2)+"  "+(class2==class3));

                /*输出
                class Student
                class Student
                class Student
                true  true*/
                +

                注意点

                  +

                1. 布局

                  +

                  页面布局使用table标签。这点让我感觉非常新奇。

                  +

                  而且表格布局可以嵌套，也即每一行可以是一个新的表格。

                  +
                  2. +

                2. 图片适应屏幕宽度

                  +

                  只需在img标签加个width=”100%”的属性即可。如：

                  +
                  <img src="./image/top_banner.jpg" width="100%">
                  3. +
                +

                表单

                注意

                  +

                1. 表项中的数据要被提交的话，必须指定其名称

                  +

                  image-20221223161847622

                  +

                  也即一定要有属性name。

                  +
                  2. +

                2. 关于from的属性

                  +

                  image-20221223162035569

                  +
                  3. +

                3. 一般都这么写

                  +

                  image-20221223165046277

                  +
                  4. +
                +

                练习

                image-20221223171603366

                +
                <!DOCTYPE html>
                <html lang="ch">
                <head>
                    <meta charset="UTF-8">
                    <title>注册界面</title>
                </head>
                <body>
                    <form action="#">
                        <table border="1" cellpadding="1" cellspacing="1">
                            <tr>
                                <td>
                                    <label for="username">用户名:</label>
                                </td>
                                <td>
                                    <input type="text" id="username" name="username" placeholder="请输入用户名">
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <label for="password">密码：</label>
                                </td>
                                <td>
                                    <input type="password" id="password" name="password" placeholder="请输入密码">
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <label for="email">邮箱：</label>
                                </td>
                                <td>
                                    <input type="email" id="email" name="email" placeholder="请输入邮箱">
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <label for="name">姓名：</label>
                                </td>
                                <td>
                                    <input type="text" id="name" name="name" placeholder="请输入姓名">
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <label for="phone_number">手机号：</label>
                                </td>
                                <td>
                                    <input type="text" id="phone_number" name="phone_number" placeholder="请输入手机号">
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    性别：
                                </td>
                                <td>
                                    <input type="radio" name="gender" value="1">女
                                    <input type="radio" name="gender" value="2">男
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <label for="birthday">出生日期：</label>
                                </td>
                                <td>
                                    <input type="date" name="birthday" id="birthday">
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <label for="certification">验证码：</label>
                                </td>
                                <td>
                                    <input type="text" name="certification" id="certification">
                                    <img src="./image/verify_code.jpg" >
                                </td>
                            </tr>
                            <tr align="center">
                                <td colspan="2">
                                    <input type="image" src="./image/regbtn.jpg">
                                </td>
                            </tr>
                        </table>
                    </form>

                </body>
                </html>
                -

                同一个字节码文件（*.class）在一次程序运行过程中只会被加载一次，不管是以哪种方式得到的Class对象，都是同一个。

                -

                使用Class对象

                可以通过class对象得到其字段、构造方法、方法等。

                -
                class Student{
                    public String name;
                    int birthday;
                    protected int money;
                    private double weight;

                    private Student() {

                    }
                    public Student(String name, int birthday, int money, double weight) {
                        this.name = name;
                        this.birthday = birthday;
                        this.money = money;
                        this.weight = weight;
                    }

                    @Override
                    public String toString() {
                        return "Student{" +
                                "name='" + name + '\'' +
                                ", birthday=" + birthday +
                                ", money=" + money +
                                ", weight=" + weight +
                                '}';
                    }

                    public static void haha(){
                        System.out.println("haha");
                    }
                    public void hello(){
                        System.out.println("hello");
                    }
                    public void hello(String name){
                        System.out.println("hello,"+name+"!");
                    }
                    private void giveMoney(){
                        System.out.println("my money is yours...");
                        money = 0;
                    }
                }
                +

                CSS

                盒子模型

                盒

                image-20221223204733649

                +

                练习：注册页面

                image-20221223223128861

                +
                <!DOCTYPE html>
                <html lang="ch">
                <head>
                    <meta charset="UTF-8">
                    <title>注册界面</title>
                    <link rel="stylesheet" href="./2.css">
                </head>
                <body>
                <div id="log_in_box">
                    <div id="log_in_text">
                        <div id="log_in_text1">
                            新用户注册
                        </div>
                        <div id="log_in_text2">
                            USER REGISTER
                        </div>
                    </div>

                    <div id="log_in_text3">
                        已有账号？<font color = red>立即登录</font>
                    </div>
                    <div id="log_in_table">
                        <form>
                            <table>
                                <tr>
                                    <td class="td_left"><label for="username">用户名</label></td>
                                    <td class="td_right"><input type="text" name="username" id="username" placeholder="请输入用户名"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="password">密码</label></td>
                                    <td class="td_right"><input type="password" name="password" id="password" placeholder="请输入密码"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="email">Email</label></td>
                                    <td class="td_right"><input type="email" name="email" id="email" placeholder="请输入邮箱"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="name">姓名</label></td>
                                    <td class="td_right"><input type="text" name="name" id="name" placeholder="请输入姓名"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="tel">手机号</label></td>
                                    <td class="td_right"><input type="text" name="tel" id="tel" placeholder="请输入手机号"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label>性别</label></td>
                                    <td class="td_right">
                                        <input type="radio" name="gender" value="male"> <span class="choice">男</span>
                                        <input type="radio" name="gender" value="female"> <span class="choice">女</span>
                                    </td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="birthday">出生日期</label></td>
                                    <td class="td_right"><input type="date" name="birthday" id="birthday" placeholder="请输入出生日期"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="checkcode" >验证码</label></td>
                                    <td class="td_right"><input type="text" name="checkcode" id="checkcode" placeholder="请输入验证码">
                                        <img id="img_check" src="img/verify_code.jpg">
                                    </td>
                                </tr>


                                <tr>
                                    <td colspan="2" align="center"><input type="submit" value="注册" id="submit"></td>
                                </tr>
                            </table>
                        </form>
                    </div>
                </div>
                </body>
                </html>
                + +
                *{
                    margin: 0px;
                    padding: 0px;
                    /*防止大小因padding变化*/
                    box-sizing: border-box;
                }
                body{
                    z-index: 0;
                    background-image: url("./img/login_bg.png");
                }
                #log_in_box {
                    border: 9px solid darkgray;
                    z-index: 100;
                    width: 987px;
                    height: 590px;
                    /*让div水平居中*/
                    margin: auto;
                    margin-top: 20px;
                    padding: 15px;
                    background: white;

                }

                #log_in_table {
                    margin-top: 96px;
                    margin-left: 300px;
                }

                #log_in_text3{
                    font-size: 12px;
                    float: right;
                }

                #log_in_text > div:first-child{
                    margin-right: 0px;
                    width: 150px;
                    color: orange;
                    font-size: 25px;
                }
                #log_in_text > div:last-child{
                    margin-right: 0px;
                    width: 200px;
                    color: darkgray;
                    font-size: 17px;
                    font-family: "Arial Black";
                }

                #log_in_text{
                    margin: 0px;
                    display:inline;
                    float: left;
                }

                /*此处一定得是选择input，不能是选择.td_right，因为这样才能覆盖掉input原有的那个丑边框*/
                input {
                    padding: 5px;
                    align-self: center;
                    border: 1px solid lightgrey;
                    height: 35px;
                    border-radius: 6px;
                    margin: 3px;
                    margin-left: 15px;
                    /*解决了radio的选框和文本不对齐。*/
                    vertical-align: middle;
                }

                .td_left{
                    color: slategrey;
                    text-align: right;
                }

                .choice{
                    font-size: 15px;
                }

                #checkcode{
                    width: 100px;
                    font-size: 15px;
                }

                #img_check{
                    vertical-align:middle;
                }

                #submit{
                    margin-top: 15px;
                    margin-left: 15px;
                    margin-right: 155px;
                    color: transparent;
                    width: 100px;
                    background-image: url("./img/regbtn.jpg");
                }
                + +

                JavaScript

                对象

                function
                1. 创建：
+   1. var fun = new Function(形式参数列表,方法体);  //忘掉吧
+   2. function 方法名称(形式参数列表){
+          方法体
+      }
+
+   3. var 方法名 = function(形式参数列表){
+           方法体
+      }
+2. 方法：
+
+3. 属性：
+   length:代表形参的个数
+4. 特点：
+   1. 方法定义是，形参的类型不用写,返回值类型也不写。
+   2. 方法是一个对象，如果定义名称相同的方法，会覆盖
+   3. 在JS中，方法的调用只与方法的名称有关，和参数列表无关
+   4. 在方法声明中有一个隐藏的内置对象（数组），**arguments**,封装所有的实际参数
+5. 调用：
+   方法名称(实际参数列表);
+
                +
                /**
                * 求任意个数的和
                */
                function add (){
                    var sum = 0;
                    for (var i = 0; i < arguments.length; i++) {
                        sum += arguments[i];
                    }
                    return sum;
                }

                var sum = add(1,2,3,4);
                alert(sum);
                + +
                Global
                  +

                1. 特点：全局对象，这个Global中封装的方法不需要对象就可以直接调用。 方法名();

                  +
                  2. +

                2. 方法：
                  encodeURI():url编码
                  decodeURI():url解码

                  +

                  encodeURIComponent():url编码,编码的字符更多
                  decodeURIComponent():url解码

                  +

                  parseInt():将字符串转为数字

                  +
                    +
                  • 逐一判断每一个字符是否是数字，直到不是数字为止，将前边数字部分转为number
                    isNaN():判断一个值是否是NaN
                      +
                    • NaN六亲不认，连自己都不认。NaN参与的==比较全部问false
                      • +
                    +
                    • +
                  +

                  eval():讲 JavaScript 字符串，并把它作为脚本代码来执行。

                  +
                  var str = "http://www.baidu.com?wd=传智播客";
                  var encode = encodeURI(str);
                  document.write(encode +"<br>");//%E4%BC%A0%E6%99%BA%E6%92%AD%E5%AE%A2
                  var s = decodeURI(encode);
                  document.write(s +"<br>");//传智播客


                  var str1 = "http://www.baidu.com?wd=传智播客";
                  var encode1 = encodeURIComponent(str1);
                  document.write(encode1 +"<br>");//%E4%BC%A0%E6%99%BA%E6%92%AD%E5%AE%A2
                  var s1 = decodeURIComponent(encode);
                  document.write(s1 +"<br>");//传智播客

                  var jscode = "alert(123)";
                  eval(jscode);
                  3. +
                +

                DOM

                image-20221224162341993

                +

                image-20221224162540306

                +
                document
                获取元素对象
                getElementById();
                getElementsByTagName();//通过标签名
                getElementsByClassName();
                getElementsByName();//注意是数组
                -
                Student stu = new Student("张三",321,1000,57.7);
                Class stuC = stu.getClass();
                +
                创建DOM对象
                createAttribute(name);
                createComment();
                createElement();
                createTextNode();
                -

                字段

                获取字段

                常用方法：

                -
                //获取所有公有字段
                Field[] fs = stuC.getFields();
                //获取某个公有字段
                Filed f = stuC.getField("name");
                //获取所有字段
                Field[] fs = stuC.getDeclaredFields();
                //获取某个字段
                Filed f = stuC.getDeclaredField("name");
                /*输出
                public java.lang.String Student.name

                public java.lang.String Student.name

                public java.lang.String Student.name
                int Student.birthday
                protected int Student.money
                private double Student.weight*/
                +
                Element
                removeAttribute();
                setAttribute(属性名,属性值);
                -
                使用字段
                Field f = stuC.getDeclaredField("money");
                //由于money protected，故应该先设置其为可访问，否则会抛出异常。
                //这是暴力反射，不推荐。
                f.setAccessible(true);
                //获取成员变量的值
                //注意此处是要用field.get(该类型对象)的。想想也有道理，Filed字段是属于Class对象的，因而你想获取某个对象的值当然得传入该对象。
                System.out.println(f.get(stu));
                //设置对象的值
                f.set(stu,0);
                System.out.println(stu);
                /* Student{name='张三', birthday=321, money=0, weight=57.7}  */
                +
                Node

                说了树结构后，这个就好理解多了。

                +

                image-20221224164239507

                +
                练习：动态表格
                <!DOCTYPE html>
                <html lang="ch">
                <head>
                    <meta charset="UTF-8">
                    <title>动态表格</title>
                    <style>
                        #input{
                            width: 60%;
                            margin: auto;
                            margin-top: 50px;
                        }
                        table{
                            margin: auto;
                            margin-top: 100px;
                            width: 70%;
                            text-align: center;
                        }
                    </style>
                </head>
                <body>
                    <div id="input">
                        <input type="text" placeholder="请输入编号"  id="id">
                        <input type="text" placeholder="请输入姓名" id="name">
                        <input type="text" placeholder="请输入性别" id="gender">
                        <input type="button" id="add_but" value="添加">
                    </div>
                    <table border="1px solid black"  id="table">
                        <tr>
                            <title>学生信息表</title>
                            <td>编号</td>
                            <td>姓名</td>
                            <td>性别</td>
                            <td>操作</td>
                        </tr>
                    </table>
                    <script>
                        //获取表对象
                        let table = document.getElementById("table");

                        //最后那列删除要用很多次，所以这里只写一份原始的，之后要用再copy del_col对象即可。
                        //但是要注意，js的深拷贝 object.cloneNode(true)是不会拷贝事件绑定的
                        //所以事件绑定不得不放在下面的函数里做了
                        let del_col = document.createElement("td");
                        let del_col_a = document.createElement("a");
                        del_col_a.href="javascript:void(0);";
                        del_col_a.innerHTML="删除";
                        del_col.appendChild(del_col_a);

                        //删除列
                        function del_row(obj){
                            let target = obj.parentNode.parentNode;
                            table.removeChild(target);
                        }
                        //添加行
                        function add_row(id,name,gender){
                            if (id=="" || name=="" || gender=="") return;
                            let row = document.createElement("tr");
                            let col1 = document.createElement("td");
                            let col2 = document.createElement("td");
                            let col3 = document.createElement("td");
                            col1.innerHTML = id;
                            col2.innerHTML = name;
                            col3.innerHTML = gender;

                            //为“删除”绑定事件
                            let col4 = del_col.cloneNode(true);
                            col4.lastChild.onclick = function(){
                                //通过this定位。此时this指代a标签。
                                //如果在del_row内把obj换成this反倒是不行的，因为那时候的this会指代的是window
                                del_row(this);
                            };

                            row.appendChild(col1);
                            row.appendChild(col2);
                            row.appendChild(col3);
                            row.appendChild(col4);

                            table.appendChild(row);
                        }

                        //为“添加”按钮绑定事件
                        document.getElementById("add_but").onclick = function(){
                            add_row(document.getElementById("id").value,
                                document.getElementById("name").value,
                                document.getElementById("gender").value);
                        };
                    </script>
                </body>
                </html>
                -

                构造方法

                获取方法跟上面格式差不多。

                -
                //获取构造方法
                //获取无参私有构造方法
                Constructor cons = stuC.getDeclaredConstructor();
                cons.setAccessible(true);
                System.out.println(cons.newInstance());
                //获取有参构造方法
                Constructor cons2 = stuC.getConstructor(String.class,int.class,int.class,double.class);
                System.out.println(cons2.newInstance("李四",102,100,90.9));
                /*输出
                Student{name='null', birthday=0, money=0, weight=0.0}
                Student{name='李四', birthday=102, money=100, weight=90.9}*/
                +

                老师标答值得学习借鉴的点：

                +
                //使用innerHTML添加
                document.getElementById("btn_add").onclick = function() {
                    //2.获取文本框的内容
                    var id = document.getElementById("id").value;
                    var name = document.getElementById("name").value;
                    var gender = document.getElementById("gender").value;

                    //获取table
                    var table = document.getElementsByTagName("table")[0];

                    //追加一行
                    table.innerHTML += "<tr>\n" +
                        "        <td>"+id+"</td>\n" +
                        "        <td>"+name+"</td>\n" +
                        "        <td>"+gender+"</td>\n" +
                        "        <td><a href=\"javascript:void(0);\" onclick=\"delTr(this);\" >删除</a></td>\n" +
                        "    </tr>";
                }
                -

                如果想要获取公有的无参构造器，还可以使用Class类提供的更简单的方法，不用先创造构造器：

                -
                System.out.println(stuC.newInstance());
                +
                事件
                练习：全选/全不选/反选+行变色

                image-20221225192124809

                +
                <!DOCTYPE html>
                <html lang="ch">
                <head>
                    <meta charset="UTF-8">
                    <title>动态表格</title>
                    <style>
                        #input{
                            width: 60%;
                            margin: auto;
                            margin-top: 50px;
                        }
                        table{
                            margin: auto;
                            margin-top: 100px;
                            width: 70%;
                            text-align: center;
                        }
                    </style>
                </head>
                <body>
                <div id="input">
                    <input type="text" placeholder="请输入编号"  id="id">
                    <input type="text" placeholder="请输入姓名" id="name">
                    <input type="text" placeholder="请输入性别" id="gender">
                    <input type="button" id="add_but" value="添加">
                </div>
                <table border="1px solid black"  id="table">
                    <tr>
                        <td>选择</td>
                        <td>编号</td>
                        <td>姓名</td>
                        <td>性别</td>
                        <td>操作</td>
                    </tr>
                    <tr>
                        <td><input type="checkbox" class="box"></td>
                        <td>1</td>
                        <td>Lily</td>
                        <td>female</td>
                        <td><a href="#" >删除</a></td>
                    </tr>
                    <tr>
                        <td><input type="checkbox" class="box"></td>
                        <td>2</td>
                        <td>Jack</td>
                        <td>male</td>
                        <td><a href="#" >删除</a></td>
                    </tr>
                    <tr>
                        <td><input type="checkbox" class="box"></td>
                        <td>3</td>
                        <td>Peterson</td>
                        <td>male</td>
                        <td><a href="#" >删除</a></td>
                    </tr>
                    <tr>
                        <td><input type="checkbox" class="box"></td>
                        <td>4</td>
                        <td>Mary</td>
                        <td>female</td>
                        <td><a href="#" >删除</a></td>
                    </tr>
                </table>
                <div style="text-align: center;margin-top: 20px">
                    <input type="button" id="select_all" value="全选">
                    <input type="button" id="select_none" value="全不选">
                    <input type="button" id="select_aside" value="反选">
                </div>
                <script>
                    window.onload = function (){
                        //行变色
                        let rows = document.getElementsByTagName("tr");
                        for (let i = 0; i < rows.length; i++) {
                            rows[i].onmouseover = function (){
                                rows[i].setAttribute("style","background: pink");
                            };
                            rows[i].onmouseout = function (){
                                rows[i].removeAttribute("style");
                            }
                        }

                        //三个按钮
                        let select_all = document.getElementById("select_all");
                        let select_none = document.getElementById("select_none");
                        let select_aside = document.getElementById("select_aside");
                        let boxes = document.getElementsByClassName("box");

                        select_all.onclick = function(){
                            for (let i = 0; i < boxes.length; i++) {
                                boxes[i].checked = 1;
                            }
                        };
                        select_none.onclick = function(){
                            for (let i = 0; i < boxes.length; i++) {
                                boxes[i].checked = 0;
                            }
                        };
                        select_aside.onclick = function(){
                            for (let i = 0; i < boxes.length; i++) {
                                boxes[i].checked = !(boxes[i].checked);
                            }
                        };
                    };
                </script>
                </body>
                </html>
                -

                方法

                //获取方法
                //可以获取静态方法
                Method m = stuC.getMethod("haha");
                System.out.println(m);
                //获取带参方法，自动根据参数推断
                Method m2 = stuC.getMethod("hello");
                Method m3 = stuC.getMethod("hello",String.class);
                //调用方法
                m2.invoke(stu);
                m3.invoke(stu,"琳琳");
                //获取私有方法并调用
                Method m4 = stuC.getDeclaredMethod("giveMoney");
                m4.setAccessible(true);
                m4.invoke(stu);
                /*输出
                public static void Student.haha()
                hello
                hello,琳琳!
                my money is yours...*/
                +
                练习：表单校验
                <!DOCTYPE html>
                <html lang="ch">
                <head>
                    <meta charset="UTF-8">
                    <title>注册界面</title>
                    <link rel="stylesheet" href="./2.css">
                </head>
                <body>
                <div id="log_in_box">
                    <div id="log_in_text">
                        <div id="log_in_text1">
                            新用户注册
                        </div>
                        <div id="log_in_text2">
                            USER REGISTER
                        </div>
                    </div>

                    <div id="log_in_text3">
                        已有账号？<font color = red>立即登录</font>
                    </div>
                    <div id="log_in_table">
                        <form id="form">
                            <table>
                                <tr>
                                    <td class="td_left"><label for="username">用户名</label></td>
                                    <td class="td_right"><input type="text" name="username" id="username" placeholder="请输入用户名"></td>
                                    <td></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="password">密码</label></td>
                                    <td class="td_right"><input type="password" name="password" id="password" placeholder="请输入密码"></td>
                                    <td></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="email">Email</label></td>
                                    <td class="td_right"><input type="email" name="email" id="email" placeholder="请输入邮箱"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="name">姓名</label></td>
                                    <td class="td_right"><input type="text" name="name" id="name" placeholder="请输入姓名"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="tel">手机号</label></td>
                                    <td class="td_right"><input type="text" name="tel" id="tel" placeholder="请输入手机号"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label>性别</label></td>
                                    <td class="td_right">
                                        <input type="radio" name="gender" value="male"> <span class="choice">男</span>
                                        <input type="radio" name="gender" value="female"> <span class="choice">女</span>
                                    </td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="birthday">出生日期</label></td>
                                    <td class="td_right"><input type="date" name="birthday" id="birthday" placeholder="请输入出生日期"></td>
                                </tr>

                                <tr>
                                    <td class="td_left"><label for="checkcode" >验证码</label></td>
                                    <td class="td_right"><input type="text" name="checkcode" id="checkcode" placeholder="请输入验证码">
                                        <img id="img_check" src="img/verify_code.jpg">
                                    </td>
                                </tr>


                                <tr>
                                    <td colspan="2" align="center"><input type="submit" value="注册" id="submit"></td>
                                </tr>
                            </table>
                        </form>
                    </div>
                </div>

                <script>
                    //在开始加载的时候绑定事件的好习惯
                    window.onload = function(){
                        document.getElementById("form").onsubmit = function (){
                            return checkUsername()&&checkPassword();
                        };
                        document.getElementById("username").onblur = checkUsername;
                        document.getElementById("password").onblur = checkPassword;
                    }
                    let username = document.getElementById("username");
                    let password = document.getElementById("password");

                    function checkUsername(){
                        let reg_username = /^\w{6,12}$/;
                        let flag = reg_username.test(username.value);
                        if (flag){
                            username.parentNode.parentNode.lastElementChild.innerHTML = "<img src=\"./img/gou.png\" alt=\"\">";
                        }
                        else{
                            username.parentNode.parentNode.lastElementChild.innerHTML = "<font color=\"red\">格式错误！</font>";
                        }
                        return flag;
                    }

                    function checkPassword(){
                        let reg_username = /^\w{6,12}$/;
                        let flag = reg_username.test(password.value);
                        if (flag){
                            password.parentNode.parentNode.lastElementChild.innerHTML = "<img src=\"./img/gou.png\" alt=\"\">";
                        }
                        else{
                            password.parentNode.parentNode.lastElementChild.innerHTML = "<font color=\"red\">格式错误！</font>";
                        }
                        return flag;
                    }

                </script>
                </body>
                </html>
                -

                使用反射的案例

                image-20221205205122805

                -
                public class ReflectTest {
                    public static void main(String[] args) throws Exception {
                        /* 加载配置文件 */
                        Properties pro = new Properties();
                        //获取字节码文件加载器
                        ClassLoader cl = ReflectTest.class.getClassLoader();
                        pro.load(cl.getResourceAsStream("pro.properties"));

                        /* 获取配置文件中的数据并执行 */
                        Class cla = Class.forName(pro.getProperty("className"));
                        cla.getMethod(pro.getProperty("methodName")).invoke(cla.newInstance());
                    }
                }
                +

                BOM

                浏览器对象模型，将浏览器各个组成部分封装成对象。

                +

                image-20221224152804747

                +

                Window对象包含DOM对象。

                +

                组成：Window、Navigator、Screen、History、Location

                +
                Window

                不需要创建，直接用window.使用，也可以直接用方法名。比如alert

                +
                方法
                  +

                1. 与弹出有关的方法

                  +

                  alert：弹出警告框； confirm：确认取消对话框。确定返回true；prompt：输入框。参数为输入提示，返回值为输入值。

                  +
                  2. +

                2. 与开关有关的方法

                  +

                  close：关闭调用的window对象的浏览器窗口；open：打开新窗口，可传入URL，返回新的window对象

                  +
                  3. +

                3. 定时器

                  +
                  //只执行一次
                  setTimeout();
                  clearTimeout();
                  //间隔执行多次
                  setInterval();
                  clearInterval();
                  +
                  //一次性定时器
                  //setTimeout("fun();",2000);
                  var id = setTimeout(fun,2000);
                  //取消
                  clearTimeout(id);
                  function fun(){
                      alert('boom~~');
                  }

                  //循环定时器
                  var id = setInterval(fun,2000);
                  clearInterval(id);
                  4. +
                +
                属性
                  +

                1. 获取其他BOM对象

                  +

                  history、location、navigator、screen

                  +
                  2. +

                2. 获取DOM对象

                  +

                  document

                  +
                  3. +
                +
                练习：轮播图
                <!DOCTYPE html>
                <html lang="ch">
                <head>
                    <meta charset="UTF-8">
                    <title>轮播图</title>
                </head>
                <body>
                <img src="./img/banner_1.jpg" width="100%" id="picture">
                <script>
                    let pictures = ["./img/banner_1.jpg","./img/banner_2.jpg","./img/banner_3.jpg"];
                    let i = 0;
                    let img = document.getElementById("picture");
                    function change_picture(){
                        img.src = pictures[(++i)%3];
                    }
                    setInterval(change_picture,2000);
                </script>
                </body>
                </html>
                +
                Location
                  +

                1. 刷新

                  +

                  location.reload方法

                  +
                  2. +

                2. 设置或返回完整的url

                  +

                  location.href属性

                  +
                  3. +
                +
                练习：自动返回首页
                <!DOCTYPE html>
                <html lang="ch">
                <head>
                    <meta charset="UTF-8">
                    <title>自动跳转</title>
                </head>
                <body>
                    <div style="width: 235px; height: 100px; margin: auto">
                        <span style="color: red" id="second">5</span>秒后，自动跳转首页
                    </div>
                    <script>
                        let num = 5;
                        let second = document.getElementById("second");
                        function dao_ji_shi(){
                            if (num == 0){
                                location.href = "https://www.baidu.com/";
                                clearInterval(id);
                            }
                            second.innerHTML = (num--);
                        }
                        let id = setInterval(dao_ji_shi,1000);
                    </script>
                </body>
                </html>
                -

                注解

                image-20221205211932790

                -

                image-20221205212028989

                -

                ①和③都是jdk预定义的。自定义主要是②。

                -

                生成doc文档

                javadoc XXX.java
                +

                Bootstrap

                web前端框架

                +

                image-20221225160246028

                +

                快速入门

                image-20221225161243229

                +

                基本模板：

                +
                <!DOCTYPE html>
                <html lang="zh-CN">
                <head>
                  <meta charset="utf-8">
                  <meta http-equiv="X-UA-Compatible" content="IE=edge">
                  <meta name="viewport" content="width=device-width, initial-scale=1">
                  <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
                  <title>Bootstrap 101 Template</title>
                  
                  <link href="./css/bootstrap.min.css" rel="stylesheet">
                </head>
                <body>
                <h1>你好，世界！</h1>

                <script src="./jquery.min.js"></script>
                <script src="js/bootstrap.min.js"></script>
                </body>
                </html>
                -

                会自动根据里面的注解生成文档

                -

                JDK预定义注解

                image-20221205212443918

                -

                自定义注解

                注解类的本质

                @Target(ElementType.METHOD)
                @Retention(RetentionPolicy.SOURCE)
                public @interface Override {
                }
                +

                响应式布局

                实现依赖于栅格系统。

                +

                栅格系统

                将一行平均分成12个格子，可以指定元素占几个格子

                +

                可以感受到，其实跟我们之前那个纯纯HTML做页面的思想是差不多的，都是把整个页面看做一个表，表有很多行，每行有不同的格子。

                +
                基本原理
                  +
                1. 定义容器。相当于之前的table
                  2. +
                +
                  +

                • 容器分类：

                  +
                    +
                  1. container：两边留白
                    2. +
                  2. container-fluid：每一种设备都是100%宽度
                    3. +
                  +
                  • +
                +
                  +
                1. 定义行。相当于之前的tr 样式：row
                  2. +
                2. 定义元素。指定该元素在不同的设备上，所占的格子数目。样式：col-设备代号-格子数目
                  3. +
                +
                  +

                • 设备代号：

                  +
                    +
                  1. xs：超小屏幕 手机 (<768px)：col-xs-12
                    2. +
                  2. sm：小屏幕 平板 (≥768px)
                    3. +
                  3. md：中等屏幕 桌面显示器 (≥992px)
                    4. +
                  4. lg：大屏幕 大桌面显示器 (≥1200px)
                    5. +
                  +
                  • +
                +
                使用方法
                <!DOCTYPE html>
                <html lang="zh-CN">
                <head>
                    <meta charset="utf-8">
                    <meta http-equiv="X-UA-Compatible" content="IE=edge">
                    <meta name="viewport" content="width=device-width, initial-scale=1">
                    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
                    <title>Bootstrap HelloWorld</title>

                    <!-- Bootstrap -->
                    <link href="css/bootstrap.min.css" rel="stylesheet">


                    <!-- jQuery (Bootstrap 的所有 JavaScript 插件都依赖 jQuery，所以必须放在前边) -->
                    <script src="js/jquery-3.2.1.min.js"></script>
                    <!-- 加载 Bootstrap 的所有 JavaScript 插件。你也可以根据需要只加载单个插件。 -->
                    <script src="js/bootstrap.min.js"></script>
                    <style>
                        .inner{
                            border:1px solid red;
                        }

                    </style>
                </head>
                <body>
                    <!--1.定义容器-->
                    <div class="container-fluid">
                        <!--2.定义行-->
                        <div class="row">
                            <!--3.定义元素
                                在大显示器一行12个格子
                                在pad上一行6个格子
                            -->
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <!--超出12个格子的部分自动换行-->
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                            <div class="col-lg-1 col-sm-2 inner">栅格</div>
                        </div>

                    </div>

                </body>
                </html>
                -

                本质上

                -
                public @interface Override{}
                +

                样式

                看文档。

                +

                练习：用bootstrap优化旅游网站首页

                代码

                HTML
                <!DOCTYPE html>
                <html lang="zh-CN">
                <head>
                  <meta charset="utf-8">
                  <meta http-equiv="X-UA-Compatible" content="IE=edge">
                  <meta name="viewport" content="width=device-width, initial-scale=1">
                  <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
                  <title>Bootstrap 101 Template</title>

                  <link href="./css/bootstrap.min.css" rel="stylesheet">
                  <link rel="stylesheet" href="./3.css">
                </head>
                <body>
                <div class="container-fluid">
                  <div class="row">
                    <img src="./image/top_banner.jpg" class="img-responsive" id="top">
                  </div>

                  <div class="row" id="top_2">
                    <div class="col-md-3">
                      <img src="./image/logo.jpg" class="img-responsive" id="logo">
                    </div>
                    <div class="col-md-6" id="search">
                      <input type="text" placeholder="Search" id="search_text">
                      <div id="search_but">
                        <a href="#">搜索</a>
                      </div>
                    </div>
                    <div class="col-md-3">
                      <img src="./image/hotel_tel.png" alt="hotel">
                    </div>
                  </div>

                  <div class="row">
                    <nav class="navbar navbar-default">
                      <div class="container-fluid">
                        <!-- Brand and toggle get grouped for better mobile display -->
                        <div class="navbar-header">
                          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
                            <span class="sr-only">Toggle navigation</span>
                            <span class="icon-bar"></span>
                            <span class="icon-bar"></span>
                            <span class="icon-bar"></span>
                          </button>
                          <a class="navbar-brand" href="#">传智播客</a>
                        </div>

                        <!-- Collect the nav links, forms, and other content for toggling -->
                        <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
                          <ul class="nav navbar-nav">
                            <li><a href="#">Android <span class="sr-only">(current)</span></a></li>
                            <li><a href="#">Android</a></li>
                            <li><a href="#">Android</a></li>
                            <li><a href="#">Android</a></li>
                            <li><a href="#">Android</a></li>
                            <li><a href="#">Android</a></li>
                            <li><a href="#">Android</a></li>
                          </ul>
                        </div><!-- /.navbar-collapse -->
                      </div><!-- /.container-fluid -->
                    </nav>
                  </div>

                  <!--  轮播图-->
                  <div class="row">
                    <div id="carousel-example-generic" class="carousel slide" data-ride="carousel">
                      <!-- Indicators -->
                      <ol class="carousel-indicators">
                        <li data-target="#carousel-example-generic" data-slide-to="0" class="active"></li>
                        <li data-target="#carousel-example-generic" data-slide-to="1"></li>
                        <li data-target="#carousel-example-generic" data-slide-to="2"></li>
                      </ol>

                      <!-- Wrapper for slides -->
                      <div class="carousel-inner" role="listbox">
                        <!--        注意只能有其中一张的class是active的-->
                        <div class="item active">
                          <img src="./image/banner_1.jpg" alt="...">
                          <div class="carousel-caption">
                          </div>
                        </div>
                        <div class="item">
                          <img src="./image/banner_2.jpg" alt="...">
                          <div class="carousel-caption">
                          </div>
                        </div>
                        <div class="item">
                          <img src="./image/banner_3.jpg" alt="...">
                          <div class="carousel-caption">
                          </div>
                        </div>
                      </div>

                      <!-- Controls -->
                      <a class="left carousel-control" href="#carousel-example-generic" role="button" data-slide="prev">
                        <span class="glyphicon glyphicon-chevron-left" aria-hidden="true"></span>
                        <span class="sr-only">Previous</span>
                      </a>
                      <a class="right carousel-control" href="#carousel-example-generic" role="button" data-slide="next">
                        <span class="glyphicon glyphicon-chevron-right" aria-hidden="true"></span>
                        <span class="sr-only">Next</span>
                      </a>
                    </div>
                  </div>

                  <div class="container">
                    <div class="row">
                      <img src="./image/icon_5.jpg" alt="亲子周边旅游节">
                      <span class="text1">黑马精选</span>
                      <hr>
                    </div>
                    <div class="row block">
                      <div class="xuanchuan col-md-3">
                        <img src="./image/jiangxuan_1.jpg" alt="" >
                        <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                        <font size = 3 color="#8b0000">￥899</font>
                      </div>
                      <div class="xuanchuan col-md-3">
                        <img src="./image/jiangxuan_1.jpg" alt="" >
                        <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                        <font size = 3 color="#8b0000">￥899</font>
                      </div>
                      <div class="xuanchuan col-md-3">
                        <img src="./image/jiangxuan_1.jpg" alt="">
                        <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                        <font size = 3 color="#8b0000">￥899</font>
                      </div>
                      <div class="xuanchuan col-md-3">
                        <img src="./image/jiangxuan_1.jpg" alt="">
                        <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                        <font size = 3 color="#8b0000">￥899</font>
                      </div>
                    </div>


                    <div class="row">
                      <img src="./image/icon_6.jpg" alt="亲子周边旅游节">
                      <span class="text1">国内游</span>
                      <hr>
                    </div>
                    <div class="row">
                      <div class="col-md-4">
                        <img src="./image/guonei_1.jpg" alt="亲子周边旅游节">
                      </div>
                      <div class="col-md-8">
                        <div class="xuanchuan col-md-4">
                          <img src="./image/jiangxuan_2.jpg" alt="" >
                          <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                          <font size = 3 color="#8b0000">￥899</font>
                        </div>
                        <div class="xuanchuan col-md-4">
                          <img src="./image/jiangxuan_1.jpg" alt="" >
                          <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                          <font size = 3 color="#8b0000">￥899</font>
                        </div>
                        <div class="xuanchuan col-md-4">
                          <img src="./image/jiangxuan_1.jpg" alt="" >
                          <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                          <font size = 3 color="#8b0000">￥899</font>
                        </div>
                        <div class="xuanchuan col-md-4">
                          <img src="./image/jiangxuan_1.jpg" alt="" >
                          <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                          <font size = 3 color="#8b0000">￥899</font>
                        </div>
                        <div class="xuanchuan col-md-4">
                          <img src="./image/jiangxuan_1.jpg" alt="">
                          <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                          <font size = 3 color="#8b0000">￥899</font>
                        </div>
                        <div class="xuanchuan col-md-4">
                          <img src="./image/jiangxuan_1.jpg" alt="">
                          <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                          <font size = 3 color="#8b0000">￥899</font>
                        </div>
                      </div>
                    </div>
                  </div>
                  <div class="row">
                    <img src="./image/footer_service.png" alt="" class="img-responsive">
                    <div id="foot_text" class="col-md-12">
                      <font color="gray" size = 2>江苏传智播客教育科技股份有限公司 版权所有Copyright 2006-2018&copy;, All Rights Reserved 苏ICP备16007882</font>
                    </div>
                  </div>
                </div>

                <script src="./jquery-3.2.1.min.js"></script>
                <script src="js/bootstrap.min.js"></script>
                </body>
                </html>
                -

                等价于

                -
                public interface Override extends java.lang.annotation.Annotation{}
                +
                CSS
                *{
                    margin: 0px;
                    padding: 0px;
                }

                #search{
                    text-align: center;
                }

                #top_2{
                    margin-top: 10px;
                }

                #search_text{
                    border: 3px solid orange;
                    width: 400px;
                    height: 50px;
                    margin-right: 0px;
                    text-align: left;
                    padding: 15px;
                }

                #search_but{
                    margin: 0px;
                    width: 90px;
                    height: 50px;
                    display: inline-block;
                    background: orange;
                    box-sizing: border-box;
                    vertical-align: top;
                    padding: 13px;
                }

                #search_but a{
                    color: white;
                }

                .text1{
                    font-size: 15px;
                }

                hr{
                    margin: 3px;
                    border: 1px solid orange;
                    background: orange;
                }

                .xuanchuan{
                    padding: 6px;
                    margin: auto;
                    height: 244px;
                    border: 1px solid dimgray;
                    text-align: center;
                }

                .xuanchuan img{
                    width: 90%;
                }

                .block{
                    text-align: center;
                }

                #foot_text{
                    height: 60px;
                    width: 100%;
                    background: orange;
                    text-align: center;
                    padding: 15px;
                }

                .row{
                    margin-top: 10px;
                    margin-bottom: 10px;
                }
                -

                注解的属性

                注解的属性就是接口中的成员方法。要求无参，且返回类型有固定取值：

                -

                image-20221205213135522

                -
                public @interface MyAnno {
                    String name() default "haha";
                }
                +

                注意点

                这东西写了我还挺久的。。。不过收获也挺多。

                +
                  +

                1. text-align

                  +

                  是一个css属性，我觉得挺好用的（。我不知道它精确是什么意思，但我发现它好像有种能让该元素下的子元素水平居中的效果。

                  +
                  2. +

                2. 关于“容器”的理解

                  +

                  上面说过，Bootstrap有个容器的概念，跟我们上面纯HTML的表格概念其实是很类似的。

                  +

                  HTML的容器是表格标签，Bootsrap的容器是container-fluid和container类的标签。

                  +

                  与HTML的表格相同，“容器”也是可以嵌套的。这点在本案例体现为一下两点：

                  +

                  ① container中可以嵌套container-fluid。

                  +

                  ​ 案例中，页首-轮播图和页尾这两段是两边不留白的，轮播图-页尾这段是两边留白的。所以，我们就可以让整体为一个container容器，中间一段再用container-fluid容器包装起来。也即：

                  +
                  <body>
                  <div class="container-fluid">
                    <div class="row"></div>
                    <div class="container"></div>
                    <div class="row"></div>
                  </div>
                  </body>
                  -
                  @MyAnno(name = "haha")
                  public class Student{}
                  +

                  注意，此处不要作死为了优雅统一性这样写：

                  +
                  <div class="row container"></div>
                  -

                  元注解

                  描述注解的注解

                  -

                  image-20221205213324052

                  -

                  RetentionPolicy的三个取值：SOURCE、CLASS、RUNTIME，正对应着java对象的三个阶段。

                  -

                  SOURCE：不保留到字节码文件，会被编译器扔掉

                  -

                  CLASS：保留到字节码文件

                  -

                  RUNTIME：被读到

                  -

                  自定义的注解一般都取RUNTIME。

                  -

                  在程序中获取注解属性

                  相当于用注解替换配置文件

                  -
                  @Target(ElementType.TYPE)
                  @Retention(RetentionPolicy.RUNTIME)
                  public @interface Pro {
                      String className();
                      String methodName();
                  }
                  //保留在runtime应该是因为运行时要动态获取值。我试了一下换成CLASS或者SOURCE，会有NullPointerException
                  +

                  也即多加一个row类。要不row的属性会覆盖掉container的。

                  +

                  ② 对于“col-md-4”这些的理解

                  +

                  image-20221225183910393

                  +

                  在做这样的包含row-span元素的行时，之前的解决方案是采用表格嵌套。同样的，这里也可以采用容器嵌套。而此时，列的书写方式就比较特殊了。

                  +
                  <div class="row">
                       <div class="col-md-4">
                         row-span的图片
                       </div>
                         
                       <div class="col-md-8">
                         <div class="col-md-4"></div>
                         <div class="col-md-4"></div>
                         <div class="col-md-4"></div>
                         <div class="col-md-4"></div>
                         <div class="col-md-4"></div>
                         <div class="col-md-4"></div>
                       </div>
                     </div>
                  -
                  @Pro(className = "Student",methodName = "hello")
                  public class ReflectTest {
                      public static void main(String[] args) throws Exception{
                          Pro pro = ReflectTest.class.getAnnotation(Pro.class);
                          
                          Class cla = Class.forName(pro.className());
                          cla.getMethod(pro.methodName()).invoke(cla.newInstance());
                      }
                  }
                  +

                  其实是非常直观的，相信以后你看到这段应该也能理解（。提示一点，栅格系统其实好像是相对于父类的。也就是说，不是“把整个页面分成12个格子”，而是，“把父类占有的空间分成12个格子”。

                  +
                  3. +

                3. 关于hr标签

                  +

                  使用css改颜色时应该写background: orange;而不是color: orange;。

                  +
                  4. +
                +

                XML

                xml叫做可扩展标签语言。它的全部标签都是自定义的。

                +

                image-20221225220356932

                +

                快速入门

                  +
                • 基本语法：
                    1. xml文档的后缀名 .xml
+  2. xml第一行必须定义为文档声明
+  3. xml文档中有且仅有一个根标签
+  4. 属性值必须使用引号(单双都可)引起来
+  5. 标签必须正确关闭
+  6. xml标签名称区分大小写
+
                  +
                  • +
                +
                <?xml version="1.0" encoding="utf-8" ?>

                <users>
                    <user id="1">
                        <name>zhangsan</name>
                        <age>23</age>
                        <gender>male</gender>
                    </user>
                    <user id="2">
                        <name>zhangsan</name>
                        <age>23</age>
                        <gender>male</gender>
                    </user>
                    <user id="3">
                        <name>zhangsan</name>
                        <age>23</age>
                        <gender>male</gender>
                    </user>
                </users>
                -

                class.getAnnotation(Pro.class);这句话实质上是创建了一个实例，继承了Pro接口，重载了里面的抽象方法。

                -

                使用案例：测试框架

                @Target(ElementType.METHOD)
                @Retention(RetentionPolicy.RUNTIME)
                public @interface Check {
                }
                +

                细说

                语法

                文档声明

                常见属性：version[必须]、encoding、standalone[取值为yes和no，yes为依赖其他文件]

                +
                属性

                id属性值唯一

                +
                文本

                image-20221225222029698

                +

                这种要转义来转义去的显然很麻烦。所以就需要用到CDATA区。

                +

                CDATA区的文本会被原样展示。

                +
                <code>

                    <![CDATA[
                            if(1 == 1 && 2 == 2){}
                    ]]>

                </code>
                -

                然后在要测试的每个方法上面加上此标签。

                -

                image-20221205215017285

                -

                然后编写test方法：

                -
                public class TestCheck {
                    public static void main(String[] args) throws IOException {
                        //创建对象
                        Calculator c = new Calculator();
                        //获取所有方法
                        Method[] methods = c.getClass().getMethods();

                        //写入文件
                        int number = 0;//异常次数
                        BufferedWriter bf = new BufferedWriter(new FileWriter("bug.txt"));

                        //检查每个方法是否有注解。有的话则执行。
                        for (Method m : methods){
                            if (m.isAnnotationPresent(Check.class)){
                                try {
                                    m.invoke(c);
                                } catch (Exception e) {
                                    //记录文件信息
                                    number++;
                                    bf.write(m.getName()+"出异常了。");
                                    bf.write("\n");
                                    bf.write(e.getCause().getClass().getSimpleName()+" "+e.getCause().getMessage());
                                    bf.write("\n");
                                    bf.write("-------------");
                                    bf.write("\n");
                                }
                            }
                        }
                        bf.write("共出现"+number+"次异常");
                        bf.flush();
                        bf.close();
                    }
                }
                /*
                haha出异常了。
                ArithmeticException / by zero
                -------------
                共出现1次异常
                */
                +

                约束

                只能写约束文件内的标签

                +
                dtd
                文档
                //students标签里可以包含若干个student标签
                <!ELEMENT students (student*) >
                //student标签必须按顺序出现name，age，sex标签
                <!ELEMENT student (name,age,sex)>
                //name、age、sex都为字符串类型
                <!ELEMENT name (#PCDATA)>
                <!ELEMENT age (#PCDATA)>
                <!ELEMENT sex (#PCDATA)>
                //student标签有一个属性叫number，类型为ID,并且必须要有。类型为ID表示该属性值唯一。
                <!ATTLIST student number ID #REQUIRED>
                -

                image-20221205220053258

                -

                第二部分 数据库

                Mysql

                登录方式

                mysql -h[IP地址] -u[用户名] -p
                +
                引入方式
                //外部引入
                <!DOCTYPE 根标签名 SYSTEM "dtd文件的位置">
                <!DOCTYPE 根标签名 PUBLIC "dtd文件名字" "dtd文件的位置URL">
                -

                文件结构

                本地的一个文件夹就代表一个数据库，文件夹里的一个文件代表一张表。

                -

                image-20221205221041508

                -

                image-20221205221055114

                -

                SQL语法

                image-20221205221216882

                -

                SQL有四种语句类型

                -

                image-20221205221246672

                -

                DDL 操作数据库、表

                操纵数据库

                增
                create datebase 数据库名称;
                create datebase if not exists 数据库名称;
                create datebase if not exists 数据库名称 character set gbk;
                +

                或者可以直接在xml内部写：

                +
                <?xml version="1.0" encoding="UTF-8" ?>
                <!DOCTYPE students SYSTEM "student.dtd">

                <!DOCTYPE students [

                		<!ELEMENT students (student+) >
                		<!ELEMENT student (name,age,sex)>
                		<!ELEMENT name (#PCDATA)>
                		<!ELEMENT age (#PCDATA)>
                		<!ELEMENT sex (#PCDATA)>
                		<!ATTLIST student number ID #REQUIRED>


                		]>
                <students>
                	
                	<student number="s001">
                		<name>zhangsan</name>
                		<age>abc</age>
                		<sex>hehe</sex>
                	</student>

                	<student number="s002">
                		<name>lisi</name>
                		<age>24</age>
                		<sex>female</sex>
                	</student>
                	
                </students>
                -
                删
                drop database 数据库名称;
                drop database if exists 数据库名称;
                +
                使用
                <student number="s001">
                	<name>zhangsan</name>
                	<age>abc</age>
                	<sex>hehe</sex>
                </student>

                <student number="s002">
                	<name>lisi</name>
                	<age>24</age>
                	<sex>female</sex>
                </student>
                -
                改
                alter database 数据库名称 charactor set 修改后新值;
                +
                schema
                文档
                <?xml version="1.0"?>
                <xsd:schema xmlns="http://www.itcast.cn/xml"
                        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                        targetNamespace="http://www.itcast.cn/xml" elementFormDefault="qualified">
                    
                    <xsd:element name="students" type="studentsType"/>
                    //定义类型
                    <xsd:complexType name="studentsType">
                        //类型里面有有序序列
                        <xsd:sequence>
                            <xsd:element name="student" type="studentType" minOccurs="0" maxOccurs="unbounded"/>
                        </xsd:sequence>
                    </xsd:complexType>
                    
                    <xsd:complexType name="studentType">
                        <xsd:sequence>
                            <xsd:element name="name" type="xsd:string"/>
                            <xsd:element name="age" type="ageType" />
                            <xsd:element name="sex" type="sexType" />
                        </xsd:sequence>
                        <xsd:attribute name="number" type="numberType" use="required"/>
                    </xsd:complexType>
                    
                    <xsd:simpleType name="sexType">
                        <xsd:restriction base="xsd:string">
                            //枚举类型
                            <xsd:enumeration value="male"/>
                            <xsd:enumeration value="female"/>
                        </xsd:restriction>
                    </xsd:simpleType>
                    
                    <xsd:simpleType name="ageType">
                        <xsd:restriction base="xsd:integer">
                            <xsd:minInclusive value="0"/>
                            <xsd:maxInclusive value="256"/>
                        </xsd:restriction>
                    </xsd:simpleType>
                    
                    <xsd:simpleType name="numberType">
                        <xsd:restriction base="xsd:string">
                            //正则匹配
                            <xsd:pattern value="heima_\d{4}"/>
                        </xsd:restriction>
                    </xsd:simpleType>
                </xsd:schema>
                -
                查
                show databases;# 查询所有数据库名称
                show create database 数据库名称;# 显示指定数据库创建时的指令内容
                +
                引入方式
                <?xml version="1.0" encoding="UTF-8" ?>
                <!-- 
                	1.填写xml文档的根元素
                	2.引入xsi前缀.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                	3.引入xsd文件命名空间.  xsi:schemaLocation="http://www.itcast.cn/xml  student.xsd"
                	4.为每一个xsd约束声明一个前缀,作为标识  xmlns="http://www.itcast.cn/xml" 
                	
                	
                 -->
                <students   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                			xmlns="http://www.itcast.cn/xml"
                			xsi:schemaLocation="http://www.itcast.cn/xml  student.xsd"
                >
                	<student number="heima_0001">
                		<name>tom</name>
                		<age>18</age>
                		<sex>male</sex>
                	</student>

                </students>
                -
                使用
                select database();# 查询正在使用的数据库名称
                use 数据库名称;
                +

                它这意识就是，每个schema文件都要起一个别名，比如xsi:schemaLocation="http://www.itcast.cn/xml student.xsd"这行代码实际上就是把student.xsd的别名起为了http://www.itcast.cn/xml。

                +

                为什么要起名呢？这就类似于命名空间这种东西，你要用到一个标签需要指明这个标签从哪来的，比如std::vector，Class.toString这种。这种命名空间在xml里叫前缀。所以，实际上完整写法应该是<http://www.itcast.cn/xml:students>。

                +

                但这样显然太麻烦了，别名一般都是这种网址，写起来太长了。所以我们选择给别名起别名，设置方法为xmlns:a="http://www.itcast.cn/xml"，这样一来，以后就不用写<http://www.itcast.cn/xml:students>，只用写<a:students>了。

                +

                但是如果每个都写一个前缀还是有点难顶。所以就引入了一个空前缀。这样写<students>这样没有前缀的标签，就相当于从空前缀那个命名空间里拿出来的了。当然如果有多个命名空间，还是得区分一下的。

                +

                解析

                image-20221225234106078

                +

                解析方式有两种方法。

                +
                解析方法
                DOM

                将标记语言文档一次性加载进内存，形成DOM树

                +

                操作方便，可以进行CRUD所有操作；但占内存

                +
                SAX

                逐行读取，基于事件驱动

                +

                不占内存；但只能读取

                +
                解析工具

                image-20221225234649287

                +

                主要学习Jsoup。

                +
                快速入门

                image-20221225234813135

                +

                跟前面html的DOM是差不多的。

                +
                public class JsoupDemo {
                    public static void main(String[] args) throws IOException {
                        //获取Document对象，根据xml文档
                        //解析xml文档（加载进内存且获取dom树）
                        Document doc = Jsoup.parse(new File(JsoupDemo.class.getClassLoader()
                                .getResource("student.xml").getPath()),"utf-8");
                        //获取元素对象
                        //Elements extends ArrayList<Element>
                        Elements ele = doc.getElementsByTag("name");
                        //获取元素里的数据
                        System.out.println(ele.get(0).text());
                    }
                }
                -

                操纵表

                增
                create table students(
                    name varchar(20),
                    age int,
                    score double(3,1),
                    birthday date,
                    insert_time timestamp
                );# 创建表
                create table students2 like students;# 复制表
                +
                细说
                  +

                1. Jsoup：工具类，可以解析html或xml文档，返回Document

                  +
                    +
                  • parse：解析html或xml文档，返回Document
                      +
                    • parse(File in, String charsetName)：解析xml或html文件的。
                      • +
                    • parse(String html)：解析xml或html字符串
                      • +
                    • parse(URL url, int timeoutMillis)：通过网络路径获取指定的html或xml的文档对象
                      • +
                    +
                    • +
                  +
                  2. +

                2. Document：文档对象。代表内存中的dom树

                  +
                    +
                  • 获取Element对象
                      +
                    • getElementById(String id)：根据id属性值获取唯一的element对象
                      • +
                    • getElementsByTag(String tagName)：根据标签名称获取元素对象集合
                      • +
                    • getElementsByAttribute(String key)：根据属性名称获取元素对象集合
                      • +
                    • getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合
                      • +
                    +
                    • +
                  +
                  3. +

                3. Elements：元素Element对象的集合。可以当做 ArrayList来使用

                  +
                  4. +

                4. Element：元素对象

                  +
                    +
                  1. 获取子元素对象
                    2. +
                  +

                  这一点很好理解。因为Document和Element对象的获取元素方法都继承自Node结点，本意就是获取子元素对象。只不过Document是根节点，所以就变成了获取所有元素对象。

                  +
                    +
                  • getElementById(String id)：根据id属性值获取唯一的element对象
                    • +
                  • getElementsByTag(String tagName)：根据标签名称获取元素对象集合
                    • +
                  • getElementsByAttribute(String key)：根据属性名称获取元素对象集合
                    • +
                  • getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合
                    • +
                  +
                    +
                  1. 获取属性值
                    2. +
                  +
                    +
                  • String attr(String key)：根据属性名称获取属性值
                    • +
                  +
                    +
                  1. 获取文本内容
                    2. +
                  +
                    +
                  • String text():获取字标签的所有纯文本内容
                    • +
                  • String html():获取标签体的所有内容(包括字标签的字符串内容)
                    • +
                  +
                  5. +

                5. Node：节点对象

                  +
                    +
                  • 是Document和Element的父类
                    • +
                  +
                  6. +
                +
                快速查找
                  +

                1. 使用选择器selector

                  +

                  其实语法格式跟css的那个选择器差不多。

                  +
                  /**
                   *选择器查询
                   */
                  public class JsoupDemo5 {
                      public static void main(String[] args) throws IOException {
                          //1.获取student.xml的path
                          String path = JsoupDemo5.class.getClassLoader().getResource("student.xml").getPath();
                          //2.获取Document对象
                          Document document = Jsoup.parse(new File(path), "utf-8");

                          //3.查询name标签
                          /*
                              div{

                              }
                           */
                          Elements elements = document.select("name");
                          System.out.println(elements);
                          System.out.println("=----------------");
                          //4.查询id值为itcast的元素
                          Elements elements1 = document.select("#itcast");
                          System.out.println(elements1);
                          System.out.println("----------------");
                          //5.获取student标签并且number属性值为heima_0001的age子标签
                          //5.1.获取student标签并且number属性值为heima_0001
                          Elements elements2 = document.select("student[number=\"heima_0001\"]");
                          System.out.println(elements2);
                          System.out.println("----------------");

                          //5.2获取student标签并且number属性值为heima_0001的age子标签
                          Elements elements3 = document.select("student[number=\"heima_0001\"] > age");
                          System.out.println(elements3);

                      }

                  }
                  2. +

                2. 使用XPath

                  +

                  XPath：xml路径语言。

                  +

                  XPath API文档

                  +
                  /**
                   *XPath查询
                   */
                  public class JsoupDemo6 {
                      public static void main(String[] args) throws IOException, XpathSyntaxErrorException {
                          //1.获取student.xml的path
                          String path = JsoupDemo6.class.getClassLoader().getResource("student.xml").getPath();
                          //2.获取Document对象
                          Document document = Jsoup.parse(new File(path), "utf-8");

                          //3.根据document对象，创建JXDocument对象
                          JXDocument jxDocument = new JXDocument(document);

                          //4.结合xpath语法查询
                          //4.1查询所有student标签
                          List<JXNode> jxNodes = jxDocument.selN("//student");
                          for (JXNode jxNode : jxNodes) {
                              System.out.println(jxNode);
                          }

                          System.out.println("--------------------");

                          //4.2查询所有student标签下的name标签
                          List<JXNode> jxNodes2 = jxDocument.selN("//student/name");
                          for (JXNode jxNode : jxNodes2) {
                              System.out.println(jxNode);
                          }

                          System.out.println("--------------------");

                          //4.3查询student标签下带有id属性的name标签
                          List<JXNode> jxNodes3 = jxDocument.selN("//student/name[@id]");
                          for (JXNode jxNode : jxNodes3) {
                              System.out.println(jxNode);
                          }
                          System.out.println("--------------------");
                          //4.4查询student标签下带有id属性的name标签 并且id属性值为itcast

                          List<JXNode> jxNodes4 = jxDocument.selN("//student/name[@id='itcast']");
                          for (JXNode jxNode : jxNodes4) {
                              System.out.println(jxNode);
                          }
                      }

                  }
                  3. +
                +

                第四部分 JavaWeb核心

                Tomcat

                概述

                概述

                image-20221226154531990

                +

                Tomcat是Java相关的web服务器软件。

                +

                tomcat目录结构

                image-20221226155107723

                +

                image-20221226155143920启动

                +

                启动时出现的问题

                省流：看系统环境变量有没有CATALINA_HOME这一项，并且看这个CATALINA_HOME的值是否与当前版本安装路径相符合。

                +

                我电脑上本来也有了一个tomcat，只不过跟老师版本不一样。我把这两个都安到同一个目录了。然后我启动了老师版本，却发现输入localhost:8080没有任何响应。我首先去看了一下tomcat的config下的server.xml，发现端口号确实是8080没问题。然后试图访问localhost，发现没有响应，故推测是此处发生了问题。因而我上网按照该教程做了一遍：

                +

                127.0.0.1 拒绝了我们的连接请求–访问本地IP时显示拒绝访问

                +

                我重启电脑后，再次启动老师版本，发现还是不行。这时我开始怀疑是否我的tomcat没有正常启动，或者是否是因为8080这个端口号冲突了。所以我又找了一下如何查看端口号占用情况：

                +

                如何查看端口号是否被占用

                +

                用netstat -a命令即可。我便发现，在我开着tomcat的情况下，8080这个端口没有被使用。说明好像启动不大正常。于是我打开了另一篇回答：

                +

                tomcat 启动了，为什么没打开 8080 端口？

                +

                按照它说的去查看日志文件。发现老师版本的tomcat下的log目录为空。我就去我本安装的版本下的log目录去看了，惊奇地发现，原来我在使用老师版本的tomcat时，tomcat用的是老版本的log目录。也就是说，很有可能config目录也是用的老版本的。我去查看老版本的config，发现端口是8888。于是我把老师版本的tomcat卸载了，去访问localhost:8888，成功力。

                +

                我探寻了以下原因，发现tomcat的startup里面如此写道：

                +
                if not "%CATALINA_HOME%" == "" goto gotHome
                :gotHome
                if exist "%CATALINA_HOME%\bin\catalina.bat" goto okHome
                :okHome
                rem ....
                call "%EXECUTABLE%" start %CMD_LINE_ARGS%
                :end
                -

                *注：

                +

                这一段大概是在找到tomcat这个软件的位置。如果我们在环境变量里面设置了CATALINA_HOME，那么就会直接把软件位置定位到CATALINA_HOME的值的地方，随后之后的逻辑都在那边执行。

                +

                我发现我确实设置了这个CATALINA_HOME，并且：

                +

                image-20221226170930763

                +

                它的值是我电脑原本有的老版本的目录！

                +

                故而，这也就说明了为什么老师的版本不去用自己的log，不去用自己的config，而用的是我电脑上的老版本的log，config了。。。

                +

                image-20221226172653916

                +

                配置

                  +

                • 部署项目的方式：

                    -

                  1. mysql的数据类型表

                    -

                    image-20221205222127740

                    -

                    其中：

                    -

                    ① double(3,1)表示XXX.X，最大值为99.9.

                    -

                    ② 关于三个时间类型

                    -

                    image-20221205222307284

                    -

                    所以timestamp常用作插入时间。

                    -

                    ③ varchar(20)表示二十个字符长的字符串。

                    -

                    注意，是“二十个字符”而不是“二十个字节”。如果使用的字符集每个字符占3个字节，则varchar(20)占60个字节。

                    -

                    ④ BLOB、CLOB、二进制这些用于存储大数，不常用

                    +

                  2. 直接将项目放到webapps目录下即可。 * /hello：项目的访问路径–>虚拟目录 * 简化部署：将项目打成一个war包，再将war包放置到webapps目录下。

                    +
                      +
                    • war包会自动解压缩
                      • +
                    +
                    3. +

                  3. 配置conf/server.xml文件
                    在<Host>标签体中配置
                    <Context docBase="C:\aWorkSpace\Projects\Java\JavaWeb" path="/web" />

                  -
                  删
                  drop table 表名;
                  - -
                  改
                  # 修改表名
                  alter table students rename to new_students;
                  # 修改表的字符集
                  alter table students character set 字符集名称;
                  # 修改表的列名/类型
                  alter table students change name new_name varchar(20);# 新列名 新数据类型
                  alter table students modify name varchar(15);# 新数据类型
                  # 添加一列
                  alter table students add ID double(10);
                  # 删除一列
                  alter table students drop ID;
                  - -
                  查
                  show tables;# 查询数据库中所有表的名字
                  desc 表名;# 查询某个表的结构
                  - +
                  然后之后访问时输入`localhost/web/JavaWeb.html`即可
 
+* docBase:项目存放的路径
+* path：虚拟目录
+
                  +
                    +
                  1. 在conf\Catalina\localhost创建任意名称的xml文件。在文件中编写
                    <Context docBase="C:\aWorkSpace\Projects\Java\JavaWeb" />
                      +
                    • 虚拟目录：xml文件的名称
                      • +
                    +
                    2. +
                  +
                  注意，该方法是热部署的。也就是说，可以不关闭服务器的情况下，去增删xml文件，会马上变化，而不是像上面两种方式一样重启生效。
+
                  +
                  • +
                +

                动态项目目录结构

                项目都存放在webapp里。打开webapp中的任一个。

                +

                image-20221226221811747

                +

                WEB-INF下是动态资源，也就是Java控制的一些文件【大概这个意思】。有这个文件夹的项目是动态项目。

                +

                WEB-INF以外的都是静态资源。

                +

                image-20221226221933346

                +

                tomcat集成到IDEA

                使用maven创建Web项目
                更换maven镜像源

                idea中Maven镜像源详细配置步骤（对所有项目）

                +
                创造项目

                image-20221226235520519

                +

                然后等着它开始下载就行了。

                +

                最后的目录结构：

                +

                image-20221226235607604

                +

                如果java或者resources目录没有，自己建就行。

                +
                加入tomcat

                1.

                +

                TOMCAT -＞ IDEA

                +

                2.

                +

                还有另一种更便捷的方式，就是直接添加maven的tomcat插件。在pom.xml文件里加入此段：

                +
                <build>
                  <plugins>
                    <plugin>
                      <groupId>org.apache.tomcat.maven</groupId>
                      <artifactId>tomcat7-maven-plugin</artifactId>
                      <version>2.2</version>
                    </plugin>
                  </plugins>
                </build>
                -

                DML 增删改表中数据

                增

                insert into students(name,age,score,birthday) values('张三',15,99.9,"2022-12-5");
                insert into students values("张三",15,99.9,"2022-12-5",NULL);
                +

                即可，可用alt+insert自动补全。

                +

                这里我出现了一个飘红报错问题，用这个可以解决：

                +

                maven学习 & Plugin ‘org.apache.tomcat.maven:tomcat7-maven-plugin:2.2’ not found报错解决【问题及解决过程记录】

                +

                然后，右键项目就可以run了：

                +

                image-20221227003805955

                +

                如果没有此选项，就去下载maven helper插件。

                +
                修改tomcat配置参数
                图形化界面

                run-edit configuration-tomcat

                +
                配置文件

                image-20221230221339275

                +

                启动服务器时控制台前几句输出有一句这样的。对应目录下的就可以找到tomcat配置文件。

                +

                Servlet

                server applet运行在服务器端的小程序

                +

                servlet是java编写的服务器端的程序，运行在web服务器中。作用：接收用户端发来的请求，调用其他java程序来处理请求，将处理结果返回到服务器中

                +

                image-20221227154053743

                +

                servlet是接口，定义了Java类被tomcat执行、被浏览器访问的规则。

                +

                image-20221227154222612

                +

                快速入门

                image-20221227154841102

                +

                这里的配置用的是注解，具体原理在第一部分的JavaSE基础里有详细描述了。

                +
                +

                使用maven创建web项目见上面的tomcat-tomcat集成到IDEA-使用maven创建web项目

                +
                +
                +

                如果已经导入依赖坐标却还未生效，就点击右侧侧边栏的maven刷新。

                +

                Maven导入依赖后还不出现Servlet的问题

                +
                +

                原理

                执行原理

                  +
                • 执行原理：
                    +
                  1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径
                    2. +
                  2. 查找web.xml文件，是否有对应的标签体内容。
                    3. +
                  3. 如果有，则在找到对应的全类名【注意：在下面，url-pattern都使用注解配置方法了，所以这两步应该是不用了，应该会变成这样：① 逐个遍历注册的servlet实现类，查看其注解属性是否为对应的url-pattern。② 如果有，则找到类名，步骤继续】
                    4. +
                  4. tomcat会将字节码文件加载进内存，并且创建其对象
                    5. +
                  5. 调用其方法
                    6. +
                  +
                  • +
                +

                生命周期

                image-20221227161516964

                +

                并发安全

                Servlet的init方法只执行一次，一种Servlet在内存中只存在一个对象，Servlet是单例的。因而，当多线程同时访问同一个Servlet对象时，就会产生线程安全问题。所以有需要的话，就要采取手段保障Servlet类的线程安全性。

                +

                体系结构

                为了简化开发，我们可以用提供的servlet的实现类。

                +

                image-20221227163713317

                +

                GenericServlet

                除了service方法之外的方法，差不多都只做了空实现。所以只需写service方法即可。

                +
                @WebServlet("/demo2")
                public class Servletdemo2 extends GenericServlet {
                    public void service(ServletRequest servletRequest, ServletResponse servletResponse){
                    }
                }
                -

                删

                如果不加条件，会把表中所有数据删除

                -
                delete from students where name="张三";
                truncate table students;# 删除表，然后创建一张一模一样的新表
                +

                HttpServlet

                使用

                比如httpservlet，就只用重写里面的doGet和doPost两个方法就行。

                +
                @WebServlet("/demo2")
                public class Servletdemo2 extends HttpServlet {
                    @Override
                    protected void doGet(HttpServletRequest req, HttpServletResponse resp){
                        System.out.println("get!!!");
                    }

                    @Override
                    protected void doPost(HttpServletRequest req, HttpServletResponse resp){
                        System.out.println("post!!!");
                    }
                }

                -

                image-20221205224600869

                -

                改

                如果不加条件，会把表中所有记录全部修改

                -
                update students set name="1", age=10 where name="张三";
                +

                这两个方法的区别就是，当使用get方式提交表单，就会执行第一个方法；使用post则会执行第二个方法。

                +

                比方说post时：

                +

                网页代码如下（放在webapp目录下）

                +
                <!DOCTYPE html>
                <html lang="en">
                <head>
                    <meta charset="UTF-8">
                    <title>Title</title>
                </head>
                <body>
                    Hello,World!
                    <!--  action内写Servlet的资源路径  -->
                    <form action="/webdemo4_war/demo2" method="post">
                        name: <input type="text" name="username" id="username" placeholder="请输入用户名">
                        <input type="submit" value="submit">
                    </form>
                </body>
                </html>
                +

                servlet代码同上。

                +

                最终在网页中点击提交

                +

                image-20221230172048250

                +

                会跳转到\demo页面【也即servlet的访问路径】，并且在console打印“post!!!”

                +
                +

                为啥会这样呢？

                +

                之前在讲表单的时候说过，form的action属性代表着提交时这个表单会提交给谁，值为一个URL。所以，这里action的值设置为Servlet的路径，意思就是把表单数据发送给了Servelet，由于使用的是post方式，因此触发了Servlet的doPost方法。Servlet对得到的数据进行各种处理，并且通过req和resp进行交互。

                +
                +
                +

                为什么此处写的是“\demo”这样的路径？

                +

                事实上这是一个相对路径。

                +

                image-20221230215927404

                +

                部署的根路径可以在 run-edit configuration-tomcat-deployment中找到。

                +
                +
                深层一些的问题
                分成get和post

                之所以这两种方法需要分别处理，是因为在Servlet的service方法中，其实是要对req对象进行参数分解，这两种方法分解方式不一样。

                +

                按照以往，我们需要这样写

                +
                 public void service(ServletRequest servletRequest, ServletResponse servletResponse) {
                     String method = ((HttpServletRequest)servletRequest).getMethod();
                     if("GET".equals(method)){
                //执行get的逻辑
                     }
                     else if ("POST".equals(method)){
                //执行post的逻辑
                     }
                 }
                +

                就类似于可以这么写：

                +
                public void service(ServletRequest servletRequest, ServletResponse servletResponse){
                    String method = ((HttpServletRequest)servletRequest).getMethod();
                    if("GET".equals(method)){
                        doGet(servletRequest,servletResponse);
                    }
                    else if ("POST".equals(method)){
                        doPost(servletRequest,servletResponse);
                    }
                }
                -

                DQL 查询表中记录

                语法

                image-20221205224802814

                -

                基础查询

                select # 多字段查询
                	name,
                	age 
                from 
                	students;
                	
                select distinct # 去重
                	address
                from
                	students;

                # 有NULL参与的计算结果都为NULL
                select name,math,english,math+english from students;
                # ifnull函数不会修改原表中的数据
                select name,math,english,IFNULL(math,0)+IFNULL(english,0) from students;

                select 
                	name,
                	math,
                	english,
                	IFNULL(math,0)+IFNULL(english,0)  total_score # 起别名
                from 
                	students;
                +

                于是最后就融合入httpservlet了。

                +

                url-pattern配置

                  +

                1. 一个Servlet可以定义多个访问路径 ： @WebServlet({“/d4”,”/dd4”,”/ddd4”})

                  +
                  2. +

                2. 路径定义规则：

                  +
                    +
                  1. /xxx：路径匹配如/demo、/*【第一个优先级大于第二个】
                    2. +
                  2. /xxx/xxx:多层路径，目录结构
                    3. +
                  3. *.do：扩展名匹配不能在前面加’/‘。也即：
                    @WebServlet("*.do")
                    -

                    条件查询

                    运算符
                      -

                    1. 基本运算符

                      -

                      <、>、=、<=、>=、<>(不等于，也可以用!=)

                      +url访问填写http://localhost/webdemo4_war/*.do。
                      2. +
                    +
                    4. +
                  +

                  service参数

                  image-20230102005833327

                  +

                  http协议

                  概述

                  概念：Hyper Text Transfer Protocol 超文本传输协议

                  +
                    +

                  • 传输协议：定义了客户端和服务器端通信时发送数据的格式

                    +
                    • +

                  • 特点：

                    +
                      +
                    1. 基于TCP/IP的高级协议需要先经历三次握手，可靠传输
                      2. +
                    2. 默认端口号:80
                      +

                      如果说域名是ip地址的简化表示，ip地址又表示着一台主机，那么使用http协议访问一个网址，相当于访问一台主机，并且端口号为80.

                      +
                      +
                      3. +
                    3. 基于请求/响应模型的:一次请求对应一次响应
                      4. +
                    4. 无状态的：每次请求之间相互独立，不能交互数据
                      5. +
                    +

                    历史版本：

                    +
                      +
                    • 1.0：每一次请求响应都会建立新的连接
                      • +
                    • 1.1：复用连接
                      • +
                    +
                    • +
                  +
                  报文格式
                  请求

                  客户端发送给服务器端的消息

                  +

                  数据格式：

                  +
                    +

                  1. 请求行
                    请求方式 请求url 请求协议/版本
                    GET /login.html HTTP/1.1

                    +
                      +
                    • 请求方式：
                        +
                      • HTTP协议有7中请求方式，常用的有2种
                          +
                        • GET：
                            +
                          1. 请求参数在请求行中【在url后】。
                            2. +
                          2. 请求的url长度有限制的
                            3. +
                          3. 不太安全
                            4. +
                          +
                          • +
                        • POST：
                            +
                          1. 请求参数在请求体中
                            2. +
                          2. 请求的url长度没有限制的
                            3. +
                          3. 相对安全
                            4. +
                          +
                          • +
                        +
                        • +
                      +
                      • +
                    +
                    2. +

                  2. 请求头：客户端浏览器告诉服务器一些信息
                    请求头名称: 请求头值

                    +
                      +

                    • 常见的请求头：

                      +
                        +

                      1. User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息 * 可以在服务器端获取该头的信息，解决浏览器的兼容性问题

                        +
                        2. +

                      2. Accept：可以支持的响应格式

                        +
                        3. +

                      3. Accept-language：可以支持的语言环境

                        +
                        4. +

                      4. Referer：http://localhost/login.html * 告诉服务器，我(当前请求)从哪里来？

                        +
                          +
                        • 作用：
                          • +
                        +
                          +
                        1. 防盗链：image-20230101235437317如果ref头非合法就不播放
                          2. +
                        2. 统计工作：看从哪个网站来的人数多
                          3. +
                        +
                        5. +

                      5. Connection：连接是否活着

                        6. -

                      6. 逻辑运算符

                        -

                        AND、OR

                        +
                      • -

                    • BETWEEN AND

                      +
                    3. -

                  3. IN后跟集合

                    -

                    image-20221205230824086

                    +

                  4. 请求空行
                    空行，就是用于分割POST请求的请求头，和请求体的。

                    5. -

                  5. IS、IS NOT

                    -

                    image-20221205230902110

                    +

                  6. 请求体(正文)：

                    +
                      +
                    • 封装POST请求消息的请求参数的
                      • +
                    7. -

                  7. LIKE 模糊查询

                    -

                    类似正则使用占位符匹配

                    -

                    image-20221205231037021

                    -
                    select * from students where name like "马%";
                  -

                  各种函数一样的东西

                  排序函数
                  order by 排序字段1 排序方式1,排序字段2 排序方式2;
                  +

                  字符串格式：

                  +
                  //请求行
                  POST /login.html	HTTP/1.1
                  //请求头
                  Host: localhost
                  User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0
                  Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
                  Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
                  Accept-Encoding: gzip, deflate
                  Referer: http://localhost/login.html
                  Connection: keep-alive
                  Upgrade-Insecure-Requests: 1
                  //请求空行

                  //请求体
                  username=zhangsan
                  + + +
                  响应

                  响应消息：服务器端发送给客户端的数据

                  +

                  数据格式：

                    -

                  1. 默认升序。

                    -
                    2. -

                  2. ASC、DESC

                    -
                    3. -

                  3. 多关键字排序

                    -

                    image-20221205231606255

                    -

                    第二条件仅当第一条件一样才使用。

                    +

                  4. 响应行

                    +
                      +

                    1. 组成：协议/版本 响应状态码 状态码描述 HTTP/1.1 200 OK

                      2. -
                    -
                    聚合函数

                    将一列数据作为整体，纵向计算

                    -

                    注意，聚合函数的计算会排除NULL值。如果不想让空置排除，可以尝试该方法：

                    -
                    select count(ifnull(math,0)) from students;
                    - +

                  5. 响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态, 状态码都是3位数字. 分类:

                      -

                    1. count 计算个数

                      -
                      select count(name) from students;# 有多少条记录
                      - -

                      一般如果要看有多少记录，可以用count(主键)，因为主键不为空。

                      +

                    2. 1xx：服务器接收客户端消息，但没有接收完成，等待一段时间后，发送1xx多状态码，询问是否还要继续发

                      3. -

                    3. max、min

                      +

                    4. 2xx：成功。代表：200

                      5. -

                    5. sum 求和

                      +

                    6. 3xx：重定向。代表：302(重定向)，304(访问缓存)

                      +

                      image-20230103151112791

                      +

                      需要自动重定向到另一个C去

                      +

                      image-20230103151237984

                      +

                      发现资源未变化且本地有缓存

                      7. -

                    7. avg 平均值

                      +

                    8. 4xx：由客户端造成的错误

                      +

                      代表：

                      +
                        +

                      1. 404（请求路径没有对应的资源，可能路径输错了）

                        2. +

                      2. 405：请求方式没有对应的doXxx方法

                        +

                        当我们在Servlet中未重写doXXX方法，就默认不能用此方法进行访问。因为doXXX方法的默认实现为：

                        +
                        String protocol = req.getProtocol();
                        String msg = lStrings.getString("http.method_get_not_supported");
                        if (protocol.endsWith("1.1")) {
                            resp.sendError(405, msg);
                        } else {
                            resp.sendError(400, msg);
                        }
                      -
                      分组查询

                      分组之后查询的字段只能是两种：① 分组字段 ② 聚合函数。因为分组了之后再查具有个人特色的东西就没意义了。【高版本的mysql如果查询别的字段会报错】

                      -
                      select sex,avg(math) from students group by sex;
                      - -

                      image-20221207212103151

                      -
                      对分组结果进行条件限制

                      还可以在分组前对条件限定，使用WHERE

                      -
                      select sex,avg(math) from students where math >= 70 group by sex;
                      - -

                      或者在分组后限定，使用HAVING

                      -
                      select sex,avg(math),count(id) from students group by sex having count(id)>2;
                      # 或
                      select sex,avg(math),count(id) total from students group by sex having total>2;
                      - -
                      WHERE和HAVING的区别
                        -
                      1. WHERE在分组前限定，不满足where则不参与分组；HAVING在分组后限定，不满足having则不会被查询出来。
                        2. -
                      2. WHERE条件里不能有聚合函数，HAVING可以。
                        3. + +

                      3. 5xx：服务器端错误。

                        +

                        代表：500(服务器内部出现Exception)

                        +
                        int i = 3/0;
                      -
                      分页查询

                      image-20221207213958848

                      -

                      这种就是分页查询。

                      -
                      limit 开始的索引,每页查询的条数;
                      - -

                      limit只能在mysql使用。

                      -

                      DCL 管理用户，授权操作

                      管理用户

                      查询用户

                      image-20221219223932789

                      -

                      用户表存放地点↑

                      -
                      USE mysql;
                      SELECT * FROM USER;
                      - -
                      创建用户

                      注意，以下出现的”用户名”@”主机名” IDENTIFIED BY “密码”，不能在@两侧加空格，否则报错。

                      -
                      CREATE USER "用户名"@"主机名" IDENTIFIED BY "密码";
                      - -
                      删除用户
                      DROP USER "用户名"@"主机名";
                      - -
                      修改密码
                      -- 使用mysql自带的密码加密函数PASSWORD
                      -- 1
                      UPDATE USER SET PASSWORD = PASSWORD("新密码") WHERE USER = "用户名";
                      -- 2
                      SET PASSWORD FOR "用户名"@"主机名" = PASSWORD("新密码");
                      - -

                      image-20221219225036633

                      -

                      授权操作

                      查询权限
                      SHOW GRANTS FOR "root"@"%";
                      - -
                      授予权限
                      grant 权限列表 on 数据库名.表名 to '用户名'@'主机名';
                      - -

                      image-20221219225715075

                      -
                      撤销权限
                      revoke 权限列表 on 数据库名.表名 from '用户名'@'主机名';
                      - -

                      约束

                      非空约束

                      添加非空约束

                      CREATE TABLE stu(
                      	id INT,
                      	name VARCHAR(20) NOT NULL
                      );
                      ALTER TABLE stu MODIFY name VARCHAR(20) NOT NULL;
                      - -

                      删除非空约束

                      如果要去掉该约束，可以这么做：

                      -
                      ALTER TABLE stu MODIFY name VARCHAR(20);
                      - -

                      由于我们没写“NOT NULL ”，所以非空约束就被去掉了。感觉这点的解释挺有意思的。

                      -

                      唯一约束

                      添加唯一约束

                      某列值不能重复

                      -
                      CREATE TABLE stu(
                      	id INT,
                      	phone_number VARCHAR(20) UNIQUE
                      );
                      ALTER TABLE stu MODIFY phone_number VARCHAR(20) UNIQUE;
                      - -

                      但是注意，唯一约束允许多个NULL存在。

                      -

                      删除唯一约束

                      唯一约束的删除方法跟前面的非空约束就完全不一样了。

                      -
                      ALTER TABLE stu DROP INDEX phone_number;
                      - -
                      -

                      创建唯一约束时会自动创建唯一索引，需要删除索引

                      -
                      -

                      主键约束

                      一张表只能有一个主键。主键非空且唯一。

                      -

                      添加主键约束

                      CREATE TABLE stu(
                      	id INT PRIMARY KEY,
                      	name VARCHAR(20)
                      );
                      ALTER TABLE stu MODIFY id INT PRIMARY KEY;
                      - -

                      删除主键约束

                      ALTER TABLE stu DROP PRIMARY KEY;
                      - -

                      自动增长

                      这东西一般都跟主键结合使用。

                      -

                      若某一列是数值类型，可以使用auto_increment关键字来完成值的自动增长。

                      -
                      CREATE TABLE stu(
                      	id INT PRIMARY KEY AUTO_INCREMENT,
                      	NAME VARCHAR(20)
                      );
                      INSERT INTO stu VALUES(NULL,'111');# 设NULL或自己指派都行。
                      - -

                      自动增长的数据只跟上一个记录有关系。

                      -

                      外键约束

                      引言

                      image-20221207222232057

                      -

                      表中dep_name和dep_location有数据冗余，修改或者插入都不方便，不符合数据库设计准则，所以需要创造两张表。

                      -

                      image-20221207222418827

                      -

                      image-20221207222439652

                      -

                      但要是你想裁员了，直接在第二个表删研发部是没用的，第一个表数据还在，还得麻烦地一个个删。这时候外键就起作用了。

                      -

                      添加外键约束

                      外键只能关联唯一约束或者主键约束的列。一般外键都是去关联主表的主键。

                      -

                      image-20221207223758950

                      -
                      CREATE TABLE employee(
                      	id INT PRIMARY KEY AUTO_INCREMENT,
                      	NAME VARCHAR(20),
                      	age INT,
                      	dep_id INT, -- 外键列
                      	CONSTRAINT emp_dept_fk FOREIGN KEY (dep_id) REFERENCES department(id) -- 外键声明
                      );

                      ALTER TABLE employee ADD CONSTRAINT emp_dept_fk FOREIGN KEY (dep_id) REFERENCES department(id) -- 外键声明
                      - -

                      此时不能删除department的行【要是该行在employee表没出现过的话就可以删掉】，也不能在employee添加一个不存在的外键值。

                      -

                      删除外键约束

                      ALTER TABLE employee DROP FOREIGN KEY emp_dept_fk;
                      - -

                      外键级联

                      如果你想修改外表主键值，就需要用到级联更新。

                      -
                      ALTER TABLE employee ADD CONSTRAINT emp_dept_fk FOREIGN KEY (dep_id) REFERENCES department(id) ON UPDATE CASCADE ;-- 外键声明+级联更新声明
                      - -

                      如果你想达到删除一个主键值就能删除表中的所有与该主键值关联的数据，就需要用到级联删除。

                      -
                      ALTER TABLE employee ADD CONSTRAINT emp_dept_fk FOREIGN KEY (dep_id) REFERENCES department(id) ON DELETE CASCADE ;-- 外键声明+级联删除声明
                      - -

                      级联使用应该要谨慎。一是它不大安全，二是它涉及多表操作，效率低下

                      -

                      多表关系与范式

                      多表关系

                      image-20221219161901631

                      -

                      image-20221219161847190

                      -

                      image-20221219161853190

                      -

                      范式

                      image-20221219162311785

                      -

                      image-20221219162646556

                      -

                      1NF

                      image-20221219162034996

                      -

                      image-20221219162047446

                      -

                      2NF

                      1NF中的主属性为学号和课程名称。可以看到，分数完全依赖于码，但是姓名、系名、系主任都只是部分依赖于码，这不符合2NF的条件。因而，我们就可以选择拆分表，把完全依赖的部分和部分依赖的部分分开：

                      -

                      由于分数->（学号，课程名称），因而可以把学号、课程名称、分数放在一张表

                      -

                      由于姓名、系名、系主任 ->(学号)，因而可以把学号、姓名、系名、系主任放在一张表

                      -

                      如下图所示。这样就消除了部分依赖。

                      -

                      图片2

                      -

                      3NF

                      2NF中选课表的主属性为学号和课程名称，学生表的主属性为学号。可以看到，学生表中，存在着系主任->系名->学号这样的传递依赖，不符合3NF的规定。因而，我们需要对学生表进行进一步的拆分。

                      -

                      我们为了破坏系主任->系名->学号这个传递链，可以拆分成系主任->系名和系名->学号两个传递关系。

                      -

                      因而，可以把学生表拆分为如下图两张表：

                      -

                      image-20221219162231385

                      -

                      多表查询

                      内连接查询

                      隐式内连接

                      使用where条件

                      -
                      -- 查询所有员工信息和对应的部门信息
                      SELECT * FROM emp,dept WHERE emp.`dept_id` = dept.`id`;
                      -- 进行去重就成为了自然连接：
                      SELECT emp.*,dept.`NAME` FROM emp,dept WHERE emp.`dept_id` = dept.`id`;
                      - -
                      -

                      此在书中称为“等值连接和非等值连接”。

                      -
                      -

                      显式内连接

                      语法： select 字段列表 from 表名1 [inner] join 表名2 on 条件

                      -
                      SELECT * FROM emp INNER JOIN dept ON emp.`dept_id` = dept.`id`;
                      - -

                      外连接查询

                      -

                      关于外连接和内连接的区别，以及左外连接与右外连接的区别：

                      -

                      image-20221219155724391

                      -

                      ![屏幕截图 2022-12-19 155750](./JavaWeb/屏幕截图 2022-12-19 155750.png)

                      -

                      image-20221219155846157

                      -
                      -

                      左外连接

                      语法：select 字段列表 from 表1 left [outer] join 表2 on 条件；

                      -
                      SELECT 	t1.*,t2.`name` FROM emp t1 LEFT JOIN dept t2 ON t1.`dept_id` = t2.`id`;
                      - -

                      右外连接

                      语法：select 字段列表 from 表1 right [outer] join 表2 on 条件；

                      -
                      SELECT 	* FROM dept t2 RIGHT JOIN emp t1 ON t1.`dept_id` = t2.`id`;
                      - -

                      子查询

                      查询嵌套

                      -
                      -

                      子查询中不允许使用ORDER BY

                      -

                      在实际运用中，内连接比子查询的效率更高

                      -
                      -

                      不相关子查询

                      -

                      image-20221219160800762

                      -
                      -
                      子查询结果单行单列

                      可用于WHERE条件

                      -
                      -- 查询工资最高的员工信息
                      SELECT * FROM emp WHERE emp.salary = (SELECT MAX(salary) FROM emp);
                      - -
                      子查询结果多行单列

                      可以作为条件用IN关键字

                      -
                      -- 查询'财务部'和'市场部'所有的员工信息
                      SELECT * FROM emp WHERE dept_id IN (SELECT id FROM dept WHERE name = "财务部" OR name = "市场部");
                      - -
                      子查询结果多行多列

                      可以当做一个新表，可以转化为普通内连接

                      -
                      -- 查询员工入职日期是2011-11-11日之后的员工信息和部门信息
                      -- 嵌套查询
                      SELECT *
                      FROM dept, (
                      	SELECT *
                          FROM emp
                          WHERE emp.join_data > '2011-11-11'
                      )
                      WHERE dept.id = emp.dept_id;
                      -- 内连接
                      SELECT * FROM emp,dept WHERE emp.join_data > '2011-11-11' AND emp.dep_id = dept.id;
                      - -

                      相关子查询

                      -

                      image-20221219160653496

                      -

                      子查询内部使用了父查询的东西

                      -

                      image-20221219161626542

                      -

                      image-20221219161637827

                      -
                      -

                      事务

                      基本介绍

                      概念

                      一个包含多个步骤的业务操作被事务管理，操作要么同时成功，要么同时失败。【有种原子操作的感觉？】

                      -

                      image-20221219214157761

                      -

                      当操作失败时，会回滚到执行前的状态。

                      -

                      事务操作

                      事实上就是类似有个缓冲区，得到commit指令就把缓冲区内容更新，得到rollback指令就把缓冲区内容丢弃。

                      -
                      -- 开启事务
                      START TRANSACTION;

                      -- 操作序列：转账500元
                      UPDATE usr SET money = money - 500 WHERE uname = "Mary";
                      UPDATE usr SET money = money + 500 WHERE uname = "Lily";

                      -- 提交
                      COMMIT;
                      - -
                      -- 开启事务
                      START TRANSACTION;

                      -- 操作序列：转账500元
                      UPDATE usr SET money = money - 500 WHERE uname = "Mary";
                      出错了
                      UPDATE usr SET money = money + 500 WHERE uname = "Lily";

                      -- 出错则回滚
                      ROLLBACK;
                      - -
                      开启事务
                      START TRANSACTION;
                      - -
                      回滚事务
                      ROLLBACK;
                      - -
                      提交事务
                      COMMIT;
                      - -

                      一条DML（增删改表中数据）语句默认会自动提交。但如果手动开启了事务，那么事务内保护的原子序列就需要手动提交。

                      -

                      如果想将默认提交给kill了，也即不论是否开启事务都得手动提交，那么就需要用如下语句：

                      -
                      SET @@autocommit = 0;
                      - -

                      事务的四大特征

                      原子性

                      持久性

                      一旦事务提交/回滚，会持久性更新数据库表。

                      -

                      隔离性

                      多个事务之间应该相互独立。为了保障这一点，需要设置事务的隔离级别。

                      -

                      一致性

                      事务操作前后数据总量不变。

                      -

                      事务的隔离级别

                      概念：多个事务之间隔离的，相互独立的。但是如果多个事务操作同一批数据，则会引发一些问题，设置不同的隔离级别就可以解决这些问题。【有点并发的感觉】

                      -

                      image-20221219221141605

                      -

                      隔离级别越高，安全性越高，效率越来越差。

                      -

                      mysql默认的是3，oracle默认的是2.

                      -

                      可以设置隔离级别。

                      -
                      set global transaction isolation level  "级别字符串";
                      - -
                      -

                      通过之后老师说的内容，感觉有了点个人的感悟：

                      -

                      级别1寻找数据可能优先从缓冲区找；级别2相当于不能读到缓冲区内容；级别3可能相当于在开启事务前对表做了个快照？级别4应该就是直接上了把互斥锁，同一时刻只能一个事务读写。

                      -
                      -

                      JDBC

                      概念

                      Java Database Connectivity Java语言操作数据库

                      -

                      image-20221220141025613

                      -

                      image-20221220141214259

                      -

                      快速入门

                        -

                      1. 导入驱动jar包

                        -

                        ① 新建libs目录

                        -

                        ② 把jar包复制到libs目录下

                        -

                        ③ 右键libs目录 add as library

                        2. -

                      2. 注册驱动

                        +
                      +
                      9. +

                    9. 响应头：

                      +
                        +

                      1. 格式： [头名称 : 值]

                        +
                        2. +

                      2. 常见的响应头：

                        +
                          +

                        1. Content-Type：服务器告诉客户端本次响应体 数据格式以及编码格式

                          +

                          浏览器依照编码格式来对该页面进行解码。

                          2. -

                        2. 获取数据库连接对象 Connection

                          +

                        3. Content-disposition：服务器告诉客户端以什么格式打开响应体数据

                          +
                            +
                          • 值：
                              +
                            • in-line：默认值，在当前页面内打开
                              • +
                            • attachment;filename=xxx：以附件形式打开响应体。也即点击超链接后开始文件下载
                              • +
                            • -

                          • 定义sql语句

                            +
                          4. -

                        4. 获取执行sql语句的对象 Statement

                          +
                        3. -

                      3. 执行sql，接收返回的结果

                        +
                      10. -

                    10. 处理结果

                      +

                    11. 响应空行

                      12. -

                    12. 释放资源

                      +

                    13. 响应体：传输的数据

                    -
                    public class JdbcDemo1 {
                        public static void main(String[] args) throws ClassNotFoundException, SQLException {
                            //1 注册驱动
                            Class.forName("com.mysql.jdbc.Driver");
                            //2 获取数据库连接对象
                            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/helloworld","root","root");
                            //3 定义sql语句
                            String sql = "update usr set money = 5000 where id = 1";
                            //4 获取执行对象 Statement
                            Statement stmt = conn.createStatement();
                            //5 执行sql
                            int count = stmt.executeUpdate(sql);
                            //6 处理结果
                            System.out.println(count);
                            //7 释放资源
                            stmt.close();
                            conn.close();
                        }
                    }
                    +

                    字符串格式:

                    +
                    //响应行
                    HTTP/1.1 200 OK
                    //响应头
                    Content-Type: text/html;charset=UTF-8
                    Content-Length: 101
                    Date: Wed, 06 Jun 2018 07:08:42 GMT
                    //响应空行

                    //响应体
                    <html>
                        <head>
                            <title>$Title$</title>
                        </head>
                        <body>
                            hello , response
                        </body>
                    </html>
                    -

                    优化版【增加try-catch-finally】：

                    -
                    public class JdbcDemo1 {
                        public static void main(String[] args) {
                            //1 注册驱动
                            //提升作用域，放在try外面
                            Connection conn = null;
                            Statement stmt = null;
                            ResultSet resultSet = null;
                            try {
                                Class.forName("com.mysql.jdbc.Driver");
                                //2 获取数据库连接对象
                                conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/helloworld","root","root");
                    			//3 定义sql语句
                                String sql = "select * from usr";
                    			//4 获取执行对象 Statement
                                stmt = conn.createStatement();
                    			//5 执行sql
                                resultSet = stmt.executeQuery(sql);
                    			//6 处理结果
                                if (resultSet == null)
                                    System.out.println("修改失败");
                                else {
                                    while(resultSet.next()){
                                        System.out.println(resultSet.getInt(1)+" "
                                                +resultSet.getString(2)+" "
                                                +resultSet.getInt(3));
                                    }
                                }

                            } catch (ClassNotFoundException e) {
                                throw new RuntimeException(e);
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            } finally {
                                if (resultSet != null){
                                    try {
                                        resultSet.close();
                                    } catch (SQLException e) {
                                        throw new RuntimeException(e);
                                    }
                                }
                                //为了避免空指针异常
                                if (stmt != null) {
                                    try {
                                        stmt.close();
                                    } catch (SQLException e) {
                                        throw new RuntimeException(e);
                                    }
                                }
                                if (conn != null){
                                    try {
                                        conn.close();
                                    } catch (SQLException e) {
                                        throw new RuntimeException(e);
                                    }
                                }
                            }
                        }
                    }
                    -

                    详解各个类

                    DriverManager

                    注册驱动

                    目的是告诉程序该使用哪一个数据库驱动jar包

                    -

                    在快速入门中，我们使用这一行来注册驱动：

                    -
                    Class.forName("com.mysql.jdbc.Driver");
                    -

                    表面上看跟DriverManager类可以说是毫无关系。

                    -

                    但其实，类加载器加载类的时候，其实是会自动执行类中的静态代码块的。Driver类中有一段静态代码块如下：

                    -
                    static {
                        try {
                            DriverManager.registerDriver(new Driver());
                        } catch (SQLException var1) {
                            throw new RuntimeException("Can't register driver!");
                        }
                    }
                    +

                    Request

                    继承体系结构

                    ServletRequest(I) - HttpServletRequest(I) - RequestFacade(C)[tomcat创建]

                    +
                    功能
                    获取请求行
                      +

                    1. 获取请求方式 POST

                      +
                      String getMethod()
                      2. +

                    2. 获取虚拟目录 /webdemo

                      +
                      String getContextPath()
                      3. +

                    3. 获取Servlet路径 /demo1

                      +
                      String getServletPath()
                      4. +

                    4. 获取get方式请求参数 name=zhangsan

                      +

                      &分割每个键值对

                      +
                      String getQueryString()
                      5. +

                    5. 获取请求URI和URL

                      +
                      //  /webdemo/demo1
                      String getRequestURI();

                      //  http://localhost/webdemo/demo1
                      StringBuffer getRequestURL();
                      -

                      可见，注册驱动其实主要任务是由DriverManager类干的。这个静态块仅仅用于简化代码书写。

                      -

                      注意：mysql5之后的版本，这一步注册驱动可以省略。

                      -

                      image-20221220151045275

                      -

                      配置文件里自动帮你注册了。我想原理应该是让本文件的类自动加载。

                      +

                      URL:统一资源定位符 ： http://localhost/day14/demo1 中华人民共和国
                      URI：统一资源标识符 : /day14/demo1 共和国

                      +

                      URI的代表范围更大

                      -
                      获取数据库连接
                      Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/helloworld","root","root");
                      - -

                      url的语法：”jdbc:mysql://IP地址:端口号/数据库名称”

                      -

                      image-20221220151425953

                      -

                      Connection

                      数据库连接对象。

                      -
                      获取Statement对象
                      Statement createStatement() throws SQLException;
                      PreparedStatement prepareStatement(String sql) throws SQLException;
                      +
                      6. +

                    6. 获取协议及版本 HTTP/1.1

                      +
                      String getProtocol()
                      7. +

                    7. 获取访问的客户机的IP地址

                      +
                      String getRemoteAddr()
                      8. +
                    +
                    获取请求头
                      +

                    1. 通过请求头的名称获取请求头的值

                      +
                      String getHeader(String name)
                      2. +

                    2. 获取所有的请求头名称

                      +
                      Enumeration<String> getHeaderNames()
                      -
                      管理事务
                      开启事务
                      void setAutoCommit(boolean autoCommit) throws SQLException;
                      +

                      返回的是一个迭代器

                      +
                      3. +
                    +
                    public class Servletdemo2 extends GenericServlet {

                        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
                            HttpServletRequest req = (HttpServletRequest) servletRequest;
                            Enumeration<String> enumerator = req.getHeaderNames();
                            while(enumerator.hasMoreElements()){
                                String name = enumerator.nextElement();
                                System.out.println(name);
                                //System.out.println(name+"-----"+req.getHeader(name));
                            }
                        }
                    }

                    输出结果：
                    host
                    connection
                    sec-ch-ua
                    sec-ch-ua-mobile
                    sec-ch-ua-platform
                    upgrade-insecure-requests
                    user-agent
                    accept
                    purpose
                    sec-fetch-site
                    sec-fetch-mode
                    sec-fetch-user
                    sec-fetch-dest
                    accept-encoding
                    accept-language
                    cookie
                    -

                    设置参数为false即开启事务。也即关闭自动提交。

                    -
                    提交事务
                    void commit() throws SQLException;
                    +

                    这些请求头名称正是上面的键值对里的键。

                    +
                    获取请求体

                    request将请求体中的数据封装成了流。如果数据是字符，那就是字符流；是视频这种的字节，那就是字节流。

                    +
                    * 步骤：
+    1. 获取流对象
+  *  BufferedReader getReader()：获取字符输入流，只能操作字符数据
+  *  ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据
+    2. 操作流获取数据
+
                    +
                    @WebServlet("/demo2")
                    public class Servletdemo2 extends GenericServlet {

                        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
                            HttpServletRequest req = (HttpServletRequest) servletRequest;
                            BufferedReader bfr = req.getReader();
                            String line;
                            while((line = bfr.readLine())!=null){
                                System.out.print(line);
                            }
                        }
                    }
                    -
                    回滚事务
                    void rollback() throws SQLException;
                    +

                    请求体中键值对会在一行里，用&分割

                    +
                    +

                    获取时中文乱码

                    +
                      +

                    • get方式：tomcat 8 已经将get方式乱码问题解决了

                      +
                      • +

                    • post方式：会乱码

                      +
                                         * 解决：在获取参数前，设置流的编码:
 
-
                      Statement
                      
-
                      The object used for executing a static SQL statement and returning the results it produces.执行静态sql
                      
+    
                      request.setCharacterEncoding("utf-8");
                      
+
                      +
                      • +
                    -
                    执行sql
                    //执行任意语句
                    boolean execute(String sql) throws SQLException;
                    /*
                      执行DML（增删改表中数据）和DDL（表和库）语句
                      返回值：影响到的行数。
                    */
                    int executeUpdate(String sql) throws SQLException;
                    //执行DQL（查询表记录）语句
                    ResultSet executeQuery(String sql) throws SQLException;
                    - -

                    ResultSet

                    封装查询结果集。

                    -

                    具体取数方法就是类似迭代器原理。next移动迭代器指针，getXxx()方法，Xxx是数据类型，得到该行表记录中对应列对应数据类型的值。可以传入列数或者列名。

                    -
                    boolean next() throws SQLException;
                    String getString(int columnIndex) throws SQLException;
                    boolean getBoolean(int columnIndex) throws SQLException;
                    //...
                    long getLong(int columnIndex) throws SQLException;
                    //...
                    /*@param:
                    columnLabel – the label for the column specified with the SQL AS clause.
                    		If the SQL AS clause was not specified, then the label is the name of the column
                    */
                    String getString(String columnLabel) throws SQLException;
                    - -

                    使用实例：

                    -

                    image-20221220164414363

                    -
                    public static Collection<Client> query(){
                        ArrayList<Client> clients = new ArrayList<>();
                        Connection conn = null;
                        Statement stmt = null;
                        ResultSet resultSet = null;
                        try {
                            Class.forName("com.mysql.jdbc.Driver");
                            conn = DriverManager.getConnection("jdbc:mysql:///helloworld","root","root");
                            stmt = conn.createStatement();
                            resultSet = stmt.executeQuery("select * from usr");
                            if (resultSet == null)
                                System.out.println("查询失败");
                            else
                                while(resultSet.next())
                                    clients.add(new Client(resultSet.getInt(1),
                                                           resultSet.getString(2),
                                                           resultSet.getInt(3)));
                        } catch (ClassNotFoundException e) {
                            throw new RuntimeException(e);
                        } catch (SQLException e) {
                            throw new RuntimeException(e);
                        } finally {
                            if (resultSet != null){
                                try {
                                    resultSet.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                            //为了避免空指针异常
                            if (stmt != null) {
                                try {
                                    stmt.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                            if (conn != null){
                                try {
                                    conn.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        }
                        return clients;
                    }
                    - -

                    注意：

                    +
                    获取请求参数通用的方法（通用指对get和post通用）

                    这里的请求参数应该是指上面Post的请求体、Get的请求行里的参数，请求头里的参数是获取不到的。

                      -

                    1. 这东西也得Close。

                      +

                    2. 根据参数名称获取参数值

                      +
                      String getParameter(String name)
                      + +

                      如 username=zs&password=123，getParameter(“username”)会得到zs。

                      3. -

                    3. 如果想做“查询到了结果则返回true”这样的操作，不应该使用这样的代码：

                      -
                      if (resultSet != null)  return true;
                      else return false;
                      +

                    4. 根据参数名称获取参数值的数组

                      +
                      String[] getParameterValues(String name)
                      -

                      而应该这样：

                      -
                      return resultSet.next();
                      5. +

                      如 hobby=xx&hobby=game，会得到{xx,game}

                      + +

                    5. 获取所有请求的参数名称

                      +
                      Enumeration<String> getParameterNames()
                      6. +

                    6. 取所有参数的map集合

                      +
                      Map<String,String[]> getParameterMap()
                    -

                    PreparedStatement

                    简介
                    //An object that represents a precompiled SQL statement.
                    //表示预编译的sql语句的对象
                    public interface PreparedStatement extends Statement
                    - -

                    Statement的子类。可以用来解决sql注入问题。

                    -

                    它是预编译的sql语句，也即sql语句中的参数使用“？”占位符，需要传入参数。

                    -
                    使用步骤

                    如下面的验证密码程序。键盘输入账号密码，从数据库查询该用户是否存在。

                    -
                    public class Login {
                        public static void main(String[] args) throws IOException {
                            //输入账号密码
                            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                            System.out.println("Please enter the user name.");
                            String uname = br.readLine();
                            System.out.println("Please enter the password.");
                            String password = br.readLine();
                            //验证账号密码
                            System.out.println(checkPassword(uname,password));
                        }

                        public static boolean checkPassword(String uname,String password){
                            if (uname == null | password == null)   return false;
                            
                            Connection conn = null;
                            PreparedStatement stmt = null;
                            ResultSet resultSet = null;
                            try {
                                conn = JDBCUtils.getConnection();
                                stmt = conn.prepareStatement(
                                    "select * from user where name = ? and password = ?");
                                //这跟resultset的获取表值的那个是一样的，都是需要指定列数和要设定的值。
                                //并且下标都是以1开始。
                                stmt.setString(1,uname);
                                stmt.setString(2,password);
                                resultSet = stmt.executeQuery();
                    //            stmt = conn.createStatement();
                    //            resultSet = stmt.executeQuery("select * from user where name = '"
                    //            								+uname+"' and password = '"+password+"'");
                                return resultSet.next();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            } finally {
                                JDBCUtils.close(conn,stmt,resultSet);
                            }
                        }
                    }
                    - -
                    用PreparedStatement替代Statement

                    它更安全且效率更高。

                    -

                    JDBC工具类

                    书写

                    public class JDBCUtils {
                        //获取连接时不想传参，且需要保证通用性，使用配置文件
                        //配置文件只需读取一次，可以用静态代码块完成
                        private static Properties pro;
                        private static String url;
                        private static String driver;
                        private static String user;
                        private static String password;
                        static{
                            pro = new Properties();
                            try {
                                /*
                                ClassLoader类可以获取src路径下的文件。使用ClassLoader获取文件时，只用传入相对于src的相对路径就行
                                此处如果使用FileReader，需要以下写法：
                                pro.load(new FileReader(
                                        JDBCUtils.class.getClassLoader()
                                                .getResource("jdbc.properties")
                                                .getPath())
                                );
                                */
                                pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("./jdbc.properties"));
                                url = pro.getProperty("url");
                                user = pro.getProperty("user");
                                password = pro.getProperty("password");
                                driver = pro.getProperty("driver");
                                //在静态块里注册驱动
                                Class.forName(driver);
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            } catch (ClassNotFoundException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        public static Connection getConnection()  {
                            try {
                                return DriverManager.getConnection(url,user,password);
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }

                        //重载机制
                        public static void close(Connection conn){
                            close(conn,null,null);
                        }

                        public static void close(Connection conn, Statement stmt){
                            close(conn,stmt,null);
                        }

                        public static void close(Connection conn, Statement stmt, ResultSet resultSet){
                            if (resultSet != null){
                                try {
                                    resultSet.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                            if (stmt != null){
                                try {
                                    stmt.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                            if (conn !=null){
                                try {
                                    conn.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        }
                    }
                    - -

                    使用

                    public static Collection<Client> query(){
                        ArrayList<Client> clients = new ArrayList<>();
                        Statement stmt = null;
                        Connection conn = null;
                        ResultSet resultSet = null;
                        try {
                            conn = JDBCUtils.getConnection();
                            stmt = conn.createStatement();
                            resultSet = stmt.executeQuery("select * from usr");
                            if (resultSet == null)
                                System.out.println("查询失败");
                            else
                                while(resultSet.next())
                                    clients.add(new Client(resultSet.getInt(1),resultSet.getString(2),resultSet.getInt(3)));
                        } catch (SQLException e) {
                            throw new RuntimeException(e);
                        } finally {
                            JDBCUtils.close(conn,stmt,resultSet);
                        }
                        return clients;
                    }
                    - -

                    JDBC控制事务

                    使用Connection对象的管理事务的方法。

                    -

                    image-20221220214249168

                    -

                    image-20221220224401302

                    -
                    public class Account {
                        public static void main(String[] args) {
                            Connection conn = null;
                            PreparedStatement stmt = null;
                            PreparedStatement stmt2 = null;
                            try {
                                conn = JDBCUtils.getConnection();
                                conn.setAutoCommit(false);
                                stmt = conn.prepareStatement(
                                        "update usr set money = money - 500 where id = 1");
                                stmt.executeUpdate();
                    //            int i = 3/0;
                                stmt2 = conn.prepareStatement(
                                        "update usr set money = money + 500 where id = 2");
                                    stmt2.executeUpdate();
                                conn.commit();
                            } catch (Exception e) {
                                try {
                                    conn.rollback();
                                } catch (SQLException ex) {
                                    throw new RuntimeException(ex);
                                }
                                throw new RuntimeException(e);
                            } finally {
                                JDBCUtils.close(conn,stmt);
                            }
                        }
                    }
                    - -

                    数据库连接池

                    其实就是上面的JDBC中的Connection的对象池。

                    -

                    image-20221222212904151

                    -

                    C3P0

                    基本使用

                    非常简单，就是改一下Connection的获取，写一下xml就行。

                    -
                    设置配置文件

                    固定放在src目录下。名字必须为c3p0-config.xml或者c3p0.properties

                    -
                    <c3p0-config>
                        <!-- 使用默认的配置读取连接池对象 -->
                        <default-config>
                            <!--  连接参数 -->
                            <property name="driverClass">com.mysql.jdbc.Driver</property>
                            <property name="jdbcUrl">jdbc:mysql://localhost:3306/helloworld</property>
                            <property name="user">root</property>
                            <property name="password">root</property>

                            <!-- 连接池参数 -->
                            <property name="initialPoolSize">5</property>
                            <property name="maxPoolSize">10</property>
                            <!-- 如果超过此超时时间，就说明数据库连接失败 -->
                            <property name="checkoutTimeout">3000</property>
                        </default-config>

                        <named-config name="otherc3p0">
                            <!--  连接参数 -->
                            <property name="driverClass">com.mysql.jdbc.Driver</property>
                            <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
                            <property name="user">root</property>
                            <property name="password">root</property>

                            <!-- 连接池参数 -->
                            <property name="initialPoolSize">5</property>
                            <property name="maxPoolSize">8</property>
                            <property name="checkoutTimeout">1000</property>
                        </named-config>
                    </c3p0-config>
                    - -

                    可以注意到，xml文件里面可以保存多套配置，比如上面的示例代码就保存了两套配置，default-config和name=”otherc3p0”的config。

                    -

                    ComboPooledDataSource有一个含参构造器：

                    -
                    public ComboPooledDataSource(String configName) {
                        super(configName);
                    }
                    - -

                    就可以传入config的名称指定要用的配置信息。

                    -
                    使用
                    DataSource cpds = new ComboPooledDataSource();
                    Connection conn = null;
                    try{
                        conn = cpds.getConnection();
                    	//正常使用......
                    } catch(Exception e){
                        
                    } finally{
                        if (conn != null){
                            try {
                                //正常使用关闭方法
                                conn.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                    +
                    请求转发

                    在服务器内部资源跳转。

                    +

                    image-20230102195615676

                    +

                    AServlet做了一部分事情，把剩余的事情交给BServlet去做

                    +

                    步骤：

                    +
                      +

                    1. 通过request对象获取请求转发器对象

                      +
                      RequestDispatcher getRequestDispatcher(String path)
                      2. +

                    2. 使用RequestDispatcher对象来进行转发

                      +
                      requestDispatcher.forward(ServletRequest request, ServletResponse response)
                      3. +
                    +
                    @WebServlet("/demo2")
                    public class Servletdemo2 extends GenericServlet {

                        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
                            System.out.println("I am "+Servletdemo2.class.getName());
                            //进行转发
                            servletRequest.getRequestDispatcher("/demo3")
                                .forward(servletRequest,servletResponse);
                        }
                    }

                    @WebServlet("/demo3")
                    public class ServletDemo3 extends GenericServlet {

                        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
                            System.out.println("I am "+ServletDemo3.class.getName());
                        }
                    }
                    -

                    Druid

                    基本使用

                    设置配置文件

                    Druid的配置文件可以放在任意路径下，随便取名字。因为到时候需要指定配置文件。使用的是Properties文件。

                    -
                    driverClassName=com.mysql.jdbc.Driver
                    url=jdbc:mysql://localhost:3306/helloworld
                    username=root
                    password=root
                    initialSize=5
                    maxActive=10
                    maxWait=3000
                    +

                    特点：

                    +
                      +
                    1. 浏览器地址栏路径不变
                      2. +
                    2. 只能在服务器内部跳转，只能转发到服务器内部的资源中
                      3. +
                    3. 转发是一次请求，多个资源使用的是同一次请求
                      4. +
                    +
                    共享数据

                    接力工作的两个Servlet可以通过request对象进行数据通信。

                    +
                    * 方法：
+
                    +
                      +

                    1. 存储键值对

                      +
                      void setAttribute(String name,Object obj)
                      2. +

                    2. 获取值

                      +
                      Object getAttitude(String name)
                      3. +

                    3. 移除键值对

                      +
                      void removeAttribute(String name)
                      4. +
                    +
                    获取ServletContext
                    ServletContext getServletContext()
                    -
                    使用
                    //导入配置文件
                    Properties pro = new Properties();
                    pro.load(Main.class.getClassLoader().getResourceAsStream("./druid.properties"));
                    //使用工厂方法获取连接池对象
                    DataSource cpds = DruidDataSourceFactory.createDataSource(pro);
                    Connection conn = null;
                    try{
                        conn = cpds.getConnection();
                    	//正常使用......
                    } catch(Exception e){
                        
                    } finally{
                        if (conn != null){
                            try {
                                //正常使用关闭方法
                                conn.close();
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                    +
                    练习：结合数据库与Servlet进行用户登录
                    +

                    要求：

                    +

                    1.编写login.html登录页面
                    username & password 两个输入框
                    2.使用Druid数据库连接池技术,操作mysql，day14数据库中user表
                    3.使用JdbcTemplate技术封装JDBC
                    4.登录成功跳转到SuccessServlet展示：登录成功！用户名,欢迎您
                    5.登录失败跳转到FailServlet展示：登录失败，用户名或密码错误

                    +
                    +
                    文件结构

                    ![屏幕截图 2023-01-02 235207](./JavaWeb/屏幕截图 2023-01-02 235207.png)

                    +
                    +

                    错误历程

                    +
                      +

                    1. lib目录位置错误

                      +

                      NoClassDefFoundError解决方案一开始lib目录没放进web-inf，通过此文章得知错误为包未引入，再由下面这篇文章得知lib目录放置错误

                      +

                      JDBC Template报错：java.lang.ClassNotFoundException: org.springframework.jdbc.core.RowMapper

                      +
                      2. +

                    2. druid.properties文件位置错误

                      +

                      报错

                      +

                      java.lang.NullPointerException at java.util.Properties$LineReader.readLine(Properties.java:434)

                      +

                      ，报错位置在pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));

                      +

                      由文章

                      +

                      关于java.lang.NullPointerException at java.util.Properties$LineReader.readLine(Properties.java:434)问题

                      +

                      回忆到，由于是使用类加载器获取文件流，故而要求druid.properties文件应该放在resource文件下。对于以前的项目，resource文件都默认是src文件夹。

                      +

                      但是这次放在src目录下还是不行。定睛一看它web项目文件结构中有一个硕大的resources……放在下面果然就好了。

                      +
                      3. +
                    +
                    +
                    druid.properties
                    driverClassName=com.mysql.jdbc.Driver
                    url=jdbc:mysql://localhost:3306/helloworld
                    username=root
                    password=root
                    initialSize=5
                    maxActive=10
                    maxWait=3000
                    -

                    定义工具类

                    一般使用的时候还是会自定义一个工具类的

                    -
                    import com.alibaba.druid.pool.DruidDataSourceFactory;

                    import javax.sql.DataSource;
                    import java.sql.Connection;
                    import java.sql.ResultSet;
                    import java.sql.SQLException;
                    import java.sql.Statement;
                    import java.util.Properties;

                    public class JDBCUtils {
                        private static DataSource ds;
                        static{
                            try {
                                Properties pro = new Properties();
                                pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("./druid.properties"));
                                ds = DruidDataSourceFactory.createDataSource(pro);
                            } catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        }

                        public static Connection getConnection() throws SQLException {
                            return ds.getConnection();
                        }

                        public  static DataSource getDataSource(){
                            return ds;
                        }

                        //重载机制
                        public static void close(Connection conn){
                            close(conn,null,null);
                        }

                        public static void close(Connection conn, Statement stmt){
                            close(conn,stmt,null);
                        }

                        public static void close(Connection conn, Statement stmt, ResultSet resultSet){
                            if (resultSet != null){
                                try {
                                    resultSet.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                            if (stmt != null){
                                try {
                                    stmt.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                            if (conn !=null){
                                try {
                                    conn.close();
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        }
                    }
                    +
                    html界面
                    <!DOCTYPE html>
                    <html lang="en">
                    <head>
                        <meta charset="UTF-8">
                        <title>Title</title>
                    </head>
                    <body>
                    <!--  action内写Servlet的资源路径  -->
                    <form action="/webdemo4_war/check" method="post">
                      name: <input type="text" name="username" id="username" placeholder="请输入用户名">
                      password: <input type="password" name="password" id="password" placeholder="请输入密码">
                      <input type="submit" value="submit">
                    </form>
                    </body>
                    </html>
                    -

                    使用同上的JDBCUtils

                    -

                    Spring JDBC

                    Spring框架对JDBC的简单封装，提供JDBCTemplate对象。

                    -

                    使用方法

                    带参（PreparedStatement）

                    jdbcTemplate.update("update usr set money = ? where uname = ?",10,"Mary");
                    +
                    Servlet
                    @WebServlet(value = "/fail")
                    public class FailServlet extends HttpServlet {
                        @Override
                        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                            doPost(req,resp);
                        }

                        @Override
                        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                            // 设置字符集，防止中文乱码
                            resp.setContentType("text/html;charset=utf-8");
                            resp.getWriter().write("登录失败，用户名或密码错误");
                        }
                    }
                    -

                    DML

                    update
                    public static void main(String[] args) throws Exception {
                        JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
                        
                        //增
                        int count = jdbcTemplate.update("insert into usr values (null,'Jack',3000),(null,'LiMing',500000)");
                        System.out.println(count);
                        //删
                        int count2 = jdbcTemplate.update("delete from usr where uname = 'Jack'");
                        System.out.println(count2);
                        //改
                        int count3 = jdbcTemplate.update("update usr set money = ? where uname = ?",10,"Mary");
                        System.out.println(count3);
                    }
                    /*输出结果：
                    2
                    1
                    1
                    */
                    +
                    @WebServlet(value = "/success")
                    public class SuccessServlet extends HttpServlet {
                        @Override
                        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                            doPost(req,resp);
                        }

                        @Override
                        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                            resp.setContentType("text/html;charset=utf-8");
                            resp.getWriter().write("登录成功！"+req.getAttribute("uname")+",欢迎您");
                        }
                    }
                    -

                    DQL

                    提供了三种方法。

                    -
                    queryForMap

                    将得到的结果（只能是一行）封装为一个Map<String,Object>，其中key为列名，value为该行该列的值。

                    -

                    如果得到的结果不为1行（=0 or >1），会抛出异常。

                    -
                        JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());

                        Map<String,Object> m = jdbcTemplate.queryForMap("select * from usr where id = 2");
                        System.out.println(m);
                    //输出：{id=2, uname=Lily, money=2000}
                    +
                    @WebServlet(value = "/check")
                    public class CheckServlet extends HttpServlet {
                        @Override
                        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                            doPost(req,resp);
                        }

                        @Override
                        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                            req.setCharacterEncoding("utf-8");

                            //使用BeanUtils把Map转化为对象
                            User tmp = new User();
                            try {
                                BeanUtils.populate(tmp,req.getParameterMap());
                            } catch (IllegalAccessException e) {
                                throw new RuntimeException(e);
                            } catch (InvocationTargetException e) {
                                throw new RuntimeException(e);
                            }

                            User res = UserDao.login(tmp);
                            if (res == null)
                                req.getRequestDispatcher("/fail").forward(req,resp);
                            else{
                                req.setAttribute("uname",res.getUname());
                                req.getRequestDispatcher("/success").forward(req,resp);
                            }

                        }
                    }
                    -
                    queryForList

                    将得到的结果封装为List<Map<String,Object>>，其中一个Map为一行，多个Map表示多行，存储在List中。

                    -
                        List<Map<String, Object>> res = jdbcTemplate.queryForList("select * from usr");
                        for (Map<String,Object> m : res){
                            System.out.println(m.hashCode());
                            System.out.println(m.keySet().toString());
                            System.out.println(m.values().toString());
                        }
                    /*输出结果：
                    213151839
                    [id, uname, money]
                    [1, Mary, 10]
                    213143443
                    [id, uname, money]
                    [2, Lily, 2000]
                    -2022948335
                    [id, uname, money]
                    [4, LiMing, 500000]
                    */
                    +
                    +

                    关于BeanUtils

                    +

                    BeanUtils工具类，简化数据封装, 用于封装JavaBean的

                    +
                      +

                    1. JavaBean：标准的Java类

                      +
                       1. 要求：
+     1. 类必须被public修饰
+     2. 必须提供空参的构造器
+     3. 成员变量必须使用private修饰
+     4. 提供公共setter和getter方法
+ 2. 功能：封装数据
+
                      +
                      2. +

                    2. 概念：

                      +

                      ​ 成员变量：
                      ​ 属性：setter和getter方法截取后的产物

                      +
                                 例如：getUsername() --> Username--> username
+
                      +
                      3. +

                    3. 方法：

                      +
                      1. setProperty()
+1. getProperty()
+1. populate(Object obj , Map map):
+
                      +

                      ​ 将map集合的键值对信息，封装到对应的JavaBean对象中

                      +
                      4. +
                    +
                    +
                    JDBCUtils

                    原封不动地照搬了：第二部分-数据库连接池-Druid-定义工具类 部分的代码。

                    +
                    UserDao
                    public class UserDao {
                        private static final JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
                        public static User login(User user){
                            List<User> users = jdbcTemplate.query("select * from usr where uname = ? and pass = ?",
                                            new BeanPropertyRowMapper<User>(User.class),
                                            user.getUname(),user.getPass());
                            if (users.size() == 0)
                                return null;
                            else
                                return users.get(0);
                        }
                    }
                    -
                    query

                    可以把查询回的结果封装为自己想要的对象而不是Map。如示例就封装为了Client对象。

                    -
                    原始一点的

                    可以看到，里面的包装内容还是得自己写，有点麻烦。

                    -
                            JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());

                            List<Client> clients = jdbcTemplate.query(
                                "select * from usr where money > 1000", 
                                new RowMapper<Client>() {
                                @Override
                                public Client mapRow(ResultSet resultSet, int i) throws SQLException {
                                    return new Client(
                                        resultSet.getInt(1),
                                        resultSet.getString(2),
                                        resultSet.getInt(3));
                                }
                            });
                            System.out.println(clients.toString());
                    /*输出结果
                    [Client{id=2, name='Lily', money=2000}, Client{id=4, name='LiMing', money=500000}, Client{id=6, name='LiMing', money=500000}]
                    */
                    +

                    Response

                    功能

                    设置响应消息。

                    +
                    设置响应行

                    设置状态码

                    +
                    setStatus(int sc);
                    -
                    常用的

                    使用包装好的BeanPropertyRowMapper类。

                    -
                            JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());

                            List<Client> clients = jdbcTemplate.query("select * from usr where money > 1000",
                                    new BeanPropertyRowMapper<Client>(Client.class));
                            System.out.println(clients.toString());
                    /*输出结果：
                    [Client{id=2, uname='Lily', money=2000}, Client{id=4, uname='LiMing', money=500000}, Client{id=6, uname='LiMing', money=500000}]
                    */
                    +
                    设置响应头
                    setHeader(String name, String value)
                    -

                    注意：

                    +
                    设置响应体

                    以流的方式传输数据。

                    +

                    使用步骤：

                      -
                    1. 要求包装的class，比如说Client，必须要有public的无参构造器。
                      2. -
                    2. Java的那个被包装类的字段最好不使用基本数据类型，而使用引用类型，如Integer，Double等等等。因为如果使用基本数据类型，当表中数据为null时会报错。
                      3. -
                    3. 要求被包装的class的字段名称一定要与数据库的一模一样，大小写可以不一样。
                      4. -
                    4. 要求被包装的class的字段一定要是可以修改的。也就是说，要么public，要么提供set方法。
                      5. -
                    -
                    queryForObject

                    返回查到的某个东西。可以用于聚合函数的查询。

                    -
                    int money = jdbcTemplate.queryForObject("select money from usr where uname = 'Mary'",Integer.class);
                    System.out.println(money);
                    - -

                    第三部分 Web概述和静态网页技术

                    Web概述

                      -

                    • JavaWeb：

                      -
                        -
                      • 使用Java语言开发基于互联网的项目
                        • -
                      -
                      • -

                    • 软件架构：

                      +

                    • 获取输出流

                        -
                      1. C/S: Client/Server 客户端/服务器端
                          -
                        • 在用户本地有一个客户端程序，在远程有一个服务器端程序
                          • -
                        • 如：QQ，迅雷…
                          • -
                        • 优点：
                            -
                          1. 用户体验好
                            2. -
                          -
                          • -
                        • 缺点：
                            -
                          1. 开发、安装，部署，维护 麻烦
                            2. +

                          2. 字节输出流

                            +
                            ServletOutputStream getOutputStream()
                            3. +

                          3. 字符输出流

                            +
                            PrintWriter getWriter()
                          • -
                        -
                        2. -
                      2. B/S: Browser/Server 浏览器/服务器端
                          -
                        • 只需要一个浏览器，用户通过不同的网址(URL)，客户访问不同的服务器端程序
                          • -
                        • 优点：
                            -
                          1. 开发、安装，部署，维护 简单
                            2. -
                          +

                        • 使用输出流，将数据输出到客户端浏览器

                          • -
                        • 缺点：
                            -
                          1. 如果应用过大，用户的体验可能会受到影响
                            2. -
                          2. 对硬件要求过高
                          -
                          • -
                        -
                        3. +
                        案例
                        重定向

                        资源跳转的一种方式。

                        +

                        image-20230103153445565

                        +
                        @WebServlet("/demo1")
                        public class ServletDemo extends HttpServlet {
                            @Override
                            protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                                System.out.println("I am demo1  "+req.hashCode());
                                /* 重定向 */
                                //设置状态码
                                resp.setStatus(302);
                                //要填的是完整资源路径。
                                resp.setHeader("location","/practice_war/demo2");
                            }

                            @Override
                            protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                                doGet(req,resp);
                            }
                        }
                        + +
                        @WebServlet("/demo2")
                        public class ServletDemo2 extends HttpServlet {
                            @Override
                            protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                                System.out.println("I am demo2  "+req.hashCode());
                            }

                            @Override
                            protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                                doGet(req,resp);
                            }
                        }
                        + +
                        输出：
                        I am demo1  1675674230
                        I am demo2  1675674230
                        + +

                        重定向的这几行代码其实是可以简化的：

                        +
                        /* 重定向 */
                              //设置状态码
                              resp.setStatus(302);
                              //要填的是完整资源路径。
                              resp.setHeader("location","/practice_war/demo2");
                        + +

                        可以简化为：

                        +
                        resp.sendRedirect("/practice_war/demo2");
                        + +
                        +

                        关于req对象不一样，但hashcode值相同的解释：

                        +

                        hashcode很大程度与对象内存空间相关，与对象的具体内容没什么关系。两个对象拥有相同的hashcode有可能只是因为存储的内存空间位置大小都相同导致的。所以是因为两次的req对象都占用了同一个内存空间【JVM调度问题】，所以才让hashcode值相同。这两个对象实质上是不一样的。

                        +
                        +

                        重定向的特点（与请求转发完全相反）：

                        +
                          +
                        1. 浏览器地址栏路径改变
                          2. +
                        2. 可以访问其他站点的资源
                          3. +
                        3. 使用多次请求，不能使用request对象共享数据
                        - -

                      3. B/S架构详解

                        -
                          -

                        • 资源分类：

                          +

                          路径写法：

                            -
                          1. 静态资源：
                              -
                            • 使用静态网页开发技术发布的资源。
                              • -
                            • 特点：
                                -
                              • 所有用户访问，得到的结果是一样的。
                                • -
                              • 如：文本，图片，音频、视频, HTML,CSS,JavaScript
                                • -
                              • 如果用户请求的是静态资源，那么服务器会直接将静态资源发送给浏览器。浏览器中内置了静态资源的解析引擎，可以展示静态资源
                                • -
                              -
                              • +

                            • 相对路径：通过相对路径不可以确定唯一资源

                              +
                                +
                              • 规则：找到当前资源和目标资源之间的相对位置关系
                              • -
                            • 动态资源：
                                -
                              • 使用动态网页及时发布的资源。
                                • -
                              • 特点：
                                  -
                                • 所有用户访问，得到的结果可能不一样。
                                  • -
                                • 如：jsp/servlet,php,asp…
                                  • -
                                • 如果用户请求的是动态资源，那么服务器会执行动态资源，转换为静态资源，再发送给浏览器
                                  • -
                                +

                              • 绝对路径：通过绝对路径可以确定唯一资源

                                +
                                  +

                                • 如：http://localhost/day15/responseDemo2 /day15/responseDemo2

                                  +
                                  <form action="/webdemo4_war/check" method="post">
                                  • +

                                • 以/开头的路径

                                  • +

                                • 规则：判断定义的路径是给谁用的？判断请求将来从哪儿发出

                                  +
                                    +

                                  • 给客户端浏览器使用：需要加虚拟目录(项目的访问路径)

                                    +

                                    比如说在页面中弄了个a标签，将来是要给客户端点的，那么这个a标签的href就要用绝对路径。

                                    +

                                    再比如说重定向：

                                    +
                                    //要填的是完整资源路径。
                                          resp.setHeader("location","/practice_war/demo2");
                                    + +

                                    这个路径将来是给客户端将来要使用的路径，是客户端路径，所以要加虚拟目录。

                                    +
                                    • -
                          -
                          • -

                        • 我们要学习动态资源，必须先学习静态资源！

                          -
                          • -

                        • 静态资源：

                          +

                        • 给服务器使用：不需要加虚拟目录

                          +

                          比如说之前的请求转发

                            -
                          • HTML：用于搭建基础网页，展示页面的内容
                            • -
                          • CSS：用于美化页面，布局页面
                            • -
                          • JavaScript：控制页面的元素，让页面有一些动态的效果
                            • +
                          • 转发路径
                    -

                    静态网页概述

                    练习：用纯HTML写旅游网站首页

                    代码

                    <!DOCTYPE html>
                    <html lang="ch">
                    <head>
                        <meta charset="UTF-8">
                        <title>旅游网站</title>
                    </head>
                    <body>
                        <table>
                            <tr align="center">
                                <td><img src="./image/top_banner.jpg" alt="亲子周边旅游节" width="100%"></td>
                            </tr>
                            <tr>
                                <table>
                                    <tr align="center">
                                        <td width="25%"><img src="./image/logo.jpg" alt="logo" width="100%"></td>
                                        <td width="50%"><img src="./image/search.png" alt="search" width="100%"></td>
                                        <td width="25%"><img src="./image/hotel_tel.png" alt="hotel" width="100%"></td>
                                    </tr>
                                </table>
                            </tr>
                            <tr>
                                <table width="100%" bgcolor="orange" cellspacing="0" cellpadding="0">
                                    <tr align="center" height = "45">
                                        <td>首页</td>
                                        <td>门票</td>
                                        <td>酒店</td>
                                        <td>香港车票</td>
                                        <td>出境游</td>
                                        <td>国内游</td>
                                        <td>港澳游</td>
                                        <td>抱团定制</td>
                                        <td>全球自由行</td>
                                        <td>收藏排行榜</td>
                                    </tr>
                                </table>
                            </tr>
                            <tr>
                                <img src="./image/banner_3.jpg" alt="亲子周边旅游节" width="100%">
                            </tr>
                            <tr>
                                <table>
                                    <tr>
                                        <td align="right" width="20%"><img src="./image/icon_5.jpg" alt="亲子周边旅游节" width="100%"></td>
                                        <td width="80%">黑马精选</td>
                                    </tr>
                                </table>
                                <hr color="orange">
                            </tr>
                            <tr>
                                <table>
                                    <tr>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_1.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_1.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_1.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                    </tr>
                                </table>
                            </tr>
                            <tr>
                                <table>
                                    <tr>
                                        <td align="right" width="20%"><img src="./image/icon_6.jpg" alt="亲子周边旅游节" width="100%"></td>
                                        <td width="80%">国内游</td>
                                    </tr>
                                </table>
                                <hr color="orange">
                            </tr>
                            <tr>
                                <table align="center" width="95%">
                                    <tr>
                                        <td rowspan="2" width = "25%">
                                            <img src="./image/guonei_1.jpg" alt="亲子周边旅游节">
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                    </tr>
                                </table>
                            </tr>
                            <tr>
                                <table>
                                    <tr>
                                        <td align="right" width="20%"><img src="./image/icon_7.jpg" alt="亲子周边旅游节" width="100%"></td>
                                        <td width="80%">境外游</td>
                                    </tr>
                                </table>
                                <hr color="orange">
                            </tr>
                            <tr>
                                <table align="center" width="95%">
                                    <tr>
                                        <td rowspan="2" width = "25%">
                                            <img src="./image/jiangwai_1.jpg" alt="亲子周边旅游节">
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                        <td>
                                            <div>
                                                <img src="./image/jiangxuan_2.jpg" alt="" width="100%">
                                                <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                                <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                        </td>
                                    </tr>
                                </table>
                            </tr>
                            <tr>
                                <img src="./image/footer_service.png" alt="" width="100%">
                            </tr>
                            <tr>
                                <table bgcolor="orange" width="100%" height = 75>
                                    <tr align="center">
                                        <td>
                                            <font color="gray" size = 2>江苏传智播客教育科技股份有限公司 版权所有Copyright 2006-2018&copy;, All Rights Reserved 苏ICP备16007882</font>
                                        </td>
                                    </tr>
                                </table>
                            </tr>
                        </table>
                    </body>
                    </html>
                    - -

                    注意点

                      -

                    1. 布局

                      -

                      页面布局使用table标签。这点让我感觉非常新奇。

                      -

                      而且表格布局可以嵌套，也即每一行可以是一个新的表格。

                      -
                      2. -

                    2. 图片适应屏幕宽度

                      -

                      只需在img标签加个width=”100%”的属性即可。如：

                      -
                      <img src="./image/top_banner.jpg" width="100%">
                      3. -
                    -

                    表单

                    注意

                      -

                    1. 表项中的数据要被提交的话，必须指定其名称

                      -

                      image-20221223161847622

                      -

                      也即一定要有属性name。

                      -
                      2. -

                    2. 关于from的属性

                      -

                      image-20221223162035569

                      -
                      3. -

                    3. 一般都这么写

                      -

                      image-20221223165046277

                    -

                    练习

                    image-20221223171603366

                    -
                    <!DOCTYPE html>
                    <html lang="ch">
                    <head>
                        <meta charset="UTF-8">
                        <title>注册界面</title>
                    </head>
                    <body>
                        <form action="#">
                            <table border="1" cellpadding="1" cellspacing="1">
                                <tr>
                                    <td>
                                        <label for="username">用户名:</label>
                                    </td>
                                    <td>
                                        <input type="text" id="username" name="username" placeholder="请输入用户名">
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        <label for="password">密码：</label>
                                    </td>
                                    <td>
                                        <input type="password" id="password" name="password" placeholder="请输入密码">
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        <label for="email">邮箱：</label>
                                    </td>
                                    <td>
                                        <input type="email" id="email" name="email" placeholder="请输入邮箱">
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        <label for="name">姓名：</label>
                                    </td>
                                    <td>
                                        <input type="text" id="name" name="name" placeholder="请输入姓名">
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        <label for="phone_number">手机号：</label>
                                    </td>
                                    <td>
                                        <input type="text" id="phone_number" name="phone_number" placeholder="请输入手机号">
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        性别：
                                    </td>
                                    <td>
                                        <input type="radio" name="gender" value="1">女
                                        <input type="radio" name="gender" value="2">男
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        <label for="birthday">出生日期：</label>
                                    </td>
                                    <td>
                                        <input type="date" name="birthday" id="birthday">
                                    </td>
                                </tr>
                                <tr>
                                    <td>
                                        <label for="certification">验证码：</label>
                                    </td>
                                    <td>
                                        <input type="text" name="certification" id="certification">
                                        <img src="./image/verify_code.jpg" >
                                    </td>
                                </tr>
                                <tr align="center">
                                    <td colspan="2">
                                        <input type="image" src="./image/regbtn.jpg">
                                    </td>
                                </tr>
                            </table>
                        </form>

                    </body>
                    </html>
                    +
                    服务器输出字符数据到浏览器
                    @WebServlet("/responseDemo4")
                    public class ResponseDemo4 extends HttpServlet {
                        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

                            //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
                            response.setCharacterEncoding("utf-8");

                            //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
                            response.setHeader("content-type","text/html;charset=utf-8");

                            /* 也有设置编码的简单形式
                            //简单的形式，设置编码
                            response.setContentType("text/html;charset=utf-8");
                            */

                            //1.获取字符输出流
                            PrintWriter pw = response.getWriter();
                            //2.输出数据
                            //pw.write("<h1>hello response</h1>");
                            pw.write("你好啊啊啊 response");
                        }

                        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                            this.doPost(request,response);
                        }
                    }
                    -

                    CSS

                    盒子模型

                    盒

                    image-20221223204733649

                    -

                    练习：注册页面

                    image-20221223223128861

                    -
                    <!DOCTYPE html>
                    <html lang="ch">
                    <head>
                        <meta charset="UTF-8">
                        <title>注册界面</title>
                        <link rel="stylesheet" href="./2.css">
                    </head>
                    <body>
                    <div id="log_in_box">
                        <div id="log_in_text">
                            <div id="log_in_text1">
                                新用户注册
                            </div>
                            <div id="log_in_text2">
                                USER REGISTER
                            </div>
                        </div>

                        <div id="log_in_text3">
                            已有账号？<font color = red>立即登录</font>
                        </div>
                        <div id="log_in_table">
                            <form>
                                <table>
                                    <tr>
                                        <td class="td_left"><label for="username">用户名</label></td>
                                        <td class="td_right"><input type="text" name="username" id="username" placeholder="请输入用户名"></td>
                                    </tr>

                                    <tr>
                                        <td class="td_left"><label for="password">密码</label></td>
                                        <td class="td_right"><input type="password" name="password" id="password" placeholder="请输入密码"></td>
                                    </tr>

                                    <tr>
                                        <td class="td_left"><label for="email">Email</label></td>
                                        <td class="td_right"><input type="email" name="email" id="email" placeholder="请输入邮箱"></td>
                                    </tr>

                                    <tr>
                                        <td class="td_left"><label for="name">姓名</label></td>
                                        <td class="td_right"><input type="text" name="name" id="name" placeholder="请输入姓名"></td>
                                    </tr>

                                    <tr>
                                        <td class="td_left"><label for="tel">手机号</label></td>
                                        <td class="td_right"><input type="text" name="tel" id="tel" placeholder="请输入手机号"></td>
                                    </tr>

                                    <tr>
                                        <td class="td_left"><label>性别</label></td>
                                        <td class="td_right">
                                            <input type="radio" name="gender" value="male"> <span class="choice">男</span>
                                            <input type="radio" name="gender" value="female"> <span class="choice">女</span>
                                        </td>
                                    </tr>

                                    <tr>
                                        <td class="td_left"><label for="birthday">出生日期</label></td>
                                        <td class="td_right"><input type="date" name="birthday" id="birthday" placeholder="请输入出生日期"></td>
                                    </tr>

                                    <tr>
                                        <td class="td_left"><label for="checkcode" >验证码</label></td>
                                        <td class="td_right"><input type="text" name="checkcode" id="checkcode" placeholder="请输入验证码">
                                            <img id="img_check" src="img/verify_code.jpg">
                                        </td>
                                    </tr>


                                    <tr>
                                        <td colspan="2" align="center"><input type="submit" value="注册" id="submit"></td>
                                    </tr>
                                </table>
                            </form>
                        </div>
                    </div>
                    </body>
                    </html>
                    +
                    服务器输出字节数据到浏览器
                    @WebServlet("/responseDemo5")
                    public class ResponseDemo5 extends HttpServlet {
                        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                            //依然要保证编码一致
                            response.setContentType("text/html;charset=utf-8");

                            //1.获取字节输出流
                            ServletOutputStream sos = response.getOutputStream();
                            //2.输出数据
                            sos.write("你好".getBytes("utf-8"));
                        }

                        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                            this.doPost(request,response);
                        }
                    }
                    -
                    *{
                        margin: 0px;
                        padding: 0px;
                        /*防止大小因padding变化*/
                        box-sizing: border-box;
                    }
                    body{
                        z-index: 0;
                        background-image: url("./img/login_bg.png");
                    }
                    #log_in_box {
                        border: 9px solid darkgray;
                        z-index: 100;
                        width: 987px;
                        height: 590px;
                        /*让div水平居中*/
                        margin: auto;
                        margin-top: 20px;
                        padding: 15px;
                        background: white;

                    }

                    #log_in_table {
                        margin-top: 96px;
                        margin-left: 300px;
                    }

                    #log_in_text3{
                        font-size: 12px;
                        float: right;
                    }

                    #log_in_text > div:first-child{
                        margin-right: 0px;
                        width: 150px;
                        color: orange;
                        font-size: 25px;
                    }
                    #log_in_text > div:last-child{
                        margin-right: 0px;
                        width: 200px;
                        color: darkgray;
                        font-size: 17px;
                        font-family: "Arial Black";
                    }

                    #log_in_text{
                        margin: 0px;
                        display:inline;
                        float: left;
                    }

                    /*此处一定得是选择input，不能是选择.td_right，因为这样才能覆盖掉input原有的那个丑边框*/
                    input {
                        padding: 5px;
                        align-self: center;
                        border: 1px solid lightgrey;
                        height: 35px;
                        border-radius: 6px;
                        margin: 3px;
                        margin-left: 15px;
                        /*解决了radio的选框和文本不对齐。*/
                        vertical-align: middle;
                    }

                    .td_left{
                        color: slategrey;
                        text-align: right;
                    }

                    .choice{
                        font-size: 15px;
                    }

                    #checkcode{
                        width: 100px;
                        font-size: 15px;
                    }

                    #img_check{
                        vertical-align:middle;
                    }

                    #submit{
                        margin-top: 15px;
                        margin-left: 15px;
                        margin-right: 155px;
                        color: transparent;
                        width: 100px;
                        background-image: url("./img/regbtn.jpg");
                    }
                    +
                    验证码
                    @WebServlet("/demo1")
                    public class ServletDemo extends HttpServlet {
                        @Override
                        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                            //验证码图片大小
                            final int width = 100;
                            final int height = 50;

                            /* 绘制验证码 */
                            BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
                            Graphics pen = image.getGraphics();
                            //绘制背景
                            pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
                            pen.fillRect(0,0,width,height);
                            //绘制边框
                            pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
                            pen.drawRect(0,0,width-1,height-1);
                            //随机填充字母数字
                            String source = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890";
                            for (int i = 1; i <= 4; i++){
                                int index = (int)(Math.random()*source.length());
                                pen.drawString(source.substring(index,index+1),20*i,27);
                            }
                            //画干扰色线
                            pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
                            for (int i = 0; i < 5; i++){
                                pen.drawLine((int)(Math.random()*width),(int)(Math.random()*height),(int)(Math.random()*width),(int)(Math.random()*height));
                            }

                            //将图片输出
                            ImageIO.write(image,"jpg",resp.getOutputStream());
                        }

                        @Override
                        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                            doGet(req,resp);
                        }
                    }
                    -

                    JavaScript

                    对象

                    function
                    1. 创建：
-   1. var fun = new Function(形式参数列表,方法体);  //忘掉吧
-   2. function 方法名称(形式参数列表){
-          方法体
-      }
+
                    <!DOCTYPE html>
                    <html lang="en">
                    <head>
                        <meta charset="UTF-8">
                        <title>Title</title>
                    </head>
                    <body>
                    <img id="img" src="/practice_war/demo1"/>
                    <a href="" id = "a">看不清？换一张</a>
                    <script>
                      window.onload = function (){
                        let img = document.getElementById("img");
                        let a = document.getElementById("a");
                        img.onclick = function (){
                          //加时间戳作为请求参数，为了防止浏览器不更换图片缓存
                          img.src = "/practice_war/demo1?"+new Date().getTime();
                        }
                        a.onclick = img.onclick;
                      }
                    </script>
                    </body>
                    </html>
                    
 
-   3. var 方法名 = function(形式参数列表){
-           方法体
-      }
-2. 方法：
+
                    ServletContext对象
                    概念
                    代表整个web应用，可以和servlet容器（服务器）通信
                    
+
                    获取
                    通过request对象获取
                    ServletContext getServletContext()
                    
 
-3. 属性：
-   length:代表形参的个数
-4. 特点：
-   1. 方法定义是，形参的类型不用写,返回值类型也不写。
-   2. 方法是一个对象，如果定义名称相同的方法，会覆盖
-   3. 在JS中，方法的调用只与方法的名称有关，和参数列表无关
-   4. 在方法声明中有一个隐藏的内置对象（数组），**arguments**,封装所有的实际参数
-5. 调用：
-   方法名称(实际参数列表);
+
                    通过HttpServlet获取
                    this.getContext();
                    
+
+
                    功能
                    获取MIME类型
                    MIME是在互联网通信过程中定义的一种文件数据类型
                    
+
                            * 格式： 大类型/小类型   text/html        image/jpeg
 
                    
-
                    /**
                    * 求任意个数的和
                    */
                    function add (){
                        var sum = 0;
                        for (var i = 0; i < arguments.length; i++) {
                            sum += arguments[i];
                        }
                        return sum;
                    }

                    var sum = add(1,2,3,4);
                    alert(sum);
                    
+
                    /*
                    @param: 文件的后缀扩展名，如.txt
                    */
                    String getMimeType(String file);
                    
 
-
                    Global
                      
-
                    1. 特点：全局对象，这个Global中封装的方法不需要对象就可以直接调用。  方法名();
                      
+
                      image-20230107010006874
                      
+
                      mime映射存在了服务器的xml文件中。
                      
+
                      使用案例：
                      
+
                      System.out.println(this.getServletContext().getMimeType("a.txt"));
                      
+
+
+
+
                      共享数据
                      ServletContext是一个域对象，可以用来共享数据。
                      
+
                      ServletContext代表着服务器，因而它的生命周期跟随服务器关闭而灭亡。ServletContext可以共享所有请求的数据。也就是说，任何一次请求，任何用户，看到的ServletContext域都是同一个。
                      
+
                      这样大的效果也使得我们需要更加谨慎地使用它。一旦数据存入ServletContext域，就只会在服务器关闭后才会消亡，很耗内存。
                      
+
                      获取文件的真实（服务器）路径
                      String getRealPath();
                      
+
+
                      经测试发现，这东西只是起了一个字符串拼接的作用，是不会帮忙检查文件是否存在的。
                      
+
                      学到这我顺便看了看文件放在不同的地方最后应该如何访问：
                      
+
                      image-20230107012903495
                      
+
                      这是最终部署项目文件夹的结构：
                      
+
                      image-20230107013010276
                      
+
                      可以看到只有bcd被保留了。它们的目录要这样获取：
                      
+
                          @Override
                          protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                              ServletContext context = this.getServletContext();

                              System.out.println(context.getRealPath("/WEB-INF/classes/b.txt"));
                              System.out.println(context.getRealPath("/c.txt"));
                              System.out.println(context.getRealPath("/WEB-INF/d.txt"));
                          }
                      /*输出结果：
                      D:\aWorkStorage\etc\apache-tomcat-8.5.83\webapps\practice_war\WEB-INF\classes\b.txt
                      D:\aWorkStorage\etc\apache-tomcat-8.5.83\webapps\practice_war\c.txt
                      D:\aWorkStorage\etc\apache-tomcat-8.5.83\webapps\practice_war\WEB-INF\d.txt
                      是我的电脑里tomcat的目录
                      */
                      
+
+
                      案例：文件下载
                      要求
                        
+
                      • 文件下载需求：
                          
+
                        1. 页面显示超链接
                          2. 
+
                        2. 点击超链接后弹出下载提示框
                          3. 
+
                        3. 完成图片文件下载，那种会存到你电脑download目录下，而不是直接加载出来的
                          4. 
+
                        
 
                        • 
-
                      • 方法：
                        encodeURI():url编码
                        decodeURI():url解码
                        
-
                        encodeURIComponent():url编码,编码的字符更多
                        decodeURIComponent():url解码
                        
-
                        parseInt():将字符串转为数字
                        
+
                      
+
                      image-20230201170701909
                      
+
                      用户点击下载->请求发送给某个servlet，servlet修改response->tomcat响应用户，传递的图片资源按照response的方法打开
                      
+
                      代码
                      说实话看了感觉有点难以下手，主要还是完全不知道html和servlet怎么交互造成的，看了老师讲解才有点恍然大悟。
                      
+
                      我们可以把a标签以重定向的角度去看。它会新建一个request，然后发送到它的href中的那个url。在此处我们将url设置为/practice_war/download?filename=1.jpg，也即要以GET的方式发送给download，请求体为filename=1.jpg。然后servlet执行结束后，就会将信息存储在resp中返回给tomcat，由tomcat发送给用户。
                      
+
                      html
                      <body>
                      <a href="/practice_war/download?filename=1.jpg" id = "a">点击下载图片</a>
                      </body>
                      
+
+
                      servlet
                      思路：
                      
+
                      获取要下载的资源，并且将其输入到resp的stream中。
                      
+
                      有一点需要非常注意：
                      
+
                      resp.setContentType(this.getServletContext().getMimeType(path));
                      resp.setHeader("content-disposition","attachment;filename="+name);
                      
+
+
                      必须要在把资源输入到resp的stream前设置好，精确来说是调用sos.write前设置好，不然无法起作用。
                      
+
                      猜测是因为可能resp会根据disposition方式的不同而自动决策write的方式。
                      
+
                      @Override
                      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                          //获取要下载的资源名称
                          String name = req.getParameter("filename");

                          //获取路径
                          String path = this.getServletContext().getRealPath("/img/"+name);
                          //使用字节流
                          FileInputStream fis = new FileInputStream(path);
                          //输出数据

                          resp.setContentType(this.getServletContext().getMimeType(path));
                          resp.setHeader("content-disposition",
                                         "attachment;filename="+
                                         // 为了防止中文乱码，需要针对不同的浏览器来进行编码
                                         DownLoadUtils.getFileName(req.getHeader("user-agent"),name));

                          //获取字节输出流
                          ServletOutputStream sos = resp.getOutputStream();
                          byte[] buff = new byte[1024];
                          int len = 0;
                          while((len = fis.read(buff))!=-1){
                              sos.write(buff,0,len);
                          }
                          //释放资源
                          fis.close();

                          //        resp.setContentType(this.getServletContext().getMimeType(path));
                          //        resp.setHeader("content-disposition","attachment;filename="+name);
                      }
                      
+
+
                      会话
                      会话：一次会话中包含多次请求和响应。
                      
 
                        
-
                      • 逐一判断每一个字符是否是数字，直到不是数字为止，将前边数字部分转为number
                        isNaN():判断一个值是否是NaN
                          
-
                        • NaN六亲不认，连自己都不认。NaN参与的==比较全部问false
                          • 
+
                        • 一次会话：浏览器第一次给服务器资源发送请求，会话建立，直到有一方断开为止
                          
+
                          • 
+
                        • 功能：请求之间本来是相互独立的。将多次请求组织在一次会话中，就可以让请求之间进行数据的共享。
                          
+
                          • 
+
                        • 方式：
                          
+
                            
+
                          • 客户端会话技术    Cookie
                            
+
                            把数据存进客户端
                            
+
                            • 
+
                          • 服务器端会话技术 Session
                            
+
                            把数据存进服务器端
                            
+
                            • 
+
                          
+
                          • 
+
                        
+
                        概念
                        客户端会话技术，将数据保存到客户端
                        
+
                        快速入门
                          
+
                        • 使用步骤：
                          
+
                            
+
                          1. 创建Cookie对象，绑定数据【为了从服务器端发送cookie给客户端】
                              
+
                            • new Cookie(String name, String value) 
                              • 
+
                            • 可以看到，Cookie其实就是一种name-value这样的键值对对象
                              • 
 
                            
 
                            2. 
+
                          2. 发送Cookie对象【因为要发送给客户端，所以应该在response里存】
                              
+
                            • response.addCookie(Cookie cookie) 
                              • 
 
                            
-
                            eval():讲 JavaScript 字符串，并把它作为脚本代码来执行。
                            
-
                            var str = "http://www.baidu.com?wd=传智播客";
                            var encode = encodeURI(str);
                            document.write(encode +"<br>");//%E4%BC%A0%E6%99%BA%E6%92%AD%E5%AE%A2
                            var s = decodeURI(encode);
                            document.write(s +"<br>");//传智播客


                            var str1 = "http://www.baidu.com?wd=传智播客";
                            var encode1 = encodeURIComponent(str1);
                            document.write(encode1 +"<br>");//%E4%BC%A0%E6%99%BA%E6%92%AD%E5%AE%A2
                            var s1 = decodeURIComponent(encode);
                            document.write(s1 +"<br>");//传智播客

                            var jscode = "alert(123)";
                            eval(jscode);
                            3. 
+
+
                          3. 获取Cookie，拿到数据【因为是来自客户端，所以要从request里要】
                              
+
                            • Cookie[]  request.getCookies()  
                              • 
+
                            
+
                            4. 
 
                          
-
                          DOM
                          image-20221224162341993
                          
-
                          image-20221224162540306
                          
-
                          document
                          获取元素对象
                          getElementById();
                          getElementsByTagName();//通过标签名
                          getElementsByClassName();
                          getElementsByName();//注意是数组
                          
-
-
                          创建DOM对象
                          createAttribute(name);
                          createComment();
                          createElement();
                          createTextNode();
                          
-
-
                          Element
                          removeAttribute();
                          setAttribute(属性名,属性值);
                          
-
-
                          Node
                          说了树结构后，这个就好理解多了。
                          
-
                          image-20221224164239507
                          
-
                          练习：动态表格
                          <!DOCTYPE html>
                          <html lang="ch">
                          <head>
                              <meta charset="UTF-8">
                              <title>动态表格</title>
                              <style>
                                  #input{
                                      width: 60%;
                                      margin: auto;
                                      margin-top: 50px;
                                  }
                                  table{
                                      margin: auto;
                                      margin-top: 100px;
                                      width: 70%;
                                      text-align: center;
                                  }
                              </style>
                          </head>
                          <body>
                              <div id="input">
                                  <input type="text" placeholder="请输入编号"  id="id">
                                  <input type="text" placeholder="请输入姓名" id="name">
                                  <input type="text" placeholder="请输入性别" id="gender">
                                  <input type="button" id="add_but" value="添加">
                              </div>
                              <table border="1px solid black"  id="table">
                                  <tr>
                                      <title>学生信息表</title>
                                      <td>编号</td>
                                      <td>姓名</td>
                                      <td>性别</td>
                                      <td>操作</td>
                                  </tr>
                              </table>
                              <script>
                                  //获取表对象
                                  let table = document.getElementById("table");

                                  //最后那列删除要用很多次，所以这里只写一份原始的，之后要用再copy del_col对象即可。
                                  //但是要注意，js的深拷贝 object.cloneNode(true)是不会拷贝事件绑定的
                                  //所以事件绑定不得不放在下面的函数里做了
                                  let del_col = document.createElement("td");
                                  let del_col_a = document.createElement("a");
                                  del_col_a.href="javascript:void(0);";
                                  del_col_a.innerHTML="删除";
                                  del_col.appendChild(del_col_a);

                                  //删除列
                                  function del_row(obj){
                                      let target = obj.parentNode.parentNode;
                                      table.removeChild(target);
                                  }
                                  //添加行
                                  function add_row(id,name,gender){
                                      if (id=="" || name=="" || gender=="") return;
                                      let row = document.createElement("tr");
                                      let col1 = document.createElement("td");
                                      let col2 = document.createElement("td");
                                      let col3 = document.createElement("td");
                                      col1.innerHTML = id;
                                      col2.innerHTML = name;
                                      col3.innerHTML = gender;

                                      //为“删除”绑定事件
                                      let col4 = del_col.cloneNode(true);
                                      col4.lastChild.onclick = function(){
                                          //通过this定位。此时this指代a标签。
                                          //如果在del_row内把obj换成this反倒是不行的，因为那时候的this会指代的是window
                                          del_row(this);
                                      };

                                      row.appendChild(col1);
                                      row.appendChild(col2);
                                      row.appendChild(col3);
                                      row.appendChild(col4);

                                      table.appendChild(row);
                                  }

                                  //为“添加”按钮绑定事件
                                  document.getElementById("add_but").onclick = function(){
                                      add_row(document.getElementById("id").value,
                                          document.getElementById("name").value,
                                          document.getElementById("gender").value);
                                  };
                              </script>
                          </body>
                          </html>
                          
-
-
                          老师标答值得学习借鉴的点：
                          
-
                          //使用innerHTML添加
                          document.getElementById("btn_add").onclick = function() {
                              //2.获取文本框的内容
                              var id = document.getElementById("id").value;
                              var name = document.getElementById("name").value;
                              var gender = document.getElementById("gender").value;

                              //获取table
                              var table = document.getElementsByTagName("table")[0];

                              //追加一行
                              table.innerHTML += "<tr>\n" +
                                  "        <td>"+id+"</td>\n" +
                                  "        <td>"+name+"</td>\n" +
                                  "        <td>"+gender+"</td>\n" +
                                  "        <td><a href=\"javascript:void(0);\" onclick=\"delTr(this);\" >删除</a></td>\n" +
                                  "    </tr>";
                          }
                          
-
-
                          事件
                          练习：全选/全不选/反选+行变色
                          image-20221225192124809
                          
-
                          <!DOCTYPE html>
                          <html lang="ch">
                          <head>
                              <meta charset="UTF-8">
                              <title>动态表格</title>
                              <style>
                                  #input{
                                      width: 60%;
                                      margin: auto;
                                      margin-top: 50px;
                                  }
                                  table{
                                      margin: auto;
                                      margin-top: 100px;
                                      width: 70%;
                                      text-align: center;
                                  }
                              </style>
                          </head>
                          <body>
                          <div id="input">
                              <input type="text" placeholder="请输入编号"  id="id">
                              <input type="text" placeholder="请输入姓名" id="name">
                              <input type="text" placeholder="请输入性别" id="gender">
                              <input type="button" id="add_but" value="添加">
                          </div>
                          <table border="1px solid black"  id="table">
                              <tr>
                                  <td>选择</td>
                                  <td>编号</td>
                                  <td>姓名</td>
                                  <td>性别</td>
                                  <td>操作</td>
                              </tr>
                              <tr>
                                  <td><input type="checkbox" class="box"></td>
                                  <td>1</td>
                                  <td>Lily</td>
                                  <td>female</td>
                                  <td><a href="#" >删除</a></td>
                              </tr>
                              <tr>
                                  <td><input type="checkbox" class="box"></td>
                                  <td>2</td>
                                  <td>Jack</td>
                                  <td>male</td>
                                  <td><a href="#" >删除</a></td>
                              </tr>
                              <tr>
                                  <td><input type="checkbox" class="box"></td>
                                  <td>3</td>
                                  <td>Peterson</td>
                                  <td>male</td>
                                  <td><a href="#" >删除</a></td>
                              </tr>
                              <tr>
                                  <td><input type="checkbox" class="box"></td>
                                  <td>4</td>
                                  <td>Mary</td>
                                  <td>female</td>
                                  <td><a href="#" >删除</a></td>
                              </tr>
                          </table>
                          <div style="text-align: center;margin-top: 20px">
                              <input type="button" id="select_all" value="全选">
                              <input type="button" id="select_none" value="全不选">
                              <input type="button" id="select_aside" value="反选">
                          </div>
                          <script>
                              window.onload = function (){
                                  //行变色
                                  let rows = document.getElementsByTagName("tr");
                                  for (let i = 0; i < rows.length; i++) {
                                      rows[i].onmouseover = function (){
                                          rows[i].setAttribute("style","background: pink");
                                      };
                                      rows[i].onmouseout = function (){
                                          rows[i].removeAttribute("style");
                                      }
                                  }

                                  //三个按钮
                                  let select_all = document.getElementById("select_all");
                                  let select_none = document.getElementById("select_none");
                                  let select_aside = document.getElementById("select_aside");
                                  let boxes = document.getElementsByClassName("box");

                                  select_all.onclick = function(){
                                      for (let i = 0; i < boxes.length; i++) {
                                          boxes[i].checked = 1;
                                      }
                                  };
                                  select_none.onclick = function(){
                                      for (let i = 0; i < boxes.length; i++) {
                                          boxes[i].checked = 0;
                                      }
                                  };
                                  select_aside.onclick = function(){
                                      for (let i = 0; i < boxes.length; i++) {
                                          boxes[i].checked = !(boxes[i].checked);
                                      }
                                  };
                              };
                          </script>
                          </body>
                          </html>
                          
+
                          • 
+
                        • 代码
                          
+
                          @WebServlet("/demo")
                          public class ServletDemo extends HttpServlet {
                              @Override
                              protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                  response.addCookie(new Cookie("password","abc123"));
                              }

                              @Override
                              protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                  this.doGet(request, response);
                              }
                          }
                          
 
-
                          练习：表单校验
                          <!DOCTYPE html>
                          <html lang="ch">
                          <head>
                              <meta charset="UTF-8">
                              <title>注册界面</title>
                              <link rel="stylesheet" href="./2.css">
                          </head>
                          <body>
                          <div id="log_in_box">
                              <div id="log_in_text">
                                  <div id="log_in_text1">
                                      新用户注册
                                  </div>
                                  <div id="log_in_text2">
                                      USER REGISTER
                                  </div>
                              </div>

                              <div id="log_in_text3">
                                  已有账号？<font color = red>立即登录</font>
                              </div>
                              <div id="log_in_table">
                                  <form id="form">
                                      <table>
                                          <tr>
                                              <td class="td_left"><label for="username">用户名</label></td>
                                              <td class="td_right"><input type="text" name="username" id="username" placeholder="请输入用户名"></td>
                                              <td></td>
                                          </tr>

                                          <tr>
                                              <td class="td_left"><label for="password">密码</label></td>
                                              <td class="td_right"><input type="password" name="password" id="password" placeholder="请输入密码"></td>
                                              <td></td>
                                          </tr>

                                          <tr>
                                              <td class="td_left"><label for="email">Email</label></td>
                                              <td class="td_right"><input type="email" name="email" id="email" placeholder="请输入邮箱"></td>
                                          </tr>

                                          <tr>
                                              <td class="td_left"><label for="name">姓名</label></td>
                                              <td class="td_right"><input type="text" name="name" id="name" placeholder="请输入姓名"></td>
                                          </tr>

                                          <tr>
                                              <td class="td_left"><label for="tel">手机号</label></td>
                                              <td class="td_right"><input type="text" name="tel" id="tel" placeholder="请输入手机号"></td>
                                          </tr>

                                          <tr>
                                              <td class="td_left"><label>性别</label></td>
                                              <td class="td_right">
                                                  <input type="radio" name="gender" value="male"> <span class="choice">男</span>
                                                  <input type="radio" name="gender" value="female"> <span class="choice">女</span>
                                              </td>
                                          </tr>

                                          <tr>
                                              <td class="td_left"><label for="birthday">出生日期</label></td>
                                              <td class="td_right"><input type="date" name="birthday" id="birthday" placeholder="请输入出生日期"></td>
                                          </tr>

                                          <tr>
                                              <td class="td_left"><label for="checkcode" >验证码</label></td>
                                              <td class="td_right"><input type="text" name="checkcode" id="checkcode" placeholder="请输入验证码">
                                                  <img id="img_check" src="img/verify_code.jpg">
                                              </td>
                                          </tr>


                                          <tr>
                                              <td colspan="2" align="center"><input type="submit" value="注册" id="submit"></td>
                                          </tr>
                                      </table>
                                  </form>
                              </div>
                          </div>

                          <script>
                              //在开始加载的时候绑定事件的好习惯
                              window.onload = function(){
                                  document.getElementById("form").onsubmit = function (){
                                      return checkUsername()&&checkPassword();
                                  };
                                  document.getElementById("username").onblur = checkUsername;
                                  document.getElementById("password").onblur = checkPassword;
                              }
                              let username = document.getElementById("username");
                              let password = document.getElementById("password");

                              function checkUsername(){
                                  let reg_username = /^\w{6,12}$/;
                                  let flag = reg_username.test(username.value);
                                  if (flag){
                                      username.parentNode.parentNode.lastElementChild.innerHTML = "<img src=\"./img/gou.png\" alt=\"\">";
                                  }
                                  else{
                                      username.parentNode.parentNode.lastElementChild.innerHTML = "<font color=\"red\">格式错误！</font>";
                                  }
                                  return flag;
                              }

                              function checkPassword(){
                                  let reg_username = /^\w{6,12}$/;
                                  let flag = reg_username.test(password.value);
                                  if (flag){
                                      password.parentNode.parentNode.lastElementChild.innerHTML = "<img src=\"./img/gou.png\" alt=\"\">";
                                  }
                                  else{
                                      password.parentNode.parentNode.lastElementChild.innerHTML = "<font color=\"red\">格式错误！</font>";
                                  }
                                  return flag;
                              }

                          </script>
                          </body>
                          </html>
                          
+
                          @WebServlet("/demo2")
                          public class ServletDemo2 extends HttpServlet {
                              @Override
                              protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                  System.out.println(request.getCookies());
                              }

                              @Override
                              protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                  this.doGet(request, response);
                              }
                          }
                          • 
+
                        • 得到效果
                          
+
                          运行服务器，首先访问/demo，然后在同一个浏览器再次访问/demo2，就可以在控制台看到输出。
                          
+
                          这个过程发生了什么呢？
                          
+
                          首先，访问/demo就相当于建立了会话。/demo的Servlet获取到请求之后，在response中将cookie填入。
                          
+
                          保持浏览器窗口不变，会话也不变。
                          
+
                          再次访问/demo2，cookie信息自动保存在request对象中。/demo2的Servlet获取到请求之后，在控制台中打印输出了cookie。
                          
+
                          • 
+
                        
+
                        细节学习
                        一次发送多个cookie
                        你看它那个API叫add，就知道数据结构差不多是个list，所以多次add就行。
                        
+
                        保存时间
                        默认情况下，浏览器关闭则cookie就马上被销毁。
                        
+
                        如果需要持久化存储：
                        
+
                        cookie.setMaxAge(int seconds)
                        
 
-
                        BOM
                        浏览器对象模型，将浏览器各个组成部分封装成对象。
                        
-
                        image-20221224152804747
                        
-
                        Window对象包含DOM对象。
                        
-
                        组成：Window、Navigator、Screen、History、Location
                        
-
                        Window
                        不需要创建，直接用window.使用，也可以直接用方法名。比如alert
                        
-
                        方法
                          
-
                        1. 与弹出有关的方法
                          
-
                          alert：弹出警告框； confirm：确认取消对话框。确定返回true；prompt：输入框。参数为输入提示，返回值为输入值。
                          
+
                          参数：
                          
+
                            
+
                          1. 正数：将Cookie数据写到硬盘的文件中。持久化存储。并指定cookie存活时间，时间到后，cookie文件自动失效
                            2. 
+
                          2. 负数：默认值
                            3. 
+
                          3. 零：删除cookie信息
                            4. 
+
                          
+
                          中文问题
                          在tomcat 8 之前 cookie中不能直接存储中文数据，需要将中文数据转码——一般采用URL编码(%E3)
                          
+
                          在tomcat 8 之后，cookie支持中文数据。
                          
+
                          获取范围
                            
+
                          1. 假设在一个tomcat服务器中，部署了多个web项目，那么在这些web项目中cookie能不能共享？
                            
+
                              
+
                            • 默认情况下cookie不能共享
                              
 
                              • 
-
                            • 与开关有关的方法
                              
-
                              close：关闭调用的window对象的浏览器窗口；open：打开新窗口，可传入URL，返回新的window对象
                              
+
                            • 共享方法：
                              
+
                              setPath(String path):设置cookie的获取范围。默认情况下，设置当前的虚拟目录
                              
+
                              如果要共享，则可以将path设置为”/“
                              
 
                              • 
-
                            • 定时器
                              
-
                              //只执行一次
                              setTimeout();
                              clearTimeout();
                              //间隔执行多次
                              setInterval();
                              clearInterval();
                              
+
                            
+
                            2. 
+
                          2. 不同的tomcat服务器间cookie共享问题？
                            
+
                            比如说：
                            
+image-20230221225514567
 
-
                            //一次性定时器
                            //setTimeout("fun();",2000);
                            var id = setTimeout(fun,2000);
                            //取消
                            clearTimeout(id);
                            function fun(){
                                alert('boom~~');
                            }

                            //循环定时器
                            var id = setInterval(fun,2000);
                            clearInterval(id);
                            3. 
+
                              
+
                            • setDomain(String path):如果设置一级域名相同，那么多个服务器之间cookie可以共享
                              
+
                              （setDomain(".baidu.com"),那么tieba.baidu.com和news.baidu.com中cookie可以共享）
                              
+
                              • 
+
                            
+
 
                          
-
                          属性
                            
-
                          1. 获取其他BOM对象
                            
-
                            history、location、navigator、screen
                            
+
                            作用和特点
                            特点：
                            
+
                              
+
                            1. cookie存储数据在客户端浏览器
                              
+
                              因而它相对不安全
                              
 
                              2. 
-
                            2. 获取DOM对象
                              
-
                              document
                              
+
                            3. 浏览器对于单个cookie 的大小有限制(4kb) 以及 对同一个域名下的总cookie数量也有限制(20个)
                              
 
                              4. 
 
                            
-
                            练习：轮播图
                            <!DOCTYPE html>
                            <html lang="ch">
                            <head>
                                <meta charset="UTF-8">
                                <title>轮播图</title>
                            </head>
                            <body>
                            <img src="./img/banner_1.jpg" width="100%" id="picture">
                            <script>
                                let pictures = ["./img/banner_1.jpg","./img/banner_2.jpg","./img/banner_3.jpg"];
                                let i = 0;
                                let img = document.getElementById("picture");
                                function change_picture(){
                                    img.src = pictures[(++i)%3];
                                }
                                setInterval(change_picture,2000);
                            </script>
                            </body>
                            </html>
                            
-
-
                            Location
                              
-
                            1. 刷新
                              
-
                              location.reload方法
                              
+
                              作用：
                              
+
                                
+
                              1. cookie一般用于存出少量的不太敏感的数据
                                
 
                                2. 
-
                              2. 设置或返回完整的url
                                
-
                                location.href属性
                                
+
                              3. 在不登录的情况下，完成服务器对客户端的身份识别
                                
+
                                比如说，以不登录情况下对某个网页进行属性设置，你下次打开的时候属性设置依然在，这是因为你的属性设置的cookie在设置后被存入到你的电脑中，下次访问该网页发出请求，服务器端就能根据请求中cookie里的属性设置信息来做出响应了。
                                
 
                                4. 
 
                              
-
                              练习：自动返回首页
                              <!DOCTYPE html>
                              <html lang="ch">
                              <head>
                                  <meta charset="UTF-8">
                                  <title>自动跳转</title>
                              </head>
                              <body>
                                  <div style="width: 235px; height: 100px; margin: auto">
                                      <span style="color: red" id="second">5</span>秒后，自动跳转首页
                                  </div>
                                  <script>
                                      let num = 5;
                                      let second = document.getElementById("second");
                                      function dao_ji_shi(){
                                          if (num == 0){
                                              location.href = "https://www.baidu.com/";
                                              clearInterval(id);
                                          }
                                          second.innerHTML = (num--);
                                      }
                                      let id = setInterval(dao_ji_shi,1000);
                                  </script>
                              </body>
                              </html>
                              
-
-
                              Bootstrap
                              web前端框架
                              
-
                              image-20221225160246028
                              
-
                              快速入门
                              image-20221225161243229
                              
-
                              基本模板：
                              
-
                              <!DOCTYPE html>
                              <html lang="zh-CN">
                              <head>
                                <meta charset="utf-8">
                                <meta http-equiv="X-UA-Compatible" content="IE=edge">
                                <meta name="viewport" content="width=device-width, initial-scale=1">
                                <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
                                <title>Bootstrap 101 Template</title>
                                
                                <link href="./css/bootstrap.min.css" rel="stylesheet">
                              </head>
                              <body>
                              <h1>你好，世界！</h1>

                              <script src="./jquery.min.js"></script>
                              <script src="js/bootstrap.min.js"></script>
                              </body>
                              </html>
                              
+
                              案例：记住上一次访问时间
                              需求：
                                      1. 访问一个Servlet，如果是第一次访问，则提示：您好，欢迎您首次访问。
                                      2. 如果不是第一次访问，则提示：欢迎回来，您上次访问时间为:显示时间字符串
                              
+
                              public class ServletDemo extends HttpServlet {
                                  @Override
                                  protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                      //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
                                      response.setCharacterEncoding("utf-8");

                                      //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
                                      response.setHeader("content-type","text/html;charset=utf-8");
                                      if(request.getCookies() != null)
                                          for(Cookie c : request.getCookies()){
                                              if(c.getName().equals("isfirst")){
                                                  response.getWriter()
                                                      .write("<h1>欢迎回来，您上次访问的时间为<h1>"+c.getValue());
                                                  break;
                                              }
                                          }
                                      else
                                          response.getWriter().write("<h1>你好！欢迎你！<h1>");

                                      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
                                      Date date1 = new Date();
                                      String currentTime = dateFormat.format(date1);

                                      response.addCookie(new Cookie("isfirst",currentTime));
                                  }

                                  @Override
                                  protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                      this.doGet(request, response);
                                  }
                              }
                              
 
-
                              响应式布局
                              实现依赖于栅格系统。
                              
-
                              栅格系统
                              将一行平均分成12个格子，可以指定元素占几个格子
                              
-
                              可以感受到，其实跟我们之前那个纯纯HTML做页面的思想是差不多的，都是把整个页面看做一个表，表有很多行，每行有不同的格子。
                              
-
                              基本原理
                                
-
                              1. 定义容器。相当于之前的table
                                2. 
-
                              
-
                                
-
                              • 容器分类：
                                
+
                                Session
                                概念
                                服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中。HttpSession
                                
+
                                应用场合
                                比如说购物网站的购物车这种，就会存在session。想想也是（
                                
 
                                  
-
                                1. container：两边留白
                                  2. 
-
                                2. container-fluid：每一种设备都是100%宽度
                                  3. 
+
                                3. session用于存储一次会话的多次请求的数据，存在服务器端
                                  
+
                                  比如说，当我们做重定向的时候，就可以选择用session共享数据（会话域）而非使用ServletContext（此范围过大）
                                  
+
                                  4. 
+
                                4. session可以存储任意类型，任意大小的数据
                                  
+
                                  5. 
+
                                5. session与Cookie的区别：
                                  
+
                                    
+
                                  1. session存储数据在服务器端，Cookie在客户端
                                    2. 
+
                                  2. session没有数据大小限制，Cookie有
                                    3. 
+
                                  3. session数据安全，Cookie相对于不安全
                                    4. 
 
                                  
 
                                  6. 
-
                              
-
                                
-
                              1. 定义行。相当于之前的tr   样式：row
                                2. 
-
                              2. 定义元素。指定该元素在不同的设备上，所占的格子数目。样式：col-设备代号-格子数目
                                3. 
 
                              
-
                                
-
                              • 设备代号：
                                
-
                                  
-
                                1. xs：超小屏幕 手机 (<768px)：col-xs-12
                                  2. 
-
                                2. sm：小屏幕 平板 (≥768px)
                                  3. 
-
                                3. md：中等屏幕 桌面显示器 (≥992px)
                                  4. 
-
                                4. lg：大屏幕 大桌面显示器 (≥1200px)
                                  5. 
+
                                  快速入门
                                    
+
                                  1. 获取HttpSession对象：
                                     HttpSession session = request.getSession();
                                    
+
                                    2. 
+
                                  2. 使用HttpSession对象：
                                    
+
                                      Object getAttribute(String name)  
                                      void setAttribute(String name, Object value)
                                      void removeAttribute(String name)

                                    #### 原理

                                    ![image-20230223102722575](./JavaWeb/image-20230223102722575.png)

                                    实现依赖于Cookie

                                    #### 细节

                                    前面说到，当客户端和服务器端有任何一端关闭之后，会话结束，在这种情况下，session在客户端和服务器端的保留情况不同。

                                    1. 当客户端关闭后，服务器不关闭，两次获取session是否为同一个？
                                      * 默认情况下。不是。
                                      * 如果需要相同，则可以创建Cookie,键为JSESSIONID，设置最大存活时间，让cookie持久化保存。
                                      	 ```java
                                         Cookie c = new Cookie("JSESSIONID",session.getId());
                                         c.setMaxAge(60*60);
                                         response.addCookie(c);
                                    3. 
+
                                  3. 客户端不关闭，服务器关闭后，两次获取的session是同一个吗？
                                    
+
                                    4. 
 
                                  
+
                                    
+
                                  • 不是同一个，但是要确保数据不丢失。tomcat自动（IDEA不会活化）完成以下工作
                                      
+
                                    • session的钝化：（序列化）
                                          * 在服务器正常关闭之前，将session对象序列化到硬盘上
+
                                      
 
                                      • 
 
                                    
-
                                    使用方法
                                    <!DOCTYPE html>
                                    <html lang="zh-CN">
                                    <head>
                                        <meta charset="utf-8">
                                        <meta http-equiv="X-UA-Compatible" content="IE=edge">
                                        <meta name="viewport" content="width=device-width, initial-scale=1">
                                        <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
                                        <title>Bootstrap HelloWorld</title>

                                        <!-- Bootstrap -->
                                        <link href="css/bootstrap.min.css" rel="stylesheet">


                                        <!-- jQuery (Bootstrap 的所有 JavaScript 插件都依赖 jQuery，所以必须放在前边) -->
                                        <script src="js/jquery-3.2.1.min.js"></script>
                                        <!-- 加载 Bootstrap 的所有 JavaScript 插件。你也可以根据需要只加载单个插件。 -->
                                        <script src="js/bootstrap.min.js"></script>
                                        <style>
                                            .inner{
                                                border:1px solid red;
                                            }

                                        </style>
                                    </head>
                                    <body>
                                        <!--1.定义容器-->
                                        <div class="container-fluid">
                                            <!--2.定义行-->
                                            <div class="row">
                                                <!--3.定义元素
                                                    在大显示器一行12个格子
                                                    在pad上一行6个格子
                                                -->
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <!--超出12个格子的部分自动换行-->
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                                <div class="col-lg-1 col-sm-2 inner">栅格</div>
                                            </div>

                                        </div>

                                    </body>
                                    </html>
                                    
-
-
                                    样式
                                    看文档。
                                    
-
                                    练习：用bootstrap优化旅游网站首页
                                    代码
                                    HTML
                                    <!DOCTYPE html>
                                    <html lang="zh-CN">
                                    <head>
                                      <meta charset="utf-8">
                                      <meta http-equiv="X-UA-Compatible" content="IE=edge">
                                      <meta name="viewport" content="width=device-width, initial-scale=1">
                                      <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
                                      <title>Bootstrap 101 Template</title>

                                      <link href="./css/bootstrap.min.css" rel="stylesheet">
                                      <link rel="stylesheet" href="./3.css">
                                    </head>
                                    <body>
                                    <div class="container-fluid">
                                      <div class="row">
                                        <img src="./image/top_banner.jpg" class="img-responsive" id="top">
                                      </div>

                                      <div class="row" id="top_2">
                                        <div class="col-md-3">
                                          <img src="./image/logo.jpg" class="img-responsive" id="logo">
                                        </div>
                                        <div class="col-md-6" id="search">
                                          <input type="text" placeholder="Search" id="search_text">
                                          <div id="search_but">
                                            <a href="#">搜索</a>
                                          </div>
                                        </div>
                                        <div class="col-md-3">
                                          <img src="./image/hotel_tel.png" alt="hotel">
                                        </div>
                                      </div>

                                      <div class="row">
                                        <nav class="navbar navbar-default">
                                          <div class="container-fluid">
                                            <!-- Brand and toggle get grouped for better mobile display -->
                                            <div class="navbar-header">
                                              <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
                                                <span class="sr-only">Toggle navigation</span>
                                                <span class="icon-bar"></span>
                                                <span class="icon-bar"></span>
                                                <span class="icon-bar"></span>
                                              </button>
                                              <a class="navbar-brand" href="#">传智播客</a>
                                            </div>

                                            <!-- Collect the nav links, forms, and other content for toggling -->
                                            <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
                                              <ul class="nav navbar-nav">
                                                <li><a href="#">Android <span class="sr-only">(current)</span></a></li>
                                                <li><a href="#">Android</a></li>
                                                <li><a href="#">Android</a></li>
                                                <li><a href="#">Android</a></li>
                                                <li><a href="#">Android</a></li>
                                                <li><a href="#">Android</a></li>
                                                <li><a href="#">Android</a></li>
                                              </ul>
                                            </div><!-- /.navbar-collapse -->
                                          </div><!-- /.container-fluid -->
                                        </nav>
                                      </div>

                                      <!--  轮播图-->
                                      <div class="row">
                                        <div id="carousel-example-generic" class="carousel slide" data-ride="carousel">
                                          <!-- Indicators -->
                                          <ol class="carousel-indicators">
                                            <li data-target="#carousel-example-generic" data-slide-to="0" class="active"></li>
                                            <li data-target="#carousel-example-generic" data-slide-to="1"></li>
                                            <li data-target="#carousel-example-generic" data-slide-to="2"></li>
                                          </ol>

                                          <!-- Wrapper for slides -->
                                          <div class="carousel-inner" role="listbox">
                                            <!--        注意只能有其中一张的class是active的-->
                                            <div class="item active">
                                              <img src="./image/banner_1.jpg" alt="...">
                                              <div class="carousel-caption">
                                              </div>
                                            </div>
                                            <div class="item">
                                              <img src="./image/banner_2.jpg" alt="...">
                                              <div class="carousel-caption">
                                              </div>
                                            </div>
                                            <div class="item">
                                              <img src="./image/banner_3.jpg" alt="...">
                                              <div class="carousel-caption">
                                              </div>
                                            </div>
                                          </div>

                                          <!-- Controls -->
                                          <a class="left carousel-control" href="#carousel-example-generic" role="button" data-slide="prev">
                                            <span class="glyphicon glyphicon-chevron-left" aria-hidden="true"></span>
                                            <span class="sr-only">Previous</span>
                                          </a>
                                          <a class="right carousel-control" href="#carousel-example-generic" role="button" data-slide="next">
                                            <span class="glyphicon glyphicon-chevron-right" aria-hidden="true"></span>
                                            <span class="sr-only">Next</span>
                                          </a>
                                        </div>
                                      </div>

                                      <div class="container">
                                        <div class="row">
                                          <img src="./image/icon_5.jpg" alt="亲子周边旅游节">
                                          <span class="text1">黑马精选</span>
                                          <hr>
                                        </div>
                                        <div class="row block">
                                          <div class="xuanchuan col-md-3">
                                            <img src="./image/jiangxuan_1.jpg" alt="" >
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                          </div>
                                          <div class="xuanchuan col-md-3">
                                            <img src="./image/jiangxuan_1.jpg" alt="" >
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                          </div>
                                          <div class="xuanchuan col-md-3">
                                            <img src="./image/jiangxuan_1.jpg" alt="">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                          </div>
                                          <div class="xuanchuan col-md-3">
                                            <img src="./image/jiangxuan_1.jpg" alt="">
                                            <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                            <font size = 3 color="#8b0000">￥899</font>
                                          </div>
                                        </div>


                                        <div class="row">
                                          <img src="./image/icon_6.jpg" alt="亲子周边旅游节">
                                          <span class="text1">国内游</span>
                                          <hr>
                                        </div>
                                        <div class="row">
                                          <div class="col-md-4">
                                            <img src="./image/guonei_1.jpg" alt="亲子周边旅游节">
                                          </div>
                                          <div class="col-md-8">
                                            <div class="xuanchuan col-md-4">
                                              <img src="./image/jiangxuan_2.jpg" alt="" >
                                              <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                              <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                            <div class="xuanchuan col-md-4">
                                              <img src="./image/jiangxuan_1.jpg" alt="" >
                                              <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                              <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                            <div class="xuanchuan col-md-4">
                                              <img src="./image/jiangxuan_1.jpg" alt="" >
                                              <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                              <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                            <div class="xuanchuan col-md-4">
                                              <img src="./image/jiangxuan_1.jpg" alt="" >
                                              <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                              <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                            <div class="xuanchuan col-md-4">
                                              <img src="./image/jiangxuan_1.jpg" alt="">
                                              <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                              <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                            <div class="xuanchuan col-md-4">
                                              <img src="./image/jiangxuan_1.jpg" alt="">
                                              <br>上海飞三亚五天4晚自由行(春节销售+亲子+蜜月+自由行)<br>
                                              <font size = 3 color="#8b0000">￥899</font>
                                            </div>
                                          </div>
                                        </div>
                                      </div>
                                      <div class="row">
                                        <img src="./image/footer_service.png" alt="" class="img-responsive">
                                        <div id="foot_text" class="col-md-12">
                                          <font color="gray" size = 2>江苏传智播客教育科技股份有限公司 版权所有Copyright 2006-2018&copy;, All Rights Reserved 苏ICP备16007882</font>
                                        </div>
                                      </div>
                                    </div>

                                    <script src="./jquery-3.2.1.min.js"></script>
                                    <script src="js/bootstrap.min.js"></script>
                                    </body>
                                    </html>
                                    
-
-
                                    CSS
                                    *{
                                        margin: 0px;
                                        padding: 0px;
                                    }

                                    #search{
                                        text-align: center;
                                    }

                                    #top_2{
                                        margin-top: 10px;
                                    }

                                    #search_text{
                                        border: 3px solid orange;
                                        width: 400px;
                                        height: 50px;
                                        margin-right: 0px;
                                        text-align: left;
                                        padding: 15px;
                                    }

                                    #search_but{
                                        margin: 0px;
                                        width: 90px;
                                        height: 50px;
                                        display: inline-block;
                                        background: orange;
                                        box-sizing: border-box;
                                        vertical-align: top;
                                        padding: 13px;
                                    }

                                    #search_but a{
                                        color: white;
                                    }

                                    .text1{
                                        font-size: 15px;
                                    }

                                    hr{
                                        margin: 3px;
                                        border: 1px solid orange;
                                        background: orange;
                                    }

                                    .xuanchuan{
                                        padding: 6px;
                                        margin: auto;
                                        height: 244px;
                                        border: 1px solid dimgray;
                                        text-align: center;
                                    }

                                    .xuanchuan img{
                                        width: 90%;
                                    }

                                    .block{
                                        text-align: center;
                                    }

                                    #foot_text{
                                        height: 60px;
                                        width: 100%;
                                        background: orange;
                                        text-align: center;
                                        padding: 15px;
                                    }

                                    .row{
                                        margin-top: 10px;
                                        margin-bottom: 10px;
                                    }
                                    
-
-
                                    注意点
                                    这东西写了我还挺久的。。。不过收获也挺多。
                                    
-
                                      
-
                                    1. text-align
                                      
-
                                      是一个css属性，我觉得挺好用的（。我不知道它精确是什么意思，但我发现它好像有种能让该元素下的子元素水平居中的效果。
                                      
 
                                      2. 
-
                                    2. 关于“容器”的理解
                                      
-
                                      上面说过，Bootstrap有个容器的概念，跟我们上面纯HTML的表格概念其实是很类似的。
                                      
-
                                      HTML的容器是表格标签，Bootsrap的容器是container-fluid和container类的标签。
                                      
-
                                      与HTML的表格相同，“容器”也是可以嵌套的。这点在本案例体现为一下两点：
                                      
-
                                      ① container中可以嵌套container-fluid。
                                      
-
                                      ​    案例中，页首-轮播图和页尾这两段是两边不留白的，轮播图-页尾这段是两边留白的。所以，我们就可以让整体为一个container容器，中间一段再用container-fluid容器包装起来。也即：
                                      
-
                                      <body>
                                      <div class="container-fluid">
                                        <div class="row"></div>
                                        <div class="container"></div>
                                        <div class="row"></div>
                                      </div>
                                      </body>
                                      
-
-
                                      注意，此处不要作死为了优雅统一性这样写：
                                      
-
                                      <div class="row container"></div>
                                      
+
                                  
+
                                          * 具体是会放在这里：
 
-
                                  也即多加一个row类。要不row的属性会覆盖掉container的。
                                  
-
                                  ② 对于“col-md-4”这些的理解
                                  
-
                                  image-20221225183910393
                                  
-
                                  在做这样的包含row-span元素的行时，之前的解决方案是采用表格嵌套。同样的，这里也可以采用容器嵌套。而此时，列的书写方式就比较特殊了。
                                  
-
                                  <div class="row">
                                       <div class="col-md-4">
                                         row-span的图片
                                       </div>
                                         
                                       <div class="col-md-8">
                                         <div class="col-md-4"></div>
                                         <div class="col-md-4"></div>
                                         <div class="col-md-4"></div>
                                         <div class="col-md-4"></div>
                                         <div class="col-md-4"></div>
                                         <div class="col-md-4"></div>
                                       </div>
                                     </div>
                                  
+      ![image-20230223104447097](./JavaWeb/image-20230223104447097.png)
+    
+* session的活化：（反序列化
+    * 在服务器启动后，将session文件转化为内存中的session对象即可。
 
-
                                  其实是非常直观的，相信以后你看到这段应该也能理解（。提示一点，栅格系统其实好像是相对于父类的。也就是说，不是“把整个页面分成12个格子”，而是，“把父类占有的空间分成12个格子”。
                                  
+我想，cookie应该在这点上不会像session这么做，因为cookie本质上是保存在客户端的数据，按理来说服务器端把cookie发出去之后就可以销毁了，在服务器序列化一点意义都没有。
+
                                  
+
                                    
+
                                  1. 销毁时间
                                    
+
                                      
+
                                    1. 服务器关闭
                                      
 
                                      2. 
-
                                    2. 关于hr标签
                                      
-
                                      使用css改颜色时应该写background: orange;而不是color: orange;。
                                      
+
                                    3. session对象调用invalidate() 。
                                      
 
                                      4. 
+
                                    4. session默认失效时间 30分钟
                                      选择性配置修改    
                                      
+
                                      可以在每个项目的子配置文件（如下图）或者总的项目的父配置文件apache-tomcat-8.5.83\conf\web.xml中配置
                                      
+
                                      image-20230223105053170
                                      
+
                                      <session-config>
                                           <session-timeout>30</session-timeout>
                                       </session-config>
                                      5. 
 
                                    
-
                                    XML
                                    xml叫做可扩展标签语言。它的全部标签都是自定义的。
                                    
-
                                    image-20221225220356932
                                    
-
                                    快速入门
                                      
-
                                    • 基本语法：
                                        1. xml文档的后缀名 .xml
-  2. xml第一行必须定义为文档声明
-  3. xml文档中有且仅有一个根标签
-  4. 属性值必须使用引号(单双都可)引起来
-  5. 标签必须正确关闭
-  6. xml标签名称区分大小写
-
                                      
 
                                      • 
+
                                  
+
                                  案例
                                  
+
                                  需求：
                                  
+
                                    
+
                                  1. 访问带有验证码的登录页面login.jsp
                                    2. 
+
                                  2. 用户输入用户名，密码以及验证码。
                                      
+
                                    • 如果用户名和密码输入有误，跳转登录页面，提示:用户名或密码错误
                                      • 
+
                                    • 如果验证码输入有误，跳转登录页面，提示：验证码错误
                                      • 
+
                                    • 如果全部输入正确，则跳转到主页success.jsp，显示：用户名,欢迎您
                                      • 
 
                                    
-
                                    <?xml version="1.0" encoding="utf-8" ?>

                                    <users>
                                        <user id="1">
                                            <name>zhangsan</name>
                                            <age>23</age>
                                            <gender>male</gender>
                                        </user>
                                        <user id="2">
                                            <name>zhangsan</name>
                                            <age>23</age>
                                            <gender>male</gender>
                                        </user>
                                        <user id="3">
                                            <name>zhangsan</name>
                                            <age>23</age>
                                            <gender>male</gender>
                                        </user>
                                    </users>
                                    
+
                                    3. 
+
                                  
+
                                  
+
                                  初见思路
                                  我们可以在服务器端使用session存储password和username的map，存储验证码图片编号和图片的map，然后用cookie携带验证码图片编号，在req中存储用户名和密码。
                                  
+
                                  正确思路
                                  感觉我上面的思路是没有充分利用到session的性质，仅仅把它作为在服务器端存储数据的工具，
                                  
+
                                  “在服务器端存储password和username的map，存储验证码图片编号和图片的map，然后用cookie携带验证码图片编号，在req中存储用户名和密码。”
                                  
+
                                  这样也依然成立，跟session没半毛钱关系。我们可以这样使用session：
                                  
+
                                    
+
                                  1. 在服务器端存储password和username的map，存储验证码图片编号和图片的map
                                    2. 
+
                                  2. 当会话建立，由于没有cookie，故而session第一次创建。我们在session内写入验证码对应的编号，把图片通过response发送给客户端。
                                    3. 
+
                                  3. 会话端输入图片验证码后，按下submit按键，验证码存入request域，向服务器端发送请求
                                    4. 
+
                                  4. 服务器端Servlet从请求中get到验证码，然后在session中get到当前验证码的图片编号，向一开始存储的map查询数据，这样就能验证验证码是否正确了
                                    5. 
+
                                  
+
                                  那么在这里为什么不用Cookie而使用session呢？大概是因为cookie不安全罢（慌乱）
                                  
+
                                  代码
                                  jsp
                                  <html lang="en">
                                  <head>
                                      <meta charset="UTF-8">
                                      <title>Title</title>
                                  </head>
                                  <body>
                                  <form action="/practice_war/loginServlet" method="post">
                                      name: <input type="text" name="username" id="username" placeholder="请输入用户名">
                                      password: <input type="password" name="password" id="password" placeholder="请输入密码">
                                      verifycode:<input type="text" name="verifycode" id="verifycode" placeholder="请输入验证码">

                                      <img id="img" src="/practice_war/check"/>

                                      <input type="submit" value="submit">
                                  </form>
                                  <script>
                                      window.onload = function(){
                                          document.getElementById("img").onclick = function(){
                                              this.src = "/practice_war/check?"+new Date().getTime();
                                          }
                                      }

                                  </script>
                                  </body>
                                  </html>
                                  
 
-
                                  细说
                                  语法
                                  文档声明
                                  常见属性：version[必须]、encoding、standalone[取值为yes和no，yes为依赖其他文件]
                                  
-
                                  属性
                                  id属性值唯一
                                  
-
                                  文本
                                  image-20221225222029698
                                  
-
                                  这种要转义来转义去的显然很麻烦。所以就需要用到CDATA区。
                                  
-
                                  CDATA区的文本会被原样展示。
                                  
-
                                  <code>

                                      <![CDATA[
                                              if(1 == 1 && 2 == 2){}
                                      ]]>

                                  </code>
                                  
+
                                  checkcode
                                  @WebServlet("/check")
                                  public class ServletDemo extends HttpServlet {
                                      @Override
                                      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                          //验证码图片大小
                                          final int width = 100;
                                          final int height = 50;

                                          /* 绘制验证码 */
                                          BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
                                          Graphics pen = image.getGraphics();
                                          //绘制背景
                                          pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
                                          pen.fillRect(0,0,width,height);
                                          //绘制边框
                                          pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
                                          pen.drawRect(0,0,width-1,height-1);
                                          //随机填充字母数字
                                          String source = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890";

                                          StringBuilder verifyAnswer = new StringBuilder();

                                          for (int i = 1; i <= 4; i++){
                                              int index = (int)(Math.random()*source.length());
                                              verifyAnswer = verifyAnswer.append(source.charAt(index));
                                              pen.drawString(source.substring(index,index+1),20*i,27);
                                          }
                                          //画干扰色线
                                          pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
                                          for (int i = 0; i < 5; i++){
                                              pen.drawLine((int)(Math.random()*width),(int)(Math.random()*height),(int)(Math.random()*width),(int)(Math.random()*height));
                                          }

                                          request.getSession().setAttribute("verifycode",verifyAnswer.toString());
                                          System.out.println("verify:"+verifyAnswer.toString());
                                          //将图片输出
                                          ImageIO.write(image,"jpg",response.getOutputStream());
                                      }

                                      @Override
                                      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                          this.doGet(request, response);
                                      }
                                  }
                                  
 
-
                                  约束
                                  只能写约束文件内的标签
                                  
-
                                  dtd
                                  文档
                                  //students标签里可以包含若干个student标签
                                  <!ELEMENT students (student*) >
                                  //student标签必须按顺序出现name，age，sex标签
                                  <!ELEMENT student (name,age,sex)>
                                  //name、age、sex都为字符串类型
                                  <!ELEMENT name (#PCDATA)>
                                  <!ELEMENT age (#PCDATA)>
                                  <!ELEMENT sex (#PCDATA)>
                                  //student标签有一个属性叫number，类型为ID,并且必须要有。类型为ID表示该属性值唯一。
                                  <!ATTLIST student number ID #REQUIRED>
                                  
+
                                  login
                                  @WebServlet("/loginServlet")
                                  public class loginServlet extends HttpServlet {
                                      @Override
                                      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                          HttpSession session = request.getSession();
                                          String verifycode = request.getParameter("verifycode");
                                          System.out.println(flag);

                                          String ans = session.getAttribute("verifycode");
                                          if (ans == null||!ans.equals(verifycode)){
                                              session.removeAttribute("verifycode");
                                              // 重定向到错误界面
                                              request.getRequestDispatcher("/fail_code").forward(request,response);
                                              return;
                                          }
                                          session.removeAttribute("verifycode");

                                          // 进行密码账号匹配处理
                                          String username = request.getParameter("username");
                                          String password = request.getParameter("password");
                                          System.out.println(username+"  "+password);
                                          if(UserDao.login(new User(username,password))){
                                              // 成功界面
                                              request.setAttribute("uname",username);
                                              request.getRequestDispatcher("/success").forward(request,response);
                                          }else{
                                              // 失败界面
                                              request.getRequestDispatcher("/fail").forward(request,response);
                                          }
                                      }

                                      @Override
                                      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                          this.doGet(request, response);
                                      }
                                  }
                                  
 
-
                                  引入方式
                                  //外部引入
                                  <!DOCTYPE 根标签名 SYSTEM "dtd文件的位置">
                                  <!DOCTYPE 根标签名 PUBLIC "dtd文件名字" "dtd文件的位置URL">
                                  
+
                                  老师的写法是将错误信息直接写在原登录界面，和我的略有不同：
                                  
+
                                  // in loginServlet
                                  if (!session.getAttribute("verifycode").equals(verifycode)){
                                      request.setAttribute("message","checkcode_fail");
                                      request.getRequestDispatcher("/login.jsp").forward(request,response);
                                      return;
                                  }
                                  
 
-
                                  或者可以直接在xml内部写：
                                  
-
                                  <?xml version="1.0" encoding="UTF-8" ?>
                                  <!DOCTYPE students SYSTEM "student.dtd">

                                  <!DOCTYPE students [

                                  		<!ELEMENT students (student+) >
                                  		<!ELEMENT student (name,age,sex)>
                                  		<!ELEMENT name (#PCDATA)>
                                  		<!ELEMENT age (#PCDATA)>
                                  		<!ELEMENT sex (#PCDATA)>
                                  		<!ATTLIST student number ID #REQUIRED>


                                  		]>
                                  <students>
                                  	
                                  	<student number="s001">
                                  		<name>zhangsan</name>
                                  		<age>abc</age>
                                  		<sex>hehe</sex>
                                  	</student>

                                  	<student number="s002">
                                  		<name>lisi</name>
                                  		<age>24</age>
                                  		<sex>female</sex>
                                  	</student>
                                  	
                                  </students>
                                  
+
                                  // in login.jsp
                                      <%
                                         String message = (String) request.getAttribute("message");
                                         if(message != null){
                                             if(message.equals("checkcode_fail")){
                                                 out.write("验证码错误！");
                                             }else if(message.equals("pass_fail")){
                                                 out.write("用户名或密码错误！");
                                             }
                                         }
                                      %>
                                  
 
-
                                  使用
                                  <student number="s001">
                                  	<name>zhangsan</name>
                                  	<age>abc</age>
                                  	<sex>hehe</sex>
                                  </student>

                                  <student number="s002">
                                  	<name>lisi</name>
                                  	<age>24</age>
                                  	<sex>female</sex>
                                  </student>
                                  
+
                                  以及success.jsp
                                  
+
                                  image-20230302233110661
                                  
+
                                  成功/两个失败
                                  仅以成功为例
                                  
+
                                  @WebServlet(value = "/success")
                                  public class SuccessServlet extends HttpServlet {
                                      @Override
                                      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                                          doPost(req,resp);
                                      }

                                      @Override
                                      protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                                          resp.setContentType("text/html;charset=utf-8");
                                          resp.getWriter().write("登录成功！"+req.getAttribute("uname")+",欢迎您");
                                      }
                                  }
                                  
 
-
                                  schema
                                  文档
                                  <?xml version="1.0"?>
                                  <xsd:schema xmlns="http://www.itcast.cn/xml"
                                          xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                                          targetNamespace="http://www.itcast.cn/xml" elementFormDefault="qualified">
                                      
                                      <xsd:element name="students" type="studentsType"/>
                                      //定义类型
                                      <xsd:complexType name="studentsType">
                                          //类型里面有有序序列
                                          <xsd:sequence>
                                              <xsd:element name="student" type="studentType" minOccurs="0" maxOccurs="unbounded"/>
                                          </xsd:sequence>
                                      </xsd:complexType>
                                      
                                      <xsd:complexType name="studentType">
                                          <xsd:sequence>
                                              <xsd:element name="name" type="xsd:string"/>
                                              <xsd:element name="age" type="ageType" />
                                              <xsd:element name="sex" type="sexType" />
                                          </xsd:sequence>
                                          <xsd:attribute name="number" type="numberType" use="required"/>
                                      </xsd:complexType>
                                      
                                      <xsd:simpleType name="sexType">
                                          <xsd:restriction base="xsd:string">
                                              //枚举类型
                                              <xsd:enumeration value="male"/>
                                              <xsd:enumeration value="female"/>
                                          </xsd:restriction>
                                      </xsd:simpleType>
                                      
                                      <xsd:simpleType name="ageType">
                                          <xsd:restriction base="xsd:integer">
                                              <xsd:minInclusive value="0"/>
                                              <xsd:maxInclusive value="256"/>
                                          </xsd:restriction>
                                      </xsd:simpleType>
                                      
                                      <xsd:simpleType name="numberType">
                                          <xsd:restriction base="xsd:string">
                                              //正则匹配
                                              <xsd:pattern value="heima_\d{4}"/>
                                          </xsd:restriction>
                                      </xsd:simpleType>
                                  </xsd:schema> 
                                  
+
                                  JSP
                                  
+
                                  现在都用 Thymeleaf ，更符合 MVC 的执行过程，也没有 JSP 这种耦合杂乱的页面代码，但是模板引擎的思路大致相同，还是可以看一看的
                                  
+
                                  
+
                                  改动之后无需重启服务器，刷新界面即可。
                                  
+
                                  
+
                                  关于热更新的机制可以看看这篇文章，水平有限还看不懂就先放在这了：
                                  
+
                                  JSP热部署的实现原理[通俗易懂]
                                  
+
                                  
+
                                  概念
                                  JSP(Java Server Pages) Java服务器端页面，用于简化书写
                                  
+
                                  可以理解为：一个特殊的页面，其中既可以定义html标签，又可以定义java代码
                                  
+
                                  比如说，上一个案例的Servlet代码就可以直接写入到JSP中，而且response和request这些对象可以直接用
                                  
+
                                  <%@ page import="java.text.SimpleDateFormat" %>
                                  <%@ page import="java.util.Date" %>
                                  <html>
                                  <body>
                                  <h2>Hello World!</h2>
                                  <%
                                      //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
                                      response.setCharacterEncoding("utf-8");

                                      //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
                                      response.setHeader("content-type","text/html;charset=utf-8");
                                      if(request.getCookies() != null)
                                          for(Cookie c : request.getCookies()){
                                              if(c.getName().equals("isfirst")){
                                                  //response.getWriter().write("<h1>欢迎回来，您上次访问的时间为<h1>"+c.getValue());
                                                  response.getWriter().write("<h1>Welcome!The last time you visit is <h1>"+c.getValue());
                                                  //System.out.println("欢迎回来，您上次访问的时间为"+c.getValue());
                                                  break;
                                              }
                                          }
                                      else
                                          response.getWriter().write("<h1>Hello!Welcome!<h1>");

                                      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
                                      Date date1 = new Date();
                                      String currentTime = dateFormat.format(date1);

                                      //response.getWriter().write("<h1>你好！欢迎你！<h1>");
                                      //System.out.println("你好！欢迎你！");
                                      response.addCookie(new Cookie("isfirst",currentTime));
                                  %>
                                  </body>
                                  </html>
                                  
 
-
                                  引入方式
                                  <?xml version="1.0" encoding="UTF-8" ?>
                                  <!-- 
                                  	1.填写xml文档的根元素
                                  	2.引入xsi前缀.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                                  	3.引入xsd文件命名空间.  xsi:schemaLocation="http://www.itcast.cn/xml  student.xsd"
                                  	4.为每一个xsd约束声明一个前缀,作为标识  xmlns="http://www.itcast.cn/xml" 
                                  	
                                  	
                                   -->
                                  <students   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                                  			xmlns="http://www.itcast.cn/xml"
                                  			xsi:schemaLocation="http://www.itcast.cn/xml  student.xsd"
                                  >
                                  	<student number="heima_0001">
                                  		<name>tom</name>
                                  		<age>18</age>
                                  		<sex>male</sex>
                                  	</student>

                                  </students>
                                  
+
                                  最终效果：
                                  
+image-20230222230929893
 
-
                                  它这意识就是，每个schema文件都要起一个别名，比如xsi:schemaLocation="http://www.itcast.cn/xml  student.xsd"这行代码实际上就是把student.xsd的别名起为了http://www.itcast.cn/xml。
                                  
-
                                  为什么要起名呢？这就类似于命名空间这种东西，你要用到一个标签需要指明这个标签从哪来的，比如std::vector，Class.toString这种。这种命名空间在xml里叫前缀。所以，实际上完整写法应该是<http://www.itcast.cn/xml:students>。
                                  
-
                                  但这样显然太麻烦了，别名一般都是这种网址，写起来太长了。所以我们选择给别名起别名，设置方法为xmlns:a="http://www.itcast.cn/xml"，这样一来，以后就不用写<http://www.itcast.cn/xml:students>，只用写<a:students>了。
                                  
-
                                  但是如果每个都写一个前缀还是有点难顶。所以就引入了一个空前缀。这样写<students>这样没有前缀的标签，就相当于从空前缀那个命名空间里拿出来的了。当然如果有多个命名空间，还是得区分一下的。
                                  
-
                                  解析
                                  image-20221225234106078
                                  
-
                                  解析方式有两种方法。
                                  
-
                                  解析方法
                                  DOM
                                  将标记语言文档一次性加载进内存，形成DOM树
                                  
-
                                  操作方便，可以进行CRUD所有操作；但占内存
                                  
-
                                  SAX
                                  逐行读取，基于事件驱动
                                  
-
                                  不占内存；但只能读取
                                  
-
                                  解析工具
                                  image-20221225234649287
                                  
-
                                  主要学习Jsoup。
                                  
-
                                  快速入门
                                  image-20221225234813135
                                  
-
                                  跟前面html的DOM是差不多的。
                                  
-
                                  public class JsoupDemo {
                                      public static void main(String[] args) throws IOException {
                                          //获取Document对象，根据xml文档
                                          //解析xml文档（加载进内存且获取dom树）
                                          Document doc = Jsoup.parse(new File(JsoupDemo.class.getClassLoader()
                                                  .getResource("student.xml").getPath()),"utf-8");
                                          //获取元素对象
                                          //Elements extends ArrayList<Element>
                                          Elements ele = doc.getElementsByTag("name");
                                          //获取元素里的数据
                                          System.out.println(ele.get(0).text());
                                      }
                                  }
                                  
+
                                  原理
                                  JSP本质上是Servlet
                                  
+
                                  image-20230222233533332
                                  
+
                                  JSP的脚本
                                  JSP定义Java代码的方式
                                  
+
                                    
+
                                  1. <%  代码 %>
                                    
+
                                    定义的java代码，在service方法中。service方法中可以定义什么，该脚本中就可以定义什么。
                                    
+
                                    也即最后会构成Servlet体
                                    
+
                                    2. 
+
                                  2. <%! 代码 %>
                                    
+
                                    定义的java代码，在jsp转换后的java类的成员位置。可以是成员变量，或者是成员方法。
                                    
+
                                    注：最好不要在Servlet中定义成员变量，否则容易引发线程安全问题。
                                    
+
                                    3. 
+
                                  3. <%= 代码 %>
                                    
+
                                    定义的java代码，会输出到页面上。输出语句中可以定义什么，该脚本中就可以定义什么。
                                    
+
                                    image-20230223000057595
                                    
+
                                    比如说可以用来输出某个变量的值。注意这东西由于本质上是写在Servlet的service方法中的，因而当成员变量和service方法的局部变量重名，会依据就近原则优先使用局部变量的值。
                                    
+
                                    4. 
+
                                  
+
                                  指令
                                  也就是jsp开头那些东西，比如说这个：
                                  
+
                                  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
                                  
 
-
                                  细说
                                    
-
                                  1. Jsoup：工具类，可以解析html或xml文档，返回Document
                                    
+
                                    用来配置jsp的资源页面信息
                                    
 
                                      
-
                                    • parse：解析html或xml文档，返回Document
                                        
-
                                      • parse(File in, String charsetName)：解析xml或html文件的。
                                        • 
-
                                      • parse(String html)：解析xml或html字符串
                                        • 
-
                                      • parse(URL url, int timeoutMillis)：通过网络路径获取指定的html或xml的文档对象
                                        • 
-
                                      
+
                                    • 分类：
                                        
+
                                      1. page        ： 配置JSP页面的
                                          
+
                                        • contentType：等同于response.setContentType()  
                                          contentType="text/html;charset=UTF-8"
                                          
+
                                            
+
                                          1. 设置响应体的mime类型以及字符集
                                            2. 
+
                                          2. 设置当前jsp页面的编码（只能是高级的IDE才能生效，如果使用低级工具，则需要设置pageEncoding属性设置当前页面的字符集）
                                            3. 
+
                                          
 
                                          • 
+
                                        • import：导包
                                          • 
+
                                        • errorPage：当前页面发生异常后，会自动跳转到指定的错误页面
                                          • 
+
                                        • isErrorPage：标识当前页面是否是错误页面。
                                            
+
                                          • true：是，可以使用内置对象exception【用来获取异常名称/信息等】
                                            • 
+
                                          • false：否。默认值。不可以使用内置对象exception
                                            • 
 
                                          
 
                                          • 
-
                                        • Document：文档对象。代表内存中的dom树
                                          
-
                                            
-
                                          • 获取Element对象
                                              
-
                                            • getElementById(String id)：根据id属性值获取唯一的element对象
                                              • 
-
                                            • getElementsByTag(String tagName)：根据标签名称获取元素对象集合
                                              • 
-
                                            • getElementsByAttribute(String key)：根据属性名称获取元素对象集合
                                              • 
-
                                            • getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合
                                              • 
 
                                            
 
                                            • 
+
                                          • include    ： 页面包含的。导入页面的资源文件，可以引入其它的jsp或者html，引入之后就会展示同样的内容。
                                              
+
                                            • <%@include file=”top.jsp”%>
                                              • 
 
                                            
 
                                            • 
-
                                          • Elements：元素Element对象的集合。可以当做 ArrayList来使用
                                            
+
                                          • taglib导入资源。用来导入标签库
                                                * <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+        * prefix：前缀，自定义的。之后就可以用`<c:XXX>`了。相当于什么std::。
+
                                            
 
                                            • 
-
                                          • Element：元素对象
                                            
-
                                              
-
                                            1. 获取子元素对象 
                                              2. 
 
                                            
-
                                               这一点很好理解。因为Document和Element对象的获取元素方法都继承自Node结点，本意就是获取子元素对象。只不过Document是根节点，所以就变成了获取所有元素对象。
                                            
-
                                              
-
                                            • getElementById(String id)：根据id属性值获取唯一的element对象
                                              • 
-
                                            • getElementsByTag(String tagName)：根据标签名称获取元素对象集合
                                              • 
-
                                            • getElementsByAttribute(String key)：根据属性名称获取元素对象集合
                                              • 
-
                                            • getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合
                                              • 
+
 
                                            
-
                                              
-
                                            1. 获取属性值
                                              2. 
-
                                            
+
                                            中文乱码
                                            但是注意一点
                                            
+
                                            //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
                                            response.setCharacterEncoding("utf-8");

                                            //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
                                            response.setHeader("content-type","text/html;charset=utf-8");
                                            
+
+
                                            这样做在Servlet不会导致中文乱码，但JSP不行，这个大概是因为两者原理不一样。
                                            
+
                                            Servlet的中文乱码：
                                            
+image-20230222231756277
+
+
                                            JSP的：
                                            
+
                                            image-20230222231820358
                                            
+
                                            Servlet乱码是因为客户端和response请求体编码不一致，JSP乱码与JSP的原理有关，是只跟服务器端有关
                                            
+
                                            
+
                                            编译jsp有以下几个步骤：
                                            (1)把jsp转化为java源码。pageEncoding=xxx指定以xxx编码格式读取jsp文件，因此，jsp文件的编码格式应与pageEncoding值一致。
                                            (2)把java源码编译为字节码，即.class文件。转化后的java源码为utf-8编码格式，字节码也为utf-8编码，我们无需干预。
                                            (3)执行.class文件。在此过程，需向浏览器发送中文字符，contentType=xxx指定了jsp以xxx编码显示字符。也就是在浏览器中查看页面编码，其值为contentType指定的编码。
                                            
+
                                            因此，在1、3环节，**只要指定一致的编码格式(jsp文件编码格式=pageEncoding=contentType)**，即可保证jsp页面不出现乱码。
                                            举例：jsp文件以utf-8格式编写，那么pageEncoding=utf-8, contentType=utf-8，就保证了jsp页面不出现乱码。
                                            ————————————————
                                            版权声明：本文为CSDN博主「liuhaidl」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
                                            原文链接：https://blog.csdn.net/liuhaidl/article/details/84012372
                                            
+
                                            
+
                                            指定方法是在JSP开头添加：
                                            
+
                                            <%@ page pageEncoding="UTF-8"%>
                                            
+
+
                                            内置对象
                                            在jsp页面中不需要获取和创建，可以直接使用的对象。
                                            
+
                                            jsp一共有9个内置对象。
                                            
+
                                              
+
                                            1. request     HttpServletRequest    一次请求访问的多个资源(转发)
                                              
+
                                              2. 
+
                                            2. response   HttpServletResponse        响应对象
                                              
+
                                              3. 
+
                                            3. out：   JspWriter    字符输出流对象。可以将数据输出到页面上。和response.getWriter()类似
                                              
 
                                                
-
                                              • String attr(String key)：根据属性名称获取属性值
                                                • 
+
                                              • response.getWriter()和out.write()的区别：  在tomcat服务器真正给客户端做出响应之前，会先找response缓冲区数据，再找out缓冲区数据。因而response.getWriter()数据输出永远在out.write()之前  所以说，用out更好，因为它跟随你布局变化，你out写在哪，这句话最终就会输出在哪
                                                • 
 
                                              
-
                                                
-
                                              1. 获取文本内容
                                                2. 
+
+
                                              2. pageContext    PageContext    当前页面共享数据，还可以获取其他八个内置对象
                                                
+
                                                3. 
+
                                              3. session    HttpSession    一次会话的多个请求间
                                                
+
                                                4. 
+
                                              4. application    ServletContext    所有用户间共享数据
                                                
+
                                                5. 
+
                                              5. page    Object    当前页面(Servlet)的对象，相当于this
                                                
+
                                                6. 
+
                                              6. config    ServletConfig    Servlet的配置对象
                                                
+
                                                7. 
+
                                              7. exception    Throwable    异常对象。只在page指令的isErrorPage为true的情况下才能使用此对象。
                                                
+
                                                8. 
 
                                              
-
                                                
-
                                              • String text():获取字标签的所有纯文本内容
                                                • 
-
                                              • String html():获取标签体的所有内容(包括字标签的字符串内容)
                                                • 
+
                                                其中，
                                                
+
                                                image-20230307144539506
                                                
+
                                                这四个为用来共享数据的域对象
                                                
+
                                                演变：MVC开发模式
                                                jsp的演变
                                                image-20230307145442383
                                                
+
                                                MVC模式
                                                将程序分成三个部分，分别是M-V-C。
                                                
+
                                                  
+
                                                1. M：Model，模型。JavaBean
                                                    
+
                                                  • 完成具体的业务操作，如：查询数据库，封装对象
                                                    • 
 
                                                  
 
                                                  2. 
-
                                                2. Node：节点对象
                                                  
-
                                                    
-
                                                  • 是Document和Element的父类
                                                    • 
+
                                                  • V：View，视图。JSP
                                                      
+
                                                    • 展示数据
                                                      • 
+
                                                    
+
                                                    • 
+
                                                  • C：Controller，控制器。Servlet
                                                      
+
                                                    • 获取用户的输入
                                                      • 
+
                                                    • 调用模型
                                                      • 
+
                                                    • 将数据交给视图进行展示【域对象共享数据】
                                                      • 
 
                                                    
 
                                                    • 
 
                                                
-
                                                快速查找
                                                  
-
                                                1. 使用选择器selector
                                                  
-
                                                  其实语法格式跟css的那个选择器差不多。
                                                  
-
                                                  /**
                                                   *选择器查询
                                                   */
                                                  public class JsoupDemo5 {
                                                      public static void main(String[] args) throws IOException {
                                                          //1.获取student.xml的path
                                                          String path = JsoupDemo5.class.getClassLoader().getResource("student.xml").getPath();
                                                          //2.获取Document对象
                                                          Document document = Jsoup.parse(new File(path), "utf-8");

                                                          //3.查询name标签
                                                          /*
                                                              div{

                                                              }
                                                           */
                                                          Elements elements = document.select("name");
                                                          System.out.println(elements);
                                                          System.out.println("=----------------");
                                                          //4.查询id值为itcast的元素
                                                          Elements elements1 = document.select("#itcast");
                                                          System.out.println(elements1);
                                                          System.out.println("----------------");
                                                          //5.获取student标签并且number属性值为heima_0001的age子标签
                                                          //5.1.获取student标签并且number属性值为heima_0001
                                                          Elements elements2 = document.select("student[number=\"heima_0001\"]");
                                                          System.out.println(elements2);
                                                          System.out.println("----------------");

                                                          //5.2获取student标签并且number属性值为heima_0001的age子标签
                                                          Elements elements3 = document.select("student[number=\"heima_0001\"] > age");
                                                          System.out.println(elements3);

                                                      }

                                                  }
                                                  2. 
-
                                                2. 使用XPath
                                                  
-
                                                  XPath：xml路径语言。
                                                  
-
                                                  XPath API文档
                                                  
-
                                                  /**
                                                   *XPath查询
                                                   */
                                                  public class JsoupDemo6 {
                                                      public static void main(String[] args) throws IOException, XpathSyntaxErrorException {
                                                          //1.获取student.xml的path
                                                          String path = JsoupDemo6.class.getClassLoader().getResource("student.xml").getPath();
                                                          //2.获取Document对象
                                                          Document document = Jsoup.parse(new File(path), "utf-8");

                                                          //3.根据document对象，创建JXDocument对象
                                                          JXDocument jxDocument = new JXDocument(document);

                                                          //4.结合xpath语法查询
                                                          //4.1查询所有student标签
                                                          List<JXNode> jxNodes = jxDocument.selN("//student");
                                                          for (JXNode jxNode : jxNodes) {
                                                              System.out.println(jxNode);
                                                          }

                                                          System.out.println("--------------------");

                                                          //4.2查询所有student标签下的name标签
                                                          List<JXNode> jxNodes2 = jxDocument.selN("//student/name");
                                                          for (JXNode jxNode : jxNodes2) {
                                                              System.out.println(jxNode);
                                                          }

                                                          System.out.println("--------------------");

                                                          //4.3查询student标签下带有id属性的name标签
                                                          List<JXNode> jxNodes3 = jxDocument.selN("//student/name[@id]");
                                                          for (JXNode jxNode : jxNodes3) {
                                                              System.out.println(jxNode);
                                                          }
                                                          System.out.println("--------------------");
                                                          //4.4查询student标签下带有id属性的name标签 并且id属性值为itcast

                                                          List<JXNode> jxNodes4 = jxDocument.selN("//student/name[@id='itcast']");
                                                          for (JXNode jxNode : jxNodes4) {
                                                              System.out.println(jxNode);
                                                          }
                                                      }

                                                  }
                                                  3. 
+
                                                  image-20230307150845273
                                                  
+
                                                  服务器将接收的请求给控制器处理，控制器控制model完成必要的运算，model把算出的东西返回给控制器，控制器再把数据交给视图展示，数据最终就回到了浏览器客户端。
                                                  
+
                                                  这就算是一个微型CPU了吧，控制器就是CU，模型就是ALU，也许客户端和视图什么的可以视为IO接口。
                                                  
+
                                                    
+
                                                  • 优缺点：
                                                    
+
                                                      
+
                                                    1. 优点：
                                                      
+
                                                        
+
                                                      1. 耦合性低，方便维护，可以利于分工协作
                                                        2. 
+
                                                      2. 重用性高
                                                        3. 
 
                                                      
-
                                                      第四部分 JavaWeb核心
                                                      Tomcat
                                                      概述
                                                      概述
                                                      image-20221226154531990
                                                      
-
                                                      Tomcat是Java相关的web服务器软件。
                                                      
-
                                                      tomcat目录结构
                                                      image-20221226155107723
                                                      
-
                                                      image-20221226155143920启动
                                                      
-
                                                      启动时出现的问题
                                                      省流：看系统环境变量有没有CATALINA_HOME这一项，并且看这个CATALINA_HOME的值是否与当前版本安装路径相符合。
                                                      
-
                                                      我电脑上本来也有了一个tomcat，只不过跟老师版本不一样。我把这两个都安到同一个目录了。然后我启动了老师版本，却发现输入localhost:8080没有任何响应。我首先去看了一下tomcat的config下的server.xml，发现端口号确实是8080没问题。然后试图访问localhost，发现没有响应，故推测是此处发生了问题。因而我上网按照该教程做了一遍：
                                                      
-
                                                      127.0.0.1 拒绝了我们的连接请求–访问本地IP时显示拒绝访问
                                                      
-
                                                      我重启电脑后，再次启动老师版本，发现还是不行。这时我开始怀疑是否我的tomcat没有正常启动，或者是否是因为8080这个端口号冲突了。所以我又找了一下如何查看端口号占用情况：
                                                      
-
                                                      如何查看端口号是否被占用
                                                      
-
                                                      用netstat -a命令即可。我便发现，在我开着tomcat的情况下，8080这个端口没有被使用。说明好像启动不大正常。于是我打开了另一篇回答：
                                                      
-
                                                      tomcat 启动了，为什么没打开 8080 端口？
                                                      
-
                                                      按照它说的去查看日志文件。发现老师版本的tomcat下的log目录为空。我就去我本安装的版本下的log目录去看了，惊奇地发现，原来我在使用老师版本的tomcat时，tomcat用的是老版本的log目录。也就是说，很有可能config目录也是用的老版本的。我去查看老版本的config，发现端口是8888。于是我把老师版本的tomcat卸载了，去访问localhost:8888，成功力。
                                                      
-
                                                      我探寻了以下原因，发现tomcat的startup里面如此写道：
                                                      
-
                                                      if not "%CATALINA_HOME%" == "" goto gotHome
                                                      :gotHome
                                                      if exist "%CATALINA_HOME%\bin\catalina.bat" goto okHome
                                                      :okHome
                                                      rem ....
                                                      call "%EXECUTABLE%" start %CMD_LINE_ARGS%
                                                      :end
                                                      
-
-
                                                      这一段大概是在找到tomcat这个软件的位置。如果我们在环境变量里面设置了CATALINA_HOME，那么就会直接把软件位置定位到CATALINA_HOME的值的地方，随后之后的逻辑都在那边执行。
                                                      
-
                                                      我发现我确实设置了这个CATALINA_HOME，并且：
                                                      
-
                                                      image-20221226170930763
                                                      
-
                                                      它的值是我电脑原本有的老版本的目录！
                                                      
-
                                                      故而，这也就说明了为什么老师的版本不去用自己的log，不去用自己的config，而用的是我电脑上的老版本的log，config了。。。
                                                      
-
                                                      image-20221226172653916
                                                      
-
                                                      配置
                                                        
-
                                                      • 部署项目的方式：
                                                        
+
                                                        • 
+
                                                      • 缺点：
                                                        
 
                                                          
-
                                                        1. 直接将项目放到webapps目录下即可。    * /hello：项目的访问路径–>虚拟目录    * 简化部署：将项目打成一个war包，再将war包放置到webapps目录下。
                                                          
+
                                                        2. 使得项目架构变得复杂，对开发人员要求高
                                                          3. 
+
                                                        
+
                                                        • 
+
                                                    
+
                                                    • 
+
                                                  
+
                                                  那么，我们可以知道，jsp就只需负责数据的展示了。那怎么展示数据呢？这就需要用到jsp的几个技术了：
                                                  
+
                                                  EL表达式
                                                  
+
                                                  注意，servlet3.0以来默认关闭el表达式解析，需要手动在page上加属性打开，详见 jsp文件中的el表达式失效问题解决
                                                  
+
                                                  
+
                                                  Expression language，替换和简化jsp上java代码的书写
                                                  
+
                                                  语法：${表达式}
                                                  
+
                                                  jsp会执行里面的表达式，然后把结果输出。
                                                  
+
                                                  image-20230307151706211
                                                  
+
                                                  加反斜杠可忽略。
                                                  
+
                                                  使用场景：
                                                  
+
                                                    
+
                                                  1. 运算
                                                    
+
                                                          1. 算数运算符： + - *  / %
+      2. 比较运算符： > < >= <= == !=
+      3. 逻辑运算符： && || !
+      4. 空运算符： empty
+   * 功能：用于判断字符串、集合、数组对象是否为null**或者**长度是否为0
+   * `${empty 变量名}`: 判断字符串、集合、数组对象是否为null或者长度为0
+   * `${not empty 变量名}`: 表示判断字符串、集合、数组对象是否不为null 并且 长度>0
+
                                                    
+
                                                    2. 
+
                                                  2. 获取值
                                                    
+
                                                      
+
                                                    1. el表达式只能从域对象中获取值
                                                      
+
                                                      image-20230307144539506
                                                      
+
                                                      2. 
+
                                                    2. 语法：
                                                      
+
                                                        
+
                                                      1. ${域名称.键名}：从指定域中获取指定键的值
                                                        2. 
+
                                                      
 
                                                        
-
                                                      • war包会自动解压缩
                                                        • 
+
                                                      • 域名称：
                                                          
+
                                                        1. pageScope        –> pageContext
                                                          2. 
+
                                                        2. requestScope     –> request
                                                          3. 
+
                                                        3. sessionScope     –> session
                                                          4. 
+
                                                        4. applicationScope –> application（ServletContext）
                                                          5. 
+
                                                        
+
                                                        • 
+
                                                      • 举例：在request域中存储了name=张三，获取：${requestScope.name}
                                                        • 
 
                                                      
+
                                                        
+
                                                      1. ${键名}：表示依次从最小的域中查找是否有该键对应的值，直到找到为止。
                                                        2. 
+
                                                      
 
                                                      3. 
-
                                                    3. 配置conf/server.xml文件
                                                       在<Host>标签体中配置
                                                       <Context docBase="C:\aWorkSpace\Projects\Java\JavaWeb" path="/web" />
                                                      
+
                                                    4. 案例
                                                      
+
                                                      这样一来，访问/demo就能转发到index.jsp，显示出属性值
                                                      
+
                                                        
+
                                                      1. Servlet
                                                        
+
                                                        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                                                            request.setAttribute("name","xiunian");
                                                            request.getRequestDispatcher("/index.jsp").forward(request,response);
                                                        }
                                                        2. 
+
                                                      2. index.jsp
                                                        
+
                                                        <%@ page pageEncoding="UTF-8" isELIgnored="false" %>
                                                        <html>
                                                        <body>
                                                        <h2>Hello World!</h2>
                                                        ${requestScope.name}
                                                        </body>
                                                        </html>
                                                        3. 
+
                                                      
+
                                                      5. 
+
                                                    5. 获取非字符串类型的值
                                                      
+
                                                        
+
                                                      1. 对象
                                                        
+
                                                        2. 
+
                                                      2. 集合（List、Map等）
                                                        
 
                                                        3. 
 
                                                      
-
                                                      然后之后访问时输入`localhost/web/JavaWeb.html`即可
-
-* docBase:项目存放的路径
-* path：虚拟目录
-
                                                      
-
                                                        
-
                                                      1. 在conf\Catalina\localhost创建任意名称的xml文件。在文件中编写
                                                         <Context docBase="C:\aWorkSpace\Projects\Java\JavaWeb" />
                                                          
-
                                                        • 虚拟目录：xml文件的名称
                                                          • 
-
                                                        
 
                                                        2. 
+
                                                      2. 
 
                                                      
-
                                                      注意，该方法是热部署的。也就是说，可以不关闭服务器的情况下，去增删xml文件，会马上变化，而不是像上面两种方式一样重启生效。
-
                                                      
 
                                                      6. 
-
                                              
-
                                              动态项目目录结构
                                              项目都存放在webapp里。打开webapp中的任一个。
                                              
-
                                              image-20221226221811747
                                              
-
                                              WEB-INF下是动态资源，也就是Java控制的一些文件【大概这个意思】。有这个文件夹的项目是动态项目。
                                              
-
                                              WEB-INF以外的都是静态资源。
                                              
-
                                              image-20221226221933346
                                              
-
                                              tomcat集成到IDEA
                                              使用maven创建Web项目
                                              更换maven镜像源
                                              idea中Maven镜像源详细配置步骤（对所有项目）
                                              
-
                                              创造项目
                                              image-20221226235520519
                                              
-
                                              然后等着它开始下载就行了。
                                              
-
                                              最后的目录结构：
                                              
-
                                              image-20221226235607604
                                              
-
                                              如果java或者resources目录没有，自己建就行。
                                              
-
                                              加入tomcat
                                              1.
                                              
-
                                              TOMCAT -＞ IDEA
                                              
-
                                              2.
                                              
-
                                              还有另一种更便捷的方式，就是直接添加maven的tomcat插件。在pom.xml文件里加入此段：
                                              
-
                                              <build>
                                                <plugins>
                                                  <plugin>
                                                    <groupId>org.apache.tomcat.maven</groupId>
                                                    <artifactId>tomcat7-maven-plugin</artifactId>
                                                    <version>2.2</version>
                                                  </plugin>
                                                </plugins>
                                              </build>
                                              
-
-
                                              即可，可用alt+insert自动补全。
                                              
-
                                              这里我出现了一个飘红报错问题，用这个可以解决：
                                              
-
                                              maven学习 & Plugin ‘org.apache.tomcat.maven:tomcat7-maven-plugin:2.2’ not found报错解决【问题及解决过程记录】
                                              
-
                                              然后，右键项目就可以run了：
                                              
-
                                              image-20221227003805955
                                              
-
                                              如果没有此选项，就去下载maven helper插件。
                                              
-
                                              修改tomcat配置参数
                                              图形化界面
                                              run-edit configuration-tomcat
                                              
-
                                              配置文件
                                              image-20221230221339275
                                              
-
                                              启动服务器时控制台前几句输出有一句这样的。对应目录下的就可以找到tomcat配置文件。
                                              
-
                                              Servlet
                                              server applet运行在服务器端的小程序
                                              
-
                                              servlet是java编写的服务器端的程序，运行在web服务器中。作用：接收用户端发来的请求，调用其他java程序来处理请求，将处理结果返回到服务器中 
                                              
-
                                              image-20221227154053743
                                              
-
                                              servlet是接口，定义了Java类被tomcat执行、被浏览器访问的规则。
                                              
-
                                              image-20221227154222612
                                              
-
                                              快速入门
                                              image-20221227154841102
                                              
-
                                              这里的配置用的是注解，具体原理在第一部分的JavaSE基础里有详细描述了。
                                              
-
                                              
-
                                              使用maven创建web项目见上面的tomcat-tomcat集成到IDEA-使用maven创建web项目
                                              
+
                                            
+]]>
+      
+        Java
+      
+  
+  
+    计算机组成原理
+    /2023/06/21/comporgan/
+    概述
                                            架构
                                            冯诺依曼
                                            以运算器为中心，指令和数据同等地位（不满足摩尔定律）
                                            
+
                                            image-20230617133555268
                                            
+
                                            存储器为中心
                                            image-20230617133840406
                                            
+
                                            哈佛架构
                                            哈佛结构数据空间和程序空间是分开的
                                            
+
                                            大部分ROM操作部分是采用了冯诺依曼结构，
                                            
+
                                            有些需要CPU与ROM之间快速的响应和交互，采用的是5级流水的哈佛结构。
                                            
+
                                            早期（如X86）采用冯诺依曼
                                            
+
                                            DSP和ARM用改进哈佛
                                            
+
                                            image-20230617134010940
                                            
+
                                            现代计算机
                                            image-20230617134045099
                                            
+
                                            RISC-V
                                            数的表示
                                            无符号数与有符号数
                                            机器数与真值
                                            image-20230619211124996
                                            
+
                                            意思就是真值有±符号，机器数把±符号换成了数字罢了
                                            
+
                                            原码/补码/反码/移码
                                            image-20230617142534411
                                            
+
                                            原码
                                            整数用逗号隔开，小数用小数点隔开
                                            
+
                                            整数
                                            image-20230617140847726
                                            
+
                                            小数
                                            image-20230617140920563
                                            
+
                                            注意0的特殊情况
                                            image-20230617141011120
                                            
+
                                            补码
                                            
+
                                            对于负数，原码->补码符号位不变，数值位按位取反再加一的理论由来。神奇的是对于补码->原码，也是按位取反再加一。
                                            
+
                                            简单证明一下：
                                            
+
                                            设x为补码，y为原码，n为位数
                                            
+
                                            已知 x = !(y - 2^n) +1
                                            
+
                                            则反转一下可得 y = !(x - 1) + 2^n
                                            
+
                                            
+
                                            符号位不变，按位取反再加一
                                            
+
                                            整数
                                            image-20230617141209384
                                            
+
                                            小数
                                            image-20230617141232325
                                            
+
                                            特殊
                                            [y]补连同符号位在内，每位取反末位加1，即得**[-y]补**
                                            
+
                                            后面那三个是真的抽象
                                            
+
                                            image-20230617141627719
                                            
+
                                            反码
                                            对于正数，反码和原码一致；
                                            
+
                                            对于负数，反码为原码的数值位取反
                                            
+
                                            整数
                                            image-20230617141351461
                                            
+
                                            小数
                                            image-20230617141418617
                                            
+
                                            0
                                            image-20230617141525918
                                            
+
                                            移码
                                            
+
                                            注意，移码只有整数形式的定义，这与它的用途有关。计算机中，移码通常用来标识浮点数的阶码【阶码是整数】。
                                            
 
                                            
+
                                            与补码数值位计算方式相同，区别是符号位相反
                                            
+
                                            image-20230617142858076
                                            
+
                                            image-20230617145309340
                                            
+
                                            注意，移码的0为100000，最小值为000000
                                            
+
                                            浮点表示
                                            表示形式和范围
                                            image-20230617143220170
                                            
+
                                            注意，这边的上溢和下溢只与阶码有关，与尾数无关。
                                            
+
                                            这个溢出条件及其处理方式需要记，会考
                                            
+
                                            image-20230617143328674
                                            
+
                                            规格化
                                            image-20230617143654003
                                            
+
                                            特例
                                            image-20230617143731873
                                            
+
                                            范围
                                            image-20230617143912465
                                            
+
                                            image-20230617145251169
                                            
+
                                            题型 表示范围
                                            image-20230617145826541
                                            
+
                                            看得我cpu快烧了
                                            
 
                                            
-
                                            如果已经导入依赖坐标却还未生效，就点击右侧侧边栏的maven刷新。
                                            
-
                                            Maven导入依赖后还不出现Servlet的问题
                                            
+
                                            https://www.jianshu.com/p/7b9dd240685c
                                            
+
                                            image-20230617145857698
                                            
+
                                            之所以最小负数不一样，是因为原码不能表示-1，补码可以；
                                            
+
                                            之所以规格化最大负数是那玩意，是因为最大负数本应为2^-8，为了规格化必须再加个2^-1，然后原码转补码就变成那样了
                                            
 
                                            
-
                                            原理
                                            执行原理
                                              
-
                                            • 执行原理：
                                                
-
                                              1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径
                                                2. 
-
                                              2. 查找web.xml文件，是否有对应的标签体内容。
                                                3. 
-
                                              3. 如果有，则在找到对应的全类名【注意：在下面，url-pattern都使用注解配置方法了，所以这两步应该是不用了，应该会变成这样：① 逐个遍历注册的servlet实现类，查看其注解属性是否为对应的url-pattern。② 如果有，则找到类名，步骤继续】
                                                4. 
-
                                              4. tomcat会将字节码文件加载进内存，并且创建其对象
                                                5. 
-
                                              5. 调用其方法
                                                6. 
+
                                                IEEE754标准
                                                难绷，最沙比的来了
                                                
+
                                                image-20230617150024955
                                                
+
                                                没有阶符和数符力
                                                
+
                                                image-20230617150101092
                                                
+
                                                image-20230617150816446
                                                
+
                                                它就相当于指数是移码表示的，并且注意到一点就是指数的0和255被征用表示特殊的数了，所以指数范围为1-254
                                                
+
                                                image-20230617151013979
                                                
+
                                                题型 把数转化为IEEE754
                                                首先背一下上面那个数的范围图，然后判断下是规格化还是非规格化，然后套公式就行了
                                                
+
                                                image-20230617152014370
                                                
+
                                                image-20230617152309065
                                                
+
                                                算术移位与逻辑移位
                                                
+
                                                来自 https://blog.csdn.net/qq_34283722/article/details/107093193 ：
                                                
+
                                                img 
                                                
+
                                                这应该与补码的运算机制有关。
                                                
+
                                                
+
                                                image-20230617152527973
                                                
+
                                                反码不论是左还是右都添1
                                                
+
                                                image-20230617152938114
                                                
+
                                                注意，符号位不变！！！这点在左移的时候需要尤其注意，很容易出错
                                                
+
                                                RISC-V概述
                                                ISA
                                                ISA位宽：通用寄存器的宽度，决定了寻址范围大小、数据运算强弱。
                                                
+
                                                CISC-RISC
                                                image-20230619211742901
                                                
+
                                                X86 & MIPS
                                                相比于上述的差异，还有以下几个：
                                                
+
                                                  
+
                                                1. x86有8个通用寄存器，MIPS有32个
                                                  2. 
+
                                                2. x86有标志寄存器，MIPS没有
                                                  3. 
+
                                                3. x86为两地址指令，MIPS为三地址
                                                  4. 
+
                                                4. x86有堆栈指令，MIPS没有
                                                  5. 
+
                                                5. x86有IO指令，MIPS设备统一编址
                                                  6. 
+
                                                6. x86函数参数只用栈帧，MIPS用4寄存器+栈帧
                                                  7. 
+
                                                7. X86的字为2字节，MIPS/RISC-V的字为4字节
                                                  8. 
 
                                                
+
                                                RISC-V的特点
                                                  
+
                                                1. RISC-V是小端，也即低字节放在低地址
                                                  
 
                                                  2. 
-
                                            
-
                                            生命周期
                                            image-20221227161516964
                                            
-
                                            并发安全
                                            Servlet的init方法只执行一次，一种Servlet在内存中只存在一个对象，Servlet是单例的。因而，当多线程同时访问同一个Servlet对象时，就会产生线程安全问题。所以有需要的话，就要采取手段保障Servlet类的线程安全性。
                                            
-
                                            体系结构
                                            为了简化开发，我们可以用提供的servlet的实现类。
                                            
-
                                            image-20221227163713317
                                            
-
                                            GenericServlet
                                            除了service方法之外的方法，差不多都只做了空实现。所以只需写service方法即可。
                                            
-
                                            @WebServlet("/demo2")
                                            public class Servletdemo2 extends GenericServlet {
                                                public void service(ServletRequest servletRequest, ServletResponse servletResponse){
                                                }
                                            }
                                            
-
-
                                            HttpServlet
                                            使用
                                            比如httpservlet，就只用重写里面的doGet和doPost两个方法就行。
                                            
-
                                            @WebServlet("/demo2")
                                            public class Servletdemo2 extends HttpServlet {
                                                @Override
                                                protected void doGet(HttpServletRequest req, HttpServletResponse resp){
                                                    System.out.println("get!!!");
                                                }

                                                @Override
                                                protected void doPost(HttpServletRequest req, HttpServletResponse resp){
                                                    System.out.println("post!!!");
                                                }
                                            }

                                            
-
-
                                            这两个方法的区别就是，当使用get方式提交表单，就会执行第一个方法；使用post则会执行第二个方法。
                                            
-
                                            比方说post时：
                                            
-
                                            网页代码如下（放在webapp目录下）
                                            
-
                                            <!DOCTYPE html>
                                            <html lang="en">
                                            <head>
                                                <meta charset="UTF-8">
                                                <title>Title</title>
                                            </head>
                                            <body>
                                                Hello,World!
                                                <!--  action内写Servlet的资源路径  -->
                                                <form action="/webdemo4_war/demo2" method="post">
                                                    name: <input type="text" name="username" id="username" placeholder="请输入用户名">
                                                    <input type="submit" value="submit">
                                                </form>
                                            </body>
                                            </html>
                                            
-
-
                                            servlet代码同上。
                                            
-
                                            最终在网页中点击提交
                                            
-
                                            image-20221230172048250
                                            
-
                                            会跳转到\demo页面【也即servlet的访问路径】，并且在console打印“post!!!”
                                            
-
                                            
-
                                            为啥会这样呢？
                                            
-
                                            之前在讲表单的时候说过，form的action属性代表着提交时这个表单会提交给谁，值为一个URL。所以，这里action的值设置为Servlet的路径，意思就是把表单数据发送给了Servelet，由于使用的是post方式，因此触发了Servlet的doPost方法。Servlet对得到的数据进行各种处理，并且通过req和resp进行交互。
                                            
+
                                          • 支持字节（8位）、半字（16位）、字（32位）、双字（64位，64位架构）的数据传输
                                            
+
                                            主存按照字节进行编址
                                            
+
                                            • 
+
                                          • 采用哈佛结构
                                            
+
                                            • 
+
                                          • 三种特权模式
                                            
+
                                            image-20230617155657577
                                            
+
                                            • 
+
                                          • 模块化设计
                                            
+
                                            image-20230617155224429
                                            
+
                                            • 
+
                                      
+
                                      RISC-V汇编语言
                                      寄存器
                                      image-20230619212236116
                                      
+
                                      image-20230617194244388
                                      
+
                                      x3的全局指的是全局的静态数据区
                                      
+
                                      指令详解
                                      image-20230617160729611
                                      
+
                                      算术指令
                                      RISC-V 忽略溢出问题，高位被截断，低位写入目标寄存器
                                      
+
                                      如果想要保留乘法所有位：
                                      
+
                                      image-20230617183814367
                                      
+
                                      image-20230617183924758
                                      
+
                                      image-20230617184010487
                                      
+
                                      逻辑指令
                                      image-20230617184151843
                                      
+
                                      移位指令
                                      image-20230617185225785
                                      
+
                                      shift left logical，shift left arithmetic
                                      
+
                                      数据传输
                                      ld/sd，lw/sw，lh/sh（半字，也即2字节），lb/sb，以及load指令对应的无符号数（+后缀u）版本。
                                      
+
                                      bAddrReg+offset为4的倍数，数据传输指令除了字节指令（lb sb lbu）外都需要按字对齐。
                                      
+
                                      注意，如果为有符号数取数，放入寄存器时会自动进行符号扩展。
                                      
+
                                      image-20230617191543433
                                      
+
                                      比较指令
                                      image-20230617192731684
                                      
+
                                      条件跳转指令
                                      image-20230617193045409
                                      
+
                                      无条件跳转指令
                                      image-20230617193346852
                                      
+
                                      j：+label，用于实现无条件跳转，使用相对于当前 PC（程序计数器）的偏移量来计算目标地址，跳转范围较广
                                      
+
                                      jr：+寄存器，用于实现通过寄存器的值进行跳转，跳转的目标是存储在寄存器中的地址，而不是相对于 PC 的偏移量
                                      
+
                                      伪指令
                                      image-20230617193450180
                                      
+
                                      image-20230617193521343
                                      
+
                                      函数调用及栈的使用
                                      image-20230617195109547
                                      
+
                                      六种指令格式
                                      image-20230617213801145
                                      
+
                                      注意，jalr属于I型指令，而非J型指令！！！
                                      
+
                                      image-20230617213815058
                                      
+
                                      image-20230620164851924
                                      
+
                                      R型指令
                                      image-20230617214018489
                                      
+
                                      image-20230617214139338
                                      
+
                                      I型指令
                                      image-20230617214544561
                                      
+
                                      image-20230617214659517
                                      
+
                                      image-20230617214735023
                                      
+
                                      特例1 load
                                      image-20230617215007481
                                      
+
                                      特例2 jalr
                                      image-20230617215304022
                                      
+
                                      注意，jalr也属于I型指令，且其funct3为0
                                      
+
                                      S型指令
                                      image-20230617215730749
                                      
+
                                      image-20230617215842401
                                      
+
                                      B型指令
                                      image-20230617220521906
                                      
+
                                      这个计算过程很值得注意
                                      
+
                                      image-20230617220833542
                                      
+
                                      image-20230617220903564
                                      
+
                                      image-20230617221131122
                                      
+
                                      U型指令
                                      image-20230617221220495
                                      
+
                                      image-20230617221323268
                                      
+
                                      image-20230617221508473
                                      
+
                                      666
                                      
+
                                      J型指令
                                      image-20230617222154873
                                      
+
                                      寻址方式（x86）
                                      
+
                                      img 
                                      
+
                                      img 
                                      
+
                                      img 
                                      
+
                                      imgimg 
                                      
+
                                      尽管A很小，但可以让EA很大，从而扩展寻址范围。同时相对于上面的直接寻址，它更容易编程，因为只用修改A存储的那个地址值，而不用修改指令【比如说对数组进行循环，这个间接寻址就只用A++就行，而不用去修改指令里的那个“A”。】。
                                      
+
                                      That is 指针【】
                                      
+
                                      img 
                                      
+
                                      img至于为啥间接寻址不便于循环，也许是因为间接寻址是访存两次比较慢，要是真用来循环还了得
                                      
+
                                      imgimg 
                                      
+
                                      程序动态定位
                                      
+
                                      img循环数组时，可以用A作为数组地址，IX作为数组下标？？？【为什么不能用基址寻址？】
                                      
+
                                      应该是因为基址寻址的基址是系统内定的，数组循环问题需要用户指定数组起始地址，所以不能用基址寻址，只能用面向用户的变址寻址。
                                      
+
                                      img区别就在于直接寻址直接把指令参数****硬编码在内存****中，非常耗费空间。变址寻址则把指令参数作为变量了。
                                      
+
                                      img更应该像是指令寻址方式。
                                      
+
                                      程序浮动：程序在内存单元的位置出现变化【毕竟不可能同一个程序在每台电脑都是在同一个物理地址，相当于又减少了硬编码】
                                      
+
                                      imgimg【为2002H是因为假设字长为2byte】
                                      
+
                                      imgimg 
                                      
+
                                      一般栈顶地址最低。 
                                      
 
                                      
-
                                      
-
                                      为什么此处写的是“\demo”这样的路径？
                                      
-
                                      事实上这是一个相对路径。
                                      
-
                                      image-20221230215927404
                                      
-
                                      部署的根路径可以在 run-edit configuration-tomcat-deployment中找到。
                                      
+
                                      运算方法
                                      定点运算
                                      一位乘法运算
                                      原码一位乘
                                      
+
                                      image-20230621195833297
                                      
+
                                      大致明白了：
                                      
+
                                      ①乘积一共有四位，故而需要两个寄存器来保存。
                                      
+
                                      ②按照上面的原理公式，每次右移一位，被移出的那一位也是最后的结果（相当于竖式中每次相加的最后一位），需要把它存储在另一个寄存器中。
                                      
+
                                      ③我们选择了存乘数的寄存器，因为乘数已经乘过的位是没用的。存乘数的那个寄存器的乘数不断被结果的低位所替代。
                                      
+
                                      故****基本流程****：
                                      
+
                                      ①准备阶段：清零ACC【置部分积=0】，在MQ中放乘数，X中放被乘数
                                      
+
                                      ②判断MQ中乘数最低位，若为1，则ACC部分积加上X中的被乘数；若为0，则ACC不变
                                      
+
                                      ③将ACC和MQ中四位数字视作一个整体，符号位也算上，进行逻辑右移，左侧补0.
                                      
+
                                      ④重复上述过程，按移位次数来控制结束。
                                      
+
                                      ⑤则最后，ACC中存储的就是乘法结果的高位，MQ中存储的结果就是乘法中的低位。
                                      
+
                                      这其实就是我们用的列竖式一行一行加起来的一个过程。
                                      
+
                                      img
                                      
+
                                      S是符号位，GM是乘法标志位。
                                      
+
                                      控制门：当最后一位是1时，控制门打开，X中的被乘数进入加法器。
                                      
 
                                      
-
                                      深层一些的问题
                                      分成get和post
                                      之所以这两种方法需要分别处理，是因为在Servlet的service方法中，其实是要对req对象进行参数分解，这两种方法分解方式不一样。
                                      
-
                                      按照以往，我们需要这样写
                                      
-
                                       public void service(ServletRequest servletRequest, ServletResponse servletResponse) {
                                           String method = ((HttpServletRequest)servletRequest).getMethod();
                                           if("GET".equals(method)){
                                      //执行get的逻辑
                                           }
                                           else if ("POST".equals(method)){
                                      //执行post的逻辑
                                           }
                                       }
                                      
-
-
                                      就类似于可以这么写：
                                      
-
                                      public void service(ServletRequest servletRequest, ServletResponse servletResponse){
                                          String method = ((HttpServletRequest)servletRequest).getMethod();
                                          if("GET".equals(method)){
                                              doGet(servletRequest,servletResponse);
                                          }
                                          else if ("POST".equals(method)){
                                              doPost(servletRequest,servletResponse);
                                          }
                                      }
                                      
-
-
                                      于是最后就融合入httpservlet了。
                                      
-
                                      url-pattern配置
                                        
-
                                      1. 一个Servlet可以定义多个访问路径 ： @WebServlet({“/d4”,”/dd4”,”/ddd4”})
                                        
-
                                        2. 
-
                                      2. 路径定义规则：
                                        
 
                                          
-
                                        1. /xxx：路径匹配如/demo、/*【第一个优先级大于第二个】
                                          2. 
-
                                        2. /xxx/xxx:多层路径，目录结构
                                          3. 
-
                                        3. *.do：扩展名匹配不能在前面加’/‘。也即：
                                          @WebServlet("*.do")
                                          
-
-url访问填写http://localhost/webdemo4_war/*.do。
                                          4. 
-
                                        
+
                                      3. 部分积  乘数
                                        
 
                                        4. 
-
                                      
-
                                      service参数
                                      image-20230102005833327
                                      
-
                                      http协议
                                      概述
                                      概念：Hyper Text Transfer Protocol 超文本传输协议
                                      
-
                                        
-
                                      • 传输协议：定义了客户端和服务器端通信时发送数据的格式
                                        
+
                                      • 乘数不用符号位，写数值位即可
                                        
 
                                        • 
-
                                      • 特点：
                                        
-
                                          
-
                                        1. 基于TCP/IP的高级协议需要先经历三次握手，可靠传输
                                          2. 
-
                                        2. 默认端口号:80
                                          
-
                                          如果说域名是ip地址的简化表示，ip地址又表示着一台主机，那么使用http协议访问一个网址，相当于访问一台主机，并且端口号为80.
                                          
-
                                          
+
                                        3. 按照是0是1，要么+被乘数要么+0
                                          
 
                                          4. 
-
                                        4. 基于请求/响应模型的:一次请求对应一次响应
                                          5. 
-
                                        5. 无状态的：每次请求之间相互独立，不能交互数据
                                          6. 
-
                                        
-
                                          历史版本：
                                        
-
                                          
-
                                        • 1.0：每一次请求响应都会建立新的连接
                                          • 
-
                                        • 1.1：复用连接
                                          • 
-
                                        
+
                                      • 右移（连符号位一起逻辑右移）
                                        
+
                                        image-20230620232152706
                                        
 
                                        • 
-
                                      
-
                                      报文格式
                                      请求
                                      客户端发送给服务器端的消息
                                      
-
                                      数据格式：
                                      
-
                                        
-
                                      1. 请求行
                                         请求方式 请求url 请求协议/版本
                                         GET /login.html    HTTP/1.1
                                        
-
                                          
-
                                        • 请求方式：
                                            
-
                                          • HTTP协议有7中请求方式，常用的有2种
                                              
-
                                            • GET：
                                                
-
                                              1. 请求参数在请求行中【在url后】。
                                                2. 
-
                                              2. 请求的url长度有限制的
                                                3. 
-
                                              3. 不太安全
                                                4. 
-
                                              
+
                                            • 直到乘数全部移完
                                              
 
                                              • 
-
                                            • POST：
                                                
-
                                              1. 请求参数在请求体中
                                                2. 
-
                                              2. 请求的url长度没有限制的
                                                3. 
-
                                              3. 相对安全
                                                4. 
 
                                              
+
                                              Booth算法
                                                
+
                                              1. 部分积 乘数 y补（一开始为0）
                                                
 
                                                2. 
-
                                            
+
                                          • 部分积双符号位，乘数单符号位且参与运算
                                            
+
                                            image-20230620212054291
                                            
 
                                            • 
-
                                          
+
                                        • 每次依据乘数和y补的关系，进行是否加被乘数的决策：
                                          
+
                                          注意右移不同于原码，是算术右移
                                          
+
                                          image-20230620212122222
                                          
 
                                          • 
-
                                        
+
                                      2. 最后一步不用移位
                                        
+
                                        image-20230620212150280
                                        
 
                                        3. 
-
                                      3. 请求头：客户端浏览器告诉服务器一些信息
                                         请求头名称: 请求头值
                                        
-
                                          
-
                                        • 常见的请求头：
                                          
+
                                      
+
                                      除法运算
                                      逻辑左移
                                      
+
                                      最后得到的余数还得乘个2的-n次方
                                      
+
                                      恢复余数法
                                        
+
                                      1. 被除数（余数）  商
                                        2. 
+
                                      2. 先加上 - 除数的补
                                        3. 
+
                                      3. 如果得到结果≥0，则上商1，左移
                                        4. 
+
                                      4. 如果小于0，则上商0，+除数补，左移
                                        5. 
+
                                      5. 左移5次（商包括符号位的所有数字被填满），最后一次上商不用移位
                                        6. 
+
                                      
+
                                      不恢复余数法（加减交替法）
                                      
+
                                      image-20230621200001791
                                      
+
                                      总结一下，大概流程：
                                      
+
                                      ①准备阶段：MQ清零【存放商】，ACC放入被除数，X放入除数
                                      
+
                                      ②ACC - X中的值
                                      
+
                                      ③若ACC中值【上一轮的余数】为负，则上商0；为正，则上商1.ACC左移一位。判断MQ的最后一位【上商的值】，若为负，则ACC + X中的y；为正，ACC - X中的y。【注意，若为第一次减去X，则当余数为正时，就即刻发生溢出错误退出】
                                      
+
                                      ④重复③，直到移位n次。
                                      
+
                                      img 
                                      
+
                                      V表示是否溢出。 
                                      
+
                                      
 
                                        
-
                                      1. User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息    * 可以在服务器端获取该头的信息，解决浏览器的兼容性问题
                                        
+
                                      2. 被除数（余数） 商
                                        
 
                                        3. 
-
                                      3. Accept：可以支持的响应格式
                                        
+
                                      4. 先加上 - 除数的补
                                        
 
                                        5. 
-
                                      5. Accept-language：可以支持的语言环境
                                        
+
                                      6. 如果得到结果≥0，则上商1，左移，下一次继续加 - 除数的补
                                        
 
                                        7. 
-
                                      7. Referer：http://localhost/login.html    * 告诉服务器，我(当前请求)从哪里来？
                                        
-
                                          
-
                                        • 作用：
                                          • 
-
                                        
+
                                      8. 如果小于0，则上商0，左移，下一次加除数的补
                                        
+
                                        image-20230620234054088
                                        
+
                                        逻辑左移
                                        
+
                                        9. 
+
                                      9. 左移5次（商包括符号位的所有数字被填满），最后一次上商不用移位
                                        
+
                                        10. 
+
                                      
+
                                      浮点运算
                                      舍入
                                      
+
                                      （1）意思是，舍去的要是1，就在保留数+1.如果是0就直接舍去。
                                      
+
                                      img这意思难道是说可以一次性右移，最后再看要不要+1，而不是移一下加一次1？【不过想了一下，这两种顺序得到的结果好像是一样的。】
                                      
+
                                      
+
                                      快速进位链
                                      
+
                                      https://www.bilibili.com/video/BV1AB4y1p7ax?spm_id_from=333.880.my_history.page.click&vd_source=ac571aae41aa0b588dd184591f27f582 
                                      
+
                                      以及老师在这讲的也挺好的【p88】
                                      
+
                                      imgimg 
                                      
+
                                      当AiBi都为1时，无论Ci是什么，都必定进位1；当AiBi有一个为1时，Ci才会起决定性作用；当AiBi都为0时，无论Ci是什么，都不会进位。因此，AiBi为本地进位，Ai+Bi为传送条件。（乘号表示且，加号表示或）
                                      
+
                                      img进位链是影响加法器速度的瓶颈
                                      
+
                                      img但问题是电路太复杂了，因此给出折中方案：
                                      
+
                                      img 
                                      
+
                                      4先产生进位，传给3，3再产生进位，传给4，依次下去。
                                      
+
                                      img 
                                      
+
                                      imgimg 
                                      
+
                                      imgimg 
                                      
+
                                      相当于又套了一层并行进位链。
                                      
+
                                      img实在是太强了。感受到还要再套一层分组的必要性了。
                                      
+
                                      
+
                                      处理器
                                      RISC-V数据通路的组件选择
                                      image-20230617232028775
                                      
+
                                      RISC CPU采用哈佛架构。
                                      
+
                                      存储器
                                        
+
                                      1. DM Data Memory 数据存储器
                                        
+
                                        读异步，写有写使能
                                        
+
                                        2. 
+
                                      2. IM Instruction Memory 指令存储器
                                        
+
                                        一般read only
                                        
+
                                        3. 
+
                                      
+
                                      寄存器堆
                                      同步写异步读
                                      
+
                                      image-20230617233101214
                                      
+
                                      立即数扩展（生成）部件
                                      零扩展、符号扩展
                                      
+
                                      PC（程序计数器）
                                      支持两种加法：+4、+立即数
                                      
+
                                      ALU
                                      
+
                                      【以下运算器结构适用于累加型运算器。累加器好像意思是一次最多两个输入。 】
                                      
+
                                      运算器的功能是运算，因此其核心就是ALU（算术逻辑单元）。ALU是一个组合电路，组合电路的特点是，如果输入撤销了，那么输出结果也会撤销【组合逻辑电路】。因而，为了让ALU的结果能被保存，必须在输入端加上两个寄存器来保证信号持续输入。这两个寄存器一个叫做ACC，另一个叫做x，也叫做数据寄存器。
                                      
+
                                      imgMQ也是寄存器，用于保存计算过程中溢出的位数。
                                      
+
                                      img具体见第六章，弹幕说汇编语言也有讲。乘法要这样放是为了防止乘积低位覆盖乘数。
                                      
+
                                      img 
                                      
+
                                      imgACC里存放着上面的操作或者与外部交流得到的被乘数，按照约定需要转移到X里。我猜M放在MQ而不是ACC，可能是因为第一二步是并行的，如果放在ACC就需要一些等待。
                                      
+
                                      并且乘法做的是移位累加【可能相当于上面乘法原理的第一个图吧】，ACC用来存储这些累加的暂时交换成果，因而需要将ACC先清空为0.
                                      
+
                                      这些操作的先后顺序由控制器进行控制。
                                      
+
                                      img 
                                      
+
                                      MQ也称乘商寄存器
                                      
+
                                      
+
                                      运算类型：加、减、或、比较、slt、nor
                                      
+
                                      操作数：寄存器或立即数
                                      
+
                                      image-20230619214753499
                                      
+
                                      RISC-V部分指令的数据通路设计
                                      取数指令的完成过程
                                      
+
                                      image-20230621192714673
                                      
+
                                      下面是取数指令的完成过程。
                                      
+
                                      完成一条指令有三个阶段：取指令、分析指令、执行指令。
                                      
+
                                      取指令：PC把地址送到MAR，MAR把地址送到存储体。存储体在控制器的控制下，把地址所对应的指令的内容发给MDR，MDR把取出的指令送到IR.
                                      
+
                                      分析指令：IR将指令的操作码部分交予CU，CU控制IR，IR将指令中的地址码部分交予MAR，MAR给存储体，存储体在控制器控制下给MDR，MDR送给ACC。
                                      
+
                                      【这个过程正像是计算机网络，只不过此处全靠硬件完成，计算机网络只能依靠协议】
                                      
+
                                      
+
                                      流水线周期
                                      RISC-V
                                      image-20230617233444017
                                      
+
                                      image-20230618170512788
                                      
+
                                      注意，在ID阶段还会发生读寄存器
                                      
+
                                      image-20230617233433422
                                      
+
                                      X86
                                      
+
                                      一、指令周期
                                      
 
                                        
-
                                      1. 防盗链：image-20230101235437317如果ref头非合法就不播放
                                        2. 
-
                                      2. 统计工作：看从哪个网站来的人数多
                                        3. 
+
                                      3. 基本概念
                                        4. 
+
                                      
+
                                      ① 指令周期
                                      
+
                                      ② 每条指令的指令周期不同
                                      
+
                                      imgADD取指阶段和执行阶段都需要一次访存
                                      
+
                                      ③ 具有间接寻址的指令周期
                                      
+
                                      img 
                                      
+
                                      三个周期各需要访存一次。【****现在暂时还不知道这有毛用****】
                                      
+
                                      ④ 具有中断周期的指令周期
                                      
+
                                      img 
                                      
+
                                      ⑤ 指令周期的流程
                                      
+
                                      img 
                                      
+
                                      ⑥ CPU工作周期的标志
                                      
+
                                      指令周期的不同阶段，控制器要做不同的操作，要发出不同的命令。因而，控制器需要知道当前处于指令周期的哪一个阶段。
                                      
+
                                      img用四个触发器
                                      
+
                                        
+
                                      1. 指令周期的数据流
                                        2. 
 
                                      
+
                                      ① 取指周期
                                      
+
                                      img 
                                      
+
                                      首先，PC把自己里面存的地址放进MAR，再通过地址总线传输给存储器。
                                      
+
                                      CU通过控制总线向存储器发出读控制信号。
                                      
+
                                      存储器执行读操作，通过数据总线传输取到的指令给MDR，MDR再传给IR。
                                      
+
                                      CU把加一后的地址保存在PC中，为下一条指令取指做准备。
                                      
+
                                      ② 间址周期
                                      
+
                                      img 
                                      
+
                                      如果指令的数据部分采用的是间接寻址的方式，那么此时，MDR中的地址部分不是有效地址，而是存储存储有效地址的存储单元的地址值。因而，我们需要再通过一次访存操作，把有效地址值存储在MDR中。
                                      
+
                                      ③ 执行周期
                                      
+
                                      img留给第九章介绍。
                                      
+
                                      ④ 中断周期
                                      
+
                                      做了三件事：保存断点、形成服务程序入口地址、中断返回
                                      
+
                                      img 
                                      
+
                                      首先，保存断点。由CU来确定断电保存在内存单元的哪里。CU把地址传给MAR,MAR将其发到存储器，CU给存储器写命令。PC将自己的值【也就是下一条要执行的命令的地址值】交付给MDR，MDR传给存储器。【MDR在读写操作时都充当了缓冲区的角色。】
                                      
+
                                      然后，CU形成中断服务程序入口地址，并直接把它写入到CU。 
                                      
+
                                      
+
                                      流水线处理器
                                      流水线概述
                                      流水线
                                      image-20230618150003983
                                      
+
                                      这点我觉得讲得挺好的。以前只知道流水线通过并行来加速指令执行，但这里给出了一个新的思路：如果是单周期处理器，则RISC-V的时钟周期受执行时间最长的指令限制；如果是流水线处理器，时钟周期就可以由某个步骤决定，主频就可以加快。这个出发点很有意思。
                                      
+
                                      如果流水线各阶段平衡，也即每个阶段需要的执行时间差不多，则
                                      
+
                                      image-20230618150515599
                                      
+
                                      也即在理想条件和有大量指令的情况下，流水线带来的加速比约等于流水线的级数，若各阶段不完全平衡，加速比会变小。
                                      
+
                                      流水线技术是通过提高指令的吞吐率来提高性能的。
                                      
+
                                      RISC-V与流水线
                                      我们可以看到，比起X86，RISC-V是面向流水线设计的，其特性与流水线高度相关：
                                      
+
                                        
+
                                      1. 指令长度相同
                                        
+
                                        简化IF和ID
                                        
 
                                        2. 
-
                                      2. Connection：连接是否活着
                                        
+
                                      3. 只有六种指令格式，格式整齐
                                        
+
                                        能在一个阶段内完成译码和读寄存器（ID）
                                        
 
                                        4. 
-
                                      
+
                                    • 只通过load、store访存
                                      
+
                                      可以利用EX阶段计算存储器地址，然后在下一阶段访存（MEM）
                                      
 
                                      • 
-
                                    
+
                                  
+
                                  流水线冒险
                                  image-20230618151040625
                                  
+
                                  结构冒险
                                  image-20230618151208189
                                  
+
                                  数据冒险
                                  image-20230618151243620
                                  
+
                                  解决方法
                                  前递
                                  image-20230618151601721
                                  
+
                                  编译重排
                                  image-20230618151706080
                                  
+
                                  停顿（气泡）
                                  实在不行只能暂停流水线了
                                  
+
                                  image-20230618151637437
                                  
+
                                  控制冒险
                                  image-20230619220308876
                                  
+
                                  解决方法
                                  硬件支持
                                  image-20230619220259945
                                  
+
                                  分支预测
                                    
+
                                  1. 遇到分支预测就停顿
                                    
 
                                    2. 
-
                                  2. 请求空行
                                     空行，就是用于分割POST请求的请求头，和请求体的。
                                    
+
                                  3. 分支预测
                                    
+
                                      
+
                                    1. 静态分支预测
                                      
+
                                      image-20230618153106322
                                      
 
                                      2. 
-
                                    2. 请求体(正文)：
                                      
-
                                        
-
                                      • 封装POST请求消息的请求参数的
                                        • 
-
                                      
+
                                    3. 动态分支预测
                                      
+
                                      image-20230618153125295
                                      
 
                                      4. 
 
                                    
-
                                    字符串格式：
                                    
-
                                    //请求行
                                    POST /login.html	HTTP/1.1
                                    //请求头
                                    Host: localhost
                                    User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0
                                    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
                                    Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
                                    Accept-Encoding: gzip, deflate
                                    Referer: http://localhost/login.html
                                    Connection: keep-alive
                                    Upgrade-Insecure-Requests: 1
                                    //请求空行

                                    //请求体
                                    username=zhangsan	
                                    
-
-
-
-
                                    响应
                                    响应消息：服务器端发送给客户端的数据
                                    
-
                                    数据格式：
                                    
-
                                      
-
                                    1. 响应行
                                      
-
                                        
-
                                      1. 组成：协议/版本 响应状态码 状态码描述    HTTP/1.1 200 OK
                                        
 
                                        2. 
-
                                      2. 响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态, 状态码都是3位数字. 分类:
                                        
+
                                      
+
                                      流水线数据通路和控制
                                      流水线数据通路
                                      流水线寄存器
                                      image-20230618154028950
                                      
+
                                      image-20230618154608423
                                      
+
                                      66666，这个帅
                                      
+
                                      image-20230618154815411
                                      
+
                                      流水线控制
                                      数据冒险：前递与停顿
                                      前递
                                      分类
                                      前递有两种情况：
                                      
+
                                      image-20230618155952018
                                      
+
                                      前递产生条件
                                        
+
                                      1. RegWrite != 0（写有效）
                                        2. 
+
                                      2. Rd != x0
                                        3. 
+
                                      
+
                                      解决方法
                                      流水线寄存器解决：
                                      
+
                                      image-20230618160141827
                                      
+
                                      并且增加前递所需硬件。
                                      
+
                                      停顿
                                      流水线寄存器解决：
                                      
 
                                        
-
                                      1. 1xx：服务器接收客户端消息，但没有接收完成，等待一段时间后，发送1xx多状态码，询问是否还要继续发
                                        
-
                                        2. 
-
                                      2. 2xx：成功。代表：200
                                        
+
                                      3. 置ID/EX寄存器中控制信号为0（防止寄存器和存储器被写入数据），执行空指令nop
                                        
 
                                        4. 
-
                                      4. 3xx：重定向。代表：302(重定向)，304(访问缓存)
                                        
-
                                        image-20230103151112791
                                        
-
                                        需要自动重定向到另一个C去
                                        
-
                                        image-20230103151237984
                                        
-
                                        发现资源未变化且本地有缓存
                                        
+
                                      5. 禁止PC寄存器和IF/ID寄存器内容改变
                                        
+
                                        下一条指令就能重新取指
                                        
 
                                        6. 
-
                                      6. 4xx：由客户端造成的错误
                                        
-
                                        代表：
                                        
+
                                      
+
                                      控制冒险
                                      image-20230618161320779
                                      
+
                                      image-20230618161333487
                                      
+
                                      缩短分支延迟的方法：
                                      
+
                                      硬件支持
                                      image-20230618161429557
                                      
+
                                      动态分支预测
                                      image-20230618161807387
                                      
+
                                      image-20230618161932429
                                      
+
                                      计算目标地址
                                      image-20230618162114338
                                      
+
                                      流水线的多发技术
                                      img 
                                      
+
                                      img 
                                      
+
                                      超流水技术要求一个时钟周期内不同的指令不能相互叠加干扰。
                                      
+
                                      img 
                                      
+
                                      意思就是多条指令并成一条，有公共的取指、译码、写回阶段，但是执行阶段各不相同且并行执行，应该是这样。 
                                      
+
                                      例外和中断
                                      概述
                                      image-20230618162247586
                                      
+
                                      内部的一定是例外，外部的只有IO请求和硬件故障是中断
                                      
+
                                      image-20230618162302149
                                      
+
                                      image-20230618162437636
                                      
+
                                      image-20230618162500928
                                      
+
                                      哦哦哦WOC!!!!!
                                      
+
                                      这让我想起来在做xv6的时候，的那个kerneltrap和usertrap，应该就是这里的这个统一入口地址。
                                      
+
                                      xv6是RISC-V架构，故而发生中断的时候，就会跳转到统一的kernel trap，然后再在里面通过scause进行读取。666
                                      
+
                                      不过盘问了下gpt，RISC-V对于exception和interruption的处理方式是不一样的：
                                      
+
                                      在RISC-V中，异常通常是由于程序执行过程中的错误或非预期事件而引起的，包括故障（faults）、陷阱（traps）和中止（aborts）。中断（interrupts）则是由外部事件触发的，例如定时器到期、外部设备请求等。中断是异步事件，与当前正在执行的指令无关，因此会在任何时候发生。
                                      
+
                                      例外是通过统一入口地址处理，中断则是中断向量的方式
                                      
+
                                      流水线中的例外
                                      image-20230618163521639
                                      
+
                                      微操作（X86）
                                      X86将一条指令的执行分为多个微操作。
                                      
+
                                      
+
                                      一、微操作命令分析
                                      
+
                                      微操作命令是控制单元在完成一大条指令时所需要细分完成的一条条微小的命令
                                      
+
                                      image-20230621201435702
                                      
 
                                        
-
                                      1.  404（请求路径没有对应的资源，可能路径输错了）
                                        
+
                                      2. 取值周期
                                        
+
                                        image-20230621201345807
                                        
 
                                        3. 
-
                                      3. 405：请求方式没有对应的doXxx方法
                                        
-
                                        当我们在Servlet中未重写doXXX方法，就默认不能用此方法进行访问。因为doXXX方法的默认实现为：
                                        
-
                                        String protocol = req.getProtocol();
                                        String msg = lStrings.getString("http.method_get_not_supported");
                                        if (protocol.endsWith("1.1")) {
                                            resp.sendError(405, msg);
                                        } else {
                                            resp.sendError(400, msg);
                                        }
                                        4. 
-
                                      
+
                                    2. 间址周期
                                      
+
                                      image-20230621201351939
                                      
 
                                      3. 
-
                                    3. 5xx：服务器端错误。
                                      
-
                                      代表：500(服务器内部出现Exception)
                                      
-
                                      int i = 3/0;
                                      4. 
-
                                    
+
                                  4. 执行周期  ①访存指令  ②非访存指令  ③转移指令  ④三类指令的指令周期
                                    
+
                                    image-20230621201358396
                                    
+
                                    imgimg
                                    
+
                                    image-20230621201423245
                                    
 
                                    5. 
-
                                  
+
                                5. 中断周期  硬件法和软件法
                                  
+
                                  imgimg
                                  
+
                                  硬件和软件法。
                                  
 
                                  6. 
-
                                6. 响应头：
                                  
+
                                
+
                                二、控制单元的功能
                                
 
                                  
-
                                1. 格式：    [头名称 : 值]
                                  
+
                                2. 输入信号
                                  
+
                                  ①时钟信号  ②指令寄存器【控制信号与操作码有关】  ③标志  ④外来信号【中断请求、总线请求】
                                  
 
                                  3. 
-
                                3. 常见的响应头：
                                  
-
                                    
-
                                  1. Content-Type：服务器告诉客户端本次响应体 数据格式以及编码格式
                                    
-
                                    浏览器依照编码格式来对该页面进行解码。
                                    
+
                                  2. 输出信号
                                    
+
                                    ①CPU内各种控制信号【比如（PC）+1->PC这种】
                                    
+
                                    ②送至控制总线的信号【比如中断响应、总线响应】
                                    
 
                                    3. 
-
                                  3. Content-disposition：服务器告诉客户端以什么格式打开响应体数据
                                    
-
                                      
-
                                    • 值：
                                        
-
                                      • in-line：默认值，在当前页面内打开
                                        • 
-
                                      • attachment;filename=xxx：以附件形式打开响应体。也即点击超链接后开始文件下载
                                        • 
-
                                      
+
                                    • 控制信号举例
                                      
+
                                      ①不使用内部总线
                                      
+
                                      ②采用内部总线
                                      
 
                                      • 
-
                                    
+
                                  4. 多级时序系统
                                    
+
                                      
+
                                    1. 机器周期  
                                      
+
                                      取指周期=机器周期=最复杂的微操作所需时间【访存】
                                      
+
                                      在机器周期内部也需要有时钟来控制微操作的执行顺序
                                      
 
                                      2. 
-
                                    
+
                                  5. 时钟周期（节拍、状态）
                                    
+
                                    每个指令周期都可分为若干个机器周期，每个机器周期都可分为若干个节拍（时钟周期）。一个机器周期内包含多少节拍与需要发送多少控制信号、控制信号复杂度、控制信号能否并行有关。
                                    
+
                                    时钟产生节拍信号，不同的节拍信号有不同的先后顺序。
                                    
+
                                    一个时钟周期产生一个或几个【并行的几个，或者是操作时间很短，虽然有一定的先后顺序，但可以在一个节拍内完成】微操作命令
                                    
+
                                    时钟信号利用上升沿让CU发出控制命令【微操作】控制各个不同部件。
                                    
 
                                    6. 
 
                                  
 
                                  4. 
-
                                4. 响应空行
                                  
-
                                  5. 
-
                                5. 响应体：传输的数据
                                  
+
                                6. 控制方式
                                  
+
                                  ①同步控制方式  采用定长的机器周期、不定长的机器周期、中央控制和局部控制相结合
                                  
+
                                  ​    当指令大多都是可以提前确定的，就用同步。当一条微操作的时间很难控制，可以采用异步控制。
                                  
+
                                  ②异步控制方式  等待IO读写
                                  
+
                                  ③联合控制方式  同步与异步结合
                                  
+
                                  ④人工控制
                                  
 
                                  7. 
 
                                
-
                                字符串格式:
                                
-
                                //响应行
                                HTTP/1.1 200 OK
                                //响应头
                                Content-Type: text/html;charset=UTF-8
                                Content-Length: 101
                                Date: Wed, 06 Jun 2018 07:08:42 GMT
                                //响应空行

                                //响应体
                                <html>
                                    <head>
                                        <title>$Title$</title>
                                    </head>
                                    <body>
                                        hello , response
                                    </body>
                                </html>
                                
-
-
-
-
                                Request
                                继承体系结构
                                ServletRequest(I) - HttpServletRequest(I) - RequestFacade(C)[tomcat创建] 
                                
-
                                功能
                                获取请求行
                                  
-
                                1. 获取请求方式  POST
                                  
-
                                  String getMethod()
                                  2. 
-
                                2. 获取虚拟目录  /webdemo
                                  
-
                                  String getContextPath()
                                  3. 
-
                                3. 获取Servlet路径 /demo1
                                  
-
                                  String getServletPath()
                                  4. 
-
                                4. 获取get方式请求参数 name=zhangsan
                                  
-
                                  &分割每个键值对
                                  
-
                                  String getQueryString()
                                  5. 
-
                                5. 获取请求URI和URL
                                  
-
                                  //  /webdemo/demo1
                                  String getRequestURI();

                                  //  http://localhost/webdemo/demo1
                                  StringBuffer getRequestURL();
                                  
-
-
                                  
-
                                  URL:统一资源定位符 ： http://localhost/day14/demo1    中华人民共和国
                                  URI：统一资源标识符 : /day14/demo1                    共和国
                                  
-
                                  URI的代表范围更大
                                  
-
                                  
+
                                  三、组合逻辑设计
                                  
+
                                    
+
                                  1. 组合逻辑控制单元框图
                                    
+
                                    ①CU外特性  ②节拍信号
                                    
 
                                    2. 
-
                                  2. 获取协议及版本  HTTP/1.1
                                    
-
                                    String getProtocol()
                                    3. 
-
                                  3. 获取访问的客户机的IP地址
                                    
-
                                    String getRemoteAddr()
                                    4. 
-
                                  
-
                                  获取请求头
                                    
-
                                  1. 通过请求头的名称获取请求头的值
                                    
-
                                    String getHeader(String name)
                                    2. 
-
                                  2. 获取所有的请求头名称
                                    
-
                                    Enumeration<String> getHeaderNames()
                                    
-
-
                                    返回的是一个迭代器
                                    
+
                                  3. 微操作的节拍安排
                                    
+
                                    ①安排微操作时序的原则
                                    
+
                                    原则一：先后顺序不更改。
                                    
+
                                    原则二：可以并行执行的，且微操作间没有先后顺序的，就尽量把它们安排在一个节拍中。
                                    
+
                                    原则三：时间较短微操作尽量在一个节拍内且可以有先后顺序。
                                    
+
                                    ②取值周期间址周期执行周期的
                                    
+
                                    image-20230621201709245
                                    
+
                                    image-20230621201717225
                                    
+
                                    image-20230621201722561
                                    
+
                                    image-20230621201732549
                                    
 
                                    4. 
 
                                  
-
                                  public class Servletdemo2 extends GenericServlet {

                                      public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
                                          HttpServletRequest req = (HttpServletRequest) servletRequest;
                                          Enumeration<String> enumerator = req.getHeaderNames();
                                          while(enumerator.hasMoreElements()){
                                              String name = enumerator.nextElement();
                                              System.out.println(name);
                                              //System.out.println(name+"-----"+req.getHeader(name));
                                          }
                                      }
                                  }

                                  输出结果：
                                  host
                                  connection
                                  sec-ch-ua
                                  sec-ch-ua-mobile
                                  sec-ch-ua-platform
                                  upgrade-insecure-requests
                                  user-agent
                                  accept
                                  purpose
                                  sec-fetch-site
                                  sec-fetch-mode
                                  sec-fetch-user
                                  sec-fetch-dest
                                  accept-encoding
                                  accept-language
                                  cookie
                                  
-
-
                                  这些请求头名称正是上面的键值对里的键。
                                  
-
                                  获取请求体
                                  request将请求体中的数据封装成了流。如果数据是字符，那就是字符流；是视频这种的字节，那就是字节流。
                                  
-
                                  * 步骤：
-    1. 获取流对象
-  *  BufferedReader getReader()：获取字符输入流，只能操作字符数据
-  *  ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据
-    2. 操作流获取数据
-
                                  
-
                                  @WebServlet("/demo2")
                                  public class Servletdemo2 extends GenericServlet {

                                      public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
                                          HttpServletRequest req = (HttpServletRequest) servletRequest;
                                          BufferedReader bfr = req.getReader();
                                          String line;
                                          while((line = bfr.readLine())!=null){
                                              System.out.print(line);
                                          }
                                      }
                                  }
                                  
-
-
                                  请求体中键值对会在一行里，用&分割
                                  
+
                +

                存储器

                概述

                分类

                image-20230618183618033

                +

                层次结构

                +

                寄存器分为两类，体系结构寄存器和非体系结构寄存器。前者可以让程序员调度使用，后者不行。

                +
                +

                image-20230618183742599

                +

                image-20230618183845067

                +

                主存储器

                概述

                基本组成

                +

                MAR中的地址需要经过译码器才能得到对应存储体中的位置。MDR中的数据是读是写需要通过读写电路控制，读写电路接收控制电路的读写信号。

                +
                +

                image-20230618184214916

                +

                与CPU连接

                image-20230618211118255

                +

                小端模式

                image-20230618211717123

                +

                技术指标

                image-20230618211918511

                +

                半导体存储芯片简介

                基本结构

                image-20230618212044462

                +

                image-20230618212116854

                +

                译码驱动方式

                线选法

                image-20230618212207454

                +
                重合法

                image-20230618212227553

                +

                RAM 随机存取存储器

                DRAM和SRAM

                image-20230618222428159

                +

                SRAM

                基本电路
                +

                image-20230621193330855

                +

                核心就是利用****触发器（T1—T4）****来表示0和1的

                +

                用T5和T6行开关来控制对触发器部件读写，用T7和T8列开关……【对应上面说的重合法？】

                +

                写入要在A段写入数据，同时在A’段写入数据的非【因为触发器是双稳态的，要求两边输入的信号相反。】对应的，写选择那边输入数据也得对称经过门和非门。

                +
                +
                经典芯片

                image-20230618212447162

                +
                读写

                img

                +

                上面的部分是64*64的基本电路矩阵。我们按列分，每十六列为一组，则分成了四组。因为2^4=16，因而我们用四位来表示地址控制信号。

                +

                对于行，当地址控制信号为0000时，表示选择存储矩阵的第一行的数据，为0001时，选择第二行的……依此类推。

                +

                对于列，当地址控制信号为0000时，表示选择每一组的第一列的数据，为0001时，选择第二列的……依此类推。

                +

                每一组只能有一列被选中，这就达到了一次读写四位的目的。【一个字节分开存】

                +

                DRAM

                基本电路
                +

                主要是通过电容的充放电实现的

                +

                img

                +

                左侧三管那个中，读数据线读出的跟存储的是相反的，存0读1，存1读0.但写入跟输入的信息是相同的。

                +

                右侧单管中，读出时数据线有电流则是1，没有则是0.写入时，对Cs充电则为1，Cs放电（输入信号为低电平）则为0.

                +
                +

                image-20230618215704699

                +
                经典芯片/读写

                image-20230618215803608

                -

                获取时中文乱码

                -
                  -

                • get方式：tomcat 8 已经将get方式乱码问题解决了

                  +

                  img

                  +

                  14位的地址分了两次传，分别作为行列地址。

                  +

                  RAS:行选控制信号 CAS：列选控制信号 WE：读写控制信号。产生的时钟控制了芯片内部的读写操作

                  +

                  img

                  +

                  如果读放大器左边有电，那么右边输出没电；左没电右有电.这样，读放大器左边的部分，有电表示0，没电表示1 ；读放大器右边的部分，有电表示1，没电表示0.

                  +
                +
                刷新

                为什么要刷新：

                +

                image-20230619224003589

                +
                集中刷新

                image-20230618221439701

                +
                分散刷新

                image-20230618221603727

                +
                异步刷新

                image-20230618222049113

                +

                ROM 只读存储器

                  +

                1. 掩膜ROM(MROM) 用户不能修改

                  +

                  image-20230618222716561

                  2. -

                2. post方式：会乱码

                  -
                                     * 解决：在获取参数前，设置流的编码:
-
-    
                  request.setCharacterEncoding("utf-8");
                  
-
                  +

                3. PROM（一次性编程） 破坏性编程

                  +

                  image-20230618223116398

                  4. -
          -
    -
    获取请求参数通用的方法（通用指对get和post通用）

    这里的请求参数应该是指上面Post的请求体、Get的请求行里的参数，请求头里的参数是获取不到的。

    -
      -

    1. 根据参数名称获取参数值

      -
      String getParameter(String name)
      - -

      如 username=zs&password=123，getParameter(“username”)会得到zs。

      +

    2. EPROM（多次性编程）

      +

      image-20230618223151914

      3. -

    3. 根据参数名称获取参数值的数组

      -
      String[] getParameterValues(String name)
      - -

      如 hobby=xx&hobby=game，会得到{xx,game}

      +

    4. EEPROM（电可擦写）

      +

      image-20230618223229585

      +
      5. +

    5. Flash Memory（闪速型存储器）

      +

      image-20230618223252821

      6. -

    6. 获取所有请求的参数名称

      -
      Enumeration<String> getParameterNames()
      7. -

    7. 取所有参数的map集合

      -
      Map<String,String[]> getParameterMap()
      8. -
    -
    请求转发

    在服务器内部资源跳转。

    -

    image-20230102195615676

    -

    AServlet做了一部分事情，把剩余的事情交给BServlet去做

    -

    步骤：

    -
      -

    1. 通过request对象获取请求转发器对象

      -
      RequestDispatcher getRequestDispatcher(String path)
      2. -

    2. 使用RequestDispatcher对象来进行转发

      -
      requestDispatcher.forward(ServletRequest request, ServletResponse response)
      3. -
    -
    @WebServlet("/demo2")
    public class Servletdemo2 extends GenericServlet {

        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
            System.out.println("I am "+Servletdemo2.class.getName());
            //进行转发
            servletRequest.getRequestDispatcher("/demo3")
                .forward(servletRequest,servletResponse);
        }
    }

    @WebServlet("/demo3")
    public class ServletDemo3 extends GenericServlet {

        public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
            System.out.println("I am "+ServletDemo3.class.getName());
        }
    }
    - -

    特点：

    -
      -
    1. 浏览器地址栏路径不变
      2. -
    2. 只能在服务器内部跳转，只能转发到服务器内部的资源中
      3. -
    3. 转发是一次请求，多个资源使用的是同一次请求
    -
    共享数据

    接力工作的两个Servlet可以通过request对象进行数据通信。

    -
    * 方法：
-
    +

    存储器与CPU的连接

    存储器容量的扩展

    位扩展

    image-20230618224638384

    +
    字扩展

    image-20230618224745584

    +

    带了片选思想

    +
    位字扩展

    image-20230618224955557

    +

    存储器与CPU的连接

    存储器的校验

    image-20230620221830055

    +

    汉明码组成

    image-20230620222021345

    +

    image-20230620222133679

    +

    image-20230620222301502

    +

    n为数据的位数

    +

    image-20230620222225994

    +

    image-20230620222518156

    +

    汉明码纠错

    image-20230620222951821

    +

    跟组成的步骤是一样的

    +

    提高访存速度的措施

    image-20230618233156234

    +

    image-20230618233234559

    +

    image-20230618233325427

    +

    image-20230619224341497

    +

    image-20230618233855438

    +

    不过这里也帅得一批，非常有那种从小到大的抽象思维在。

    +

    之前的单独一块RAM芯片，一个字节是分开存；这里的一个主存堆，一个块是分主存存。

    +

    Cache 高速缓冲存储器

    概述

    image-20230618233726163

    +

    技术指标

    image-20230618233800847

    +

    image-20230618234113714

    +

    因为在一个存取周期当中，每体都可以取一个字，16体就可以取16字，因而一个存取周期可以取出16个字出来。

    +

    image-20230618234151529

    +

    但是这个公式前提是访问cache和主存并行。如果换用另一个策略，即先看cache有没有，没有再去主存，计算公式就不一样。

    +

    Cache的读写操作

    +

    img

    +

    cache接收CPU发来的地址信号。CPU发出的地址中的块内地址无需转换，而块号需要通过主存cache地址映射变换机构转化成cache内的块号。【所以说CPU访问cache的时候，传给cache的地址是主存的物理地址吧？然后再通过主存cache地址映射转化为cache的块内地址。】

    +

    如果命中，则转换机构工作，传递地址给cache存储体，存储体通过数据总线发送信号。

    +

    如果不命中，并且cache没装满，则发送信号给主存。

    +

    如果不命中，且cache装满了，则cache替换机构使用替换算法，淘汰cache中一些块，同时发送信号给主存。

    +

    主存收到信号，在数据总线上发给cpu要的东西之后，再将所在块发给cache。

    +

    image-20230621193732489

    +
    +

    读

    image-20230618234639119

    +

    写

    image-20230618234752772

    +

    Cache-主存映射

    直接映射

    image-20230618234904098

    +

    image-20230618234921789

    +

    全相联映射

    image-20230618235007647

    +

    组相联映射

    image-20230618235147739

    +

    缓存替换算法

    image-20230618235750985

    +

    改进

    +

    现在很多处理器至少有三级cache。比如每个核一个cache，多个核还有一个公用的cache。

    +

    流水线计算机很多都分了指令cache和数据cache，避免资源冲突。

    +

    注意，每个层次的cache采用的映射可能不一样。

    +

    靠近CPU采用直接相连或者路数（r）少的组相连【其实直接相连就相当于是一路的组相联了】。中间的用组相联。距离CPU较远的用全相联。

    +

    距离越远，对速度要求越低，对利用率要求越高。

    +
    +

    虚拟存储器

    与Cache的差异

    image-20230619000944183

    +

    虚拟存储器

    image-20230618235955557

    +

    image-20230619000042556

    +

    相当于把主存-辅存（磁盘）看成另一个cache-主存。这也就类似于内存页面换入换出了。原来这玩意叫虚拟存储器啊，不过这也类似于虚拟地址空间的叫法就是了。

    +

    image-20230619000208477

    +

    image-20230619000304314

    +

    页表结构

    image-20230619000428020

    +

    访问流程

    image-20230619000542665

    +

    TLB

    image-20230619000628910

    +

    image-20230619000804374

    +

    image-20230619000827244

    +

    image-20230619000851370

    +

    辅助存储器

    硬盘、U盘、软盘、磁带、光盘

    +

    RAID

    image-20230619142112318

    +

    image-20230619142148621

    +

    image-20230619143428427

    +

    image-20230619143411577

    +

    系统总线

    概述

    是啥

    总线两个特点：分时和共享

    +

    遵循协议或标准，方便计算机系统集成、扩展和进化

    +

    总线的猝发传输方式：在一个总线周期内，传输存储地址连续的多个数据字的总线传输方式。

    +

    分类

    image-20230618173335493

    +

    image-20230618173414845

    +

    总线结构

    单总线

    注意，单总线是默认统一编址的？

    +

    image-20230618175005524

    +

    面向CPU的双总线

    image-20230618175035406

    +

    存储器为中心

    image-20230618175435591

    +

    有通道的多总线结构

    image-20230618175533637

    +

    image-20230618175631552

    +

    帅

    +

    image-20230618175705273

    +

    image-20230618175743501

    +

    总线控制

    总线判优控制

    image-20230618180345695

    +

    image-20230618180704321

    +

    注意，独立请求是最快的

    +

    链式查询

    +

    所有设备可在BR线发布总线请求，主设备通过BG线表态，争得总线的设备要通过BS线告诉其他设备总线忙。

    +

    BG线中，总线同意信号会依次遍历每一个设备，直到找到第一个提出请求的设备。

    +

    可见，这个遍历顺序就代表了各个IO设备的优先级顺序。

    +

    这样相当于分离出格外的线来控制信号。这种方式对电路故障非常敏感。

    +
    +

    image-20230618180431836

    +

    计数器定时查询

    +

    意思好像是，在BR线提出请求，主设备接收到请求后，可以响应的情况下，启动计数器，计数器初始值为零。计数器的值通过设备地址线输出。如果计数器为0，则观察接口0有没有请求，没有的话计数器++，继续看下一个，以此类推，直到找到第一个对应接口，则开始传输数据，BS线启用。

    +

    设备地址线需要给所有设备地址进行编码，因此宽度与设备数有关。

    +

    这个的优点在于，优先级的确定更加灵活了。比如说，计数器不一定从零开始而是从上一次停止的地方开始（循环优先级，这样的话每个设备的机会均等），或者用软件控制优先级初始值，或者每一次不一定++而是有其他计算规则。

    +
    +

    image-20230618180602116

    +

    独立请求方式

    +

    优先级由主设备内部逻辑（排队器）规定。也可以用自适应、计数器等等等。

    +
    +

    image-20230618180645765

    +

    总线通信控制

    image-20230618180848436

    +

    这玩意传输周期还考了

    +

    image-20230618180912414

    +

    这个通信方式有哪几种也要求默写了

    +

    image-20230618181827840

    +

    这个同步和异步的特点总结得很棒

    +

    同步、异步、半同步三者的共同点：

    +

    image-20230618181948854

    +

    同步

    +

    img定宽定距的时钟

    +

    白色菱形代表有地址、命令、数据；紫色阴影代表没有东西

    +

    数字电路中，数字电平从低电平（数字“0”）变为高电平（数字“1”）的那一瞬间（时刻）叫作上升沿。数字电平从高电平（数字“1”）变为低电平（数字“0”）的那一瞬间叫作下降沿。

    +

    有固定的时间点，和在每个固定时间点固定要做的事

    +

    第一部分：主设备要给出地址信号

    +

    第二部分：给出读命令（控制信号）

    +

    第三部分：从设备传输数据给主设备

    +

    第四部分：读命令、数据信号撤销

    +

    第五部分：地址信号撤销

    +

    img

    +

    *先给数据能保证命令到达立刻写入正确数据。菱形那段表示电平并非瞬间稳定*

    +

    *如果数据是并行就先给数据，再给读写信号，直接锁存；如果是串行数据，就先给读写信号，再给数据*

    +

    有固定的时间点，和在每个固定时间点固定要做的事

    +

    第一部分：主设备要给出地址信号

    +

    第二部分：主设备给出数据信号

    +

    第三部分：主设备给出写入信号

    +

    第四部分：写入

    +

    第五部分：读命令、数据信号撤销

    +

    第六部分：地址信号撤销

    +
    +

    同步通信通常只适用于总线长度短的。

    +

    因为是并行总线，总线长度长了很难做到等长，到达设备后就不同步了

    +

    因为需要统一时标；总线长，需要迁就最远的设备；读写时间差距大，需要迁就最慢的设备

    +

    异步

    image-20230618181416220

    +
    不互锁

    CPU从主存读信息

    +

    主要用在单机不同设备之间的通信中

    +
    半互锁

    多机系统中，某个CPU需要访问共享存储器时

    +
    全互锁

    主要用于网络通信，如TCP三握手

    +

    半同步通信

    输入数据为例：

    +

    image-20230618181924196

    +

    分离式通信

    +

    在子周期2中，从模块实际上从从模块变成了主模板，因为它发起了占用总线的请求。

    +
    +

    image-20230618182050912

    +

    IO

    概述

    发展概况

    image-20230619144243913

    +

    image-20230619144359313

    +

    image-20230619144452679

    +

    组成

    image-20230619144602504

    +
    +

    ① IO指令

    +

    操作码相当于标志，标志这个指令是IO的。命令码才算是操作码，指出对IO设备做什么。设备码给出IO设备或者设备中某一个寄存器【端口】的编址。

    +

    ② 通道指令

    +

    通道是小型DMA处理器，可以实现IO设备与主机之间进行信息交互。

    +

    通道有自己的控制器，有的通道还有存储器。

    +

    通道能够执行由通道指令组成的通道程序。

    +

    通常情况下，编程人员在应用程序当中，为了调用外部设备，应用程序中需要增加广义IO指令【这意思是封装吧】。广义IO指令要指出参加数据传输的IO设备、数据传输主存的首地址、传输数据的长度、传输方向。操作系统根据广义IO指令给出的参数以及要求的操作，会编写一个由通道指令组成的通道程序，并且会把程序放到内存或者是通道内存的指定位置，之后启动通道进行工作。

    +
    +

    连接方式

    编址

    image-20230619144651480

    +

    选址和传送

    image-20230619144727325

    +

    联络方式

    image-20230619144851937

    +

    image-20230619145010236

    +

    连接方式

    image-20230619145037444

    +

    控制方式

    image-20230619145313853

    +

    程序查询方式

    image-20230619145133293

    +

    程序中断方式

    image-20230619145154206

    +

    image-20230619145214775

    +

    DMA方式

    image-20230619145252864

    +

    外部设备

    概述

    image-20230619145414624

    +

    IO接口

    概述

    image-20230619151239077

    +

    功能和组成

    image-20230619151310223

    +

    image-20230619151421396

    +

    image-20230619151442848

    +

    接口类型

    image-20230619151602920

    +

    程序查询方式

    image-20230619151713642

    +

    image-20230619152130068

    +

    image-20230619152909693

    +

    程序中断方式

    中断

    概述

    image-20230619153352974

    +

    image-20230619153557165

    +

    接口电路

    image-20230619153715848

    +
    中断请求触发器和中断屏蔽触发器

    image-20230619153949008

    +

    image-20230619154445642

    +

    中断分类

    外部中断一般是由计算机外设发出的中断请求，如：键盘中断、打印机中断、定时器中断等。

    +

    外部中断一般指io高低电平(下降沿等由寄存器配置)来触发并响应io中断函数。

    +

    接口电路

    排队器

    image-20230619155014803

    +

    image-20230619155029933

    +
    硬件实现

    image-20230619155054248

    +
    +

    以下介绍的是链式排队器

      -

    1. 存储键值对

      -
      void setAttribute(String name,Object obj)
      2. -

    2. 获取值

      -
      Object getAttitude(String name)
      3. -

    3. 移除键值对

      -
      void removeAttribute(String name)
      4. +
    4. INTR默认为0，取非为1. 经&后整个排队电路为1
      5. +
    5. 当i设备发出请求，INTRi=1，取非为0，经&后变为0，INTPi之后的电路清零，只有i之前的INTP为1
      6. +
    6. 3在一连串的显示为 1 的INTP中，最后一个显示1的设备优先级最高。因为按照我们的分析，是它发出了请求
    -
    获取ServletContext
    ServletContext getServletContext()
    - -
    练习：结合数据库与Servlet进行用户登录
    -

    要求：

    -

    1.编写login.html登录页面
    username & password 两个输入框
    2.使用Druid数据库连接池技术,操作mysql，day14数据库中user表
    3.使用JdbcTemplate技术封装JDBC
    4.登录成功跳转到SuccessServlet展示：登录成功！用户名,欢迎您
    5.登录失败跳转到FailServlet展示：登录失败，用户名或密码错误

    +

    使用与非+非而不是直接与门是因为与非门+非更便宜。

    +

    我猜这个意思是，链式排队的话，越前面的优先级越高，现在我们讲的是怎么快速****找出****最高的最前面的是哪一个。之所以为什么越前面的优先级最高，可从这个电路中得知。如果一个东西发出请求，那么它后面的INTPi’都会被置零，因而它肯定比它后面的高级。因此越前面的优先级越高。

    +

    https://www.likecs.com/show-390301.html

    +

    img

    +

    这个可以验证我的观点。至于这个轮询方式，应该在第三章的总线那边讲过，应该用的是链式查询。

    -
    文件结构

    ![屏幕截图 2023-01-02 235207](./JavaWeb/屏幕截图 2023-01-02 235207.png)

    +
    软件实现

    程序查询

    +

    image-20230619155116410

    +

    中断向量形成部件

    硬件向量法

    image-20230619155154822

    +
    软件查询法

    image-20230619161630629

    +

    接口电路组成

    image-20230619161803883

    -

    错误历程

    +

    应该意思就是，参照上面那个程序电路图，首先CPU先发送一个启动IO设备的命令，然后就去忙了。

    +

    与此同时，IO接口接到命令开始准备，比如说对DBR的整理【因读写而异】。

    +

    IO接口准备完之后会卡在INTR那边，等待CPU的中断查询信号。

    +

    CPU本来一直在不断边干自己的活边发送中断查询信号【在每条指令执行阶段的结束前】，终于逮到这个时候发现IO接口已经准备好了，就回复中断响应信号，CPU进入中断周期，执行中断隐指令。

    +

    IO接口发出中断请求后就排好队选好设备了，收到CPU的中断响应信号，就给CPU发向量地址，CPU根据地址去内存中找到中断服务程序并开始执行，之后就可以开始数据传输了。

    +

    可见这个过程是异步的。

    +
    +

    中断响应（中断处理过程）

    image-20230619162001376

    +

    image-20230619162057309

    +

    IO中断处理过程

    image-20230619162142239

    +

    image-20230619201800980

    +

    单重/多重中断服务流程（CPU）

    image-20230619201934346

    +

    image-20230619202014591

    +

    image-20230619202106846

    +

    中断屏蔽技术（CPU）

    image-20230619202207357

    +

    image-20230619202219859

    +

    image-20230619202321781

    +

    image-20230619202355070

    +

    image-20230619202434146

    +

    DMA方式

    特点

    image-20230619202548302

    +

    实现方案

    image-20230619202628150

    +

    沙比

    +

    image-20230619202708423

    +

    image-20230619202739633

    +

    功能和组成

    image-20230619202841809

    +

    image-20230619203043097

    +

    工作过程

    DMA传送过程

    预处理、数据传送、后处理

    +

    image-20230619203248171

    +

    注意还有个传送字数，看来有点安全设定。如果溢出了就需要中断

    +

    image-20230619203423482

    +

    image-20230619203535039

    +

    连接方式

    image-20230619204520342

    +

    image-20230619204537086

    +

    与程序中断比较

    image-20230619204641555

    +]]> + + + 密码学基础 + /2023/11/26/cryptography/ + +

    学习目的：顺利过考试，以及获取基本的密码学知识，数学原理不重要

    +
    +

    第一章 概述

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    第二章 传统密码技术

    概念

    image

    +

    image

    +

    分类

    置换密码

    image

    +

    列置换密码

    加密

    image

    +
    解密

    image

    +
    例子

    image

    +

    image

    +

    周期置换密码

    image

    +

    image

    +

    代换密码

    image

    +

    单表代换

    image

    +

    image

    +

    多表代换

    image

    +

    image

    +

    image

    +

    image

    +

    传统密码体制分析

    频率（单表代换）

    image

    +

    重合指数（多表代换）

    image

    +

    明文-密文对（hill密码）

    image

    +

    第三章 分组密码-DES

    概述

    image

      -

    1. lib目录位置错误

      -

      NoClassDefFoundError解决方案一开始lib目录没放进web-inf，通过此文章得知错误为包未引入，再由下面这篇文章得知lib目录放置错误

      -

      JDBC Template报错：java.lang.ClassNotFoundException: org.springframework.jdbc.core.RowMapper

      -
      2. -

    2. druid.properties文件位置错误

      -

      报错

      -

      java.lang.NullPointerException at java.util.Properties$LineReader.readLine(Properties.java:434)

      -

      ，报错位置在pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));

      -

      由文章

      -

      关于java.lang.NullPointerException at java.util.Properties$LineReader.readLine(Properties.java:434)问题

      -

      回忆到，由于是使用类加载器获取文件流，故而要求druid.properties文件应该放在resource文件下。对于以前的项目，resource文件都默认是src文件夹。

      -

      但是这次放在src目录下还是不行。定睛一看它web项目文件结构中有一个硕大的resources……放在下面果然就好了。

      -
      3. +
    3. 分组密码一般指对称分组密码
    -
    -
    druid.properties
    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/helloworld
    username=root
    password=root
    initialSize=5
    maxActive=10
    maxWait=3000
    - -
    html界面
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <!--  action内写Servlet的资源路径  -->
    <form action="/webdemo4_war/check" method="post">
      name: <input type="text" name="username" id="username" placeholder="请输入用户名">
      password: <input type="password" name="password" id="password" placeholder="请输入密码">
      <input type="submit" value="submit">
    </form>
    </body>
    </html>
    - -
    Servlet
    @WebServlet(value = "/fail")
    public class FailServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }

        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            // 设置字符集，防止中文乱码
            resp.setContentType("text/html;charset=utf-8");
            resp.getWriter().write("登录失败，用户名或密码错误");
        }
    }
    - -
    @WebServlet(value = "/success")
    public class SuccessServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }

        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.setContentType("text/html;charset=utf-8");
            resp.getWriter().write("登录成功！"+req.getAttribute("uname")+",欢迎您");
        }
    }
    - -
    @WebServlet(value = "/check")
    public class CheckServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }

        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            req.setCharacterEncoding("utf-8");

            //使用BeanUtils把Map转化为对象
            User tmp = new User();
            try {
                BeanUtils.populate(tmp,req.getParameterMap());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            }

            User res = UserDao.login(tmp);
            if (res == null)
                req.getRequestDispatcher("/fail").forward(req,resp);
            else{
                req.setAttribute("uname",res.getUname());
                req.getRequestDispatcher("/success").forward(req,resp);
            }

        }
    }
    - -
    -

    关于BeanUtils

    -

    BeanUtils工具类，简化数据封装, 用于封装JavaBean的

    +

    image

    +
      +
    1. 明文经编码表示后变成二进制序列
      2. +
    2. 二进制序列固定长度分组
      3. +
    3. 每组在密钥控制下转为密文分组
      4. +
    4. 本质上是明文到密文的一一映射
      5. +
    5. 一般明文长度=密文长度，密钥长度不一定
      6. +
    +

    image

    +

    image

    +

    设计思想

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    基本特点

    image

    +

    子密钥生成算法

    image

    +

    轮函数

    image

    +

    迭代轮数

    image

    +

    DES算法

    概述

    image

    +

    image

    +

    加密流程

    总体流程

    image

    +

    image

    +

    image

    +

    选择扩展置换E

    image

    +

    子密钥生成

    image

    +

    压缩替代S-盒

    image

    +

    image

    +

    image

    +

    置换p-盒

    image

    +

    解密流程

    image

    +

    image

    +

    安全性分析

    image

    +

    互补性

    image

    +

    image

    +

    弱密钥

    image

    +

    image

    +

    差分分析

    只有理论上意义

    +

    image

    +

    线性分析

    实际上不可行

    +

    image

    +

    密钥搜索

    image

    +

    image

    +

    多重DES

    image

    +

    image

    +

    二重

    image

    +

    3DES

    你也是过渡阶段？

    +

    image

    +

    第四章 有限域

    数学基础

    image

    +

    逆元：

    +

    image-20231119235319197

    +

    比如说在G(7)中，2的逆元为4。

    +

    也即，任意整数a，则存在x，a / 2 == a * 4 (mod 7)，4为2模7的乘法逆元，记为 2(-1)(mod 7) = 4。

    +

    image

    +

    求逆元的方法是求b^(m-2) mod m。如2^(5) mod 7 = 4。

    +

    群环域

    群

    image

    +

    image

    +

    image

    +

    确实封闭且结合且单位元且逆元

    +

    循环群

    image

    +

    环

    image

    +

    image

    +

    确实是环

    +

    域

    image

    +

    image

    +

    有限域GF(p)

    有限域就是阶为素数幂的域？

    +

    image

    +

    image

    +

    image

    +

    image-20231119233220659

    +

    多项式运算

    image

    +

    普通多项式运算

    image

    +

    image

    +

    image

    +

    image

    +

    系数模p运算的多项式运算

    image

    +

    确实，毕竟系数本身就是域了，除了没定义逆元外别的都满足。

    +

    image

    +

    image

    +

    有限域GF(2^n)

    image

    +

    image

    +

    image

    +

    第五章 高级加密标准-AES

    概述

    简介

    image

    +

    image

    +

    Nr=Nk的幂数x2

    +

    简化版AES

    image

    +

    image

    +

    具体算法详见PPT。

    +

    基本结构

    image

    +

    总体流程

    image

    +

    加密流程

    整体流程

    image

    +

    image

    +

    image

    +

    状态矩阵

    image

    +

    字节代替

    image

    +

    行移位

    image

    +

    列混淆

    image

    +

    image

    +

    可以关注下是怎么通过C矩阵求出这个固定多项式的：

    +

    image

    +

    轮密钥加

    image

    +

    密钥扩展

    image

    +

    image

    +

    感觉也是类似对明文做的操作

    +

    安全评估

    image

    +

    image

    +

    image

    +

    image

    +

    SM4

    image

    +

    image

    +

    第六章 分组密码的工作模式

    image

    +

    image

    +

    电码本ECB

    image

    +

    image

    +

    image

    +

    密码分组链接CBC

    image

    +

    image

    +

    密码反馈CFB

    image

    +

    image

    +

    输出反馈OFB

    image

    +

    image

    +

    计数器Counter

    image

    +

    image

    +

    image

    +

    总结

    image

    +

    第七章 序列密码

    概述

    序列密码的密钥序列是随机的。

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    总体流程

    image

    +

    image

    +

    image

    +

    密钥产生器KG

    总体构成

    image

    +

    image

    +

    线性反馈移位寄存器理论

    image

    +

    反馈移位寄存器

    image

    +

    image

    +

    线性反馈移位寄存器

    image

    +

    image

    +

    确实，感觉相比上面的这笔就是换了个反馈函数，就达到了2^n-1的周期

    +

    m序列

    特性

    image

    +

    image

    +
    生成

    image

    +

    image

    +
    分析

    image

    +
    破译

    image

    +

    image

    +

    image

    +

    image

    +

    常见序列生成算法

    Geffe序列生成器

    image

    +

    Pless生成器

    image

    +

    image

    +

    A5算法

    image

    +

    image

    +

    ZUC算法

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    RC4

    简介

    image

    +

    image

    +

    image

    +

    image

    +

    流程

    数据表S的初始状态

    image

    +

    数据表S的初始置换

    image

    +

    密钥流的生成

    image

    +

    第八章 数论基础

    整除性和带余除法，最大公因子

    image

    +

    image

    +

    素数和模运算

    image

    +

    image

    +

    也就是说求最大公因子实际上可以只求共有素数因子

    +

    image

    +

    image

    +

    image

    +

    image

    +

    欧几里得算法和扩展欧几里得算法

    欧几里得算法

    image

    +

    image

    +

    image

    +

    扩展欧几里得

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    费马小定理和欧拉定理

    费马小定理

    image

    +

    image

    +

    欧拉定理

    image

    +

    image

    +

    素性检测

    miller-rabin

    image

    +

    image

    +

    image

    +

    中国剩余定理

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    离散对数

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    第九章 公钥加密体系-RSA

    image

    +

    image

    +

    概述

    image

    +

    image

    +

    image

    +

    RSA

    组成

    image

    +

    image

    +

    image

    +

    安全性

    image

    +

    image

    +

    image

    +

    image

    +

    应用

    image

    +

    Rabin加密

    image

    +

    image

    +

    MH背包密码

    image

    +

    简介

    image

    +

    流程

    image

    +

    image

    +

    例子

    image

    +

    image

    +

    安全性分析

    image

    +

    image

    +

    EIGamal加密

    image

    +

    image

    +

    image

    +

    image

    +

    椭圆曲线密码体制

    image

    +

    数学理论

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    密码体制

    image

    +

    image

    +

    image

    +

    image

    +

    IBE算法

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    看起来意思就是公钥完全明文，用的是用户的身份ID；私钥用户自己存着。

    +

    image

    +

    image

    +

    image

    +

    后量子密码

    概述

    image

    +

    image

    +

    image

    +

    格

    image

    +

    NTRU

    流程

    image

    +

    image

    +

    image

    +

    image

    +

    举例

    image

    +

    image

    +

    安全性

    image

    +

    第十一章 哈希函数

    概述

    image

    +

    image

    +

    image

    +

    image

    +

    这个角度很有意思，确实是名字一样原理相近，但是目的完全不一样：

    +

    image

    +

    image

    +

    常见哈希函数

    SHA

    image

    +

    image

    +

    SM3

    image

    +

    image

    +

    安全性

    image

    +

    image

    +

    暴力攻击

    image

    +

    生日攻击

    image

    +

    image

    +

    攻击过程

    image

    +

    image

    +

    应用

    image

    +

    身份认证

    image

    +

    image

    +

    image

    +

    数字签名

    image

    +

    也就是中途会哈希两次吼。

    +

    第十二章 消息认证码 (MAC)

    概述

    基本思想

    image

    +

    image

    +

    一样的话就是说明消息没被篡改

    +

    image

    +

    要求

    image

    +

    基于哈希函数的MAC

    image

    +

    直观构造

    image

    +

    image

    +

    image

    +

    image

    +

    HMAC

    image

    +

    image

    +

    image

    +

    基于分组密码的MAC

    image

    +

    数据认证算法DAA

    image

    +

    image

    +

    CMAC

    image

    +

    认证加密

    概述

    image

    +

    image

    +

    CCM

    image

    +

    局限性

    image

    +

    第十三章 数字签名PKI

    概述

    简介

    image

    +

    image

    +

    对比

    image

    +

    image

    +

    安全性

    image

    +

    实现

    image

    +

    image

    +

    image

    +

    image

    +

    常见实现

    都包含签名算法、验证算法、正确性证明、举例，详细看PPT吧。

    +

    基于RSA

    image

    +

    基于离散对数

    image

    +

    ELGamal

    Schnorr

    DSA

    盲签名

    image

    +

    image

    +

    image

    +

    群（组）签名

    image

    +

    第十四章 密码协议

    概述

    image

    +

    image

    +

    分割和选择协议

    image

    +

    掷硬币协议

    image

    +

    单向函数

    image

    +

    模p指数运算

    image

    +

    零知识证明

    image

    +

    image

    +

    image

    +

    比特承诺

    image

    +

    image

    +

    image

    +

    安全多方计算

    这个有点复杂，可以看看PPT。

    +

    第十五章 密钥管理

    概述

    image

    +

    image

    +

    密钥分配

    image

    +

    image

    +

    无中心

    image

    +

    中心模式

    image

    +

    基于公钥密钥

    image

    +

    密钥协商

    image

    +

    Diffie-Hellman密钥交换方案

    image

    +

    image

    +

    PKI

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +

    SSL

    概述

    image

    +

    image

    +

    底层协议

    image

    +

    image

    +

    image

    +

    上层协议

    警告协议

    image

    +

    握手协议/密码变化协议

    image

    +

    密钥交换（四握手）

    image

    +

    image

    +

    image

    +

    image

    +

    image

    +]]> + + + 编译原理 + /2023/11/18/compilation_principle/ + 第一章 绪论

    概述

    picture

    +

    可重定位的代码通过linker和loader重定位这部分内容就是在之前那本书学过的。

    +

    picture

    +

    从中，我们也可以看到有语法分析、中间代码的影子。

    +

    picture

    +

    词法分析相当于通过DFA NFA捉出各类符号，形成简单的符号表和token list；语法分析相当于对token list组词成句，判断该句子是否符合语言规则；语义分析相当于对词句进行类型判断和中间代码的生成，获得基本语义。

    +

    编译程序总体结构

    picture

    +

    picture

    +

    语法制导翻译：语义分析和中间代码生成集成到语法分析中

    +

    词法分析

    将结果转化为token的形式。

    +

    picture

    +

    picture

    +

    语法分析

    从token list中识别出各个短语，并且构造语法分析树。

    +

    picture

    +

    picture

    +

    相当于是通过文法来进行归约（自底向上的语法分析），从而判断给定句子是否合法。

    +

    语义分析

    picture

      -

    1. JavaBean：标准的Java类

      -
       1. 要求：
-     1. 类必须被public修饰
-     2. 必须提供空参的构造器
-     3. 成员变量必须使用private修饰
-     4. 提供公共setter和getter方法
- 2. 功能：封装数据
-
      -
      2. -

    2. 概念：

      -

      ​ 成员变量：
      ​ 属性：setter和getter方法截取后的产物

      -
                 例如：getUsername() --> Username--> username
-
      -
      3. -

    3. 方法：

      -
      1. setProperty()
-1. getProperty()
-1. populate(Object obj , Map map):
-
      -

      ​ 将map集合的键值对信息，封装到对应的JavaBean对象中

      +
    4. 收集标识符的属性信息，并将其存入符号表
      5. +
    +

    picture

    +

    种属就是比如是函数还是数组之类的。

    +

    picture

    +
      +
    1. 语义检查
      2. +
    +

    picture

    +
      +

    1. 静态绑定

      +

      包括绑定代码相对地址（子程序）、数据相对地址（变量）

    -
    -
    JDBCUtils

    原封不动地照搬了：第二部分-数据库连接池-Druid-定义工具类 部分的代码。

    -
    UserDao
    public class UserDao {
        private static final JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
        public static User login(User user){
            List<User> users = jdbcTemplate.query("select * from usr where uname = ? and pass = ?",
                            new BeanPropertyRowMapper<User>(User.class),
                            user.getUname(),user.getPass());
            if (users.size() == 0)
                return null;
            else
                return users.get(0);
        }
    }
    - -

    Response

    功能

    设置响应消息。

    -
    设置响应行

    设置状态码

    -
    setStatus(int sc);
    - -
    设置响应头
    setHeader(String name, String value)
    - -
    设置响应体

    以流的方式传输数据。

    -

    使用步骤：

    -
      -

    1. 获取输出流

      +

      中间代码生成

      picture

      +

      picture

      +

      波兰也就是前序遍历二叉树（中左右），逆波兰也就是后序遍历二叉树（左右中）

      +

      picture

      +

      代码优化

      picture

        -

      1. 字节输出流

        -
        ServletOutputStream getOutputStream()
        2. -

      2. 字符输出流

        -
        PrintWriter getWriter()
        3. -
      +

    2. 无关机器

      +

      picture

      3. -

    3. 使用输出流，将数据输出到客户端浏览器

      +

    4. 有关机器

      +

      picture

    -
    案例
    重定向

    资源跳转的一种方式。

    -

    image-20230103153445565

    -
    @WebServlet("/demo1")
    public class ServletDemo extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("I am demo1  "+req.hashCode());
            /* 重定向 */
            //设置状态码
            resp.setStatus(302);
            //要填的是完整资源路径。
            resp.setHeader("location","/practice_war/demo2");
        }

        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    }
    - -
    @WebServlet("/demo2")
    public class ServletDemo2 extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("I am demo2  "+req.hashCode());
        }

        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    }
    - -
    输出：
    I am demo1  1675674230
    I am demo2  1675674230
    - -

    重定向的这几行代码其实是可以简化的：

    -
    /* 重定向 */
          //设置状态码
          resp.setStatus(302);
          //要填的是完整资源路径。
          resp.setHeader("location","/practice_war/demo2");
    - -

    可以简化为：

    -
    resp.sendRedirect("/practice_war/demo2");
    - -
    -

    关于req对象不一样，但hashcode值相同的解释：

    -

    hashcode很大程度与对象内存空间相关，与对象的具体内容没什么关系。两个对象拥有相同的hashcode有可能只是因为存储的内存空间位置大小都相同导致的。所以是因为两次的req对象都占用了同一个内存空间【JVM调度问题】，所以才让hashcode值相同。这两个对象实质上是不一样的。

    -
    -

    重定向的特点（与请求转发完全相反）：

    +

    目标代码生成

    picture

    +

    表格管理

    这也挺好理解，相当于管理符号表吧。

    +

    picture

    +

    错误处理

    picture

    +

    编译程序的组织

    了解了编译程序的基本结构，那么我们就可以想想该怎么实现这个编译器了。

    +

    最直观的想法是，我们有几个步骤就对代码进行多少次扫描：

      -
    1. 浏览器地址栏路径改变
      2. -
    2. 可以访问其他站点的资源
      3. -
    3. 使用多次请求，不能使用request对象共享数据
      4. +
    4. 首先扫一次，进行词法分析，将所有标识符写入到符号表中，同时进行语法分析，看看有没有错，如果出错了就转到错误处理，没有的话就进行语义分析；（三合一）
      5. +
    5. 然后再针对得出来的语义分析树进行中间代码生成；
      6. +
    6. 再对得出来的中间代码进行代码优化，最后对优化出来的代码进行翻译处理。（二合一）
    -

    路径写法：

    +

    picture

    +

    picture

    +

    picture

    +

    实现编译器

    picture

    +

    T形图

    picture

    +

    自展

    picture

    +

    也就是说：

      -

    1. 相对路径：通过相对路径不可以确定唯一资源

      -
        -
      • 规则：找到当前资源和目标资源之间的相对位置关系
        • -
      -
      2. -

    2. 绝对路径：通过绝对路径可以确定唯一资源

      -
        -

      • 如：http://localhost/day15/responseDemo2 /day15/responseDemo2

        -
        <form action="/webdemo4_war/check" method="post">
        • -

      • 以/开头的路径

        -
        • -

      • 规则：判断定义的路径是给谁用的？判断请求将来从哪儿发出

        -
          -

        • 给客户端浏览器使用：需要加虚拟目录(项目的访问路径)

          -

          比如说在页面中弄了个a标签，将来是要给客户端点的，那么这个a标签的href就要用绝对路径。

          -

          再比如说重定向：

          -
          //要填的是完整资源路径。
                resp.setHeader("location","/practice_war/demo2");
          - -

          这个路径将来是给客户端将来要使用的路径，是客户端路径，所以要加虚拟目录。

          - -
          • -

        • 给服务器使用：不需要加虚拟目录

          -

          比如说之前的请求转发

          -
            -
          • 转发路径
            • -
          -
          • -
        -
        • -
      -
      3. -
    -
    服务器输出字符数据到浏览器
    @WebServlet("/responseDemo4")
    public class ResponseDemo4 extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

            //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
            response.setCharacterEncoding("utf-8");

            //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
            response.setHeader("content-type","text/html;charset=utf-8");

            /* 也有设置编码的简单形式
            //简单的形式，设置编码
            response.setContentType("text/html;charset=utf-8");
            */

            //1.获取字符输出流
            PrintWriter pw = response.getWriter();
            //2.输出数据
            //pw.write("<h1>hello response</h1>");
            pw.write("你好啊啊啊 response");
        }

        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            this.doPost(request,response);
        }
    }
    - -
    服务器输出字节数据到浏览器
    @WebServlet("/responseDemo5")
    public class ResponseDemo5 extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            //依然要保证编码一致
            response.setContentType("text/html;charset=utf-8");

            //1.获取字节输出流
            ServletOutputStream sos = response.getOutputStream();
            //2.输出数据
            sos.write("你好".getBytes("utf-8"));
        }

        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            this.doPost(request,response);
        }
    }
    - -
    验证码
    @WebServlet("/demo1")
    public class ServletDemo extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //验证码图片大小
            final int width = 100;
            final int height = 50;

            /* 绘制验证码 */
            BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
            Graphics pen = image.getGraphics();
            //绘制背景
            pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
            pen.fillRect(0,0,width,height);
            //绘制边框
            pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
            pen.drawRect(0,0,width-1,height-1);
            //随机填充字母数字
            String source = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890";
            for (int i = 1; i <= 4; i++){
                int index = (int)(Math.random()*source.length());
                pen.drawString(source.substring(index,index+1),20*i,27);
            }
            //画干扰色线
            pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
            for (int i = 0; i < 5; i++){
                pen.drawLine((int)(Math.random()*width),(int)(Math.random()*height),(int)(Math.random()*width),(int)(Math.random()*height));
            }

            //将图片输出
            ImageIO.write(image,"jpg",resp.getOutputStream());
        }

        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    }
    - -
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <img id="img" src="/practice_war/demo1"/>
    <a href="" id = "a">看不清？换一张</a>
    <script>
      window.onload = function (){
        let img = document.getElementById("img");
        let a = document.getElementById("a");
        img.onclick = function (){
          //加时间戳作为请求参数，为了防止浏览器不更换图片缓存
          img.src = "/practice_war/demo1?"+new Date().getTime();
        }
        a.onclick = img.onclick;
      }
    </script>
    </body>
    </html>
    - -

    ServletContext对象

    概念

    代表整个web应用，可以和servlet容器（服务器）通信

    -

    获取

    通过request对象获取
    ServletContext getServletContext()
    - -
    通过HttpServlet获取
    this.getContext();
    - -

    功能

    获取MIME类型

    MIME是在互联网通信过程中定义的一种文件数据类型

    -
            * 格式： 大类型/小类型   text/html        image/jpeg
-
    -
    /*
    @param: 文件的后缀扩展名，如.txt
    */
    String getMimeType(String file);
    - -

    image-20230107010006874

    -

    mime映射存在了服务器的xml文件中。

    -

    使用案例：

    -
    System.out.println(this.getServletContext().getMimeType("a.txt"));
    - - - -
    共享数据

    ServletContext是一个域对象，可以用来共享数据。

    -

    ServletContext代表着服务器，因而它的生命周期跟随服务器关闭而灭亡。ServletContext可以共享所有请求的数据。也就是说，任何一次请求，任何用户，看到的ServletContext域都是同一个。

    -

    这样大的效果也使得我们需要更加谨慎地使用它。一旦数据存入ServletContext域，就只会在服务器关闭后才会消亡，很耗内存。

    -
    获取文件的真实（服务器）路径
    String getRealPath();
    - -

    经测试发现，这东西只是起了一个字符串拼接的作用，是不会帮忙检查文件是否存在的。

    -

    学到这我顺便看了看文件放在不同的地方最后应该如何访问：

    -

    image-20230107012903495

    -

    这是最终部署项目文件夹的结构：

    -

    image-20230107013010276

    -

    可以看到只有bcd被保留了。它们的目录要这样获取：

    -
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            ServletContext context = this.getServletContext();

            System.out.println(context.getRealPath("/WEB-INF/classes/b.txt"));
            System.out.println(context.getRealPath("/c.txt"));
            System.out.println(context.getRealPath("/WEB-INF/d.txt"));
        }
    /*输出结果：
    D:\aWorkStorage\etc\apache-tomcat-8.5.83\webapps\practice_war\WEB-INF\classes\b.txt
    D:\aWorkStorage\etc\apache-tomcat-8.5.83\webapps\practice_war\c.txt
    D:\aWorkStorage\etc\apache-tomcat-8.5.83\webapps\practice_war\WEB-INF\d.txt
    是我的电脑里tomcat的目录
    */
    - -

    案例：文件下载

    要求
      -
    • 文件下载需求：
        -
      1. 页面显示超链接
        2. -
      2. 点击超链接后弹出下载提示框
        3. -
      3. 完成图片文件下载，那种会存到你电脑download目录下，而不是直接加载出来的
        4. +
      4. P0是汇编语言，可以用来编译C语言子集；（P0：汇编语言，C子集→汇编）
        5. +
      5. P1是机器语言，可以用来把汇编语言翻译为机器语言；（P1：机器语言，汇编→机器）
        6. +
      6. 所以我们就得到了P2，也即一个可以用来编译C语言子集的机器语言程序；（P2：机器语言，C子集→汇编）
        7. +
      7. 然后我们就可以用C语言子集来写C语言编译程序P3，再用P2翻译P3，就可以得到工具P4。（P4：汇编语言，C→汇编）
      +

      image-20230912153726618

      +

      帅的。

      +

      移植

      picture

      +

      picture

      +

      本机编译器的利用

      picture

      +

      编译程序的自动生成

      这大概是描述了我们到时候会怎么实现这两个阶段代码。

      +

      不过确实，词法分析可以看作是正则匹配，语法分析可以看作是产生式。

      +

      picture

      +

      picture

      +

      第二章 文法等概念

      image-20231111160656018

      +

      基本概念

        +

      1. 字母表

        +

        picture

        +

        picture

        +

        picture

        +

        picture

        2. -
    -

    image-20230201170701909

    -

    用户点击下载->请求发送给某个servlet，servlet修改response->tomcat响应用户，传递的图片资源按照response的方法打开

    -
    代码

    说实话看了感觉有点难以下手，主要还是完全不知道html和servlet怎么交互造成的，看了老师讲解才有点恍然大悟。

    -

    我们可以把a标签以重定向的角度去看。它会新建一个request，然后发送到它的href中的那个url。在此处我们将url设置为/practice_war/download?filename=1.jpg，也即要以GET的方式发送给download，请求体为filename=1.jpg。然后servlet执行结束后，就会将信息存储在resp中返回给tomcat，由tomcat发送给用户。

    -
    html
    <body>
    <a href="/practice_war/download?filename=1.jpg" id = "a">点击下载图片</a>
    </body>
    - -
    servlet

    思路：

    -

    获取要下载的资源，并且将其输入到resp的stream中。

    -

    有一点需要非常注意：

    -
    resp.setContentType(this.getServletContext().getMimeType(path));
    resp.setHeader("content-disposition","attachment;filename="+name);
    - -

    必须要在把资源输入到resp的stream前设置好，精确来说是调用sos.write前设置好，不然无法起作用。

    -

    猜测是因为可能resp会根据disposition方式的不同而自动决策write的方式。

    -
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取要下载的资源名称
        String name = req.getParameter("filename");

        //获取路径
        String path = this.getServletContext().getRealPath("/img/"+name);
        //使用字节流
        FileInputStream fis = new FileInputStream(path);
        //输出数据

        resp.setContentType(this.getServletContext().getMimeType(path));
        resp.setHeader("content-disposition",
                       "attachment;filename="+
                       // 为了防止中文乱码，需要针对不同的浏览器来进行编码
                       DownLoadUtils.getFileName(req.getHeader("user-agent"),name));

        //获取字节输出流
        ServletOutputStream sos = resp.getOutputStream();
        byte[] buff = new byte[1024];
        int len = 0;
        while((len = fis.read(buff))!=-1){
            sos.write(buff,0,len);
        }
        //释放资源
        fis.close();

        //        resp.setContentType(this.getServletContext().getMimeType(path));
        //        resp.setHeader("content-disposition","attachment;filename="+name);
    }
    - -

    会话

    会话：一次会话中包含多次请求和响应。

    -
      -

    • 一次会话：浏览器第一次给服务器资源发送请求，会话建立，直到有一方断开为止

      -
      • -

    • 功能：请求之间本来是相互独立的。将多次请求组织在一次会话中，就可以让请求之间进行数据的共享。

      +

    • 串

      +

      克林闭包中的每一个元素都称为是字母表Σ上的一个串

      +

      picture

      +

      picture

      +

      picture

      • -

    • 方式：

      -
        -

      • 客户端会话技术 Cookie

        -

        把数据存进客户端

        +
+

文法

picture

+

如果文法用于描述单词，基本符号就是字母；用于描述句子，基本符号就是单词

+
    +

  1. 文法的形式化定义

    +

    picture

    +

    picture

    +

    由于可以从它们推出其他语法成分，故而称之为非终结符

    +

    picture

    +

    picture

    +

    还真是最大的语法成分

    2. -

  2. 服务器端会话技术 Session

    -

    把数据存进服务器端

    +

  3. 产生式

    +

    picture

    4. - +

  4. 符号约定

    +

    picture

    +

    picture

    +

    picture

    +

    文法符号串应该就是指既包含终结符也包含非终结符的，也可能是空串的串。

    +

    注意终结符号串也包括空串。

    5. - -

    概念

    客户端会话技术，将数据保存到客户端

    -

    快速入门

      -

    • 使用步骤：

      +
+

语言

picture

+

这部分就是要讲怎么看一个串是否满足文法规则，那么我们就需要先从什么样的串是满足文法规则的串开始说起，也即引入“语言”的概念。

    -
  1. 创建Cookie对象，绑定数据【为了从服务器端发送cookie给客户端】
      -
    • new Cookie(String name, String value)
      • -
    • 可以看到，Cookie其实就是一种name-value这样的键值对对象
      • -
    +

  2. 推导与归约

    +

    picture

    +

    然后也分为最左推导和最右推导，对应最右归约和最左归约。

    +

    picture

    +

    故而，如果从开始符号可以推导（派生）出该句子，或者从该句子可以归约到开始符号，那么该句子就是该语言的句子。

    3. -
  3. 发送Cookie对象【因为要发送给客户端，所以应该在response里存】
      -
    • response.addCookie(Cookie cookie)
      • -
    +

  4. 句子与句型

    +

    picture

    +

    句型就是可以有非终结符，句子就是只能有终结符

    5. -
  5. 获取Cookie，拿到数据【因为是来自客户端，所以要从request里要】
      -
    • Cookie[] request.getCookies()
      • -
    +

  6. 语言

    +

    picture

    +

    文法解决了无穷语言的有穷表示问题。

    +

    picture

    +

    picture

    +

    emm，就是好像没有∩运算

    +

    picture

    +

    有正则那味了

+

乔姆斯基文法体系

picture

+

picture

+
    +

  1. 0型

    +

    picture

    2. -

  2. 代码

    -
    @WebServlet("/demo")
    public class ServletDemo extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            response.addCookie(new Cookie("password","abc123"));
        }

        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            this.doGet(request, response);
        }
    }
    - -
    @WebServlet("/demo2")
    public class ServletDemo2 extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            System.out.println(request.getCookies());
        }

        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            this.doGet(request, response);
        }
    }
    3. -

  3. 得到效果

    -

    运行服务器，首先访问/demo，然后在同一个浏览器再次访问/demo2，就可以在控制台看到输出。

    -

    这个过程发生了什么呢？

    -

    首先，访问/demo就相当于建立了会话。/demo的Servlet获取到请求之后，在response中将cookie填入。

    -

    保持浏览器窗口不变，会话也不变。

    -

    再次访问/demo2，cookie信息自动保存在request对象中。/demo2的Servlet获取到请求之后，在控制台中打印输出了cookie。

    +

  4. 1型

    +

    picture

    +

    之所以是上下文有关，是因为只有A的上下文为a1和a2时才能替换为β【666666，第一次懂】

    +

    CSG不包含空产生式。

    5. - -

    细节学习

    一次发送多个cookie

    你看它那个API叫add，就知道数据结构差不多是个list，所以多次add就行。

    -
    保存时间

    默认情况下，浏览器关闭则cookie就马上被销毁。

    -

    如果需要持久化存储：

    -
    cookie.setMaxAge(int seconds)
    - -

    参数：

    +

  5. 2型

    +

    picture

    +

    左部只能是一个非终结符。

    +
    6. +

  6. 3型

    +

    picture

    +

    产生式右部最多只有一个非终结符，且要在同一侧

    +

    picture

    +

    看起来还能转（是的，自动机教的已经全忘了（））

    +
    7. +
+

CFG

正则文法用于判定大多数标识，但是无法判断句子构造。

    -
  1. 正数：将Cookie数据写到硬盘的文件中。持久化存储。并指定cookie存活时间，时间到后，cookie文件自动失效
    2. -
  2. 负数：默认值
    3. -
  3. 零：删除cookie信息
    4. +
  4. 分析树
-
中文问题

在tomcat 8 之前 cookie中不能直接存储中文数据，需要将中文数据转码——一般采用URL编码(%E3)

-

在tomcat 8 之后，cookie支持中文数据。

-
获取范围
    -

  1. 假设在一个tomcat服务器中，部署了多个web项目，那么在这些web项目中cookie能不能共享？

    -
      -

    • 默认情况下cookie不能共享

      -
      • -

    • 共享方法：

      -

      setPath(String path):设置cookie的获取范围。默认情况下，设置当前的虚拟目录

      -

      如果要共享，则可以将path设置为”/“

      +

      picture

      +

      picture

      +

      也就是说，每个句型都有自己对应的分析树。那么接下来就介绍什么是句型的短语

      +

      picture

      +

      意思就是直接短语是高度为2的子树的边缘，直接短语一定是某个产生式的右部，但是产生式右部不一定是给定句型的直接短语（因为有可能给定句型的推导用不到那个产生式）

      +
        +
      1. 二义性文法
        2. +
      +

      picture

      +

      通过自定义规则消除歧义

      +

      picture

      +

      第三章 词法分析

      正则语言

      正则表达式

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      最后两条值得注意

      +

      picture

      +

      正则定义

      picture

      +

      picture

      +

      picture

      +

      有穷自动机

      概述

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      所以真正的终止是输入带到末尾并且指向终态

      +

      分类

      DFA

      picture

      +

      NFA

      picture

      +

      NFA与DFA转化

      picture

      +

      picture

      +

      e-NFA

      picture

      +

      e-NFA与NFA转化

      picture

      +

      词法分析相关

      识别单词的DFA

      数字

      picture

      +

      picture

      +

      66666，还能这么捏起来

      +

      picture

      +

      注释

      picture

      +

      识别token

      picture

      +

      关键字是在识别完标识符之后进行查表识别的

      +

      scanner的错误处理

      说实话没太看懂

      +

      picture

      +

      picture

      +

      picture

      +

      第四章 语法分析

      根据给定文法，识别各类短语，构造分析树。所以关键就是怎么构建分析树

      +

      自顶向下LL(1)

      概念

      可以看做是推导（派生）的过程。
      如果同一非终结符的各个产生式的可选集互不相交，就可以进行确定的自顶向下分析：

      +

      picture

      +

      这两个分析也是我们的分析方法需要解决的。

      +

      picture

      +

      picture

      +

      也就是说，在自顶向下分析时，采用的是最左推导；在自底向上分析时，最左归约和最右推导才是正道！

      +

      通用算法

      例子

      picture

      +

      大概流程应该是，有产生式就展开，然后当产生式右部有多个候选式的时候再根据输入决定。

      +

      递归下降分析

      picture

      +

      如果有多个以输入终结符打头的右部候选，那就需要逐一尝试错了再回溯，因而效率较低。

      +

      预测分析

      picture

      +

      66666，这其实就可以类似于动态规划了吧

      +

      【感觉这里也能窥见一些算法设计的思想。

      +

      仔细想想，我们在引入动态规划时，也是这个说辞：对于一些回溯问题，回溯效率太低，所以我们就可以提前通过动态规划的思想构造一个状态转移表，到时候只需从零开始按照表进行状态转移即可。

      +

      仔细想想，这不就是这里这个预测分析提出的思想吗！真的牛逼，6666

      +

      我记得KMP算法一开始也是这个思想，感觉十分神奇】

      +

      文法转换

      什么情况需要改造

      picture

      +

      picture

      +

      消除左递归

      直接左递归

      picture

      +

      这个左递归及其消除方法解释得很形象

      +

      picture

      +
      间接左递归

      picture

      +

      先转化为直接左递归

      +

      消除回溯

      picture

      +

      666666这个解读可以，感觉这个就跟：

      +

      image-20231111224823978

      +

      这个“向前看”有异曲同工之妙了。

      +

      LL(1)文法

      LL(1)文法才能使用预测分析技术。判断是否是LL文法就得看具有相同左部的产生式的select集是否相交。

      +

      S_文法

      picture

      +

      S文法不包含空产生式

      +

      q_文法

      picture

      +

      也就是说，B的Follow集为{b,c}，只有当输入符号为b/c时才能使用空产生式。

      +

      picture

      +

      first集和follow集不交。

      +

      这下总算知道这两个是什么玩意了。也就是这样：

      +
        +

      1. 输入符号与B的First集元素匹配

        +

        直接用那个产生式

        2. -
    +

  2. 否则，看输入符号是否与Follow集元素匹配

    +
      +

    1. 是

      +

      若B无空产生式，报错；否则，使用B的空产生式（相当于消了一个符号但不变输入带指针）

      2. -

    2. 不同的tomcat服务器间cookie共享问题？

      -

      比如说：

      -image-20230221225514567 - -
        -

      • setDomain(String path):如果设置一级域名相同，那么多个服务器之间cookie可以共享

        -

        （setDomain(".baidu.com"),那么tieba.baidu.com和news.baidu.com中cookie可以共享）

        +

      • 否

        +

        报错

        • -
      +
-

作用和特点

特点：

+

picture

+

这个感觉跟first集有点像，相当于是右部只能以终结符开始的形式，所以下面的LL文法会增强定义。

+

当该非终结符对应的所有SELECT集不相交，就可以进行确定的自顶向下语法分析。这个思想也将贯穿下面的LL文法

+

picture

+

LL(1)文法

picture

+

picture

+

最后，如果同一非终结符的各个产生式的可选集互不相交，就可以进行确定的自顶向下分析：

+

picture

+

picture

+

总结

这几个推理下来，真是让人感觉酣畅淋漓！

+

确定的自顶向下分析的核心就是，给定一个当前所处的非终结符和一个输入字符[E, a]，我们可以唯一确定一个产生式P用于构建语法分析树。

+

picture

+

也即，同一个非终结符的所有产生式的SELECT集必须是不交的【才能确保选择产生式的唯一性】。因而，问题就转化为了如何让SELECT集不交。

+

我们需要对空产生式和正常产生式的SELECT集计算做一个分类讨论。

    -

  1. cookie存储数据在客户端浏览器

    -

    因而它相对不安全

    +

  2. 空产生式

    +

    由于可以推导出空，相当于把该符号啥了去读下一个符号，因此我们的问题就转化为输入字符a是否能够跟该符号后面紧跟着的字符相匹配。而紧跟着的字符集我们将其成为FOLLOW集，如果a在follow集中，那么就可以接受，否则不行。

    +

    对于LL(1)文法，相当于是进一步处理了简介推出空的串：

    +

    ​ 由于α串->*空，则α串必定仅由非终结符构成。那么它能推导出的所有可能即为SELECT集。故而为First(α)∪Follow(α)

    3. -

  3. 浏览器对于单个cookie 的大小有限制(4kb) 以及 对同一个域名下的总cookie数量也有限制(20个)

    +

  4. 非空产生式

    +

    很简单，就是其First集。

-

作用：

+

故而，只需要让这些计算出来的First集合不交，就能进行确定的自顶向下语法分析，构造确定的语法分析树。不得不说真的牛逼。

+

感觉其“预测分析”的“预测”主要体现在对空产生式的处理上。

+

总算懂了为什么LL(1)能够解决这个回溯效率太低的问题了，太牛逼。不过问题是怎么转化为LL(1)呢（）上面的消除回溯和左递归只是一部分而已吧。

+

预测分析法

picture

+

这个消除二义性是啥玩意？二轮的时候看看PPT怎么讲的

+

递归的预测分析

picture

+

picture

+

66666，它这个计算follow集的方法就很直观

+

declistn有个空产生式，那么我们看得看②，而②的declistn排在最后，也就是说declistn的follow集就是其左部declist的follow集【6666】，所以我们看①，可以发现declist后面为:。

+

picture

+

如果是终结符，就直接==比较；非终结符，就把token传入到其对应的过程。

+

非递归的预测分析

picture

+

66666

+

感觉从中又能窥见动态规划的同样思想了。下推自动机其实感觉就像是递归思想（或者说顺序模拟递归，因为它甚至有一个栈，出栈相当于达成条件递归return），动态规划的话可能有点像是把每个不同状态以及不同状态时的栈顶元素整成一个2x2的表，所以感觉思想类似。

+

picture

+

注意，是栈顶跟输入一样都是非终结符才会移动指针和出栈

+

值得注意的是，输出的产生式序列就对应了一个最左推导。

+

picture

+

picture

+

错误处理

picture

+

picture

+

picture

+

其实也挺有道理，栈顶是非终结符，但是输入是它的follow集，那我们自然而然可以想到把这b赶跑，看看下面有没有真的它的follow集在嗷嗷待哺。

+

自底向上语法分析

概述

正确识别句柄是一个关键问题。

+

句柄：当前句型的最左直接短语。【最左、子树高度为2】

+

自底向上

picture

+

picture

+

每次句柄形成就将它归约，因而保证一直是最左归约（recall that，句柄一定是某个产生式的右部，并且每次最左句柄一旦形成就归约）

+

picture

+

正如上面的LL分析，每次推导要选择哪个产生式是一个问题；这里的LR分析，每次归约要选择哪个产生式，也即正确识别句柄，也是一个关键问题。

+

所以，我们应该把句柄定义为当前句型的最左直接短语。

+

如下图所示，左下角是当前句型（画红线部分）的语法分析树，红字为在栈中的部分，蓝字为输入符号串剩余部分。当前句型的直接短语（相当于根节点的高度为二的子树，或者说子树前两层）有两个，一个是以<IDS>为根节点的<IDS> , iB，另一个是<T>为根节点的real。

+

picture

+

而LR分析技术的核心就是正确地识别了句柄。

+

LR文法

picture

+

也就是说LR技术就是用来识别句柄的，识别完了句柄就可以构建类似自顶向下的预测分析那样的自动机表来进行转移。

+

picture

    -

  1. cookie一般用于存出少量的不太敏感的数据

    +

  2. 移进状态

    +

    ·后为终结符

    +
    3. +

  3. 待约状态

    +

    ·后为非终结符

    4. -

  4. 在不登录的情况下，完成服务器对客户端的身份识别

    -

    比如说，以不登录情况下对某个网页进行属性设置，你下次打开的时候属性设置依然在，这是因为你的属性设置的cookie在设置后被存入到你的电脑中，下次访问该网页发出请求，服务器端就能根据请求中cookie里的属性设置信息来做出响应了。

    +

  5. 归约状态

    +

    ·后为空

-

案例：记住上一次访问时间

需求：
1. 访问一个Servlet，如果是第一次访问，则提示：您好，欢迎您首次访问。
2. 如果不是第一次访问，则提示：欢迎回来，您上次访问时间为:显示时间字符串

-
public class ServletDemo extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
        response.setCharacterEncoding("utf-8");

        //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
        response.setHeader("content-type","text/html;charset=utf-8");
        if(request.getCookies() != null)
            for(Cookie c : request.getCookies()){
                if(c.getName().equals("isfirst")){
                    response.getWriter()
                        .write("<h1>欢迎回来，您上次访问的时间为<h1>"+c.getValue());
                    break;
                }
            }
        else
            response.getWriter().write("<h1>你好！欢迎你！<h1>");

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
        Date date1 = new Date();
        String currentTime = dateFormat.format(date1);

        response.addCookie(new Cookie("isfirst",currentTime));
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}
- -

Session

概念

服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中。HttpSession

-

应用场合

比如说购物网站的购物车这种，就会存在session。想想也是（

+

picture

+

picture

+

以前感觉一直很难理解GOTO表的作用，现在感觉稍微明白了点了，你想想，归约之后的那个结果是不是有可能是另一个产生式的右部成分之一，也即一个新的句柄？并且这个也是由你栈顶刚归约好的那个左部和下面的输入符号决定的。那么你自然而然需要切换一下当前状态，以便之后遇到那个产生式的时候能发现到了。

+

那么，剩下的问题就是如何构造LR分析表了：

+

picture

+

算符分析

picture

+

也就是它会整一个终结符之间的优先级关系。。。

+

picture

+

picture

+

也就是说：

    -

  1. session用于存储一次会话的多次请求的数据，存在服务器端

    -

    比如说，当我们做重定向的时候，就可以选择用session共享数据（会话域）而非使用ServletContext（此范围过大）

    +

  2. a=b

    +

    相邻

    3. -

  3. session可以存储任意类型，任意大小的数据

    +

  4. a<b

    +

    也即在A->aB时，b在FIRSTOP(B)中（理解一下，这个First指在前面。。。）

    5. -

  5. session与Cookie的区别：

    -
      -
    1. session存储数据在服务器端，Cookie在客户端
      2. -
    2. session没有数据大小限制，Cookie有
      3. -
    3. session数据安全，Cookie相对于不安全
      4. -
    +

  6. a>b

    +

    也即在A->Bb时，a在LASTOP(B)中（理解一下，这个LAST指在后面。。。）

-

快速入门

    -

  1. 获取HttpSession对象：
    HttpSession session = request.getSession();

    -
    2. -

  2. 使用HttpSession对象：

    -
      Object getAttribute(String name)  
      void setAttribute(String name, Object value)
      void removeAttribute(String name)

    #### 原理

    ![image-20230223102722575](./JavaWeb/image-20230223102722575.png)

    实现依赖于Cookie

    #### 细节

    前面说到，当客户端和服务器端有任何一端关闭之后，会话结束，在这种情况下，session在客户端和服务器端的保留情况不同。

    1. 当客户端关闭后，服务器不关闭，两次获取session是否为同一个？
      * 默认情况下。不是。
      * 如果需要相同，则可以创建Cookie,键为JSESSIONID，设置最大存活时间，让cookie持久化保存。
      	 ```java
         Cookie c = new Cookie("JSESSIONID",session.getId());
         c.setMaxAge(60*60);
         response.addCookie(c);
    3. -

  3. 客户端不关闭，服务器关闭后，两次获取的session是同一个吗？

    -
    4. +

    picture

    +

    picture

    +

    我服了

    +

    picture

    +

    picture

    +

    好像#这个固定都是，横的为左，竖的为右

    +

    picture

    +

    根据优先关系来判断移入和归约

    +

    picture

    +

    LR分析

    LR(0)

    每个分析方法其实都对应着一种构造LR分析表的方法。
    LR(0)通过构造规范LR0项集族，从而构造LR分析表，从而构造LR0 DFA来最终进行语法分析。

    +

    每一个项目都对应着句柄识别的一个状态。

    +

    picture

    +

    picture

    +

    picture

    +

    picture

    +

    而肯定不可能整那么多个状态，所以我们需要进行状态合并。（这样也就很容易理解LR的状态族构建了。）

    +

    picture

    +

    它这里也很直观解释了为什么点遇到非终结符就需要加入其对应的所有产生式，因为在等待该非终结符就相当于在等待它的对应产生式的第一个字母。

    +

    picture

    +

    picture

    +

    上面这东西就是这个所谓的规范LR(0)项集族了。

    +

    picture

    +

    picture

    +

    但是会产生移进归约冲突：

    +

    picture

    +

    picture

    +

    还有归约归约冲突：

    +

    picture

    +

    所以我们就把没有冲突的叫LR(0)文法。

    +

    image-20231112165527201

    +

    感觉上述两个问题都是因为有公共前缀【包括空产生式勉强也能算是这个情况】，导致信息不足无法判断应该怎么做，多读入一个字符（也即LR(1)）应该可以有效解决该问题。

    +

    SLR分析

    其实本质还是识别句柄问题，也即此时是归约还是移入，得看是不是句柄。故而LR0信息已经不能帮我们识别句柄了。

    +

    picture

    +

    Follow集可以帮助我们判断。由该状态I2可知，输入一个*应该跳转到I7。如果在I2把T归约为一个E，由Follow集可知E后面不可能有一个*，也就说明在这里进行归约是错误的，应该进行移入。

    +

    这种依靠Follow集和下一个符号判断的思想，就会运用在SLR分析中。

    +

    picture

    +

    picture

    +

    picture

    +

    但值得注意的是SLR分析的条件还是相对更严苛，它要求移进项目和归约项目的Follow集不相交，所以它也会产生像下图这样的冲突：

    +

    picture

    +

    LR(1)

    picture

    +

    SLR将子集扩大到了全集，显然进行了概念扩大。

    +

    含义为只有当下一个输入符号是XX时，才能运用这个产生式归约。这个XX是产生式左部非终结符的Follow子集。

    +

    picture

    +

    这玩意只有归约时会用到，这个很显然，毕竟前面提到的LR0的问题就是归约冲突。

    +

    picture

    +

    对了，值得注意的是这个FIRST(βa)，它表示的并不是FIRST(a)∪FIRST(β)，里面的βa应该取连接意，也即，当β为非空时这玩意等于FIRST(β)，当β空时这玩意等于FIRST(a)。

    +

    picture

    +

    刚刚老师对着这个状态转移图进行了一番强大的看图写话操作，我感觉还是十分地牛逼。她从这个图触发，讲述了状态I2为什么不能对R->L进行归约。

    +

    假如我们进行了归约，那么我们就需要弹出状态I2回到I0，压入符号R，I0遇到符号R进入了I3，I3继续归约回到I0，I0遇到符号S到状态I1，但1是接收状态，下一个符号是=不是$，所以错了。

    +

    picture

    +

    picture

    +

    比如说I8和I10就是同心的。左边的那个实际上是LR0项目集，所以这里的心指的是LR0。

    +

    picture

    +

    LALR分析

    然而，LR(1)会导致状态急剧膨胀，影响效率，所以又提出了个LALR分析。

    +

    picture

    +

    picture

    +

    跟前面的SLR对比可以发现，相当于它就是多了个逗号后面的条件。但是这是可以瞎合的吗？不会出啥问题不。。。

    +

    picture

    +

    好吧问题这就来了，LALR可能会产生归约归约冲突。但值得注意的是，它不可能出现归约移入冲突，因为LR1没有这个东西，而LALR只是修改右边的符号，所以也不会有这个。

    +

    picture

    +

    因为LALR实际上是合并了展望符集合，这东西与移进没有关系，所以只会影响归约，不会影响移进。

    +

    picture

    +

    LALR可能会产生归约归约冲突。但值得注意的是，它不可能出现归约移入冲突，因为LR1没有这个东西，而LALR只是修改右边的符号，所以也不会有这个。

    +

    它有可能做多余的归约动作，从而推迟错误的发现。

    +

    形式上与LR1相同；大小上与LR0/SLR相当；分析能力介于SLR和LR1之间；展望集仍为Follow集的子集。

    +

    总结

    感觉一路看下来，思路还是很流畅的。LR0会产生归约移进冲突和归约归约冲突，所以我们在归约时根据下一个符号是在移进符号还是在Follow集中来判断是要归约还是要移进。但是SLR条件严苛，对于那些移进符号集和Follow集有交的不适用，并且这种情况其实很普遍。加之，出于这个motivation：其实不应该用整个Follow集判断，而是应该用其真子集，所以我们开发出来个LR1文法。然后LR1文法虽然效果好但是状态太多了，所以我们再次折中一下，造出来个效果没有那么好但是状态少的LALR文法。

    +

    二义性文法的LR

    picture

    +

    所以我们可以用LR对二义性文法进行分析

    +

    我们可以通过自定义规则来消除二义性文法的归约移入冲突

    +

    picture

    +

    对于状态7，此时输入+ or *会面临归约移入冲突。由于有E->E+E归约式子，可以知道此时栈中为E+E。当输入*，由于*运算优先级更高，所以我们在此时进行移入动作转移到I5；当输入+，由于同运算先执行左结合，所以我们此时可以安全归约。

    +

    对于状态8，由于*运算比+优先级高，且左结合，所以始终进行归约。

    +

    picture

    +

    picture

    +

    picture

    +

    picture

    +

    错误检测

    picture

    +

    picture

    +

    它这个意思大概就是，符号栈和状态栈都一直pop，直到pop到一个状态，GOTO[符号栈顶，状态栈顶]有值【注意，始终保持符号栈元素+1 == 状态栈元素数+1】。然后，一直不断丢弃输入符号，直到输入符号在A的Follow集中。此时，就将GOTO值压入栈中继续分析。

    +

    【这其实也很有道理。如果输入符号在A的Follow集，说明A之后很有可能可以消耗这个输入符号。】

    +

    picture

    +

    picture

    +

    第五章 语义分析

    注意：

    +
      +
    1. 语义翻译包含语义分析和中间代码生成
      2. +
    2. 这笔包含了语法分析、语义分析、中间代码生成
    -
      -
    • 不是同一个，但是要确保数据不丢失。tomcat自动（IDEA不会活化）完成以下工作
        -
      • session的钝化：（序列化）
            * 在服务器正常关闭之前，将session对象序列化到硬盘上
-
        -
        • -
      -
      • -
    -
            * 具体是会放在这里：
-
-      ![image-20230223104447097](./JavaWeb/image-20230223104447097.png)
-    
-* session的活化：（反序列化
-    * 在服务器启动后，将session文件转化为内存中的session对象即可。
-
-我想，cookie应该在这点上不会像session这么做，因为cookie本质上是保存在客户端的数据，按理来说服务器端把cookie发出去之后就可以销毁了，在服务器序列化一点意义都没有。
-
    -
      -

    1. 销毁时间

      +

      思想：

        -

      1. 服务器关闭

        -
        2. -

      2. session对象调用invalidate() 。

        -
        3. -

      3. session默认失效时间 30分钟
        选择性配置修改

        -

        可以在每个项目的子配置文件（如下图）或者总的项目的父配置文件apache-tomcat-8.5.83\conf\web.xml中配置

        -

        image-20230223105053170

        -
        <session-config>
             <session-timeout>30</session-timeout>
         </session-config>
        4. +
      4. 通过为文法符号设置语义属性，来表达语义信息
        5. +
      5. 通过与产生式（语法规则）相关联的语义规则来计算符号的语义属性值
      -
      2. +

      也可能是先入为主吧，感觉用实验的方法来理解语义分析比较便利。语义分析相当于定义一连串事件，附加在每个产生式上。当该产生式进行归约的时候，就执行对应的语义事件。而由于执行语义分析时需要的符号在语法分析栈中，所以我们也同样需要维护一个语义分析栈，在移进时也需要进栈。

      +

      SDD/SDT概念

      语义分析一般与语法分析一同实现，这一技术成为语法制导翻译。

      +

      picture

      +

      picture

      +

      picture

      +

      SDD

      picture

      +

      可以回忆一下实验，相当于对每个产生式进行一个switch-case，然后依照产生式的类别和代码规则进行出栈入栈来计算属性值。

      +

      SDT

      picture

      +

      picture

      +

      SDD

      picture

      +

      概念

      一个很简单区分综合属性和继承属性的方法，就是如果定义的是产生式左部的属性，那就是综合属性；右部，那就是继承属性

      +

      综合属性

      picture

      +

      picture

      +

      继承属性

      picture

      +

      picture

      +

      这个东西就是我们实验里写的，副作用也是更新符号表。

      +

      属性文法

      没有副作用的SDD称为属性文法。

      +

      求值顺序

      picture

      +

      而感觉语法分析这个过程的产生式归约顺序就能一定程度上表示了这个求值顺序

      +

      picture

      +
        +
      1. 继承属性放在结点左边，综合属性放在结点右边
        2. +
      2. 如果属性值A依赖于属性值B，那么就有一条从B到A的箭头【B决定A】
        3. +
      3. 对于副作用，我们将其看作一个虚综合属性【注意是综合的，虽然它看起来既由兄弟结点决定也由子节点决定】
        4. +
      4. 可行的求值序列就是拓扑排序
      -

      案例

      -

      需求：

      +

      picture

      +

      蛤？这不是你自己规则设计有问题吗，关我屁事

      +

      picture

      +

      其实我还是不大理解，因为这个规则不是user定义的吗？所以产生环不也是它的事，难道说自顶向下或者自底向上分析还能优化SDD定义？？

      +

      感觉它意思应该是这样的，有一个方法能绝对不产生循环依赖环，也即将自底向上/自顶向下语法分析与语义分析结合的这个方法。这个方法就是它说的真子集。

      +

      所以我们接下来要研究的就是什么样的语义分析可以用自顶向下or自底向上语法分析一起制导。

      +

      S-SDD

      picture

      +

      那确实，你自底向上想要计算继承属性好像也不大可能

      +

      L-SDD

      picture

      +

      picture

      +

      对应了自顶向下的最左推导顺序

      +

      S-SDD包含于L-SDD

      +

      picture

      +

      SDT

      picture

      +

      S-SDD -> SDT

      picture

      +

      picture

      +

      当归约发生时执行对应的语义动作

      +

      picture

      +

      还需要加个属性栈

      +

      picture

      +

      所以S-SDD+自底向上其实很简单，因为只需在归约的时候进行语义分析，在移进的时候push进属性栈就行了。

      +

      picture

      +

      具体的S-SDD结合语法分析的分析过程可以看视频。

      +

      这个例子还算简单的，毕竟只是综合属性的计算而已，只需要加个属性栈，保存值就行了。

      +

      picture

      +

      我们可以来关注一下这个SDT的设计，也很简单。可以产生式和语义规则分离看待，这也给我们以后设计提供一定的启发。

      +

      L-SDD -> SDT

      picture

      +

      picture

      +

      picture

      +

      非递归的预测分析

      picture

      +

      picture

      +

      这个是自顶向下的语法分析，本来只用一个栈就行了，现在需要进行扩展。T的综合属性存放在它的右边，继承属性存放在它的平行位置。

      +

      当属性值还没计算完时，不能出栈；当综合记录出栈时，它要将属性值借由语义动作复制给特定属性。

      +

      picture

      +

      然后语义动作也得一起进栈。

      +

      image-20231117015114181

      +

      digit是终结符，只有词法分析器提供值

      +

      此时，digit跟一个语义动作关联，所以我们需要把它的值复制给它关联的这个语义动作{a6}，然后才能出栈。

      +image-20231117015317921 + +
      +

      关联的另一个实例：

      +

      image-20231117015508123

      +

      此时由于T’.inh还要被a3用到，所以我们就得在T’出栈前把它的这个inh值复制给a3。

      +
      +

      当遇到语义动作之后，就执行动作，并且出栈语义动作。

      +

      picture

      +

      它这意思应该是遇到每个产生式的每个符号要执行什么动作都是确定的，所以代码实现是可能的。

      +

      可以看到：

        -
      1. 访问带有验证码的登录页面login.jsp
        2. -
      2. 用户输入用户名，密码以及验证码。
          -
        • 如果用户名和密码输入有误，跳转登录页面，提示:用户名或密码错误
          • -
        • 如果验证码输入有误，跳转登录页面，提示：验证码错误
          • -
        • 如果全部输入正确，则跳转到主页success.jsp，显示：用户名,欢迎您
          • -
        -
        3. +
      3. 语义动作代码就是执行
        4. +
      4. 综合属性代码就是赋给关联语义动作
        5. +
      5. 非终结符就是选一个它作为左部的产生式，然后看看要不要用到它自身的属性对右部子属性进行复制（体现了继承属性）
      +

      递归的预测分析

      picture

      +

      666666666

      +

      感觉这个值得深思，但反正现在的我思不出啥了。。。

      +

      picture

      +

      picture

      +

      LR分析

      picture

      +

      picture

      +

      相当于把L-SDD转化为了个S-SDD。具体是这样，把原式子右边的变量替换为marker的继承属性，结果替换为marker的综合属性。那么新符号继承属性怎么算啊。。。不用担心，因为观察可知要使用的这两个非终结符一定已经在栈中了。

      +

      具体分析也看视频就好了。

      +

      第六章 中间代码生成

      中间代码的形式

      picture

      +

      逆波兰（后缀）

      picture

      +

      三地址码

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      false list就是if失败后的那个goto序号，true list是成功的那个goto序号，s.nextline是整个if的下一条指令

      +

      picture

      +

      四元式

      picture

      +

      picture

      +

      picture

      +

      增量生成

      +

      DAG图

      picture

      +

      picture

      +

      声明语句

      类型表达式

      picture

      +

      一般声明

      非嵌套

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      嵌套

      picture

      +

      picture

      +

      它这个相当于是把符号表和offset都整成了一个栈，毕竟确实过程调用就是得用栈结构的

      +

      picture

      +

      picture

      +

      记录

      picture

      +

      picture

      +

      之后用到该记录类型，就指向记录符号表即可。

      +

      picture

      +

      简单赋值语句

      定义

      这个就不用填符号表了，所以helper function都是用来产生中间代码的

      +

      picture

      +

      addr属性需要从符号表中获取

      +

      picture

      +

      临时变量处理

      picture

      +

      数组元素寻址

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      类型检查

      规则

      看个乐吧

      +

      picture

      +

      类型转换

      picture

      +

      picture

      +

      在语义动作中实现

      +

      控制流语句

      简单控制流

      picture

      +

      picture

      +

      反正意思就是用S.next这个继承属性来表示S.code执行完后的下一个三地址码地址。

      +

      picture

      +

      if-then

      picture

      +

      if-then-else

      picture

      +

      while-do

      picture

      +

      ;

      其实不大懂这什么玩意

      +

      picture

      +

      picture

      +

      picture

      +

      抽象

      +

      picture

      +

      picture

      +

      picture

      +

      布尔表达式

      布尔表达式翻译

      基本

      picture

      +

      picture

      +
      数值表示

      picture

      +

      picture

      +

      picture

      +
      控制流表示

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      混合模式布尔表达式

      picture

      +

      picture

      +

      picture

      +

      回填

      基本

      picture

      +

      picture

      +

      picture

      +

      这两个都是综合属性

      +

      相当于是一个waiting list

      +
      布尔表达式的回填

      picture

      +

      可以理解为，B这个表达式可以分为两种情况，两种情况有一个为真B就为真。那么，B的真回填list相当于也被分为了两种情况，所以要求B的就是把它们合起来。

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      原来回填是这个意思

      +
      控制流结构的回填

      nextline是一个综合属性

      +
      if-then

      picture

      +
      if-then-else

      picture

      +
      while-do

      picture

      +
      sequence

      picture

      +
      for

      picture

      +

      picture

      +
      repeat

      picture

      +
      switch-case

      TODO 这笔之后再看。。。。

      +

      picture

      +

      picture

      +

      picture

      +

      过程调用

      picture

      +

      picture

      +

      picture

      +

      输入输出语句

      TODO

      +

      picture

      +

      picture

      +

      题型1 四元序列

      picture

      +

      第七章 运行存储分配

      概念

      存储组织

      活动记录

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      静态/动态链

      picture

      +

      静态链也被称作访问链，用于访问存放于其他活动记录中的非局部数据。

      +

      动态链也被称作控制链，用于指向调用者的活动记录。

      +

      picture

      +

      picture

      +

      内存对齐

      picture

      +

      picture

      +

      作用域

      picture

      +

      picture

      +

      传参方式

      传值

      picture

      +

      传地址

      picture

      +

      传值结果

      picture

      +

      反正意思就是既要得到原来的A，又要修改A

      +

      传名

      picture

      +

      picture

      +

      静态存储分配

      picture

      +

      picture

      +

      顺序分配法

      picture

      +

      层次分配法

      picture

      +

      栈式存储分配

      概念

      picture

      +

      picture

      +

      也就是说左边及其所有子树全调完了，才能调下一个兄弟的。

      +

      picture

      +

      picture

      +

      image-20231114154150835

      +

      左边这几点设计规则都十分reasonable，很值得注意。

      +

      不过我其实挺好奇，参数存在那么后面该咋访问。。。。看xv6，似乎是fp指向前面，sp才指向local，也即用了两个栈指针。

      +

      这个控制链也是约定俗成的，具体可以想起来xv6也是类似结构：

      +

      picture

      +

      当函数返回的时候，就会进行恢复现场，从而出栈一直到ra，很合理。

      +

      调用/返回序列

      是什么

      picture

      +

      调用序列应该就是设置参数、填写栈帧一类，返回序列就是恢复现场

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      生成代码

      picture

      +
      调用序列

      传变量、改变meta data、改变top和sp指针

      +

      picture

      +

      picture

      +
      返回序列

      picture

      +

      变长数据

      picture

      +

      这段解释了下为什么不用堆，说得很好

      +

      picture

      +

      缺点

      picture

      +

      第二点，比如malloc后不free

      +

      栈中非局部数据的访问

      picture

      +

      有过程嵌套

      picture

      +

      静态作用域

      访问链

      picture

      +

      picture

      +

      picture

      +

      picture

      +
      建立访问链

      picture

      +

      picture

      +

      picture

      +
      过程参数的访问链

      picture

      +

      picture

      +

      Display表

      通俗解释

      每一个嵌套深度的分配一个Display位

      +

      S嵌套深度1，所以占据d[1]；Y和X嵌套深度2，所以占据d[2]；Z嵌套深度3，所以占据d[3]。

      +

      然后，一开始遇到个S，d1指向S；然后调用Y，d2指向Y；然后Y中调用X，就修改d2指向X；然后调用Z，就修改d3指向Z。

      +

      总之显示栈就是这个变换指针的过程。

      +

      至于控制栈，要打印这里面的display表，就是看层数。如果d1那就打印当前层，d2就打印的12层，d3就123层【不是纯显示栈，是它自己内部的未变换指针的结果】

      +

      picture

      +

      picture

      +

      picture

      +

      结果：SXZ

      +
      定义

      picture

      +

      picture

      +

      picture

      +
      访问流程

      picture

      +

      picture

      +

      picture

      +
      生成代码

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      动态作用域

      静态作用域是空间上就近原则，动态是时间上。

      +

      picture

      +

      picture

      +

      无过程嵌套

      picture

      +

      picture

      +

      也就是说这时候非局部的一定是全局变量或者静态的局部变量。

      +

      堆管理

      picture

      +

      内存管理器

      局部性

      picture

      +

      堆分配算法

      人工回收请求

      符号表

      如题

      picture

      +

      picture

      +

      如果是支持过程声明嵌套，顺着符号表就可以找到其父过程/子过程的数据。

      +

      符号表也可以用于构造访问链，因为过程名也是一种符号。

      +

      picture

      +

      符号表的建立

      picture

      +

      第九章 代码生成

      概述

      picture

      +

      目标代码形式

      picture

      +

      指令选择

      picture

      +

      寄存器分配

      picture

      +

      计算顺序选择

      picture

      +

      不讨论这个

      +

      目标语言

      定义

      picture

      +

      指令开销

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      运行时刻地址

      简单的代码生成器

      后续引用信息

      picture

      +

      picture

      +

      寄存器与地址描述符

      picture

      +

      代码生成算法

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      窥孔优化

      picture

      +

      冗余指令消除

      picture

      +

      不可达代码消除

      picture

      +

      强度削弱

      picture

      +

      特殊机器指令使用

      picture

      +

      寄存器分配指派

      picture

      +

      全局寄存器分配

      picture

      +

      引用计数

      picture

      +

      picture

      +

      picture

      +

      picture

      +

      所以这东西是用来决策寄存器分配的

      +

      外层循环的寄存器指派

      picture

      +

      picture

      +

      反正类似保护现场恢复现场

      +

      拓展阅读

      AC自动机

      在思考自动机和动态规划的关系时，胡乱搜索看到了AC自动机，于是来了解了一下。

      +
      +

      算法学习笔记(89): AC自动机 - Pecco的文章 - 知乎

      +
      +
      +

      考虑一个问题：给出若干个模式串，如何构建一个DFA，接受所有以任一模式串结尾（称为与该模式串匹配）的文本串？

      +

      可以先思考一个更简单的问题：如何构建接受所有模式串的DFA？很明显，**字典树**就可以看做符合要求的自动机。例如，有模式串"abab"、"abc"、"bca"、"cc" ，我们把它们插入字典树，可以得到：

      +

      picture

      +

      为了使它不仅接受模式串，还接受以模式串结尾的文本串，一个看起来挺正确的改动是，使每个状态接受所有原先不能接受的字符，转移到初始状态（即根节点）。

      +

      picture

      +

      但是如果我们尝试"abca"，我们会发现我们的自动机并不能接受它。稍加观察发现，我们在状态5接受a应该跳到状态8才对，而不是初始状态。某种意义上来说，状态7是状态5退而求其次的选择，因为状态7在trie上对应的字符串"bc"是状态5对应的字符串"abc"的后缀。既然状态5原本不能接受"a"，我们完全可以退而求其次看看状态7是否可以接受。这看起来很像KMP算法，确实，AC自动机常常被人称作trie上KMP。

      +

      所以我们给每个状态分配一条fail边，它连向的是该状态对应字符串在trie上存在的最长真后缀所对应的状态。我们令所有状态p接受原来不能接受的字符c，转移到 next(fail(p),c) ，特别地，根节点转移到自己。为什么不需要像KMP算法一样，用一个循环不断进行退而求其次的选择呢？因为如果我们用BFS的方式进行上面的重构，我们可以保证 fail(p) 在p重构前已经重构完成了，类似于动态规划。

      +

      picture

      +

      这样建fail边和重构完成后得到的自动机称为AC自动机（Aho-Corasick Automation）。

      +

      我们发现fail边也形成一棵树，所以其实AC自动机包含两棵树：trie树和fail树。一个重要的性质是，如果当前状态 p 在某个终止状态 s 的fail树的子树上，那么当前文本串就与 s 所对应模式串匹配。

      +
      +

      也就是说它的解决方法是加fall边（蓝色）和加新边（红色），

      +]]> + + + Lab0 + /2023/02/25/cs144$lab0/ + Lab0
      +

      本次实验一直在强调的一点就是，TCP的功能是将底层的零散数据包，拼接成一个reliable in-order的byte stream。这个对我来说非常“振聋发聩”（夸张了233），以前只是背诵地知道TCP的可靠性，这次我算是第一次知道了所谓“可靠”究竟可靠在哪：一是保证了序列有序性，二是保证了数据不丢失（从软件层面）。

      +

      还有一个就是大致了解了cs144的主题：实现TCP协议。也就是说，运输层下面的那些层是不用管的吗？不过这样也挺恰好，我正好在学校的实验做过对下面这些层的实现了，就差一个TCP23333这样一来，我的协议栈就可以完整了。

      -
      初见思路

      我们可以在服务器端使用session存储password和username的map，存储验证码图片编号和图片的map，然后用cookie携带验证码图片编号，在req中存储用户名和密码。

      -
      正确思路

      感觉我上面的思路是没有充分利用到session的性质，仅仅把它作为在服务器端存储数据的工具，

      -

      “在服务器端存储password和username的map，存储验证码图片编号和图片的map，然后用cookie携带验证码图片编号，在req中存储用户名和密码。”

      -

      这样也依然成立，跟session没半毛钱关系。我们可以这样使用session：

      -
        -
      1. 在服务器端存储password和username的map，存储验证码图片编号和图片的map
        2. -
      2. 当会话建立，由于没有cookie，故而session第一次创建。我们在session内写入验证码对应的编号，把图片通过response发送给客户端。
        3. -
      3. 会话端输入图片验证码后，按下submit按键，验证码存入request域，向服务器端发送请求
        4. -
      4. 服务器端Servlet从请求中get到验证码，然后在session中get到当前验证码的图片编号，向一开始存储的map查询数据，这样就能验证验证码是否正确了
        5. -
      -

      那么在这里为什么不用Cookie而使用session呢？大概是因为cookie不安全罢（慌乱）

      -
      代码
      jsp
      <html lang="en">
      <head>
          <meta charset="UTF-8">
          <title>Title</title>
      </head>
      <body>
      <form action="/practice_war/loginServlet" method="post">
          name: <input type="text" name="username" id="username" placeholder="请输入用户名">
          password: <input type="password" name="password" id="password" placeholder="请输入密码">
          verifycode:<input type="text" name="verifycode" id="verifycode" placeholder="请输入验证码">

          <img id="img" src="/practice_war/check"/>

          <input type="submit" value="submit">
      </form>
      <script>
          window.onload = function(){
              document.getElementById("img").onclick = function(){
                  this.src = "/practice_war/check?"+new Date().getTime();
              }
          }

      </script>
      </body>
      </html>
      - -
      checkcode
      @WebServlet("/check")
      public class ServletDemo extends HttpServlet {
          @Override
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              //验证码图片大小
              final int width = 100;
              final int height = 50;

              /* 绘制验证码 */
              BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
              Graphics pen = image.getGraphics();
              //绘制背景
              pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
              pen.fillRect(0,0,width,height);
              //绘制边框
              pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
              pen.drawRect(0,0,width-1,height-1);
              //随机填充字母数字
              String source = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890";

              StringBuilder verifyAnswer = new StringBuilder();

              for (int i = 1; i <= 4; i++){
                  int index = (int)(Math.random()*source.length());
                  verifyAnswer = verifyAnswer.append(source.charAt(index));
                  pen.drawString(source.substring(index,index+1),20*i,27);
              }
              //画干扰色线
              pen.setColor(new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)));
              for (int i = 0; i < 5; i++){
                  pen.drawLine((int)(Math.random()*width),(int)(Math.random()*height),(int)(Math.random()*width),(int)(Math.random()*height));
              }

              request.getSession().setAttribute("verifycode",verifyAnswer.toString());
              System.out.println("verify:"+verifyAnswer.toString());
              //将图片输出
              ImageIO.write(image,"jpg",response.getOutputStream());
          }

          @Override
          protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              this.doGet(request, response);
          }
      }
      - -
      login
      @WebServlet("/loginServlet")
      public class loginServlet extends HttpServlet {
          @Override
          protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              HttpSession session = request.getSession();
              String verifycode = request.getParameter("verifycode");
              System.out.println(flag);

              String ans = session.getAttribute("verifycode");
              if (ans == null||!ans.equals(verifycode)){
                  session.removeAttribute("verifycode");
                  // 重定向到错误界面
                  request.getRequestDispatcher("/fail_code").forward(request,response);
                  return;
              }
              session.removeAttribute("verifycode");

              // 进行密码账号匹配处理
              String username = request.getParameter("username");
              String password = request.getParameter("password");
              System.out.println(username+"  "+password);
              if(UserDao.login(new User(username,password))){
                  // 成功界面
                  request.setAttribute("uname",username);
                  request.getRequestDispatcher("/success").forward(request,response);
              }else{
                  // 失败界面
                  request.getRequestDispatcher("/fail").forward(request,response);
              }
          }

          @Override
          protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              this.doGet(request, response);
          }
      }
      - -

      老师的写法是将错误信息直接写在原登录界面，和我的略有不同：

      -
      // in loginServlet
      if (!session.getAttribute("verifycode").equals(verifycode)){
          request.setAttribute("message","checkcode_fail");
          request.getRequestDispatcher("/login.jsp").forward(request,response);
          return;
      }
      - -
      // in login.jsp
          <%
             String message = (String) request.getAttribute("message");
             if(message != null){
                 if(message.equals("checkcode_fail")){
                     out.write("验证码错误！");
                 }else if(message.equals("pass_fail")){
                     out.write("用户名或密码错误！");
                 }
             }
          %>
      - -

      以及success.jsp

      -

      image-20230302233110661

      -
      成功/两个失败

      仅以成功为例

      -
      @WebServlet(value = "/success")
      public class SuccessServlet extends HttpServlet {
          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
              doPost(req,resp);
          }

          @Override
          protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
              resp.setContentType("text/html;charset=utf-8");
              resp.getWriter().write("登录成功！"+req.getAttribute("uname")+",欢迎您");
          }
      }
      - -

      JSP

      -

      现在都用 Thymeleaf ，更符合 MVC 的执行过程，也没有 JSP 这种耦合杂乱的页面代码，但是模板引擎的思路大致相同，还是可以看一看的

      +
      +

      本次实验与TCP的关系：

      +

      在我们的webget实现中，正是由于TCP的可靠传输，才能使我们的http request正确地被服务器接收，才能使服务器的response正确地被我们接收打印。

      +

      而在ByteStream中，我们也做了跟TCP类似的工作：接收substring，并且将它们拼接为in-order的byte stream【由于在内存中/单线程，所以这个工作看起来非常简单】：

      +
      while(is_input_end == false&&pointer<length){
          if(buffer.size() == capacity)   break;
          buffer.push_back(data[pointer]);
          pointer++;
      }
      -

      改动之后无需重启服务器，刷新界面即可。

      +

      Fetch a Web page

      主要是介绍了telnet指令

      +

      屏幕截图 2023-02-23 194758

      +

      Send yourself an email

      用的是telnet带smtp参

      +

      Listening and connecting

      上面的telnet是一个client program。接下来我们要把自己放在server的位置上。

      +

      用的是netcat指令。

      +

      image-20230223202202509

      +

      Use socket to write webget

      这个确实不难，就是这个地方有点坑：

      -

      关于热更新的机制可以看看这篇文章，水平有限还看不懂就先放在这了：

      -

      JSP热部署的实现原理[通俗易懂]

      +

      Please note that in HTTP, each line must be ended with “\r\n” (it’s not sufficient to use just “\n” or endl).

      -

      概念

      JSP(Java Server Pages) Java服务器端页面，用于简化书写

      -

      可以理解为：一个特殊的页面，其中既可以定义html标签，又可以定义java代码

      -

      比如说，上一个案例的Servlet代码就可以直接写入到JSP中，而且response和request这些对象可以直接用

      -
      <%@ page import="java.text.SimpleDateFormat" %>
      <%@ page import="java.util.Date" %>
      <html>
      <body>
      <h2>Hello World!</h2>
      <%
          //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
          response.setCharacterEncoding("utf-8");

          //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
          response.setHeader("content-type","text/html;charset=utf-8");
          if(request.getCookies() != null)
              for(Cookie c : request.getCookies()){
                  if(c.getName().equals("isfirst")){
                      //response.getWriter().write("<h1>欢迎回来，您上次访问的时间为<h1>"+c.getValue());
                      response.getWriter().write("<h1>Welcome!The last time you visit is <h1>"+c.getValue());
                      //System.out.println("欢迎回来，您上次访问的时间为"+c.getValue());
                      break;
                  }
              }
          else
              response.getWriter().write("<h1>Hello!Welcome!<h1>");

          SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-HH:mm:ss");
          Date date1 = new Date();
          String currentTime = dateFormat.format(date1);

          //response.getWriter().write("<h1>你好！欢迎你！<h1>");
          //System.out.println("你好！欢迎你！");
          response.addCookie(new Cookie("isfirst",currentTime));
      %>
      </body>
      </html>
      +

      导致我跟400 Bad Request大眼瞪小眼了好久。。。

      +
      void get_URL(const string &host, const string &path) {
      	TCPSocket sock;
          string tmp;
      //    sock.set_blocking(true);// 默认情况下即为true
          sock.connect(Address(host,"http"));
          sock.write("GET " + path + " HTTP/1.1\r\nHost: " + 
                     host + "\r\nConnection: close\r\n\r\n");
          
          while((tmp = sock.read(1)) != ""){
              cout << tmp;
          }
      	/*
      	上面那个写法不大规范，更规范的写法：
          while(!sock.eof()){
              cout << sock.read(1);
          }
      	*/
          sock.close();
      }
      -

      最终效果：

      -image-20230222230929893 +

      还有一点值得注意的是，当我这样时：

      +
      TCPSocket sock;
         sock.set_blocking(false);
         sock.connect(Address(host,"http"));
      -

      原理

      JSP本质上是Servlet

      -

      image-20230222233533332

      -

      JSP的脚本

      JSP定义Java代码的方式

      -
        -

      1. <% 代码 %>

        -

        定义的java代码，在service方法中。service方法中可以定义什么，该脚本中就可以定义什么。

        -

        也即最后会构成Servlet体

        -
        2. -

      2. <%! 代码 %>

        -

        定义的java代码，在jsp转换后的java类的成员位置。可以是成员变量，或者是成员方法。

        -

        注：最好不要在Servlet中定义成员变量，否则容易引发线程安全问题。

        -
        3. -

      3. <%= 代码 %>

        -

        定义的java代码，会输出到页面上。输出语句中可以定义什么，该脚本中就可以定义什么。

        -

        image-20230223000057595

        -

        比如说可以用来输出某个变量的值。注意这东西由于本质上是写在Servlet的service方法中的，因而当成员变量和service方法的局部变量重名，会依据就近原则优先使用局部变量的值。

        -
        4. -
      -

      指令

      也就是jsp开头那些东西，比如说这个：

      -
      <%@ page contentType="text/html;charset=UTF-8" language="java" %>
      +

      会报错Operation now in progress。

      +
      +

      关于socket通信中在connect()遇到的Operation now in progress错误

      +

      遇到此错误是因为将在connect()函数之前将套接字socket设为了非阻塞模式。改为在connect()函数之后设置即可。

      +
      +

      我觉得这个实验设计得挺好的，写的时候感觉很有意思。我推荐看下 https://github.com/shootfirst/CS144/blob/main/lab-0/apps/webget.cc 里的注释，写得很好很规范，让我明白了很多本来没搞懂的地方，比如说shutdown的用法。

      +

      An in-memory reliable byte stream

      +

      实现一个ByteStream类，可以通过read和write对其两端进行读写。是单线程程序，因而无需考虑阻塞。

      +
      +

      感想

      这东西其实是很简单的，但是我还是花了一定的时间，主要原因有两点，一是我不懂c++，所以一些地方错得我很懵逼，二是因为我是sb。

      +

      下面就记录下三个我印象比较深刻的错误吧。

      +
      错误1 member initialization list

      构造函数我一开始是这么写的：

      +

      image-20230224113108208

      +

      结果爆出了这样的错：

      +

      image-20230224112056879

      +

      搜了半天也没看懂怎么回事，去求助了下某场外c艹选手，才知道了还有成员变量初始化列表这玩意，这个东西似乎比较高效安全。

      +

      于是我改成了这么写：

      +

      image-20230224113333962

      +

      它告诉我buffer也得初始化。于是我又这么写：

      +

      image-20230224113358856

      +

      又是奇奇怪怪的错误，说明vector不能这么初始化。

      +

      场外c艹选手看到了这个：

      +

      image-20230224113456432

      +

      所以说vector应该这样初始化：

      +

      image-20230224113549970

      +
      错误2 使用了vector作为buffer的载体

      应该使用的是可以从front删除数据的数据结构，比如说deque。【vector也行，但是效率较低】

      +

      具体为什么，可以以数据流为cat为例。执行peek(2)时，使用vector得到的是at，使用deque得到的是ca。

      +
      错误3 错误地阻塞

      一开始在write方法，我是这么写的：

      +
      int length = data.length();
      while(is_input_end == false&&pointer<length){
          while(buffer.size() == capacity);
          buffer.push_back(data[pointer]);
          pointer++;
          total_write ++;
      }
      -

      用来配置jsp的资源页面信息

      -
        -
      • 分类：
          -
        1. page ： 配置JSP页面的
            -
          • contentType：等同于response.setContentType() 
            contentType="text/html;charset=UTF-8"
            -
              -
            1. 设置响应体的mime类型以及字符集
              2. -
            2. 设置当前jsp页面的编码（只能是高级的IDE才能生效，如果使用低级工具，则需要设置pageEncoding属性设置当前页面的字符集）
              3. -
            -
            • -
          • import：导包
            • -
          • errorPage：当前页面发生异常后，会自动跳转到指定的错误页面
            • -
          • isErrorPage：标识当前页面是否是错误页面。
              -
            • true：是，可以使用内置对象exception【用来获取异常名称/信息等】
              • -
            • false：否。默认值。不可以使用内置对象exception
              • -
            -
            • -
          -
          2. -
        2. include ： 页面包含的。导入页面的资源文件，可以引入其它的jsp或者html，引入之后就会展示同样的内容。
            -
          • <%@include file=”top.jsp”%>
            • -
          -
          3. -
        3. taglib导入资源。用来导入标签库
              * <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-        * prefix：前缀，自定义的。之后就可以用`<c:XXX>`了。相当于什么std::。
-
          -
          4. -
        -
        • -
      -

      中文乱码

      但是注意一点

      -
      //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
      response.setCharacterEncoding("utf-8");

      //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
      response.setHeader("content-type","text/html;charset=utf-8");
      +

      结果就是测试用例Timeout。我找了很久都不知道错在了哪，最后求助了场外观众【罪过……这次实验太不独立了】，学着他把length改成了这样：

      +
      int length = min(data.length(),capacity-buffer.size());
      -

      这样做在Servlet不会导致中文乱码，但JSP不行，这个大概是因为两者原理不一样。

      -

      Servlet的中文乱码：

      -image-20230222231756277 +

      发现成了。

      +

      我去看了看testbench，猜测应该是因为阻塞了，我还以为是deque自身会阻塞【是的，我完全没注意到自己顺手把阻塞写了下去】，查了半天发现不会，最后才发现是自己不小心搞错了呃呃…………

      +

      代码

      头文件声明

      class ByteStream {
        private:
          // Your code here -- add private members as necessary.

          // Hint: This doesn't need to be a sophisticated data structure at
          // all, but if any of your tests are taking longer than a second,
          // that's a sign that you probably want to keep exploring
          // different approaches.

          size_t total_write;
          size_t total_read;
          bool is_input_end;
          const size_t capacity;
          deque<char> buffer;
      -

      JSP的：

      -

      image-20230222231820358

      -

      Servlet乱码是因为客户端和response请求体编码不一致，JSP乱码与JSP的原理有关，是只跟服务器端有关

      +

      具体实现

      ByteStream::ByteStream(const size_t cap) : total_write(0),total_read(0),is_input_end(false),capacity(cap),buffer(){ }

          //! Write a string of bytes into the stream. Write as many
          //! as will fit, and return how many were written.
          //! \returns the number of bytes accepted into the stream
      size_t ByteStream::write(const string &data) {
          if(is_input_end == true)    is_input_end = false;
          int pointer = 0;
          int length = data.length();
          while(is_input_end == false&&pointer<length){
              if(buffer.size() == capacity)   break;
              buffer.push_back(data[pointer]);
              pointer++;
          }
          total_write+=pointer;
          return pointer;
      }
          //! Peek at next "len" bytes of the stream
      //! \param[in] len bytes will be copied from the output side of the buffer
      string ByteStream::peek_output(const size_t len) const {
          string res;
          size_t i = 0;
          for (auto it = buffer.begin(); it != buffer.end(); it++) {
              if (i >= len)
                  break;
              i++;
              res.push_back(*it);
          }
          return res;
      }

          //! Remove bytes from the buffer
      //! \param[in] len bytes will be removed from the output side of the buffer
      void ByteStream::pop_output(const size_t len) {
          size_t i;
          for (i = 0; i < len; i++) {
              if (buffer.empty())
                  break;
              buffer.pop_front();
          }
          total_read+=i;
      }

      //! Read (i.e., copy and then pop) the next "len" bytes of the stream
      //! \param[in] len bytes will be popped and returned
      //! \returns a string
      std::string ByteStream::read(const size_t len) {
          string res = peek_output(len);
          pop_output(len);
          return res;
      }

      void ByteStream::end_input() {is_input_end = true;}

      bool ByteStream::input_ended() const { return is_input_end; }

      size_t ByteStream::buffer_size() const { return buffer.size(); }

      bool ByteStream::buffer_empty() const { return buffer.empty(); }

      bool ByteStream::eof() const { return is_input_end && buffer.empty(); }

      size_t ByteStream::bytes_written() const { return total_write; }

      size_t ByteStream::bytes_read() const { return total_read; }

      size_t ByteStream::remaining_capacity() const { return capacity - buffer.size(); }
      +]]> + + + Lab1 StreamReassembler + /2023/02/25/cs144$lab1/ + Lab1 StreamReassembler
      +

      TCP managed to produce a pair of reliable in-order byte streams (one from you to the server, and one in the opposite direction), even though the underlying network only delivers “best-effort” datagrams.

      +

      You also implemented the byte-stream abstraction yourself, in memory within one computer.

      +

      Over the next four weeks, you’ll implement TCP, to provide the byte-stream abstraction between a pair of computers separated by an unreliable datagram network.

      +
      +

      我们的任务是实现一个StreamReassembler。它的具体功能相信看下数据传输路径就很明了了：

      -

      编译jsp有以下几个步骤：
      (1)把jsp转化为java源码。pageEncoding=xxx指定以xxx编码格式读取jsp文件，因此，jsp文件的编码格式应与pageEncoding值一致。
      (2)把java源码编译为字节码，即.class文件。转化后的java源码为utf-8编码格式，字节码也为utf-8编码，我们无需干预。
      (3)执行.class文件。在此过程，需向浏览器发送中文字符，contentType=xxx指定了jsp以xxx编码显示字符。也就是在浏览器中查看页面编码，其值为contentType指定的编码。

      -

      因此，在1、3环节，**只要指定一致的编码格式(jsp文件编码格式=pageEncoding=contentType)**，即可保证jsp页面不出现乱码。
      举例：jsp文件以utf-8格式编写，那么pageEncoding=utf-8, contentType=utf-8，就保证了jsp页面不出现乱码。
      ————————————————
      版权声明：本文为CSDN博主「liuhaidl」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
      原文链接：https://blog.csdn.net/liuhaidl/article/details/84012372

      +

      receiver的数据传输路径：network → StreamReassembler整流 →（write）ByteStream（read）→ app

      -

      指定方法是在JSP开头添加：

      -
      <%@ page pageEncoding="UTF-8"%>
      +

      感想

      先放个通关截图在这。

      +

      image-20230225192145829

      +

      这个实验我前前后后总共做了大概有9h+……写我下面放上来的屎山代码可能大概用了5h+。我总共使用了140+行代码实现我的核心函数push_substring。

      +

      整个过程，包括思路和代码都十分复杂，但最后的表现相比于别人好像也没好到哪去，让我不禁怀疑自己是不是想错了……以及，这样的复杂性也给我带来很多担忧，担心会不会在以后的实验因为这个的bug而寄，毕竟我在写笔记的同时都已经找到了不止一个bug了（）希望人没事。

      +

      总而言之，先把我的思路和一步步的代码拆解放上来吧。

      +
      +

      后记：

      +

      不得不说，这个东西太健壮了，给后面的TCPReceiver省去了好多功夫……

      +

      比如说，TCPReceiver无需考虑ack怎么算，因为这里就帮你算好了；TCPReceiver无需考虑数据包重叠或者重复，因为这里已经考虑到这个情况了；TCPReceiver无需担忧FIN是否会因为容量满丢弃一部分数据而未达到真正的FIN，只需调用其相关接口判断就行。

      +

      它虽然帮助了TCPReceiver那么多，但很神奇的是，它们的耦合性并不高。你把StreamReassembler单独拆出来看，左看右看，它都确实仅仅只是一个健壮的区间合并算法。

      +

      这得益于实验设计的精良，得益于设计TCPReceiver时的野心。这些边界情况都这么麻烦，而且都只与区间合并有关，那么我们为什么不直接把它抽象进区间合并进行处理呢？这种想法极富胆识，事实证明最后也确实能实现。这种设计理念让我受益很深。

      +
      +

      为什么我的思路那么复杂

      看了感恩的代码，我发现我俩的大题思路其实差不多是一模一样的，都是先进行两轮的区间合并，然后再处理但为啥我看起来就那么复杂呢？

      +

      一是题意理解问题。

      +

      我发现他对_capacity的理解跟我的理解不一样emmm……

      +

      额好像怪我没认真看指导书的图。

      +

      image-20230225232723083-1677339210527-2

      +

      我理解的capacity：绿色部分和红色部分的净含量

      +

      似乎是真正的capacity：绿色部分+红色部分+空部分？？也就是说capacity只是一个跟index差不多的索引下标？？…………

      +
       // out of bound
      if (start >= hope_to_rec + _capacity - _output.buffer_size()) {
          return;
      }
      -

      内置对象

      在jsp页面中不需要获取和创建，可以直接使用的对象。

      -

      jsp一共有9个内置对象。

      -
        -

      1. request HttpServletRequest 一次请求访问的多个资源(转发)

        -
        2. -

      2. response HttpServletResponse 响应对象

        -
        3. -

      3. out： JspWriter 字符输出流对象。可以将数据输出到页面上。和response.getWriter()类似

        -
          -
        • response.getWriter()和out.write()的区别： 在tomcat服务器真正给客户端做出响应之前，会先找response缓冲区数据，再找out缓冲区数据。因而response.getWriter()数据输出永远在out.write()之前 所以说，用out更好，因为它跟随你布局变化，你out写在哪，这句话最终就会输出在哪
          • -
        -
        4. -

      4. pageContext PageContext 当前页面共享数据，还可以获取其他八个内置对象

        -
        5. -

      5. session HttpSession 一次会话的多个请求间

        -
        6. -

      6. application ServletContext 所有用户间共享数据

        -
        7. -

      7. page Object 当前页面(Servlet)的对象，相当于this

        -
        8. -

      8. config ServletConfig Servlet的配置对象

        -
        9. -

      9. exception Throwable 异常对象。只在page指令的isErrorPage为true的情况下才能使用此对象。

        -
        10. -
      -

      其中，

      -

      image-20230307144539506

      -

      这四个为用来共享数据的域对象

      -

      演变：MVC开发模式

      jsp的演变

      image-20230307145442383

      -

      MVC模式

      将程序分成三个部分，分别是M-V-C。

      -
        -
      1. M：Model，模型。JavaBean
          -
        • 完成具体的业务操作，如：查询数据库，封装对象
          • -
        -
        2. -
      2. V：View，视图。JSP
          -
        • 展示数据
          • -
        -
        3. -
      3. C：Controller，控制器。Servlet
          -
        • 获取用户的输入
          • -
        • 调用模型
          • -
        • 将数据交给视图进行展示【域对象共享数据】
          • -
        -
        4. -
      -

      image-20230307150845273

      -

      服务器将接收的请求给控制器处理，控制器控制model完成必要的运算，model把算出的东西返回给控制器，控制器再把数据交给视图展示，数据最终就回到了浏览器客户端。

      -

      这就算是一个微型CPU了吧，控制器就是CU，模型就是ALU，也许客户端和视图什么的可以视为IO接口。

      -
        -

      • 优缺点：

        -
          -

        1. 优点：

          -
            -
          1. 耦合性低，方便维护，可以利于分工协作
            2. -
          2. 重用性高
            3. -
          -
          2. -

        2. 缺点：

          +

          也就是说我能过测试是因为偶然吗？？

          +

          我其实感觉正确理解的capacity意义好怪啊，这怎么就能节省内存了呢？我觉得我理解的反而比较有道理（倔强）

          +

          笑一笑算了家人们。总之先这么写吧，以后的实验寄掉了再回来改。

          +
          +

          UPDATE: 确实寄掉了，并且已经改过来了，也不复杂，只需要添加对right边界的处理就行。【指去掉超出start+capacity的部分。】

          +
          +

          二是代码规范问题。

          +

          首先他代码规范性强，看起来非常舒服。其次他会用类似upper_bound()这样的函数（反观我压根没想起来），这样就显得比我的循环简洁了很多很多。

          +

          三是设计问题。

          +

          他用的是map我用的是set。确实是map比较合理，它既有find功能也兼具了有序的特性。

          +

          我的思路

          我们要做的，是将零散的数据包拼接成完整的字节流，并且将整流过的数据送入ByteStream中，这通过核心函数push_substring实现。我们可以先来看看push_substring的定义：

          +
          void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) ;
          + +

          data为数据包，index为data中第一个字符在整个字节流的下标，eof用来标识这是字节流的最后一个数据包。

          +
          +

          详细说明：

          +

          比方说有字节流“abcdefg”，则合法的参数对有如：{“abc”,0,0},{“cdef”,2,0},{“g”,6,1}

          +
          +

          通俗来说，我们这个函数的功能就是，把一堆起始下标为index的data（无序、可能重叠）拼接为一个完整的字节流。

          +

          听起来有没有觉得很耳熟？是的，我认为这正是“区间合并”问题。我接下来便通过区间合并的思想，对问题进行如下数据结构以及算法的设计。

          +

          数据结构

          区间

          由于是区间合并问题，所以就先需要定义区间。

          +
          struct node {
              size_t left;   // 当前data位于总体的左index（闭）
              size_t right;  // 右index（开）
              string data;
              bool operator<(const node &b) const { return left < b.left; }
          };
          + +

          集合

          我们需要维护一个左端点升序的区间集合，故使用内部红黑树实现的有序集合set。

          +
          set<node> buffer;   // 存储结构
          + +

          算法

          我们要做的，是对数据包进行整流，并且把整流过的部分输送到ByteStream中。由于存储结构存在_capacity的上限，因而，我们需要尽可能早地把存储结构中已经整流好的数据送入ByteStream中。

          +

          那么，如何定义“已经整流好的数据”呢？它需要满足跟“之前已经整流好了的数据”的有序性，也即，比方说[0,1000]已经整流完毕送入app，那么下一个送入app的数据一定满足index=1001。

          +

          因而，我们可以维护一个变量left_bound，表示下一个将被app接受的数据的index（如上例的1001）。为了达到“尽早”目的，我们需要在每次push_substring执行完区间合并之后，检查buffer的第一个区间的左端点是否与left_bound相等，是的话则将第一个区间写入ByteStream，不是的话就什么也不做。

          +

          因而，在push_substring中，对于一个新来的数据包，我们大致需要进行以下几步：

            -
          1. 使得项目架构变得复杂，对开发人员要求高
            2. -
          -
          3. +
        3. 将参数所给的区间( [index, index+data.length()) )并入区间集合buffer中
          4. +
        4. 查看是否需要ByteStream
        -
        • -
      -

      那么，我们可以知道，jsp就只需负责数据的展示了。那怎么展示数据呢？这就需要用到jsp的几个技术了：

      -

      EL表达式

      -

      注意，servlet3.0以来默认关闭el表达式解析，需要手动在page上加属性打开，详见 jsp文件中的el表达式失效问题解决

      +

      区间合并

      问题定义

      问题可抽象为：

      +
      +

      给定一个有序区间集合buffer，以及一个小区间node，你需要把node塞进buffer里。

      +

      Example： buffer = {[1,3),[5,7)} , node = [6,8) 输出：buffer = {[1,3), [5,8)}

      -

      Expression language，替换和简化jsp上java代码的书写

      -

      语法：${表达式}

      -

      jsp会执行里面的表达式，然后把结果输出。

      -

      image-20230307151706211

      -

      加反斜杠可忽略。

      -

      使用场景：

      -
        -

      1. 运算

        -
              1. 算数运算符： + - *  / %
-      2. 比较运算符： > < >= <= == !=
-      3. 逻辑运算符： && || !
-      4. 空运算符： empty
-   * 功能：用于判断字符串、集合、数组对象是否为null**或者**长度是否为0
-   * `${empty 变量名}`: 判断字符串、集合、数组对象是否为null或者长度为0
-   * `${not empty 变量名}`: 表示判断字符串、集合、数组对象是否不为null 并且 长度>0
-
        -
        2. -

      2. 获取值

        -
          -

        1. el表达式只能从域对象中获取值

          -

          image-20230307144539506

          -
          2. -

        2. 语法：

          +
          算法思路

          判断区间重叠统一只检查左端点。注意，两次重叠的判断条件不一样，是因为相对性发生了改变。第一次相当于node的左端点在buffer[i]中，第二次相当于buffer[i]的左端点在node中。

            -
          1. ${域名称.键名}：从指定域中获取指定键的值
            2. -
          -
            -
          • 域名称：
              -
            1. pageScope –> pageContext
              2. -
            2. requestScope –> request
              3. -
            3. sessionScope –> session
              4. -
            4. applicationScope –> application（ServletContext）
              5. -
            +

          • 对buffer进行第一轮扫描

            +

            如果node与buffer[i]产生重叠（(left >= it->left && left <= it->right)），那么更新node为node∪buffer[i]，并且将buffer[i]从buffer中删去。

            +

            在第一次找到重叠的区间，就应该break退出第一轮循环。

            • -
          • 举例：在request域中存储了name=张三，获取：${requestScope.name}
            • -
          -
            -
          1. ${键名}：表示依次从最小的域中查找是否有该键对应的值，直到找到为止。
            2. -
          +

        3. 对buffer进行第二轮扫描

          +

          如果node与buffer[i]产生重叠（ (it->left >= left && it->left <= right)），那么更新node为node∪buffer[i]，并且将buffer[i]从buffer中删去。

          4. -

        4. 案例

          -

          这样一来，访问/demo就能转发到index.jsp，显示出属性值

          -
            -

          1. Servlet

            -
            protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
                request.setAttribute("name","xiunian");
                request.getRequestDispatcher("/index.jsp").forward(request,response);
            }
            2. -

          2. index.jsp

            -
            <%@ page pageEncoding="UTF-8" isELIgnored="false" %>
            <html>
            <body>
            <h2>Hello World!</h2>
            ${requestScope.name}
            </body>
            </html>
          -
          5. -

        5. 获取非字符串类型的值

          +

          我们在合并区间时，不仅需要对struct node的左端点left和右端点right进行更新，还需要对其数据域data也进行合并拼接。我们维护变量res作为维护的目标区间的数据域。对于res，我们应该进行如下操作：

            -

          1. 对象

            +

          2. 初始化为data

            3. -

          3. 集合（List、Map等）

            +

          4. 除去[left, left_bound)这一区间内的数据

            +

            这部分数据我们已经整流过并且写入ByteStream

            5. -
          +

        6. 在两轮合并中对其进行正确拼接

          7. -
        -
        3. +
        图解

        image-20230225200605175

        +
        代码
        size_t left = index, right = index + data.length();  // 初始化左右区间
        size_t o_left = left, o_right = right;               // keep the original value
        node tmp = {0, 0, ""};

        if (right < left_bound)	return;                // must be duplicated
        left = left < left_bound ? left_bound : left;  // 左边已经接受过的数据就不要了
        string res = data.substr(left - o_left, right - left);// 掐头

        /* 开始区间合并。需要扫描两次 */
        // 第一次
        for (auto it = buffer.begin(); it != buffer.end(); it++) {
            if (left >= it->left && left <= it->right) { // 区间重叠
                size_t r = right,l = left;
                // 更新左右端点
                right = max(right, it->right);
                left = min(left, it->left);
                if (r <= it->right) // 如果目标区间被包裹在it内
                    // res需要更新为it头+data掐头后的全长+it尾，也即将it中间重叠部分用data替换
                    res = it->data.substr(0, l - it->left) + data.substr(l - o_left) +
                    it->data.substr(r - it->left, it->right - r);
                else 
                    res = it->data.substr(0, l - it->left) + data.substr(l - o_left);
                // 删除原来的结点
                buffer.erase(it);
                break;
            }
        }

        // 第二次
        for (auto it = buffer.begin(); it != buffer.end(); it++) {
            if (it->left >= left && it->left <= right) {
                if (it->right <= right);// it这个区间被包含在目标区间内，则什么也不做
                else {
                    // 需要加上it的尾
                    res += it->data.substr(right - it->left, it->right - right);
                    // 更新右端点
                    right = it->right;
                }
                // 删除
                buffer.erase(it);
            }
        }
        // 将维护区间插入区间集合
        tmp = {left, right, res};
        buffer.insert(tmp);
        + +

        写入ByteStream

        思路

        我们需要检查buffer内的第一个区间，如果其左端点与left_bound相等，则把第一个区间填入ByteStream，然后更新left_bound，从buffer中删去该区间；如果不相等（只可能是left > left_bound）则什么也不做。

        +

        在把区间数据填入ByteStream的过程中，可能造成ByteStream满。因而我们就只能填入第一个区间内的一部分数据，更新left_bound，将第一个区间的剩余数据继续存在buffer中。

        +
        代码
        auto iterator = buffer.begin();  
        iterator = buffer.begin();
        // write into the ByteStream
        if (iterator != buffer.end() && iterator->left == left_bound) {
            // 防止_output的容量超过
            size_t out_rem = _output.remaining_capacity();
            if (out_rem < iterator->data.length()) { // ByteStream剩余容量小于第一个区间长度
                _output.write(iterator->data.substr(0, out_rem));// 写入尽量多数据
                left_bound = iterator->left + out_rem;// 更新左边界
                // 由于iterator只读，因而我们不能直接修改其左端点和data域
                tmp = {left_bound, iterator->right, iterator->data.substr(out_rem)};
                buffer.erase(iterator);
                buffer.insert(tmp);
            } else {
                _output.write(iterator->data);
                left_bound = iterator->right;
                buffer.erase(iterator);
            }
        }
        + +

        buffer的最大容量_capacity

        背景

        维护“存储结构的容量不超过capacity”这个不变性条件可以说是这个实验最恶心最难的地方……也正是它，让我的代码写成了一坨shit山（）

        +

        为什么说它最难最恶心呢？其实它本来也许不算难，但在这个思路下想要保持这个不变性条件，就显得非常地困难。

        +

        一开始没过脑子的时候，我觉得这样就行：

        +
        void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) {
        	if(data.length() + unassemble_bytes() > capacity)	return;
        }
        + +

        但是这样很明显有两个问题。

        +

        一是就算你超过了，你也不能直接丢弃掉data，得把没超过的部分填满。

        +

        二是，data.length() + unassemble_bytes()有时，甚至是很多时候，都不会是将data并入buffer之后buffer的容量。因为data和buffer很大概率会存在重叠区间。

        +

        那么，你能不能在区间合并完之后，再进行该不变性条件的判断，并且将没超过的部分填满，超过的部分丢弃呢？

        +

        答案是，也不能。因为经过两轮合并，你的data和buffer里原有的数据早已你中有我我中有你了，你无法在最后将它们分开，找出data超过capacity的数据并且丢弃它。

        +

        因而，头尾都不行的话，唯一的答案就是，我们只能在两轮区间合并中途，去时刻追踪当前容量是否超过capacity。

        +

        这听起来就令人十分地头大。但事实证明，并不是无法实现的，坚持下去，就算是shit山也能跑起来（）下面便是我的实现思路。

        +
        思路

        维护一个变量remaining，表示当前还有多少容量。维护start，表示未判断是否可以写入buffer的数据起点。我们要做的事：

        +
          +
        1. 初始化remaining为capacity - 当前容量，start为掐头后的left
          2. +
        2. 在第一轮循环中更新start
          3. +
        3. 在第二轮循环中通过start和remaining来判断是否能够写入buffer。尽可能多地写入，把写入不了的部分丢弃。
        +
        例子

        下面举个例子来说明整个流程。

        +
        initial:  
        buffer = { [1,3], [5,8],[10,12],[13,14] } , capacity = 12, remaining = 12-9=3, data = [2,11], start = 2
        + +

        start为2，是因为data的从2开始的这段数据还不知道能不能被成功存入buffer中。

        +

        第一次合并后，buffer = { [5,8],[10,12],[13,14] } ，data=[1,11]，start = 3.

        +

        start为3，是因为[2,11]与[1,3]合并，由于[2,3]这段本来就在buffer中，因而可以不用占用remaining，但从3开始这段数据还不知道能不能成功存入buffer中。

        +

        在第二轮合并中，首先扫描到[5,8]。由于[start,it->left]也即[3,5]这段数据长度为2<remaining=3，故而这段数据可以存入buffer，remaining更新为3-2=1，start更新为it->right=8.

        +

        /*

        +

        注意，此处无需再对[9,10]进行同样的操作。对于这种情况：

        +
        buffer = { [1,3], [5,8] } , capacity = 12, remaining = 12-9=3, data = [2,11], start = 2
        + +

        在循环结束的这里已经处理：

        +
        if (remaining < right - start) {
            right = remaining + start;
            if (eof == 1)
                is_eof = false;
        }
        + +

        */

        +

        然后扫描到[10,12]。由于[start,it->left]也即[8,10]这段数据长度为2>remaining=1，故而这段数据只能把[8,9]这部分存入buffer。因而，我们把到此为止的[1,9]结点存入buffer，剩下的[10,11]部分直接丢弃，也即直接跳入到最后的写入ByteStream部分。

        +
        代码
        void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) {
            size_t remaining = _capacity - unassembled_bytes();  // how much room left?

            size_t left = index, right = index + data.length();  // 初始化左右区间
            size_t o_left = left, o_right = right;               // keep the original value

            size_t start = left;  // the begin of the unused data-zone of variable data
            // if(remaining == 0)	goto end; // buffer满

            // 开始区间合并。需要扫描两次
            for (auto it = buffer.begin(); it != buffer.end(); it++) {
                if (left >= it->left && left <= it->right) {
                    right = max(right, it->right);
                    left = min(left, it->left);
                    // 说明目标区间完全被包裹，也即目标区间一定可以塞进buffer中
                    if (right == it->right) 	start = o_right;
                    // 说明仅仅部分重叠，去重部分从it->right开始
                    else	start = it->right;
        			// ...
                    break;
                }
            }

            // 第二次
            for (auto it = buffer.begin(); it != buffer.end(); it++) {
                if (it->left >= left && it->left <= right) {
                    // 比remaining满
                    // 第一个条件是为了防止unsigned溢出
                    if (it->left > start && remaining < it->left - start) {
                        // 截取能塞得下的部分
                        tmp = {left, start + remaining, res.substr(0, start - left + remaining)};
                        remaining = 0;
                        // 此时塞进去是肯定不重叠的，因为tmp.right < it->left
                        buffer.insert(tmp);
                        // 剩下的直接丢弃
                        goto end;
                    }
                    // 塞得下
                    remaining -= it->left - start;
                    start = it->right;
                    // ...
                }
            }

            // 边界处理
            if (remaining < right - start) {
                // 扔掉塞不下的部分
                right = remaining + start;
            }
            tmp = {left, right, res};
            buffer.insert(tmp);

        end:
            iterator = buffer.begin();
            // write into the ByteStream
            // ...
        }
        + +

        capacity还没结束

        背景

        你以为做到上面那个小标题那样就万无一失了吗？答案是，并不！

        +

        我们还有哪里想得不周全呢？考虑这样一个案例，ByteStream未满，但是在更新remaining时发现buffer已满塞不下了。这时候，我们上面的做法是直接扔掉塞不下的部分。但其实，我们还可以查看buffer的一部分数据是否能够再塞进ByteStream，如果能的话，就又能省下一笔空间了！

        +

        所以，我们在发现remaining不够时，应该首先检查能不能塞一部分buffer的数据进入ByteStream中用来腾出空间。

        +
        代码
        // 第二次
        for (auto it = buffer.begin(); it != buffer.end(); it++) {
            if (it->left >= left && it->left <= right) {
                // 比remaining满
                // 第一个条件是为了防止unsigned溢出
                if (it->left > start && remaining < it->left - start) {
                    // 先看看能不能塞进ByteStream腾空间。需要满足两个条件
                    // buffer的第一个区间正好是left_bound
                    if (left == left_bound) {
                        size_t out_mem = _output.remaining_capacity();
                        // ByteStream有位置
                        if (out_mem > 0) {
                            // 腾出的空间很充足，完全可以不改变remaining
                            if (out_mem >= it->left - start) {
                                // 写入ByteStream
                                _output.write(res.substr(0, it->left - start));
                                // 更新
                                res = res.substr(it->left - start);
                                left_bound = it->left - start + left;
                                left = left_bound;
                                // 加上腾出的空间【在ok标签处减掉】
                                remaining += it->left-start;
                                goto ok;
                            } else {
                                // 空间不足以完全不改变remaining
                                _output.write(res.substr(0, out_mem));
                                res = res.substr(out_mem);
                                left_bound = out_mem + left;
                                left = left_bound;
                                // 加上腾出的空间
                                remaining += out_mem;
                                // 如果两个加起来就行，则ok
                                if(it->left>start && remaining>=it->left - start){
                                        goto ok;
                                }
                                // 否则remaining依然不充足
                            }
                        }
                    }
                    // 截取能塞得下的部分
                    tmp = {left, start + remaining, res.substr(0, start - left + remaining)};
                    remaining = 0;
                    // 此时塞进去是肯定不重叠的，因为tmp.right < it->left
                    buffer.insert(tmp);
                    // 剩下的直接丢弃
                    goto end;
                }
            ok:
                // 塞得下
                remaining -= it->left - start;
                start = it->right;
                // ...
            }
        }
        + +
        小细节

        因而，在一开始发现remaining满的时候，不能直接goto end。

        +
        // if(remaining == 0)	goto end; // buffer满
        + +

        因为还得看看ByteStream能不能腾空间。

        +

        eof

        对于eof的处理也是需要注意的一个小细节。

        +

        我们不能这么写：

        +
        if (eof)
            _output.end_input();
        + +

        原因有二，一是最后一个数据包有可能是部分丢失，二是整流可能还未结束。

        +

        所以我们应该在成员变量中维护is_eof，记录是否收到过最后一个数据包，并且在最后一个数据包部分丢失的时候置它为false。当且仅当is_eof == true且buffer非空时，才能说明输入结束。

        +

        相关代码：

        +
        void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) {
            if (eof == 1)
                is_eof = true;
        	// ...
            // 第二次
            for (auto it = buffer.begin(); it != buffer.end(); it++) {
                if (it->left >= left && it->left <= right) {
                    // 此时空间不够，先尝试下能不能写入一部分到_output中
                    if (it->left > start && remaining < it->left - start) {
                        // ...
                        tmp = {left, start + remaining, res.substr(0, start - left + remaining)};
                        remaining = 0;
                        if (eof == 1)
                            is_eof = false;
                        buffer.insert(tmp);
                        goto end;
                    }
                ok:
                // ...
            }
            
            if (remaining < right - start) {
                right = remaining + start;
                if (eof == 1)
                    is_eof = false;
            }
        	// ...
        end:
        	// ...
            // 满足两个条件才是真的eof
            if (is_eof && buffer.empty()){
                is_eof = false;
                _output.end_input();
            }
        }
        + +

        代码

        头文件声明

        class StreamReassembler {
          private:
            // Your code here -- add private members as necessary.
            struct node {
                size_t left;   // 当前data位于总体的左index（闭）
                size_t right;  // 右index（开）
                string data;
                bool operator<(const node &b) const { return left < b.left; }
            };
            bool is_eof;        // 文件的末尾是否接收成功
            size_t left_bound;  // 当前已经成功接收到left_bound之前的数据
            set<node> buffer;   // 存储结构

            ByteStream _output;  //!< The reassembled in-order byte stream
            size_t _capacity;    //!< The maximum number of bytes
           
          public:
            // ...
            
            // used by the TCPReceiver
            void set_is_eof() { is_eof = false; }
        }
        + +

        具体实现

        #include "stream_reassembler.hh"
        #include <iostream>
        #include <map>

        template <typename... Targs>
        void DUMMY_CODE(Targs &&... /* unused */) {}

        using namespace std;

        StreamReassembler::StreamReassembler(const size_t capacity)
            : is_eof(false), left_bound(0), buffer(), _output(capacity), _capacity(capacity) {}

        void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) {
            if (eof == 1)
                is_eof = true;

            size_t unass = unassembled_bytes();
            size_t remaining = _capacity > unass ? _capacity - unass : 0;  // how much room left?

            size_t left = index, right = index + data.length();  // 初始化左右区间
            size_t o_left = left, o_right = right;               // keep the original value
            auto iterator = buffer.begin();                 // 这些变量在这里声明是为了防止后面goto报错
            node tmp = {0, 0, ""};

            if (right < left_bound)	return;                // must be duplicated
            left = left < left_bound ? left_bound : left;  // 左边已经接受过的数据就不要了
            right = right <= left_bound + _capacity ? right : left_bound + _capacity;  // 右边越界的也不要
            o_right = right;
            string res = data.substr(left - o_left, right - left);

            size_t start = left;  // the begin of the unused data-zone of variable data
            if (data.compare("") == 0 || res.compare("") == 0)	goto end;  // 如果data是空串也直接不要
            if (o_left >= left_bound + _capacity)	goto end;  // 越界的不要

            // 开始区间合并。需要扫描两次
            for (auto it = buffer.begin(); it != buffer.end(); it++) {
                if (left >= it->left && left <= it->right) {
                    size_t r = right;
                    size_t l = left;
                    right = max(right, it->right);
                    left = min(left, it->left);
                    if (right == it->right) {
                        start = o_right;
                    } else {
                        start = it->right;
                    }
                    if (r <= it->right) {
                        res = it->data.substr(0, l - it->left) + data.substr(l - o_left) +
                              it->data.substr(r - it->left, it->right - r);
                    } else {
                        res = it->data.substr(0, l - it->left) + data.substr(l - o_left);
                    }
                    // 删除这一步很关键。
                    buffer.erase(it);
                    break;
                }
            }

            // 第二次
            for (auto it = buffer.begin(); it != buffer.end(); it++) {
                if (it->left >= left && it->left <= right) {
                    // 此时空间不够，先尝试下能不能写入一部分到_output中
                    if (it->left > start && remaining < it->left - start) {
                        if (left == left_bound) {
                            size_t out_mem = _output.remaining_capacity();
                            if (out_mem > 0) {
                                // out的区域本身就很充足
                                if (out_mem >= it->left - start) {
                                    // 写入ByteStream
                                    _output.write(res.substr(0, it->left - start));
                                    // 更新
                                    res = res.substr(it->left - start);
                                    left_bound = it->left - start + left;
                                    left = left_bound;
                                    remaining += it->left - start;
                                    // out剩下的空位会在最后写入
                                    goto ok;
                                } else {
                                    // 光是out不够的话，那就先能腾多少空间腾多少
                                    _output.write(res.substr(0, out_mem));
                                    res = res.substr(out_mem);
                                    left_bound = out_mem + left;
                                    left = left_bound;
                                    remaining += out_mem;
                                    // 如果腾出空间加上原来空间足够，那就非常ok
                                    if (it->left > start && remaining >= it->left - start) {
                                        goto ok;
                                    }
                                    // 否则进入错误处理代码
                                }
                            }
                        }
                        tmp = {left, start + remaining, res.substr(0, start - left + remaining)};
                        remaining = 0;
                        if (eof == 1)
                            is_eof = false;
                        buffer.insert(tmp);
                        goto end;
                    }
                ok:
                    remaining -= it->left - start;
                    start = it->right;
                    if (it->right > right){
                        res += it->data.substr(right - it->left, it->right - right);
                        right = it->right;
                    }
                    buffer.erase(it);
                }
            }
            
            if (start < o_right && remaining < o_right - start) {
                right = start + remaining;
                if (eof == 1)
                    is_eof = false;
            }
            tmp = {left, right, res};
            if (left < right)
            	buffer.insert(tmp);

        end:
            iterator = buffer.begin();
            // write into the ByteStream
            if (iterator != buffer.end() && iterator->left == left_bound) {
                size_t out_rem = _output.remaining_capacity();
                if (out_rem < iterator->data.length()) {
                    _output.write(iterator->data.substr(0, out_rem));
                    left_bound = iterator->left + out_rem;
                    tmp = {left_bound, iterator->right, iterator->data.substr(out_rem)};
                    buffer.erase(iterator);
                    buffer.insert(tmp);
                } else {
                    _output.write(iterator->data);
                    left_bound = iterator->right;
                    buffer.erase(iterator);
                }
            }

            // 满足两个条件才是真的eof
            if (is_eof && buffer.empty()){
                is_eof = false;
                _output.end_input();
            }
        }

        size_t StreamReassembler::unassembled_bytes() const {
            // 可以跟上面的write合起来的，但在此处我采取了最保守的做法。
            size_t res = 0;
            for (auto it = buffer.begin(); it != buffer.end(); it++) {
                res += it->right - it->left;
            }
            return res;
        }

        bool StreamReassembler::empty() const { return buffer.empty()&&is_eof; }
        + ]]> - - Java - - Lab0 - /2023/02/25/cs144$lab0/ - Lab0
        -

        本次实验一直在强调的一点就是，TCP的功能是将底层的零散数据包，拼接成一个reliable in-order的byte stream。这个对我来说非常“振聋发聩”（夸张了233），以前只是背诵地知道TCP的可靠性，这次我算是第一次知道了所谓“可靠”究竟可靠在哪：一是保证了序列有序性，二是保证了数据不丢失（从软件层面）。

        -

        还有一个就是大致了解了cs144的主题：实现TCP协议。也就是说，运输层下面的那些层是不用管的吗？不过这样也挺恰好，我正好在学校的实验做过对下面这些层的实现了，就差一个TCP23333这样一来，我的协议栈就可以完整了。

        -
        -
        -

        本次实验与TCP的关系：

        -

        在我们的webget实现中，正是由于TCP的可靠传输，才能使我们的http request正确地被服务器接收，才能使服务器的response正确地被我们接收打印。

        -

        而在ByteStream中，我们也做了跟TCP类似的工作：接收substring，并且将它们拼接为in-order的byte stream【由于在内存中/单线程，所以这个工作看起来非常简单】：

        -
        while(is_input_end == false&&pointer<length){
            if(buffer.size() == capacity)   break;
            buffer.push_back(data[pointer]);
            pointer++;
        }
        + 其他的对实验未涉及的思考 + /2023/02/25/cs144$else/ + 其他的对实验未涉及的思考

        网络层实现

        在我们的协议栈实现中，我们负责了运输层的TCP协议、网络层的ARP协议以及数据链路层的ETH协议的编写，剩下的网络层的IP协议则由官方给定。接下来我们就来探究下网络层的实现。

        +

        总体架构

        +

        You’ve done this already.

        +

        In Lab 4, we gave:

        +
          +
        1. an object that represents an Internet datagram and knows how to parse and serialize itself (tcp_helpers/ipv4_datagram.{hh,cc}) 表示了Internet datagram的数据结构，它可以自己序列化。
          2. +
        2. the logic to encapsulate(封装) TCP segments in IP (now found in tcp_helpers/tcp_over_ip.cc).
          3. +
        +

        The CS144TCPSocket uses these tools to connect your TCPConnection to a TUN device.

        -

        Fetch a Web page

        主要是介绍了telnet指令

        -

        屏幕截图 2023-02-23 194758

        -

        Send yourself an email

        用的是telnet带smtp参

        -

        Listening and connecting

        上面的telnet是一个client program。接下来我们要把自己放在server的位置上。

        -

        用的是netcat指令。

        -

        image-20230223202202509

        -

        Use socket to write webget

        这个确实不难，就是这个地方有点坑：

        +

        也即，IP协议主要由两个文件实现，一个是IP数据报抽象为的类ipv4_datagram.{hh,cc}，另一个是将TCP报文封装为IP报文的类tcp_helpers/tcp_over_ip.cc；除此之外，IP协议还负责与下次协议连接，在实验0-4中它通过CS144TCPSocket与TUN连接，在实验5-6则与TAN连接。

        +

        连接部分暂且先放到下一部分讲，下面来看看IP协议的具体实现。

        +

        具体实现

        ipv4_datagram.hh && ipv4_header.hh

        ipv4_datagram没什么好说的，跟TCPSegment的结构一模一样。ipv4_header也没什么好说的，就纯纯是IP数据报的报头、

        +

        tcp_over_ip

        头文件

        它的头文件很简单，只包含一个类的定义：

        +
        // A converter from TCP segments to serialized IPv4 datagrams
        class TCPOverIPv4Adapter : public FdAdapterBase {
          public:
            std::optional<TCPSegment> unwrap_tcp_in_ip(const InternetDatagram &ip_dgram);

            InternetDatagram wrap_tcp_in_ip(TCPSegment &seg);
        };
        #endif  // SPONGE_LIBSPONGE_TCP_OVER_IP_HH
        + +
        具体实现

        可以看到，相比于TCP和ETH/ARP协议，IP协议的实现可以说是非常简单。它作为一个中间层，只需要把上面给的东西包装下再传到下面，或者把下面给的东西解包下再传给上面，无需其他复杂的算法和数据结构（比如TCP的reliable transmission和ETH/ARP的地址自学习），也无需跟外界打交道。

        +

        除了打包解包外，它只需确保一件事，那就是一台主机只能同时拥有一个TCP连接。这样一来也能简化其实现：填写IP协议头时，它就只需从自己保存的config中取参数就行。

        +
        // 用来拆IP数据包为一个TCP数据包
        //! If this succeeds, it then checks that the received segment is related to the
        //! current connection. When a TCP connection has been established, this means
        //  如果TCP连接已建立，则会检查src和dst端口号的正确性
        //! checking that the source and destination ports in the TCP header are correct.
        //!
        //! If the TCP connection is listening 如果处于listening状态，并且参数为SYN报文
        //! and the TCP segment read from the wire includes a SYN, this function clears the
        //  就需要解除listening的flag，记录下src和dst的地址和端口号
        //! `_listen` flag and records the source and destination addresses and port numbers
        //  目的是为了 filter future reads
        //  这说明我们的sponge实现是单线程的，也就是一台主机只能同时建立一个TCP连接
        //  并且在此时会忽略其他主机发过来的数据包
        //! from the TCP header; it uses this information to filter future reads.

        //  returns a std::optional<TCPSegment> that is empty if the segment was invalid or unrelated
        optional<TCPSegment> TCPOverIPv4Adapter::unwrap_tcp_in_ip(const InternetDatagram &ip_dgram) {
            // is the IPv4 datagram for us?
            // Note: it's valid to bind to address "0" (INADDR_ANY) and reply from actual address contacted
            if (not listening() and (ip_dgram.header().dst != config().source.ipv4_numeric())) {
                return {};
            }

            // is the IPv4 datagram from our peer?
            // 过滤非peer发来的其他数据包
            if (not listening() and (ip_dgram.header().src != config().destination.ipv4_numeric())) {
                return {};
            }

            // does the IPv4 datagram claim that its payload is a TCP segment?
            // 我们只需解包TCP数据报
            if (ip_dgram.header().proto != IPv4Header::PROTO_TCP) {
                return {};
            }

            // is the payload a valid TCP segment?
            TCPSegment tcp_seg;
            if (ParseResult::NoError != tcp_seg.parse(ip_dgram.payload(), ip_dgram.header().pseudo_cksum())) {
                return {};
            }

            // is the TCP segment for us?
            if (tcp_seg.header().dport != config().source.port()) {
                return {};
            }

            // should we target this source addr/port (and use its destination addr as our source) in reply?
            if (listening()) {
                // records the source and destination addresses and port numbers
                if (tcp_seg.header().syn and not tcp_seg.header().rst) {
                    config_mutable().source = {inet_ntoa({htobe32(ip_dgram.header().dst)}), config().source.port()};
                    config_mutable().destination = {inet_ntoa({htobe32(ip_dgram.header().src)}), tcp_seg.header().sport};
                    set_listening(false);
                } else {
                    return {};
                }
            }

            // is the TCP segment from our peer?
            if (tcp_seg.header().sport != config().destination.port()) {
                return {};
            }

            return tcp_seg;
        }

        //! Takes a TCP segment, sets port numbers as necessary, and wraps it in an IPv4 datagram
        //! \param[in] seg is the TCP segment to convert
        InternetDatagram TCPOverIPv4Adapter::wrap_tcp_in_ip(TCPSegment &seg) {
            // set the port numbers in the TCP segment
            seg.header().sport = config().source.port();
            seg.header().dport = config().destination.port();

            // create an Internet Datagram and set its addresses and length
            InternetDatagram ip_dgram;
            ip_dgram.header().src = config().source.ipv4_numeric();
            ip_dgram.header().dst = config().destination.ipv4_numeric();
            // uint8_t hlen = LENGTH / 4;  //!< header length
            // uint8_t doff = LENGTH / 4;  //!< data offset
            ip_dgram.header().len = ip_dgram.header().hlen * 4 + seg.header().doff * 4 + seg.payload().size();

            // set payload, calculating TCP checksum using information from IP header
            ip_dgram.payload() = seg.serialize(ip_dgram.header().pseudo_cksum());

            return ip_dgram;
        }
        + +

        Socket实现

        最top的话可以分为CS144TCPSocket和FullStackSocket。

        +

        继承关系如下图：

        +

        Inheritance graph

        +

        其中，TCPSocket是完完全全的包装类，它的所有协议栈都是在内核态中实现（也就是跟我们之后写的没半毛钱关系），它的存在意义应该是用在lab0来写webget的测试。而CS144TCPSocket就是我们在lab0-4用的了，它的数据链路层由内核实现，网络层和运输层由用户实现。FullStackSocket就是加上了我们在lab5做的用户态数据链路层。

        +

        最主要的部分是TCPSpongeSocket的实现，其他就是一些包装类没什么好说的。

        +

        FileDescriptor

        将socket看作是fd，将网络看作是IO，这一抽象简直是太伟大了，牛逼到爆。

        +

        头文件

        //! A reference-counted handle to a file descriptor
        class FileDescriptor {
            //! \brief A handle on a kernel file descriptor.
            //! \details FileDescriptor objects contain a std::shared_ptr to a FDWrapper.
            class FDWrapper {
              public:
                int _fd;                    // file descriptor number returned by the kernel
                bool _eof = false;          // fd是否eof
                bool _closed = false;       // fd是否close
                // fd被读写的次数
                unsigned _read_count = 0;   
                unsigned _write_count = 0; 

                //! Construct from a file descriptor number returned by the kernel
                explicit FDWrapper(const int fd);
                //! Closes the file descriptor upon destruction
                ~FDWrapper();
                //! Calls [close(2)](\ref man2::close) on FDWrapper::_fd
                void close();
                //! An FDWrapper cannot be copied or moved
                FDWrapper(const FDWrapper &other) = delete;
                FDWrapper &operator=(const FDWrapper &other) = delete;
                FDWrapper(FDWrapper &&other) = delete;
                FDWrapper &operator=(FDWrapper &&other) = delete;
            };

            //! A reference-counted handle to a shared FDWrapper
            std::shared_ptr<FDWrapper> _internal_fd;

            // private constructor used to duplicate the FileDescriptor (increase the reference count)  这个构造函数会增加其参数传进来的那个fd的引用，也许相当于dump
            explicit FileDescriptor(std::shared_ptr<FDWrapper> other_shared_ptr);

          protected:
            void register_read() { ++_internal_fd->_read_count; }    //!< increment read count
            void register_write() { ++_internal_fd->_write_count; }  //!< increment write count

          public:
            //! Construct from a file descriptor number returned by the kernel
            explicit FileDescriptor(const int fd);

            //! Free the std::shared_ptr; the FDWrapper destructor calls close() when the refcount goes to zero.
            ~FileDescriptor() = default;

            /*  读写  */
            std::string read(const size_t limit = std::numeric_limits<size_t>::max());
            void read(std::string &str, const size_t limit = std::numeric_limits<size_t>::max());
            // possibly blocking until all is written
            size_t write(const char *str, const bool write_all = true) { return write(BufferViewList(str), write_all); }
            size_t write(const std::string &str, const bool write_all = true) { return write(BufferViewList(str), write_all); }
            size_t write(BufferViewList buffer, const bool write_all = true);

            //! Close the underlying file descriptor
            void close() { _internal_fd->close(); }

            //! Copy a FileDescriptor explicitly, increasing the FDWrapper refcount
            FileDescriptor duplicate() const;

            //! Set blocking(true) or non-blocking(false)
            void set_blocking(const bool blocking_state);
            // ...
        + +

        具体实现

        差不多就是全程调用系统调用没什么好说的，记录下几个有意思的点

        +
        包装系统调用

        可以看下其调用系统调用的方式，看起来很有意思：

        +
        void FileDescriptor::set_blocking(const bool blocking_state) {
            int flags = SystemCall("fcntl", fcntl(fd_num(), F_GETFL));
            if (blocking_state) {
                flags ^= (flags & O_NONBLOCK);
            } else {
                flags |= O_NONBLOCK;
            }

            SystemCall("fcntl", fcntl(fd_num(), F_SETFL, flags));
        }
        + +

        比如说这里设置文件读写是否阻塞就是通过系统调用实现的。

        +

        在写os实验时，你应该就能很深刻感受到，很多时候调用完一个系统调用后，对它的返回结果进行合法性判断以及错误处理还是有点烦的（举例来说，如if(kalloc() == 0)或者if(mappages() == 0)，出错后杀死进程等等等）。在那会我们还可以直接就这么冗余地干了，但是这里不行，一是我们要用面向对象的思想，二是我们的重点事实上并不是操作系统而是网络，因而最好还是这么封装下以减少冗余代码。

        +

        而它除了会调用系统调用外，还使用了一个包装性的方法SystemCall来保障调用的安全性和合理性。看看SystemCall的具体实现方式，确实就是包了层安全检查。

        +
        int SystemCall(const char *attempt, const int return_value, const int errno_mask) {
            if (return_value >= 0 || errno == errno_mask) {
                return return_value;
            }

            throw unix_error(attempt);
        }

        // os内核看不懂c++，所以要注意转换为c-style的字符串
        int SystemCall(const string &attempt, const int return_value, const int errno_mask) {
            return SystemCall(attempt.c_str(), return_value, errno_mask);
        }
        + +

        Socket

        没什么好说的，只是操作系统socket接口的包装类。

        +

        头文件

        // Base class for network sockets (TCP, UDP, etc.)
        // Socket is generally used via a subclass. See TCPSocket and UDPSocket for usage examples.
        class Socket : public FileDescriptor {
          private:
            //! Get the local or peer address the socket is connected to
            Address get_address(const std::string &name_of_function,
                                const std::function<int(int, sockaddr *, socklen_t *)> &function) const;

          protected:
            Socket(const int domain, const int type);
            Socket(FileDescriptor &&fd, const int domain, const int type);
            
            template <typename option_type>
            void setsockopt(const int level, const int option, const option_type &option_value);
          public:
            // Bind a socket to a local address, usually for listen/accept
            void bind(const Address &address);
            // Connect a socket to a peer address
            void connect(const Address &address);
            // Shut down a socket
            void shutdown(const int how);
            //! Get local address of socket
            Address local_address() const;
            //! Get peer address of socket
            Address peer_address() const;
            //! Allow local address to be reused sooner
            void set_reuseaddr();
        };

        //! A wrapper around [UDP sockets](\ref man7::udp)
        class UDPSocket : public Socket {
          protected:
            //! \brief Construct from FileDescriptor (used by TCPOverUDPSocketAdapter)
            //! \param[in] fd is the FileDescriptor from which to construct
            explicit UDPSocket(FileDescriptor &&fd) : Socket(std::move(fd), AF_INET, SOCK_DGRAM) {}

          public:
            //! Default: construct an unbound, unconnected UDP socket
            UDPSocket() : Socket(AF_INET, SOCK_DGRAM) {}

            // carries received data and information about the sender
            struct received_datagram {
                Address source_address;  //!< Address from which this datagram was received
                std::string payload;     //!< UDP datagram payload
            };
            //! Receive a datagram and the Address of its sender
            received_datagram recv(const size_t mtu = 65536);
            //! Receive a datagram and the Address of its sender (caller can allocate storage)
            void recv(received_datagram &datagram, const size_t mtu = 65536);

            //! Send a datagram to specified Address
            void sendto(const Address &destination, const BufferViewList &payload);
            //! Send datagram to the socket's connected address (must call connect() first)
            void send(const BufferViewList &payload);
        };

        //! A wrapper around [TCP sockets](\ref man7::tcp)
        class TCPSocket : public Socket {
          private:
            // Construct from FileDescriptor (used by accept())
            // fd is the FileDescriptor from which to construct
            explicit TCPSocket(FileDescriptor &&fd) : Socket(std::move(fd), AF_INET, SOCK_STREAM) {}
          public:
            //! Default: construct an unbound, unconnected TCP socket
            TCPSocket() : Socket(AF_INET, SOCK_STREAM) {}
            //! Mark a socket as listening for incoming connections
            void listen(const int backlog = 16);
            //! Accept a new incoming connection
            TCPSocket accept();
        };

        //! A wrapper around [Unix-domain stream sockets](\ref man7::unix)
        class LocalStreamSocket : public Socket {
          public:
            // ...构造器
        };
        #endif  // SPONGE_LIBSPONGE_SOCKET_HH
        + +

        具体实现

        构造器的参数

        参考文章

        +

        也是系统调用socket的参数，了解一下知识多多益善。

        +
          +

        1. domain

          +

          在本次实验中只会取值前两个，即本地通信和IPv4网络通信

          +

          image-20230309232045195

          +
          2. +

        2. type

          +

          好像比如说取SOCK_DGRAM就是UDP，取SOCK_STREAM就是TCP。

          +
          3. +
        +
        代码
        /* Socket */
        /* 构造器 */
        // default constructor for socket of (subclassed) domain and type
        Socket::Socket(const int domain, const int type) : FileDescriptor(SystemCall("socket", socket(domain, type, 0))) {}
        // construct from file descriptor
        Socket::Socket(FileDescriptor &&fd, const int domain, const int type) : FileDescriptor(move(fd)) { ... }

        // get the local or peer address the socket is connected to
        // 此为private函数，应该是用于方便下面那两个函数的，虽然我觉得这个设计意图没什么必要（）
        Address Socket::get_address(const string &name_of_function,const function<int(int, sockaddr *, socklen_t *)> &function) const {
            Address::Raw address;
            socklen_t size = sizeof(address);
        	SystemCall(name_of_function, function(fd_num(), address, &size));
            return {address, size};
        }
        Address Socket::local_address() const { return get_address("getsockname", getsockname); }
        Address Socket::peer_address() const { return get_address("getpeername", getpeername); }

        /* 
        这两个函数是用于把socket连到CS的
        将socket的一端连上本机，就需要调用bind；连上别的什么东西就要用connect
        */
        // bind socket to a specified local address (usually to listen/accept)
        // address is a local Address to bind
        void Socket::bind(const Address &address) { SystemCall("bind", ::bind(fd_num(), address, address.size())); }
        // connect socket to a specified peer address
        // address is the peer's Address
        void Socket::connect(const Address &address) { SystemCall("connect", ::connect(fd_num(), address, address.size())); }

        // shut down a socket in the specified way
        // how can be `SHUT_RD`, `SHUT_WR`, or `SHUT_RDWR`
        void Socket::shutdown(const int how) {
            SystemCall("shutdown", ::shutdown(fd_num(), how));
            switch (how) {
                case SHUT_RD:
                    register_read();
                    break;
                // ...
            }
        }

        // set socket option，传入协议层以及要设置非选项的键和值
        template <typename option_type>
        void Socket::setsockopt(const int level, const int option, const option_type &option_value) {
            SystemCall("setsockopt", ::setsockopt(fd_num(), level, option, &option_value, sizeof(option_value)));
        }

        // allow local address to be reused sooner, at the cost of some robustness
        // 以鲁棒性为代价，让local address可复用
        // Using `SO_REUSEADDR` may reduce the robustness of your application
        void Socket::set_reuseaddr() { setsockopt(SOL_SOCKET, SO_REUSEADDR, int(true)); }

        /* UDPSocket */
        // 从socket中接收数据并放进datagram中
        // If mtu is too small to hold the received datagram, this method throws a runtime_error
        void UDPSocket::recv(received_datagram &datagram, const size_t mtu) {
            // receive source address and payload
            // ...
            const ssize_t recv_len = SystemCall(
                "recvfrom",
                ::recvfrom(
                    fd_num(), datagram.payload.data(), datagram.payload.size(), MSG_TRUNC, datagram_source_address, &fromlen));
        	// ...
        }
        UDPSocket::received_datagram UDPSocket::recv(const size_t mtu) {
            received_datagram ret{{nullptr, 0}, ""};
            recv(ret, mtu);
            return ret;
        }

        // 向socket发送数据
        void sendmsg_helper(const int fd_num,
                            const sockaddr *destination_address,
                            const socklen_t destination_address_len,
                            const BufferViewList &payload) {
            // ...
            const ssize_t bytes_sent = SystemCall("sendmsg", ::sendmsg(fd_num, &message, 0));
        	// ...
        }
        void UDPSocket::sendto(const Address &destination, const BufferViewList &payload) {
            sendmsg_helper(fd_num(), destination, destination.size(), payload);
            register_write();
        }
        void UDPSocket::send(const BufferViewList &payload) {
            sendmsg_helper(fd_num(), nullptr, 0, payload);
            register_write();
        }
        // ...
        + +

        * TCPSpongeSocket

        上面那俩类其实就是两个包装类，用来将系统调用包装为c++类，看起来很抽象很迷惑。但到这就不一样了！我们开始用上我们之前写的TCP协议的代码了！

        +

        除了跟fd以及socket一致的read、write以及close之外，TCPSocket最独特的功能，应该就是TCP连接的建立与释放了，其状态转移等逻辑已由我们在Lab0-4实现，此socket类仅实现事件的监听和TCP协议对象生命周期的管理。

        +

        双线程

        在详细说明其两个功能——事件监听和生命周期管理——之前，不妨先了解下其总体的架构。

        +

        TCPSpongeSocket需要双线程实现。其中一个线程用来招待其owner：它会执行向owner public的connect、read、write等服务。另一个线程用来运行TCPConnection：它会时刻调用connection的tick方法，并且进行事件监听。

        +
        //! \class TCPSpongeSocket
        //! This class involves the simultaneous operation of two threads.
        //!
        //! One, the "owner" or foreground thread, interacts with this class in much the
        //! same way as one would interact with a TCPSocket: it connects or listens, writes to
        //! and reads from a reliable data stream, etc. Only the owner thread calls public
        //! methods of this class.
        //!
        //! The other, the "TCPConnection" thread, takes care of the back-end tasks that the kernel would
        //! perform for a TCPSocket: reading and parsing datagrams from the wire, filtering out
        //! segments unrelated to the connection, etc.
        + +

        事件监听

        完成事件监听的核心部分是方法_tcp_loop以及_initialize_TCP中对_eventloop的初始化，还有eventloop的实现。

        +

        看下来其实理解难度不大（虽然细节很多并且我懒得研究了），但我认为很值得学习。

        +
        _initialize_TCP

        主要功能是添加我们想监听的事件，有四个，分别是从app得到数据、有要向app发送的数据、从底层协议得到数据、有要向底层协议发送的数据。具体的话，代码和注释都写得很详细就不说了。

        +

        可以看到，TCP与协议栈交互【包括收发数据报】，是通过AdaptT _datagram_adapter;实现的；TCP与上层APP交互【包括传送数据】，是通过LocalStreamSocket _thread_data;实现的。

        +
        template <typename AdaptT>
        void TCPSpongeSocket<AdaptT>::_initialize_TCP(const TCPConfig &config) {
            _tcp.emplace(config);
            // Set up the event loop

            // There are four possible events to handle:需要监听以下四种事件
            //
            // 1) Incoming datagram received (needs to be given to
            //    TCPConnection::segment_received method)得到底层协议栈送过来的data
            //
            // 2) Outbound bytes received from local application via a write()
            //    call (needs to be read from the local stream socket and
            //    given to TCPConnection::data_written method)得到上层app送过来的data
            //
            // 3) Incoming bytes reassembled by the TCPConnection
            //    (needs to be read from the inbound_stream and written
            //    to the local stream socket back to the application)TCP协议需要向app写入data
            //
            // 4) Outbound segment generated by TCP (needs to be
            //    given to underlying datagram socket)TCP需要向外界发送data

            // rule 1: read from filtered packet stream and dump into TCPConnection得到外界data
            _eventloop.add_rule(_datagram_adapter,
                                Direction::In,
                                [&] {
                                    auto seg = _datagram_adapter.read();
                                    if (seg) {
                                        _tcp->segment_received(move(seg.value()));
                                    }
                                    if (_thread_data.eof() and _tcp.value().bytes_in_flight() == 0 and not _fully_acked) { _fully_acked = true; }
                                },
                                [&] { return _tcp->active(); });

            // rule 2: read from pipe into outbound buffer得到app data
            _eventloop.add_rule(
                // LocalStreamSocket _thread_data;
        		// 看来用户是通过socket写入的数据
                _thread_data,
                Direction::In,
                [&] {
                    const auto data = _thread_data.read(_tcp->remaining_outbound_capacity());
                    const auto len = data.size();
                    const auto amount_written = _tcp->write(move(data));
                    if (amount_written != len) {
                        throw runtime_error("TCPConnection::write() accepted less than advertised length");
                    }
                    if (_thread_data.eof()) {
                        _tcp->end_input_stream();
                        _outbound_shutdown = true;
                    }
                },
                [&] { return (_tcp->active()) and (not _outbound_shutdown) and (_tcp->remaining_outbound_capacity() > 0); },
                [&] {
                    _tcp->end_input_stream();
                    _outbound_shutdown = true;
                });

            // rule 3: read from inbound buffer into pipe向app写入data
            _eventloop.add_rule(
                _thread_data,
                Direction::Out,
                [&] {
                    ByteStream &inbound = _tcp->inbound_stream();
                    // Write from the inbound_stream into the pipe
                    const size_t amount_to_write = min(size_t(65536), inbound.buffer_size());
                    const std::string buffer = inbound.peek_output(amount_to_write);
                    // 通过向socket写实现
                    const auto bytes_written = _thread_data.write(move(buffer), false);
                    inbound.pop_output(bytes_written);

                    if (inbound.eof() or inbound.error()) {
                        _thread_data.shutdown(SHUT_WR);
                        _inbound_shutdown = true;
                    }
                },
                [&] {
                    return (not _tcp->inbound_stream().buffer_empty()) or
                           ((_tcp->inbound_stream().eof() or _tcp->inbound_stream().error()) and not _inbound_shutdown);
                });

            // rule 4: read outbound segments from TCPConnection and send as datagrams向外界写data
            _eventloop.add_rule(_datagram_adapter,
                                Direction::Out,
                                [&] {
                                    while (not _tcp->segments_out().empty()) {
                                        // 通过对adapter写实现
                                        _datagram_adapter.write(_tcp->segments_out().front());
                                        _tcp->segments_out().pop();
                                    }
                                },
                                [&] { return not _tcp->segments_out().empty(); });
        }
        + +
        _tcp_loop

        可以看到，_tcp_loop的功能就是，在condition为真的时候，一是监听我们之前塞进_event_loop的所有事件，二是调用TCPConnection的tick方法来管理时间。

        +
        // condition is a function returning true if loop should continue
        // Process events while specified condition is true
        // 周期性调用事件condition以达到监听等待事件的效果，管理TCP的tick
        template <typename AdaptT>
        void TCPSpongeSocket<AdaptT>::_tcp_loop(const function<bool()> &condition) {
            auto base_time = timestamp_ms();
            // 当条件一直为真时，监听event
            while (condition()) {
                // 持续监听eventloop中的各种event
                auto ret = _eventloop.wait_next_event(TCP_TICK_MS);
                // 条件为退出/丢弃
                if (ret == EventLoop::Result::Exit or _abort) {
                    break;
                }
                // 如果tcp还存活，则调用其tick方法
                if (_tcp.value().active()) {
                    const auto next_time = timestamp_ms();
                    _tcp.value().tick(next_time - base_time);
                    _datagram_adapter.tick(next_time - base_time);
                    base_time = next_time;
                }
            }
        }
        + +
        eventloop

        eventloop具体是通过Linux提供的poll机制来进行事件监听的。

        -

        Please note that in HTTP, each line must be ended with “\r\n” (it’s not sufficient to use just “\n” or endl).

        +

        Linux poll机制

        +

        怎么说，又一次感受到了“网络就是IO”这个抽象的牛逼之处。操作系统的poll机制和poll函数本质上是针对IO读写来设计的，而正因为网络的本质是IO，正因为网络收发数据包、与上层app交互本质还是IO（因为通过文件描述符），才能在这里采用这种方式进行文件读写。

        +

        我的评价是佩服到五体投地好吧

        +

        image-20230310185319115

        +

        poll函数就是IO等待的一种实现机制。

        +
        int poll(struct pollfd *fds, nfds_t nfds, int timeout);
        + +

        事件类型events可以为下列值：

        +
        POLLIN:有数据可读
        POLLRDNORM:有普通数据可读，等效于POLLIN
        POLLRDBAND:有优先数据可读
        POLLPRI:有紧迫数据可读
        POLLOUT:写数据不会导致阻塞
        POLLWRNORM:写普通数据不会导致阻塞
        POLLWRBAND:写优先数据不会导致阻塞
        POLLMSG:SIGPOLL消息可用
        POLLER:指定的文件描述符发生错误
        POLLHUP:指定的文件描述符挂起事件
        POLLNVAL:无效的请求，打不开指定的文件描述符
        -

        导致我跟400 Bad Request大眼瞪小眼了好久。。。

        -
        void get_URL(const string &host, const string &path) {
        	TCPSocket sock;
            string tmp;
        //    sock.set_blocking(true);// 默认情况下即为true
            sock.connect(Address(host,"http"));
            sock.write("GET " + path + " HTTP/1.1\r\nHost: " + 
                       host + "\r\nConnection: close\r\n\r\n");
            
            while((tmp = sock.read(1)) != ""){
                cout << tmp;
            }
        	/*
        	上面那个写法不大规范，更规范的写法：
            while(!sock.eof()){
                cout << sock.read(1);
            }
        	*/
            sock.close();
        }
        +

        我们在前面的eventloop的rule初始化中：

        +
        _eventloop.add_rule(_datagram_adapter,
                                Direction::In,
                                [&] { ... });
        -

        还有一点值得注意的是，当我这样时：

        -
        TCPSocket sock;
           sock.set_blocking(false);
           sock.connect(Address(host,"http"));
        +

        这个的意思是针对_datagram_adapter这个文件的Direction::In这个事件发生时，就会执行[&]中的事件。那么Direction::In是什么？

        +
        enum class Direction : short {
            In = POLLIN,   //!< Callback will be triggered when Rule::fd is readable.
            Out = POLLOUT  //!< Callback will be triggered when Rule::fd is writable.
        };
        -

        会报错Operation now in progress。

        -
        -

        关于socket通信中在connect()遇到的Operation now in progress错误

        -

        遇到此错误是因为将在connect()函数之前将套接字socket设为了非阻塞模式。改为在connect()函数之后设置即可。

        -
        -

        我觉得这个实验设计得挺好的，写的时候感觉很有意思。我推荐看下 https://github.com/shootfirst/CS144/blob/main/lab-0/apps/webget.cc 里的注释，写得很好很规范，让我明白了很多本来没搞懂的地方，比如说shutdown的用法。

        -

        An in-memory reliable byte stream

        -

        实现一个ByteStream类，可以通过read和write对其两端进行读写。是单线程程序，因而无需考虑阻塞。

        -
        -

        感想

        这东西其实是很简单的，但是我还是花了一定的时间，主要原因有两点，一是我不懂c++，所以一些地方错得我很懵逼，二是因为我是sb。

        -

        下面就记录下三个我印象比较深刻的错误吧。

        -
        错误1 member initialization list

        构造函数我一开始是这么写的：

        -

        image-20230224113108208

        -

        结果爆出了这样的错：

        -

        image-20230224112056879

        -

        搜了半天也没看懂怎么回事，去求助了下某场外c艹选手，才知道了还有成员变量初始化列表这玩意，这个东西似乎比较高效安全。

        -

        于是我改成了这么写：

        -

        image-20230224113333962

        -

        它告诉我buffer也得初始化。于是我又这么写：

        -

        image-20230224113358856

        -

        又是奇奇怪怪的错误，说明vector不能这么初始化。

        -

        场外c艹选手看到了这个：

        -

        image-20230224113456432

        -

        所以说vector应该这样初始化：

        -

        image-20230224113549970

        -
        错误2 使用了vector作为buffer的载体

        应该使用的是可以从front删除数据的数据结构，比如说deque。【vector也行，但是效率较低】

        -

        具体为什么，可以以数据流为cat为例。执行peek(2)时，使用vector得到的是at，使用deque得到的是ca。

        -
        错误3 错误地阻塞

        一开始在write方法，我是这么写的：

        -
        int length = data.length();
        while(is_input_end == false&&pointer<length){
            while(buffer.size() == capacity);
            buffer.push_back(data[pointer]);
            pointer++;
            total_write ++;
        }
        +

        可见，eventloop具体是通过os提供的IO事件机制来进行监听的。

        +

        具体的监听以及执行逻辑由wait_next_event来实现。它主要干的就是，清理掉那些我们不感兴趣的或者已经似了（比如说对应的fd已经close之类的）的事件，然后找到那些触发到了的active的事件并且调用它们的caller。

        +

        具体代码还是有些微复杂的，有兴趣可以去看看，这里就不放了。

        +

        生命周期的管理

        核心部分为方法connect、listen_and_accept以及_tcp_main。

        +
        connect

        由客户端调用。

        +
        // Client调用
        // 未收到外界连接时，owner进程会阻塞
        template <typename AdaptT>
        void TCPSpongeSocket<AdaptT>::connect(const TCPConfig &c_tcp, const FdAdapterConfig &c_ad) {
            // 初始化tcp的事件监听
            _initialize_TCP(c_tcp);
            // 初始化adapater
            _datagram_adapter.config_mut() = c_ad;

            cerr << "DEBUG: Connecting to " << c_ad.destination.to_string() << "...\n";
            // 我们实现的：发送SYN报文
            _tcp->connect();

            // 统一的状态管理
            const TCPState expected_state = TCPState::State::SYN_SENT;
            // 等待直到条件为假，也即脱离SYN-SENT转移到ESTABLISHED
            _tcp_loop([&] { return _tcp->state() == TCPState::State::SYN_SENT; });
            cerr << "Successfully connected to " << c_ad.destination.to_string() << ".\n";

            // 建立连接后开启connection进程, 执行_tcp_main，继续监听event直到死亡
            _tcp_thread = thread(&TCPSpongeSocket::_tcp_main, this);
        }
        -

        结果就是测试用例Timeout。我找了很久都不知道错在了哪，最后求助了场外观众【罪过……这次实验太不独立了】，学着他把length改成了这样：

        -
        int length = min(data.length(),capacity-buffer.size());
        +
        _tcp_main

        负责establish状态的监听以及之后关闭TCP连接的擦屁股工作

        +
        template <typename AdaptT>
        void TCPSpongeSocket<AdaptT>::_tcp_main() {
            try {
                if (not _tcp.has_value()) {
                    throw runtime_error("no TCP");
                }
                // 持续监听直到死亡
                _tcp_loop([] { return true; });
                shutdown(SHUT_RDWR);
                if (not _tcp.value().active()) {
                    cerr << "DEBUG: TCP connection finished "
                         << (_tcp.value().state() == TCPState::State::RESET ? "uncleanly" : "cleanly.\n");
                }
                _tcp.reset();
            } catch (const exception &e) {
                cerr << "Exception in TCPConnection runner thread: " << e.what() << "\n";
                throw e;
            }
        }
        -

        发现成了。

        -

        我去看了看testbench，猜测应该是因为阻塞了，我还以为是deque自身会阻塞【是的，我完全没注意到自己顺手把阻塞写了下去】，查了半天发现不会，最后才发现是自己不小心搞错了呃呃…………

        -

        代码

        头文件声明

        class ByteStream {
          private:
            // Your code here -- add private members as necessary.

            // Hint: This doesn't need to be a sophisticated data structure at
            // all, but if any of your tests are taking longer than a second,
            // that's a sign that you probably want to keep exploring
            // different approaches.

            size_t total_write;
            size_t total_read;
            bool is_input_end;
            const size_t capacity;
            deque<char> buffer;
        +
        listen_and_accept

        由服务器端调用。

        +
        // Server调用
        // 未收到外界连接时，owner进程会阻塞
        template <typename AdaptT>
        void TCPSpongeSocket<AdaptT>::listen_and_accept(const TCPConfig &c_tcp, const FdAdapterConfig &c_ad) {
             _initialize_TCP(c_tcp);
            _datagram_adapter.config_mut() = c_ad;
            
            _datagram_adapter.set_listening(true);

            cerr << "DEBUG: Listening for incoming connection...\n";
            // 等待直到ESTABLISHED。注意下这里的状态条件
            // 其中各种收发报文的事件由tcp_loop中的event做
            _tcp_loop([&] {
                const auto s = _tcp->state();
                return (s == TCPState::State::LISTEN or s == TCPState::State::SYN_RCVD or s == TCPState::State::SYN_SENT);
            });
            cerr << "New connection from " << _datagram_adapter.config().destination.to_string() << ".\n";

            // 开启connection进程
            _tcp_thread = thread(&TCPSpongeSocket::_tcp_main, this);
        }
        -

        具体实现

        ByteStream::ByteStream(const size_t cap) : total_write(0),total_read(0),is_input_end(false),capacity(cap),buffer(){ }

            //! Write a string of bytes into the stream. Write as many
            //! as will fit, and return how many were written.
            //! \returns the number of bytes accepted into the stream
        size_t ByteStream::write(const string &data) {
            if(is_input_end == true)    is_input_end = false;
            int pointer = 0;
            int length = data.length();
            while(is_input_end == false&&pointer<length){
                if(buffer.size() == capacity)   break;
                buffer.push_back(data[pointer]);
                pointer++;
            }
            total_write+=pointer;
            return pointer;
        }
            //! Peek at next "len" bytes of the stream
        //! \param[in] len bytes will be copied from the output side of the buffer
        string ByteStream::peek_output(const size_t len) const {
            string res;
            size_t i = 0;
            for (auto it = buffer.begin(); it != buffer.end(); it++) {
                if (i >= len)
                    break;
                i++;
                res.push_back(*it);
            }
            return res;
        }

            //! Remove bytes from the buffer
        //! \param[in] len bytes will be removed from the output side of the buffer
        void ByteStream::pop_output(const size_t len) {
            size_t i;
            for (i = 0; i < len; i++) {
                if (buffer.empty())
                    break;
                buffer.pop_front();
            }
            total_read+=i;
        }

        //! Read (i.e., copy and then pop) the next "len" bytes of the stream
        //! \param[in] len bytes will be popped and returned
        //! \returns a string
        std::string ByteStream::read(const size_t len) {
            string res = peek_output(len);
            pop_output(len);
            return res;
        }

        void ByteStream::end_input() {is_input_end = true;}

        bool ByteStream::input_ended() const { return is_input_end; }

        size_t ByteStream::buffer_size() const { return buffer.size(); }

        bool ByteStream::buffer_empty() const { return buffer.empty(); }

        bool ByteStream::eof() const { return is_input_end && buffer.empty(); }

        size_t ByteStream::bytes_written() const { return total_write; }

        size_t ByteStream::bytes_read() const { return total_read; }

        size_t ByteStream::remaining_capacity() const { return capacity - buffer.size(); }
        +

        CS144TCPSocket 和 FullStackSocket

        主菜（上面那个）已经说完了，这两个就是简单的包装类，没什么好说的，大概就做了点传参工作，主要差异还是adapter。

        +

        Adapter实现

        在我们的TCPSpongeSocket实现中，我们引入了“adapter”的概念。

        +
          protected:
            //! Adapter to underlying datagram socket (e.g., UDP or IP)
            AdaptT _datagram_adapter;

        using TCPOverUDPSpongeSocket = TCPSpongeSocket<TCPOverUDPSocketAdapter>;
        using TCPOverIPv4SpongeSocket = TCPSpongeSocket<TCPOverIPv4OverTunFdAdapter>;
        using TCPOverIPv4OverEthernetSpongeSocket = TCPSpongeSocket<TCPOverIPv4OverEthernetAdapter>;

        using LossyTCPOverUDPSpongeSocket = TCPSpongeSocket<LossyTCPOverUDPSocketAdapter>;
        using LossyTCPOverIPv4SpongeSocket = TCPSpongeSocket<LossyTCPOverIPv4OverTunFdAdapter>;
        + +

        它很完美地以策略模式的形式，凝结出了我们本次实验所需的各种协议栈的共同代码，放进了TCPSpongeSocket，而将涉及到协议栈差异的部分用adapter完成。

        +

        在TCPSpongeSocket中，adapter主要完成了如下操作：

        +
          +

        1. adapter的tick函数

          +
          // in tcp_loop
          _tcp.value().tick(next_time - base_time);
          _datagram_adapter.tick(next_time - base_time);
          2. +

        2. 作为订阅事件的IO流

          +
          _eventloop.add_rule(_datagram_adapter,
                                  Direction::In,
                                  [&] {
          	// ...
          3. +

        3. TCP层通过对其读写来获取TCP segment

          +
          auto seg = _datagram_adapter.read();
          _datagram_adapter.write(_tcp->segments_out().front());
          4. +

        4. 记录各类参数

          +
          datagram_adapter.config().destination.to_string()
          5. +
        +

        Inheritance graph

        +

        具体实现说实话没什么好说的，确实无非也就是上面那几个方法，然后在里面包装下和操作系统提供的tun和tap的接口交互罢了，代码也比较简单，此处就不说了。

        +

        apps

        除了对协议栈的实现之外，在app文件夹下还有许多对我们实现的协议栈的应用实例。我认为了解下应用实例也是很重要的。

        +

        bidirectional_stream_copy

        其作用就是建立stdin/stdout与socket的关联。它从stdin读输入，作为上层app的输入写入socket；从socket读输出，传给上层app，也即stdout输出。它的具体实现在stdin/stdout之间隔了两条bytestream，分别是_inbound和_outbound。

        +

        由于stdin、stdout、socket本质上都是fd，所以我们依然可以采用跟上面一样的事件驱动方式。我们只需在socket有输出时马上读给inbound bytestream，在inbound bytestream有输入时马上读给stdout，在stdin有输入时马上写入outbound bytestream，在outbound bytestream有输入时马上读给socket。遵守这4条rule就行了。

        +

        因而，具体实现就是TCPSpongeSocket::_initialize_TCP和TCPSpongeSocket::_tcp_loop的结合体，订阅事件+循环等待。由于跟前面类似，在此就不放代码了。

        +

        其他

        其他都太复杂了，感觉我水平一般还不大能理解，也懒得看了【草】总之先咕咕咕

        ]]>         @@ -6304,229 +6487,94 @@ url访问填写http://localhost/webdemo4_war/*.do。

        本质上是“the distance between the first unassembled index and the first unacceptable index”

      -

      也即，ackno为拥塞窗口的左端点，ackno+window_size为拥塞窗口的右端点

      - -
    -

    64-bit indexes ←→ 32-bit seqnos

    从Overview中可以看出来，至关重要的一点就是，将环绕的32bit的seq转化为我们在StreamReassembler中使用的index。

    -

    我们不妨再引入一个中间变量abstract seqno。则seqno、abstract seqno、stream index三者关系如下图：

    -

    image-20230227141242426

    -

    显然从seqno转化为abstract seqno更加复杂。因而，我们要做的第一个实验部分就是实现这个转化。

    -

    我们需要实现类WrappingInt32。它的wrap函数将64位的abstract seqno转化为32位的seqno，它的unwrap将32位的seqno转化为64位的abstract seqno。

    -

    感想

    64-bit indexes ←→ 32-bit seqnos

    这个实验完美地触及到了我的雷点：对这种环绕来环绕去的东西非常头疼……因而昨天晚上做的时候晕晕乎乎的什么也思考不了，今天过来边画了下图才知道要怎么做。

    -

    wrap很简单我就不说了。对于unwrap，我的做法是，先让checkpoint和n-isn都处在同一个区间（红圈）内【也即都让它们对2^32取余】，再通过几个东西之间的关系来确定最终的res是否需要+-HEAD_ONE：

    -

    【蓝线表示n-isn，橙线表示红圈区间的中点】

    -

    image-20230227133550293

    -

    具体的就不多说了。直接看下面的代码，多画画图就能明白了。

    -

    TCPReceiver

    image-20230227231044428

    -

    心得

    我一开始头晕晕地去写，对很多地方产生了疑问，激情地写下了一些消极的话语。刚刚出去吹了会儿风回来，bug全都改对了，于是狂喜着把消极的话语全部删掉了（）

    -

    怎么说呢，我的错误发生是因为我没有意识到sponge的TCP也许算是一个“简化版”。

    -

    在学习本章内容之前，我特地先去回顾了下TCP协议的全过程，并且所有的SYN，FIN等等等概念都是按照网上的概念来的。因而我在面对自己的错误时真的是一脸懵逼……好在，吹完风之后我还是及时醒悟了。

    -

    思路还是很简单的，细节也不像Lab1那样那么多那么破防，就是一些奇奇怪怪的恶心小毛病太多了，导致我出错频频，并且都是些很sb的问题，让人直接心态爆炸。

    -

    先不吐槽了，接下来就来讲讲总体的思路，以及我产生疑惑的一些地方吧。

    -

    思路

    基本流程

    得益于Lab1那个复杂算法的健壮性和多功能性，我们对TCPReceiver的实现就可以变得更加简洁。我们不再需要关心报文是否能够被成功接收、报文是否重叠等等等。我们仅需对SYN和FIN这样的报文做特殊的参数处理，将seqno转化为index，然后直接传入我们的StreamReassembler中就行了。

    -

    也即，基本流程为：

    -
      -
    1. 如果收到SYN报文，则对一些参数进行初始化，并且标记数据传输开始信号syn为true
      2. -
    2. 如果syn为true，则计算index后传入整流器
      3. -
    3. 判断是否需要加上FIN报文的比特位
      4. -
    -
    一些细节
    SYN和FIN各占一个seqno
    // SYN
        if(!syn&&header.syn){ // is the first packet
            // ...
            isn = header.seqno;
            seqno = seqno + 1; // plus one to skip the SYN byte
            // ...
        }
    // FIN
    	if(header.fin)      fin = true; // 这个一定要写在上面那个if的后面
    	// ...
    	if(_reassembler.empty() && fin){
        	ack += 1;
        }
    - -

    SYN很直观，没什么好说的。

    -

    FIN比较烧。之所以不是这么写：

    -
    if(header.fin){
       	ack += 1;
       }
    - -

    也即一发现FIN报文到了就++，是因为可能会发生这种情况：

    -

    image-20230227224055002

    -

    也即FIN报文虽然到了，但是中间有一段数据还没到，ack应该等于中间那段数据的开头，你这时候想要跳过FIN而把ack+1那肯定是不对的。

    -

    也因而，我们需要记录fin是否有过，并且仅当：

    -
    bool StreamReassembler::empty() const { return buffer.empty()&&is_eof; }
    - -

    成立时，才能表示数据传输真正结束，让ack++。

    -
    以abstract seqno的形式保存ackno

    说实话我一开始ackno的数据结构是WrappingInt32。为了这么搞，我还得特地维护一个checkpoint变量用来做unwrap的参数，然后ackno也不能用_reassembler.get_left_bound()来获取，总之就搞得非常非常麻烦。这时候我不小心【是故意的还是不小心的？】看到了感恩的代码，对其用abstract seqno保存ackno这个想法大为赞叹，于是就果断地沿用了（）果然设计思想方面我还是有很大不足啊。

    -

    疑惑

    关于特殊报文

    我一开始被这个图以及百度得到的结果受影响：

    -

    image-20230227224429692

    -

    image-20230227224449780

    -

    认为SYN报文不能携带数据【同理FIN也是】，因而在最初实现的时候看到test case人都麻透了开始怀疑人生……

    -

    不过这也怪我没有意识到实验和业界可能是不一样的，但指导书也没说SYN和FIN到底会不会携带数据……emm，我感觉这一点做得不够详细，也许可以改进一下。

    -
    关于window size的定义

    我现在还是搞不懂这东西究竟是什么玩意……

    -

    指导书上是这么说的：

    -
    -

    the distance between the “first unassembled” index and the “first unacceptable” index.

    -

    This is called the “window size”.

    -
    -

    所谓的“first unassembled”正是ackno。而，我正是理解错了所谓“first unacceptable” 的意思，才导致我想了好久好久都没想出来，最后看了答案被薄纱到现在。

    -

    看到这个“first unacceptable” ，我的第一反应就是，维护一个变量right_bound，当packet过来的时候，如果packet的index范围(seqno + data.length())比right_bound大就更新。我认为这才叫做“first unacceptable”。但其实！我会这么想是因为我英语不好……

    -

    “first unacceptable” ，unacceptable，意为无法接受的，也就是说，它跟容量有关。第一个无法接受的，就是第一个超出容量的。而结合我们上面的那张图：

    -

    image-20230225232723083

    -

    可以看出，事实上window size就是黑框部分，也即紫框部分减去绿色部分，也即ByteStream的remaining_capacity()……

    -

    而我以为它是还未收到的的意思，故而才理解成了上面那样。

    -

    看来英语不好也是原罪23333

    -

    代码

    64-bit indexes ←→ 32-bit seqnos

    //! Transform an "absolute" 64-bit sequence number (zero-indexed) into a WrappingInt32
    //! \param n The input absolute 64-bit sequence number
    //! \param isn The initial sequence number
    WrappingInt32 wrap(uint64_t n, WrappingInt32 isn) {
        uint32_t tmp = (n & TAIL_MASK);
        return isn + tmp;
    }

    //! Transform a WrappingInt32 into an "absolute" 64-bit sequence number (zero-indexed)
    //! \param n The relative sequence number
    //! \param isn The initial sequence number
    //! \param checkpoint A recent absolute 64-bit sequence number
    //! \returns the 64-bit sequence number that wraps to `n` and is closest to `checkpoint`
    //!
    //! \note Each of the two streams of the TCP connection has its own ISN. One stream
    //! runs from the local TCPSender to the remote TCPReceiver and has one ISN,
    //! and the other stream runs from the remote TCPSender to the local TCPReceiver and
    //! has a different ISN.
    uint64_t unwrap(WrappingInt32 n, WrappingInt32 isn, uint64_t checkpoint) {
        uint32_t tmp_n = n.raw_value() - isn.raw_value();
        uint64_t res = (checkpoint & HEAD_MASK);
        uint32_t tmp_cp = (checkpoint & TAIL_MASK);

        res |= tmp_n;
        if(tmp_cp < FLAG){
            if(tmp_n > tmp_cp + FLAG){
                if(res >= HEAD_ONE) res -= HEAD_ONE;
            }
        }else if(tmp_cp > FLAG){
            if(tmp_n < tmp_cp - FLAG)       res += HEAD_ONE;
        }
        return res;
    }
    - -

    TCPReceiver

    头文件

    class TCPReceiver {
        StreamReassembler _reassembler;

        size_t _capacity;
        uint64_t ack = 0;
        WrappingInt32 isn = WrappingInt32(0);

        bool syn = false;
        bool fin = false;
    // ...
    - -

    具体实现

    void TCPReceiver::segment_received(const TCPSegment &seg) {
        TCPHeader header = seg.header();
        WrappingInt32 seqno = header.seqno;
        string data = seg.payload().copy();
        size_t index = 0; // the param of the reassembler
        
        // LISTENING -> SYN_SENT
        if(!syn&&header.syn){ // is the first packet
            _reassembler.set_is_eof();// reset the eof flag
            fin = false;// reset the fin flag
            isn = header.seqno;
            seqno = seqno + 1; // plus one to skip the SYN byte
            syn = true;// mark the start of the byte stream
        }
        
        // must keep after the last if branch to avoid the case "flag = SF"
        // FIN_RECEIVED
        if(header.fin)      fin = true; 
        if(syn){
            uint64_t abs_seqno = unwrap(seqno,isn,ack);
            index = abs_seqno - 1;
            if (abs_seqno != 0)// write into the assembler
            	_reassembler.push_substring(data,index,header.fin);
            ack = _reassembler.get_left_bound() + 1;
            
            if (_reassembler.stream_out().input_ended() && fin)
                ack += 1;// plus one to skip the FIN byte
        }
    }
    optional<WrappingInt32> TCPReceiver::ackno() const {
        if(syn)     return wrap(ack,isn);
        else        return {};// empty
    }

    size_t TCPReceiver::window_size() const {
            return stream_out().remaining_capacity();
    }
    -]]> - - - Lab1 StreamReassembler - /2023/02/25/cs144$lab1/ - Lab1 StreamReassembler
    -

    TCP managed to produce a pair of reliable in-order byte streams (one from you to the server, and one in the opposite direction), even though the underlying network only delivers “best-effort” datagrams.

    -

    You also implemented the byte-stream abstraction yourself, in memory within one computer.

    -

    Over the next four weeks, you’ll implement TCP, to provide the byte-stream abstraction between a pair of computers separated by an unreliable datagram network.

    -
    -

    我们的任务是实现一个StreamReassembler。它的具体功能相信看下数据传输路径就很明了了：

    -
    -

    receiver的数据传输路径：network → StreamReassembler整流 →（write）ByteStream（read）→ app

    -
    -

    感想

    先放个通关截图在这。

    -

    image-20230225192145829

    -

    这个实验我前前后后总共做了大概有9h+……写我下面放上来的屎山代码可能大概用了5h+。我总共使用了140+行代码实现我的核心函数push_substring。

    -

    整个过程，包括思路和代码都十分复杂，但最后的表现相比于别人好像也没好到哪去，让我不禁怀疑自己是不是想错了……以及，这样的复杂性也给我带来很多担忧，担心会不会在以后的实验因为这个的bug而寄，毕竟我在写笔记的同时都已经找到了不止一个bug了（）希望人没事。

    -

    总而言之，先把我的思路和一步步的代码拆解放上来吧。

    -
    -

    后记：

    -

    不得不说，这个东西太健壮了，给后面的TCPReceiver省去了好多功夫……

    -

    比如说，TCPReceiver无需考虑ack怎么算，因为这里就帮你算好了；TCPReceiver无需考虑数据包重叠或者重复，因为这里已经考虑到这个情况了；TCPReceiver无需担忧FIN是否会因为容量满丢弃一部分数据而未达到真正的FIN，只需调用其相关接口判断就行。

    -

    它虽然帮助了TCPReceiver那么多，但很神奇的是，它们的耦合性并不高。你把StreamReassembler单独拆出来看，左看右看，它都确实仅仅只是一个健壮的区间合并算法。

    -

    这得益于实验设计的精良，得益于设计TCPReceiver时的野心。这些边界情况都这么麻烦，而且都只与区间合并有关，那么我们为什么不直接把它抽象进区间合并进行处理呢？这种想法极富胆识，事实证明最后也确实能实现。这种设计理念让我受益很深。

    -
    -

    为什么我的思路那么复杂

    看了感恩的代码，我发现我俩的大题思路其实差不多是一模一样的，都是先进行两轮的区间合并，然后再处理但为啥我看起来就那么复杂呢？

    -

    一是题意理解问题。

    -

    我发现他对_capacity的理解跟我的理解不一样emmm……

    -

    额好像怪我没认真看指导书的图。

    -

    image-20230225232723083-1677339210527-2

    -

    我理解的capacity：绿色部分和红色部分的净含量

    -

    似乎是真正的capacity：绿色部分+红色部分+空部分？？也就是说capacity只是一个跟index差不多的索引下标？？…………

    -
     // out of bound
    if (start >= hope_to_rec + _capacity - _output.buffer_size()) {
        return;
    }
    - -

    也就是说我能过测试是因为偶然吗？？

    -

    我其实感觉正确理解的capacity意义好怪啊，这怎么就能节省内存了呢？我觉得我理解的反而比较有道理（倔强）

    -

    笑一笑算了家人们。总之先这么写吧，以后的实验寄掉了再回来改。

    -
    -

    UPDATE: 确实寄掉了，并且已经改过来了，也不复杂，只需要添加对right边界的处理就行。【指去掉超出start+capacity的部分。】

    -
    -

    二是代码规范问题。

    -

    首先他代码规范性强，看起来非常舒服。其次他会用类似upper_bound()这样的函数（反观我压根没想起来），这样就显得比我的循环简洁了很多很多。

    -

    三是设计问题。

    -

    他用的是map我用的是set。确实是map比较合理，它既有find功能也兼具了有序的特性。

    -

    我的思路

    我们要做的，是将零散的数据包拼接成完整的字节流，并且将整流过的数据送入ByteStream中，这通过核心函数push_substring实现。我们可以先来看看push_substring的定义：

    -
    void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) ;
    - -

    data为数据包，index为data中第一个字符在整个字节流的下标，eof用来标识这是字节流的最后一个数据包。

    -
    -

    详细说明：

    -

    比方说有字节流“abcdefg”，则合法的参数对有如：{“abc”,0,0},{“cdef”,2,0},{“g”,6,1}

    -
    -

    通俗来说，我们这个函数的功能就是，把一堆起始下标为index的data（无序、可能重叠）拼接为一个完整的字节流。

    -

    听起来有没有觉得很耳熟？是的，我认为这正是“区间合并”问题。我接下来便通过区间合并的思想，对问题进行如下数据结构以及算法的设计。

    -

    数据结构

    区间

    由于是区间合并问题，所以就先需要定义区间。

    -
    struct node {
        size_t left;   // 当前data位于总体的左index（闭）
        size_t right;  // 右index（开）
        string data;
        bool operator<(const node &b) const { return left < b.left; }
    };
    - -

    集合

    我们需要维护一个左端点升序的区间集合，故使用内部红黑树实现的有序集合set。

    -
    set<node> buffer;   // 存储结构
    - -

    算法

    我们要做的，是对数据包进行整流，并且把整流过的部分输送到ByteStream中。由于存储结构存在_capacity的上限，因而，我们需要尽可能早地把存储结构中已经整流好的数据送入ByteStream中。

    -

    那么，如何定义“已经整流好的数据”呢？它需要满足跟“之前已经整流好了的数据”的有序性，也即，比方说[0,1000]已经整流完毕送入app，那么下一个送入app的数据一定满足index=1001。

    -

    因而，我们可以维护一个变量left_bound，表示下一个将被app接受的数据的index（如上例的1001）。为了达到“尽早”目的，我们需要在每次push_substring执行完区间合并之后，检查buffer的第一个区间的左端点是否与left_bound相等，是的话则将第一个区间写入ByteStream，不是的话就什么也不做。

    -

    因而，在push_substring中，对于一个新来的数据包，我们大致需要进行以下几步：

    -
      -
    1. 将参数所给的区间( [index, index+data.length()) )并入区间集合buffer中
      2. -
    2. 查看是否需要ByteStream
      3. -
    -

    区间合并

    问题定义

    问题可抽象为：

    -
    -

    给定一个有序区间集合buffer，以及一个小区间node，你需要把node塞进buffer里。

    -

    Example： buffer = {[1,3),[5,7)} , node = [6,8) 输出：buffer = {[1,3), [5,8)}

    -
    -
    算法思路

    判断区间重叠统一只检查左端点。注意，两次重叠的判断条件不一样，是因为相对性发生了改变。第一次相当于node的左端点在buffer[i]中，第二次相当于buffer[i]的左端点在node中。

    -
      -

    1. 对buffer进行第一轮扫描

      -

      如果node与buffer[i]产生重叠（(left >= it->left && left <= it->right)），那么更新node为node∪buffer[i]，并且将buffer[i]从buffer中删去。

      -

      在第一次找到重叠的区间，就应该break退出第一轮循环。

      -
      2. -

    2. 对buffer进行第二轮扫描

      -

      如果node与buffer[i]产生重叠（ (it->left >= left && it->left <= right)），那么更新node为node∪buffer[i]，并且将buffer[i]从buffer中删去。

      -
      3. -
    -

    我们在合并区间时，不仅需要对struct node的左端点left和右端点right进行更新，还需要对其数据域data也进行合并拼接。我们维护变量res作为维护的目标区间的数据域。对于res，我们应该进行如下操作：

    -
      -

    1. 初始化为data

      -
      2. -

    2. 除去[left, left_bound)这一区间内的数据

      -

      这部分数据我们已经整流过并且写入ByteStream

      -
      3. -

    3. 在两轮合并中对其进行正确拼接

      -
      4. -
    -
    图解

    image-20230225200605175

    -
    代码
    size_t left = index, right = index + data.length();  // 初始化左右区间
    size_t o_left = left, o_right = right;               // keep the original value
    node tmp = {0, 0, ""};

    if (right < left_bound)	return;                // must be duplicated
    left = left < left_bound ? left_bound : left;  // 左边已经接受过的数据就不要了
    string res = data.substr(left - o_left, right - left);// 掐头

    /* 开始区间合并。需要扫描两次 */
    // 第一次
    for (auto it = buffer.begin(); it != buffer.end(); it++) {
        if (left >= it->left && left <= it->right) { // 区间重叠
            size_t r = right,l = left;
            // 更新左右端点
            right = max(right, it->right);
            left = min(left, it->left);
            if (r <= it->right) // 如果目标区间被包裹在it内
                // res需要更新为it头+data掐头后的全长+it尾，也即将it中间重叠部分用data替换
                res = it->data.substr(0, l - it->left) + data.substr(l - o_left) +
                it->data.substr(r - it->left, it->right - r);
            else 
                res = it->data.substr(0, l - it->left) + data.substr(l - o_left);
            // 删除原来的结点
            buffer.erase(it);
            break;
        }
    }

    // 第二次
    for (auto it = buffer.begin(); it != buffer.end(); it++) {
        if (it->left >= left && it->left <= right) {
            if (it->right <= right);// it这个区间被包含在目标区间内，则什么也不做
            else {
                // 需要加上it的尾
                res += it->data.substr(right - it->left, it->right - right);
                // 更新右端点
                right = it->right;
            }
            // 删除
            buffer.erase(it);
        }
    }
    // 将维护区间插入区间集合
    tmp = {left, right, res};
    buffer.insert(tmp);
    - -

    写入ByteStream

    思路

    我们需要检查buffer内的第一个区间，如果其左端点与left_bound相等，则把第一个区间填入ByteStream，然后更新left_bound，从buffer中删去该区间；如果不相等（只可能是left > left_bound）则什么也不做。

    -

    在把区间数据填入ByteStream的过程中，可能造成ByteStream满。因而我们就只能填入第一个区间内的一部分数据，更新left_bound，将第一个区间的剩余数据继续存在buffer中。

    -
    代码
    auto iterator = buffer.begin();  
    iterator = buffer.begin();
    // write into the ByteStream
    if (iterator != buffer.end() && iterator->left == left_bound) {
        // 防止_output的容量超过
        size_t out_rem = _output.remaining_capacity();
        if (out_rem < iterator->data.length()) { // ByteStream剩余容量小于第一个区间长度
            _output.write(iterator->data.substr(0, out_rem));// 写入尽量多数据
            left_bound = iterator->left + out_rem;// 更新左边界
            // 由于iterator只读，因而我们不能直接修改其左端点和data域
            tmp = {left_bound, iterator->right, iterator->data.substr(out_rem)};
            buffer.erase(iterator);
            buffer.insert(tmp);
        } else {
            _output.write(iterator->data);
            left_bound = iterator->right;
            buffer.erase(iterator);
        }
    }
    - -

    buffer的最大容量_capacity

    背景

    维护“存储结构的容量不超过capacity”这个不变性条件可以说是这个实验最恶心最难的地方……也正是它，让我的代码写成了一坨shit山（）

    -

    为什么说它最难最恶心呢？其实它本来也许不算难，但在这个思路下想要保持这个不变性条件，就显得非常地困难。

    -

    一开始没过脑子的时候，我觉得这样就行：

    -
    void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) {
    	if(data.length() + unassemble_bytes() > capacity)	return;
    }
    - -

    但是这样很明显有两个问题。

    -

    一是就算你超过了，你也不能直接丢弃掉data，得把没超过的部分填满。

    -

    二是，data.length() + unassemble_bytes()有时，甚至是很多时候，都不会是将data并入buffer之后buffer的容量。因为data和buffer很大概率会存在重叠区间。

    -

    那么，你能不能在区间合并完之后，再进行该不变性条件的判断，并且将没超过的部分填满，超过的部分丢弃呢？

    -

    答案是，也不能。因为经过两轮合并，你的data和buffer里原有的数据早已你中有我我中有你了，你无法在最后将它们分开，找出data超过capacity的数据并且丢弃它。

    -

    因而，头尾都不行的话，唯一的答案就是，我们只能在两轮区间合并中途，去时刻追踪当前容量是否超过capacity。

    -

    这听起来就令人十分地头大。但事实证明，并不是无法实现的，坚持下去，就算是shit山也能跑起来（）下面便是我的实现思路。

    -
    思路

    维护一个变量remaining，表示当前还有多少容量。维护start，表示未判断是否可以写入buffer的数据起点。我们要做的事：

    +

    也即，ackno为拥塞窗口的左端点，ackno+window_size为拥塞窗口的右端点

    + +
+

64-bit indexes ←→ 32-bit seqnos

从Overview中可以看出来，至关重要的一点就是，将环绕的32bit的seq转化为我们在StreamReassembler中使用的index。

+

我们不妨再引入一个中间变量abstract seqno。则seqno、abstract seqno、stream index三者关系如下图：

+

image-20230227141242426

+

显然从seqno转化为abstract seqno更加复杂。因而，我们要做的第一个实验部分就是实现这个转化。

+

我们需要实现类WrappingInt32。它的wrap函数将64位的abstract seqno转化为32位的seqno，它的unwrap将32位的seqno转化为64位的abstract seqno。

+

感想

64-bit indexes ←→ 32-bit seqnos

这个实验完美地触及到了我的雷点：对这种环绕来环绕去的东西非常头疼……因而昨天晚上做的时候晕晕乎乎的什么也思考不了，今天过来边画了下图才知道要怎么做。

+

wrap很简单我就不说了。对于unwrap，我的做法是，先让checkpoint和n-isn都处在同一个区间（红圈）内【也即都让它们对2^32取余】，再通过几个东西之间的关系来确定最终的res是否需要+-HEAD_ONE：

+

【蓝线表示n-isn，橙线表示红圈区间的中点】

+

image-20230227133550293

+

具体的就不多说了。直接看下面的代码，多画画图就能明白了。

+

TCPReceiver

image-20230227231044428

+

心得

我一开始头晕晕地去写，对很多地方产生了疑问，激情地写下了一些消极的话语。刚刚出去吹了会儿风回来，bug全都改对了，于是狂喜着把消极的话语全部删掉了（）

+

怎么说呢，我的错误发生是因为我没有意识到sponge的TCP也许算是一个“简化版”。

+

在学习本章内容之前，我特地先去回顾了下TCP协议的全过程，并且所有的SYN，FIN等等等概念都是按照网上的概念来的。因而我在面对自己的错误时真的是一脸懵逼……好在，吹完风之后我还是及时醒悟了。

+

思路还是很简单的，细节也不像Lab1那样那么多那么破防，就是一些奇奇怪怪的恶心小毛病太多了，导致我出错频频，并且都是些很sb的问题，让人直接心态爆炸。

+

先不吐槽了，接下来就来讲讲总体的思路，以及我产生疑惑的一些地方吧。

+

思路

基本流程

得益于Lab1那个复杂算法的健壮性和多功能性，我们对TCPReceiver的实现就可以变得更加简洁。我们不再需要关心报文是否能够被成功接收、报文是否重叠等等等。我们仅需对SYN和FIN这样的报文做特殊的参数处理，将seqno转化为index，然后直接传入我们的StreamReassembler中就行了。

+

也即，基本流程为：

    -
  1. 初始化remaining为capacity - 当前容量，start为掐头后的left
    2. -
  2. 在第一轮循环中更新start
    3. -
  3. 在第二轮循环中通过start和remaining来判断是否能够写入buffer。尽可能多地写入，把写入不了的部分丢弃。
    4. +
  4. 如果收到SYN报文，则对一些参数进行初始化，并且标记数据传输开始信号syn为true
    5. +
  5. 如果syn为true，则计算index后传入整流器
    6. +
  6. 判断是否需要加上FIN报文的比特位
-
例子

下面举个例子来说明整个流程。

-
initial:  
buffer = { [1,3], [5,8],[10,12],[13,14] } , capacity = 12, remaining = 12-9=3, data = [2,11], start = 2
- -

start为2，是因为data的从2开始的这段数据还不知道能不能被成功存入buffer中。

-

第一次合并后，buffer = { [5,8],[10,12],[13,14] } ，data=[1,11]，start = 3.

-

start为3，是因为[2,11]与[1,3]合并，由于[2,3]这段本来就在buffer中，因而可以不用占用remaining，但从3开始这段数据还不知道能不能成功存入buffer中。

-

在第二轮合并中，首先扫描到[5,8]。由于[start,it->left]也即[3,5]这段数据长度为2<remaining=3，故而这段数据可以存入buffer，remaining更新为3-2=1，start更新为it->right=8.

-

/*

-

注意，此处无需再对[9,10]进行同样的操作。对于这种情况：

-
buffer = { [1,3], [5,8] } , capacity = 12, remaining = 12-9=3, data = [2,11], start = 2
- -

在循环结束的这里已经处理：

-
if (remaining < right - start) {
    right = remaining + start;
    if (eof == 1)
        is_eof = false;
}
- -

*/

-

然后扫描到[10,12]。由于[start,it->left]也即[8,10]这段数据长度为2>remaining=1，故而这段数据只能把[8,9]这部分存入buffer。因而，我们把到此为止的[1,9]结点存入buffer，剩下的[10,11]部分直接丢弃，也即直接跳入到最后的写入ByteStream部分。

-
代码
void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) {
    size_t remaining = _capacity - unassembled_bytes();  // how much room left?

    size_t left = index, right = index + data.length();  // 初始化左右区间
    size_t o_left = left, o_right = right;               // keep the original value

    size_t start = left;  // the begin of the unused data-zone of variable data
    // if(remaining == 0)	goto end; // buffer满

    // 开始区间合并。需要扫描两次
    for (auto it = buffer.begin(); it != buffer.end(); it++) {
        if (left >= it->left && left <= it->right) {
            right = max(right, it->right);
            left = min(left, it->left);
            // 说明目标区间完全被包裹，也即目标区间一定可以塞进buffer中
            if (right == it->right) 	start = o_right;
            // 说明仅仅部分重叠，去重部分从it->right开始
            else	start = it->right;
			// ...
            break;
        }
    }

    // 第二次
    for (auto it = buffer.begin(); it != buffer.end(); it++) {
        if (it->left >= left && it->left <= right) {
            // 比remaining满
            // 第一个条件是为了防止unsigned溢出
            if (it->left > start && remaining < it->left - start) {
                // 截取能塞得下的部分
                tmp = {left, start + remaining, res.substr(0, start - left + remaining)};
                remaining = 0;
                // 此时塞进去是肯定不重叠的，因为tmp.right < it->left
                buffer.insert(tmp);
                // 剩下的直接丢弃
                goto end;
            }
            // 塞得下
            remaining -= it->left - start;
            start = it->right;
            // ...
        }
    }

    // 边界处理
    if (remaining < right - start) {
        // 扔掉塞不下的部分
        right = remaining + start;
    }
    tmp = {left, right, res};
    buffer.insert(tmp);

end:
    iterator = buffer.begin();
    // write into the ByteStream
    // ...
}
- -

capacity还没结束

背景

你以为做到上面那个小标题那样就万无一失了吗？答案是，并不！

-

我们还有哪里想得不周全呢？考虑这样一个案例，ByteStream未满，但是在更新remaining时发现buffer已满塞不下了。这时候，我们上面的做法是直接扔掉塞不下的部分。但其实，我们还可以查看buffer的一部分数据是否能够再塞进ByteStream，如果能的话，就又能省下一笔空间了！

-

所以，我们在发现remaining不够时，应该首先检查能不能塞一部分buffer的数据进入ByteStream中用来腾出空间。

-
代码
// 第二次
for (auto it = buffer.begin(); it != buffer.end(); it++) {
    if (it->left >= left && it->left <= right) {
        // 比remaining满
        // 第一个条件是为了防止unsigned溢出
        if (it->left > start && remaining < it->left - start) {
            // 先看看能不能塞进ByteStream腾空间。需要满足两个条件
            // buffer的第一个区间正好是left_bound
            if (left == left_bound) {
                size_t out_mem = _output.remaining_capacity();
                // ByteStream有位置
                if (out_mem > 0) {
                    // 腾出的空间很充足，完全可以不改变remaining
                    if (out_mem >= it->left - start) {
                        // 写入ByteStream
                        _output.write(res.substr(0, it->left - start));
                        // 更新
                        res = res.substr(it->left - start);
                        left_bound = it->left - start + left;
                        left = left_bound;
                        // 加上腾出的空间【在ok标签处减掉】
                        remaining += it->left-start;
                        goto ok;
                    } else {
                        // 空间不足以完全不改变remaining
                        _output.write(res.substr(0, out_mem));
                        res = res.substr(out_mem);
                        left_bound = out_mem + left;
                        left = left_bound;
                        // 加上腾出的空间
                        remaining += out_mem;
                        // 如果两个加起来就行，则ok
                        if(it->left>start && remaining>=it->left - start){
                                goto ok;
                        }
                        // 否则remaining依然不充足
                    }
                }
            }
            // 截取能塞得下的部分
            tmp = {left, start + remaining, res.substr(0, start - left + remaining)};
            remaining = 0;
            // 此时塞进去是肯定不重叠的，因为tmp.right < it->left
            buffer.insert(tmp);
            // 剩下的直接丢弃
            goto end;
        }
    ok:
        // 塞得下
        remaining -= it->left - start;
        start = it->right;
        // ...
    }
}
- -
小细节

因而，在一开始发现remaining满的时候，不能直接goto end。

-
// if(remaining == 0)	goto end; // buffer满
+
一些细节
SYN和FIN各占一个seqno
// SYN
    if(!syn&&header.syn){ // is the first packet
        // ...
        isn = header.seqno;
        seqno = seqno + 1; // plus one to skip the SYN byte
        // ...
    }
// FIN
	if(header.fin)      fin = true; // 这个一定要写在上面那个if的后面
	// ...
	if(_reassembler.empty() && fin){
    	ack += 1;
    }
-

因为还得看看ByteStream能不能腾空间。

-

eof

对于eof的处理也是需要注意的一个小细节。

-

我们不能这么写：

-
if (eof)
    _output.end_input();
+

SYN很直观，没什么好说的。

+

FIN比较烧。之所以不是这么写：

+
if(header.fin){
   	ack += 1;
   }
-

原因有二，一是最后一个数据包有可能是部分丢失，二是整流可能还未结束。

-

所以我们应该在成员变量中维护is_eof，记录是否收到过最后一个数据包，并且在最后一个数据包部分丢失的时候置它为false。当且仅当is_eof == true且buffer非空时，才能说明输入结束。

-

相关代码：

-
void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) {
    if (eof == 1)
        is_eof = true;
	// ...
    // 第二次
    for (auto it = buffer.begin(); it != buffer.end(); it++) {
        if (it->left >= left && it->left <= right) {
            // 此时空间不够，先尝试下能不能写入一部分到_output中
            if (it->left > start && remaining < it->left - start) {
                // ...
                tmp = {left, start + remaining, res.substr(0, start - left + remaining)};
                remaining = 0;
                if (eof == 1)
                    is_eof = false;
                buffer.insert(tmp);
                goto end;
            }
        ok:
        // ...
    }
    
    if (remaining < right - start) {
        right = remaining + start;
        if (eof == 1)
            is_eof = false;
    }
	// ...
end:
	// ...
    // 满足两个条件才是真的eof
    if (is_eof && buffer.empty()){
        is_eof = false;
        _output.end_input();
    }
}
+

也即一发现FIN报文到了就++，是因为可能会发生这种情况：

+

image-20230227224055002

+

也即FIN报文虽然到了，但是中间有一段数据还没到，ack应该等于中间那段数据的开头，你这时候想要跳过FIN而把ack+1那肯定是不对的。

+

也因而，我们需要记录fin是否有过，并且仅当：

+
bool StreamReassembler::empty() const { return buffer.empty()&&is_eof; }
-

代码

头文件声明

class StreamReassembler {
  private:
    // Your code here -- add private members as necessary.
    struct node {
        size_t left;   // 当前data位于总体的左index（闭）
        size_t right;  // 右index（开）
        string data;
        bool operator<(const node &b) const { return left < b.left; }
    };
    bool is_eof;        // 文件的末尾是否接收成功
    size_t left_bound;  // 当前已经成功接收到left_bound之前的数据
    set<node> buffer;   // 存储结构

    ByteStream _output;  //!< The reassembled in-order byte stream
    size_t _capacity;    //!< The maximum number of bytes
   
  public:
    // ...
    
    // used by the TCPReceiver
    void set_is_eof() { is_eof = false; }
}
+

成立时，才能表示数据传输真正结束，让ack++。

+
以abstract seqno的形式保存ackno

说实话我一开始ackno的数据结构是WrappingInt32。为了这么搞，我还得特地维护一个checkpoint变量用来做unwrap的参数，然后ackno也不能用_reassembler.get_left_bound()来获取，总之就搞得非常非常麻烦。这时候我不小心【是故意的还是不小心的？】看到了感恩的代码，对其用abstract seqno保存ackno这个想法大为赞叹，于是就果断地沿用了（）果然设计思想方面我还是有很大不足啊。

+

疑惑

关于特殊报文

我一开始被这个图以及百度得到的结果受影响：

+

image-20230227224429692

+

image-20230227224449780

+

认为SYN报文不能携带数据【同理FIN也是】，因而在最初实现的时候看到test case人都麻透了开始怀疑人生……

+

不过这也怪我没有意识到实验和业界可能是不一样的，但指导书也没说SYN和FIN到底会不会携带数据……emm，我感觉这一点做得不够详细，也许可以改进一下。

+
关于window size的定义

我现在还是搞不懂这东西究竟是什么玩意……

+

指导书上是这么说的：

+
+

the distance between the “first unassembled” index and the “first unacceptable” index.

+

This is called the “window size”.

+
+

所谓的“first unassembled”正是ackno。而，我正是理解错了所谓“first unacceptable” 的意思，才导致我想了好久好久都没想出来，最后看了答案被薄纱到现在。

+

看到这个“first unacceptable” ，我的第一反应就是，维护一个变量right_bound，当packet过来的时候，如果packet的index范围(seqno + data.length())比right_bound大就更新。我认为这才叫做“first unacceptable”。但其实！我会这么想是因为我英语不好……

+

“first unacceptable” ，unacceptable，意为无法接受的，也就是说，它跟容量有关。第一个无法接受的，就是第一个超出容量的。而结合我们上面的那张图：

+

image-20230225232723083

+

可以看出，事实上window size就是黑框部分，也即紫框部分减去绿色部分，也即ByteStream的remaining_capacity()……

+

而我以为它是还未收到的的意思，故而才理解成了上面那样。

+

看来英语不好也是原罪23333

+

代码

64-bit indexes ←→ 32-bit seqnos

//! Transform an "absolute" 64-bit sequence number (zero-indexed) into a WrappingInt32
//! \param n The input absolute 64-bit sequence number
//! \param isn The initial sequence number
WrappingInt32 wrap(uint64_t n, WrappingInt32 isn) {
    uint32_t tmp = (n & TAIL_MASK);
    return isn + tmp;
}

//! Transform a WrappingInt32 into an "absolute" 64-bit sequence number (zero-indexed)
//! \param n The relative sequence number
//! \param isn The initial sequence number
//! \param checkpoint A recent absolute 64-bit sequence number
//! \returns the 64-bit sequence number that wraps to `n` and is closest to `checkpoint`
//!
//! \note Each of the two streams of the TCP connection has its own ISN. One stream
//! runs from the local TCPSender to the remote TCPReceiver and has one ISN,
//! and the other stream runs from the remote TCPSender to the local TCPReceiver and
//! has a different ISN.
uint64_t unwrap(WrappingInt32 n, WrappingInt32 isn, uint64_t checkpoint) {
    uint32_t tmp_n = n.raw_value() - isn.raw_value();
    uint64_t res = (checkpoint & HEAD_MASK);
    uint32_t tmp_cp = (checkpoint & TAIL_MASK);

    res |= tmp_n;
    if(tmp_cp < FLAG){
        if(tmp_n > tmp_cp + FLAG){
            if(res >= HEAD_ONE) res -= HEAD_ONE;
        }
    }else if(tmp_cp > FLAG){
        if(tmp_n < tmp_cp - FLAG)       res += HEAD_ONE;
    }
    return res;
}
-

具体实现

#include "stream_reassembler.hh"
#include <iostream>
#include <map>

template <typename... Targs>
void DUMMY_CODE(Targs &&... /* unused */) {}

using namespace std;

StreamReassembler::StreamReassembler(const size_t capacity)
    : is_eof(false), left_bound(0), buffer(), _output(capacity), _capacity(capacity) {}

void StreamReassembler::push_substring(const string &data, const size_t index, const bool eof) {
    if (eof == 1)
        is_eof = true;

    size_t unass = unassembled_bytes();
    size_t remaining = _capacity > unass ? _capacity - unass : 0;  // how much room left?

    size_t left = index, right = index + data.length();  // 初始化左右区间
    size_t o_left = left, o_right = right;               // keep the original value
    auto iterator = buffer.begin();                 // 这些变量在这里声明是为了防止后面goto报错
    node tmp = {0, 0, ""};

    if (right < left_bound)	return;                // must be duplicated
    left = left < left_bound ? left_bound : left;  // 左边已经接受过的数据就不要了
    right = right <= left_bound + _capacity ? right : left_bound + _capacity;  // 右边越界的也不要
    o_right = right;
    string res = data.substr(left - o_left, right - left);

    size_t start = left;  // the begin of the unused data-zone of variable data
    if (data.compare("") == 0 || res.compare("") == 0)	goto end;  // 如果data是空串也直接不要
    if (o_left >= left_bound + _capacity)	goto end;  // 越界的不要

    // 开始区间合并。需要扫描两次
    for (auto it = buffer.begin(); it != buffer.end(); it++) {
        if (left >= it->left && left <= it->right) {
            size_t r = right;
            size_t l = left;
            right = max(right, it->right);
            left = min(left, it->left);
            if (right == it->right) {
                start = o_right;
            } else {
                start = it->right;
            }
            if (r <= it->right) {
                res = it->data.substr(0, l - it->left) + data.substr(l - o_left) +
                      it->data.substr(r - it->left, it->right - r);
            } else {
                res = it->data.substr(0, l - it->left) + data.substr(l - o_left);
            }
            // 删除这一步很关键。
            buffer.erase(it);
            break;
        }
    }

    // 第二次
    for (auto it = buffer.begin(); it != buffer.end(); it++) {
        if (it->left >= left && it->left <= right) {
            // 此时空间不够，先尝试下能不能写入一部分到_output中
            if (it->left > start && remaining < it->left - start) {
                if (left == left_bound) {
                    size_t out_mem = _output.remaining_capacity();
                    if (out_mem > 0) {
                        // out的区域本身就很充足
                        if (out_mem >= it->left - start) {
                            // 写入ByteStream
                            _output.write(res.substr(0, it->left - start));
                            // 更新
                            res = res.substr(it->left - start);
                            left_bound = it->left - start + left;
                            left = left_bound;
                            remaining += it->left - start;
                            // out剩下的空位会在最后写入
                            goto ok;
                        } else {
                            // 光是out不够的话，那就先能腾多少空间腾多少
                            _output.write(res.substr(0, out_mem));
                            res = res.substr(out_mem);
                            left_bound = out_mem + left;
                            left = left_bound;
                            remaining += out_mem;
                            // 如果腾出空间加上原来空间足够，那就非常ok
                            if (it->left > start && remaining >= it->left - start) {
                                goto ok;
                            }
                            // 否则进入错误处理代码
                        }
                    }
                }
                tmp = {left, start + remaining, res.substr(0, start - left + remaining)};
                remaining = 0;
                if (eof == 1)
                    is_eof = false;
                buffer.insert(tmp);
                goto end;
            }
        ok:
            remaining -= it->left - start;
            start = it->right;
            if (it->right > right){
                res += it->data.substr(right - it->left, it->right - right);
                right = it->right;
            }
            buffer.erase(it);
        }
    }
    
    if (start < o_right && remaining < o_right - start) {
        right = start + remaining;
        if (eof == 1)
            is_eof = false;
    }
    tmp = {left, right, res};
    if (left < right)
    	buffer.insert(tmp);

end:
    iterator = buffer.begin();
    // write into the ByteStream
    if (iterator != buffer.end() && iterator->left == left_bound) {
        size_t out_rem = _output.remaining_capacity();
        if (out_rem < iterator->data.length()) {
            _output.write(iterator->data.substr(0, out_rem));
            left_bound = iterator->left + out_rem;
            tmp = {left_bound, iterator->right, iterator->data.substr(out_rem)};
            buffer.erase(iterator);
            buffer.insert(tmp);
        } else {
            _output.write(iterator->data);
            left_bound = iterator->right;
            buffer.erase(iterator);
        }
    }

    // 满足两个条件才是真的eof
    if (is_eof && buffer.empty()){
        is_eof = false;
        _output.end_input();
    }
}

size_t StreamReassembler::unassembled_bytes() const {
    // 可以跟上面的write合起来的，但在此处我采取了最保守的做法。
    size_t res = 0;
    for (auto it = buffer.begin(); it != buffer.end(); it++) {
        res += it->right - it->left;
    }
    return res;
}

bool StreamReassembler::empty() const { return buffer.empty()&&is_eof; }
+

TCPReceiver

头文件

class TCPReceiver {
    StreamReassembler _reassembler;

    size_t _capacity;
    uint64_t ack = 0;
    WrappingInt32 isn = WrappingInt32(0);

    bool syn = false;
    bool fin = false;
// ...
+

具体实现

void TCPReceiver::segment_received(const TCPSegment &seg) {
    TCPHeader header = seg.header();
    WrappingInt32 seqno = header.seqno;
    string data = seg.payload().copy();
    size_t index = 0; // the param of the reassembler
    
    // LISTENING -> SYN_SENT
    if(!syn&&header.syn){ // is the first packet
        _reassembler.set_is_eof();// reset the eof flag
        fin = false;// reset the fin flag
        isn = header.seqno;
        seqno = seqno + 1; // plus one to skip the SYN byte
        syn = true;// mark the start of the byte stream
    }
    
    // must keep after the last if branch to avoid the case "flag = SF"
    // FIN_RECEIVED
    if(header.fin)      fin = true; 
    if(syn){
        uint64_t abs_seqno = unwrap(seqno,isn,ack);
        index = abs_seqno - 1;
        if (abs_seqno != 0)// write into the assembler
        	_reassembler.push_substring(data,index,header.fin);
        ack = _reassembler.get_left_bound() + 1;
        
        if (_reassembler.stream_out().input_ended() && fin)
            ack += 1;// plus one to skip the FIN byte
    }
}
optional<WrappingInt32> TCPReceiver::ackno() const {
    if(syn)     return wrap(ack,isn);
    else        return {};// empty
}

size_t TCPReceiver::window_size() const {
        return stream_out().remaining_capacity();
}
]]> + + + Lab6 Router + /2023/02/25/cs144$lab6/ + Lab6 Router

心得

要做什么

本次实验要实现的是IP层的路由工作，但是只用实现对路由表进行操作的部分，比如说增加表项以及查询路由表等，其他的什么RIP、OSPF都不用我们实现，所以这样一来其实就简单非常多了（）

+

有一点需要注意的是，它一直在强调一个“最长前缀匹配”。也就是：

+

image-20230309142032359

+

image-20230309141949757

+

还有一点需要注意的是路由的结构：

+

image-20230308142934287

+

实际上就是路由表+一堆网络接口，这些端口都是network interface。

+
+

路由器可分为两部分，一部分控制路由协议，包括完善路由表之类的；另一部分负责数据转发。

+

负责接收数据的端口既可能收到数据，也可能收到路由信息报文。收到前者，则需要查询转发表然后进行路由转发；收到后者，就需要将其交付给路由选择处理机进行处理。

+

它有一个地方说得很有意思：路由表需要对网络拓扑最优化，转发表需要使查找过程最优化

+

也就是说，路由表只是key为目的IP地址，value为下一跳IP地址的一个普通map，可以是unordered_map，因为无需对它进行查找操作；转发表的内容可能跟路由表差不多，但是由于它要被进行频繁的查找工作，因而其数据结构需要对查找的消耗较低。

+

不过在我们这边，一般不区分路由表和转发表的概念。

+
+

感想

说实话思路很直观很简单，懒得说了，直接看代码吧【开摆】

+

我唯一卡得比较久的有两个地方，一个是一开始数据结构选用的是set，图它的天然排序，针对prefix_length排序来优化查找，但是没有意识到，对于自定义比较运算符的结构体，set也是会自动去重的（）而不同路由项的prefix_length显然可以重复。因而这样是达咩的，最后不得已选用了一个普通的list。

+

另一个是子网掩码计算问题，刚开始一个小地方想错了。这个没什么好说的，纯纯脑子一抽。

+

代码

头文件

// ...
class Router {
    struct route_node {
        uint32_t route_prefix = 0;
        uint8_t prefix_length = 0;
        std::optional<Address> next_hop{};
        size_t interface_num = 0;
        // 降序
        bool operator<(const route_node &b) const { return prefix_length > b.prefix_length; }
    };

    std::list<route_node> route_table{};
// ...
+ +

具体实现

void Router::add_route(const uint32_t route_prefix,
                       const uint8_t prefix_length,
                       const optional<Address> next_hop,
                       const size_t interface_num) {
    cerr << "DEBUG: adding route " << Address::from_ipv4_numeric(route_prefix).ip() << "/" << int(prefix_length)
         << " => " << (next_hop.has_value() ? next_hop->ip() : "(direct)") << " on interface " << interface_num << "\n";
    // 添加
    route_node node;
    node.route_prefix = route_prefix;
    node.prefix_length = prefix_length;
    node.next_hop = next_hop;
    node.interface_num = interface_num;
    route_table.push_back(node);
    route_table.sort();
}

//! \param[in] dgram The datagram to be routed
void Router::route_one_datagram(InternetDatagram &dgram) {
    // 减少TTL
    if (dgram.header().ttl <= 1)
        return;  // drop
    dgram.header().ttl -= 1;

    const uint32_t target_ip = dgram.header().dst;
    for (auto it = route_table.begin(); it != route_table.end(); it++) {
        uint32_t mask = 0;
        mask = (((~mask) >> (32-it->prefix_length)) << (32-it->prefix_length));
        if (it->prefix_length == 0 || ((it->route_prefix & mask) == (target_ip & mask))){
            // 发送报文
            if (it->next_hop.has_value())
                interface(it->interface_num).send_datagram(dgram, it->next_hop.value());
            else
                interface(it->interface_num).send_datagram(dgram,
Address::from_ipv4_numeric(dgram.header().dst));
            return;  // 一定是最长前缀
        }
    }
}

void Router::route() {
    // Go through all the interfaces, and route every incoming datagram to its proper outgoing interface.
    for (auto &interface : _interfaces) {
        auto &queue = interface.datagrams_out();
        while (not queue.empty()) {
            route_one_datagram(queue.front());
            queue.pop();
        }
    }
}
]]> Lab3 TCPSender @@ -6599,237 +6647,44 @@ url访问填写http://localhost/webdemo4_war/*.do。

当timer触发时，我们需要重传tmp_segments 队列头。

如果空间足够，直接重传就行了，然后double RTO，然后用RTO reset timer，然后再次启动timer。

-

如果空间不足够，只做上面那个的后两步，也即reset timer，然后再次启动timer。

- -

  • ack_received

    -
      -

    1. 更新window_size和ackno

      -
      2. -

    2. 重置超时重传

      -

      如果接收到的ackno比以前的大，则重置RTO，重启timer（如果tmp_segments不为空），重置cons_retran

      -
      3. -

    3. 从tmp_segments中删除元素

      -
      4. -

    4. 调用fill_window

      -
      5. -
    -
    • -

  • fill_window

    -

    如果window_size - tmp_size <= 0 或者 byte stream空，则什么也不做

    -

    否则根据syn和fin标记创建一个new segment，然后写入out stream

    -
    -

    no bigger than the value given by TCPConfig::MAX PAYLOAD SIZE (1452 bytes)

    -
    -
    -

    If the receiver has announced a window size of zero, the fifill window method should act like the window size is one.

    -
    -
    • - -

    细节补充

    实现起来虽然很复杂，但思路确实很简单，正确思路和初见思路差不多，指导书写得很好很详细【以至于一开始我被指导书这么多内容给吓到了】。在这里只记录点实现过程中遇到的一些小错误以及我各个部分的实现细节补充。

    -

    timer实现

    指导书的建议是实现一个类，但是我太懒了（）而且确实这个timer的状态也很少，因而我就直接把它写在sender里面了。

    -

    SYN报文是否可以带数据

    此实验未涉及这个。本次全部的测试用例都是SYN报文不携带数据的情况。【因为发出syn报文之后才将window_size设置为非0情况】

    -

    如果需要SYN报文不携带数据，可以在fill_window中把这句话：

    -
    if (!(_stream.buffer_empty() || remaining == 0)) {
    - -

    修改为这句话：

    -
    if (!segment.header().syn&&!(_stream.buffer_empty() || remaining == 0)) {
    - -

    代码

    头文件

    class TCPSender {
      private:
        // our initial sequence number, the number for our SYN.
        WrappingInt32 _isn;

        // outbound queue of segments that the TCPSender wants sent
        std::queue<TCPSegment> _segments_out{};

        // retransmission timer for the connection
        unsigned int _initial_retransmission_timeout;// 初始的超时重传时间

        // outgoing stream of bytes that have not yet been sent
        ByteStream _stream;

        // the (absolute) sequence number for the next byte to be sent
        uint64_t _next_seqno{0};

        struct OutSegment { // outstanding segment的包装类
            TCPSegment segment;
            uint64_t seqno;
            size_t data_size;
        };
        std::list<OutSegment> tmp_segments{};// 内部存储结构
        size_t tmp_size = 0;// 存储结构中含有的segment的总字节数
        
        // 注意此处一定要初始化为1
        size_t window_size = 1;// 拥塞窗口大小
        uint64_t ackno = 0;// 最大的ackno
        size_t ticks = 0;// 从出生到当前经过的时间
        
        unsigned int cons_retran = 0;  // 超时重传连续次数
        unsigned int rto;// 当前超时重传时间
        bool timer_start = false;// 超时重传timer是否开启
        unsigned int timer_ticks = 0;// timer开启时的时间
        
        bool syn = false;// 是否发送了SYN报文
        bool fin = false;// 是否发送了FIN报文
      public:
        void send_empty_rst_segment();
        void send_empty_ack_segment(WrappingInt32 t_ackno);
        bool fully_acked() const { return _next_seqno == ackno; }
    - -

    具体实现

    TCPSender::TCPSender(const size_t capacity, const uint16_t retx_timeout, const std::optional<WrappingInt32> fixed_isn)
        : _isn(fixed_isn.value_or(WrappingInt32{random_device()()}))
        , _initial_retransmission_timeout{retx_timeout}
        , _stream(capacity)
        , rto{retx_timeout} {}

    uint64_t TCPSender::bytes_in_flight() const { return tmp_size; }

    // 尽可能地创造segment并且填充到segment output中
    void TCPSender::fill_window() {
        // should act like the window size is one
        size_t t_win_size = window_size == 0 ? 1 : window_size;
        size_t remaining = t_win_size - tmp_size;
        // 防止数值溢出的情况
        if (t_win_size < tmp_size)
            remaining = 0;

        // fill as possible
        while (remaining > 0) {
            // create and fill in a segment
            TCPSegment segment = TCPSegment();
            // 如果处于CLOSED状态
            if (!syn) {
                // 转移到SYN_SENT状态
                // first segment
                segment.header().syn = true;
                segment.header().seqno = _isn;
                remaining -= 1;
                syn = true;
                // should start the timer here
                rto = _initial_retransmission_timeout;
                timer_start = true;
                timer_ticks = ticks;
            }
            // fill in the payload
            if (!segment.header().syn && !(_stream.buffer_empty() || remaining == 0)) {
                string data = _stream.read(min(remaining, TCPConfig::MAX_PAYLOAD_SIZE));
                remaining -= data.length();
                Buffer buf = Buffer(move(data));
                segment.payload() = buf;
            }

            // 转移到FIN_SENT状态
            if (_stream.eof() && !fin && remaining > 0) {
                // last segment
                segment.header().fin = true;
                fin = true;
                remaining -= 1;
            }

            // segment为空（不为SYN、FIN，也不携带任何数据）
            if (segment.length_in_sequence_space() == 0)
                break;

            segment.header().seqno = wrap(_next_seqno, _isn);
            _next_seqno += segment.length_in_sequence_space();
            // push into the outstanding segments
            tmp_segments.push_back(
                {segment, unwrap(segment.header().seqno, _isn, _next_seqno), segment.length_in_sequence_space()});
            tmp_size += segment.length_in_sequence_space();
            // push into the segment out queue
            _segments_out.push(segment);
        }
    }

    void TCPSender::ack_received(const WrappingInt32 ack, const uint16_t wind_size) {
        window_size = wind_size;
        uint64_t a_ack = unwrap(ack, _isn, ackno);
        if (a_ack > _next_seqno)
            return;  // impossible ack is ignored
        if (a_ack > ackno) {
            // reset the retransmission
            rto = _initial_retransmission_timeout;
            timer_ticks = ticks;
            cons_retran = 0;
            // erase elements from the tmp_segments
            for (auto it = tmp_segments.begin(); it != tmp_segments.end();) {
                if (a_ack >= it->seqno + it->data_size) {
                    tmp_size -= (it->segment).length_in_sequence_space();
                    // 如果FIN报文被成功接收，就关闭timer
                    // FIN_ACKED
                    if (it->segment.header().fin)
                        timer_start = false;
                    it = tmp_segments.erase(it);
                } else
                    it++;
            }
        }
        ackno = a_ack;
        fill_window();
    }

    void TCPSender::tick(const size_t ms_since_last_tick) {
        if (ticks > ticks + ms_since_last_tick) {
            // 进行简单的溢出处理，还是有可能溢出
            ticks -= timer_ticks;
            timer_ticks = 0;
        }
        ticks += ms_since_last_tick;

        if (timer_start && ticks > timer_ticks && ticks - timer_ticks >= rto) {
            if (!tmp_segments.empty()) {
                // resend
                _segments_out.push(tmp_segments.front().segment);
                if (window_size != 0) {
                    cons_retran++;
                    rto *= 2;
                }
            }
            timer_ticks = ticks;
        }
    }

    unsigned int TCPSender::consecutive_retransmissions() const { return cons_retran; }

    /*  在TCPConnection中被使用的辅助方法们  */
    void TCPSender::send_empty_segment() {
        TCPSegment segment = TCPSegment();
        segment.header().seqno = wrap(_next_seqno, _isn);
        _segments_out.push(segment);
    }
    void TCPSender::send_empty_ack_segment(WrappingInt32 t_ackno) {
        TCPSegment segment = TCPSegment();
        segment.header().seqno = wrap(_next_seqno, _isn);
        segment.header().ack = true;
        segment.header().ackno = t_ackno;
        _segments_out.push(segment);
    }
    void TCPSender::send_empty_rst_segment() {
        TCPSegment segment = TCPSegment();
        segment.header().seqno = wrap(_next_seqno, _isn);
        segment.header().rst = true;
        _segments_out.push(segment);
    }
    ]]> - - - Lab4 TCPConnection - /2023/02/25/cs144$lab4/ - Lab4 TCPConnection

    心得

    耗时情况

    【长舒一口气】

    -

    最开始先记录下总体耗时情况吧。本次实验共耗费我16h+【不包括接下来写笔记的时间23333】，共耗费三个工作日。第一天看完了指导书，写完了代码，过掉了#45 reorder之前的所有测试。第二天过掉了#55 t_ucS_1M_32k之前的所有测试，直到第三天才过完了所有测试。

    -

    我觉得这整个过程还是挺有意义的，每天都有新的进展，看到test case越过越多是真的很高兴。但是可以说第二天以来就都是面向测试用例改bug了，非常折磨非常坐牢，既要去再次理清之前写过的shit山，又得搞清楚很多让人一头雾水不知从何下手的地方。但总之，这三天很充实，并不会让人觉得心累。

    -

    放个通关截图吧，感人至深。

    -

    image-20230305160608116

    -

    思路

    在TCPConnection中具体要做什么，指导书已经写得很详细了，跟着指导书就行。代码部分还是不折磨的，思路直观清晰。

    -

    指导书内容

    -

    Here are the basic rules the TCPConnection has to follow:

    -
    -
      -

    1. Receiving segments

      -

      大概是在segment_received中做

      -

      image-20230303103640065

      -
        -

      1. 检查RST flag

        -

        如果RST被设置，sets both the inbound and outbound streams to the error state，杀死当前connection

        -

        return;

        -

        具体实现中，杀死connection可以置_linger_after_streams_finish为false。 the inbound and outbound streams对应着receiver和sender里的stream。让它们都处于error状态，只需设置ByteStream中的error字段

        -
        2. -

      2. 如果收到的segment with an invalid sequence number，connection需要发送empty segment应答

        -

        image-20230303110238265

        -
        3. -

      3. 转发segment给receiver

        -
        4. -

      4. 如果ACK，则把ackno和win_size给sender

        -
        5. -
      -
      2. -

    2. Sending segments

      -
        -
      1. 任何时候sender把segment放进其out流，你都要从中取出来
        2. -
      2. 从receiver处获取ackno和window_size，填入segment中
        3. -
      3. 放到自己的segment_out中
        4. -
      -

      从上述表述中，我们需要注意两点：

      -
        -

      1. 顺带ACK

        -

        可以看到，这跟我们上课的时候所学的一样，是“顺带ACK”，也即ACK报文并非独立发送，而是在下一次要发送其他数据报文的时候携带发送。这也一定程度上使得ack报文发送不会太频繁也不会太稀疏。

        -
        2. -

      2. 一定要经由sender

        -

        我们如果想要发送一个报文，一定得先把它存入sender中，再从sender的segment_out中取出来。这样做的目的是把该报文列入sender的超时重传管辖范围，你如果直接把报文发送到自己的segment_out中，就无法管理其超时重传了

        -
        3. -
      -
      3. -

    3. When time passes

      -

      在tick()中

      -
        -
      1. 调用sender的tick()
        2. -
      2. 检查sender的连续超时重传次数，如果大于MAX RETX ATTEMPTS，则关闭连接，并且发送RST标志的空报文
        3. -
      3. end the connection cleanly if necessary
        4. -
      -
      4. -
    -

    再注意一点对于connection的关闭。它要求有一个time pass

    -

    image-20230303111131650

    -

    image-20230303112817891

    -

    第一点挺好实现的，第二点需要在析构函数中检测。

    -

    最后的5.1部分值得一看。

    -

    接口说明

    TCPConnection的public函数接口定义以及具体要做什么如下。结合上面的指导书内容，TCPConnection的实现就很简单了，我就不多bb了。

    -
     private:
       TCPConfig _cfg;
       // 一个endpoint可以同时作为sender和receiver。
       TCPReceiver _receiver{_cfg.recv_capacity};
       TCPSender _sender{_cfg.send_capacity, _cfg.rt_timeout, _cfg.fixed_isn};

       //! outbound queue of segments that the TCPConnection wants sent
       // 把要发送的segment放在这里就行了
       std::queue<TCPSegment> _segments_out{};

       //! Should the TCPConnection stay active (and keep ACKing)
       //! for 10 * _cfg.rt_timeout milliseconds after both streams have ended,
       //! in case the remote TCPConnection doesn't know we've received its whole stream?
       bool _linger_after_streams_finish{true};

     public:
       // 也许需要调用TCPSender的fill_window()，然后从其segment_out中取出来，再发送给自己的segment_out
       // Initiate a connection by sending a SYN segment初始化connection并且发送SYN
       void connect();

    /*  这几个都很好实现，都很直观，只需调sender和receiver的API就行  */
       // 由上层socket调用，data路径 socket->connection->sender.stream_in().write()
       //! \brief Write data to the outbound byte stream, and send it over TCP if possible
       //! \returns the number of bytes from `data` that were actually written.
       size_t write(const std::string &data);
       //! \returns the number of `bytes` that can be written right now.
       size_t remaining_outbound_capacity() const;
       //! \brief Shut down the outbound byte stream (still allows reading incoming data)
       void end_input_stream();
       //! \brief The inbound byte stream received from the peer
       ByteStream &inbound_stream() { return _receiver.stream_out(); }
       // number of bytes sent and not yet acknowledged, counting SYN/FIN each as one byte
       size_t bytes_in_flight() const;
       //! \brief number of bytes not yet reassembled
       size_t unassembled_bytes() const;

       //! \brief Number of milliseconds since the last segment was received
       size_t time_since_last_segment_received() const;

    // debug用
       //!< \brief summarize the state of the sender, receiver, and the connection
       TCPState state() const { return {_sender, _receiver, active(), _linger_after_streams_finish}; };

       // 这些函数都会由上层在某些时候调用
       // 时钟滴答、收到segment以及从segment_out中取数据，这些都是由os调用相应函数实现的
       // 这也正是所谓“协议”的接口意义！
       //! \name Methods for the owner or operating system to call
       //! Called when a new segment has been received from the network
       void segment_received(const TCPSegment &seg);

       //! Called periodically when time elapses
       void tick(const size_t ms_since_last_tick);

       //! \brief TCPSegments that the TCPConnection has enqueued for transmission.
       //! \note The owner or operating system will dequeue these and
       //! put each one into the payload of a lower-layer datagram (usually Internet datagrams (IP),
       //! but could also be user datagrams (UDP) or any other kind).
       std::queue<TCPSegment> &segments_out() { return _segments_out; }

       //! \brief Is the connection still alive in any way?
       //! \returns `true` if either stream is still running or if the TCPConnection is lingering
       //! after both streams have finished (e.g. to ACK retransmissions from the peer)
       bool active() const;

       //! Construct a new connection from a configuration
       explicit TCPConnection(const TCPConfig &cfg) : _cfg{cfg} {}

       //! \name construction and destruction
       //! moving is allowed; copying is disallowed; default construction not possible

       ~TCPConnection();  //!< destructor sends a RST if the connection is still open
       TCPConnection() = delete;
       TCPConnection(TCPConnection &&other) = default;
       TCPConnection &operator=(TCPConnection &&other) = default;
       TCPConnection(const TCPConnection &other) = delete;
       TCPConnection &operator=(const TCPConnection &other) = delete;
    - -

    测试程序

    这部分暂时还不大明白，随便瞎写一点（）

    -

    首先是socket实现，似乎要涉及到对一些事件，比如说segment receive的监听。它具体是这么做的：

    -
    // in libsponge/tcp_helper/tcp_sponge_socket.cc  _initialize_TCP()
        // Set up the event loop

        // There are four possible events to handle:
        //
        // 1) Incoming datagram received (needs to be given to
        //    TCPConnection::segment_received method)
        //
        // 2) Outbound bytes received from local application via a write()
        //    call (needs to be read from the local stream socket and
        //    given to TCPConnection::data_written method)
        //
        // 3) Incoming bytes reassembled by the TCPConnection
        //    (needs to be read from the inbound_stream and written
        //    to the local stream socket back to the application)
        //
        // 4) Outbound segment generated by TCP (needs to be
        //    given to underlying datagram socket)
    - -

    比如说event4：

    -

    image-20230304171810877

    -
    -

    什么是eventloop

    -

    事件循环（event loop）就是 任务在主线程不断进栈出栈的一个循环过程。任务会在将要执行时进入主线程，在执行完毕后会退出主线程。

    -

    这里的大致意思就是增加了一个监听事件，一旦tcp_connection的segments_out有元素，就会马上取出来

    -
    -

    这部分不大懂，不知道后面会不会涉及对socket的编写？

    -

    还有一点是对测试脚本好像有了点了解。比如在build/CTestTestfile.cmake中可以看到每个测试的对应脚本以及使用的options：

    -

    image-20230304170132380

    -

    如果不知道option的用法可以这么做：

    -

    image-20230305232621024

    -

    这些脚本实现的对应代码在sponge/apps中。

    -

    又比如，在sponge/etc/tests.cmake中，可以找到各个测试程序执行的参数，就可以比如说修改测试的Timeout时间：

    -

    image-20230305232913611

    -

    总结：状态机

    我们已经完整实现了整个TCP协议，是时候该对其做出一个总结了。

    -

    TCP协议本质上是一个状态机。

    -

    在我们的sponge TCP中，我们将一个endpoint的TCP协议分成了两个状态机，一个是TCPReceiver的状态机，另一个是TCPSender的状态机。它们依据外界的输入【从app或者互联网】来进行状态的转移。

    -

    以下几张图完美地体现了状态转移关系【具体的状态体现标注在代码中了】：

    -

    image-20230226200935395

    -

    image-20230226202631406

    -

    image-20230305225738049

    -

    image-20230225232723083

    -

    而TCPConnection并不是状态机，它是两个状态机和外界联通的桥梁。它的职能有：

    -
      -

    1. 给状态机提供输入

      -

      包括：

      -
        -
      1. app调用write传进来的数据
        2. -
      2. peer通过segment_received传进来的数据
        3. -
      +

      如果空间不足够，只做上面那个的后两步，也即reset timer，然后再次启动timer。

      2. -

    2. 处理状态机的输出

      -

      包括：

      +

    3. ack_received

        -
      1. app调用receiver的stream接口获取数据
        2. -
      2. 通过send_segment向peer传递数据
        3. -
      +

    4. 更新window_size和ackno

      +
      5. +

    5. 重置超时重传

      +

      如果接收到的ackno比以前的大，则重置RTO，重启timer（如果tmp_segments不为空），重置cons_retran

      +
      6. +

    6. 从tmp_segments中删除元素

      +
      7. +

    7. 调用fill_window

    -

    也可以说，它具有显式推动状态机状态转移的作用，比如说：

    -
      -
    1. 给状态机传递外界数据让他们转移
      2. -
    2. connect通过调用fill_window推动_sender从CLOSED状态转移到SYN_SENT状态
      3. -
    3. 转移到ERROR状态的条件判断
      4. -
    -

    等等等。

    -

    也因而，TCPConnection并不包含复杂的逻辑和算法，它仅仅是做一些条件判断，以及一些数据转发的工作。

    -

    喜闻乐见的bug合集

    相比于代码的编写，本次实验最难的部分是测试。由于lab4基于lab0-3，因而前面没有发现的bug在本次黑压压162个测试之下会全部涌现出来。有些bug我还是不知道怎么回事，并且debug过程也不像xv6那样条理清晰步步为营，感觉充满着不少玄幻色彩，所以也没有很多干货好说。在这里就先记录下印象比较深刻，耗时比较久的bug吧。

    -

    TCP produced ‘ackno=1’

    image-20230303214944132

    -

    需要发送一个ackno=2的帧，但是不知道为什么却发送了一个ackno=1的，并且无论我怎么找，在哪里print，都只能找到一个ackno=2的，连1的影子都看不到。这个现象确实很诡异，但其实它的内因很简单。它是由于我对空的ACK帧发送条件限制得不恰当才出现的。

    -
    -

    有没有觉得这里有点跳跃？我是怎么通过这个现象得知是ACK发送不恰当导致的？

    -

    答案是我当时也没想到这一点，无头苍蝇般转了可能有一个小时，这里print一下那里print一下都没有发现异常。最后我放弃了这个用例去看下一个错误的用例，才发现了这个小bug，改了一下发现这个也一起过了【绷】

    -
    -

    本来我是这么写的：

    -
    // 把_sender的所有segment都发送出去
    void TCPConnection::segment_send() {
        // 当没有要发送的帧，无法进行顺带ACK时，就只能发送一个只有ACK的空帧
        if (_sender.segments_out().empty()) {
            if (_receiver.ackno().has_value()) {
                _sender.send_empty_ack_segment(_receiver.ackno().value());
            }
        }
        while (!_sender.segments_out().empty()) {
            // ...
        }
    }

    // in segment_received()
        //if (seg.length_in_sequence_space() != 0) {
        //    empty_ack_send();
        //}
        segment_send();
    - -

    如果这么写的话，当这台endpoint收到peer的一个empty ACK后，它就也会以示敬意回复一个empty ACK，这样除了本应发过去的ackno=2的报文，就多了个幽灵般的ackno=1的empty ACK，从而导致上面的错误。

    -

    因而，正确的做法是，我们在receive时只对**!empty**的seg进行ACK回复就行。具体写法可以看看我下面的代码。

    -

    超时重传时间翻倍问题

    image-20230303224104016

    -

    image-20230303224053277

    -

    可以看到，它是想要我们在1000ms后再发一次FIN的，也即rto依然等于1000，但是我们的rto却是2000.为啥呢？那就去看看超时重传呗。

    -

    原来的超时重传代码：

    -
    // in libsponge/tcp_sender.cc
    if (timer_start && ticks > timer_ticks && ticks - timer_ticks >= rto) {
        // resend
        if (!tmp_segments.empty()) {
            _segments_out.push(tmp_segments.front().segment);
        }

        if (window_size != 0) {
            cons_retran++;
            rto *= 2;
        }
        timer_ticks = ticks;
    }
    - -

    改完后：

    -
    if (timer_start && ticks > timer_ticks && ticks - timer_ticks >= rto) {
        if (!tmp_segments.empty()) {
            // resend
            _segments_out.push(tmp_segments.front().segment);

            if (window_size != 0) {
                cons_retran++;
                rto *= 2;
            }
        }
        timer_ticks = ticks;
    }
    - -

    想想超时重传的定义，是不是重传了之后才会double时间呀（）

    -

    assembler

    image-20230304163111298

    -

    这个test花了我半个下午的时间排查和修改。大致流程及报错信息是，一方发了65000个byte，但是另一方只能收到<<65000个。最后print了一下，发现是streamassembler写错了，在stream end的时候仍然有很大一部分数据未被整流。

    -
    -

    这个直面屎山的经历极大地鼓舞了我

    -
    -

    之前在写streamassembler的时候就知道有个地方是错的了，那就是我对capacity的理解【具体见前面的笔记】。现在只用改一下就好了。修改方式很简单，加上这两句话就行：

    -
    right = right <= left_bound + _capacity ? right : left_bound + _capacity;  // 右边越界的也不要
    if (o_left >= left_bound + _capacity)       goto end;  // 越界的不要
    - -

    t_udp_client_send超时

    image-20230304215748823

    -

    这个错因非常地诡异，我到最后也还是没有自己找出来。直到我瞎搜来搜去看到了这篇文章：

    + +

  • fill_window

    +

    如果window_size - tmp_size <= 0 或者 byte stream空，则什么也不做

    +

    否则根据syn和fin标记创建一个new segment，然后写入out stream

    -

    我也是真的很佩服这篇文章的作者能找到这个点

    -

    image-20230304221420748

    -

    https://www.cnblogs.com/lawliet12/p/17066719.html

    +

    no bigger than the value given by TCPConfig::MAX PAYLOAD SIZE (1452 bytes)

    -

    image-20230305215310021

    -

    噔噔咚。

    -

    我为什么不用_cfg.rt_timeout呢？答案是我当初脑子一抽以为rt_timeout是static、const的，就写了个TCPConfig::rt_timeout然后报错了，我懒得思考了就换成了上面的那个，结果……就这东西，又花费了我好久好久【悲】怪我没有认真看，没发现rt_timeout不是一个静态常量。

    -

    t_ucS_1M_32K超时

    image-20230305162239877

    -

    以及其后面的其他test也都超时了。

    -

    说实话我真是百思不得其解，这里打印来那里打印去，也都看得眼花缭乱什么也看不出来，使用指导书那些手动测试的方法，还有抓包，都十分地正常，但它自动测试就是会timeout。

    -

    我折腾来折腾去，这里print那里print，最后还怀疑是电脑问题就放到服务器上跑了一下结果还是不行。绝望之际，我只能使出了万策尽之时的迫不得已的非法手段：将我的一部分代码替换成别人的看看会怎么样。【传统艺能23333】

    -

    最终我定位发现是TCPSender出了问题，我猜测是因为状态机出错了。我比对着别人的代码【知道这不对，但我心态已经崩了。。。】，以及指导书提供的状态机，发现是这个地方出了小问题：

    -

    image-20230305220614819

    -
    // in tcp_sender.cc fill_window()
    		// 注释的是以前写的错误版本
            // if (_stream.input_ended() && !fin && remaining > 0) {
            if (_stream.eof() && !fin && remaining > 0) {
                // last segment
                segment.header().fin = true;
                fin = true;
                remaining -= 1;
            }
    - -

    这里不应该是input_ended，而应该是eof……

    -

    改了之后立刻所有测试都能跑通了【悲】

    -

    那么问题来了，为什么错误版本就会timeout呢？我的猜测如下：

    -

    eof的条件如下：

    -
    bool ByteStream::eof() const { return is_input_end && buffer.empty(); }
    - -

    可以看到，eof既要求input_ended，又要求缓冲区内所有数据成功发送。这也很符合FIN_SENT的语义：在数据流终止时（所有数据成功发送，不要求fully acked）发送FIN。

    -

    如果按照我错误版本的写法，会导致数据还没发送完毕（!buffer.empty()），就发送了FIN。之后数据虽然还能正常进入receiver的bytestream，并且发送给peer的receiver。但是会存在这也一个空窗期：FIN之后的数据还没到的时候，peer的receiver接收到FIN，并且peer的app从socket将receiver接收到的数据全部读出。出现了这样的空窗期，就会导致peer的receiver的stream达到eof状态：

    -
    // in tcp_receiver.cc segment_received()
         if (abs_seqno != 0)
             _reassembler.push_substring(data, index, header.fin);
    // in streamassembler.cc
     if (is_eof && buffer.empty()) {
         _output.end_input();
     }
    - -

    【接下来就是猜了】由于bytestream eof了，socket就停止读了。后来的数据再来，receiver的stream的缓冲区就满了，receiver就只能一直丢包。【接下来是真的纯猜】而且由于测试脚本问题，在这之后都不会调用tick方法了，故而超时重传检测不会被触发，而sender也会因为没有ack，而一直重传重传，就死循环然后timeout寄掉了。

    -

    纯猜部分的依据是：

    -

    image-20230305173110776

    -

    image-20230305173152469

    -

    可以看到，tick方法一直被调用，但是ticks却不变。数据报文一直被重传，但是retran一直不变。ticks-timer_ticks一直大于rto，但却始终无法进入那句if（经测试是这样的）。这非常奇怪，我也不知道为什么。

    +

    If the receiver has announced a window size of zero, the fifill window method should act like the window size is one.

    -

    代码

    【珍贵的调试用代码没删的版本放在github了。】

    -

    TCPConnection.hh

    class TCPConnection {
      private:
    // ...
        size_t rec_tick{};// 上一次收到segment时的ticks数
        size_t ticks = 0;
      public:
        void segment_send();
        void empty_ack_send();
        void set_rst();
    // ...
    +
    • + +

    细节补充

    实现起来虽然很复杂，但思路确实很简单，正确思路和初见思路差不多，指导书写得很好很详细【以至于一开始我被指导书这么多内容给吓到了】。在这里只记录点实现过程中遇到的一些小错误以及我各个部分的实现细节补充。

    +

    timer实现

    指导书的建议是实现一个类，但是我太懒了（）而且确实这个timer的状态也很少，因而我就直接把它写在sender里面了。

    +

    SYN报文是否可以带数据

    此实验未涉及这个。本次全部的测试用例都是SYN报文不携带数据的情况。【因为发出syn报文之后才将window_size设置为非0情况】

    +

    如果需要SYN报文不携带数据，可以在fill_window中把这句话：

    +
    if (!(_stream.buffer_empty() || remaining == 0)) {
    -

    TCPConnection.cc

    如果想要以状态机的视角来看待，可以看看感恩的代码。他写得很清晰。

    -
    #include "tcp_connection.hh"
    #include <iostream>

    template <typename... Targs>
    void DUMMY_CODE(Targs &&... /* unused */) {}

    using namespace std;

    size_t TCPConnection::remaining_outbound_capacity() const { return _sender.stream_in().remaining_capacity(); }

    size_t TCPConnection::bytes_in_flight() const { return _sender.bytes_in_flight(); }

    size_t TCPConnection::unassembled_bytes() const { return _receiver.unassembled_bytes(); }

    size_t TCPConnection::time_since_last_segment_received() const { return ticks - rec_tick; }

    // 发送一个只有ACK的空帧，仅在segment_received中调用
    // 当没有要发送的帧，无法进行顺带ACK时，
    // 为了保障一定有ACK发送，就只能发送一个只有ACK的空帧
    void TCPConnection::empty_ack_send() {
        if (_sender.segments_out().empty()) {
            if (_receiver.ackno().has_value()) {
                _sender.send_empty_ack_segment(_receiver.ackno().value());
            }
        }
    }

    // 把_sender的所有segment都发送出去
    void TCPConnection::segment_send() {
        while (!_sender.segments_out().empty()) {
            TCPSegment seg = _sender.segments_out().front();
            // 顺带ACK
            if (_receiver.ackno().has_value()) {
                seg.header().ack = true;
                seg.header().ackno = _receiver.ackno().value();
            }
            seg.header().win = _receiver.window_size();
            _segments_out.push(seg);
            _sender.segments_out().pop();
        }
    }

    // connection被置为error状态的部分必要操作
    void TCPConnection::set_rst() {
        _sender.stream_in().set_error();
        _receiver.stream_out().set_error();
        _linger_after_streams_finish = false;
    }

    void TCPConnection::segment_received(const TCPSegment &seg) {
        // 重置发送的ticks
        rec_tick = ticks;
        
        if (seg.header().rst) {
            // RST is set
            set_rst();
            return;
        }
        
        // 回复对方问你是死是活的信息
        if (_receiver.ackno().has_value() && seg.length_in_sequence_space() == 0 &&
            seg.header().seqno - _receiver.ackno().value() < 0) {
            _sender.send_empty_segment();
            segment_send();
            return;
        }
        
        _receiver.segment_received(seg);
        
        if (seg.header().ack) { // ack_received也会调用fill_window
            _sender.ack_received(seg.header().ackno, seg.header().win);
        } else
            _sender.fill_window();
        
    	// 只在本次收到的seg需要被ACK的时候才要ACK。
        // 需要被ACK：FIN/SYN/携带数据   总之就是length!=0
        // 不得不说，FIN和SYN都会占一个序列号这个点给ACK设计带来了简便，同时也增加了安全性
        if (seg.length_in_sequence_space() != 0) {
            empty_ack_send();
        }
        
        segment_send();
        
        // If the inbound stream ends before the TCPConnection has reached EOF 
        // on its outbound stream, this variable needs to be set to false
        // 如果receiver的那个stream比sender的stream早结束，就不用等待
        // 为什么呢？因为receiver的stream结束说明了全部的seg都成功接收并且全部整流【参见assembler实现】
        // 也就说明对方不发送数据了，并且已经把FIN也发过来了
        // 也即对方进入了FIN_WAIT状态
        // 而我们的sender还在输出，也即我们在CLOSE_WAIT状态
        // 因而我们只需输出完剩余数据再发送AF,最后直接关闭就行
        // 因为我们知道对方已经关闭了，无需再进行linger。
        if (_receiver.stream_out().input_ended() && !_sender.stream_in().eof()) {
            // peer:FIN_WAIT   self:CLOSE_WAIT
            _linger_after_streams_finish = false;
        }
    }

    bool TCPConnection::active() const{
        // 处于error状态
        if (!_linger_after_streams_finish && _receiver.stream_out().error() && _sender.stream_in().error()) {
            return false;
        }
        
        // 满足条件1-3
        if (_receiver.stream_out().input_ended() &&
            _sender.stream_in().eof() && _sender.bytes_in_flight() == 0 && _sender.fully_acked()) {
            // 无需等待的话就直接返回false
            if (!_linger_after_streams_finish)
                return false;
            // 否则需要等待10*timeout
            else if (time_since_last_segment_received() >= 10 * _cfg.rt_timeout){
                return false;
    		}
        }
        return true;
    }

    size_t TCPConnection::write(const string &data) {
        size_t res = _sender.stream_in().write(data);
        // 注意此处需要手动调一下fill_window和send方法
        _sender.fill_window();
        segment_send();
        return res;
    }

    // ms_since_last_tick: number of milliseconds since the last call to this method
    void TCPConnection::tick(const size_t ms_since_last_tick) {
        ticks += ms_since_last_tick;
        _sender.tick(ms_since_last_tick);
        if (_sender.consecutive_retransmissions() > _cfg.MAX_RETX_ATTEMPTS) {
            while (!_sender.segments_out().empty())
                _sender.segments_out().pop();  // 清除sender遗留的所有帧
            _sender.send_empty_rst_segment();// 只发送rst帧
            set_rst();
        }
        segment_send();
        
        // end the connection cleanly if necessary
        if (_receiver.stream_out().input_ended() &&
            _sender.stream_in().eof() && _sender.bytes_in_flight() == 0 && _sender.fully_acked()
    	&& time_since_last_segment_received() >= 10 * _cfg.rt_timeout) {
            // 等待结束
    	    _linger_after_streams_finish = false;
        }

    }

    void TCPConnection::end_input_stream() {
        _sender.stream_in().end_input();
        _sender.fill_window();
        segment_send();
    }

    void TCPConnection::connect() {
        _sender.fill_window();
        // send_segment重复代码。目的是防止发送SYN外还发送别的东西
        if (!_sender.segments_out().empty()) {
            TCPSegment seg = _sender.segments_out().front();
            if (_receiver.ackno().has_value()) {
                seg.header().ack = true;
                seg.header().ackno = _receiver.ackno().value();
            }
            seg.header().win = _receiver.window_size();
            _segments_out.push(seg);
            _sender.segments_out().pop();
        }
    }

    TCPConnection::~TCPConnection() {
        try {
            // shutdown uncleanly
            if (active()) {
    	    	set_rst();
                _sender.send_empty_rst_segment();
                segment_send();
            }
        } catch (const exception &e) {
            std::cerr << "Exception destructing TCP FSM: " << e.what() << std::endl;
        }
    }
    +

    修改为这句话：

    +
    if (!segment.header().syn&&!(_stream.buffer_empty() || remaining == 0)) {
    -

    debug函数

    // in libsponge/tcp_helper/tcp_segment.hh
    void print_seg() const{
             std::cerr<<"  flag="<<(header().syn?"S":"")<<(header().ack?"A":"")<<(header().fin?"F":"")
                <<"  seqno="<<header().seqno.raw_value()<<"   ackno="<<header().ackno.raw_value()
                <<"  payload_size:"<<payload().size()<<std::endl;
    }
    +

    代码

    头文件

    class TCPSender {
      private:
        // our initial sequence number, the number for our SYN.
        WrappingInt32 _isn;

        // outbound queue of segments that the TCPSender wants sent
        std::queue<TCPSegment> _segments_out{};

        // retransmission timer for the connection
        unsigned int _initial_retransmission_timeout;// 初始的超时重传时间

        // outgoing stream of bytes that have not yet been sent
        ByteStream _stream;

        // the (absolute) sequence number for the next byte to be sent
        uint64_t _next_seqno{0};

        struct OutSegment { // outstanding segment的包装类
            TCPSegment segment;
            uint64_t seqno;
            size_t data_size;
        };
        std::list<OutSegment> tmp_segments{};// 内部存储结构
        size_t tmp_size = 0;// 存储结构中含有的segment的总字节数
        
        // 注意此处一定要初始化为1
        size_t window_size = 1;// 拥塞窗口大小
        uint64_t ackno = 0;// 最大的ackno
        size_t ticks = 0;// 从出生到当前经过的时间
        
        unsigned int cons_retran = 0;  // 超时重传连续次数
        unsigned int rto;// 当前超时重传时间
        bool timer_start = false;// 超时重传timer是否开启
        unsigned int timer_ticks = 0;// timer开启时的时间
        
        bool syn = false;// 是否发送了SYN报文
        bool fin = false;// 是否发送了FIN报文
      public:
        void send_empty_rst_segment();
        void send_empty_ack_segment(WrappingInt32 t_ackno);
        bool fully_acked() const { return _next_seqno == ackno; }
    -

    in libsponge/tcp_helper/fd_adapter.cc

    -

    image-20230304172207234

    -]]>     +

    具体实现

    TCPSender::TCPSender(const size_t capacity, const uint16_t retx_timeout, const std::optional<WrappingInt32> fixed_isn)
        : _isn(fixed_isn.value_or(WrappingInt32{random_device()()}))
        , _initial_retransmission_timeout{retx_timeout}
        , _stream(capacity)
        , rto{retx_timeout} {}

    uint64_t TCPSender::bytes_in_flight() const { return tmp_size; }

    // 尽可能地创造segment并且填充到segment output中
    void TCPSender::fill_window() {
        // should act like the window size is one
        size_t t_win_size = window_size == 0 ? 1 : window_size;
        size_t remaining = t_win_size - tmp_size;
        // 防止数值溢出的情况
        if (t_win_size < tmp_size)
            remaining = 0;

        // fill as possible
        while (remaining > 0) {
            // create and fill in a segment
            TCPSegment segment = TCPSegment();
            // 如果处于CLOSED状态
            if (!syn) {
                // 转移到SYN_SENT状态
                // first segment
                segment.header().syn = true;
                segment.header().seqno = _isn;
                remaining -= 1;
                syn = true;
                // should start the timer here
                rto = _initial_retransmission_timeout;
                timer_start = true;
                timer_ticks = ticks;
            }
            // fill in the payload
            if (!segment.header().syn && !(_stream.buffer_empty() || remaining == 0)) {
                string data = _stream.read(min(remaining, TCPConfig::MAX_PAYLOAD_SIZE));
                remaining -= data.length();
                Buffer buf = Buffer(move(data));
                segment.payload() = buf;
            }

            // 转移到FIN_SENT状态
            if (_stream.eof() && !fin && remaining > 0) {
                // last segment
                segment.header().fin = true;
                fin = true;
                remaining -= 1;
            }

            // segment为空（不为SYN、FIN，也不携带任何数据）
            if (segment.length_in_sequence_space() == 0)
                break;

            segment.header().seqno = wrap(_next_seqno, _isn);
            _next_seqno += segment.length_in_sequence_space();
            // push into the outstanding segments
            tmp_segments.push_back(
                {segment, unwrap(segment.header().seqno, _isn, _next_seqno), segment.length_in_sequence_space()});
            tmp_size += segment.length_in_sequence_space();
            // push into the segment out queue
            _segments_out.push(segment);
        }
    }

    void TCPSender::ack_received(const WrappingInt32 ack, const uint16_t wind_size) {
        window_size = wind_size;
        uint64_t a_ack = unwrap(ack, _isn, ackno);
        if (a_ack > _next_seqno)
            return;  // impossible ack is ignored
        if (a_ack > ackno) {
            // reset the retransmission
            rto = _initial_retransmission_timeout;
            timer_ticks = ticks;
            cons_retran = 0;
            // erase elements from the tmp_segments
            for (auto it = tmp_segments.begin(); it != tmp_segments.end();) {
                if (a_ack >= it->seqno + it->data_size) {
                    tmp_size -= (it->segment).length_in_sequence_space();
                    // 如果FIN报文被成功接收，就关闭timer
                    // FIN_ACKED
                    if (it->segment.header().fin)
                        timer_start = false;
                    it = tmp_segments.erase(it);
                } else
                    it++;
            }
        }
        ackno = a_ack;
        fill_window();
    }

    void TCPSender::tick(const size_t ms_since_last_tick) {
        if (ticks > ticks + ms_since_last_tick) {
            // 进行简单的溢出处理，还是有可能溢出
            ticks -= timer_ticks;
            timer_ticks = 0;
        }
        ticks += ms_since_last_tick;

        if (timer_start && ticks > timer_ticks && ticks - timer_ticks >= rto) {
            if (!tmp_segments.empty()) {
                // resend
                _segments_out.push(tmp_segments.front().segment);
                if (window_size != 0) {
                    cons_retran++;
                    rto *= 2;
                }
            }
            timer_ticks = ticks;
        }
    }

    unsigned int TCPSender::consecutive_retransmissions() const { return cons_retran; }

    /*  在TCPConnection中被使用的辅助方法们  */
    void TCPSender::send_empty_segment() {
        TCPSegment segment = TCPSegment();
        segment.header().seqno = wrap(_next_seqno, _isn);
        _segments_out.push(segment);
    }
    void TCPSender::send_empty_ack_segment(WrappingInt32 t_ackno) {
        TCPSegment segment = TCPSegment();
        segment.header().seqno = wrap(_next_seqno, _isn);
        segment.header().ack = true;
        segment.header().ackno = t_ackno;
        _segments_out.push(segment);
    }
    void TCPSender::send_empty_rst_segment() {
        TCPSegment segment = TCPSegment();
        segment.header().seqno = wrap(_next_seqno, _isn);
        segment.header().rst = true;
        _segments_out.push(segment);
    }
    ]]>     Lab5 NetworkInterface @@ -6978,74 +6833,6 @@ url访问填写http://localhost/webdemo4_war/*.do。

    具体实现

    #include "network_interface.hh"
    #include "arp_message.hh"
    #include "ethernet_frame.hh"
    #include <iostream>

    template <typename... Targs>
    void DUMMY_CODE(Targs &&... /* unused */) {}

    using namespace std;


    NetworkInterface::NetworkInterface(const EthernetAddress &ethernet_address, const Address &ip_address)
        : _ethernet_address(ethernet_address), _ip_address(ip_address) { }

    // param: target ip address , target ethernet address , and the arp opcode
    // if is the request, pass BROADCAST as the param;
    // if is the response, pass arprequest.eth_add as the param.
    void NetworkInterface::send_arp(uint32_t target_ip, EthernetAddress eth_add, uint16_t opcode) {
        // create the eth frame
        EthernetFrame frame;
        /* create the payload */
        // create the arp message
        ARPMessage arp_mes;
        arp_mes.sender_ethernet_address = _ethernet_address;
        arp_mes.sender_ip_address = _ip_address.ipv4_numeric();
        arp_mes.opcode = opcode;
        arp_mes.target_ip_address = target_ip;
        if (opcode == ARPMessage::OPCODE_REPLY)
            arp_mes.target_ethernet_address = eth_add;
        else // if is the REQUEST, arp target mac is unknown and should be set to zero
            arp_mes.target_ethernet_address = {0, 0, 0, 0, 0, 0};
        // serialize and put it into the payload
        frame.payload() = BufferList(arp_mes.serialize());
        /* fill in the header */
        EthernetHeader header;
        header.src = _ethernet_address;
        header.dst = eth_add;
        header.type = EthernetHeader::TYPE_ARP;
        frame.header() = header;

        // send it
        _frames_out.push(frame);
    }

    //! \param[in] dgram the IPv4 datagram to be sent
    //! \param[in] next_hop the IP address of the interface to send it to (typically a router or default gateway, but may also be another host if directly connected to the same network as the destination)
    //! (Note: the Address type can be converted to a uint32_t (raw 32-bit IP address) with the Address::ipv4_numeric() method.)
    // 处理从上层协议接收到的信息
    void NetworkInterface::send_datagram(const InternetDatagram &dgram, const Address &next_hop) {
        // convert IP address of next hop to raw 32-bit representation (used in ARP header)
        const uint32_t next_hop_ip = next_hop.ipv4_numeric();
        // create the eth frame
        EthernetFrame frame;
        // fill in the payload
        frame.payload() = dgram.serialize();
        // fill in the header
        EthernetHeader header;
        // dst is reserved
        header.src = _ethernet_address;
        header.type = EthernetHeader::TYPE_IPv4;

        auto tmp_arp = arp_mappings.find(next_hop_ip);// find the mac from the arp mappings
        if (tmp_arp == arp_mappings.end()) {  // not exist
            frame.header() = header;          // remember that the dst field is reserved
            auto tmp_wait = waiting_frames.find(next_hop_ip);// is there a waiting queue?
            // the arp request hasn't been sent if there is not a waiting queue, 
            if (tmp_wait == waiting_frames.end()) {
                // create the waiting queue
                vector<EthernetFrame> frames;
                frames.push_back(frame);
                waiting_node node;
                node.frames = frames;
                node.latest_ticks = ticks;
                waiting_frames.insert(make_pair(next_hop_ip, node));
                // send arp request
                send_arp(next_hop_ip, ETHERNET_BROADCAST, ARPMessage::OPCODE_REQUEST);
            } else { // the arp request has been sended
                if (ticks - tmp_wait->second.latest_ticks > 5*1000) {// send before 5 seconds
                    // resend arp request
                    send_arp(next_hop_ip, ETHERNET_BROADCAST, ARPMessage::OPCODE_REQUEST);
                    // update the time only when the arp request was sent
                    tmp_wait->second.latest_ticks = ticks;  
                }
                tmp_wait->second.frames.push_back(frame);// add the frame to the waiting list
            }
            return;
        }
        // recall that the dst field is reserved
        header.dst = tmp_arp->second.mac;
        frame.header() = header;

        // send it right away
        _frames_out.push(frame);
    }

    //! \param[in] frame the incoming Ethernet frame
    optional<InternetDatagram> NetworkInterface::recv_frame(const EthernetFrame &frame) {
        if (frame.header().dst != _ethernet_address && frame.header().dst != ETHERNET_BROADCAST)
            return {};  // should not accept
        if (frame.header().type == EthernetHeader::TYPE_IPv4) {
            InternetDatagram ip_data;
            ParseResult res = ip_data.parse(frame.payload());
            if (res == ParseResult::NoError) {
                return ip_data; // return to send it to the upper protocal
            } else
                return {};
        }
        if (frame.header().type != EthernetHeader::TYPE_ARP)
            return {};
        
        ARPMessage arp_mes;
        ParseResult res = arp_mes.parse(frame.payload());
        if (res != ParseResult::NoError)
            return {};
        // I'm not the arp target
        if (arp_mes.target_ip_address != _ip_address.ipv4_numeric())
            return {};
        
        auto tmp_arp = arp_mappings.find(arp_mes.sender_ip_address);
        if (tmp_arp == arp_mappings.end()) {  // arp mapping not exist, create one
            arp_node node;
            node.ticks = ticks;
            node.mac = arp_mes.sender_ethernet_address;
            arp_mappings.insert(make_pair(arp_mes.sender_ip_address, node));
        } else {
            tmp_arp->second.ticks = ticks;  // update the record ticks
        }
        if (arp_mes.opcode == ARPMessage::OPCODE_REQUEST) {
            send_arp(arp_mes.sender_ip_address, arp_mes.sender_ethernet_address, ARPMessage::OPCODE_REPLY);
            // shouldn't return now, maybe we are also waiting for the sender's mac address
            // return {};
        }
        // send all frames in the waiting queue
        auto tmp_wait = waiting_frames.find(arp_mes.sender_ip_address);
        // have no frames waiting for the address
        if (tmp_wait == waiting_frames.end())
            return {};
        while (!tmp_wait->second.frames.empty()) {
            EthernetFrame f = tmp_wait->second.frames.back();
            // recall that the dst field is reserved
            f.header().dst = arp_mes.sender_ethernet_address;  
            _frames_out.push(f);
            tmp_wait->second.frames.pop_back();
        }
        // erase all the waiting frames
        waiting_frames.erase(tmp_wait);
        return {};
    }

    //! \param[in] ms_since_last_tick the number of milliseconds since the last call to this method
    void NetworkInterface::tick(const size_t ms_since_last_tick) {
        ticks += ms_since_last_tick;
        // walk the arp mappings to check whether a mapping is out-of-date
        for (auto it = arp_mappings.begin(); it != arp_mappings.end();) {
            if (ticks - it->second.ticks > 30 * 1000) {
                it = arp_mappings.erase(it);
            } else
                it++;
        }
    }
    ]]>     - - Lab6 Router - /2023/02/25/cs144$lab6/ - Lab6 Router

    心得

    要做什么

    本次实验要实现的是IP层的路由工作，但是只用实现对路由表进行操作的部分，比如说增加表项以及查询路由表等，其他的什么RIP、OSPF都不用我们实现，所以这样一来其实就简单非常多了（）

    -

    有一点需要注意的是，它一直在强调一个“最长前缀匹配”。也就是：

    -

    image-20230309142032359

    -

    image-20230309141949757

    -

    还有一点需要注意的是路由的结构：

    -

    image-20230308142934287

    -

    实际上就是路由表+一堆网络接口，这些端口都是network interface。

    -
    -

    路由器可分为两部分，一部分控制路由协议，包括完善路由表之类的；另一部分负责数据转发。

    -

    负责接收数据的端口既可能收到数据，也可能收到路由信息报文。收到前者，则需要查询转发表然后进行路由转发；收到后者，就需要将其交付给路由选择处理机进行处理。

    -

    它有一个地方说得很有意思：路由表需要对网络拓扑最优化，转发表需要使查找过程最优化

    -

    也就是说，路由表只是key为目的IP地址，value为下一跳IP地址的一个普通map，可以是unordered_map，因为无需对它进行查找操作；转发表的内容可能跟路由表差不多，但是由于它要被进行频繁的查找工作，因而其数据结构需要对查找的消耗较低。

    -

    不过在我们这边，一般不区分路由表和转发表的概念。

    -
    -

    感想

    说实话思路很直观很简单，懒得说了，直接看代码吧【开摆】

    -

    我唯一卡得比较久的有两个地方，一个是一开始数据结构选用的是set，图它的天然排序，针对prefix_length排序来优化查找，但是没有意识到，对于自定义比较运算符的结构体，set也是会自动去重的（）而不同路由项的prefix_length显然可以重复。因而这样是达咩的，最后不得已选用了一个普通的list。

    -

    另一个是子网掩码计算问题，刚开始一个小地方想错了。这个没什么好说的，纯纯脑子一抽。

    -

    代码

    头文件

    // ...
    class Router {
        struct route_node {
            uint32_t route_prefix = 0;
            uint8_t prefix_length = 0;
            std::optional<Address> next_hop{};
            size_t interface_num = 0;
            // 降序
            bool operator<(const route_node &b) const { return prefix_length > b.prefix_length; }
        };

        std::list<route_node> route_table{};
    // ...
    - -

    具体实现

    void Router::add_route(const uint32_t route_prefix,
                           const uint8_t prefix_length,
                           const optional<Address> next_hop,
                           const size_t interface_num) {
        cerr << "DEBUG: adding route " << Address::from_ipv4_numeric(route_prefix).ip() << "/" << int(prefix_length)
             << " => " << (next_hop.has_value() ? next_hop->ip() : "(direct)") << " on interface " << interface_num << "\n";
        // 添加
        route_node node;
        node.route_prefix = route_prefix;
        node.prefix_length = prefix_length;
        node.next_hop = next_hop;
        node.interface_num = interface_num;
        route_table.push_back(node);
        route_table.sort();
    }

    //! \param[in] dgram The datagram to be routed
    void Router::route_one_datagram(InternetDatagram &dgram) {
        // 减少TTL
        if (dgram.header().ttl <= 1)
            return;  // drop
        dgram.header().ttl -= 1;

        const uint32_t target_ip = dgram.header().dst;
        for (auto it = route_table.begin(); it != route_table.end(); it++) {
            uint32_t mask = 0;
            mask = (((~mask) >> (32-it->prefix_length)) << (32-it->prefix_length));
            if (it->prefix_length == 0 || ((it->route_prefix & mask) == (target_ip & mask))){
                // 发送报文
                if (it->next_hop.has_value())
                    interface(it->interface_num).send_datagram(dgram, it->next_hop.value());
                else
                    interface(it->interface_num).send_datagram(dgram,
    Address::from_ipv4_numeric(dgram.header().dst));
                return;  // 一定是最长前缀
            }
        }
    }

    void Router::route() {
        // Go through all the interfaces, and route every incoming datagram to its proper outgoing interface.
        for (auto &interface : _interfaces) {
            auto &queue = interface.datagrams_out();
            while (not queue.empty()) {
                route_one_datagram(queue.front());
                queue.pop();
            }
        }
    }
    ]]>     -     - - cs144 - /2023/02/25/cs144/ - -

    总耗时：65h 约17天

    -

    实验官网

    -

    感恩

    -
    -

    总结

    本实验总体思维和代码上的难度还是不难的（至少比xv6简单），我认为其难点主要集中在TCP协议本身就很复杂很多的细节问题，以及需要我们有一种面向测试用例编程、直面自己往日写过的屎山的勇气（。

    -

    下面，我将对本实验的完成情况即心得进行一个总结，也算是本篇博客/本次实验的一个导读。

    -
    -

    类似于这样的块引用中的部分是我自认为的精华部分哦。

    -
    -

    本实验对TCP-IP-ETH协议栈的实验是自顶向下的，其中对TCP协议的实现是由内而外的。

    -

    后者很容易导致，在对TCP协议的实现中，当你写完了lab0-3，你还是不知道自己到底写了个啥，以及TCP又究竟怎么通过你写的那几个类run起来。直到lab4结束，你完成了对TCP状态机的组织，并且出于debug目的钻研过部分socket的代码、熟悉了（其实差不多已经背下来了）TCP的三握手四挥手的过程，至此你才会对TCP的实现有较为清晰的理解。这个过程很痛苦，但是也真的非常爽。

    -
    -

    关于TCP状态机的理解总结，请参见Lab4 TCPConnection——心得——总结：状态机部分。

    -
    -

    然而，实现了TCP协议之后，我们还是不知道，在TCPConnection中发送的数据包，又是如何到达网络上的另一个host处的，我们究竟又写了个啥。

    -

    这时，官方贴心地为我们指了条明路：它告诉我们，我们在lab0-4实现的是TCP-IP协议栈，其中运输层和网络层由用户实现，其他更底层则由内核实现，二者通过操作系统提供的TUN接口进行交互。也即，我们之前实现的是用户态TCP协议！而我们接下来的学习目标，就是从内核中再夺走一些权力：数据链路层也要由我们自己实现！

    -
    -

    关于此处的TCP-IP架构等，请参见Lab5 NetworkInterface——Overview——承上启下

    -
    -

    故而，接下来，我们将实现用户态的TCP-IP-ETH协议栈。在lab5，我们将目光投向TCP层以下的数据链路层(网络层官方已经帮我们实现了)，实现ETH协议和ARP协议；在lab6，我们则需要实现路由查找的功能。

    -

    至此，所有实验已经结束。写完了上述实验，我们对协议栈已经具有了很深刻的了解，对TCP—IP—ETH—TAN—Internet—TAN—ETH—IP—TCP的这个数据传输过程也已经是懂王了。

    -

    然而，我们在TCPConnection，只知道会有好心人，在上层app有数据传进来的时候调用write、在下层协议栈有segment传进来的时候调用segment_received、取出_segment_out的segment向底层协议栈发送、读走outputstream的内容。但是这个所谓的“好心人”具体是怎么做到的，怎么实现的，我们一概不知。

    -

    答案是，这个所谓的“好心人”，其实就是我们的TCPSpongeSocket。它向上将协议栈与上层app连接，向下又将协议栈与TAN接口结合。

    -
    -

    发送数据时，数据流向：上层app→（通过TCPSpongeSocket）TCPConnection→（通过write方法）ByteStream→TCPSender→（通过从_sender.segments_out读）TCPConnection→（通过TCPSpongeSocket的adapter）TAN

    -

    接收数据时，数据流向：TAN→（通过TCPSpongeSocket的adapter）TCPConnection→TCPReceiver→（中间经过StreamAssembler）BYteStream→（通过TCPSpongeSocket读）上层app

    -

    在TCPSpongeSocket的adapter中：TCPsegment←→IP数据报←→ETH帧

    -

    至于ETH帧进入TAN之后的过程？在xv6的网卡驱动那一节我们事实上已经实现过了！

    -
    -

    CS144TCPSocket和FullStackTCPSokect都继承自TCPSpongeSocket。TCPSpongeSocket通过一个包装了操作系统提供的socket的包装类_thread_data来与上层app进行交互，通过adapter_datagram_adapter来与协议栈进行交互（adapter本质上也是调用了操作系统的TUN/TAN接口）。

    -

    由于_thread_data和_datagram_adapter本质上都是文件描述符【牛逼吧】，因而，TCPSpongeSocket需要跟上下层进行交互的需求，就可以通过操作系统提供的POLL机制来实现，也即，app←→TCP、TCP←→协议栈的这四种数据交互情况，都用事件监听来实现！这样就能做到“及时”“高效”了。

    -
    -

    关于此处TCPSpongeSocket的事件监听机制以及其它实现细节，详见其它的对…——Socket实现——TCPSpongeSocket

    -
    -

    至此以来，我们的协议栈才算真正完整了。

    -

    Lab0

    Lab1 StreamReassembler

    Lab2 TCPReceiver

    Lab3 TCPSender

    Lab4 TCPConnection

    Lab5 NetworkInterface

    Lab6 Router

    其他的对实验未涉及的思考

    ]]> - - labs - - 数据库原理 /2023/11/26/database/ @@ -7995,870 +7782,959 @@ url访问填写http://localhost/webdemo4_war/*.do。

    整体架构

    在rtt中，提供了一系列回调函数用于实现gpio：

    struct rt_pin_ops
    {
        // 设置gpio的模式（读/写）
        void (*pin_mode)(struct rt_device *device, rt_base_t pin, rt_uint8_t mode);
        // 读写gpio
        void (*pin_write)(struct rt_device *device, rt_base_t pin, rt_uint8_t value);
        rt_int8_t  (*pin_read)(struct rt_device *device, rt_base_t pin);
        // rtt特有中断回调，mode可以设置为电平/边缘触发，以及触发极性
        rt_err_t (*pin_attach_irq)(struct rt_device *device, rt_base_t pin,
                rt_uint8_t mode, void (*hdr)(void *args), void *args);
        rt_err_t (*pin_detach_irq)(struct rt_device *device, rt_base_t pin);
        rt_err_t (*pin_irq_enable)(struct rt_device *device, rt_base_t pin, rt_uint8_t enabled);
        // 引脚映射
        rt_base_t (*pin_get)(const char *name);
    };
    -

    milkv上有ABCDE五个gpio组件：

    -
    gpio@03020000 {
            bank-name = "porta";
    };

    gpio@03021000 {
            bank-name = "portb";
    };

    gpio@03022000 {
            bank-name = "portc";
    };

    gpio@03023000 {
            bank-name = "portd";
    };

    gpio@05021000 {
            bank-name = "porte";
    };
    - -

    但是，在实现中，这五个gpio组件会被注册为同一个设备，而不是像uart那样有多少个就注册多少个：

    -
    rt_device_pin_register("gpio", &_dwapb_ops, RT_NULL);
    - -

    外界交互

    应用程序会通过引脚名，使用rt_pin_get获取驱动内部自定义的引脚号，然后就可以通过引脚号对其进行模式设置和读写：

    -
    int DUO_LED = rt_pin_get("C24");
    rt_pin_mode(DUO_LED, PIN_MODE_OUTPUT);
    rt_pin_write(DUO_LED, PIN_LOW);
    - -

    寄存器

    配置

    这坨宏我是从linux里搬过来的。各个寄存器的含义可以详见data book，在此不多赘述。

    -

    访问

    在rtt中，外设地址也是统一编址到内存地址空间的。由其它gpio实现可知，当开启RT_USING_LWP（轻量级进程支持）时，外设地址不再是一一映射，需要我们手动在init中调用ioremap进行映射：

    -
    #ifdef RT_USING_LWP
    #define BSP_IOREMAP_GPIO_DEVICE(no)     \
        rt_ioremap((void *)(DWAPB_GPIOA_BASE + (no) * DWAPB_GPIO_SIZE), DWAPB_GPIO_SIZE);

        dwapb_gpio_base = (rt_size_t)BSP_IOREMAP_GPIO_DEVICE(0);
        BSP_IOREMAP_GPIO_DEVICE(1);
        BSP_IOREMAP_GPIO_DEVICE(2);
        BSP_IOREMAP_GPIO_DEVICE(3);
        dwapb_gpio_base_e = (rt_size_t)rt_ioremap((void *)DWAPB_GPIOE_BASE, DWAPB_GPIO_SIZE);
    #endif
    - -

    然后，之后就可以在各个方法中借助这两个函数传入寄存器地址直接进行读写了：

    -
    rt_inline rt_uint32_t dwapb_read32(rt_ubase_t addr)
    {
        return HWREG32(addr);
    }

    rt_inline void dwapb_write32(rt_ubase_t addr, rt_uint32_t value)
    {
        HWREG32(addr) = value;
    }
    #define HWREG32(x)          (*((volatile rt_uint32_t *)(x)))
    - -

    引脚映射

    摸索了半天，最终还是猜测这个引脚映射规定应该是自己决定的，于是我就从别的bsp那边把规则搬了过来：

    -
    // port && no -> pin
    #define PIN_NUM(port, no)   (((((port) & 0xFu) << 8) | ((no) & 0xFFu)))
    // pin -> port
    #define PIN_PORT(pin)       ((uint8_t)(((pin) >> 8) & 0xFu))
    // pin -> no
    #define PIN_NO(pin)         ((uint8_t)((pin) & 0xFFu))
    - -

    例如，“C24”就可转化为((((('C' - 'A') & 0xFu) << 8) | ((24) & 0xFFu)))。

    -

    根据此规则实现get_pin回调即可。具体板子上哪个引脚是哪个port，详见milkv的schematic book。

    -

    中断

    回调执行

    rtt提供了很好用的中断回调。参考别的bsp以及以前的经验，很容易知道attach_irq和detach_irq就是注册和注销回调函数。那么，回调是什么时候被调用的呢？查阅其他bsp，也可得知它这是采取了一个非常巧妙的委托：在rtt给的rt_hw_interrupt_install(DWAPB_GPIOE_IRQNUM, rt_hw_gpio_isr, RT_NULL, "gpio");注册的rt_hw_gpio_isr中做即可。这个层层外包的思想让我不禁想起Linux的调度类机制和用户态调度框架的实现原理，实在是牛逼至极。

    -

    为了记录所有回调签名，我们需要为每个gpio组件整一个数据结构：

    -
    static struct dwapb_event
    {
        void (*(hdr[DWAPB_GPIO_NR]))(void *args);
        void *args[DWAPB_GPIO_NR];
        rt_uint8_t is_both_edge[DWAPB_GPIO_NR];
    } _dwapb_events[DWAPB_GPIO_PORT_NR];
    - -

    在rt_hw_gpio_isr中：

    -
      -
    1. 根据硬件寄存器判断是否发生中断
      2. -
    2. 调用相应回调
      3. -
    3. 清除中断位表明完成中断处理
      4. -
    -

    即可。

    -

    both-edge实现

    这个是抄自linux。本质逻辑就是先设个上升沿触发，然后在rt_hw_gpio_isr执行完回调后再改成反方向也即下降沿触发，以此类推。不得不说确实帅。

    -

    I2C

    Wait todo…

    -]]> - - intern - -     - - git使用记录 - /2023/10/07/git/ - -

    记录一些git的原理学习，以及工作学习中遇到的一些git的操作问题。

    -
    -

    操作

    pull request

      -

    1. 第一次提pr

      -
        -
      1. fork原仓库
        2. -
      2. 本地clone，两个remote，fork和origin
        3. -
      3. checkout -b new-branch
        4. -
      4. 修改，add，commit，push
        5. -
      5. 在github提pr
        6. -
      -
      2. -

    2. 修改提过的pr

      -
        -

      1. 本地仓库与远程同步

        -

        直接修改，然后push到fork的对应分支就行，会自动更新。

        -
        2. -

      2. 本地仓库与远程不同步

        -

        以下操作都在new-branch分支上

        -
          -
        1. git fetch origin
          2. -
        2. git rebase origin/master
          3. -
        3. 如果有冲突则解决，然后git rebase --continue继续rebase
          4. -
        4. push fork
          5. -
        -
        3. -
      -
      3. -
    -

    rebase

    修改 git 的历史 commit，你能想到几种方案？ 详细介绍了rebase基本用法

    -

    object损坏

    image-20231030100954710

    -

    如图，我也不知道为什么突然就寄了。。。

    -

    总之进行了这些操作，虽然不知道是哪个起作用了，但总算好了：

    -

    https://blog.csdn.net/xiaoqixiaoguai/article/details/128591332

    -

    首先删除空白对象

    -
    cd .git
    find . -type f -empty -delete -print
    +

    milkv上有ABCDE五个gpio组件：

    +
    gpio@03020000 {
            bank-name = "porta";
    };

    gpio@03021000 {
            bank-name = "portb";
    };

    gpio@03022000 {
            bank-name = "portc";
    };

    gpio@03023000 {
            bank-name = "portd";
    };

    gpio@05021000 {
            bank-name = "porte";
    };
    -

    然后更新ref到某个版本号

    -
    cd ..
    tail -n 2 .git/logs/refs/heads/master
    git show xxxx(版本号)
    git update-ref HEAD xxxx(版本号)
    git fsck
    +

    但是，在实现中，这五个gpio组件会被注册为同一个设备，而不是像uart那样有多少个就注册多少个：

    +
    rt_device_pin_register("gpio", &_dwapb_ops, RT_NULL);
    -

    如果还不能用，继续：

    -
    rm .git/index
    git reset
    git fsck
    +

    外界交互

    应用程序会通过引脚名，使用rt_pin_get获取驱动内部自定义的引脚号，然后就可以通过引脚号对其进行模式设置和读写：

    +
    int DUO_LED = rt_pin_get("C24");
    rt_pin_mode(DUO_LED, PIN_MODE_OUTPUT);
    rt_pin_write(DUO_LED, PIN_LOW);
    -

    我到这里之后显示：

    -

    image-20231030101123181

    -

    继续执行：

    -
      -

    1. 修复 refs/remotes/origin/master：

      -
      bashCopy codegit update-ref -d refs/remotes/origin/master
      git fetch origin
      +

      寄存器

      配置

      这坨宏我是从linux里搬过来的。各个寄存器的含义可以详见data book，在此不多赘述。

      +

      访问

      在rtt中，外设地址也是统一编址到内存地址空间的。由其它gpio实现可知，当开启RT_USING_LWP（轻量级进程支持）时，外设地址不再是一一映射，需要我们手动在init中调用ioremap进行映射：

      +
      #ifdef RT_USING_LWP
      #define BSP_IOREMAP_GPIO_DEVICE(no)     \
          rt_ioremap((void *)(DWAPB_GPIOA_BASE + (no) * DWAPB_GPIO_SIZE), DWAPB_GPIO_SIZE);

          dwapb_gpio_base = (rt_size_t)BSP_IOREMAP_GPIO_DEVICE(0);
          BSP_IOREMAP_GPIO_DEVICE(1);
          BSP_IOREMAP_GPIO_DEVICE(2);
          BSP_IOREMAP_GPIO_DEVICE(3);
          dwapb_gpio_base_e = (rt_size_t)rt_ioremap((void *)DWAPB_GPIOE_BASE, DWAPB_GPIO_SIZE);
      #endif
      -

      这将删除损坏的 origin/master 引用，然后从远程仓库重新获取。

      -
      2. -

    2. 修复 dangling blob：

      -

      如果 git fsck 显示了 dangling blob，你可以尝试删除这些对象：

      -
      bashCopy codegit reflog expire --expire=now --all
      git gc --prune=now
      +

      然后，之后就可以在各个方法中借助这两个函数传入寄存器地址直接进行读写了：

      +
      rt_inline rt_uint32_t dwapb_read32(rt_ubase_t addr)
      {
          return HWREG32(addr);
      }

      rt_inline void dwapb_write32(rt_ubase_t addr, rt_uint32_t value)
      {
          HWREG32(addr) = value;
      }
      #define HWREG32(x)          (*((volatile rt_uint32_t *)(x)))
      -

      这将清理无用的 dangling 对象。

      -
      3. -
    -

    成功。

    -

    原理

      -

    1. merge与rebase的差异

      -

      merge：

      -

      merge

      -

      rebase：

      -

      rebase

      -
      2. -
    2. -
    -]]> - - - 开源的第一个月 - /2023/10/19/open-source-9.19-10.19/ - -

    其实是9.10就开始了，但9.19才办理入职所以少算了几天xxxx不然这不显得我菜hh

    -
    -

    引言

    也许有许多programer与我一样，在初次接触到“开源”这个概念时，便对其产生了无限的向往。千万人通过共同的事业联结在一起，为了行业的进步不求回报地压缩自己的时间，贡献出自己的一份力，这是何等的浪漫。再加上听了无数遍的Linux发展历程故事，对“开源”我是愈发地憧憬。

    -

    然而，由于学习cs的时间尚不足，也不知道该从何入手去参与社区贡献，尽管心中怀有对参与这份事业的渴望，我还是会“望而却步”。转折点在今年参加竞赛时，在使用某个开源项目时因为遇到了一点问题而去提了个issue。虽然这个问题本质很傻，但在与开发者你来我往的交流中，我深切地感受到自己仿佛离憧憬更近了一步。因而，在今年竞赛结束后的九月，我毫不犹豫地向PLCT Lab提交了简历，试图追逐那个长存我心的幻影。

    -

    而现在，距离第一次提issue已有半年，距离考核通过也已有一个半月之久，我想也是时候好好总结一下我这一个月以来的心路历程了。

    -

    我的第一个月

    -

    从9.10过审核开始写了很久的日报，当然除了实习还包括别的内容：

    -

    image-20231019155950614

    -
    -

    这一个月以来，我学到了很多东西，学习周期大致可分为三个阶段：初步了解rtt和配置环境、设备树学习以及最后的gpio driver开发。

    -

    rtt

    由于时间有限，所以仅对rtt的标准版本做了一个比较基本的了解（也就是说没有太涉及到源码部分，只能说是对文档中心的那些对外开发用接口有一定的了解）。rtt是一个微内核的RTOS，这与以前所接触的Linux和xv6都不同。由于RTOS的特性，它的许多设计都十分精简，相比于Linux可谓”麻雀虽小五脏俱全“。

    -

    对rtt的基本介绍，详情可见其文档中心。我印象最深（也是开发过程中接触得最多的）的几个点有：

    +

    引脚映射

    摸索了半天，最终还是猜测这个引脚映射规定应该是自己决定的，于是我就从别的bsp那边把规则搬了过来：

    +
    // port && no -> pin
    #define PIN_NUM(port, no)   (((((port) & 0xFu) << 8) | ((no) & 0xFFu)))
    // pin -> port
    #define PIN_PORT(pin)       ((uint8_t)(((pin) >> 8) & 0xFu))
    // pin -> no
    #define PIN_NO(pin)         ((uint8_t)((pin) & 0xFFu))
    + +

    例如，“C24”就可转化为((((('C' - 'A') & 0xFu) << 8) | ((24) & 0xFFu)))。

    +

    根据此规则实现get_pin回调即可。具体板子上哪个引脚是哪个port，详见milkv的schematic book。

    +

    中断

    回调执行

    rtt提供了很好用的中断回调。参考别的bsp以及以前的经验，很容易知道attach_irq和detach_irq就是注册和注销回调函数。那么，回调是什么时候被调用的呢？查阅其他bsp，也可得知它这是采取了一个非常巧妙的委托：在rtt给的rt_hw_interrupt_install(DWAPB_GPIOE_IRQNUM, rt_hw_gpio_isr, RT_NULL, "gpio");注册的rt_hw_gpio_isr中做即可。这个层层外包的思想让我不禁想起Linux的调度类机制和用户态调度框架的实现原理，实在是牛逼至极。

    +

    为了记录所有回调签名，我们需要为每个gpio组件整一个数据结构：

    +
    static struct dwapb_event
    {
        void (*(hdr[DWAPB_GPIO_NR]))(void *args);
        void *args[DWAPB_GPIO_NR];
        rt_uint8_t is_both_edge[DWAPB_GPIO_NR];
    } _dwapb_events[DWAPB_GPIO_PORT_NR];
    + +

    在rt_hw_gpio_isr中：

      -

    1. 接口设计

      -

      与Linux一样，rtt也采用了精简的接口设计。

      -
      2. -

    2. 自动初始化机制

      -

      帅的一匹，具体详见此。

      -
      3. +
    3. 根据硬件寄存器判断是否发生中断
      4. +
    4. 调用相应回调
      5. +
    5. 清除中断位表明完成中断处理
    -

    其余的只能说不甚了解，还有待挖掘。

    -

    配置环境

    由于确实对这种东西毫无所知，所以配环境这个过程也是比较漫长，而且很折磨很痛苦（。

    -

    硬件方面，一开始拿到IO-board连这是啥都不知道，还以为这就是开发板研究了半天怎么上电和把内核烧进去（（（。然后东西也是买得缺斤少两，比如拿到开发板不知道还要有TF卡，上网搜图研究了半天才意识到；再比如也没有USB-TTL，又是一通淘宝购物。这些各种各样的小白问题导致配环境的周期十分漫长。然后还有一些很傻的错误，再次也不好意思多说了，详情可见rtt硬件环境搭建。

    -

    软件方面倒是没什么问题，之前也早就跟编译内核用的menuconfig打过很多交道，磁盘分区之类的东西之前也简单使过几次，只不过经过这次后也算是使得更加熟练了。

    -

    设备树学习

    -

    TODO，这部分还是比较多好写的，虽然还是有点模糊（待我之后有时间整理下放个链接

    -
    -

    设备树还是比较复杂，而且因为本人的不审慎，导致对其理解出了偏差，还麻烦了社区看我的代码（悲）只能说个人出道的开源社区还是需要对自己的所有笔代码负责。

    -

    gpio driver

    -

    pr：

    -

    image-20231021105306299

    -

    涉及到的各种硬件手册：

    -

    image-20231019165451893

    -
    -

    这也是我最后这一周在做的工作，虽说只有短短一周，但是每天都研究这个花了我不少时间和精力（）目前算是写完了它的所有功能（大概），并且已经能把LED闪烁和中断绑定函数润起来了，提的pr在这里。

    -

    以前对驱动的理解，还停留在手把手教你做事的xv6的netlab。也因而，这次可以算是以完全一无所知的状态接下了这个任务。

    -

    不过，好在有以前那个短暂的lab经验，我还是稳扎稳打地定下了具体的学习步骤：调研（包括获取各种data book、schematic、rtt官方文档、Linux和rtt相关代码），然后就是学习。

    -

    好在有设备树的研究积淀，我也算是比较快地掌握了milkv上gpio的分布、型号及其地址空间，从而顺藤摸瓜找到了对应gpio型号的Linux驱动代码参考和硬件手册，算是免去了不少麻烦。

    -

    image-20231019165206369

    -

    然后，我观察rtt的gpio驱动们，也找到了对应的pin.md文档，了解了下大致的代码框架思路：

    -

    image-20231019165313914

    -

    于是接下来的工作也可以比较独立地划分为两部分，一个是数据读写的实现（通过LED闪烁程序测试），另一个是rtt特有的中断回调函数的支持（通过中断程序测试），可以专注对这两个方面开发了。

    -

    其中，数据读写的实现需要对寄存器和引脚号等有所了解。寄存器相对比较简单，只需阅读dwapb的data book即可；而引脚号到gpio的转换则花了我不少时间，做了许多猜想并且进行验证，最后误打误撞地“猜”中了正确思路，通过了LED测试。

    -

    image-20231019165706806

    -

    image-20231019165719966

    -

    image-20231019165738144

    -

    不过引脚号我现在还是不大懂，总之先参照别的bsp写法自己编了个，等着代码review看下吧。

    -

    前期调研一直到LED亮起来花了我整整五六天（）相比于此的困难，中断倒显得简单了许多，毕竟它属于是偏软件相关的。调了一天，也从Linux和其他bsp那边抄了些代码，最终在凌晨两点半成功完成了功能测试（）今天又花了一个下午整理了下代码和写日记，最终总算是把这个作业交上去了。

    -

    整个过程光是写看起来还是比较轻松，但是由于初次开发摸索，每个小跨越都得花费我不少时间去调研搜索，经常是在长达几个小时的不知所措后才短暂地获得了一些光明，我甚至多次想过要不要去辞职了（（（。总之，最后还是坚持了下来。看到蓝色的LED在夜晚的T5中闪烁，我还是十分激动的，眼泪都爆出来了（）

    -

    哎，坚持难能可贵，很高兴我最终做到了，虽然尚有测试上的不完善，以及还在等待review。

    -

    稍作总结

    总之，这一个月来我学到了许多，同时也对我以前未曾涉足的空白领域做了许多探索，包括对设备树、对嵌入式开发、对Linux设备驱动等的学习，总体来说还是十分甚至九分地开心。希望下个月能再接再厉。

    +

    即可。

    +

    both-edge实现

    这个是抄自linux。本质逻辑就是先设个上升沿触发，然后在rt_hw_gpio_isr执行完回调后再改成反方向也即下降沿触发，以此类推。不得不说确实帅。

    +

    I2C

    Wait todo…

    ]]> - mylife + intern - rtt硬件环境搭建 - /2023/10/12/rtt%E7%A1%AC%E4%BB%B6%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/ - SDK/内核编译

    编译内核和sdk时到没有太大问题，都能靠gpt or 修改menuconfig解决。比较棘手的果然还是只能靠自己摸索硬件hhh

    -

    烧录

    这个也是狠狠折磨了我许久，gpt也一直满嘴跑火车，毕竟一开始串口连错了所以一直以为自己是烧录没对，整了半天【而且还是正确的操作反反复复尝试……仿佛坐牢】。不过这其中也学到了挺多。

    -

    f2753b5e6a40f9fea328223b197ede3

    -

    具体要做的是：

    -
    sudo fdisk /dev/sdb
    - + 内核编译 + /2023/08/12/kernel_compile/ + 我们在开发过程中所用的具体硬件配置如下：

    -

    关于fdisk及part这样的分区工具，这篇文章介绍得很详细：Linux 系统中关于磁盘分区工具的使用

    +

    CPU: Intel(R) Core(TM) i7-8700 CPU @ 3 with hyper-threading

    +

    Memory: 14GB

    +

    OS: Ubuntu 22.04.3 LTS

    +

    ​ with Linux kernel 6.4.0+(COS) && 6.4.0-rc3+(EXT) && 5.11.0+(ghOSt)

    -

    然后进入后，n命令创建新分区，d删除现有分区。我们需要用n创建两个分区（大小随意），第一个用于存放bin文件。创建完分区之后，使用a命令将分区1标记为Boot，并且使用t将分区1的类型修改为W95 FAT32 (LBA)，随后就可以保存退出了。具体流程及操作结果如下：

    -
    $ sudo fdisk /dev/sdb

    Welcome to fdisk (util-linux 2.37.2).
    Changes will remain in memory only, until you decide to write them.
    Be careful before using the write command.

    Command (m for help): p

    Disk /dev/sdb: 29.72 GiB, 31914983424 bytes, 62333952 sectors
    Disk model: Storage Device  
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: dos
    Disk identifier: 0xd4c6d64f

    Command (m for help): n
    Partition type
       p   primary (0 primary, 0 extended, 4 free)
       e   extended (container for logical partitions)
    Select (default p): 

    Using default response p.
    Partition number (1-4, default 1): 
    First sector (2048-62333951, default 2048): 
    Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-62333951, default 62333951): +128M

    Created a new partition 1 of type 'Linux' and of size 128 MiB.
    Partition #1 contains a vfat signature.

    Do you want to remove the signature? [Y]es/[N]o: yes

    The signature will be removed by a write command.

    Command (m for help): n
    Partition type
       p   primary (1 primary, 0 extended, 3 free)
       e   extended (container for logical partitions)
    Select (default p): 

    Using default response p.
    Partition number (2-4, default 2): 
    First sector (264192-62333951, default 264192): 
    Last sector, +/-sectors or +/-size{K,M,G,T,P} (264192-62333951, default 62333951): 

    Created a new partition 2 of type 'Linux' and of size 29.6 GiB.

    Command (m for help): t
    Partition number (1,2, default 2): 0c
    Value out of range.
    Partition number (1,2, default 2): 1
    Hex code or alias (type L to list all): 0c

    Changed type of partition 'Linux' to 'W95 FAT32 (LBA)'.

    Command (m for help): a
    Partition number (1,2, default 2): 1

    The bootable flag on partition 1 is enabled now.

    Command (m for help): p
    Disk /dev/sdb: 29.72 GiB, 31914983424 bytes, 62333952 sectors
    Disk model: Storage Device  
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: dos
    Disk identifier: 0xd4c6d64f

    Device     Boot  Start      End  Sectors  Size Id Type
    /dev/sdb1  *      2048   264191   262144  128M  c W95 FAT32 (LBA)
    /dev/sdb2       264192 62333951 62069760 29.6G 83 Linux

    Filesystem/RAID signature on partition 1 will be wiped.

    Command (m for help): w
    The partition table has been altered.
    Calling ioctl() to re-read partition table.
    Syncing disks.
    +

    COS环境搭建

    COS可以部署在Linux物理机和虚拟机上，但建议部署在Linux物理机以获取更好的性能效果。下文将详细介绍环境搭建的详细步骤。

    +

    COS内核

    内核编译

    安装内核编译所需包：

    +
    sudo apt-get update && sudo apt-get install build-essential gcc g++ make libncurses5-dev libssl-dev bison flex bc libelf-dev
    -

    然后更新分区表，格式化文件系统，复制bin和sd文件、弹出sd卡：

    -
    sudo partprobe 
    sudo mkfs.vfat -F 32 /dev/sdb1
    sudo mkfs.vfat -F 32 /dev/sdb2
    sudo mount /dev/sdb1 /mnt/sdb1
    sudo cp boot.sd fip.bin /mnt/sdb1
    sudo umount /mnt/sdb1 
    sudo eject /dev/sdb
    +

    克隆COS内核：

    +
    git clone https://github.com/shootfirst/cos_kernel.git
    cd cos_kernel/
    + +

    生成内核编译配置文件：

    +
    make localmodconfig
    + +

    修改.config文件：

    +
    vim .config
    -

    就烧录ok了。

    -

    与此同时也顺便学了下Windows磁盘管理，感觉也挺方便。

    -

    串口连接

    不得不说十分惨痛……

    -

    也是因为我太狂妄自大不仔细了，一直以为RX就得连RX，TX就得连TX，然后下午焦灼之中才突然想起来这俩是不是以前教过得反着连……搜了一下果然是草。

    -

    这个错误害我起码花了三个小时在纠结烧录问题，一直以为没输出是因为烧录不对，发现结果那一刻我真没蚌珠。哎，以后还是别对自己太自信，毕竟本质上这种东西不是专业的学得也不够扎实，做什么都得先查一下该怎么做。

    -

    另一个问题是，乱码：

    -

    58c63791e1b4cac06a827f0ffa6b329

    -

    好像是说使用了个ch340的usb-ttl，似乎这个东西波特率有点问题不准确，具体不大懂：CH340G U-BOOT阶段乱码 总之最后简单粗暴地靠修改波特率为117200解决了。

    -

    然后别的倒是没什么问题，虽然摸索也花了点时间，都是小事。对着这张图参照就行了：

    -

    mmexport1697102534057

    -

    开发过程

    感觉有一些东西，还是比较靠悟性23333在此记录些开发过程中的小发现。

      -

    1. 关于引脚

      -

      两个引脚可以通过image-20231019162502551这玩意连起来，这样就能使一个引脚的output作为另一个引脚的input。

      -

      这是我在开发gpio中断时意识到的。这个道理虽然非常简单，但对于零基础胡乱摸索的我，知道这个还是需要一些灵光一闪。

      -
      2. -
    2. +

    3. 删除PSI监测

      +

      查找CONFIG_PSI，将其对应行修改为：

      +
      CONFIG_PSI=n
      4. +

    4. 删除系统吊销密钥

      +

      查找CONFIG_PSI，将其对应行修改为：

      +
      CONFIG_SYSTEM_REVOCATION_KEYS=""
    -]]>     -     - - Operating system interface - /2023/01/10/xv6$chap1/ - Operating system interface

    本节大概是在讲操作系统的接口，系统调用占了很大一部分。

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    系统调用描述
    int fork()创建一个进程，返回子进程的PID
    int exit(int status)终止当前进程，并将状态报告给wait()函数。无返回
    int wait(int *status)等待一个子进程退出; 将退出状态存入*status; 返回子进程PID。
    int kill(int pid)终止对应PID的进程，返回0，或返回-1表示错误
    int getpid()返回当前进程的PID
    int sleep(int n)暂停n个时钟节拍
    int exec(char *file, char *argv[])加载一个文件并使用参数执行它; 只有在出错时才返回
    char *sbrk(int n)按n 字节增长进程的内存。返回新内存的开始
    int open(char *file, int flags)打开一个文件；flags表示read/write；返回一个fd（文件描述符）
    int write(int fd, char *buf, int n)从buf 写n 个字节到文件描述符fd; 返回n
    int read(int fd, char *buf, int n)将n 个字节读入buf；返回读取的字节数；如果文件结束，返回0
    int close(int fd)释放打开的文件fd
    int dup(int fd)返回一个新的文件描述符，指向与fd 相同的文件
    int pipe(int p[])创建一个管道，把read/write文件描述符放在p[0]和p[1]中
    int chdir(char *dir)改变当前的工作目录
    int mkdir(char *dir)创建一个新目录
    int mknod(char *file, int, int)创建一个设备文件
    int fstat(int fd, struct stat *st)将打开文件fd的信息放入*st
    int stat(char *file, struct stat *st)将指定名称的文件信息放入*st
    int link(char *file1, char *file2)为文件file1创建另一个名称(file2)
    int unlink(char *file)删除一个文件
    -

    表1.2：xv6系统调用（除非另外声明，这些系统调用返回0表示无误，返回-1表示出错）

    -

    Process and memory

    fork

    int pid = fork();
    if(pid > 0){
        printf("parent: child's pid = %d\n",pid);
        pid = wait(0);
        printf("child %d is done.\n",pid);
    } else if(pid == 0){
        printf("child : exiting\n");
    } else {
        printf("fork error\n");
    }
    +

    然后就可以进行内核编译：

    +
    make -j12 && sudo make modules_install && sudo make install
    -

    这是一个利用fork的返回值对于父子进程来说不同这一特点进行编写的例程。其中比较不熟的还是wait(0)这一句的用法。这点具体可以看书中笔记和上面的系统调用表。

    -

    exec

    exec是一个系统调用，它跟exe文件被执行的原理密切相关。当程序调用exec，就会跳转到exec参数文件去执行，原程序exec下面的指令都不再被执行，除非exec因错误而退出。

    -

    exec与fork

    由shell的源码中main函数这一段

    -
    // Read and run input commands.
    while(getcmd(buf, sizeof(buf)) >= 0){
      if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
        // Chdir must be called by the parent, not the child.
        buf[strlen(buf)-1] = 0;  // chop \n
        if(chdir(buf+3) < 0)
          fprintf(2, "cannot cd %s\n", buf+3);
        continue;
      }
      if(fork1() == 0)
        runcmd(parsecmd(buf));
      wait(0);
    }
    exit(0);
    -
    void runcmd(struct cmd *cmd)
    {
      if(cmd == 0)
        exit(1);

      switch(cmd->type){
      ...
      case EXEC:
        ecmd = (struct execcmd*)cmd;
        exec(ecmd->argv[0], ecmd->argv);
        fprintf(2, "exec %s failed\n", ecmd->argv[0]);
        break;
        ...
            
      exit(0);
    }
    -

    可以看到shell其实本质上就是这样的架构架构：

    -
    while(true){
    	if(读到了command&&fork()==0){
            exec(command);
            printf("失败信息");
        }
        wait(0);
    }
    +

    修改grub

    打开grub配置文件：

    +
    sudo vim /etc/default/grub
    + +

    进行以下修改：

    +
      +
    1. 注释GRUB_TIMEOUT_STYLE=hidden
      2. +
    2. 将GRUB_CMDLINE_LINUX_DEFAULT设置为”text”
      3. +
    3. 将GRUB_TIMEOUT修改成30
      4. +
    +

    然后保存退出，更新grub：

    +
    sudo update-grub
    + + + +

    进入COS内核

    完成上述步骤后，重启虚拟机：

    +
    sudo reboot
    + +

    在进入GRUB界面时选择Advanced Ubuntu，然后选择内核版本6.4.0+即可。

    +

    COS用户态

    在完成COS内核编译，并进入COS内核之后，就完成了COS的基本环境搭建。接下来，将介绍如何搭建COS用户态环境，从而运行Shinjuku Scheduler和RocksDB实验。

    +

    首先，确保所处内核正确：

    +
    $ uname -r
    6.4.0+
    + +

    依赖安装

    apt包

    安装编译用户态需要的包：

    +
    sudo apt-get install cmake python2 python3 libtbb-dev libsnappy-dev zlib1g-dev libgflags-dev libbz2-dev liblz4-dev libzstd-dev
    + + + +

    RocksDB

    获取RocksDB 6.15.5版本release：

    +
    wget https://github.com/facebook/rocksdb/archive/refs/tags/v6.15.5.tar.gz
    tar -xvf v6.15.5.tar.gz
    cd rocksdb-6.15.5/
    -

    也即父进程创建出子进程来执行command，并且父进程等待子进程执行完再继续等待输入。

    -

    可以看到，fork和exec的使用是非常紧密的，联合使用也是非常顺理成章的。那么，如果干从fork的exec的对于内存管理的原理来讲，就会不免产生一点问题。

    -
    -

    问题描述：

    -

    fork的内存原理，实质上是开辟一片新的与父进程等大的内存空间，然后把父进程的数据都copy一份进这个新内存空间。exec的原理是用一片可以容纳得下文件指令及其所需空间的内存空间去替代调用进程原有的那片内存空间。

    -

    可以看到，如果fork和exec接连使用，理论上其实是会产生一点浪费的，fork创建子进程复制完了一片内存空间，这片新复制的内存空间又马上被扔掉了，取而代之的用的是exec的内存空间。

    -
    -

    为了解决这个问题，kernel使用了copy-on-write技术优化。

    -

    I/O and File descriptors

    文件描述符

    句柄就是一个int值，它代表了一个由内核管理的，可以被进程读写的对象.

    -
    -

    A process may obtain a file descriptor by opening a file, directory, or device, or by creating a pipe, or by duplicating an existing descriptor.

    -
    -

    每个进程的其三个句柄有默认值：

    -

    By convention, a process reads from file descriptor 0 (standard input), writes output to file descriptor 1 (standard output), and writes error messages to file descriptor 2 (standard error).

    +

    注：测试得发现本RocksDB负载同最新版本RocksDB不兼容，故而建议使用上述命令对应版本，也即v6.15.5。

    -

    句柄0对应着standard input，1对应着standard output，2对应着standard error。

    -

    read、write

    read和write的参数都是句柄，buf，读/写长度。都会导致文件指针的移动。使用如下例程【类似cat的原理】：

    -
    char buf[512];
    int n;

    for(;;){
        n = read(0);//从标准输入读
        if(n == 0){
            break;
        }
        if(n < 0){
            fprintf(2,"read error\n");
            exit(1);
        }
        if(write(1,buf,n) != n){//向标准输出写
            fprintf(2,"write error\n");
            exit(1);
        }
    }
    +

    修改CMakeLists：

    +
    vim CMakeLists.txt
    -

    close

    close函数释放了一个句柄，以后它释放掉的这个句柄就可以被用来表示别的文件了。

    -

    open

    open函数会给参数的file分配一个句柄。这个句柄通常是目前空闲的句柄中值最小的那个。

    -

    重定向的实现

    char *argv[2];

    argv[0] = "cat";
    argc[1] = 0;
    if(fork() == 0){
        close(0);
        open("input.txt",O_RDONLY);
        exec("cat",argv);
    }
    +
      +

    1. 搜索WITH_TBB，将这一项改为ON:

      +
      option(WITH_TBB "build with Threading Building Blocks (TBB)" ON)
      2. +

    2. 搜索ROCKSDB_LITE ，确保这一项为OFF

      +
      option(ROCKSDB_LITE "Build RocksDBLite version" OFF)
      3. +
    +

    保存退出后进行编译安装：

    +
    mkdir build && cd build && cmake .. && make -j12 && sudo make install
    -

    xv6的重定向实现跟这个原理差不多：

    -
    case REDIR:
      rcmd = (struct redircmd*)cmd;
      close(rcmd->fd);
      if(open(rcmd->file, rcmd->mode) < 0){
        fprintf(2, "open %s failed\n", rcmd->file);
        exit(1);
      }
      runcmd(rcmd->cmd);
      break;
    -

    共享偏移量

    fork出来的父子进程同一个句柄对同一个文件的偏移量是相同的，这个原理应该是因为，父子进程共享的是文件句柄这个结构体对象本身，也就是拷贝的时候是浅拷贝而不是深拷贝。

    -
    if(fork() == 0) {
    	write(1, "hello ", 6);
    	exit(0);
    } else {
    	wait(0);
    	write(1, "world\n", 6);
    }
    -

    dup

    dup系统调用复制一个现有的文件描述符，返回一个引用自同一个底层I/O对象的新文件描述符。

    -

    dup和open一样，都是会占用一个新的句柄的，而且都是优先分配数值小的。比如说fd = dup(3)，得到fd=4，那么结果就是句柄3和句柄4指向同一个文件，并且偏移量一样。

    -

    dup可以让这样的指令变得可以实现：

    -
    ls existing-file non-existing-file > tmp1 2>&1
    +

    运行COS

    克隆COS用户态代码：

    +
    git clone https://gitlab.eduxiji.net/202318123111334/cos_userspace.git
    cd cos_userspace
    -
    -

    这个指令的意思是，先把stderr的结果重定向到stdout，再把stdout的结果重定向到tmp1中。

    -

    关于2>&1的解释，可以看这个 shell中的”2>&1”是什么意思？

    +

    编译COS用户态：

    +
    mkdir build && cd build && cmake .. && make -j($nproc)
    + +

    然后就可以开始运行COS用户态了。在此以Fifo Scheduler为例。

    +

    打开两个终端，在其中一个运行Fifo Scheduler：

    +
    pwd # 确保在cos_userspace/build目录下
    sudo ./fifo_scheduler
    + +

    另一个运行GTest测试：

    +
    pwd # 确保在cos_userspace/build目录下
    sudo ./simple_exp
    + +

    等待测试完成即可。

    +

    若要运行展示中所提到的测试，可详细见性能测试教程。

    +

    EXT环境搭建

    EXT内核

    依赖安装

    llvm

    SCHED-EXT内核由于用到新eBPF特性，故而编译需要用到还未发行到apt包管理器的clang最新版本，因此需要手动拉取并且编译一些依赖包。

    +
    # 克隆llvm仓库
    git clone --depth=1 https://github.com/llvm/llvm-project.git

    # 编译llvm项目
    cd llvm-project
    mkdir build
    cd build
    cmake -DLLVM_ENABLE_PROJECTS=clang -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles" ../llvm
    make -j($nproc)

    # 在~/.bashrc文件添加
    export PATH=$PATH:/yourpath/llvm-project/build/bin

    # 确认
    echo $PATH
    clang --version # >= 17.0.0
    llvm-config --version # >= 17.0.0
    + + + +

    pahole

    # 克隆pahole项目
    git clone git://git.kernel.org/pub/scm/devel/pahole/pahole.git

    # 编译pahole项目
    cd pahole/
    mkdir build
    cd build
    cmake -D__LIB=lib -DBUILD_SHARED_LIBS=OFF ..
    make
    sudo make install

    # 检查
    $ pahole --version # >= v1.25
    + + + +

    rust-nightly

    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
    rustup toolchain install nightly
    rustup default nightly
    # 查看rust版本
    rustc --version
    + + + +

    内核编译

    安装内核编译所需包：

    +
    sudo apt-get update && sudo apt-get install build-essential gcc g++ make libncurses5-dev libssl-dev bison flex bc libelf-dev
    + +

    克隆COS内核：

    +
    git clone https://gitlab.eduxiji.net/202318123111334/ext-kernel.git
    cd ext-kernel/
    + +

    生成内核编译配置文件：

    +
    make localmodconfig
    + +

    对生成的.config配置文件做如下修改：

    +
      +
    1. 将CONFIG_SYSTEM_TRUSTED_KEYS="debian/canonical-certs.pem"修改为CONFIG_SYSTEM_TRUSTED_KEYS=""
      2. +
    2. 添加CONFIG_SCHED_CLASS_EXT=y
      3. +
    3. 确保CONFIG_DEBUG_INFO以及CONFIG_DEBUG_INFO_BTF为开启状态
      4. +
    +

    编译安装内核：

    +
    make -j12 && sudo make modules_install && sudo make install
    + +

    修改grub

    详见COS环境搭建的对应部分。在此不做赘述。

    +

    EXT用户态

    pwd # 确保在ext-kernel/项目根目录下
    cd ext-kernel/tools
    + +

    随后，我们需要替换原有EXT使用示例为我们搭建的EXT用户态框架。

    +
    rm -rf sched_ext/
    git clone https://gitlab.eduxiji.net/202318123111334/proj134-cfs-based-userspace-scheduler.git sched_ext
    + +

    然后就可以运行EXT用户态框架了。

    +

    若要运行展示中所提到的测试，可详细见性能测试教程。

    +

    ghOSt环境搭建

    由于测试中需要以ghOSt作为比较对象，故在运行测试之前，必须搭建ghOSt环境。

    +

    ghOSt内核

    内核编译

    安装内核编译所需包：

    +
    sudo apt-get update && sudo apt-get install build-essential gcc g++ make libncurses5-dev libssl-dev bison flex bc libelf-dev
    + +

    克隆ghOSt内核：

    +
    git clone https://github.com/google/ghost-kernel
    cd ghost-kernel/
    + +

    生成内核编译配置文件：

    +
    make localmodconfig
    + +

    对生成的.config配置文件做如下修改：

    +
      +
    1. 将CONFIG_SYSTEM_TRUSTED_KEYS="debian/canonical-certs.pem"修改为CONFIG_SYSTEM_TRUSTED_KEYS=""
      2. +
    2. 添加CONFIG_SCHED_CLASS_GHOST=y
      3. +
    +

    编译安装内核：

    +
    make -j12 && sudo make modules_install && sudo make install
    + + + +

    修改grub

    详见COS环境搭建的对应部分。在此不做赘述。

    +

    ghOSt用户态

    依赖安装

    bazel

    +

    详细安装可参照官方文档Installing Bazel on Ubuntu，在此仅给出其中第一种方法。

    -

    这个的实现就要用到dup了。我们会fork一个子进程，在子进程里面close(2)，然后再dup(1)。这样一来，我们就成功实现了句柄1和2指向同一个文件

    -

    Pipe

    使用

    int pipe(int p[]) 创建一个管道，把read/write文件描述符放在p[0]和p[1]中

    -
    int p[2];
    char* argv[2];

    argv[0] = "wc";
    argv[1] = 0;

    pipe(p);
    if(fork() == 0){
        close(0);
        dup(p[0]);
        close(p[0]);
        close(p[1]);
    } else{
        close(p[0]);
        write(p[1],"hello world\n",12);
        close(p[1]);
    }
    +

    将Bazel分发URL添加为软件包来源

    +
    # 在~目录下
    sudo apt install apt-transport-https curl gnupg -y
    curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
    sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
    echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
    -

    完成了父进程-pipe-子进程的一个重定向。

    -

    pipe是阻塞的生产者消费者模式。对管道的read，在没有数据输入时会阻塞，直到读到数据，或者所有的write方向都被关闭。示例代码中，如果不使用pipe就需要显示close(p[0]) close(p[1])，正是为了防止没有数据输入时write方向不为0导致死锁的情况出现。

    -

    实现管道命令

    管道命令的实现正是通过pipe。

    -

    执行原理就是，创建两个子进程分别执行左右两侧的句子，然后左侧子进程的out重定向到pip的write，右侧子进程的in重定向到pip的read。

    -
     case PIPE:
       pcmd = (struct pipecmd*)cmd;
       if(pipe(p) < 0)
         panic("pipe");
    //左
       if(fork1() == 0){
         close(1);
         dup(p[1]);
         close(p[0]);
         close(p[1]);
         runcmd(pcmd->left);
       }
    //右
       if(fork1() == 0){
         close(0);
         dup(p[0]);
         close(p[0]);
         close(p[1]);
         runcmd(pcmd->right);
       }
       //中
    close(p[0]);
       close(p[1]);
       //wait
    wait(0);
       wait(0);
       break;
    +

    安装和更新Bazel

    +
    sudo apt update && sudo apt install bazel
    # 将bazel升级到最新版本
    sudo apt update && sudo apt full-upgrade
    -

    这实际上是二叉树的左右中递归过程。

    -
    -

    附：对于管道命令的解读

    -
    cat a.txt | echo
    -

    我的本意是觉得，这意思就是把cat a.txt的输出连到echo的输入，这个命令结果跟cat a.txt是没什么差的。但具体执行出来发现最后的结果却是跟：

    -
    echo
    -

    这个指令的效果是一样的，也就是cat a.txt的output，即echo的input完全被丢弃了。

    -

    我想这是因为，echo这个命令的执行过程并没有用到stdin，仅仅用到了参数，也就是说管道read端的接入对它并没有什么影响。

    -

    这也是为啥

    -
    sleep 10 | echo hi
    +

    apt包

    sudo apt update
    sudo apt install libnuma-dev libcap-dev libelf-dev libbfd-dev gcc clang-12 llvm zlib1g-dev python-is-python3 libabsl-dev
    -

    这个命令最后的结果是，秒速出hi，然后等待10s后结束，了。由于echo的输出与stdin没有关系，所以，echo不会阻塞读入stdin，等待管道关闭，而是会即刻输出hi。

    + + +

    运行ghOSt

    克隆ghOSt用户态：

    +
    git clone https://gitlab.eduxiji.net/202318123111334/ghost_userspace.git
    cd ghost-userspace
    + +]]> + + + Lab4 TCPConnection + /2023/02/25/cs144$lab4/ + Lab4 TCPConnection

    心得

    耗时情况

    【长舒一口气】

    +

    最开始先记录下总体耗时情况吧。本次实验共耗费我16h+【不包括接下来写笔记的时间23333】，共耗费三个工作日。第一天看完了指导书，写完了代码，过掉了#45 reorder之前的所有测试。第二天过掉了#55 t_ucS_1M_32k之前的所有测试，直到第三天才过完了所有测试。

    +

    我觉得这整个过程还是挺有意义的，每天都有新的进展，看到test case越过越多是真的很高兴。但是可以说第二天以来就都是面向测试用例改bug了，非常折磨非常坐牢，既要去再次理清之前写过的shit山，又得搞清楚很多让人一头雾水不知从何下手的地方。但总之，这三天很充实，并不会让人觉得心累。

    +

    放个通关截图吧，感人至深。

    +

    image-20230305160608116

    +

    思路

    在TCPConnection中具体要做什么，指导书已经写得很详细了，跟着指导书就行。代码部分还是不折磨的，思路直观清晰。

    +

    指导书内容

    +

    Here are the basic rules the TCPConnection has to follow:

    -

    管道实际上就相当于：

    -
    echo hello world | wc
    echo hello world > /tmp/xyz; wc < /tmp/xyz
    +
      +

    1. Receiving segments

      +

      大概是在segment_received中做

      +

      image-20230303103640065

      +
        +

      1. 检查RST flag

        +

        如果RST被设置，sets both the inbound and outbound streams to the error state，杀死当前connection

        +

        return;

        +

        具体实现中，杀死connection可以置_linger_after_streams_finish为false。 the inbound and outbound streams对应着receiver和sender里的stream。让它们都处于error状态，只需设置ByteStream中的error字段

        +
        2. +

      2. 如果收到的segment with an invalid sequence number，connection需要发送empty segment应答

        +

        image-20230303110238265

        +
        3. +

      3. 转发segment给receiver

        +
        4. +

      4. 如果ACK，则把ackno和win_size给sender

        +
        5. +
      +
      2. +

    2. Sending segments

      +
        +
      1. 任何时候sender把segment放进其out流，你都要从中取出来
        2. +
      2. 从receiver处获取ackno和window_size，填入segment中
        3. +
      3. 放到自己的segment_out中
        4. +
      +

      从上述表述中，我们需要注意两点：

      +
        +

      1. 顺带ACK

        +

        可以看到，这跟我们上课的时候所学的一样，是“顺带ACK”，也即ACK报文并非独立发送，而是在下一次要发送其他数据报文的时候携带发送。这也一定程度上使得ack报文发送不会太频繁也不会太稀疏。

        +
        2. +

      2. 一定要经由sender

        +

        我们如果想要发送一个报文，一定得先把它存入sender中，再从sender的segment_out中取出来。这样做的目的是把该报文列入sender的超时重传管辖范围，你如果直接把报文发送到自己的segment_out中，就无法管理其超时重传了

        +
        3. +
      +
      3. +

    3. When time passes

      +

      在tick()中

      +
        +
      1. 调用sender的tick()
        2. +
      2. 检查sender的连续超时重传次数，如果大于MAX RETX ATTEMPTS，则关闭连接，并且发送RST标志的空报文
        3. +
      3. end the connection cleanly if necessary
        4. +
      +
      4. +
    +

    再注意一点对于connection的关闭。它要求有一个time pass

    +

    image-20230303111131650

    +

    image-20230303112817891

    +

    第一点挺好实现的，第二点需要在析构函数中检测。

    +

    最后的5.1部分值得一看。

    +

    接口说明

    TCPConnection的public函数接口定义以及具体要做什么如下。结合上面的指导书内容，TCPConnection的实现就很简单了，我就不多bb了。

    +
     private:
       TCPConfig _cfg;
       // 一个endpoint可以同时作为sender和receiver。
       TCPReceiver _receiver{_cfg.recv_capacity};
       TCPSender _sender{_cfg.send_capacity, _cfg.rt_timeout, _cfg.fixed_isn};

       //! outbound queue of segments that the TCPConnection wants sent
       // 把要发送的segment放在这里就行了
       std::queue<TCPSegment> _segments_out{};

       //! Should the TCPConnection stay active (and keep ACKing)
       //! for 10 * _cfg.rt_timeout milliseconds after both streams have ended,
       //! in case the remote TCPConnection doesn't know we've received its whole stream?
       bool _linger_after_streams_finish{true};

     public:
       // 也许需要调用TCPSender的fill_window()，然后从其segment_out中取出来，再发送给自己的segment_out
       // Initiate a connection by sending a SYN segment初始化connection并且发送SYN
       void connect();

    /*  这几个都很好实现，都很直观，只需调sender和receiver的API就行  */
       // 由上层socket调用，data路径 socket->connection->sender.stream_in().write()
       //! \brief Write data to the outbound byte stream, and send it over TCP if possible
       //! \returns the number of bytes from `data` that were actually written.
       size_t write(const std::string &data);
       //! \returns the number of `bytes` that can be written right now.
       size_t remaining_outbound_capacity() const;
       //! \brief Shut down the outbound byte stream (still allows reading incoming data)
       void end_input_stream();
       //! \brief The inbound byte stream received from the peer
       ByteStream &inbound_stream() { return _receiver.stream_out(); }
       // number of bytes sent and not yet acknowledged, counting SYN/FIN each as one byte
       size_t bytes_in_flight() const;
       //! \brief number of bytes not yet reassembled
       size_t unassembled_bytes() const;

       //! \brief Number of milliseconds since the last segment was received
       size_t time_since_last_segment_received() const;

    // debug用
       //!< \brief summarize the state of the sender, receiver, and the connection
       TCPState state() const { return {_sender, _receiver, active(), _linger_after_streams_finish}; };

       // 这些函数都会由上层在某些时候调用
       // 时钟滴答、收到segment以及从segment_out中取数据，这些都是由os调用相应函数实现的
       // 这也正是所谓“协议”的接口意义！
       //! \name Methods for the owner or operating system to call
       //! Called when a new segment has been received from the network
       void segment_received(const TCPSegment &seg);

       //! Called periodically when time elapses
       void tick(const size_t ms_since_last_tick);

       //! \brief TCPSegments that the TCPConnection has enqueued for transmission.
       //! \note The owner or operating system will dequeue these and
       //! put each one into the payload of a lower-layer datagram (usually Internet datagrams (IP),
       //! but could also be user datagrams (UDP) or any other kind).
       std::queue<TCPSegment> &segments_out() { return _segments_out; }

       //! \brief Is the connection still alive in any way?
       //! \returns `true` if either stream is still running or if the TCPConnection is lingering
       //! after both streams have finished (e.g. to ACK retransmissions from the peer)
       bool active() const;

       //! Construct a new connection from a configuration
       explicit TCPConnection(const TCPConfig &cfg) : _cfg{cfg} {}

       //! \name construction and destruction
       //! moving is allowed; copying is disallowed; default construction not possible

       ~TCPConnection();  //!< destructor sends a RST if the connection is still open
       TCPConnection() = delete;
       TCPConnection(TCPConnection &&other) = default;
       TCPConnection &operator=(TCPConnection &&other) = default;
       TCPConnection(const TCPConnection &other) = delete;
       TCPConnection &operator=(const TCPConnection &other) = delete;
    -

    在这种情况下，管道相比临时文件至少有四个优势

    -
      -
    • 首先，不用删文件
      • -
    • 其次，管道可以任意传递长的数据流
      • -
    • 第三，管道允许一定程度上的并行
      • -
    • 第四，如果实现进程间通讯，管道的块读写比文件的非块语义更有效率。
      • -
    -

    File system

    inode：代表文件本体，包括文件类型、文件长度、文件内容在磁盘位置、文件的链接数

    -

    link：指向文件的链接，一个文件可以有多个link，link内包含文件名和对inode的引用

    -

    当链接数=0，且句柄数=0，文件的磁盘空间和inode索引就会被释放

    -

    Lab Xv6 and Unix utilities

    配置实验环境

    -

    参考文章：

    -

    xv6环境搭建

    -

    【MIT6.S081/6.828】手把手教你搭建开发环境

    +

    测试程序

    这部分暂时还不大明白，随便瞎写一点（）

    +

    首先是socket实现，似乎要涉及到对一些事件，比如说segment receive的监听。它具体是这么做的：

    +
    // in libsponge/tcp_helper/tcp_sponge_socket.cc  _initialize_TCP()
        // Set up the event loop

        // There are four possible events to handle:
        //
        // 1) Incoming datagram received (needs to be given to
        //    TCPConnection::segment_received method)
        //
        // 2) Outbound bytes received from local application via a write()
        //    call (needs to be read from the local stream socket and
        //    given to TCPConnection::data_written method)
        //
        // 3) Incoming bytes reassembled by the TCPConnection
        //    (needs to be read from the inbound_stream and written
        //    to the local stream socket back to the application)
        //
        // 4) Outbound segment generated by TCP (needs to be
        //    given to underlying datagram socket)
    + +

    比如说event4：

    +

    image-20230304171810877

    +
    +

    什么是eventloop

    +

    事件循环（event loop）就是 任务在主线程不断进栈出栈的一个循环过程。任务会在将要执行时进入主线程，在执行完毕后会退出主线程。

    +

    这里的大致意思就是增加了一个监听事件，一旦tcp_connection的segments_out有元素，就会马上取出来

    -

    下载工具链

    $ sudo apt-get install git build-essential gdb-multiarch qemu-system-misc gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu
    +

    这部分不大懂，不知道后面会不会涉及对socket的编写？

    +

    还有一点是对测试脚本好像有了点了解。比如在build/CTestTestfile.cmake中可以看到每个测试的对应脚本以及使用的options：

    +

    image-20230304170132380

    +

    如果不知道option的用法可以这么做：

    +

    image-20230305232621024

    +

    这些脚本实现的对应代码在sponge/apps中。

    +

    又比如，在sponge/etc/tests.cmake中，可以找到各个测试程序执行的参数，就可以比如说修改测试的Timeout时间：

    +

    image-20230305232913611

    +

    总结：状态机

    我们已经完整实现了整个TCP协议，是时候该对其做出一个总结了。

    +

    TCP协议本质上是一个状态机。

    +

    在我们的sponge TCP中，我们将一个endpoint的TCP协议分成了两个状态机，一个是TCPReceiver的状态机，另一个是TCPSender的状态机。它们依据外界的输入【从app或者互联网】来进行状态的转移。

    +

    以下几张图完美地体现了状态转移关系【具体的状态体现标注在代码中了】：

    +

    image-20230226200935395

    +

    image-20230226202631406

    +

    image-20230305225738049

    +

    image-20230225232723083

    +

    而TCPConnection并不是状态机，它是两个状态机和外界联通的桥梁。它的职能有：

    +
      +

    1. 给状态机提供输入

      +

      包括：

      +
        +
      1. app调用write传进来的数据
        2. +
      2. peer通过segment_received传进来的数据
        3. +
      +
      2. +

    2. 处理状态机的输出

      +

      包括：

      +
        +
      1. app调用receiver的stream接口获取数据
        2. +
      2. 通过send_segment向peer传递数据
        3. +
      +
      3. +
    +

    也可以说，它具有显式推动状态机状态转移的作用，比如说：

    +
      +
    1. 给状态机传递外界数据让他们转移
      2. +
    2. connect通过调用fill_window推动_sender从CLOSED状态转移到SYN_SENT状态
      3. +
    3. 转移到ERROR状态的条件判断
      4. +
    +

    等等等。

    +

    也因而，TCPConnection并不包含复杂的逻辑和算法，它仅仅是做一些条件判断，以及一些数据转发的工作。

    +

    喜闻乐见的bug合集

    相比于代码的编写，本次实验最难的部分是测试。由于lab4基于lab0-3，因而前面没有发现的bug在本次黑压压162个测试之下会全部涌现出来。有些bug我还是不知道怎么回事，并且debug过程也不像xv6那样条理清晰步步为营，感觉充满着不少玄幻色彩，所以也没有很多干货好说。在这里就先记录下印象比较深刻，耗时比较久的bug吧。

    +

    TCP produced ‘ackno=1’

    image-20230303214944132

    +

    需要发送一个ackno=2的帧，但是不知道为什么却发送了一个ackno=1的，并且无论我怎么找，在哪里print，都只能找到一个ackno=2的，连1的影子都看不到。这个现象确实很诡异，但其实它的内因很简单。它是由于我对空的ACK帧发送条件限制得不恰当才出现的。

    +
    +

    有没有觉得这里有点跳跃？我是怎么通过这个现象得知是ACK发送不恰当导致的？

    +

    答案是我当时也没想到这一点，无头苍蝇般转了可能有一个小时，这里print一下那里print一下都没有发现异常。最后我放弃了这个用例去看下一个错误的用例，才发现了这个小bug，改了一下发现这个也一起过了【绷】

    +
    +

    本来我是这么写的：

    +
    // 把_sender的所有segment都发送出去
    void TCPConnection::segment_send() {
        // 当没有要发送的帧，无法进行顺带ACK时，就只能发送一个只有ACK的空帧
        if (_sender.segments_out().empty()) {
            if (_receiver.ackno().has_value()) {
                _sender.send_empty_ack_segment(_receiver.ackno().value());
            }
        }
        while (!_sender.segments_out().empty()) {
            // ...
        }
    }

    // in segment_received()
        //if (seg.length_in_sequence_space() != 0) {
        //    empty_ack_send();
        //}
        segment_send();
    -

    测试安装ok：

    -
    $ qemu-system-riscv64 --version
    QEMU emulator version 5.1.0
    //下面其中之一正常就行
    $ riscv64-linux-gnu-gcc --version
    riscv64-linux-gnu-gcc (Debian 10.3.0-8) 10.3.0
    ...
    $ riscv64-unknown-elf-gcc --version
    riscv64-unknown-elf-gcc (GCC) 10.1.0
    ...
    $ riscv64-unknown-linux-gnu-gcc --version
    riscv64-unknown-linux-gnu-gcc (GCC) 10.1.0
    ...
    +

    如果这么写的话，当这台endpoint收到peer的一个empty ACK后，它就也会以示敬意回复一个empty ACK，这样除了本应发过去的ackno=2的报文，就多了个幽灵般的ackno=1的empty ACK，从而导致上面的错误。

    +

    因而，正确的做法是，我们在receive时只对**!empty**的seg进行ACK回复就行。具体写法可以看看我下面的代码。

    +

    超时重传时间翻倍问题

    image-20230303224104016

    +

    image-20230303224053277

    +

    可以看到，它是想要我们在1000ms后再发一次FIN的，也即rto依然等于1000，但是我们的rto却是2000.为啥呢？那就去看看超时重传呗。

    +

    原来的超时重传代码：

    +
    // in libsponge/tcp_sender.cc
    if (timer_start && ticks > timer_ticks && ticks - timer_ticks >= rto) {
        // resend
        if (!tmp_segments.empty()) {
            _segments_out.push(tmp_segments.front().segment);
        }

        if (window_size != 0) {
            cons_retran++;
            rto *= 2;
        }
        timer_ticks = ticks;
    }
    + +

    改完后：

    +
    if (timer_start && ticks > timer_ticks && ticks - timer_ticks >= rto) {
        if (!tmp_segments.empty()) {
            // resend
            _segments_out.push(tmp_segments.front().segment);

            if (window_size != 0) {
                cons_retran++;
                rto *= 2;
            }
        }
        timer_ticks = ticks;
    }
    + +

    想想超时重传的定义，是不是重传了之后才会double时间呀（）

    +

    assembler

    image-20230304163111298

    +

    这个test花了我半个下午的时间排查和修改。大致流程及报错信息是，一方发了65000个byte，但是另一方只能收到<<65000个。最后print了一下，发现是streamassembler写错了，在stream end的时候仍然有很大一部分数据未被整流。

    +
    +

    这个直面屎山的经历极大地鼓舞了我

    +
    +

    之前在写streamassembler的时候就知道有个地方是错的了，那就是我对capacity的理解【具体见前面的笔记】。现在只用改一下就好了。修改方式很简单，加上这两句话就行：

    +
    right = right <= left_bound + _capacity ? right : left_bound + _capacity;  // 右边越界的也不要
    if (o_left >= left_bound + _capacity)       goto end;  // 越界的不要
    + +

    t_udp_client_send超时

    image-20230304215748823

    +

    这个错因非常地诡异，我到最后也还是没有自己找出来。直到我瞎搜来搜去看到了这篇文章：

    +
    +

    我也是真的很佩服这篇文章的作者能找到这个点

    +

    image-20230304221420748

    +

    https://www.cnblogs.com/lawliet12/p/17066719.html

    +
    +

    image-20230305215310021

    +

    噔噔咚。

    +

    我为什么不用_cfg.rt_timeout呢？答案是我当初脑子一抽以为rt_timeout是static、const的，就写了个TCPConfig::rt_timeout然后报错了，我懒得思考了就换成了上面的那个，结果……就这东西，又花费了我好久好久【悲】怪我没有认真看，没发现rt_timeout不是一个静态常量。

    +

    t_ucS_1M_32K超时

    image-20230305162239877

    +

    以及其后面的其他test也都超时了。

    +

    说实话我真是百思不得其解，这里打印来那里打印去，也都看得眼花缭乱什么也看不出来，使用指导书那些手动测试的方法，还有抓包，都十分地正常，但它自动测试就是会timeout。

    +

    我折腾来折腾去，这里print那里print，最后还怀疑是电脑问题就放到服务器上跑了一下结果还是不行。绝望之际，我只能使出了万策尽之时的迫不得已的非法手段：将我的一部分代码替换成别人的看看会怎么样。【传统艺能23333】

    +

    最终我定位发现是TCPSender出了问题，我猜测是因为状态机出错了。我比对着别人的代码【知道这不对，但我心态已经崩了。。。】，以及指导书提供的状态机，发现是这个地方出了小问题：

    +

    image-20230305220614819

    +
    // in tcp_sender.cc fill_window()
    		// 注释的是以前写的错误版本
            // if (_stream.input_ended() && !fin && remaining > 0) {
            if (_stream.eof() && !fin && remaining > 0) {
                // last segment
                segment.header().fin = true;
                fin = true;
                remaining -= 1;
            }
    +

    这里不应该是input_ended，而应该是eof……

    +

    改了之后立刻所有测试都能跑通了【悲】

    -

    注，这里出现了一个问题，qemu-system-riscv64 --version打出来发现qemu-system-riscv64 command not found。似乎是我的ubuntu16.04版本太低了【悲】去看了下网上，可以按照这个来做：

    -

    rCore qemu risc-v 实验环境配置

    -
    -

    下载编译xv6源码

    随后，进入一个你喜欢的文件夹clone xv6的实验源码，输入

    -
    $ git clone git://g.csail.mit.edu/xv6-labs-2020
    $ cd xv6-labs-2020
    $ git checkout util
    +

    那么问题来了，为什么错误版本就会timeout呢？我的猜测如下：

    +

    eof的条件如下：

    +
    bool ByteStream::eof() const { return is_input_end && buffer.empty(); }
    -

    然后进行编译

    -
    $ make
    $ make qemu
    +

    可以看到，eof既要求input_ended，又要求缓冲区内所有数据成功发送。这也很符合FIN_SENT的语义：在数据流终止时（所有数据成功发送，不要求fully acked）发送FIN。

    +

    如果按照我错误版本的写法，会导致数据还没发送完毕（!buffer.empty()），就发送了FIN。之后数据虽然还能正常进入receiver的bytestream，并且发送给peer的receiver。但是会存在这也一个空窗期：FIN之后的数据还没到的时候，peer的receiver接收到FIN，并且peer的app从socket将receiver接收到的数据全部读出。出现了这样的空窗期，就会导致peer的receiver的stream达到eof状态：

    +
    // in tcp_receiver.cc segment_received()
         if (abs_seqno != 0)
             _reassembler.push_substring(data, index, header.fin);
    // in streamassembler.cc
     if (is_eof && buffer.empty()) {
         _output.end_input();
     }
    -

    如果此处发生错误：unrecognized command line option -mno-relax，则按照此说法 xv6环境搭建更新gcc版本

    -
    $ sudo apt install gcc-8-riscv64-linux-gnu
    $ sudo update-alternatives --install /usr/bin/riscv64-linux-gnu-gcc riscv64-linux-gnu-gcc /usr/bin/riscv64-linux-gnu-gcc-8 8
    +

    【接下来就是猜了】由于bytestream eof了，socket就停止读了。后来的数据再来，receiver的stream的缓冲区就满了，receiver就只能一直丢包。【接下来是真的纯猜】而且由于测试脚本问题，在这之后都不会调用tick方法了，故而超时重传检测不会被触发，而sender也会因为没有ack，而一直重传重传，就死循环然后timeout寄掉了。

    +

    纯猜部分的依据是：

    +

    image-20230305173110776

    +

    image-20230305173152469

    +

    可以看到，tick方法一直被调用，但是ticks却不变。数据报文一直被重传，但是retran一直不变。ticks-timer_ticks一直大于rto，但却始终无法进入那句if（经测试是这样的）。这非常奇怪，我也不知道为什么。

    +
    +

    代码

    【珍贵的调试用代码没删的版本放在github了。】

    +

    TCPConnection.hh

    class TCPConnection {
      private:
    // ...
        size_t rec_tick{};// 上一次收到segment时的ticks数
        size_t ticks = 0;
      public:
        void segment_send();
        void empty_ack_send();
        void set_rst();
    // ...
    -

    再执行一次

    -
    $ make
    $ make qemu
    +

    TCPConnection.cc

    如果想要以状态机的视角来看待，可以看看感恩的代码。他写得很清晰。

    +
    #include "tcp_connection.hh"
    #include <iostream>

    template <typename... Targs>
    void DUMMY_CODE(Targs &&... /* unused */) {}

    using namespace std;

    size_t TCPConnection::remaining_outbound_capacity() const { return _sender.stream_in().remaining_capacity(); }

    size_t TCPConnection::bytes_in_flight() const { return _sender.bytes_in_flight(); }

    size_t TCPConnection::unassembled_bytes() const { return _receiver.unassembled_bytes(); }

    size_t TCPConnection::time_since_last_segment_received() const { return ticks - rec_tick; }

    // 发送一个只有ACK的空帧，仅在segment_received中调用
    // 当没有要发送的帧，无法进行顺带ACK时，
    // 为了保障一定有ACK发送，就只能发送一个只有ACK的空帧
    void TCPConnection::empty_ack_send() {
        if (_sender.segments_out().empty()) {
            if (_receiver.ackno().has_value()) {
                _sender.send_empty_ack_segment(_receiver.ackno().value());
            }
        }
    }

    // 把_sender的所有segment都发送出去
    void TCPConnection::segment_send() {
        while (!_sender.segments_out().empty()) {
            TCPSegment seg = _sender.segments_out().front();
            // 顺带ACK
            if (_receiver.ackno().has_value()) {
                seg.header().ack = true;
                seg.header().ackno = _receiver.ackno().value();
            }
            seg.header().win = _receiver.window_size();
            _segments_out.push(seg);
            _sender.segments_out().pop();
        }
    }

    // connection被置为error状态的部分必要操作
    void TCPConnection::set_rst() {
        _sender.stream_in().set_error();
        _receiver.stream_out().set_error();
        _linger_after_streams_finish = false;
    }

    void TCPConnection::segment_received(const TCPSegment &seg) {
        // 重置发送的ticks
        rec_tick = ticks;
        
        if (seg.header().rst) {
            // RST is set
            set_rst();
            return;
        }
        
        // 回复对方问你是死是活的信息
        if (_receiver.ackno().has_value() && seg.length_in_sequence_space() == 0 &&
            seg.header().seqno - _receiver.ackno().value() < 0) {
            _sender.send_empty_segment();
            segment_send();
            return;
        }
        
        _receiver.segment_received(seg);
        
        if (seg.header().ack) { // ack_received也会调用fill_window
            _sender.ack_received(seg.header().ackno, seg.header().win);
        } else
            _sender.fill_window();
        
    	// 只在本次收到的seg需要被ACK的时候才要ACK。
        // 需要被ACK：FIN/SYN/携带数据   总之就是length!=0
        // 不得不说，FIN和SYN都会占一个序列号这个点给ACK设计带来了简便，同时也增加了安全性
        if (seg.length_in_sequence_space() != 0) {
            empty_ack_send();
        }
        
        segment_send();
        
        // If the inbound stream ends before the TCPConnection has reached EOF 
        // on its outbound stream, this variable needs to be set to false
        // 如果receiver的那个stream比sender的stream早结束，就不用等待
        // 为什么呢？因为receiver的stream结束说明了全部的seg都成功接收并且全部整流【参见assembler实现】
        // 也就说明对方不发送数据了，并且已经把FIN也发过来了
        // 也即对方进入了FIN_WAIT状态
        // 而我们的sender还在输出，也即我们在CLOSE_WAIT状态
        // 因而我们只需输出完剩余数据再发送AF,最后直接关闭就行
        // 因为我们知道对方已经关闭了，无需再进行linger。
        if (_receiver.stream_out().input_ended() && !_sender.stream_in().eof()) {
            // peer:FIN_WAIT   self:CLOSE_WAIT
            _linger_after_streams_finish = false;
        }
    }

    bool TCPConnection::active() const{
        // 处于error状态
        if (!_linger_after_streams_finish && _receiver.stream_out().error() && _sender.stream_in().error()) {
            return false;
        }
        
        // 满足条件1-3
        if (_receiver.stream_out().input_ended() &&
            _sender.stream_in().eof() && _sender.bytes_in_flight() == 0 && _sender.fully_acked()) {
            // 无需等待的话就直接返回false
            if (!_linger_after_streams_finish)
                return false;
            // 否则需要等待10*timeout
            else if (time_since_last_segment_received() >= 10 * _cfg.rt_timeout){
                return false;
    		}
        }
        return true;
    }

    size_t TCPConnection::write(const string &data) {
        size_t res = _sender.stream_in().write(data);
        // 注意此处需要手动调一下fill_window和send方法
        _sender.fill_window();
        segment_send();
        return res;
    }

    // ms_since_last_tick: number of milliseconds since the last call to this method
    void TCPConnection::tick(const size_t ms_since_last_tick) {
        ticks += ms_since_last_tick;
        _sender.tick(ms_since_last_tick);
        if (_sender.consecutive_retransmissions() > _cfg.MAX_RETX_ATTEMPTS) {
            while (!_sender.segments_out().empty())
                _sender.segments_out().pop();  // 清除sender遗留的所有帧
            _sender.send_empty_rst_segment();// 只发送rst帧
            set_rst();
        }
        segment_send();
        
        // end the connection cleanly if necessary
        if (_receiver.stream_out().input_ended() &&
            _sender.stream_in().eof() && _sender.bytes_in_flight() == 0 && _sender.fully_acked()
    	&& time_since_last_segment_received() >= 10 * _cfg.rt_timeout) {
            // 等待结束
    	    _linger_after_streams_finish = false;
        }

    }

    void TCPConnection::end_input_stream() {
        _sender.stream_in().end_input();
        _sender.fill_window();
        segment_send();
    }

    void TCPConnection::connect() {
        _sender.fill_window();
        // send_segment重复代码。目的是防止发送SYN外还发送别的东西
        if (!_sender.segments_out().empty()) {
            TCPSegment seg = _sender.segments_out().front();
            if (_receiver.ackno().has_value()) {
                seg.header().ack = true;
                seg.header().ackno = _receiver.ackno().value();
            }
            seg.header().win = _receiver.window_size();
            _segments_out.push(seg);
            _sender.segments_out().pop();
        }
    }

    TCPConnection::~TCPConnection() {
        try {
            // shutdown uncleanly
            if (active()) {
    	    	set_rst();
                _sender.send_empty_rst_segment();
                segment_send();
            }
        } catch (const exception &e) {
            std::cerr << "Exception destructing TCP FSM: " << e.what() << std::endl;
        }
    }
    -

    就ok了。

    -

    关闭qemu

    qemu退出操作

    -

    在这里记个强制方法：

    -
    ps -elf | grep qemu
    +

    debug函数

    // in libsponge/tcp_helper/tcp_segment.hh
    void print_seg() const{
             std::cerr<<"  flag="<<(header().syn?"S":"")<<(header().ack?"A":"")<<(header().fin?"F":"")
                <<"  seqno="<<header().seqno.raw_value()<<"   ackno="<<header().ackno.raw_value()
                <<"  payload_size:"<<payload().size()<<std::endl;
    }
    -

    image-20230105153458808

    -

    记住第二个的pid

    -

    然后

    -
    kill 3303
    +

    in libsponge/tcp_helper/fd_adapter.cc

    +

    image-20230304172207234

    +]]>     +     + + rtt硬件环境搭建 + /2023/10/12/rtt%E7%A1%AC%E4%BB%B6%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/ + SDK/内核编译

    编译内核和sdk时到没有太大问题，都能靠gpt or 修改menuconfig解决。比较棘手的果然还是只能靠自己摸索硬件hhh

    +

    烧录

    这个也是狠狠折磨了我许久，gpt也一直满嘴跑火车，毕竟一开始串口连错了所以一直以为自己是烧录没对，整了半天【而且还是正确的操作反反复复尝试……仿佛坐牢】。不过这其中也学到了挺多。

    +

    f2753b5e6a40f9fea328223b197ede3

    +

    具体要做的是：

    +
    sudo fdisk /dev/sdb
    -

    测试gdb是否ok

    见该文章最后一部分

    -

    【MIT6.S081/6.828】手把手教你搭建开发环境

    -

    自测方法

    make grade
    +
    +

    关于fdisk及part这样的分区工具，这篇文章介绍得很详细：Linux 系统中关于磁盘分区工具的使用

    +
    +

    然后进入后，n命令创建新分区，d删除现有分区。我们需要用n创建两个分区（大小随意），第一个用于存放bin文件。创建完分区之后，使用a命令将分区1标记为Boot，并且使用t将分区1的类型修改为W95 FAT32 (LBA)，随后就可以保存退出了。具体流程及操作结果如下：

    +
    $ sudo fdisk /dev/sdb

    Welcome to fdisk (util-linux 2.37.2).
    Changes will remain in memory only, until you decide to write them.
    Be careful before using the write command.

    Command (m for help): p

    Disk /dev/sdb: 29.72 GiB, 31914983424 bytes, 62333952 sectors
    Disk model: Storage Device  
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: dos
    Disk identifier: 0xd4c6d64f

    Command (m for help): n
    Partition type
       p   primary (0 primary, 0 extended, 4 free)
       e   extended (container for logical partitions)
    Select (default p): 

    Using default response p.
    Partition number (1-4, default 1): 
    First sector (2048-62333951, default 2048): 
    Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-62333951, default 62333951): +128M

    Created a new partition 1 of type 'Linux' and of size 128 MiB.
    Partition #1 contains a vfat signature.

    Do you want to remove the signature? [Y]es/[N]o: yes

    The signature will be removed by a write command.

    Command (m for help): n
    Partition type
       p   primary (1 primary, 0 extended, 3 free)
       e   extended (container for logical partitions)
    Select (default p): 

    Using default response p.
    Partition number (2-4, default 2): 
    First sector (264192-62333951, default 264192): 
    Last sector, +/-sectors or +/-size{K,M,G,T,P} (264192-62333951, default 62333951): 

    Created a new partition 2 of type 'Linux' and of size 29.6 GiB.

    Command (m for help): t
    Partition number (1,2, default 2): 0c
    Value out of range.
    Partition number (1,2, default 2): 1
    Hex code or alias (type L to list all): 0c

    Changed type of partition 'Linux' to 'W95 FAT32 (LBA)'.

    Command (m for help): a
    Partition number (1,2, default 2): 1

    The bootable flag on partition 1 is enabled now.

    Command (m for help): p
    Disk /dev/sdb: 29.72 GiB, 31914983424 bytes, 62333952 sectors
    Disk model: Storage Device  
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: dos
    Disk identifier: 0xd4c6d64f

    Device     Boot  Start      End  Sectors  Size Id Type
    /dev/sdb1  *      2048   264191   262144  128M  c W95 FAT32 (LBA)
    /dev/sdb2       264192 62333951 62069760 29.6G 83 Linux

    Filesystem/RAID signature on partition 1 will be wiped.

    Command (m for help): w
    The partition table has been altered.
    Calling ioctl() to re-read partition table.
    Syncing disks.
    -

    或者如果只想测其中一个，可以：

    -
    ./grade-lab-util sleep
    +

    然后更新分区表，格式化文件系统，复制bin和sd文件、弹出sd卡：

    +
    sudo partprobe 
    sudo mkfs.vfat -F 32 /dev/sdb1
    sudo mkfs.vfat -F 32 /dev/sdb2
    sudo mount /dev/sdb1 /mnt/sdb1
    sudo cp boot.sd fip.bin /mnt/sdb1
    sudo umount /mnt/sdb1 
    sudo eject /dev/sdb
    -

    make qemu后卡住

    疑似qemu版本不对。解决方法

    -

    实验内容

    编写sleep.c

    -

    Implement the UNIX program sleep for xv6; your sleep should pause for a user-specified number of ticks. A tick is a notion of time defined by the xv6 kernel, namely the time between two interrupts from the timer chip. Your solution should be in the file user/sleep.c.

    -

    image-20230105164146100.png

    -
    -
    体会
    参数

    注意，他要求我们实现的sleep的参数是ticks的数量，不是秒数。我花了半天找时钟周期大小这个参数在哪，找了许久没找到，估计是没考虑到这一点。

    -

    比如说，我翻了一下linux0.11的源码，在include/linux/time.h下有这句：

    -

    image-20230105162505574.png

    -

    说明了时钟频率大小。在xv6好像没有看到对这个的显式说明。

    -
    系统调用过程

    感受了一下xv6的系统调用过程，跟linux0.11还是很相像的。

    -

    这个好像是lab2的内容，我暂且先在此放下我体会到的感受。

    +

    就烧录ok了。

    +

    与此同时也顺便学了下Windows磁盘管理，感觉也挺方便。

    +

    串口连接

    不得不说十分惨痛……

    +

    也是因为我太狂妄自大不仔细了，一直以为RX就得连RX，TX就得连TX，然后下午焦灼之中才突然想起来这俩是不是以前教过得反着连……搜了一下果然是草。

    +

    这个错误害我起码花了三个小时在纠结烧录问题，一直以为没输出是因为烧录不对，发现结果那一刻我真没蚌珠。哎，以后还是别对自己太自信，毕竟本质上这种东西不是专业的学得也不够扎实，做什么都得先查一下该怎么做。

    +

    另一个问题是，乱码：

    +

    58c63791e1b4cac06a827f0ffa6b329

    +

    好像是说使用了个ch340的usb-ttl，似乎这个东西波特率有点问题不准确，具体不大懂：CH340G U-BOOT阶段乱码 总之最后简单粗暴地靠修改波特率为117200解决了。

    +

    然后别的倒是没什么问题，虽然摸索也花了点时间，都是小事。对着这张图参照就行了：

    +

    mmexport1697102534057

    +

    开发过程

    感觉有一些东西，还是比较靠悟性23333在此记录些开发过程中的小发现。

      -

    1. xv6

      -

      首先是从用户态到内核态的切换。

      -

      在user/user.h中有各个系统调用外化的函数签名。在用户程序中调用里面的函数签名，就会执行【说实话，我没看懂为什么这里会知道要从user.h跳到usys.S中执行，也许是Makefile里有写？】user/usys.S中对应的汇编代码，比如说这种：

      -

      image-20230105170701334

      -

      然后这个SYS_close这种，其实是系统调用号宏，被定义在kernel/syscall.h中：

      -

      image-20230105171327076.pn

      -

      li a7,SYS_call就是把SYS_call的值放入a7寄存器，大概就是传参的意思。ecall是从用户态转到内核态的指令。这样一来，就完成了从用户态到内核态的切换。

      -

      然后是在内核态的执行。

      -

      切换到内核态之后的执行步骤跟linux0.11可以说是完全一样。

      -

      首先应该是会去执行kernel/syscall.c中的syscall函数，具体应该是通过ecall引发0x80中断，然后查表得知这个syscall是中断处理函数

      -

      image-20230105172110475.pn

      -

      可以看到，syscall获取了a7里的参数，然后查了系统调用表

      -

      image-20230105173019159

      -

      然后去sysproc.c文件下执行相应的sys_xxx函数。这个函数指针用得真是牛逼。

      -

      再然后，sys_xxx函数中会从栈中取出调用参数，再跳转到xxx(args)函数中去（这些xxx函数一般在kernel中以单独文件形式出现）。

      -

      这样一来，就完成了一次系统调用。

      -
      2. -

    2. linux0.11

      -

      首先是用户态到内核态的切换。

      -

      在用户态中比方说调用system call close()，则会调用lib/close.c下的：

      -

      image-20230105173820813

      -

      展开这个宏之后，是这样的：

      -

      image-20230105173845317

      -

      具体意思就是把close的系统调用号存入参数寄存器，然后引发0x80中断，进入内核态。

      -

      然后是在内核态的执行。

      -

      查表会得知sys_call函数是0x80中断的中断处理函数，然后就会根据参数里的系统调用名字去找系统调用表执行

      -

      image-20230105174832400

      -

      这部分跟xv6差不多，不再赘述

      +

    3. 关于引脚

      +

      两个引脚可以通过image-20231019162502551这玩意连起来，这样就能使一个引脚的output作为另一个引脚的input。

      +

      这是我在开发gpio中断时意识到的。这个道理虽然非常简单，但对于零基础胡乱摸索的我，知道这个还是需要一些灵光一闪。

      4. +
    -

    可见，这两个系统在内核态的实现是差不多的，只是在用户态有点稍稍不一样。感觉linux0.11会更加精妙一些。

    -

    编写pingpong程序

    -

    Write a program that uses UNIX system calls to ‘’ping-pong’’ a byte between two processes over a pair of pipes, one for each direction. The parent should send a byte to the child; the child should print “: received ping”, where is its process ID, write the byte on the pipe to the parent, and exit; the parent should read the byte from the child, print “: received pong”, and exit. Your solution should be in the file user/pingpong.c.

    +]]> + + + cs144 + /2023/02/25/cs144/ + +

    总耗时：65h 约17天

    +

    实验官网

    +

    感恩

    -
    体会

    思路很简单，我之所以写了那么久是因为走了好大的弯路……

    -

    题目要求输出格式为”: received ping”，我的思路固化为：先把pid化成数字，再用字符串拼接串成整个。为了实现我的思路，我就需要额外再写两个工具函数，一个是itoa，一个是strcat。而又由于malloc函数暂待实现，itoa和strcat的实现就仍然不够优雅。折腾了半天终于OK了，结果看到别人是怎么做到这个输出格式的呢？↓

    -
    fprintf(1,"%d: received ping\n",getpid());
    - -

    这下是真的尴尬了23333

    -

    但总而言之，自己写了那俩不够优雅的函数还算是有点用【大概】。以下是我的代码

    -

    编写primes

    -

    参考：

    -

    MIT操作系统实验lab1（案例：primes（质数筛选）附代码、详解）

    -

    XV6实验-Lab0 Utilities

    +

    总结

    本实验总体思维和代码上的难度还是不难的（至少比xv6简单），我认为其难点主要集中在TCP协议本身就很复杂很多的细节问题，以及需要我们有一种面向测试用例编程、直面自己往日写过的屎山的勇气（。

    +

    下面，我将对本实验的完成情况即心得进行一个总结，也算是本篇博客/本次实验的一个导读。

    +
    +

    类似于这样的块引用中的部分是我自认为的精华部分哦。

    +

    本实验对TCP-IP-ETH协议栈的实验是自顶向下的，其中对TCP协议的实现是由内而外的。

    +

    后者很容易导致，在对TCP协议的实现中，当你写完了lab0-3，你还是不知道自己到底写了个啥，以及TCP又究竟怎么通过你写的那几个类run起来。直到lab4结束，你完成了对TCP状态机的组织，并且出于debug目的钻研过部分socket的代码、熟悉了（其实差不多已经背下来了）TCP的三握手四挥手的过程，至此你才会对TCP的实现有较为清晰的理解。这个过程很痛苦，但是也真的非常爽。

    -

    Write a concurrent version of prime sieve using pipes. This idea is due to Doug McIlroy, inventor of Unix pipes. The picture halfway down this page and the surrounding text explain how to do it. Your solution should be in the file user/primes.c.

    +

    关于TCP状态机的理解总结，请参见Lab4 TCPConnection——心得——总结：状态机部分。

    -

    其实就是用生产者消费者模式来写素数计算的并发版本，这个我熟

    -

    ……以上是第一印象。然后我看着超链接文章里的素数筛的图片，以及指导书给的提示：

    +

    然而，实现了TCP协议之后，我们还是不知道，在TCPConnection中发送的数据包，又是如何到达网络上的另一个host处的，我们究竟又写了个啥。

    +

    这时，官方贴心地为我们指了条明路：它告诉我们，我们在lab0-4实现的是TCP-IP协议栈，其中运输层和网络层由用户实现，其他更底层则由内核实现，二者通过操作系统提供的TUN接口进行交互。也即，我们之前实现的是用户态TCP协议！而我们接下来的学习目标，就是从内核中再夺走一些权力：数据链路层也要由我们自己实现！

    -

    Your goal is to use pipe and fork to set up the pipeline. The first process feeds the numbers 2 through 35 into the pipeline. For each prime number, you will arrange to create one process that reads from its left neighbor over a pipe and writes to its right neighbor over another pipe. Since xv6 has limited number of file descriptors and processes, the first process can stop at 35.

    -
      -
    • Be careful to close file descriptors that a process doesn’t need, because otherwise your program will run xv6 out of resources before the first process reaches 35.
      • -
    +

    关于此处的TCP-IP架构等，请参见Lab5 NetworkInterface——Overview——承上启下

    +
    +

    故而，接下来，我们将实现用户态的TCP-IP-ETH协议栈。在lab5，我们将目光投向TCP层以下的数据链路层(网络层官方已经帮我们实现了)，实现ETH协议和ARP协议；在lab6，我们则需要实现路由查找的功能。

    +

    至此，所有实验已经结束。写完了上述实验，我们对协议栈已经具有了很深刻的了解，对TCP—IP—ETH—TAN—Internet—TAN—ETH—IP—TCP的这个数据传输过程也已经是懂王了。

    +

    然而，我们在TCPConnection，只知道会有好心人，在上层app有数据传进来的时候调用write、在下层协议栈有segment传进来的时候调用segment_received、取出_segment_out的segment向底层协议栈发送、读走outputstream的内容。但是这个所谓的“好心人”具体是怎么做到的，怎么实现的，我们一概不知。

    +

    答案是，这个所谓的“好心人”，其实就是我们的TCPSpongeSocket。它向上将协议栈与上层app连接，向下又将协议栈与TAN接口结合。

    +
    +

    发送数据时，数据流向：上层app→（通过TCPSpongeSocket）TCPConnection→（通过write方法）ByteStream→TCPSender→（通过从_sender.segments_out读）TCPConnection→（通过TCPSpongeSocket的adapter）TAN

    +

    接收数据时，数据流向：TAN→（通过TCPSpongeSocket的adapter）TCPConnection→TCPReceiver→（中间经过StreamAssembler）BYteStream→（通过TCPSpongeSocket读）上层app

    +

    在TCPSpongeSocket的adapter中：TCPsegment←→IP数据报←→ETH帧

    +

    至于ETH帧进入TAN之后的过程？在xv6的网卡驱动那一节我们事实上已经实现过了！

    +
    +

    CS144TCPSocket和FullStackTCPSokect都继承自TCPSpongeSocket。TCPSpongeSocket通过一个包装了操作系统提供的socket的包装类_thread_data来与上层app进行交互，通过adapter_datagram_adapter来与协议栈进行交互（adapter本质上也是调用了操作系统的TUN/TAN接口）。

    +

    由于_thread_data和_datagram_adapter本质上都是文件描述符【牛逼吧】，因而，TCPSpongeSocket需要跟上下层进行交互的需求，就可以通过操作系统提供的POLL机制来实现，也即，app←→TCP、TCP←→协议栈的这四种数据交互情况，都用事件监听来实现！这样就能做到“及时”“高效”了。

    +
    +

    关于此处TCPSpongeSocket的事件监听机制以及其它实现细节，详见其它的对…——Socket实现——TCPSpongeSocket

    +
    +

    至此以来，我们的协议栈才算真正完整了。

    +

    Lab0

    Lab1 StreamReassembler

    Lab2 TCPReceiver

    Lab3 TCPSender

    Lab4 TCPConnection

    Lab5 NetworkInterface

    Lab6 Router

    其他的对实验未涉及的思考

    ]]> + + labs + + + + git使用记录 + /2023/10/07/git/ + +

    记录一些git的原理学习，以及工作学习中遇到的一些git的操作问题。

    +
    +

    操作

    pull request

      +

    1. 第一次提pr

      +
        +
      1. fork原仓库
        2. +
      2. 本地clone，两个remote，fork和origin
        3. +
      3. checkout -b new-branch
        4. +
      4. 修改，add，commit，push
        5. +
      5. 在github提pr
        6. +
      +
      2. +

    2. 修改提过的pr

      +
        +

      1. 本地仓库与远程同步

        +

        直接修改，然后push到fork的对应分支就行，会自动更新。

        +
        2. +

      2. 本地仓库与远程不同步

        +

        以下操作都在new-branch分支上

        +
          +
        1. git fetch origin
          2. +
        2. git rebase origin/master
          3. +
        3. 如果有冲突则解决，然后git rebase --continue继续rebase
          4. +
        4. push fork
          5. +
        +
        3. +
      +
      3. +
    +

    rebase

    修改 git 的历史 commit，你能想到几种方案？ 详细介绍了rebase基本用法

    +

    object损坏

    image-20231030100954710

    +

    如图，我也不知道为什么突然就寄了。。。

    +

    总之进行了这些操作，虽然不知道是哪个起作用了，但总算好了：

    +

    https://blog.csdn.net/xiaoqixiaoguai/article/details/128591332

    +

    首先删除空白对象

    +
    cd .git
    find . -type f -empty -delete -print
    + +

    然后更新ref到某个版本号

    +
    cd ..
    tail -n 2 .git/logs/refs/heads/master
    git show xxxx(版本号)
    git update-ref HEAD xxxx(版本号)
    git fsck
    + +

    如果还不能用，继续：

    +
    rm .git/index
    git reset
    git fsck
    + +

    我到这里之后显示：

    +

    image-20231030101123181

    +

    继续执行：

    +
      +

    1. 修复 refs/remotes/origin/master：

      +
      bashCopy codegit update-ref -d refs/remotes/origin/master
      git fetch origin
      + +

      这将删除损坏的 origin/master 引用，然后从远程仓库重新获取。

      +
      2. +

    2. 修复 dangling blob：

      +

      如果 git fsck 显示了 dangling blob，你可以尝试删除这些对象：

      +
      bashCopy codegit reflog expire --expire=now --all
      git gc --prune=now
      + +

      这将清理无用的 dangling 对象。

      +
      3. +
    +

    成功。

    +

    原理

      +

    1. merge与rebase的差异

      +

      merge：

      +

      merge

      +

      rebase：

      +

      rebase

      +
      2. +
    2. +
    +]]>     +     + + 开源的第一个月 + /2023/10/19/open-source-9.19-10.19/ + +

    其实是9.10就开始了，但9.19才办理入职所以少算了几天xxxx不然这不显得我菜hh

    -

    义无反顾地……使用了35个管道hhhhh

    -

    然后不知道为什么不行，也焦头烂额地感觉我思路太离谱了，去看了下发现大家都是只用一个管道……

    -

    我也搞了个单管道的出来，但是思路受第一篇的影响非常地串行，也即先筛完再创建子进程。看到

    -

    XV6实验-Lab0 Utilities

    -

    这篇文章，才发现还可以那样双管道并行……我虽然也考虑过双管道，但是觉得实现不了【因为我是用循环的思路，如果要双管道的话切换会很麻烦】就没写了，没想到还可以向他那样【他选择的是一个在外部定义的p，和一个作用域更小在每次循环内定义的p1，再加上递归传递参数这个技巧，就可以接连不断递归下去了】，深感佩服。写得是真好，可以去参考学习一下，我懒得改了（

    -
    #include"user/user.h"

    int main(){
    	int p[2];
    	pipe(p);
        
    	if(fork() == 0){
    		while(1){
    			char buf[3];
    			//读入第一个数字 
    			read(p[0],buf,3);
    			int prime = atoi(buf);
    			if(prime == 36){
    				close(p[0]);
    				close(p[1]);
    				exit(0);
    			}
    			fprintf(1,"prime %d\n",prime);
    			//读入其他数字 
    			int tmp = atoi(buf);
    			while(1){
    				read(p[0],buf,3);
    				tmp = atoi(buf);
                    //输入结束
    				if(tmp == 36){
    					break;
    				}
    				if(tmp%prime!=0){
    					write(p[1],buf,3);
    				}
    			}
                //作为标记，标志着输入序列结束
    			itoa(36,buf);
    			write(p[1],buf,3);
    			if(fork()){
    			}
    			else{
    				close(p[0]);
    				close(p[1]);
    				wait(0);
    				exit(0);
    			}
    		}
    	} else{
    		close(p[0]);
    		char buf[3];
    		for(int i=2;i<=35;i++){
    			itoa(i,buf);
    			write(p[1],buf,3);
    		}
            //作为标记，标志着输入序列结束
    		itoa(36,buf);
    		write(p[1],buf,3);
    		close(p[1]);
    		wait(0);
    	}
    	exit(0);
    }
    - -

    编写find

    -

    Write a simple version of the UNIX find program: find all the files in a directory tree with a specific name. Your solution should be in the file user/find.c.

    +

    引言

    也许有许多programer与我一样，在初次接触到“开源”这个概念时，便对其产生了无限的向往。千万人通过共同的事业联结在一起，为了行业的进步不求回报地压缩自己的时间，贡献出自己的一份力，这是何等的浪漫。再加上听了无数遍的Linux发展历程故事，对“开源”我是愈发地憧憬。

    +

    然而，由于学习cs的时间尚不足，也不知道该从何入手去参与社区贡献，尽管心中怀有对参与这份事业的渴望，我还是会“望而却步”。转折点在今年参加竞赛时，在使用某个开源项目时因为遇到了一点问题而去提了个issue。虽然这个问题本质很傻，但在与开发者你来我往的交流中，我深切地感受到自己仿佛离憧憬更近了一步。因而，在今年竞赛结束后的九月，我毫不犹豫地向PLCT Lab提交了简历，试图追逐那个长存我心的幻影。

    +

    而现在，距离第一次提issue已有半年，距离考核通过也已有一个半月之久，我想也是时候好好总结一下我这一个月以来的心路历程了。

    +

    我的第一个月

    +

    从9.10过审核开始写了很久的日报，当然除了实习还包括别的内容：

    +

    image-20231019155950614

    -
    初始版

    直接照着ls的模板改，改成递归就ok了。值得注意的是，目录也是一种文件，也可以通过read读取。目录文件的内容就是目录里的所有文件的名字。因而，我们在递归时可以忽略文件，只对目录处理，因为目录中就包含着所有文件名的信息。

    -
    附加题：支持正则表达式

    把user/grep.c里面的匹配函数拿来就行。

    -

    编写xargs

    -

    Write a simple version of the UNIX xargs program: read lines from the standard input and run a command for each line, supplying the line as arguments to the command. Your solution should be in the file user/xargs.c.

    +

    这一个月以来，我学到了很多东西，学习周期大致可分为三个阶段：初步了解rtt和配置环境、设备树学习以及最后的gpio driver开发。

    +

    rtt

    由于时间有限，所以仅对rtt的标准版本做了一个比较基本的了解（也就是说没有太涉及到源码部分，只能说是对文档中心的那些对外开发用接口有一定的了解）。rtt是一个微内核的RTOS，这与以前所接触的Linux和xv6都不同。由于RTOS的特性，它的许多设计都十分精简，相比于Linux可谓”麻雀虽小五脏俱全“。

    +

    对rtt的基本介绍，详情可见其文档中心。我印象最深（也是开发过程中接触得最多的）的几个点有：

    +
      +

    1. 接口设计

      +

      与Linux一样，rtt也采用了精简的接口设计。

      +
      2. +

    2. 自动初始化机制

      +

      帅的一匹，具体详见此。

      +
      3. +
    +

    其余的只能说不甚了解，还有待挖掘。

    +

    配置环境

    由于确实对这种东西毫无所知，所以配环境这个过程也是比较漫长，而且很折磨很痛苦（。

    +

    硬件方面，一开始拿到IO-board连这是啥都不知道，还以为这就是开发板研究了半天怎么上电和把内核烧进去（（（。然后东西也是买得缺斤少两，比如拿到开发板不知道还要有TF卡，上网搜图研究了半天才意识到；再比如也没有USB-TTL，又是一通淘宝购物。这些各种各样的小白问题导致配环境的周期十分漫长。然后还有一些很傻的错误，再次也不好意思多说了，详情可见rtt硬件环境搭建。

    +

    软件方面倒是没什么问题，之前也早就跟编译内核用的menuconfig打过很多交道，磁盘分区之类的东西之前也简单使过几次，只不过经过这次后也算是使得更加熟练了。

    +

    设备树学习

    +

    TODO，这部分还是比较多好写的，虽然还是有点模糊（待我之后有时间整理下放个链接

    -
    体会

    思路还是很直观的，就是从stdin一行一行读入数据，然后把这数据处理成参数，最后调用exec就行。就是中间有很多小细节值得注意。

    -

    有一点比较坑的是，main方法的那个argc的计算方法是这样的，不是直接用数组的长度：

    -
    for(argc = 0; argv[argc]; argc++)
    - -

    可以看到，合格的argv的形式应该是：参1 参2 参3 “\0”，最后一个元素要以”\0”标志结束。

    -

    这个应该是编写者约定俗成的。在user/sh.c的parseexec，大概445行左右：

    -

    image-20230106172133338

    -

    shell处理命令时是会默认把最后一个清零的。

    -
    -

    确实，后面在学内存的时候，用户空间的构成如图所示：

    -

    image-20230109234930690

    -

    可以看到栈那边，参数列完了之后是会有一个用以terminate的空指针的

    +

    设备树还是比较复杂，而且因为本人的不审慎，导致对其理解出了偏差，还麻烦了社区看我的代码（悲）只能说个人出道的开源社区还是需要对自己的所有笔代码负责。

    +

    gpio driver

    +

    pr：

    +

    image-20231021105306299

    +

    涉及到的各种硬件手册：

    +

    image-20231019165451893

    -

    附加题：改善shell

    看起来又难又多所以我先摸了【润】等之后有时间再回来弄吧

    +

    这也是我最后这一周在做的工作，虽说只有短短一周，但是每天都研究这个花了我不少时间和精力（）目前算是写完了它的所有功能（大概），并且已经能把LED闪烁和中断绑定函数润起来了，提的pr在这里。

    +

    以前对驱动的理解，还停留在手把手教你做事的xv6的netlab。也因而，这次可以算是以完全一无所知的状态接下了这个任务。

    +

    不过，好在有以前那个短暂的lab经验，我还是稳扎稳打地定下了具体的学习步骤：调研（包括获取各种data book、schematic、rtt官方文档、Linux和rtt相关代码），然后就是学习。

    +

    好在有设备树的研究积淀，我也算是比较快地掌握了milkv上gpio的分布、型号及其地址空间，从而顺藤摸瓜找到了对应gpio型号的Linux驱动代码参考和硬件手册，算是免去了不少麻烦。

    +

    image-20231019165206369

    +

    然后，我观察rtt的gpio驱动们，也找到了对应的pin.md文档，了解了下大致的代码框架思路：

    +

    image-20231019165313914

    +

    于是接下来的工作也可以比较独立地划分为两部分，一个是数据读写的实现（通过LED闪烁程序测试），另一个是rtt特有的中断回调函数的支持（通过中断程序测试），可以专注对这两个方面开发了。

    +

    其中，数据读写的实现需要对寄存器和引脚号等有所了解。寄存器相对比较简单，只需阅读dwapb的data book即可；而引脚号到gpio的转换则花了我不少时间，做了许多猜想并且进行验证，最后误打误撞地“猜”中了正确思路，通过了LED测试。

    +

    image-20231019165706806

    +

    image-20231019165719966

    +

    image-20231019165738144

    +

    不过引脚号我现在还是不大懂，总之先参照别的bsp写法自己编了个，等着代码review看下吧。

    +

    前期调研一直到LED亮起来花了我整整五六天（）相比于此的困难，中断倒显得简单了许多，毕竟它属于是偏软件相关的。调了一天，也从Linux和其他bsp那边抄了些代码，最终在凌晨两点半成功完成了功能测试（）今天又花了一个下午整理了下代码和写日记，最终总算是把这个作业交上去了。

    +

    整个过程光是写看起来还是比较轻松，但是由于初次开发摸索，每个小跨越都得花费我不少时间去调研搜索，经常是在长达几个小时的不知所措后才短暂地获得了一些光明，我甚至多次想过要不要去辞职了（（（。总之，最后还是坚持了下来。看到蓝色的LED在夜晚的T5中闪烁，我还是十分激动的，眼泪都爆出来了（）

    +

    哎，坚持难能可贵，很高兴我最终做到了，虽然尚有测试上的不完善，以及还在等待review。

    +

    稍作总结

    总之，这一个月来我学到了许多，同时也对我以前未曾涉足的空白领域做了许多探索，包括对设备树、对嵌入式开发、对Linux设备驱动等的学习，总体来说还是十分甚至九分地开心。希望下个月能再接再厉。

    ]]> + + mylife + - Operating system oganization - /2023/01/10/xv6$chap2/ - Operating system oganization
    -

    Before you start coding, read Chapter 2 of the xv6 book, and Sections 4.3 and 4.4 of Chapter 4, and related source files:

    -
      -
    • The user-space code for systems calls is in user/user.h and user/usys.pl.
      • -
    • The kernel-space code is kernel/syscall.h, kernel/syscall.c.
      • -
    • The process-related code is kernel/proc.h and kernel/proc.c.
      • -
    -
    -

    这章主要是讲了操作系统为了兼顾并发性、隔离性、交互性做出的基本架构。

    -

    Kernel organization

    宏内核与微内核

    操作系统一个很重要的设计问题就是，哪部分的代码需要run在内核态，哪部分的需要run在用户态。

    -

    如果将操作系统所有系统调用统统都在内核态run，这种设计方式就叫宏内核monolithic kernel。

    -

    如果仅将系统调用中必要的部分在内核态run，其他部分都在用户态run，并且采取Client/Server这样的异步通信方式，这种设计方式就叫微内核microkernel。

    -

    image-20230107232802540

    -
    -

    由于客户/服务器（Client/Server）模式，具有非常多的优点，故在单机微内核操作系统中几乎无一例外地都采用客户/服务器模式，将操作系统中最基本的部分放入内核中，而把操作系统的绝大部分功能都放在微内核外面的一组服务器(进程)中实现。

    -
    -

    在微内核中，内核接口由一些用于启动应用程序、发送消息、访问设备硬件等的低级功能组成。这种组织允许内核相对简单，因为大多数操作系统驻留在用户级服务器中。

    -

    像大多数Unix操作系统一样，Xv6是作为一个宏内核实现的。因此，xv6内核接口对应于操作系统接口，内核实现了完整的操作系统。

    -

    Code: xv6 organization

    XV6的源代码位于kernel子目录中，源代码按照模块化的概念划分为多个文件，图2.2列出了这些文件，模块间的接口都被定义在了def.h（kernel/defs.h）。

    + Operating system interface + /2023/01/10/xv6$chap1/ + Operating system interface

    本节大概是在讲操作系统的接口，系统调用占了很大一部分。

    - + - - - - - - - - - - - - - - - - - - - - - - - - - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + +
    文件系统调用 描述
    bio.c文件系统的磁盘块缓存
    console.c连接到用户的键盘和屏幕
    entry.S首次启动指令
    exec.cexec()系统调用
    file.c文件描述符支持
    fs.c文件系统
    kalloc.c物理页面分配器int fork()创建一个进程，返回子进程的PID
    kernelvec.S处理来自内核的陷入指令以及计时器中断int exit(int status)终止当前进程，并将状态报告给wait()函数。无返回
    log.c文件系统日志记录以及崩溃修复int wait(int *status)等待一个子进程退出; 将退出状态存入*status; 返回子进程PID。
    main.c在启动过程中控制其他模块初始化int kill(int pid)终止对应PID的进程，返回0，或返回-1表示错误
    pipe.c管道int getpid()返回当前进程的PID
    plic.cRISC-V中断控制器int sleep(int n)暂停n个时钟节拍
    printf.c格式化输出到控制台int exec(char *file, char *argv[])加载一个文件并使用参数执行它; 只有在出错时才返回
    proc.c进程和调度char *sbrk(int n)按n 字节增长进程的内存。返回新内存的开始
    sleeplock.cLocks that yield the CPUint open(char *file, int flags)打开一个文件；flags表示read/write；返回一个fd（文件描述符）
    spinlock.cLocks that don’t yield the CPU.int write(int fd, char *buf, int n)从buf 写n 个字节到文件描述符fd; 返回n
    start.c早期机器模式启动代码int read(int fd, char *buf, int n)将n 个字节读入buf；返回读取的字节数；如果文件结束，返回0
    string.c字符串和字节数组库int close(int fd)释放打开的文件fd
    swtch.c线程切换int dup(int fd)返回一个新的文件描述符，指向与fd 相同的文件
    syscall.cDispatch system calls to handling function.int pipe(int p[])创建一个管道，把read/write文件描述符放在p[0]和p[1]中
    sysfile.c文件相关的系统调用int chdir(char *dir)改变当前的工作目录
    sysproc.c进程相关的系统调用int mkdir(char *dir)创建一个新目录
    trampoline.S用于在用户和内核之间切换的汇编代码int mknod(char *file, int, int)创建一个设备文件
    trap.c对陷入指令和中断进行处理并返回的C代码int fstat(int fd, struct stat *st)将打开文件fd的信息放入*st
    uart.c串口控制台设备驱动程序int stat(char *file, struct stat *st)将指定名称的文件信息放入*st
    virtio_disk.c磁盘设备驱动程序int link(char *file1, char *file2)为文件file1创建另一个名称(file2)
    vm.c管理页表和地址空间int unlink(char *file)删除一个文件
    -

    图2.2：XV6内核源文件

    -

    Process overview

    内核用来实现进程的机制包括用户态内核态标志、地址空间和进程的时间切片。

    -

    为了帮助加强隔离，进程抽象给程序提供了一种错觉，即它有自己的专用机器。进程为程序提供了一个看起来像是私有内存系统或地址空间的东西，其他进程不能读取或写入。进程还为程序提供了看起来像是自己的CPU来执行程序的指令。

    -

    Xv6使用页表（由硬件实现）为每个进程提供自己的地址空间。RISC-V页表将虚拟地址（RISC-V指令操纵的地址）转换（或“映射”）为物理地址（CPU芯片发送到主存储器的地址）。

    -

    每个进程也有自己的页表，页表中记录了以虚拟地址0开始的内存区域。

    -

    image-20230107233741922

    -

    xv6内核为每个进程维护许多状态片段，并将它们聚集到一个proc(*kernel/proc.h*:86)结构体中。一个进程最重要的内核状态片段是它的页表、内核栈区和运行状态。我们将使用符号p->xxx来引用proc结构体的元素；例如，p->pagetable是一个指向该进程页表的指针。

    -
    -

    这应该相当于pcb表。

    -
    -

    Code: starting xv6 and the first process

    看完一遍说实话还乱乱的。。。。我整理整理跟linux的对比学习一下吧。

    -

    xv6

    加载操作系统

    系统加电，启动BIOS初始化硬件 -> BIOS从引导扇区将加载程序读入内存 -> 加载程序将操作系统镜像读入内存RAM。

    -
    -

    这个过程由qemu模拟。

    -

    首先会通过mkfs造出操作系统镜像。然后由qemu将引导扇区，也即下面的filesys这图里的第0块：

    -

    image-20230121162324747

    -

    读入到主存中，然后开始执行引导扇区的程序，下同。

    -
    -

    boot loader目的是把xv6加载进内存到0x8000 0000，然后跳转到xv6初始化程序。

    -
    -

    The reason it places the kernel at 0x80000000 rather than 0x0 is because the address range 0x0:0x80000000 contains I/O devices.

    -
    -

    操作系统初始化

    entry.S配置栈空间

    此时，目前的机器状态是，1.没有开启地址映射，也即虚拟地址=真实物理地址。2.运行在machine mode

    -

    xv6会在kernel/entry.S下的这里开始执行，目的是配置好栈，以开始C语言代码start.c的执行：

    -
    .global _entry
    _entry:
            # set up a stack for C.
            # 这段主要是在计算栈顶指针sp
            # stack0 is declared in start.c,
            # with a 4096-byte stack per CPU.
            # sp = stack0 + (hartid * 4096)
            la sp, stack0
            li a0, 1024*4
            csrr a1, mhartid
            addi a1, a1, 1
            mul a0, a0, a1
            add sp, sp, a0
            # 已经有栈了，就可以开始执行C语言代码了
            # jump to start()
            call start
    +

    表1.2：xv6系统调用（除非另外声明，这些系统调用返回0表示无误，返回-1表示出错）

    +

    Process and memory

    fork

    int pid = fork();
    if(pid > 0){
        printf("parent: child's pid = %d\n",pid);
        pid = wait(0);
        printf("child %d is done.\n",pid);
    } else if(pid == 0){
        printf("child : exiting\n");
    } else {
        printf("fork error\n");
    }
    + +

    这是一个利用fork的返回值对于父子进程来说不同这一特点进行编写的例程。其中比较不熟的还是wait(0)这一句的用法。这点具体可以看书中笔记和上面的系统调用表。

    +

    exec

    exec是一个系统调用，它跟exe文件被执行的原理密切相关。当程序调用exec，就会跳转到exec参数文件去执行，原程序exec下面的指令都不再被执行，除非exec因错误而退出。

    +

    exec与fork

    由shell的源码中main函数这一段

    +
    // Read and run input commands.
    while(getcmd(buf, sizeof(buf)) >= 0){
      if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
        // Chdir must be called by the parent, not the child.
        buf[strlen(buf)-1] = 0;  // chop \n
        if(chdir(buf+3) < 0)
          fprintf(2, "cannot cd %s\n", buf+3);
        continue;
      }
      if(fork1() == 0)
        runcmd(parsecmd(buf));
      wait(0);
    }
    exit(0);
    + +
    void runcmd(struct cmd *cmd)
    {
      if(cmd == 0)
        exit(1);

      switch(cmd->type){
      ...
      case EXEC:
        ecmd = (struct execcmd*)cmd;
        exec(ecmd->argv[0], ecmd->argv);
        fprintf(2, "exec %s failed\n", ecmd->argv[0]);
        break;
        ...
            
      exit(0);
    }
    -

    其中start0：

    -
    __attribute__ ((aligned (16))) char stack0[4096 * NCPU];
    +

    可以看到shell其实本质上就是这样的架构架构：

    +
    while(true){
    	if(读到了command&&fork()==0){
            exec(command);
            printf("失败信息");
        }
        wait(0);
    }
    -
    start.c

    在start.c中，我们的任务是在machine mode下，获取machine mode才能访问到的硬件参数，做在machine mode 下才能做的时钟初始化【 it programs the clock chip to generate timer interrupts】，然后进行machine mode到内核态的切换，最后跳转到main.c进行操作系统的初始化和第一个进程的启动。

    -

    而其中，如果想从machine mode切换到内核态，就需要使用mret指令。但是mret指令除了会切换mode之外，还有一个“ret”的作用，并且是从machine mode ret到内核态。

    +

    也即父进程创建出子进程来执行command，并且父进程等待子进程执行完再继续等待输入。

    +

    可以看到，fork和exec的使用是非常紧密的，联合使用也是非常顺理成章的。那么，如果干从fork的exec的对于内存管理的原理来讲，就会不免产生一点问题。

    -

    This instruction( mret ) is most often used to return from a previous call from supervisor mode to machine mode.

    +

    问题描述：

    +

    fork的内存原理，实质上是开辟一片新的与父进程等大的内存空间，然后把父进程的数据都copy一份进这个新内存空间。exec的原理是用一片可以容纳得下文件指令及其所需空间的内存空间去替代调用进程原有的那片内存空间。

    +

    可以看到，如果fork和exec接连使用，理论上其实是会产生一点浪费的，fork创建子进程复制完了一片内存空间，这片新复制的内存空间又马上被扔掉了，取而代之的用的是exec的内存空间。

    -

    所以，我们实际上可以把最后两步连起来，用mret一个指令就完成。也即，mret指令既完成了从machine mode到内核态的切换，又完成了从start.c到main.c的跳转。

    -

    这其实很容易，只需在栈中将调用者（此时应该是entry.S）的地址替换为main.c的地址，并且将调用者的mode改为内核态，这样就ok了。

    +

    为了解决这个问题，kernel使用了copy-on-write技术优化。

    +

    I/O and File descriptors

    文件描述符

    句柄就是一个int值，它代表了一个由内核管理的，可以被进程读写的对象.

    -

    it sets the previous privilege mode to supervisor in the register mstatus, it sets the return address to main by writing main’s address into the register mepc, disables virtual address translation in supervisor mode by writing 0 into the page-table register satp, and delegates all interrupts and exceptions to supervisor mode

    -

    后面两点不大明白。为什么为了mret，就还得让内核态跟machine mode一样关闭虚拟地址映射，还得把什么中断和异常委托给内核态？？

    -

    【我猜测是因为现在页表还没初始化好所以当然得关闭虚拟地址映射（）；后者大概是开中断的意思？】

    +

    A process may obtain a file descriptor by opening a file, directory, or device, or by creating a pipe, or by duplicating an existing descriptor.

    -

    代码如下：

    -
    // entry.S jumps here in machine mode on stack0.
    void
    start()
    {
      //修改调用者为内核态
      // set M Previous Privilege mode to Supervisor, for mret.
      unsigned long x = r_mstatus();
      x &= ~MSTATUS_MPP_MASK;
      x |= MSTATUS_MPP_S;
      w_mstatus(x);

      // set M Exception Program Counter to main, for mret.
      // requires gcc -mcmodel=medany
      w_mepc((uint64)main);

      // disable paging for now.
      w_satp(0);

      // delegate all interrupts and exceptions to supervisor mode.
      w_medeleg(0xffff);
      w_mideleg(0xffff);
      w_sie(r_sie() | SIE_SEIE | SIE_STIE | SIE_SSIE);

      // configure Physical Memory Protection to give supervisor mode
      // access to all of physical memory.
      w_pmpaddr0(0x3fffffffffffffull);
      w_pmpcfg0(0xf);

      // ask for clock interrupts.
      timerinit();

      // keep each CPU's hartid in its tp register, for cpuid().
      int id = r_mhartid();
      w_tp(id);

      // switch to supervisor mode and jump to main().
      asm volatile("mret");
    }
    - -
    main.c

    main.c的作用是做很多很多init。其中，它通过userinit();来创建第一个进程，这个第一个进程再由main调用scheduler()来被调度执行。

    -
    void
    main()
    {
      if(cpuid() == 0){
        consoleinit();
        printfinit();
        printf("\n");
        printf("xv6 kernel is booting\n");
        printf("\n");
    	//...很多很多init
        userinit();      // first user process
        __sync_synchronize();
        started = 1;
      } else {
        while(started == 0)
          ;
        __sync_synchronize();
        /*
        RISC-V的处理器对底层提供了一种特殊的抽象,Hardware Thread,简称为Hart。简单来说,Hart是真实物理CPU(bare metal)提供的一种模拟
        */
        printf("hart %d starting\n", cpuid());
        kvminithart();    // turn on paging
        trapinithart();   // install kernel trap vector
        plicinithart();   // ask PLIC for device interrupts
      }

      //调用第一个scheduler，完成对scheduler线程的初始化，并且调度去执行第一个进程
      scheduler();        
    }
    - +

    每个进程的其三个句柄有默认值：

    -

    注：关于里面的cpuid，我查了一下，指的是CPU的序列号，用来唯一标识cpu的。我想这个if架构的目的应该跟fork()==0差不多。也就是说，一开始的那个init仅有cpuid==0的CPU执行，其他的CPU就乖乖wait，只有CPU0执行初始化的程序。等到CPU0执行完所有init，才置标记位start=1，然后通过条件变量start控制抢占调度，轮流初始化自己。其中__sync_synchronize是GNU内置指令，起内存屏障作用。在竞赛中深刻地了解过了内存屏障，在这里再次跟老熟人再会感觉还是很有意思的。

    +

    By convention, a process reads from file descriptor 0 (standard input), writes output to file descriptor 1 (standard output), and writes error messages to file descriptor 2 (standard error).

    -
    proc.c中的userinit()

    userinit的作用就是新创建一个进程信息proc，然后开始给第一个程序（initcode）填信息填入proc。这个进程创建完后，在main中的scheduler被调度执行。

    -
    void
    userinit(void)
    {
      struct proc *p;

      p = allocproc();
      initproc = p;
      
      // 申请一页，将initcode的指令和数据放进去
      // allocate one user page and copy initcode's instructions
      // and data into it.
      uvmfirst(p->pagetable, initcode, sizeof(initcode));
      p->sz = PGSIZE;

      //为内核态到用户态的转变做准备
      // prepare for the very first "return" from kernel to user.
      /*
      Trap Frame是指中断、自陷、异常进入内核后,在堆栈上形成的一种数据结构
      */
      p->trapframe->epc = 0;      // user program counter
      p->trapframe->sp = PGSIZE;  // user stack pointer

      // 修改进程名
      safestrcpy(p->name, "initcode", sizeof(p->name));
      p->cwd = namei("/");

      //这个也许是为了能被优先调度
      p->state = RUNNABLE;

      release(&p->lock);
    }
    +

    句柄0对应着standard input，1对应着standard output，2对应着standard error。

    +

    read、write

    read和write的参数都是句柄，buf，读/写长度。都会导致文件指针的移动。使用如下例程【类似cat的原理】：

    +
    char buf[512];
    int n;

    for(;;){
        n = read(0);//从标准输入读
        if(n == 0){
            break;
        }
        if(n < 0){
            fprintf(2,"read error\n");
            exit(1);
        }
        if(write(1,buf,n) != n){//向标准输出写
            fprintf(2,"write error\n");
            exit(1);
        }
    }
    -
    initcode.S

    以上程序都位于kernel/下。这个位于user/下。

    -

    它调用exec系统调用进入了内核态。当exec完成后，它就跳转到了用户态user/init.c中。【这里估计又用了修改返回地址的trick】

    -
    .globl start
    start:
            la a0, init
            la a1, argv
            li a7, SYS_exec
            ecall
    # char init[] = "/init\0";
    init:
      .string "/init\0"

    # char *argv[] = { init, 0 };
    .p2align 2
    argv:
      .long init
      .long 0
    +

    close

    close函数释放了一个句柄，以后它释放掉的这个句柄就可以被用来表示别的文件了。

    +

    open

    open函数会给参数的file分配一个句柄。这个句柄通常是目前空闲的句柄中值最小的那个。

    +

    重定向的实现

    char *argv[2];

    argv[0] = "cat";
    argc[1] = 0;
    if(fork() == 0){
        close(0);
        open("input.txt",O_RDONLY);
        exec("cat",argv);
    }
    -
    init.c

    在init.c中，创建了console设备文件，打开了012文件描述符，并且fork了一个子进程，开始执行shell。这样一来，操作系统就完成了全部的启动。

    -

    感想

    -

    我的疑点有三个：

    -
      -

    1. 见start.c

      -
      2. -

    2. 是怎么完成从内核态到用户态的切换的？是执行了return就会自动切换吗？userinit中设置了initcode的信息为用户态的，然后就直接能进入用户态，这里感觉有点模糊。

      -

      其实用户态和内核态本质上好像差别不大，似乎也就只有两方面，一个是页表（虚拟地址），另一个就是权限问题了。前者很好说，在main.c中完成了页表初始化，开启了虚拟地址：

      -
      kvminit();       // create kernel page table
      kvminithart();   // turn on paging
      +

      xv6的重定向实现跟这个原理差不多：

      +
      case REDIR:
        rcmd = (struct redircmd*)cmd;
        close(rcmd->fd);
        if(open(rcmd->file, rcmd->mode) < 0){
          fprintf(2, "open %s failed\n", rcmd->file);
          exit(1);
        }
        runcmd(rcmd->cmd);
        break;
      -

      后者的话，从用户态切到内核态使用ecall指令，从machine mode到内核态需要修改mstatus寄存器并且使用mret指令：

      -
      // set M Previous Privilege mode to Supervisor, for mret.
      unsigned long x = r_mstatus();
      x &= ~MSTATUS_MPP_MASK;
      x |= MSTATUS_MPP_S;
      w_mstatus(x);
      ...
      // switch to supervisor mode and jump to main().
      asm volatile("mret");
      +

      共享偏移量

      fork出来的父子进程同一个句柄对同一个文件的偏移量是相同的，这个原理应该是因为，父子进程共享的是文件句柄这个结构体对象本身，也就是拷贝的时候是浅拷贝而不是深拷贝。

      +
      if(fork() == 0) {
      	write(1, "hello ", 6);
      	exit(0);
      } else {
      	wait(0);
      	write(1, "world\n", 6);
      }
      + +

      dup

      dup系统调用复制一个现有的文件描述符，返回一个引用自同一个底层I/O对象的新文件描述符。

      +

      dup和open一样，都是会占用一个新的句柄的，而且都是优先分配数值小的。比如说fd = dup(3)，得到fd=4，那么结果就是句柄3和句柄4指向同一个文件，并且偏移量一样。

      +

      dup可以让这样的指令变得可以实现：

      +
      ls existing-file non-existing-file > tmp1 2>&1
      -

      因而从内核态切换到用户态应该也是需要类似这段对mstatus寄存器的修改的，并且其对应修改的是sstatus寄存器。

      -

      但是，我只在普通的用户态-trap入内核态-用户态这个过程的usertrapret中看到对sstatus寄存器的写入，并没有在init的时候对这个玩意进行写入。

      -

      所以，最后，我初步猜测，是会在scheduler()中的上下文切换中修改sstatus寄存器的内容为user mode，从而实现由内核态向用户态进程（initcode）的切换。不过这也仅仅是【猜想】，因为我并没有在switch的汇编代码中看到对sstatus的修改。真是令人麻木。。。

      -
      3. -
    -

    步骤十分直接且有理由：

    -

    加载操作系统——为了能执行C语言需要一个栈，所以得执行造一个的代码，然后再进入C语言zone——做点machine mode才能做的事，然后从machine mode切换到内核态——做点内核态才能做的事，从内核态切换到用户态

    -
    -

    linux0.11

    bootsect -> setup -> head.s ->main.c

    -

    加载操作系统

    系统加电，启动BIOS初始化硬件 -> BIOS从引导扇区将加载程序读入内存 -> 加载程序将操作系统镜像读入内存RAM。

    -

    其中，第二三步做进一步的细化。

    -
    读入bootsect.s

    加载程序的512个字节被读入到内存从0x7c00开始的一段内存中，并且BIOS设置CS=07c0,ip=0，开始执行加载程序的每一条指令。

    -
    bootsect.s

    加载程序的代码为bootsect.s。在bootsect.s中，首先将自身从7c00处移动到了9000处【留下空间放操作系统】，然后分别依次读取磁盘的setup和system模块，最后bootsect将控制权转交给setup。

    -
    setup.s

    setup首先获取操作系统运行的必要硬件参数。

    -

    image-20230108011824655

    -

    再然后，将system代码移到0地址。然后，我们就需要进入system代码块。

    -

    image-20230108012316631

    -

    最后一句jmpi指令本来应该是要跳到system代码段首0地址处的的，可此处却跳到了80处，这显然不合理。但它写的肯定是没错的。之所以会有这样的矛盾，是因为setup在此之前，还做了一件事情：改变寻址方式。jmpi上面的那条mov指令便做了这点。

    -

    我们之前的寻址方式一直是cs<<4+ip。但是这东西只能是16位的内存，无法满足寻址需求。故而setup要从16位切换到32位。32位模式也叫保护模式。

    -
    -

    至于怎么切的呢？要注意到一点，改变寻址方式也即改变cs和ip的地址计算方法，也即换一条硬件电路实现。计算机给我们提供了一个简单的方式操纵保护模式的转变，即修改cr0寄存器的内容。

    -
    -

    在保护模式下，寻址方式发生了改变。此时cs不再代表基址，而是表示地址在gdb表global description table中的偏移下标。真正的基址放在表项中。cs被称为selector，从表中取得基址，再和ip加在一起得到地址。

    -

    gdt表的内容由setup初始化

    -

    image-20230108013156116

    -
    -

    这样一来，就正确跳到了system模块。

    -

    操作系统初始化

    head.s

    跳到system第一个文件，也就是head.s去执行。

    -

    head.s也是在保护模式下进行的，是在保护模式下的初始化。

    -

    head.s建立了真正的gdt表，然后就要跳转到main.c执行初始化和Shell的启动。此处有汇编语言和C语言的转化，也就是push参数然后push main的地址。

    -
    main.c

    对各种东西的初始化。

    -

    image-20230108013849664

    -

    最后完成从内核态到用户态的切换。

    -

    感想

    -

    linux0.11的启动的具体思路是：

    -

    加载操作系统，获取硬件参数，进入保护模式，跳转到操作系统第一行代码——操作系统初始化，切换到用户态

    -

    linux0.11相比于xv6更加复杂，上课的时候隐藏了很多实现细节但依旧理解很费劲（。

    -

    这两个步骤思路其实都是差不多的，区别在于linux0.11好像没有machine mode这个概念。感觉也不能锐评什么，因为看完了感觉两个都很有道理，两个都一样很难懂（。

    -

    【注：为什么没有machine mode呢？是因为这个mode的划分是RISC-V架构做的，而linux0.11是基于X86架构。】

    -

    不过linux0.11这里进入保护模式后改变寻址方式是因为机器问题（好像是），xv6难道也是因为硬件问题吗？因为一开始的时候操作系统还未进行内存分页页表初始化，所以用不了地址映射？有待学习。

    -

    关于保护模式，可以看看这篇文章，今天太晚了先睡了：

    -

    Linux从头学08：Linux 是如何保护内核代码的？【从实模式到保护模式】

    -
    -

    Real world

    现实中，大多数操作系统都会兼顾宏内核与微内核。

    -

    大多数操作系统都支持与xv6类似的process进程概念，也有很多系统还支持线程概念。

    -

    Lab system calls

    -

    To start the lab, switch to the syscall branch:

    -
    $ git fetch
    $ git checkout syscall
    $ make clean
    -
    -

    trace

    -

    In this assignment you will add a system call tracing feature that may help you when debugging later labs.

    -

    You’ll create a new trace system call that will control tracing. It should take one argument, an integer “mask”, whose bits specify which system calls to trace.

    -

    For example, to trace the fork system call, a program calls trace(1 << SYS_fork). You have to modify the xv6 kernel to print out a line when each system call is about to return. The line should contain the process id, the name of the system call and the return value; you don’t need to print the system call arguments.

    -

    The trace system call should enable tracing for the process that calls it and any children that it subsequently forks, but should not affect other processes.

    +

    这个指令的意思是，先把stderr的结果重定向到stdout，再把stdout的结果重定向到tmp1中。

    +

    关于2>&1的解释，可以看这个 shell中的”2>&1”是什么意思？

    -

    感想

    一开始为了把trace做得封装性良好一些尽量不改别的代码，想了好久好久，最后就只能想出，在syscall.c获取系统调用返回值处加个条件打印，在trace中维护一个map，映射进程pid和进程当前的mask，并且给外界提供查询当前进程是否对某个系统调用有mask作为syscall条件打印的接口。

    -

    这个最后还是失败了，失败的点在于不知道要创建多大的数组来作为map映射所有进程，因为pid分配估计是递增的，是会超过最大进程数的，所以pid会是多少是不确定的。还有一点就是fork之后子进程不能自动继承父进程的mask，还得手动调用一下trace，这更加不封装了（。

    -

    总之先放上我原来的代码吧。

    -
    // in kernel/syscall.c
    #include "types.h"
    #include "param.h"
    #include "memlayout.h"
    #include "riscv.h"
    #include "spinlock.h"
    #include "proc.h"
    #include "syscall.h"
    #include "defs.h"

    //...

    void strcpy(char* buf,const char* tmp){
     int i=0;
      while((*tmp)!='\0'){
        buf[i++] = *tmp;
        tmp++;
      }  
      buf[i] = '\0';

    }

    void getname(int callid,char* buf){
      switch(callid){
        case SYS_fork: strcpy(buf,"fork"); break;
        case SYS_exit: strcpy(buf,"exit"); break;
        case SYS_wait: strcpy(buf,"wait"); break;
        case SYS_pipe: strcpy(buf,"pipe"); break;
        case SYS_read: strcpy(buf,"read"); break;
        case SYS_kill: strcpy(buf,"kill"); break;
        case SYS_exec: strcpy(buf,"exec"); break;
        case SYS_fstat: strcpy(buf,"fstat"); break;
        case SYS_chdir: strcpy(buf,"chdir"); break;
        case SYS_dup: strcpy(buf,"dup"); break;
        case SYS_getpid: strcpy(buf,"getpid"); break;
        case SYS_sbrk: strcpy(buf,"sbrk"); break;
        case SYS_sleep: strcpy(buf,"sleep"); break;
        case SYS_uptime: strcpy(buf,"uptime"); break;
        case SYS_open: strcpy(buf,"open"); break;
        case SYS_write: strcpy(buf,"write"); break;
        case SYS_mknod: strcpy(buf,"mknod"); break;
        case SYS_unlink: strcpy(buf,"unlink"); break;
        case SYS_link: strcpy(buf,"link"); break;
        case SYS_mkdir: strcpy(buf,"mkdir"); break;
        case SYS_close: strcpy(buf,"close"); break;
        case SYS_trace: strcpy(buf,"trace"); break;
        default: return;
      }
    }

    void
    syscall(void)
    {
      int num;
      struct proc *p = myproc();

      num = p->trapframe->a7;
      if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
        p->trapframe->a0 = syscalls[num]();
        char buf[32];
        getname(num,buf);
        // 在此处添加条件打印
        if(istraced(num))
        	printf("syscall %s -> %d\n",buf,p->trapframe->a0);
      } else {
        printf("%d %s: unknown sys call %d\n",
                p->pid, p->name, num);
        p->trapframe->a0 = -1;
      }
    }
    +

    这个的实现就要用到dup了。我们会fork一个子进程，在子进程里面close(2)，然后再dup(1)。这样一来，我们就成功实现了句柄1和2指向同一个文件

    +

    Pipe

    使用

    int pipe(int p[]) 创建一个管道，把read/write文件描述符放在p[0]和p[1]中

    +
    int p[2];
    char* argv[2];

    argv[0] = "wc";
    argv[1] = 0;

    pipe(p);
    if(fork() == 0){
        close(0);
        dup(p[0]);
        close(p[0]);
        close(p[1]);
    } else{
        close(p[0]);
        write(p[1],"hello world\n",12);
        close(p[1]);
    }
    -
    // in kernel/trace.c
    #include "types.h"
    #include "param.h"
    #include "memlayout.h"
    #include "riscv.h"
    #include "spinlock.h"
    #include "proc.h"
    #include "defs.h"
    #include "elf.h"

    int m_mask[NPROC];

    int
    trace(int mask){
        struct proc *p = myproc();
        m_mask[p->pid] = mask;
        return 1;    
    }

    //提供给外界查询的接口
    int
    istraced(int callid){
        struct proc *p = myproc();
        //printf("from trace ,pid = %d\n",p->pid);
        if(((m_mask[p->pid] >> callid) & 1) == 1){
    	return 1;
        } else{
        	return 0;
        }
    }
    +

    完成了父进程-pipe-子进程的一个重定向。

    +

    pipe是阻塞的生产者消费者模式。对管道的read，在没有数据输入时会阻塞，直到读到数据，或者所有的write方向都被关闭。示例代码中，如果不使用pipe就需要显示close(p[0]) close(p[1])，正是为了防止没有数据输入时write方向不为0导致死锁的情况出现。

    +

    实现管道命令

    管道命令的实现正是通过pipe。

    +

    执行原理就是，创建两个子进程分别执行左右两侧的句子，然后左侧子进程的out重定向到pip的write，右侧子进程的in重定向到pip的read。

    +
     case PIPE:
       pcmd = (struct pipecmd*)cmd;
       if(pipe(p) < 0)
         panic("pipe");
    //左
       if(fork1() == 0){
         close(1);
         dup(p[1]);
         close(p[0]);
         close(p[1]);
         runcmd(pcmd->left);
       }
    //右
       if(fork1() == 0){
         close(0);
         dup(p[0]);
         close(p[0]);
         close(p[1]);
         runcmd(pcmd->right);
       }
       //中
    close(p[0]);
       close(p[1]);
       //wait
    wait(0);
       wait(0);
       break;
    -

    下面是按照hints修改后的正确代码。

    -

    代码步骤

    实际上，标答跟我的思路差不多，只不过它没有像我一样创建数组作为map，而是在proc结构体里添加了一个属性，这本质上也是利用了map。

    -
    在各种文件添加签名
    user/user.h
    user/usys.pl
    syscall.h

    添加系统调用号

    -
    syscall.c

    添加系统调用号和sys_trace映射

    -
    修改Makefile
      -
    1. 在第一个OBJS添加trace.o
      2. -
    2. 在UPROGS添加user中的trace
      3. -
    -
    代码
    修改proc.h
    // Per-process state
    struct proc {
      // ...
      int mask; //记录trace的mask
    };
    +

    这实际上是二叉树的左右中递归过程。

    +
    +

    附：对于管道命令的解读

    +
    cat a.txt | echo
    -
    编写trace.c
    #include "types.h"
    #include "param.h"
    #include "memlayout.h"
    #include "riscv.h"
    #include "spinlock.h"
    #include "proc.h"
    #include "defs.h"
    #include "elf.h"

    int
    trace(int mask){
        struct proc *p = myproc();
        p->mask = mask;
        return 1;    
    }

    int
    istraced(int callid){
        struct proc *p = myproc();
        if(((p->mask >> callid) & 1) == 1){
    	return 1;
        } else{
        	return 0;
        }
    }
    +

    我的本意是觉得，这意思就是把cat a.txt的输出连到echo的输入，这个命令结果跟cat a.txt是没什么差的。但具体执行出来发现最后的结果却是跟：

    +
    echo
    -
    修改syscall.c
    // in kernel/syscall.c
    #include "types.h"
    #include "param.h"
    #include "memlayout.h"
    #include "riscv.h"
    #include "spinlock.h"
    #include "proc.h"
    #include "syscall.h"
    #include "defs.h"

    //...

    void strcpy(char* buf,const char* tmp){
     int i=0;
      while((*tmp)!='\0'){
        buf[i++] = *tmp;
        tmp++;
      }  
      buf[i] = '\0';

    }

    void getname(int callid,char* buf){
      switch(callid){
        case SYS_fork: strcpy(buf,"fork"); break;
        case SYS_exit: strcpy(buf,"exit"); break;
        case SYS_wait: strcpy(buf,"wait"); break;
        case SYS_pipe: strcpy(buf,"pipe"); break;
        case SYS_read: strcpy(buf,"read"); break;
        case SYS_kill: strcpy(buf,"kill"); break;
        case SYS_exec: strcpy(buf,"exec"); break;
        case SYS_fstat: strcpy(buf,"fstat"); break;
        case SYS_chdir: strcpy(buf,"chdir"); break;
        case SYS_dup: strcpy(buf,"dup"); break;
        case SYS_getpid: strcpy(buf,"getpid"); break;
        case SYS_sbrk: strcpy(buf,"sbrk"); break;
        case SYS_sleep: strcpy(buf,"sleep"); break;
        case SYS_uptime: strcpy(buf,"uptime"); break;
        case SYS_open: strcpy(buf,"open"); break;
        case SYS_write: strcpy(buf,"write"); break;
        case SYS_mknod: strcpy(buf,"mknod"); break;
        case SYS_unlink: strcpy(buf,"unlink"); break;
        case SYS_link: strcpy(buf,"link"); break;
        case SYS_mkdir: strcpy(buf,"mkdir"); break;
        case SYS_close: strcpy(buf,"close"); break;
        case SYS_trace: strcpy(buf,"trace"); break;
        default: return;
      }
    }

    void
    syscall(void)
    {
      int num;
      struct proc *p = myproc();

      num = p->trapframe->a7;
      if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
        p->trapframe->a0 = syscalls[num]();
        char buf[32];
        getname(num,buf);
        // 在此处添加条件打印
        if(istraced(num))
        	printf("syscall %s -> %d\n",buf,p->trapframe->a0);
      } else {
        printf("%d %s: unknown sys call %d\n",
                p->pid, p->name, num);
        p->trapframe->a0 = -1;
      }
    }
    +

    这个指令的效果是一样的，也就是cat a.txt的output，即echo的input完全被丢弃了。

    +

    我想这是因为，echo这个命令的执行过程并没有用到stdin，仅仅用到了参数，也就是说管道read端的接入对它并没有什么影响。

    +

    这也是为啥

    +
    sleep 10 | echo hi
    -
    在sysproc.c中添加系统调用
    uint64
    sys_trace(void)
    {
      int mask;
      if(argint(0,&mask)<0)
        return -1;
      trace(mask);
      return 0;
    }
    +

    这个命令最后的结果是，秒速出hi，然后等待10s后结束，了。由于echo的输出与stdin没有关系，所以，echo不会阻塞读入stdin，等待管道关闭，而是会即刻输出hi。

    +
    +

    管道实际上就相当于：

    +
    echo hello world | wc
    echo hello world > /tmp/xyz; wc < /tmp/xyz
    -
    修改fork

    继承父进程的mask

    -
    np->mask = p->mask;
    +

    在这种情况下，管道相比临时文件至少有四个优势

    +
      +
    • 首先，不用删文件
      • +
    • 其次，管道可以任意传递长的数据流
      • +
    • 第三，管道允许一定程度上的并行
      • +
    • 第四，如果实现进程间通讯，管道的块读写比文件的非块语义更有效率。
      • +
    +

    File system

    inode：代表文件本体，包括文件类型、文件长度、文件内容在磁盘位置、文件的链接数

    +

    link：指向文件的链接，一个文件可以有多个link，link内包含文件名和对inode的引用

    +

    当链接数=0，且句柄数=0，文件的磁盘空间和inode索引就会被释放

    +

    Lab Xv6 and Unix utilities

    配置实验环境

    +

    参考文章：

    +

    xv6环境搭建

    +

    【MIT6.S081/6.828】手把手教你搭建开发环境

    +
    +

    下载工具链

    $ sudo apt-get install git build-essential gdb-multiarch qemu-system-misc gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu
    -
    在defs.h中添加需要public的函数签名
    // trace.c
    int		trace(int);
    int		istraced(int);
    +

    测试安装ok：

    +
    $ qemu-system-riscv64 --version
    QEMU emulator version 5.1.0
    //下面其中之一正常就行
    $ riscv64-linux-gnu-gcc --version
    riscv64-linux-gnu-gcc (Debian 10.3.0-8) 10.3.0
    ...
    $ riscv64-unknown-elf-gcc --version
    riscv64-unknown-elf-gcc (GCC) 10.1.0
    ...
    $ riscv64-unknown-linux-gnu-gcc --version
    riscv64-unknown-linux-gnu-gcc (GCC) 10.1.0
    ...
    -

    sysinfotest

    -

    In this assignment you will add a system call, sysinfo, that collects information about the running system.

    -

    The system call takes one argument: a pointer to a struct sysinfo (see kernel/sysinfo.h).

    -

    The kernel should fill out the fields of this struct: the freemem field should be set to the number of bytes of free memory, and the nproc field should be set to the number of processes whose state is not UNUSED.

    -

    We provide a test program sysinfotest; you pass this assignment if it prints “sysinfotest: OK”.

    +
    +

    注，这里出现了一个问题，qemu-system-riscv64 --version打出来发现qemu-system-riscv64 command not found。似乎是我的ubuntu16.04版本太低了【悲】去看了下网上，可以按照这个来做：

    +

    rCore qemu risc-v 实验环境配置

    -
    // kernel/sysinfo.h
    struct sysinfo {
      uint64 freemem;   // amount of free memory (bytes)
      uint64 nproc;     // number of process
    };
    +

    下载编译xv6源码

    随后，进入一个你喜欢的文件夹clone xv6的实验源码，输入

    +
    $ git clone git://g.csail.mit.edu/xv6-labs-2020
    $ cd xv6-labs-2020
    $ git checkout util
    -

    感想

    代码

    系统调用要做的事情同上。

    -

    有一个我在hit实验没想到，在这里依然没有想到的点是，参数的指针来自用户空间，所以不能直接对其指向的空间进行写入，需要借助copyout函数。

    -

    还有一件事，就是不知道该怎么统计free mem的数量，后来在hints提示下才知道要去kalloc.c中找。【之前只找过了vm.c】这里其实是很后悔提前看了提示的。我应该先去看一下上面关于kernel各个文件用途的笔记，再去继续自己找的，不能太过依赖提示。

    -

    还有一点做的不好的地方是，标答是选择了将两个计数函数放在各自的文件中，我是选择直接将成员变量在头文件中extern 公开出来，比如说在proc.h中这么写：

    -
    extern struct proc proc[NPROC];
    +

    然后进行编译

    +
    $ make
    $ make qemu
    -

    hints采取了比我封装性更好的操作，这也是非常顺理成章的，我没有想到这样真是有点惭愧（。

    -

    总而言之，这个还是挺简单的，就是我很后悔我心浮气躁看了提示，要不然收获会更多。

    -
    sysinfo.c
    #include "types.h"
    #include "param.h"
    #include "memlayout.h"
    #include "riscv.h"
    #include "spinlock.h"
    #include "proc.h"
    #include "defs.h"
    #include "elf.h"
    #include "sysinfo.h"

    int 
    sysinfo(struct sysinfo* info){
      struct sysinfo res;
      res.nproc = countproc();
      res.freemem = countfree();
      struct proc *p = myproc();
      if(copyout(p->pagetable, (uint64)info,(char *)(&res), sizeof(res)) != 0)
        return -1;
      return 1;
    }
    +

    如果此处发生错误：unrecognized command line option -mno-relax，则按照此说法 xv6环境搭建更新gcc版本

    +
    $ sudo apt install gcc-8-riscv64-linux-gnu
    $ sudo update-alternatives --install /usr/bin/riscv64-linux-gnu-gcc riscv64-linux-gnu-gcc /usr/bin/riscv64-linux-gnu-gcc-8 8
    -
    sysproc.c中
    uint64
    sys_sysinfo(void){
      uint64 addr;
      if(argaddr(0, &addr) < 0)
        return -1;
      return sysinfo((struct sysinfo*)addr);
    }
    +

    再执行一次

    +
    $ make
    $ make qemu
    -
    kalloc.c中
    // 采用的是链表结构，run代表一页
    struct run {
      struct run *next;
    };

    struct {
      struct spinlock lock;
      // 指向第一个空闲页
      struct run *freelist;
    } kmem;

    int 
    countfree(){
      int npage = 0;
      struct run* r = kmem.freelist;
      while(r){
        r = r->next;
        npage++;
      }
      return npage*PGSIZE;
    }
    +

    就ok了。

    +

    关闭qemu

    qemu退出操作

    +

    在这里记个强制方法：

    +
    ps -elf | grep qemu
    + +

    image-20230105153458808

    +

    记住第二个的pid

    +

    然后

    +
    kill 3303
    + +

    测试gdb是否ok

    见该文章最后一部分

    +

    【MIT6.S081/6.828】手把手教你搭建开发环境

    +

    自测方法

    make grade
    + +

    或者如果只想测其中一个，可以：

    +
    ./grade-lab-util sleep
    + +

    make qemu后卡住

    疑似qemu版本不对。解决方法

    +

    实验内容

    编写sleep.c

    +

    Implement the UNIX program sleep for xv6; your sleep should pause for a user-specified number of ticks. A tick is a notion of time defined by the xv6 kernel, namely the time between two interrupts from the timer chip. Your solution should be in the file user/sleep.c.

    +

    image-20230105164146100.png

    +
    +
    体会
    参数

    注意，他要求我们实现的sleep的参数是ticks的数量，不是秒数。我花了半天找时钟周期大小这个参数在哪，找了许久没找到，估计是没考虑到这一点。

    +

    比如说，我翻了一下linux0.11的源码，在include/linux/time.h下有这句：

    +

    image-20230105162505574.png

    +

    说明了时钟频率大小。在xv6好像没有看到对这个的显式说明。

    +
    系统调用过程

    感受了一下xv6的系统调用过程，跟linux0.11还是很相像的。

    +

    这个好像是lab2的内容，我暂且先在此放下我体会到的感受。

    +
      +

    1. xv6

      +

      首先是从用户态到内核态的切换。

      +

      在user/user.h中有各个系统调用外化的函数签名。在用户程序中调用里面的函数签名，就会执行【说实话，我没看懂为什么这里会知道要从user.h跳到usys.S中执行，也许是Makefile里有写？】user/usys.S中对应的汇编代码，比如说这种：

      +

      image-20230105170701334

      +

      然后这个SYS_close这种，其实是系统调用号宏，被定义在kernel/syscall.h中：

      +

      image-20230105171327076.pn

      +

      li a7,SYS_call就是把SYS_call的值放入a7寄存器，大概就是传参的意思。ecall是从用户态转到内核态的指令。这样一来，就完成了从用户态到内核态的切换。

      +

      然后是在内核态的执行。

      +

      切换到内核态之后的执行步骤跟linux0.11可以说是完全一样。

      +

      首先应该是会去执行kernel/syscall.c中的syscall函数，具体应该是通过ecall引发0x80中断，然后查表得知这个syscall是中断处理函数

      +

      image-20230105172110475.pn

      +

      可以看到，syscall获取了a7里的参数，然后查了系统调用表

      +

      image-20230105173019159

      +

      然后去sysproc.c文件下执行相应的sys_xxx函数。这个函数指针用得真是牛逼。

      +

      再然后，sys_xxx函数中会从栈中取出调用参数，再跳转到xxx(args)函数中去（这些xxx函数一般在kernel中以单独文件形式出现）。

      +

      这样一来，就完成了一次系统调用。

      +
      2. +

    2. linux0.11

      +

      首先是用户态到内核态的切换。

      +

      在用户态中比方说调用system call close()，则会调用lib/close.c下的：

      +

      image-20230105173820813

      +

      展开这个宏之后，是这样的：

      +

      image-20230105173845317

      +

      具体意思就是把close的系统调用号存入参数寄存器，然后引发0x80中断，进入内核态。

      +

      然后是在内核态的执行。

      +

      查表会得知sys_call函数是0x80中断的中断处理函数，然后就会根据参数里的系统调用名字去找系统调用表执行

      +

      image-20230105174832400

      +

      这部分跟xv6差不多，不再赘述

      +
      3. +
    +

    可见，这两个系统在内核态的实现是差不多的，只是在用户态有点稍稍不一样。感觉linux0.11会更加精妙一些。

    +

    编写pingpong程序

    +

    Write a program that uses UNIX system calls to ‘’ping-pong’’ a byte between two processes over a pair of pipes, one for each direction. The parent should send a byte to the child; the child should print “: received ping”, where is its process ID, write the byte on the pipe to the parent, and exit; the parent should read the byte from the child, print “: received pong”, and exit. Your solution should be in the file user/pingpong.c.

    +
    +
    体会

    思路很简单，我之所以写了那么久是因为走了好大的弯路……

    +

    题目要求输出格式为”: received ping”，我的思路固化为：先把pid化成数字，再用字符串拼接串成整个。为了实现我的思路，我就需要额外再写两个工具函数，一个是itoa，一个是strcat。而又由于malloc函数暂待实现，itoa和strcat的实现就仍然不够优雅。折腾了半天终于OK了，结果看到别人是怎么做到这个输出格式的呢？↓

    +
    fprintf(1,"%d: received ping\n",getpid());
    -
    proc.c中
    struct proc proc[NPROC];
    int
    countproc(){
      int nproc = 0;
      for(int i=0;i<NPROC;i++){
          if(proc[i].state != UNUSED){
    	  nproc++;
          }
      }
      return nproc;
    }
    +

    这下是真的尴尬了23333

    +

    但总而言之，自己写了那俩不够优雅的函数还算是有点用【大概】。以下是我的代码

    +

    编写primes

    +

    参考：

    +

    MIT操作系统实验lab1（案例：primes（质数筛选）附代码、详解）

    +

    XV6实验-Lab0 Utilities

    +
    +
    +

    Write a concurrent version of prime sieve using pipes. This idea is due to Doug McIlroy, inventor of Unix pipes. The picture halfway down this page and the surrounding text explain how to do it. Your solution should be in the file user/primes.c.

    +
    +

    其实就是用生产者消费者模式来写素数计算的并发版本，这个我熟

    +

    ……以上是第一印象。然后我看着超链接文章里的素数筛的图片，以及指导书给的提示：

    +
    +

    Your goal is to use pipe and fork to set up the pipeline. The first process feeds the numbers 2 through 35 into the pipeline. For each prime number, you will arrange to create one process that reads from its left neighbor over a pipe and writes to its right neighbor over another pipe. Since xv6 has limited number of file descriptors and processes, the first process can stop at 35.

    +
      +
    • Be careful to close file descriptors that a process doesn’t need, because otherwise your program will run xv6 out of resources before the first process reaches 35.
      • +
    +
    +

    义无反顾地……使用了35个管道hhhhh

    +

    然后不知道为什么不行，也焦头烂额地感觉我思路太离谱了，去看了下发现大家都是只用一个管道……

    +

    我也搞了个单管道的出来，但是思路受第一篇的影响非常地串行，也即先筛完再创建子进程。看到

    +

    XV6实验-Lab0 Utilities

    +

    这篇文章，才发现还可以那样双管道并行……我虽然也考虑过双管道，但是觉得实现不了【因为我是用循环的思路，如果要双管道的话切换会很麻烦】就没写了，没想到还可以向他那样【他选择的是一个在外部定义的p，和一个作用域更小在每次循环内定义的p1，再加上递归传递参数这个技巧，就可以接连不断递归下去了】，深感佩服。写得是真好，可以去参考学习一下，我懒得改了（

    +
    #include"user/user.h"

    int main(){
    	int p[2];
    	pipe(p);
        
    	if(fork() == 0){
    		while(1){
    			char buf[3];
    			//读入第一个数字 
    			read(p[0],buf,3);
    			int prime = atoi(buf);
    			if(prime == 36){
    				close(p[0]);
    				close(p[1]);
    				exit(0);
    			}
    			fprintf(1,"prime %d\n",prime);
    			//读入其他数字 
    			int tmp = atoi(buf);
    			while(1){
    				read(p[0],buf,3);
    				tmp = atoi(buf);
                    //输入结束
    				if(tmp == 36){
    					break;
    				}
    				if(tmp%prime!=0){
    					write(p[1],buf,3);
    				}
    			}
                //作为标记，标志着输入序列结束
    			itoa(36,buf);
    			write(p[1],buf,3);
    			if(fork()){
    			}
    			else{
    				close(p[0]);
    				close(p[1]);
    				wait(0);
    				exit(0);
    			}
    		}
    	} else{
    		close(p[0]);
    		char buf[3];
    		for(int i=2;i<=35;i++){
    			itoa(i,buf);
    			write(p[1],buf,3);
    		}
            //作为标记，标志着输入序列结束
    		itoa(36,buf);
    		write(p[1],buf,3);
    		close(p[1]);
    		wait(0);
    	}
    	exit(0);
    }
    -

    附加题

    trace plus
    -

    Print the system call arguments for traced system calls.

    +

    编写find

    +

    Write a simple version of the UNIX find program: find all the files in a directory tree with a specific name. Your solution should be in the file user/find.c.

    -

    这个实现起来要说简单也简单，麻烦也麻烦。这里就先摆了【实际上尝试了半小时发现太烦了看别人写的也不大满意就放弃了】

    -
    sysinfo plus
    -

    Compute the load average and export it through sysinfo

    +
    初始版

    直接照着ls的模板改，改成递归就ok了。值得注意的是，目录也是一种文件，也可以通过read读取。目录文件的内容就是目录里的所有文件的名字。因而，我们在递归时可以忽略文件，只对目录处理，因为目录中就包含着所有文件名的信息。

    +
    附加题：支持正则表达式

    把user/grep.c里面的匹配函数拿来就行。

    +

    编写xargs

    +

    Write a simple version of the UNIX xargs program: read lines from the standard input and run a command for each line, supplying the line as arguments to the command. Your solution should be in the file user/xargs.c.

    -

    说实话没太看懂，不就加个 running process/ncpu就行了吗？

    +
    体会

    思路还是很直观的，就是从stdin一行一行读入数据，然后把这数据处理成参数，最后调用exec就行。就是中间有很多小细节值得注意。

    +

    有一点比较坑的是，main方法的那个argc的计算方法是这样的，不是直接用数组的长度：

    +
    for(argc = 0; argv[argc]; argc++)
    + +

    可以看到，合格的argv的形式应该是：参1 参2 参3 “\0”，最后一个元素要以”\0”标志结束。

    +

    这个应该是编写者约定俗成的。在user/sh.c的parseexec，大概445行左右：

    +

    image-20230106172133338

    +

    shell处理命令时是会默认把最后一个清零的。

    +
    +

    确实，后面在学内存的时候，用户空间的构成如图所示：

    +

    image-20230109234930690

    +

    可以看到栈那边，参数列完了之后是会有一个用以terminate的空指针的

    +
    +

    附加题：改善shell

    看起来又难又多所以我先摸了【润】等之后有时间再回来弄吧

    ]]> @@ -9323,1195 +9199,1233 @@ url访问填写http://localhost/webdemo4_war/*.do。 ]]> - Interrupts and device drivers - /2023/01/10/xv6$chap5/ - Interrupts and device drivers
    -

    A driver is the code in an operating system that manages a particular device:

    + Page tables + /2023/01/10/xv6$chap3/ + Page tables

    Paging hardware

    为什么需要页表

    将主存储器以及各种外设接口卡里面内置的存储器连接起来，就形成了内存地址空间。内存地址空间中的地址是真实的物理地址。RISC-V架构的指令使用的地址是虚拟地址。为了通过指令中的虚拟地址访问到真实的物理内存，需要进行从虚拟地址到物理地址的转换。从虚拟地址到物理地址的转换，就需要通过页表来实现。

    +

    页表如何运作

    在RISC-V指令集中，当我们需要开启页表服务时，我们需要将我们预先配置好的页表首地址放入 satp 寄存器中。从此之后， 计算机硬件 将把访存的地址 均视为虚拟地址 ，都需要通过硬件查询页表，将其 翻译成为物理地址 ，然后将其作为地址发送给内存进行访存。

    +

    xv6采用的指令集标准为RISC-V标准，其中页表的标准为SV39标准，也就是虚拟地址最多为39位。

    +

    虚实地址翻译流程：

      -
    1. configures the device hardware
      2. -
    2. tells the device to perform operations
      3. -
    3. handles the resulting interrupts
      4. -
    4. interacts with processes that may be waiting for I/O from the device
      5. +
    5. 获得一个虚拟地址。根页表基地址已经被装填至寄存器 satp 中。
      6. +
    6. 通过 satp 找到根页表的物理页帧号，转成物理地址（Offset为0），通过虚拟地址的L2索引，找到对应的页表项。
      7. +
    7. 通过页表项可以找到找到 次页表 的物理页帧号，转成物理地址（Offset为0），通过虚拟地址的L1索引，找到对应的页表项。
      8. +
    8. 通过页表项可以找到找到 叶子页表 的物理页帧号，转成物理地址（Offset为0），通过虚拟地址的L0索引，找到对应的页表项。
      9. +
    9. 通过页表项可以找到找到 物理地址 的物理页帧号，通过虚拟地址的Offset，转成物理地址（Offset和虚拟地址Offset相同）。
    -

    Driver code can be tricky because a driver executes concurrently with the device that it manages.

    -

    In addition, the driver must understand the device’s hardware interface, which can be complex and poorly documented.

    -
    -

    如果devices需要让操作系统对某些事情做出响应，就要采取中断的方法。在kerneltrap中，内核响应中断，并且根据设备类型来决定中断处理函数。

    +

    页表组成

    页表项

    页表由页表项PTE（Page Table Entries）构成，每个页表项由44位的PPN（Physical Page Number）和一些参数flag组成。

    +

    image-20230109153937459

    -

    image-20230115160523827

    -

    这段对设备中断的概述总结得非常到位

    -

    也就是说，一个device driver可以分为两部分实现，一部分是接收请求，然后开启read/write；另一部分是接收中断，这个中断有可能是设备完成IO，也可能是设备需要IO，它会通知设备具体怎么做，它也会唤醒恰当的进程。

    +

    Each PTE contains flflag bits that tell the paging hardware how the associated virtual address is allowed to be used. PTE_V indicates whether the PTE is present: if it is not set, a reference to the page causes an exception (i.e. is not allowed). PTE_R controls whether instructions are allowed to read to the page. PTE_W controls whether instructions are allowed to write to the page. PTE_X controls whether the CPU may interpret the content of the page as instructions and execute them. PTE_U controls whether instructions in user mode are allowed to access the page; if PTE_U is not set, the PTE can be used only in supervisor mode.

    +

    这个表项的几个参数定义在kernel/riscv.h中的341行左右。

    -

    Code: Console input

    console driver是driver structure的一个实现案例。

    -

    上层逻辑

    shell获取用户输入console的信息是通过系统调用read()实现的。read通过文件描述符，最终转向consoleread()来实现具体的逻辑。

    -
    // in file.c fileread()
      } else if(f->type == FD_DEVICE){
        if(f->major < 0 || f->major >= NDEV || !devsw[f->major].read)
          return -1;
        r = devsw[f->major].read(1, addr, n);// 在这里转向console
      } 
    // in console.c consoleinit()
    void
    consoleinit(void)
    {
      initlock(&cons.lock, "cons");

      uartinit();

      // 在这里完成devsw的初始化
      // connect read and write system calls
      // to consoleread and consolewrite.
      devsw[CONSOLE].read = consoleread;
      devsw[CONSOLE].write = consolewrite;
    }
    - -

    对console的读写事实上是对cons结构体里buf的读写。这个buf则是由底层逻辑管理的。consoleread()每次读取buf中的一行，当未读满一行且无字符输入时会阻塞，直到底层逻辑将字符放入buf。读满了一行后，consoleread将该行copy进用户空间，随后返回read。

    -
    // in kernel/console.c 

    #define INPUT_BUF_SIZE 128
    struct {
      struct spinlock lock;
      char buf[INPUT_BUF_SIZE];
      uint r;  // Read index
      uint w;  // Write index
      uint e;  // Edit index
    } cons;


    // user read()s from the console go here.
    // copy (up to) a whole input line to dst.
    // user_dist indicates whether dst is a user
    // or kernel address.
    int
    consoleread(int user_dst, uint64 dst, int n)
    {
      uint target;
      int c;
      char cbuf;

      target = n;
      acquire(&cons.lock);
      while(n > 0){
        // wait until interrupt handler has put some
        // input into cons.buffer.
        // read和write的index一样，说明此时没有数据输入，阻塞
        while(cons.r == cons.w){
          if(killed(myproc())){
            release(&cons.lock);
            return -1;
          }
          sleep(&cons.r, &cons.lock);
        }
        // 产生数据输入，接收数据
        c = cons.buf[cons.r++ % INPUT_BUF_SIZE];

        if(c == C('D')){  // end-of-file
          if(n < target){
            // Save ^D for next time, to make sure
            // caller gets a 0-byte result.
            // 这样下一次也能访问到eof
            cons.r--;
          }
          break;
        }

        // copy the input byte to the user-space buffer.
        cbuf = c;
        if(either_copyout(user_dst, dst, &cbuf, 1) == -1)
          break;

        dst++;
        --n;

        if(c == '\n'){
          // a whole line has arrived, return to
          // the user-level read().
          break;
        }
      }
      release(&cons.lock);

      return target - n;
    }
    - -

    底层逻辑

    底层逻辑维护了与上层逻辑交互的buf。

    -

    console接收数据对buf的读，是通过中断来实现的。

    -

    当用户输入字符，UART硬件检测到读，会向操作系统发送中断。中断在kerneltrap()中被接收处理，然后通过devintr()对该中断分门别类地进行转发。console的转发路径为devintr->uartintr->consoleintr。

    -

    UART

    UART的全称是Universal Asynchronous Receiver and Transmitter，即异步发送和接收。它的软件上的表示形式是a set of memory-mapped control registers。CPU通过物理地址与这些寄存器交互，也即它们跟RAM是同一个地址空间。在xv6中，UART的地址空间从UART0(0x1000 0000)开始。这些寄存器地址关于UART0的偏移量定义如下：

    -
    // the UART control registers.
    // some have different meanings for read vs write.
    // see http://byterunner.com/16550.html
    #define RHR 0                 // 接收寄存器receive holding register (for input bytes)
    #define THR 0                 // 发送寄存器transmit holding register (for output bytes)
    #define IER 1                 // 开关中断寄存器
    #define IER_RX_ENABLE (1<<0)  // 如果该位被设置，则在接收寄存器有数据，即想向外界发送数据时，UART会搓出一个中断
    #define IER_TX_ENABLE (1<<1)  // 如果该位被设置，则在发送寄存器有数据，即外界向硬件发送数据时，UART会搓出一个中断
    #define FCR 2                 // FIFO control register
    #define FCR_FIFO_ENABLE (1<<0)
    #define FCR_FIFO_CLEAR (3<<1) // clear the content of the two FIFOs
    // ...
    #define LCR 3                 // line control register
    // ...
    #define LSR 5                 // line status register
    #define LSR_RX_READY (1<<0)   // input is waiting to be read from RHR
    #define LSR_TX_IDLE (1<<5)    // THR can accept another character to send
    - +

    虚拟地址有64bit，其中25bits未使用，39bits包含了27位的PTE索引号以及12位的offset。

    +

    物理地址有56位，由PPN和offset拼接组成。

    +

    单页表和多级页表

    以单页表为例，物理地址形成过程如下图所示。

    +

    image

    +

    每个页表项PTE索引着一页。因而，每一页的大小为2^12=4096B。单页表中PTE的索引号有2^27个，因而单页表中表项有134217728个，即可以代表134217728页。页表实际上也是以页的形式存储的。因而单页表需要的存储空间为(2^27x7)/2^12=2^15x7=229376页。

    +

    RISC-V架构中真实情况是会有三级页表。三级页表结构相比于单级页表结构，会占据更多的物理存储空间。

    +

    image-20230109151346780

    +

    每个页表项PTE索引着一页，这一页可能代表着另一个页表，也可能代表着内存中需要的指令和数据。因而，每一页的大小为2^12=4096B。三页表中，一级页表中PTE的索引号有512个，可以代表的物理内存页数有512x515x512=2^27页，即可以代表134217728页。页表实际上也是以页的形式存储的，一个页表有2^9x7个字节，可以存储在1页中。因而三页表需要的存储空间为1+2^9+2^18 = 262657页。

    +

    三级页表结构相比于单级页表结构，可以节省更多内存空间。

    -

    image-20230115170107044

    -

    例如，LSR寄存器包含指示输入字符是否正在等待软件读取的位。这些字符（如果有的话）可用于从RHR寄存器读取。每次读取一个字符，UART硬件都会从等待字符的内部FIFO寄存器中删除它，并在FIFO为空时清除LSR中的“就绪”位。UART传输硬件在很大程度上独立于接收硬件；如果软件向THR写入一个字节，则UART传输该字节。

    +

    参考：页表是啥以及为啥多级页表能够节省空间

    -

    kerneltrap

    // in kerneltrap()
      // 在此处的devintr对不同的设备进行不同的处理方式
      if((which_dev = devintr()) == 0){
        printf("scause %p\n", scause);
        printf("sepc=%p stval=%p\n", r_sepc(), r_stval());
        panic("kerneltrap");
      }
    - -

    devintr

    devintr处在trap.c中，作用是对中断归类，然后分门别类地转发到下一层级的handler。

    +

    考虑到这样一个进程：

    +

    watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1eXVhbmRl,size_16,color_FFFFFF,t_70

    +

    进程使用页表时，需要将整个页表读入内存。

    +

    如果使用单级页表，尽管一个进程仅使用到页表中的某两项，也需要把整个页表都读入内存，光是页表就占据了2^15x7x4k/2^20 约为1G的内存空间。

    +

    如果使用三级页表，一个进程需要用到某两页。假设这两页存储在不同的二级页表中，则只需要读入1+2+2=5页 约为20K的内存空间。

    +

    两者相对比，显然用三级页表比单级页表顶多了。三级页表相较于一级页表，多用了13%的物理空间，却可以节省99.998%的空间。

    +

    页表使用

    每个进程会保留自己的一份用户级别的页表地址。当轮到自己使用CPU时，会将CPU的satp寄存器更换为自己的页表地址。

    +

    Kernel address space

    介绍了xv6中内核的页表结构。

    -

    注：

    -
      -

    1. 外中断和内中断

      -

      外部中断和内部中断详解

      -

      根据中断源的不同，可以把中断分为硬件中断和软件中断两大类，而硬件中断又可以分为外部中断和内部中断两类。

      -

      外部中断一般是指由计算机外设发出的中断请求，如：键盘中断、打印机中断、定时器中断等。外部中断是可以屏蔽的中断，也就是说，利用中断控制器可以屏蔽这些外部设备的中断请求。

      -

      内部中断是指因硬件出错（如突然掉电、奇偶校验错等）或运算出错（除数为零、运算溢出、单步中断等）所引起的中断。内部中断是不可屏蔽的中断。

      -

      软件中断其实并不是真正的中断，它们只是可被调用执行的一般程序。例如：ROM BIOS中的各种外部设备管理中断服务程序（键盘管理中断、显示器管理中断、打印机管理 中断等，）以及DOS的系统功能调用（INT 21H）等都是软件中断。【比如说系统调用之类的】

      -
      2. -
    +

    这里为了方便，就把三级页表省略了，只留下va和pa的对比

    -
    // check if it's an external interrupt or software interrupt,
    // and handle it.
    // returns 2 if timer interrupt,
    // 1 if other device,
    // 0 if not recognized.
    int
    devintr()
    {
      // 获取scause，辨析中断类型
      uint64 scause = r_scause();

      // 如果来自外中断（在这里应该只指device interrupt）
      if((scause & 0x8000000000000000L) &&
         (scause & 0xff) == 9){
        // this is a supervisor external interrupt, via PLIC.

        // irq indicates which device interrupted.
        // 通过PLIC硬件获取中断设备信息
        int irq = plic_claim();

        // 分别转发
        if(irq == UART0_IRQ){
          uartintr();
        } else if(irq == VIRTIO0_IRQ){
          virtio_disk_intr();
        } else if(irq){
          printf("unexpected interrupt irq=%d\n", irq);
        }

        // 中断处理完成了，可以再次开启中断
        // the PLIC allows each device to raise at most one
        // interrupt at a time; tell the PLIC the device is
        // now allowed to interrupt again.
        if(irq)
          plic_complete(irq);

        return 1;
      // 来自时钟中断
      } else if(scause == 0x8000000000000001L){
        // ...
        return 2;
      } else {
        return 0;
      }
    }
    - -

    uartintr

    这代码其实乍一看是看不懂的，这是因为uartintr不止负责读中断。它还负责另一个中断（发送区空余中断），下面会细说。

    -
    // handle a uart interrupt, raised because input has
    // arrived, or the uart is ready for more output, or
    // both. called from devintr().
    void
    uartintr(void)
    {
      // read and process incoming characters.
      while(1){
        int c = uartgetc();
        // return -1 if none is waiting,说明读完了
        if(c == -1)
          break;
        // 每读入一个字符就转交给console
        consoleintr(c);
      }

      // send buffered characters.
      acquire(&uart_tx_lock);
      uartstart();
      release(&uart_tx_lock);
    }
    - -

    consoleintr

    向buf中放入字符c

    -
    void
    consoleintr(int c)
    {
      acquire(&cons.lock);

      switch(c){
          case C('P'):  // Print process list.
          // ...一堆特殊情况处理...
          default:
            if(c != 0 && cons.e-cons.r < INPUT_BUF_SIZE){
              c = (c == '\r') ? '\n' : c;

              // echo back to the user.
              consputc(c);

              // store for consumption by consoleread().
              cons.buf[cons.e++ % INPUT_BUF_SIZE] = c;

              if(c == '\n' || c == C('D') || cons.e-cons.r == INPUT_BUF_SIZE){
                // wake up consoleread() if a whole line (or end-of-file)
                // has arrived.
                // 中断处理并不会做很多事情，只是会与缓冲区交互
                // 涉及到复杂的事情，比如说将数据拷贝到用户空间
                //就唤醒上层逻辑来做
                cons.w = cons.e;
                wakeup(&cons.r);
              }
        	}
        	break;
      }
      
      release(&cons.lock);
    }
    - -

    Code: Console output

    外部通过write这个系统调用来对console写。

    -

    uartputc

    最先到达这里。

    -

    uart内置了一个缓冲区。

    -
    char uart_tx_buf[UART_TX_BUF_SIZE];
    - -

    用户仅需通过uartputc对buf进行写入即可，具体的buf数据向UART转移由uartputc通过调用uartstart实现。

    -
    // add a character to the output buffer and tell the
    // UART to start sending if it isn't already.
    // blocks if the output buffer is full.缓冲区满则阻塞
    // because it may block, it can't be called
    // from interrupts; it's only suitable for use
    // by write().这段话很有意思，说它由于会阻塞所以最好别在中断的时候用。
    void
    uartputc(int c)
    {
      acquire(&uart_tx_lock);

      if(panicked){
        for(;;)
          ;
      }
      // 阻塞
      while(uart_tx_w == uart_tx_r + UART_TX_BUF_SIZE){
        // buffer is full.
        // wait for uartstart() to open up space in the buffer.
        sleep(&uart_tx_r, &uart_tx_lock);
      }
      uart_tx_buf[uart_tx_w % UART_TX_BUF_SIZE] = c;
      uart_tx_w += 1;
      uartstart();
      release(&uart_tx_lock);
    }
    - -

    uartstart

    uartstart的作用是从缓冲区取数据向UART硬件发送。不阻塞。

    -
    // if the UART is idle, and a character is waiting
    // in the transmit buffer, send it.
    // caller must hold uart_tx_lock.
    // called from both the top- and bottom-half.
    void
    uartstart()
    {
      while(1){
        if(uart_tx_w == uart_tx_r){
          // transmit buffer is empty.
          return;
        }
        
        if((ReadReg(LSR) & LSR_TX_IDLE) == 0){
          // the UART transmit holding register is full,
          // so we cannot give it another byte.
          // it will interrupt when it's ready for a new byte.
          // 当缓冲区满没有选择阻塞，而是先结束
          // 当UART硬件准备好继续接收的时候，UART会发送transmit complete中断，到时候会再继续从buf读取
          return;
        }
        
        // 一个字符一个字符写
        int c = uart_tx_buf[uart_tx_r % UART_TX_BUF_SIZE];
        uart_tx_r += 1;
        
        // maybe uartputc() is waiting for space in the buffer.
        wakeup(&uart_tx_r);
        
        WriteReg(THR, c);
      }
    }
    - -

    当传输过程非常流畅，UART硬件没有阻塞时，以上的代码就能完美阐述发送的过程。但是当UART硬件的transmit阻塞时，过程就会有许多改动。

    -

    transmit complete interrupt

    在uartstart中，当UART硬件的transmit满，uartstart就直接return了。

    -

    当UART硬件的transmit空，就会发送transmit complete中断。中断在kerneltrap被接收，经过devintr转发，最终来到了uartintr：

    -
    // handle a uart interrupt, raised because input has
    // arrived, or the uart is ready for more output, or
    // both. called from devintr().
    void
    uartintr(void)
    {
      // read and process incoming characters.
      while(1){
        int c = uartgetc();
        if(c == -1)
          break;
        consoleintr(c);
      }

      // send buffered characters.
      acquire(&uart_tx_lock);
      uartstart();
      release(&uart_tx_lock);
    }
    - -

    此时，第一个while循环会直接退出，因为压根没有get到字符。所以，这时候，就会去执行uartstart，然后继续读未完成读取的缓冲区。

    -

    等到所有都读完了，最后一次发送transmit complete中断时，会在uartstart进入该分支：

    -
    if(uart_tx_w == uart_tx_r){
      // transmit buffer is empty.
      return;
    }
    +

    每个进程都有一个用户级别的页表。xv6给内核提供了一个单独的内核地址空间的页表。其层级映射关系如下：

    +

    p3

    +

    在kernel/memlayout.h中正记录了这些参数：

    +
    // Physical memory layout

    // qemu -machine virt is set up like this,
    // based on qemu's hw/riscv/virt.c:
    //
    // 00001000 -- boot ROM, provided by qemu
    // 02000000 -- CLINT
    // 0C000000 -- PLIC
    // 10000000 -- uart0 
    // 10001000 -- virtio disk 
    // 80000000 -- boot ROM jumps here in machine mode
    //             -kernel loads the kernel here
    // unused RAM after 80000000.

    // the kernel uses physical memory thus:
    // 80000000 -- entry.S, then kernel text and data
    // end -- start of kernel page allocation area
    // PHYSTOP -- end RAM used by the kernel

    // qemu puts UART registers here in physical memory.
    #define UART0 0x10000000L
    #define UART0_IRQ 10

    // virtio mmio interface
    #define VIRTIO0 0x10001000
    #define VIRTIO0_IRQ 1

    // core local interruptor (CLINT), which contains the timer.
    // ...
    -

    然后就不会再发送transmit中断了。

    -

    感觉这点是真的牛逼。uartintr这个函数完美兼顾了两种情况【这也归功于uartstart做得很健壮】：1. 外部输入数据到console，2. 接收数据未结束，继续接收

    -

    Concurrency in drivers

    用户进程与设备之间的读写交流，比如说上面的console，重点依靠于uart_tx_buf和cons.buf这两个的正确性。因而，就需要保障它们的并发安全。在上面的代码中，使用到这两个的地方都被锁保护着。

    -

    在kernel中还需要格外注意的一点并发是，一个进程A在等待来自设备的中断，但此时另一个进程B在运行。这时候设备发出中断信号，CPU转入中断处理程序处理中断。此时，中断处理程序的执行不应该涉及到当前被中断进程的代码。例如，中断处理程序不能安全地使用当前进程的页表调用copyout（页表正是跟当前进程息息相关的）。中断处理程序通常做相对较少的工作（例如，只需将输入数据复制到缓冲区），并唤醒上半部分代码来完成其余工作。

    -

    Timer interrupts

    -

    Xv6 uses timer interrupts to maintain its clock and to enable it to switch among compute-bound processes; the yield calls in usertrap and kerneltrap cause this switching.

    +

    由图可知，一直从0x0到0x86400000，都是采取的直接映射的方式，虚拟地址=物理地址，这段是内核使用的空间。在0x0-0x800000000阶段，物理地址代表着各种IO设备的存储器。

    +

    但是注意，在0x86400000（PHYSTOP）以上的地址都不是直接映射，这些非直接映射的层级包含两类：

    +
      +

    1. trampoline

      +
      +

      It is mapped at the top of the virtual address space; user page tables have this same mapping.

      -
      // in kernel/trap.c usertrap()
        // give up the CPU if this is a timer interrupt.
        if(which_dev == 2)
          yield();
      - -
      // in kernel/trap.c kerneltrap()
        // give up the CPU if this is a timer interrupt.
        if(which_dev == 2 && myproc() != 0 && myproc()->state == RUNNING)
          yield();
      - +

      它有一点很特殊的是，它实际对应的物理内存是0x80000000开始的一段。也就是说，0x80000000开始的这段内存，既被直接映射了，也被trampoline通过虚拟地址映射了。它被映射了两次。

      +
      2. +

    2. 内核栈

      -

      RISC-V requires that timer interrupts be taken in machine mode, not supervisor mode. As a result, xv6 handles timer interrupts completely separately from the trap mechanism laid out above.

      +

      Each process has its own kernel stack, which is mapped high so that below it xv6 can leave an unmapped guard page. The guard page’s PTE is invalid (i.e., PTE_V is not set), so that if the kernel overflflows a kernel stack, it will likely cause an exception and the kernel will panic.

      +

      guard page可以用来防止内核栈溢出。

      -

      xv6启动时调用过start.c。start.c处于机器态，并准备向内核态过渡。start.c中就对时钟进行了初始化timeinit()。要做的有以下几件事：

      -
        -
      1. program the CLINT hardware (core-local interruptor) to generate an interrupt after a certain delay.
        2. -
      2. set up a scratch area to help the timer interrupt handler save registers and the address of the CLINT registers
        3. -
      3. start sets mtvec to timervec and enables timer interrupts.
        4. +
      -
      // arrange to receive timer interrupts.
      // they will arrive in machine mode at
      // at timervec in kernelvec.S,
      // which turns them into software interrupts for
      // devintr() in trap.c.
      void
      timerinit()
      {
        // each CPU has a separate source of timer interrupts.
        int id = r_mhartid();

        // ask the CLINT for a timer interrupt.
        int interval = 1000000; // cycles; about 1/10th second in qemu.
        *(uint64*)CLINT_MTIMECMP(id) = *(uint64*)CLINT_MTIME + interval;

        // prepare information in scratch[] for timervec.
        // scratch[0..2] : space for timervec to save registers.
        // scratch[3] : address of CLINT MTIMECMP register.
        // scratch[4] : desired interval (in cycles) between timer interrupts.
        uint64 *scratch = &timer_scratch[id][0];
        scratch[3] = CLINT_MTIMECMP(id);
        scratch[4] = interval;
        w_mscratch((uint64)scratch);

        // set the machine-mode trap handler.
        w_mtvec((uint64)timervec);

        // enable machine-mode interrupts.
        w_mstatus(r_mstatus() | MSTATUS_MIE);

        // enable machine-mode timer interrupts.
        w_mie(r_mie() | MIE_MTIE);
      }
      +

      内核使用PTE_R和PTE_X权限映射trampoline和kernel text。这表明这份内存段可以读，可以被当做指令块执行，但不能写。其他的块都是可读可写的，除了guard page被设置为不可访问。

      +

      Code: creating an address space

      vm.c

      操作地址空间和页表部分的代码都在kernel/vm.c中。代表页表的数据结构是pagetable_t。

      +

      vm.c的主要函数有walk、mappages等。walk用来在三级页表中找到某个虚拟地址表项，或者创建一个新的表项。mappages用来新建一个表项，主要用到了walk函数。

      +

      vm.c中，以kvm开头的代表操纵内核页表，以uvm开头的代表操纵进程里的用户页表。

      +

      以初始化为例介绍各个函数

      创建页表

      一开始操作系统初始化时，会调用vm.c中的kvminit来创建内核页表。主要就是在以内核地址空间的页表结构在填写页表。

      +
      void
      kvminit(void)
      {
        kernel_pagetable = kvmmake();
      }
      // Make a direct-map page table for the kernel.
      pagetable_t
      kvmmake(void)
      {
        //内核页表
        pagetable_t kpgtbl;
        //申请新的一页
        kpgtbl = (pagetable_t) kalloc();
        memset(kpgtbl, 0, PGSIZE);

        //给内核页表初始化表项，结构详见上面的内核地址空间部分
        // uart registers
        kvmmap(kpgtbl, UART0, UART0, PGSIZE, PTE_R | PTE_W);

        // virtio mmio disk interface
        kvmmap(kpgtbl, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);

        // PLIC
        kvmmap(kpgtbl, PLIC, PLIC, 0x400000, PTE_R | PTE_W);

        // map kernel text executable and read-only.
        kvmmap(kpgtbl, KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);

        // map kernel data and the physical RAM we'll make use of.
        kvmmap(kpgtbl, (uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);

        // map the trampoline for trap entry/exit to
        // the highest virtual address in the kernel.
        kvmmap(kpgtbl, TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);

        // allocate and map a kernel stack for each process.
        proc_mapstacks(kpgtbl);
        
        return kpgtbl;
      }
      -
      -

      计时器中断处理程序必须保证不干扰中断的内核代码。基本策略是处理程序要求RISC-V发出“软件中断”并立即返回。RISC-V用普通陷阱机制将软件中断传递给内核，并允许内核禁用它们。处理由定时器中断产生的软件中断的代码可以在devintr (kernel/trap.c:204)中看到：

      -
      -
      // in kernel/trap.c devintr()
         } else if(scause == 0x8000000000000001L){
          // software interrupt from a machine-mode timer interrupt,
          // forwarded by timervec in kernelvec.S.

          // 只看其中一个CPU的时钟中断计数的意思吗？确实，要是好几个一起来加倍了非常不合理
          if(cpuid() == 0){
            clockintr();
          }
          
          // acknowledge the software interrupt by clearing
          // the SSIP bit in sip.
          w_sip(r_sip() & ~2);

          return 2;
        } 

      void
      clockintr()
      {
        acquire(&tickslock);
        ticks++;
        wakeup(&ticks);
        release(&tickslock);
      }
      +

      其中，kvmmap用来在内核页表中添加一个新的表项。其函数形式为

      +
      // add a mapping to the kernel page table.
      // only used when booting.
      // does not flush TLB or enable paging.
      void
      kvmmap(pagetable_t kpgtbl, uint64 va, uint64 pa, uint64 sz, int perm)
      {
        if(mappages(kpgtbl, va, sz, pa, perm) != 0)
          panic("kvmmap");
      }
      -

      注意，w_sip(r_sip() & ~2);就对应着“RISC-V用普通陷阱机制将软件中断传递给内核”。【应该吧个人理解】

      -
      -

      来源：rCore 手册（rCore tutorial doc）

      -

      riscv 中的中断寄存器

      -

      S 态的中断寄存器主要有 sie（Supervisor Interrupt Enable，监管中断使能）, sip （Supervisor Interrupt Pending，监管中断待处理）两个，其中 s 表示 S 态，i 表示中断， e/p 表示 enable (使能)/ pending (提交申请)。 处理的中断分为三种：

      -
        -
      1. SI(Software Interrupt)，软件中断
        2. -
      2. TI(Timer Interrupt)，时钟中断
        3. -
      3. EI(External Interrupt)，外部中断
        4. -
      -

      比如 sie 有一个 STIE 位， 对应 sip 有一个 STIP 位，与时钟中断 TI 有关。当硬件决定触发时钟中断时，会将 STIP 设置为 1，当一条指令执行完毕后，如果发现 STIP 为 1，此时如果时钟中断使能，即 sie 的 STIE 位也为 1 ，就会进入 S 态时钟中断的处理程序。

      -

      可能SSIP跟这里的STIP差不多吧，都是时钟中断的标志。如果把SSIP clear掉，那么则说明不是时钟中断了，而是软中断了。

      -
      -

      Real world

      -

      UART驱动程序读取UART控制寄存器，一次检索一字节的数据；因为软件驱动数据移动，这种模式被称为程序I/O（Programmed I/O）。程序I/O很简单，但速度太慢，无法在高数据速率下使用。需要高速移动大量数据的设备通常使用直接内存访问（DMA）。DMA设备硬件直接将传入数据写入内存，并从内存中读取传出数据。现代磁盘和网络设备使用DMA。DMA设备的驱动程序将在RAM中准备数据，然后使用对控制寄存器的单次写入来告诉设备处理准备好的数据。

      -

      当一个设备在不可预知的时间需要注意时，中断是有意义的，而且不是太频繁。但是中断有很高的CPU开销。因此，如网络和磁盘控制器的高速设备，使用一些技巧减少中断需求。一个技巧是对整批传入或传出的请求发出单个中断。另一个技巧是驱动程序完全禁用中断，并定期检查设备是否需要注意。这种技术被称为轮询（polling）。如果设备执行操作非常快，轮询是有意义的，但是如果设备大部分空闲，轮询会浪费CPU时间。一些驱动程序根据当前设备负载在轮询和中断之间动态切换。

      -

      UART驱动程序首先将传入的数据复制到内核中的缓冲区，然后复制到用户空间。这在低数据速率下是可行的，但是这种双重复制会显著降低快速生成或消耗数据的设备的性能。一些操作系统能够直接在用户空间缓冲区和设备硬件之间移动数据，通常带有DMA。

      -
      -

      Lab: networking

      -

      In this lab you will write an xv6 device driver for a network interface card (NIC).

      -

      这个概述光是听起来就让人觉得热血沸腾。网络的本质其实就是IO设备，这一点我一直觉得很牛逼，而现在我居然要亲手实现网络……That’s very cool.

      -
      -
      -

      On this emulated LAN, xv6 (the “guest”) has an IP address of 10.0.2.15.

      -

      Qemu also arranges for the computer running qemu to appear on the LAN with IP address 10.0.2.2.

      -

      When xv6 uses the E1000 to send a packet to 10.0.2.2, qemu delivers the packet to the appropriate application on the (real) computer on which you’re running qemu (the “host”).

      -
      -
      -

      We’ve added some files to the xv6 repository for this lab.

      -

      The file kernel/e1000.c contains initialization code for the E1000 as well as empty functions for transmitting and receiving packets, which you’ll fill in.

      -

      kernel/e1000_dev.h contains definitions for registers and flag bits defined by the E1000 and described in the Intel E1000 Software Developer’s Manual.

      -

      kernel/net.c and kernel/net.h contain a simple network stack that implements the IP, UDP, and ARP protocols.

      -

      These files also contain code for a flexible data structure to hold packets, called an mbuf.

      -

      Finally, kernel/pci.c contains code that searches for an E1000 card on the PCI bus when xv6 boots.

      -
      +

      实现主要逻辑的是mappages函数

      +
      // Create PTEs for virtual addresses starting at va that refer to
      // physical addresses starting at pa. va and size might not
      // be page-aligned. Returns 0 on success, -1 if walk() couldn't
      // allocate a needed page-table page.
      int
      mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
      {
        uint64 a, last;
        pte_t *pte;

        if(size == 0)
          panic("mappages: size");
        
        a = PGROUNDDOWN(va);
        last = PGROUNDDOWN(va + size - 1);
        for(;;){
          //walk函数通过虚拟地址新建一个第三级页表的表项并返回其指针，之后只需要填这个表项即可
          if((pte = walk(pagetable, a, 1)) == 0)
            return -1;
          //如果pte存在并且标记为已使用，说明该虚拟地址映射已经存在
          if(*pte & PTE_V)
            panic("mappages: remap");
          //填写表项：物理地址 flags
          *pte = PA2PTE(pa) | perm | PTE_V;
          if(a == last)
            break;
          //每两个表项间隔PGSIZE个字节
          a += PGSIZE;
          pa += PGSIZE;
        }
        return 0;
      }
      + +

      通过虚拟地址获取表项主要是通过walk实现的

      +
      // Return the address of the PTE in page table pagetable
      // that corresponds to virtual address va.  If alloc!=0,
      // create any required page-table pages.
      //
      // The risc-v Sv39 scheme has three levels of page-table
      // pages. A page-table page contains 512 64-bit PTEs.
      // A 64-bit virtual address is split into five fields:
      //   39..63 -- must be zero.
      //   30..38 -- 9 bits of level-2 index.
      //   21..29 -- 9 bits of level-1 index.
      //   12..20 -- 9 bits of level-0 index.
      //    0..11 -- 12 bits of byte offset within the page.
      // 虚拟地址的格式：UNUSED 页表索引 offset，其中页表索引在三级页表中被划分为了三个，分别是
      // level0-level2，分别代表了第三级、第二级、第一级页表的索引【具体可见页表组成中的图】
      // walk的目的就是要在这三级页表中找到虚拟地址对应的页表项。当alloc!=0时，则要求找不到就新建一个
      pte_t *
      walk(pagetable_t pagetable, uint64 va, int alloc)
      {
        if(va >= MAXVA)
          panic("walk");

        for(int level = 2; level > 0; level--) {
          pte_t *pte = &pagetable[PX(level, va)];
          if(*pte & PTE_V) {
            // 取出PTE中表示下一级页表地址的字节
            pagetable = (pagetable_t)PTE2PA(*pte);
          } else {
            // 页表不存在的情况，要么返回0，要么新建一页
            if(!alloc || (pagetable = (pde_t*)kalloc()) == 0)
              return 0;
            memset(pagetable, 0, PGSIZE);
            *pte = PA2PTE(pagetable) | PTE_V;
          }
        }
        // 最终返回第三级页表的对应表项
        return &pagetable[PX(0, va)];
      }
      + +
      装上页表

      使用的是kvminithart函数。它将内核页表的root page table的物理地址写入了satp寄存器。从这个函数之后，就开启了内存映射。

      +
      // Switch h/w page table register to the kernel's page table,
      // and enable paging.
      void
      kvminithart()
      {
        // wait for any previous writes to the page table memory to finish.
        sfence_vma();

        w_satp(MAKE_SATP(kernel_pagetable));

        // flush stale entries from the TLB.
        sfence_vma();
      }
      + +

      其中sfence_vma()的用途是强制更新TLB的旧页表，类似于Java volatile的作用。

      +
      疑问

      附上书里的详细解释：

      +

      image-20230109222917346

      +

      TLB与页表类似于cache与主存的关系。TLB保存了页表的一部分。

      +
      我的错误想法

      我怎么感觉怪怪的啊？因为TLB既然是高速缓存，那么读写页表也应该优先从TLB读写【注：应该就是从这里开始错的hhh写应该是直接写入页表】。所以说，会陈旧的应该是主存中的页表，而不是TLB中的页表。但是，书里是说，改完页表必须通知TLB更改。也就是说，读写页表不是从TLB读写的，那该是从哪里？是TLB以外的free memory吗？

      +

      不过，要是从多CPU的角度思考，说不定他这个意思是某个CPU的TLB变了，需要通知其他所有CPU的TLB也变。虽然不同CPU当前执行的进程是不一样的，使用的页表项不一样，切换进程的时候也会把用户地址空间的页表项flush掉。但是内核地址空间的页表项一般是不会随着进程切换而flush掉的。所以内核页表修改就需要手动多CPU同步。

      +

      我认为多CPU角度考虑更加合理，因为它最后说了，xv6会在内核页表init后flush，以及在从内核态切换回用户态的时候flush。这两个（好像）都影响内核页表比较多，所以就需要手动flush一下。

      +
      解答

      之后学了缺页异常后，可以发现这里其实是没问题的。

      +

      计算机体系结构 – 虚拟内存

      +

      v2-e15454bf032baa4dc088b6e41ed4f4a4_1440w

      +

      页表的管理（创建、更新、删除等）是由操作系统负责的。地址转换时，页表检索是由硬件内存管理单元（Memory Management Unit, MMU）负责的。MMU通常由两部分构成：表查找单元（Table Walk Unit, TWU）和转换旁路缓冲（Translation Lookaside Buffer, TLB）[2]。TWU负责链式的访问PDE、PTE，完成上述的查表过程。

      +

      应用多级页表之后，想要完成一次地址转换，需要访问多级目录和页表，这么多次的内存访问会严重降低性能。

      +

      为了优化地址转换速度，人们在MMU中增加了一块高速cache，专门用来缓存虚拟地址到物理地址的映射，这块cache就是TLB[7][8]。MMU在做地址转换的时候，会先检索TLB，如果命中则直接返回对应的物理地址，如果不命中则会调用TWU查找页表。

      +

      TLB中缓存的是虚拟地址到物理地址映射。然而，多级页表的查找是一个链式的过程，对于在虚拟地址空间中连续的两个页，它们的各级目录项可能都是一样的，只有最后一级页号不一样。查找完第一个虚拟页之后，我们可以将相同的前级目录项都缓存起来。查找第二个虚拟页时，可以直接使用缓存好的前几级目录项，节省查找时间。这种缓存叫做Page Structure Cache[9]。

      +

      而当TLB和MMU中都没有该物理页，就会发生缺页异常。但是操作系统仅会对页表更新，而不会被TLB更新。故而，TBL中数据可能陈旧，需要手动flush。

      +

      Physical memory allocation

      在内核运行的时候，需要申请很多空间用来存放各种数据。

      -

      Your job：

      -

      Your job is to complete e1000_transmit() and e1000_recv(), both in kernel/e1000.c, so that the driver can transmit and receive packets. You are done when make grade says your solution passes all the tests.

      +

      The kernel must allocate and free physical memory at run-time for page tables, user memory, kernel stacks, and pipe buffers.

      -

      感想

      说实话，一开始看题的时候真是感觉非常地哈人……但其实文档看着看着，心中也逐渐有了个大概，最后再结合下指导书的提示【当然不是后面那些保姆级的Hints】，最后写的也就八九不离十了。总体上来说，我觉得这次实验的代码还是很简单的，它主要难在探究过程，也就是从一开始什么也不懂，然后去阅读硬件设备的文档，结合代码尝试去理解，最后一步步写出来的过程。本次实验耗时六小时，我觉得肯定有不少于一半，甚至可能达到2/3的时间都耗费在理解上。这种从零开始探究的过程给了我很大的收获，同时也稍微提高了我面对挫折的能力。

      -

      这个实验确实设计得很有教育意义。除了我上面说的它锻炼了我的能力以外，它其实还具有比较深刻的工业意义。在看书的时候，书中这么写道：

      +

      用的是这段空闲内存：

      +

      image-20230109225700837

      -

      In addition, the driver must understand the device’s hardware interface, which can be complex and poorly documented.

      +

      It keeps track of which pages are free by threading a linked list through the pages themselves.

      -

      本次实验正是上述描述的简化版：E1000的文档很详细，并且我们只用掌握一部分它的功能就行了。但虽然简化了，其探究过程的内在逻辑还是不会改变的。

      -

      总之，我很喜欢这次实验的设计。我的评价是牛逼。

      -

      思路

      正确思路

      Hints写得很详细，不做赘述了。主要就是明确一下数据结构的问题：

      -
        -

      1. rx_ring和tx_ring是两个分开的队列

        -

        它们只是结构一模一样，都是阴影部分表示software持有，白色部分表示硬件持有。

        -

        因而，对于rx来说，白色部分表示需要传给协议栈的包，因而我们需要把白色部分转化为阴影部分；对于tx来说，白色部分表示网卡将要发送的包，因而我们需要把阴影部分转化为白色部分。

        -

        image-20230220234406239

        -
        2. -

      2. rx_mbufs和tx_mbufs

        -

        一开始不知道这俩是啥，后来才意识到，这俩和第1点的那俩其实是下标一一对应的关系。也就是说rx_ring[i]这个descriptor接收到的数据存在rx_mbufs[i]，tx_ring[i]要发送的数据存在tx_mbufs[i]。知道了这个之后，代码就简单了。

        +

        kalloc.c中就是这么实现的。

        +

        Code: Physical memory allocator

        内核运行时申请释放空闲物理空间是通过kernel/kalloc.c完成的。它为内核栈、用户进程、页表和管道buffer服务。

        -

        忏悔：我一开始真没反应过来。计网我记得是有一模一样的结构的，看来算是白做了2333

        +

        kalloc.c用来在运行时申请分配新的一页，上面的vm.c正是用了kalloc申请一页，要么作为页表，要么作为存储数据的第三级页表指向的物理内存。

        -
        3. -
      -

      个人的推理过程

      一开始就先懵懵懂懂地看指导书，直到看到这句话：

      +

      最后应该会在空闲内存内形成这样的结构：

      +

      内存分成一页一页的，每页内存中的前几个字节存储着其对应队列中下一块内存的物理地址。不一定是从小地址到大地址顺序连接。

      -

      Browse the E1000 Software Developer’s Manual.

      +

      It store each free page’s run structure in the free page itself, since there’s nothing else stored there.

      -

      然后我这时连自己要干什么都迷迷糊糊，但姑且还是按他下面说的，准备先浏览第二章了。然而，我发现要我看我也还是看不懂啊，所以我就直接放弃了。【经验1：看不懂就算了，别死磕了】

      -

      我放弃了第二章后，就再次从头开始细细看了一遍这句话之前的指导书，也结合了一下它给的代码。这次总算是差不多弄懂这次要做什么了：

      -

      实现driver的两个函数，从而实现对网卡进行数据的取出和送入。数据是eth frame。数据取出后要通过net_rx传递给上层协议栈。数据是mbuf类型的。

      -

      所以我们只需实现协议栈最底下的部分，也即从网卡读写数据，其他一些别的东西比如协议栈什么的都已经写好了。

      -

      但是那些什么rx_ring，还有各种奇奇怪怪的寄存器，我都看不懂，所以我就去看第三章了。初次略过一遍感觉还是一脸懵逼不知道干什么，但我带着“我们要做的是driver”这样的想法，在第二遍细看的时候有意区分开什么是网卡硬件帮我们做的，什么是我们的driver软件需要做的（经验2：明确要做什么。我们需要做的是软件部分，它的文档一般会说Software should XXX，密切关注这部分就行），就差不多有了点实现的雏形：

      -
      for recv:
        // 通过net_rx，网络包可以发送到udp顶层.
        // 所以说，我们在这里的目的就是，通过与硬件网卡e1000进行交互，
        // 取出e1000所接收到的数据包，检查数据的完整性，然后再把数据封装进mbuf结构体中，再通过net_rx传到上层

        // 取出数据包
        // 数据包存储在网卡的缓冲区中
        // 一是获取网卡缓冲区长度的长度
        // 网卡缓冲区长度存储在RCTL.BSIZE & RCTL.BSEX中
        /*
         *RCTL.BSEX = 0b:
      00b = 2048 Bytes.
      01b = 1024 Bytes.
      10b = 512 Bytes.
      1b1 = 256 Bytes.
      RCTL.BSEX = 1b:
      00b = Reserved; software should not program this value.
      01b = 16384 Bytes.
      10b = 8192 Bytes.
      11b = 4096 Bytes
         *
         * */
        // 二是获取数据包存放在哪个地址
        // 数据包的buffer cache的地址存储在descriptor的字段中
        // 必须读取多个descriptor以确定跨越多个接收缓冲区的数据包的完整长度。
        // 那么我们要读取的这些descriptor存放在哪呢？
        // 看文档，似乎差不多意思是这些descriptor被以环形队列的形式组织在一起，也许正是
        // 本文件内的rx_ring这个数组。
        // 当有descriptor到达e1000，e1000就会把它从host memory中取出来，存入到descriptor ring
        // 也即我们rx_ring数组
        //
        // 所以我们要做的，就是遍历rx_ring数组，如果rx_ring数组中的元素是used的，那么表明它就是数据包的一部分
        // 也即它地址所指向的buf里存放的是数据包的一部分数据
        // 
        // 那么我们怎么知道这个rx_ring的元素有没有used，以及它是第几个呢?
        // 检查descriptor有没有used：status字段不为全0则为used
        // 并且硬件要求，我们在发现这个descriptor的status不为0，并且用完这个descriptor之后，需要将
        // 其status字段置零，以供硬件使用
        // Status information indicates whether the descriptor has been used and whether the referenced 
        // buffer is the last one for the packet.

        // 三是获取数据包的数据
        // 我们需要获取decriptor的该字段，然后再从这个地址读取数据包数据
        // 网卡和内存统一编址，这个数据实际上就是网卡的buffer
        // 我们应该直接通过read这个系统调用就可以对其进行读写了

        // check数据包
        // 检查RDESC.ERRORS位，如果包发生了错误，再检查，如果发现RCTL.SBP、RCTL.UPE/MPE都被标记，
        // 就接收这个包，否则直接丢弃
      +
      // Physical memory allocator, for user processes,
      // kernel stacks, page-table pages,
      // and pipe buffers. Allocates whole 4096-byte pages.

      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "spinlock.h"
      #include "riscv.h"
      #include "defs.h"

      // 释放在这范围内的物理内存空间
      void freerange(void *pa_start, void *pa_end);

      // 也就是上面说的free memory的起始位置
      extern char end[]; // first address after kernel.
                         // defined by kernel.ld.

      // run代表的是一页内存
      struct run {
        struct run *next;
      };

      // 代表了整个内核空闲的物理空间
      struct {
        struct spinlock lock;
        struct run *freelist;
      } kmem;

      void
      kinit()
      {
        initlock(&kmem.lock, "kmem");
        // init的时候先清空空闲空间，建立空闲页队列
        freerange(end, (void*)PHYSTOP);
      }

      void
      freerange(void *pa_start, void *pa_end)
      {
        char *p;
        // PGROUNDUP和PGROUNDDOWN是用于将地址四舍五入到PGSIZE
        p = (char*)PGROUNDUP((uint64)pa_start);
        for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
          kfree(p);
      }

      // Free the page of physical memory pointed at by pa,
      // which normally should have been returned by a
      // call to kalloc().  (The exception is when
      // initializing the allocator; see kinit above.)
      void
      kfree(void *pa)
      {
        struct run *r;

        // pa得是整数页，并且得在内核物理内存范围之间
        if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
          panic("kfree");

        // Fill with junk to catch dangling refs.
        memset(pa, 1, PGSIZE);

        // 之后将在pa对应的那一页的前几个字节写入next字段
        r = (struct run*)pa;

        // 这意思就是在空闲内存的链表队列中新增一块
        acquire(&kmem.lock);
        r->next = kmem.freelist;
        kmem.freelist = r;
        release(&kmem.lock);
      }

      // Allocate one 4096-byte page of physical memory.
      // Returns a pointer that the kernel can use.
      // Returns 0 if the memory cannot be allocated.
      void *
      kalloc(void)
      {
        struct run *r;

        acquire(&kmem.lock);
        r = kmem.freelist;
        if(r)
          kmem.freelist = r->next;
        release(&kmem.lock);

        if(r)
          memset((char*)r, 5, PGSIZE); // fill with junk
        return (void*)r;
      }
      -

      可以看到，跟正确思路虽然很多细节理解上有点问题，但是大体框架还是大差不差。然后再阅读指导书：

      +

      Process address space

      当用户进程叫xv6分配内存时，xv6会用kalloc去取，然后登记在页表上。

      -

      When the E1000 receives each packet from the ethernet, it first DMAs the packet to the mbuf pointed to by the next RX (receive) ring descriptor, and then generates an interrupt. 【这句话可得知，descriptor们存放在代码中的rx_ring中。】

      -

      Your e1000_recv() code must scan the RX ring and deliver each new packet’s mbuf to the network stack (in net.c) by calling net_rx(). You will then need to allocate a new mbuf and place it into the descriptor, so that when the E1000 reaches that point in the RX ring again it finds a fresh buffer into which to DMA a new packet.

      -
      -

      就差不多是正确思路了。transmit的实现也是同理

      -

      代码

      -

      以下代码不知道为什么过不了test，我跟别人的逻辑一模一样也还是不行emmm

      -

      它的问题是，不会接收到外界的返ping，导致进程一直等待网卡IO，所以kerneltrap一直触发不了，无法正常网卡读写，从而导致fileread会一直处于sleep等待状态，整个系统就沉睡了【】我感觉应该是transmit没发成功。

      -

      等以后有精力再来看看吧。

      +

      The stack is a single page, and is shown with the initial contents as created by exec. Strings containing the command-line arguments, as well as an array of pointers to them, are at the very top of the stack. Just under that are values that allow a program to start at main as if the function main(argc, argv) had just been called.

      -
      int
      e1000_transmit(struct mbuf *m)
      {
        acquire(&e1000_lock);
        struct tx_desc tx = tx_ring[regs[E1000_TDT]];
        if((tx.status & 1) == 0){
          release(&e1000_lock);
          return -1;
        }
        if(tx_mbufs[regs[E1000_TDT]] != 0)    mbuffree(tx_mbufs[regs[E1000_TDT]]);
        tx.addr = (uint64) m->head;
        tx.length = m->len;
        tx.status |= 1;// EOP
        tx.cmd |= 1;//EOP
        tx.cmd |= 8;//RS
        tx_mbufs[regs[E1000_TDT]] = m;
        regs[E1000_TDT] = (regs[E1000_TDT]+1)%TX_RING_SIZE;
        // printf("send successful!\n");
        release(&e1000_lock);
        return 0;
      }

      static void
      e1000_recv(void)
      {
        printf("go into e1000_recv\n");
        acquire(&e1000_lock);
        while(1){
        //while(regs[E1000_RDT]!=regs[E1000_RDH]){
          printf("go into while\n");
          regs[E1000_RDT] = (regs[E1000_RDT] + 1)%RX_RING_SIZE;
          int i=regs[E1000_RDT];
          if(rx_ring[i].status != 0){
            // 包含所需数据包
            // 检查是否发生了错误
            //if((rx_ring[i].status & 1) !=0 && (rx_ring[i].status & 2) != 0){
        //      // error字段有效
        //    if(rx_ring[i].errors != 0){
                // 发生错误，直接丢弃
        //      goto end;
        //    }
            if((rx_ring[i].status & 1) == 0){
            release(&e1000_lock);
              return ;
            }
            // 将地址对应数据包发送
            struct mbuf* m = rx_mbufs[i];
            m->len = rx_ring[i].length;
            net_rx(m);
          rx_ring[i].status = 0;
            struct mbuf* mbuf = mbufalloc(MBUF_DEFAULT_HEADROOM);
            rx_ring[i].addr = (uint64) mbuf->head;
            rx_mbufs[i] = mbuf;
          }
        }

        release(&e1000_lock);
      }
      -]]> - - - Locking - /2023/01/10/xv6$chap6/ - Locking

      很多概念在看Java并发的时候都学习过，这些重复的地方就不做赘述了。

      -

      Code: spinlock

      -

      spinlock 使用介绍

      -

      一、spinlock 简介
      自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，不断尝试获取锁，直到获取到锁才会退出循环

      -

      二、自旋锁与互斥锁的区别
      自旋锁与互斥锁类似，它们都是为了解决对某项资源的互斥使用，在任何时刻最多只能有一个线程获得锁
      对于互斥锁，如果资源已经被占用，调用者将进入睡眠状态
      对于自旋锁，如果资源已经被占用，调用者就一直循环在那里，看是否自旋锁的保持者已经释放了锁

      -

      三、自旋锁的优缺点
      自旋锁不会发生进程切换，不会使进程进入阻塞状态，减少了不必要的上下文切换，执行速度快。非自旋锁在获取不到锁的时候会进入阻塞状态，从而进入内核态，当获取到锁的时候需要从内核态恢复，需要线程上下文切换，影响性能
      如果某个线程持有锁的时间过长，就会导致其它等待获取锁的线程长时间循环等待消耗CPU，造成CPU使用率极高

      +

      image-20230109234930690

      +

      Code: sbrk

      +

      Sbrk is the system call for a process to shrink or grow its memory. The system call is implemented by the function growproc (kernel/proc.c:239).

      -

      spinlock

      // Mutual exclusion lock.
      struct spinlock {
        uint locked;       // Is the lock held?

        // For debugging:
        char *name;        // Name of lock.
        struct cpu *cpu;   // The cpu holding the lock.
      };
      - -

      acquire

      大概是这么个原理：

      -

      image-20230115231857670

      -

      当然这有竞态条件。xv6用的是CPU提供的amoswap原子指令来消除竞态条件的。

      -
      // in kernel/spinlock.c
      // Acquire the lock.
      // Loops (spins) until the lock is acquired.
      void
      acquire(struct spinlock *lk)
      {
        // 关中断
        // xv6允许禁止中断。但是由于xv6是一个多核系统,单个core被禁止中断并不会影响其他core。
        push_off(); // disable interrupts to avoid deadlock.
        
        // holding(): Check whether this cpu is holding the lock.
        if(holding(lk))
          panic("acquire");

        // On RISC-V, sync_lock_test_and_set turns into an atomic swap:
        //   a5 = 1
        //   s1 = &lk->locked
        //   amoswap.w.aq a5, a5, (s1)
        // amoswap: 交换a5和(s1)的值，返回(s1)原来的值
        // 也即是如图所示的竞态条件的原子指令
        while(__sync_lock_test_and_set(&lk->locked, 1) != 0)
          ;

        __sync_synchronize();

        // Record info about lock acquisition for holding() and debugging.
        lk->cpu = mycpu();
      }
      - -

      __sync_synchronize();

      代码里的官方注释：

      -
      // Tell the C compiler and the processor to not move loads or stores
      // past this point, to ensure that the critical section's memory
      // references happen strictly after the lock is acquired.
      // On RISC-V, this emits a fence instruction.
      +
      // Grow or shrink user memory by n bytes.注意单位是bytes，grow n+，shrink n-
      // Return 0 on success, -1 on failure.
      // 主要逻辑还是通过vm.c实现
      int
      growproc(int n)
      {
        uint64 sz;//size
        struct proc *p = myproc();

        sz = p->sz;
        if(n > 0){
          if((sz = uvmalloc(p->pagetable, sz, sz + n, PTE_W)) == 0) {
            return -1;
          }
        } else if(n < 0){
          sz = uvmdealloc(p->pagetable, sz, sz + n);
        }
        p->sz = sz;
        return 0;
      }
      -

      这个注释其实没太看明白。我去翻了一下asm代码，发现这句话正如它最后一句所说的被翻译成fence指令：

      -

      image-20230115231457971

      -
      -

      处理器中的存储系统（一）：RISC-V的FENCE、FENCE.I指令

      -

      顾名思义,FENCE指令犹如一道屏障,把前面的存储操作和后面的存储操作隔离开来,前面的决不能到后面再执行,后面的决不能先于FENCE前的指令执行。

      -
      -

      这个就好明白多了。

      -

      这样一来，acquire和release的两个fence就形成了两道屏障：

      -
      acquire();
      l->nexy = list;
      list = l;
      release();
      +
      // Allocate PTEs and physical memory to grow process from oldsz to
      // newsz, which need not be page aligned.不需要页对齐  Returns new size or 0 on error.
      uint64
      uvmalloc(pagetable_t pagetable, uint64 oldsz, uint64 newsz, int xperm)
      {
        char *mem;
        uint64 a;

        if(newsz < oldsz)
          return oldsz;

        // oldsz向上取整
        oldsz = PGROUNDUP(oldsz);
        // 每页alloc
        for(a = oldsz; a < newsz; a += PGSIZE){
          mem = kalloc();
          if(mem == 0){
            // 说明失败，恢复到原状
            // 这里不用像下面一样kfree是因为这里压根没有alloc成功
            uvmdealloc(pagetable, a, oldsz);
            return 0;
          }
          // 除去junk data
          memset(mem, 0, PGSIZE);
          // 放入页表
          if(mappages(pagetable, a, PGSIZE, (uint64)mem, PTE_R|PTE_U|xperm) != 0){
            // 不成功
            // dealloc原理是顺着页表一个个free的。由于mem此处没有成功放入页表，所以就得单独free掉
            kfree(mem);
            uvmdealloc(pagetable, a, oldsz);
            return 0;
          }
        }
        return newsz;
      }
      -

      中间那部分的指令可以重排，但是中间的指令就绝不会跑到临界区外。

      -

      push_off和pop_off

      -

      当CPU未持有自旋锁时，xv6重新启用中断；它必须做一些记录来处理嵌套的临界区域。acquire调用push_off (*kernel/spinlock.c*:89) 并且release调用pop_off (*kernel/spinlock.c*:100)来跟踪当前CPU上锁的嵌套级别。当计数达到零时，pop_off恢复最外层临界区域开始时存在的中断使能状态。intr_off和intr_on函数执行RISC-V指令分别用来禁用和启用中断。

      +

      Code:exec

      +

      Exec is the system call that creates the user part of an address space. It initializes the user part of an address space from a fifile stored in the fifile system.

      +

      exec是创建地址空间的用户部分的系统调用。它使用一个存储在文件系统中的文件初始化地址空间的用户部分。

      -

      release

      // in kernel/spinlock.c
      // Release the lock.
      void
      release(struct spinlock *lk)
      {
        if(!holding(lk))
          panic("release");

        lk->cpu = 0;

        __sync_synchronize();

        // Release the lock, equivalent to lk->locked = 0.
        // This code doesn't use a C assignment, since the C standard
        // implies that an assignment might be implemented with
        // multiple store instructions.
        // On RISC-V, sync_lock_release turns into an atomic swap:
        //   s1 = &lk->locked
        //   amoswap.w zero, zero, (s1)
        __sync_lock_release(&lk->locked);

        // 开中断
        pop_off();
      }
      +
      int
      exec(char *path, char **argv)
      {
        char *s, *last;
        int i, off;
        uint64 argc, sz = 0, sp, ustack[MAXARG], stackbase;
        struct elfhdr elf;
        struct inode *ip;
        struct proghdr ph;
        pagetable_t pagetable = 0, oldpagetable;
        struct proc *p = myproc();

        //开始打开文件的意思吧（
        begin_op();

        //ip是一个inode
        //打开路径为path的文件
        if((ip = namei(path)) == 0){
          end_op();
          return -1;
        }
        //暂时锁住文件，别人不许动
        ilock(ip);

        //之后应该就是把文件读入内存吧
        // Check ELF header
        if(readi(ip, 0, (uint64)&elf, 0, sizeof(elf)) != sizeof(elf))
          goto bad;

        if(elf.magic != ELF_MAGIC)
          goto bad;

        //分配新页表
        if((pagetable = proc_pagetable(p)) == 0)
          goto bad;

        //elfhd应该指的是可执行文件头
        // Load program into memory.
        for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
          if(readi(ip, 0, (uint64)&ph, off, sizeof(ph)) != sizeof(ph))
            goto bad;
          if(ph.type != ELF_PROG_LOAD)
            continue;
          if(ph.memsz < ph.filesz)
            goto bad;
          if(ph.vaddr + ph.memsz < ph.vaddr)
            goto bad;
          if(ph.vaddr % PGSIZE != 0)
            goto bad;
          //总之顺利读到了
          uint64 sz1;
          //读到了就给它分配新空间并且填入页表
          if((sz1 = uvmalloc(pagetable, sz, ph.vaddr + ph.memsz, flags2perm(ph.flags))) == 0)
            goto bad;
          sz = sz1;
          if(loadseg(pagetable, ph.vaddr, ip, ph.off, ph.filesz) < 0)
            goto bad;
        }
        //在这里解锁
        iunlockput(ip);
        end_op();
        ip = 0;

        p = myproc();
        uint64 oldsz = p->sz;

        //读完文件，开始造一个新的用户栈【fork之后用户栈是不会清空的】
        // Allocate two pages at the next page boundary.
        // Make the first inaccessible as a stack guard.
        // Use the second as the user stack.
        sz = PGROUNDUP(sz);
        uint64 sz1;
        if((sz1 = uvmalloc(pagetable, sz, sz + 2*PGSIZE, PTE_W)) == 0)
          goto bad;
        sz = sz1;
        // mark a PTE invalid for user access.造guard page
        uvmclear(pagetable, sz-2*PGSIZE);
        // sp为栈顶
        sp = sz;
        // 应该指的是栈尾
        stackbase = sp - PGSIZE;

        // 开始往栈中填入执行参数
        // Push argument strings, prepare rest of stack in ustack.
        for(argc = 0; argv[argc]; argc++) {
          if(argc >= MAXARG)
            goto bad;
          sp -= strlen(argv[argc]) + 1;
          sp -= sp % 16; // riscv sp must be 16-byte aligned
          if(sp < stackbase)
            goto bad;
          //argv来自用户空间，所以需要使用copyout
          if(copyout(pagetable, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
            goto bad;
          //这什么东西
          //exec一次将参数中的一个字符串复制到栈顶，并在ustack中记录指向它们的指针
          ustack[argc] = sp;
        }
        //放置空指针
        ustack[argc] = 0;

        // push the array of argv[] pointers.
        sp -= (argc+1) * sizeof(uint64);
        sp -= sp % 16;
        if(sp < stackbase)
          goto bad;
        if(copyout(pagetable, sp, (char *)ustack, (argc+1)*sizeof(uint64)) < 0)
          goto bad;

        // arguments to user main(argc, argv)
        // argc is returned via the system call return
        // value, which goes in a0.
        p->trapframe->a1 = sp;

        // Save program name for debugging.
        for(last=s=path; *s; s++)
          if(*s == '/')
            last = s+1;
        safestrcpy(p->name, last, sizeof(p->name));
         
        //只有成功了才会来到这，才会覆盖掉旧的内存镜像
        // Commit to the user image.
        oldpagetable = p->pagetable;
        p->pagetable = pagetable;
        p->sz = sz;
        p->trapframe->epc = elf.entry;  // initial program counter = main
        p->trapframe->sp = sp; // initial stack pointer
        proc_freepagetable(oldpagetable, oldsz);

        return argc; // this ends up in a0, the first argument to main(argc, argv)

       bad:
        //释放新镜像，不改变旧镜像
        if(pagetable)
          proc_freepagetable(pagetable, sz);
        if(ip){
          iunlockput(ip);
          end_op();
        }
        return -1;
      }
      -

      Code: Using locks

      -

      作为粗粒度锁的一个例子，xv6的kalloc.c有一个由单个锁保护的空闲列表。如果不同CPU上的多个进程试图同时分配页面，每个进程在获得锁之前将必须在acquire中自旋等待。自旋会降低性能，因为它只是无用的等待。如果对锁的争夺浪费了很大一部分CPU时间，也许可以通过改变内存分配的设计来提高性能，使其拥有多个空闲列表，每个列表都有自己的锁，以允许真正的并行分配。【很棒的思路】

      -

      作为细粒度锁的一个例子，xv6对每个文件都有一个单独的锁，这样操作不同文件的进程通常可以不需等待彼此的锁而继续进行。文件锁的粒度可以进一步细化，以允许进程同时写入同一个文件的不同区域。最终的锁粒度决策需要由性能测试和复杂性考量来驱动。

      -
      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      锁描述
      bcache.lock保护块缓冲区缓存项（block buffer cache entries）的分配
      cons.lock串行化对控制台硬件的访问，避免混合输出
      ftable.lock串行化文件表中文件结构体的分配
      icache.lock保护索引结点缓存项（inode cache entries）的分配
      vdisk_lock串行化对磁盘硬件和DMA描述符队列的访问
      kmem.lock串行化内存分配
      log.lock串行化事务日志操作
      管道的pi->lock串行化每个管道的操作
      pid_lock串行化next_pid的增量
      进程的p->lock串行化进程状态的改变
      tickslock串行化时钟计数操作
      索引结点的 ip->lock串行化索引结点及其内容的操作
      缓冲区的b->lock串行化每个块缓冲区的操作
      -

      Figure 6.3: Locks in xv6

      -

      Deadlock and lock ordering

      -

      如果在内核中执行的代码路径必须同时持有数个锁，那么所有代码路径以相同的顺序获取这些锁是很重要的。如果它们不这样做，就有死锁的风险。假设xv6中的两个代码路径需要锁A和B，但是代码路径1按照先A后B的顺序获取锁，另一个路径按照先B后A的顺序获取锁。为了避免这种死锁，所有代码路径必须以相同的顺序获取锁。全局锁获取顺序的需求意味着锁实际上是每个函数规范的一部分：调用者必须以一种使锁按照约定顺序被获取的方式调用函数。

      -

      由于sleep的工作方式（见第7章），Xv6有许多包含每个进程的锁（每个struct proc中的锁）在内的长度为2的锁顺序链。例如，consoleintr (*kernel/console.c*:138)是处理键入字符的中断例程。当换行符到达时，任何等待控制台输入的进程都应该被唤醒。为此，consoleintr在调用wakeup时持有cons.lock，wakeup获取等待进程的锁以唤醒它。因此，全局避免死锁的锁顺序包括必须在任何进程锁之前获取cons.lock的规则。【这段不怎么能看懂，学完第七章再回来看看】

      -

      文件系统代码包含xv6最长的锁链。例如，创建一个文件需要同时持有目录上的锁、新文件inode上的锁、磁盘块缓冲区上的锁、磁盘驱动程序的vdisk_lock和调用进程的p->lock。为了避免死锁，文件系统代码总是按照前一句中提到的顺序获取锁。

      +

      Real world

      image-20230110010651653

      +

      xv6内核缺少一个类似malloc可以为小对象提供内存的分配器，这使得内核无法使用需要动态分配的复杂数据结构。【确实，感觉一分配就是一页（】

      +

      内存分配是一个长期的热门话题，基本问题是有效使用有限的内存并为将来的未知请求做好准备。今天，人们更关心速度而不是空间效率。此外，一个更复杂的内核可能会分配许多不同大小的小块，而不是（如xv6中）只有4096字节的块；一个真正的内核分配器需要处理小分配和大分配。

      +

      Lab：Pagetable

      +

      In this lab you will explore page tables and modify them to to speed up certain system calls and to detect which pages have been accessed.

      -

      Locks and interrupt handlers

      -

      Xv6 is more conservative: when a CPU acquires any lock, xv6 always disables interrupts on that CPU. Interrupts may still occur on other CPUs, so an interrupt’s acquire can wait for a thread to release a spinlock; just not on the same CPU.看来是通过开关中断来保护临界区的

      -

      acquire调用push_off (*kernel/spinlock.c*:89) 并且release调用pop_off (*kernel/spinlock.c*:100)来跟踪当前CPU上锁的嵌套级别。当计数达到零时，pop_off恢复最外层临界区域开始时存在的中断使能状态。intr_off和intr_on函数执行RISC-V指令分别用来禁用和启用中断。

      -

      严格的在设置lk->locked (kernel/spinlock.c:28)之前让acquire调用push_off是很重要的。如果两者颠倒，会存在一个既持有锁又启用了中断的短暂窗口期，不幸的话定时器中断会使系统死锁。同样，只有在释放锁之后，release才调用pop_off也是很重要的(*kernel/spinlock.c*:66)。

      +

      不过遗憾的是usertests还有好几个没通过，具体都标注了。

      +

      Speed up system calls

      +

      When each process is created, map one read-only page at USYSCALL (a VA defined in memlayout.h). At the start of this page, store a struct usyscall (also defined in memlayout.h), and initialize it to store the PID of the current process. For this lab, ugetpid() has been provided on the userspace side and will automatically use the USYSCALL mapping. You will receive full credit for this part of the lab if the ugetpid test case passes when running pgtbltest.

      +

      参考文章：MIT 6.S081 2021: Lab page tables

      -

      一个解决了一半的疑问

      问题

      -

      Xv6更保守：当CPU获取任何锁时，xv6总是禁用该CPU上的中断。中断仍然可能发生在其他CPU上，此时中断的acquire可以等待线程释放自旋锁；由于不在同一CPU上，不会造成死锁。

      -

      进展：似乎书中说到，“sleep atomically yields the CPU and releases the spinlock”。等了解完sleep，也即读完第七章之后再来看看。

      +

      感想

      乌龙

      这里好像是因为实验改版了，我下的是2020年的实验包，在memlayout压根找不到USYSCALL和struct usyscall这俩东西。最后翻了下网上的总算找到了。

      +

      我一开始没找到，还以为USYSCALL以及usyscall这两个都得自己写在memlayout里面，想了很久都没想出来USYSCALL的值应该设置为多少。我认为只需满足两个条件即可：1.所处内存段应该是free memory那段，也即自kernel结束（PHYSTOP）到MAXVA这一大块。2.得确保能被用户和内核都能访问到。

      +

      前者意为虚拟地址在MAXVA和PHYSTOP之间，后者意为那段内存应该标记为PTE_U。这个范围是很宽泛的，我实在不知道要分配这期间的哪块内存，感觉也不大可能是真的自由度那么大。所以我就偷偷看了hints【悲】，想看它对这个USYSCALL应该写什么值有没有建议。结果发现这东西是实验给我们定的。遂去网上找到了它给的真正的USYSCALL值。

      +
      #define USYSCALL (TRAPFRAME - PGSIZE)

      struct usyscall{
        int pid;
      };
      + +

      用户的ugetpid只找到了一个截图：

      +

      v2-0c2603da4c8102e46ae390a0d0b1191d_1440w

      +

      恕我愚钝实在不知道该把这段代码放在哪orz于是接下来写的东西就没有自测。

      +
      panic:freewalk leaf

      一开始写好代码准备启动xv6的时候爆出了这么一个panic，搜了一下得到如下解答：

      +
      +

      来源：MIT-6.S081-2020实验（xv6-riscv64）十：mmap

      +

      这时运行会发现freewalk函数panic：freewalk: leaf，这是因为freewalk希望所有虚拟地址已经被解绑并释放对应的物理空间了，该函数只负责释放页表。

      -

      在处理时钟中断的trap.c中：

      -
      // in kernel/trap.c devintr()
          } else if(scause == 0x8000000000000001L){
              
          // 这里！！
          // in kernel/trap.c devintr()
          if(cpuid() == 0){
            clockintr();
          }
              
          w_sip(r_sip() & ~2);
          return 2;
        } 

      void
      clockintr()
      {
        acquire(&tickslock);
        ticks++;
        wakeup(&ticks);
        release(&tickslock);
      }
      +

      让我得知freewalk在vm.c下面【吐槽，我一开始还以为是自由自在地走（，看到这个才反应过来是free walk，跟页表有关的】。结合freewalk的代码

      +

      image-20230110225359361

      +

      可以知道，造成这个panic的原因是需要手动释放页表项。而在这里

      +
      // in proc.c  freeproc()
      if(p->usyscall)
          kfree((void*)p->usyscall);
        p->usyscall = 0;
      -

      可见只有CPU0才会进入clockintr【因为要求cpuid==0】，锁住ticks引起ticks递增。

      -

      而当sys_sleep获得锁之后，其结束循环的条件是ticks - ticks0 < n:

      -
      uint64
      sys_sleep(void)
      {
        int n;
        uint ticks0;
        if(argint(0, &n) < 0)
          return -1;
        acquire(&tickslock);
        ticks0 = ticks;
        while(ticks - ticks0 < n){
          if(myproc()->killed){
            release(&tickslock);
            return -1;
          }
          sleep(&ticks, &tickslock);
        }
        release(&tickslock);
        return 0;
      }
      +

      仅仅是释放掉了对应的物理页，页表项并没有被释放。

      +

      对比了一下别人写的，才发现原来这里也需要修改：

      +
      // Free a process's page table, and free the
      // physical memory it refers to.
      void
      proc_freepagetable(pagetable_t pagetable, uint64 sz)
      {
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmunmap(pagetable, TRAPFRAME, 1, 0);
        //添加此句
        uvmunmap(pagetable, USYSCALL, 1, 0);
        uvmfree(pagetable, sz);
      }
      -

      我认为，这会导致死锁情况。假设计算机为多CPU，且从零开始依次递增编号。对该死锁情况的讨论，可以分为以下两类：

      +

      这样一来，问题就解决了。

      +
      总结

      因而，可以看到，如果进程想使用页的话，需要经历以下四步：

        -

      1. sys_sleep在CPU2（或者其他编号非零的CPU）运行，且先获取了tickslock的锁。这时候，ticks将会停止增长，sys_sleep结束循环的条件将无法结束。

        -

        理由：对于CPU0，它可以进入clockintr的代码段，但是由于锁已经被获取，所以就只能一直在那边死锁等待；对于其他CPU来说，压根执行不了那段增加ticks的代码段，所以ticks压根不会增加。这样一来，CPU2进程等待ticks增加，从而获取结束循环的条件；CPU0等待CPU2进程结束，从而使得ticks增加，就造成了死锁。

        -
        2. -

      2. sys_sleep在CPU0运行，且先获取了tickslock的锁。这时候，ticks将会停止增长，sys_sleep结束循环的条件将无法结束。

        -

        理由：由于xv6会在获取锁和释放锁期间关闭中断，因而CPU0无法进行时钟中断而发生进程的切换，只能一直在sys_sleep中等待，所以ticks更不可能增加，造成了死锁。

        -
        3. +
      3. 通过kalloc获取物理页地址（可以通过该地址对页进行读写），并且记录在进程proc结构中（否则之后就获取不了了）
        4. +
      4. 建立mappages映射
        5. +
      5. 释放物理页
        6. +
      6. 释放PTE映射
      -

      暂时没有很充分的理由反驳这两点。。。

      -

      解答

      学习完下一章的内容后可知，sleep(&ticks, &tickslock);会释放掉tickslock的锁，这样CPU0就可以进入clockintr增加ticks了。

      -

      再详细梳理一次，这里的具体机制是这样的：

      -

      可以把ticks看做信号量，sys_sleep为消费者，clockintr为生产者。

      -
      // in sys_sleep()
        acquire(&tickslock);
        while(ticks < 某个数字){
          sleep(&ticks, &tickslock);
        }
        release(&tickslock);
      +

      可见12和34都是分别一一对应的。

      +

      代码

      // Look in the process table for an UNUSED proc.
      // If found, initialize state required to run in the kernel,
      // and return with p->lock held.
      // If there are no free procs, or a memory allocation fails, return 0.
      static struct proc*
      allocproc(void)
      {
        struct proc *p;

        //有线程池那味了
        for(p = proc; p < &proc[NPROC]; p++) {
          acquire(&p->lock);
          if(p->state == UNUSED) {
            goto found;
          } else {
            release(&p->lock);
          }
        }
        return 0;

      found:
        p->pid = allocpid();

        // Allocate a trapframe page.
        if((p->trapframe = (struct trapframe *)kalloc()) == 0){
          release(&p->lock);
          return 0;
        }
        // Allocate a usyscall page.
        if((p->usyscall = (struct usyscall *)kalloc()) == 0){
          release(&p->lock);
          return 0;
        }
        //在USYSCALL写入usyscall结构体
        p->usyscall->pid = p->pid;

        // An empty user page table.
        p->pagetable = proc_pagetable(p);
        if(p->pagetable == 0){
          freeproc(p);
          release(&p->lock);
          return 0;
        }

        // Set up new context to start executing at forkret,
        // which returns to user space.
        memset(&p->context, 0, sizeof(p->context));
        p->context.ra = (uint64)forkret;
        p->context.sp = p->kstack + PGSIZE;

        return p;
      }

      // free a proc structure and the data hanging from it,
      // including user pages.
      // p->lock must be held.
      static void
      freeproc(struct proc *p)
      {
        if(p->trapframe)
          kfree((void*)p->trapframe);
        p->trapframe = 0;
        if(p->pagetable)
          proc_freepagetable(p->pagetable, p->sz);
        p->pagetable = 0;
        if(p->usyscall)
          kfree((void*)p->usyscall);
        p->usyscall = 0;
        p->sz = 0;
        p->pid = 0;
        p->parent = 0;
        p->name[0] = 0;
        p->chan = 0;
        p->killed = 0;
        p->xstate = 0;
        p->state = UNUSED;
      }

      // Create a user page table for a given process,
      // with no user memory, but with trampoline pages.
      pagetable_t
      proc_pagetable(struct proc *p)
      {
        pagetable_t pagetable;

        // An empty page table.
        pagetable = uvmcreate();
        if(pagetable == 0)
          return 0;

        // map the trampoline code (for system call return)
        // at the highest user virtual address.
        // only the supervisor uses it, on the way
        // to/from user space, so not PTE_U.
        if(mappages(pagetable, TRAMPOLINE, PGSIZE,
                    (uint64)trampoline, PTE_R | PTE_X) < 0){
          uvmfree(pagetable, 0);
          return 0;
        }

        // map the trapframe just below TRAMPOLINE, for trampoline.S.
        if(mappages(pagetable, TRAPFRAME, PGSIZE,
                    (uint64)(p->trapframe), PTE_R | PTE_W) < 0){
          uvmunmap(pagetable, TRAMPOLINE, 1, 0);
          uvmfree(pagetable, 0);
          return 0;
        }

       // 映射USYSCALL
        if(mappages(pagetable, USYSCALL, PGSIZE,
                    (uint64)(p->usyscall), PTE_R|PTE_U) < 0){
          uvmunmap(pagetable, TRAMPOLINE, 1, 0);
          uvmunmap(pagetable, TRAPFRAME, 1, 0);
          uvmfree(pagetable, 0);
          return 0;
       }
        return pagetable;
      }

      // Free a process's page table, and free the
      // physical memory it refers to.
      void
      proc_freepagetable(pagetable_t pagetable, uint64 sz)
      {
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmunmap(pagetable, TRAPFRAME, 1, 0);
        uvmunmap(pagetable, USYSCALL, 1, 0);
        uvmfree(pagetable, sz);
      }
      -
      void
      clockintr()
      {
        acquire(&tickslock);
        ticks++;
        wakeup(&ticks);
        release(&tickslock);
      }
      +

      问答题

      +

      Which other xv6 system call(s) could be made faster using this shared page? Explain how.

      +
      +

      我觉得如果能在fork的父子进程用shared page共享页表应该会节省很多时间和空间，用个读时写。其他的倒是想不到了。不过这题会不会问的是那些在内核态和用户态穿梭频繁的system call呢？这个的话我就想不出来了。

      +

      Print a page table

      +

      write a function that prints the contents of a page table.

      +

      Define a function called vmprint().

      +

      It should take a pagetable_t argument, and print that pagetable in the format described below.

      +

      Insert if(p->pid==1) vmprint(p->pagetable) in exec.c just before the return argc, to print the first process’s page table.

      +

      image-20230110231020570

      +

      The first line displays the argument to vmprint. After that there is a line for each PTE, including PTEs that refer to page-table pages deeper in the tree. Each PTE line is indented by a number of " .." that indicates its depth in the tree.

      +

      Each PTE line shows the PTE index in its page-table page, the pte bits, and the physical address extracted from the PTE. Don’t print PTEs that are not valid.

      +

      In the above example, the top-level page-table page has mappings for entries 0 and 255. The next level down for entry 0 has only index 0 mapped, and the bottom-level for that index 0 has entries 0, 1, and 2 mapped.

      +
      +

      感想

      image-20230111000329475

      +

      很可惜，我在上面检索freewalk leaf到底是什么东西的时候，不小心看到了这题需要去参照freewalk这个提示【悲】其实我觉得这点还是需要绕点弯才能想到的，可能直接想到有点难【谁知道呢，世界线已经变动了】。

      +

      它这个打印页表其实最主要是考查如何遍历页表，这让人想起了walk这样的东西。但是walk是根据虚拟地址一级级找PTE的，中间很多地方会被跳过。有没有一个过程会在做事的时候遍历整个页表呢？答案是，这个过程就是释放页表的过程。释放页表才会一个个地看是否需要释放。释放页表的函数是freewalk，因而这道题参考freewalk的代码即可。

      +

      我觉得从“遍历页表”联想到“释放页表”这点是很巧的。不过也不会很突兀，毕竟学数据结构时就知道释放就需要遍历，逆向思维有点难但问题不大。

      +

      其他的就都挺简单的，不多赘述。

      +

      代码

      记得在defs.h中添加声明

      +
      //在vm.c下
      void
      vmprint_helper(pagetable_t pagetable,int level)
      {
        // there are 2^9 = 512 PTEs in a page table.
        for(int i = 0; i < 512; i++){
          pte_t pte = pagetable[i];
          if(pte & PTE_V){
            for(int j=0;j<level;j++){
      		printf(" ..");
            }
            printf("%d: pte %p pa %p\n",i,(uint64)pte,(uint64)(PTE2PA(pte)));
            if((pte & (PTE_R|PTE_W|PTE_X)) == 0){
              // this PTE points to a lower-level page table.
              uint64 child = PTE2PA(pte);
              vmprint_helper((pagetable_t)child,level+1);
            }
          }
        }
      }

      // 打印页表
      void
      vmprint(pagetable_t pagetable)
      {
        // typedef uint64 *pagetable_t;所以pagetable可以以%p形式打印
        printf("page table %p\n",(uint64)pagetable);
        vmprint_helper(pagetable,1);
      }
      -

      可以看到，这是非常典型的生产者消费者模型。生产者每生产一次ticks，就会唤醒消费者，让消费者检查条件。如果条件错误，则继续sleep等待消费者下一次唤醒，如此循环往复。

      -

      只不过，还有一个小疑点，就是clockintr这段只有CPU0可以执行这一点是否为真依然存疑。如果确实只有CPU0可以执行的话，假若sys_sleep在CPU0上执行，那么还是依然会造成死锁。所以我猜想是不是CPU0是无法关中断的？也就是说CPU0是一个后盾一般的保护角色？或者是别的CPU也能进入本段代码？如果别的CPU也能进，那是怎么实现的？因为很明显这段代码确实只有CPU0可以进入。

      -

      Sleep locks

      关于sleep lock的由来和优点，书里描述得很详细，简单来说就是：

      -
      -

      Thus we’d like a type of lock that yields the CPU while waiting to acquire, and allows yields (and interrupts) while the lock is held.

      -

      因为等待会浪费CPU时间，所以自旋锁最适合短的临界区域；睡眠锁对于冗长的操作效果很好。

      +

      问答题

      +

      Explain the output of vmprint in terms of Fig 3-4 from the text.

      +

      What does page 0 contain?

      +

      What is in page 2? When running in user mode, could the process read/write the memory mapped by page 1?

      +

      What does the third to last page contain?

      -
      void
      acquiresleep(struct sleeplock *lk)
      {
        acquire(&lk->lk);
        // 等待
        while (lk->locked) {
          // sleep atomically yields the CPU and releases the spinlock
          sleep(lk, &lk->lk);
        }
        // 占用
        lk->locked = 1;
        lk->pid = myproc()->pid;
        release(&lk->lk);
      }

      void
      releasesleep(struct sleeplock *lk)
      {
        acquire(&lk->lk);
        lk->locked = 0;
        lk->pid = 0;
        // 到时候可以留意一下wakeup是会唤醒一个还是多个
        wakeup(lk);
        release(&lk->lk);
      }
      +

      从上面操作系统的启动来看，进程1应该是在main.c中的userinit()中创建的进程，也是shell的父进程。【确实，经实践可得shell的pid为2】

      +

      可以来看一下userint的代码：

      +
      void
      userinit(void)
      {
        struct proc *p;

        p = allocproc();
        initproc = p;
        
        // 申请一页，将initcode的指令和数据放进去
        // allocate one user page and copy initcode's instructions
        // and data into it.
        /*
        uvminit的注释：
        	// Load the user initcode into address 0 of pagetable,
      	// for the very first process.
      	// sz must be less than a page.
        */
        uvminit(p->pagetable, initcode, sizeof(initcode));
        p->sz = PGSIZE;

        //为内核态到用户态的转变做准备
        // prepare for the very first "return" from kernel to user.
        /*
        Trap Frame是指中断、自陷、异常进入内核后,在堆栈上形成的一种数据结构
        */
        p->trapframe->epc = 0;      // user program counter
        p->trapframe->sp = PGSIZE;  // user stack pointer

        // 修改进程名
        safestrcpy(p->name, "initcode", sizeof(p->name));
        p->cwd = namei("/");

        //这个也许是为了能被优先调度
        p->state = RUNNABLE;

        release(&p->lock);
      }
      -

      有一点值得注意：

      -
      -

      Because sleep-locks leave interrupts enabled, they cannot be used in interrupt handlers. Because acquiresleep may yield the CPU, sleep-locks cannot be used inside spinlock critical sections (though spinlocks can be used inside sleep-lock critical sections).

      +

      可见，page0是initcode的代码和数据，page1和page2用作了进程的栈，其中page1应该是guard page，page2是stack。

      +

      不过这里从exec的角度解释其实更通用：

      +
      int
      exec(char *path, char **argv)
      {
        //分配新页表
        if((pagetable = proc_pagetable(p)) == 0)
          goto bad;

        //elfhd应该指的是可执行文件头
        // Load program into memory.
        for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
      	//...
          //总之顺利读到了
          uint64 sz1;
          //读到了就给它分配新空间并且填入页表
          if((sz1 = uvmalloc(pagetable, sz, ph.vaddr + ph.memsz, flags2perm(ph.flags))) == 0)
            goto bad;
          sz = sz1;
        }

        //读完文件，开始造一个新的用户栈【fork之后用户栈是不会清空的】
        sz = PGROUNDUP(sz);
        uint64 sz1;
        if((sz1 = uvmalloc(pagetable, sz, sz + 2*PGSIZE, PTE_W)) == 0)
          goto bad;
        sz = sz1;
        // mark a PTE invalid for user access.造guard page
        uvmclear(pagetable, sz-2*PGSIZE);
        // sp为栈顶
        sp = sz;
        // 应该指的是栈尾
        stackbase = sp - PGSIZE;
        //...
      }
      + +

      page0就填程序。这里重点说明一下为什么page1和page2分别是guard page和stack。

      +

      按照它的那个算术关系，stack和guard page的虚拟内存位置关系应该是这样的：

      +

      image-20230111004330079

      +

      那为什么最后在页表中，变成了page1是gurad page，page2是stack这样上下颠倒了呢？看vm.c中的uvmalloc就能明白。

      +

      image-20230111004500827

      +

      在253行设置了新映射。可以看到，这里设置映射的顺序是sz->sz+PGSIZE，也即先设置guard page的映射，再设置stack的映射。所以，这两位才会上下颠倒了。

      +

      Detecting which pages have been accessed

      +

      Some garbage collectors (a form of automatic memory management) can benefit from information about which pages have been accessed (read or write). In this part of the lab, you will add a new feature to xv6 that detects and reports this information to userspace by inspecting the access bits in the RISC-V page table. The RISC-V hardware page walker marks these bits in the PTE whenever it resolves a TLB miss.

      -

      这实际上是因为自旋锁内不能sleep，因而也就不能使用sleep lock。

      -

      为什么不能sleep？我猜测应该是因为sleep中会释放自旋锁然后再调度别的进程。此时，临界区就不受保护了很危险，不符合spinlock在临界区结束才能释放的规范。

      -

      在查阅别人的说法的时候，我还看到了这个讨论：

      -

      中断中为什么不能sleep | Linux内核的评论区

      -

      在中断服务程序中，无法sleep的原因应该是sleep后，调度程序将CPU窃走，由于调度的基本单位是线程（中断服务程序不是线程），因此中断服务程序无法再被调度回来，即中断程序中sleep后的部分永远无法得到执行。

      -
      -

      Real world

      -

      大多数操作系统都支持POSIX线程（Pthread），它允许一个用户进程在不同的CPU上同时运行几个线程。Pthread支持用户级锁（user-level locks）、障碍（barriers）等。支持Pthread需要操作系统的支持。例如，如果一个Pthread在系统调用中阻塞，同一进程的另一个Pthread应当能够在该CPU上运行。另一个例子是，如果一个线程改变了其进程的地址空间（例如，映射或取消映射内存），内核必须安排运行同一进程下的线程的其他CPU更新其硬件页表，以反映地址空间的变化。

      -
      -

      Lab: locks

      -

      In this lab you’ll gain experience in re-designing code to increase parallelism. You’ll do this for the xv6 memory allocator and block cache.

      -
      -

      Memory allocator

      -

      The program user/kalloctest stresses xv6’s memory allocator: three processes grow and shrink their address spaces, resulting in many calls to kalloc and kfree. kalloc and kfree obtain kmem.lock. kalloctest prints (as “#fetch-and-add”) the number of loop iterations in acquire due to attempts to acquire a lock that another core already holds, for the kmem lock and a few other locks. The number of loop iterations in acquire is a rough measure of lock contention.

      -

      To remove lock contention, you will have to redesign the memory allocator to avoid a single lock and list. 也就是说要把kalloc中的整个列表上锁，修改为每个CPU有自己的列表The basic idea is to maintain a free list per CPU, each list with its own lock. Allocations and frees on different CPUs can run in parallel, because each CPU will operate on a different list. The main challenge will be to deal with the case in which one CPU’s free list is empty, but another CPU’s list has free memory; in that case, the one CPU must “steal” part of the other CPU’s free list. Stealing may introduce lock contention, but that will hopefully be infrequent.主要挑战将是处理一个 CPU 的空闲列表为空，但另一个 CPU 的列表有空闲内存的情况； 在这种情况下，一个 CPU 必须“窃取”另一个 CPU 的空闲列表的一部分。

      -

      Your job is to implement per-CPU freelists, and stealing when a CPU’s free list is empty.

      -

      You must give all of your locks names that start with “kmem”. That is, you should call initlock for each of your locks, and pass a name that starts with “kmem”.

      -

      Run kalloctest to see if your implementation has reduced lock contention. To check that it can still allocate all of memory, run usertests sbrkmuch. Your output will look similar to that shown below, with much-reduced contention in total on kmem locks, although the specific numbers will differ.

      +

      Your job is to implement pgaccess(), a system call that reports which pages have been accessed.

      +

      The system call takes three arguments. First, it takes the starting virtual address of the first user page to check. Second, it takes the number of pages to check. Finally, it takes a user address to a buffer to store the results into a bitmask (a datastructure that uses one bit per page and where the first page corresponds to the least significant bit).

      +

      You will receive full credit for this part of the lab if the pgaccess test case passes when running pgtbltest.

      -

      感想

      总之，意思就是kalloc里面本来是多核CPU共用一个空闲页list，现在要做的就是给每一核的CPU独立分配一个空闲页list。我觉得可以分为如下几步来做：

      -
        -

      1. 定义list数组以及对应的锁

        -

        cpu的数量是一定的；cpuid可以用来作为数组下标索引

        -
        2. -

      2. 在init时初始化锁，在freelist的时候把空闲页均分给CPU

        -
        3. -

      3. 当kalloc和kfree的时候，获取当前cpuid上锁

        -
        4. -

      4. 当一个CPU的内存不够的时候，去向另一个CPU窃取。窃取之前，首先应该获取另一个CPU的锁。

        -
        5. -
      -

      以上是初见思路。正确思路确实跟上面的一样，编码过程也比较简单，没有很恶心的细节和奇奇怪怪的bug，没什么好说的。

      -

      第二步中，hints是推荐把所有空闲页都分给CPU0。

      -

      第四步的时候我是一次窃取一页。我看到一个一次窃取多页的做法，我觉得很有想法，在这里附上链接：

      +

      感想

      实验内容：

      +

      实现void pgaccess(uint64 sva,int pgnum,int* bitmask);，一个系统调用。在这里面，我们要做的是，访问从sva到sva+pgnum*PGSIZE这一范围内的虚拟地址对应的PTE，然后查看PTE的标记项是否有PTE_A。有的话则在bitmask对应位标记为1.

      +

      应该注意的点：

      +

      1.需要进行内核态到用户态的参数传递 2.需要进行系统调用的必要步骤 3.PTE_A需要自己定义

      +

      以上是初见。做完了发现，确实就是那么简单，我主要时间花费在下的实验版本不对，折腾来折腾去了可能有一个小时，最后还是选择了直接把测试函数搬过来手工调用。已经换到正确的年份版本了【泪目】

      +

      有一点我忽视了，看了提示才知道：

      -

      MIT6.S081 lab8 locks

      +

      Be sure to clear PTE_A after checking if it is set. Otherwise, it won’t be possible to determine if the page was accessed since the last time pgaccess() was called (i.e., the bit will be set forever).

      -

      代码

      定义
      struct {
        struct spinlock kmem_locks[NCPU];
        struct run *freelists[NCPU];
      } kmem;
      +

      也就是说每次检查到一个，就需要手动清除掉PTE_A标记。

      +

      还有一点以前一直没注意到的，头文件的引用需要注意次序。比如说要是把spinlock.h放在proc.h后面，就会寄得很彻底。

      +

      代码

      那些系统调用的登记步骤就先省略了。

      +
      // kernel/sysproc.c
      uint64
      sys_pgaccess(void)
      {
        uint64 sva;
        int pgnum;
        uint64 bitmask;

        if(argaddr(0,&sva) < 0 || argint(1, &pgnum) < 0 || argaddr(2, &bitmask) < 0)
          return -1;
        return pgaccess((void*)sva,pgnum,(void*)bitmask);
      }
      -
      初始化

      由于kinit仅会由一个cpu执行一次【详情见main.c】，故而我这里在kinit的做法是由一个CPU初始化所有CPU，而没有选择去修改main.c从而使每个CPU都执行一次kinit。

      -
      void
      kinit()
      {
        for(int i=0;i<NCPU;i++){
          char buf[8];
          snprintf(buf,6,"kmem%d",i);
          initlock(&kmem.kmem_locks[i], buf);
        }
        freerange(end, (void*)PHYSTOP);
      }

      // 多带一个参数表示cpuid，仅在kinit的freerange中使用
      void
      kfree_init(void *pa,int i)
      {
        struct run *r;

        if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
          panic("kfree");

        // Fill with junk to catch dangling refs.
        memset(pa, 1, PGSIZE);

        r = (struct run*)pa;

        r->next = kmem.freelists[i];
        kmem.freelists[i] = r;
      }
      void
      freerange(void *pa_start, void *pa_end)
      {
        char *p;
        p = (char*)PGROUNDUP((uint64)pa_start);
         
        // 把空闲内存页均分给每个CPU
        uint64 sz = ((uint64)pa_end - (uint64)pa_start)/NCPU;
        uint64 tmp = PGROUNDDOWN(sz) + (uint64)p;
        for(int i=0;i<NCPU;i++){
          for(; p + PGSIZE <= (char*)tmp; p += PGSIZE)
            kfree_init(p,i);
          tmp += PGROUNDDOWN(sz);
          if(i == NCPU-2){
            tmp = (uint64)pa_end;
          }
        }
      }
      +
      // kernel/pgaccess.c
      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "riscv.h"
      #include "spinlock.h"
      #include "defs.h"
      #include "proc.h"
      int
      pgaccess(void* sva,int pgnum,void* bitmask){
          if(pgnum > 32){
              printf("pgaccess: range too big.\n");
      		exit(1);
          }
          int kmask = 0;
          struct proc* p = myproc();
          for(int i=0;i<pgnum;i++){
              pte_t* pte = walk(p->pagetable,(uint64)sva+i*PGSIZE,0);
              // 映射不存在，或者没有被访问过
              if(!pte || !(*pte & PTE_A)){
                  continue;
              }
              kmask = (kmask | (1<<i));
              *pte = (*pte & (~PTE_A));
          }
          copyout(p->pagetable,(uint64)bitmask,(char*)(&kmask),sizeof(int)); 
          return 1;
      }
      -
      kfree
      void
      kfree(void *pa)
      {
        // ...

        r = (struct run*)pa;
        // 在这
        push_off();
        int id = cpuid();

        acquire(&kmem.kmem_locks[id]);
        r->next = kmem.freelists[id];
        kmem.freelists[id] = r;
        release(&kmem.kmem_locks[id]);
        pop_off();
      }
      +

      A kernel page table per process

      +

      The goal of this section and the next is to allow the kernel to directly dereference user pointers.

      +
      +
      +

      Your first job is to modify the kernel so that every process uses its own copy of the kernel page table when executing in the kernel.

      +

      Modify struct proc to maintain a kernel page table for each process, and modify the scheduler to switch kernel page tables when switching processes. For this step, each per-process kernel page table should be identical to the existing global kernel page table. You pass this part of the lab if usertests runs correctly.

      +
      +

      感想

      这个其实平心而论不难，思路很简单。写着不难是不难，但想明白花费了我很多时间。

      +

      它这个要求我们修改kernel，使得每个进程都有一份自己的kernel page。至于要改什么，围绕着proc.c中，参照pagetable的生命周期摁改就行。还有一个地方它也提示了，就是要在swtch之前更换一下satp的值。

      +

      接下来，我说说我思考的几个点以及犯错的地方。

      +
      为什么要这么干

      看完题目，我的第一印象是，这么干有啥用。。。因为我觉得以前那个所有进程共用内核页表确实很好了，没有必要每个进程配一个后来才发现，这个跟下面那个是连在一起的，目的是 allow the kernel to directly dereference user pointers.。所以，我们下面会把用户的pgtbl和这里dump出来的kpgtbl合在一起。

      +

      具体来说：

      +

      通常，进行地址翻译的时候，计算机硬件（即内存管理单元MMU）都会自动的查找对应的映射进行翻译（需要设置satp寄存器，将需要使用的页表的地址交给该寄存器）。

      +

      然而，在xv6内核需要翻译用户的虚拟地址时，因为内核页表不含对应的映射，计算机硬件不能自动帮助完成这件事。因此，我们需要先找到用户程序的页表，仿照硬件翻译的流程，一步一步的找到对应的物理地址，再对其进行访问。【walkaddr】这也就会导致copyin之类需要涉及内核和用户态交互的函数效率低下。

      +

      为了解决这个问题，我们尝试将用户页表也囊括进内核页表映射来。但是，如果将所有进程的用户页表都合并到同一个内核全局页表是不现实的。因而，我们决定换一个角度，让每个进程都仅有一张内核态和用户态共用的页表，每次切换进程时切换页表，这样就构造出了个全局的假象。

      +

      这两次实验就是为了实现该任务。在本次实验中，我们首先先实现内核页表的分离。

      +
      关于myproc()

      在allocproc中初始化的时候，我一开始是这么写的：

      +
      // in proc.c allocproc()
      perproc_kvminit();
      -
      kalloc
      void *
      kalloc(void)
      {
        struct run *r;

        push_off();
        int id = cpuid();

        acquire(&kmem.kmem_locks[id]);
        r = kmem.freelists[id];
        if(r){
          kmem.freelists[id] = r->next;
        }
        release(&kmem.kmem_locks[id]);
        pop_off();

        // 如果无空闲页，则窃取
        if(!r){
          for(int i=NCPU-1;i>=0;i--){
            acquire(&kmem.kmem_locks[i]);
            r = kmem.freelists[i];
            if(r){
              kmem.freelists[i] = r->next;
              release(&kmem.kmem_locks[i]);
              break;
            }
            release(&kmem.kmem_locks[i]);
          }
        }
        
        if(r)
          memset((char*)r, 5, PGSIZE); // fill with junk
        return (void*)r;
      }
      +
      // in vm.c
      pagetable_t
      perproc_kvminit()
      {
        struct proc* p = myproc();
        p->kpgtbl = (pagetable_t) kalloc();
        memset(p->kpgtbl, 0, PGSIZE);

        // uart registers
        pkvmmap(p->kpgtbl,UART0, UART0, PGSIZE, PTE_R | PTE_W);
        // ...
        return pt;
      }
      -

      Buffer cache

      buffer cache的结构其实跟kalloc的内存分配结构有一定的类似之处，都是采用链表管理，但是buffer cache的实现相较于kalloc更为复杂。

      +

      这样会死得很惨，爆出如下panic：

      +

      image-20230114011100370

      +

      通过hints的调试贴士

      -

      Reducing contention in the block cache is more tricky than for kalloc, because bcache buffers are truly shared among processes (and thus CPUs).

      -

      For kalloc, one could eliminate most contention by giving each CPU its own allocator; that won’t work for the block cache.

      -

      We suggest you look up block numbers in the cache with a hash table that has a lock per hash bucket.

      +

      A missing page table mapping will likely cause the kernel to encounter a page fault. It will print an error that includes sepc=0x00000000XXXXXXXX. You can find out where the fault occurred by searching for XXXXXXXX in kernel/kernel.asm.

      -

      感想

      初见思路

      我想我们可以这么实现：

      -

      首先有一个双向链表，接收着所有空闲无设备分配的buf。然后再有多个双向链表桶，以设备号为索引值。

      -

      设备号数量，也即hash table的大小定义在kernel/param.h中：

      -
      #define NDEV         10
      +

      我发现程序在这里绷掉了：

      +
      p->kpgtbl = (pagetable_t) kalloc();
      -

      在bget中，第一个循环仅需在设备链表中查找即可，第二个循环需要先看设备链表是否有空闲的对象，如果没有，则去接收所有空闲无设备分配的那个双向链表中窃取一个对象。

      -

      在brelse中，则把要释放的buf对象添加在head中即可。

      -

      因而，我们要做以下几件事：

      -
        -

      1. 修改bcache的定义

        -

        添加数量为设备号的head数组，以及对应的锁

        -
        2. -

      2. 初始化bcache

        -
        3. -

      3. 添加工具函数：将一个buf加入一个双向链表；从一个双向链表中得到一个buf

        -
        4. -

      4. 写bget和brelse

        -
        5. -
      -

      看起来确实好像可以实现的样子，但是这个问题在于，这么做就直接破坏了LRU的这个规则。所以还是不能这么写的。但总之先把我的代码放上来。

      -

      以下代码是不能正常运行的。比如说在执行ls命令时，会发生如下错误：

      -

      image-20230122163938601

      -

      会打印出一些乱七八糟的东西，并且这些东西似乎是固定的，每次都会发生，看来应该不是多进程的问题，而是代码有哪里出现逻辑错误了。不过注意到会产生“stopforking”、“bigarg-ok”，这两个似乎是在usertest中的两个文件名，很奇怪。

      -

      很遗憾我暂时没有精力debug了。姑且先把错误代码放在这里吧。

      -
      struct {
        struct spinlock lock;
        struct buf buf[NBUF];

        // Linked list of all buffers, through prev/next.
        // Sorted by how recently the buffer was used.
        // head.next is most recent, head.prev is least.
        struct buf head;
        struct buf dev_heads[NDEV];
        struct spinlock dev_locks[NDEV];
      } bcache;
      +

      而且显而易见，是系统启动时崩的。

      +

      经过了漫长的思考，我震惊地发现了它为什么崩了（）

      +

      首先，这段代码语法上是没有问题的。它固然犯了发布未初始化完成的对象这样的并发错误【我有罪】，也破坏了proc的封装性【proc中的很多私有属性本来应该作用域仅在proc.c中的。此处为了能让vm.c访问到proc中的属性，不得不给vm.c添上了proc.h的头文件】，但是它并不是语法错误，还是能用的。我做了这样的测试样例证明它没有问题：

      +
      #include <stdio.h>
      #define MAX 10
      typedef int pagetable_t;

      struct proc{
      	pagetable_t kpgtbl;
      }; 

      struct proc processes[MAX];

      struct proc* myproc(){
      	return &processes[0];
      };

      void kvminit(){
      	myproc()->kpgtbl = 1;
      }

      int main(){
      	struct proc* p = &processes[0];
      	kvminit();
      	printf("%d",p->kpgtbl);
      	return 0;
      }
      -
      void
      binit(void)
      {
        struct buf *b;

        initlock(&bcache.lock, "bcache");
        for(int i=0;i<NDEV;i++){
          char buf[10];
          snprintf(buf,9,"bcache%02d",i);
          initlock(&(bcache.dev_locks[i]), buf);
          bcache.dev_heads[i].prev = &(bcache.dev_heads[i]);
          bcache.dev_heads[i].next = &(bcache.dev_heads[i]);
        }

        // 初始时，每一个桶内都有一个buf结点
        b = bcache.buf;
        for(int i=0;i<NDEV;i++){
          b->next = bcache.dev_heads[i].next;
          b->prev = &bcache.dev_heads[i];
          initsleeplock(&b->lock, "buffer");
          bcache.dev_heads[i].next->prev = b;
          bcache.dev_heads[i].next = b;
          b++;
        }

        // Create linked list of buffers
        bcache.head.prev = &bcache.head;
        bcache.head.next = &bcache.head;
        for(; b < bcache.buf+NBUF; b++){
          b->next = bcache.head.next;
          b->prev = &bcache.head;
          initsleeplock(&b->lock, "buffer");
          bcache.head.next->prev = b;
          bcache.head.next = b;
        }
      }
      +

      我一路顺着os启动的路径找，也想不出来这能有什么错，因而非常迷茫。

      +

      此时我灵光一闪，会不会是myproc()在os刚启动的时候是发挥不了作用的？于是我一路顺着myproc的代码看下去：

      +
      struct proc*
      myproc(void) {
        push_off();
        struct cpu *c = mycpu();
        struct proc *p = c->proc;
        pop_off();
        return p;
      }
      -
      void
      brelse(struct buf *b)
      {
        if(!holdingsleep(&b->lock))
          panic("brelse");

        uint dev = b->dev;
        releasesleep(&b->lock);

        acquire(&(bcache.dev_locks[dev]));
        b->refcnt--;
        if (b->refcnt == 0) {
          b->next->prev = b->prev;
          b->prev->next = b->next;
          release(&(bcache.dev_locks[dev]));

          acquire(&bcache.lock);
          b->next = bcache.head.next;
          b->prev = &bcache.head;
          bcache.head.next->prev = b;
          bcache.head.next = b;
          release(&bcache.lock);
        }else
          release(&(bcache.dev_locks[dev]));
      }
      +

      那么，mycpu()获得的cpu的proc是怎么得到的呢？

      +

      我搜寻了一下os启动代码，发现了cpu的proc得到的路径。

      +
      void
      main()
      {
        if(cpuid() == 0){
          consoleinit();
          printfinit();
          printf("\n");
          printf("xv6 kernel is booting\n");
          printf("\n");
      	//...很多很多init
          userinit();      // first user process
          __sync_synchronize();
          started = 1;
        } else {
      	// ...
        }

        //调度执行第一个进程
        scheduler();        
      }
      -
      static struct buf*
      bget(uint dev, uint blockno)
      {
        acquire(&(bcache.dev_locks[dev]));

        // Is the block already cached?
        for(struct buf* b = bcache.dev_heads[dev].next; b != &(bcache.dev_heads[dev]); b = b->next){
          if(b->blockno == blockno){
            b->refcnt++;
            release(&(bcache.dev_locks[dev]));
            acquiresleep(&b->lock);
            return b;
          }
        }
        release(&(bcache.dev_locks[dev]));

        // 在head中找
        acquire(&bcache.lock);
        // Recycle the least recently used (LRU) unused buffer.
        for(struct buf* b = bcache.head.prev; b != &(bcache.head); b = b->prev){
          if(b->refcnt == 0) {
            b->dev = dev;
            b->blockno = blockno;
            b->valid = 0;
            b->refcnt = 1;
            release(&bcache.lock);
            acquiresleep(&b->lock);
            return b;
          }
        }
        panic("bget: no buffers");
      }
      +

      创建完进程后，就进入scheduler进行进程的调度：

      +
      void
      scheduler(void)
      {
        struct proc *p;
        struct cpu *c = mycpu();
        // ...
          int found = 0;
          for(p = proc; p < &proc[NPROC]; p++) {
      		// ...
              //在这里！！！！
              c->proc = p;
              swtch(&c->context, &p->context);

              c->proc = 0;
      // ...
      -
      正确思路

      首先，大家似乎都是用blockno来hash的，这点就跟我的原始思路不一样了（。其实也很对，因为每个设备的使用频率是不平均的，用blockno来hash比用dev来hash其实会让访问次数更加平均。

      -

      然后就是怎么保证LRU依然OK。hints的做法是使用时间戳。我们可以在brelse的时候记录时间戳字段，在bget缺块的时候遍历hash table，找出对应timestamp最小的block即可。

      -

      历经了几小时的debug，代码最终正确。正确版本在下面的代码模块处。

      -
      debug过程

      coding过程其实很短暂，毕竟思路很直观。我一开始是按初见思路写的代码，然后再从初见思路改到正确思路，这个过程，给我埋下了极大的安全隐患【悲】

      -

      其实几个小时下来，很多细节都已经忘记了，接下来就说点印象比较深的吧。

      -

      首先，我使用了正确思路以来，依然出现了跟初见思路一样的错误，也即xv6正常boot，但是执行ls命令会有错误。但是，当我make clean之后再次make qemu，错误改变了，变成了xv6 boot失败，并且爆出错误panic:ilock:no type。

      -
      -

      注：关于此处的make clean，有两点需要解释。一是为什么会做出make clean的行为，二是这个变化的原理是什么。

      -

      此处突然做出make clean的行为，是因为参照了该文章：

      -

      MIT6.S081 lab8 locks

      -

      image-20230123172138766

      -

      没想到我make clean之后反而就变成了他这样的问题23333也是感觉蛮惊讶的

      -

      这个的原理说实话我不大清楚。猜想可能是make qemu的某段访问磁盘初始化之类的代码只会执行一次，只有make clean之后才会让其执行第二次。所以我们手动完全boot了一遍操作系统，才会导致这个错误爆出来，否则，操作系统就会使用原本的正确boot版本启动，之后再执行命令就当然是错误的了。

      -

      我想知乎文章里也应该是这个原因。操作系统本来使用的是错误版本，make clean后才会重新使用正确版本。

      -

      我之后写对了又尝试了一下，觉得我的猜想应该是对的。我的执行路线：

      -
        -
      1. make qemu，得到正确结果
        2. -
      2. 将bio.c改回错误版本
        3. -
      3. 再次make qemu，发现xv6正常boot，但是执行ls命令会出以上同样的错误
        4. -
      4. make clean，然后make qemu，爆出panic:ilock: no type
        5. -
      -

      挺完美地符合了我的猜想。

      -

      【来自之后的学习：

      -

      in lab file system：

      -

      mkfs 程序创建 xv6 文件系统磁盘映像并确定文件系统总共有多少个块； 这个大小由 kernel/param.h 中的 FSSIZE 控制。 您会看到本实验存储库中的 FSSIZE 设置为 200,000 个块。 您应该在 make 输出中看到 mkfs/mkfs 的以下输出：
      nmeta 70 (boot, super, log blocks 30 inode blocks 13, bitmap blocks 25) blocks 199930 total 200000
      这一行描述了 mkfs/mkfs 构建的文件系统：它有 70 个元数据块（用于描述文件系统的块）和 199,930 个数据块，共计 200,000 个块。
      如果在实验期间的任何时候您发现自己必须从头开始重建文件系统，您可以运行 make clean 来强制 make 重建 fs.img。

      -

      可以看到，我们上面就是做了强制重构fs.img。】

      -
      -

      我想来想去不知道这个错到底怎么爆的，看了下ilock()对应报错点：

      -
      // in fs.c ilock()
        if(ip->valid == 0){
          //printf("ilock begin.\n");
          bp = bread(ip->dev, IBLOCK(ip->inum, sb));
          dip = (struct dinode*)bp->data + ip->inum%IPB;
          ip->type = dip->type;
      	// ...
          ip->size = dip->size;
          memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
          brelse(bp);
          ip->valid = 1;
          if(ip->type == 0){
            //print_buf();
            printf("bp->blockno = %d, bp->refcnt = %d\n",bp->blockno,bp->refcnt);
            panic("ilock: no type");
          }
        }
      +

      因而，c->proc是在创建进程的第一次调度后初始化的，也即，myproc只有在执行第一次scheduler之后才可以调用。而！！！

      +

      当执行调度前的userinit时：

      +
      void
      userinit(void)
      {
        struct proc *p;

        p = allocproc();
        initproc = p;
      -

      可知大概就是，ip的type为0这个非法数值就报错了，而ip的type来源于dip，dip又指向了bp的data，bp也就是我们在bio.c一直在打交道的buf结构体。所以说，其实问题是出在了buf上，我们的bread返回的是一个错误的buf。

      -

      那么，究竟是buf的哪里出错了呢？这个问题想了我很久很久很久，依然没想出来。我一直认为是我的hashtable+双向链表这个数据结构哪里写错了，反反复复看了三四遍，其他地方的逻辑也反反复复研究了好几遍，依然没有结论。当然此过程也抓出了很多bug，但抓完bug后报错仍在，非常坚挺。

      -

      快要放弃的时候，我发现了错误。这很大一部分归功于我用于调试的这个函数：

      -
      // 打印出hashtable的所有结点
      void
      print_buf(){
        printf("**********************\n");
        printf("cnt = %d,dec = %d\n",cnt,dec);
        for(int i=0;i<NBUCKET;i++){
        int should = !holding(&(bcache.dev_locks[i]));
         if(should)
           acquire(&(bcache.dev_locks[i]));
         printf("--------------\n");
         int tmp_cnt = 0;
         struct buf* b;
         for(b = bcache.dev_heads[i].next; b != &(bcache.dev_heads[i]); b = b->next){
         //for(b = bcache.dev_heads[i].prev; b != &(bcache.dev_heads[i]); b = b->prev){
           tmp_cnt++;
           printf("b.refcnt = %d,b.dev = %d,b.blockno = %d\n",b->refcnt,b->dev,b->blockno);
         }
         printf("%d:total:%d\n",i,tmp_cnt);
         printf("--------------\n");
         if(should)
           release(&(bcache.dev_locks[i]));
        }
      }
      +

      它进行了allocproc。我们亲爱的allocproc接下来就会调用perproc_kvminit，然后perproc_kvminit中调用myproc。此时尚未进行初次调度，因而c->proc未初始化，myproc返回的是0，也即null。这样一来，myproc()->kpgtbl就发生了空指针异常，也即scause = 15——写入页错误。

      +

      因而，对于myproc()的调用需要慎之又慎。

      +
      系统调用

      系统调用时，是如何知道要用的是p中的内核页表而非global内核页表呢？

      +

      依然还是从os的启动说起。

      +

      在main.c中，kvminithart开启了页表，此时的页表为全局的内核页表：

      +
      // Switch h/w page table register to the kernel's page table,
      // and enable paging.
      void
      kvminithart()
      {
        w_satp(MAKE_SATP(kernel_pagetable));
        sfence_vma();
      }
      -

      我在ilock()的panic前面调用了这个函数，并且打印了出问题的buf的blockno：

      -
      if(ip->type == 0){
        print_buf();
        printf("bp->blockno = %d, bp->refcnt = %d\n",bp->blockno,bp->refcnt);
        panic("ilock: no type");
      }
      +

      当userinit被调度时，全局的内核页表被换成了proc中的内核页表：

      +
      // in proc.c scheduler()
      p->state = RUNNING;
      w_satp(MAKE_SATP(p->kpgtbl));
      sfence_vma();
      c->proc = p;
      swtch(&c->context, &p->context);
      -

      image-20230123174332113

      -

      可以看到，出问题的这里blockno=33，而在桶7中，首先有两个blockno==33的结点，这已经违反了不变性条件；其次有一个refcnt==1的结点，那个是所需结点，但我们却没有找到那个结点，反而去新申请了一个结点。这显然非常地古怪。

      -

      于是随后，我就在bio.c的bget()中添加了这么几句话：

      -

      image-20230123174620818

      -

      最终结果是会打印出两个blockno==0的结点，但是blockno==33的结点没有访问到。

      -

      这就很奇怪了。print_buf中以及bget的这个地方，都是遍历hashtable的某个双向链表，但是，为什么print_buf可以访问到，但是bget不行呢？

      -

      我首先对比出来的，是print_buf是逆序遍历，而bget是顺序遍历，所以我就又猜想是因为我的数据结构写错了，然而又看了一遍发现并不是。

      -

      这时候，可能我的视力恢复了吧，我猛然发现：：

      -

      image-20230123174921100

      -

      我超，这里是不是应该用hash。。。。。改完这处之后，果然就非常顺利地pass了所有测试【悲】

      -

      可以看到伏笔回收了。我是在旧思路代码基础上改过来的。旧思路代码是用dev作为index的，这个for循环忘记改了。因而，就这样，就这么寄了，看了我三四个小时【悲】

      -

      不过这倒是可以解释得通所有的错误了。之所以ilock中buf出错，没有正确找到已经映射在cache中的buf而是自己新建了一个，是因为，我压根就没有在正确的桶里找，而是在别的桶中找，这样自然就找不到了，就会自己新建一个，然后就寄了。

      -

      这个故事告诉我们，还是得谨慎写代码（）以及，我在旧代码基础上改的时候，其实可以用更聪明的替换方法：修改dev的变量名为hash->把参数里的dev变量名改为dev。这样就不会出错了。很遗憾，我并没有想到，只是很急很急地手动一个个改了，之后也没有检查，才发生如此错误。忏悔。

      -

      本次bug虽然很sb，但确实让我在debug过程中收获了些许，至少毅力变强了（）途中无数次想要放弃，还好我坚持了下来，才能看到如此感动的OK一片：

      -

      image-20230123170805666

      -

      代码

      -

      之后写学校实验时回过头来看，发现之前的实现是不对的，在同时进入bfree函数时有死锁风险。经过修改后虽然粒度大了但是安全了。对了，额外附上一版不知道为啥错了的细粒度版本……看了真感觉没什么问题，但依然是会在bfree时panic两次free。等以后有精力再继续研究吧（泪目）

      -

      错误版本的思路就是，使用每个block块自己的锁(b->lock)和每个桶的锁来实现细粒度加锁。我是左看右看感觉每个block从在bget中获取一直到brelse释放的b->lock锁是一直持有的，但确实依然有可能发生两个进程同时获取同一个block的锁的情况。实在不知道怎么办了，想了很久还是没想出细粒度好方法（泪）总之代码先放在这里。

      -
      -
      正确版本

      请见我的github。

      -
      错误版本
      static struct buf*
      bget(uint dev, uint blockno)
      {
        // printf("bget\n");
        uint hash = blockno % 13;

        acquire(&(bcache.dev_locks[hash]));

        // Is the block already cached?
        for(struct buf* b = bcache.dev_heads[hash].next; b != &(bcache.dev_heads[hash]); b = b->next){
          int initial_hold = holdingsleep(&b->lock);
          release(&(bcache.dev_locks[hash]));

          if (!initial_hold)
            acquiresleep(&b->lock);

          if(b->blockno == blockno&&b->dev == dev){ // 找到了
            b->refcnt++;
            b->timestamp = ticks;
            // release(&(bcache.dev_locks[hash]));
            // acquiresleep(&b->lock);
            return b;
          }

          if (!initial_hold)
            releasesleep(&b->lock);
          acquire(&(bcache.dev_locks[hash]));
        }

        release(&(bcache.dev_locks[hash]));

        // 没找到，进行LRU
        // 遍历hash table，找到LRU，也即时间戳最小的且refcnt小于0的那一项

        uint min_time = 4294967295;// uint的最大值。此处不能使用(uint)(-1)
        struct buf* goal = 0;
        for(int i = 0; i < NBUCKET; i++) {
          uint time = 0;
          acquire(&(bcache.dev_locks[i]));
          for(struct buf* b = bcache.dev_heads[i].prev; b != &(bcache.dev_heads[i]); b = b->prev){
            int initial_hold = holdingsleep(&b->lock);
            release(&(bcache.dev_locks[i]));
            if (!initial_hold) 
              acquiresleep(&b->lock);
            
            if(b->refcnt == 0) {
                time = b->timestamp;
                if(time < min_time){
                  min_time = time;
                  if (goal) releasesleep(&goal->lock);
                  goal = b;
                }
            }
            if (!initial_hold && goal != b)  releasesleep(&b->lock);
            acquire(&(bcache.dev_locks[i]));
          }
          release(&(bcache.dev_locks[i]));
        }
        // hashtable中存在着空闲buf
        if(goal != 0){
            // acquiresleep(&goal->lock);
            goal->dev = dev;
            goal->blockno = blockno;
            goal->valid = 0;
            goal->refcnt = 1;

            // 将goal从其所在双向链表中移除
            acquire(&(bcache.dev_locks[hash]));

            goal->prev->next = goal->next;
            goal->next->prev = goal->prev;

            // 在新双向链表中添加goal
            goal->prev = &(bcache.dev_heads[hash]);
            goal->next = bcache.dev_heads[hash].next;

            bcache.dev_heads[hash].next->prev = goal;
            bcache.dev_heads[hash].next = goal;

            release(&(bcache.dev_locks[hash]));

            return goal;
        }
        panic("bget: no buffers");
      }
      +

      但是这样还没有结束。因为我们除了得更换目前的页表，还得更换trapframe中的内核页表相关的东西：

      +
      struct trapframe {
        /*   0 */ uint64 kernel_satp;   // kernel page table
        /*   8 */ uint64 kernel_sp;     // top of process's kernel stack
      }
      -
      void
      brelse(struct buf *b)
      {
        if(!holdingsleep(&b->lock))
          panic("brelse");

        uint hash = b->blockno%NBUCKET;

        acquire(&(bcache.dev_locks[hash]));
        b->refcnt--;
        b->timestamp = ticks;
        if (b->refcnt == 0) {
          // no one is waiting for it.
          b->next->prev = b->prev;
          b->prev->next = b->next;
          
          b->next = bcache.dev_heads[hash].next;
          b->prev = &bcache.dev_heads[hash];
          bcache.dev_heads[hash].next->prev = b;
          bcache.dev_heads[hash].next = b;
        }
        release(&(bcache.dev_locks[hash]));
        releasesleep(&b->lock);
      }
      +

      为啥还要更换trapframe中的呢？因为以后系统调用的时候，uservec是从这里读取值来作为内核栈和内核页表的来源的：

      +
      # in uservec
      		# restore kernel stack pointer from p->trapframe->kernel_sp
              # 完成了内核栈的切换
              ld sp, 8(a0)

      		# 完成了页表的切换
              # restore kernel page table from p->trapframe->kernel_satp
              ld t1, 0(a0)
              csrw satp, t1
              sfence.vma zero, zero
      -]]> - - - Scheduling - /2023/01/10/xv6$chap7/ - Scheduling

      Code: Context switching

      xv6中，每个CPU中的scheduler都有一个专用的线程。这里线程的概念是，有自己的栈，有自己的寄存器状态。

      -

      当发生时钟中断时，当前进程调用yield，yield再通过swtch切换到scheduler线程。scheduler线程会通过swtch跳转到另外一个进程去执行。当另外一个进程发生时钟中断，又会通过yield回到scheduler，scheduler再调度原进程继续执行，如此周而复始。

      -
      -

      Linux的调度原理也差不多类似这样。每个CPU都有一个调度类为SCHED_CLASS_IDLE的IDLE进程，IDLE进程体大概就是间歇不断地执行__schedule()函数，CPU空闲时就会不断执行IDLE线程。

      -

      而当有新的任务产生时（或任务被唤醒。可以从此看出task new和task wakeup的共通点，可以联想到竞赛中对该消息的处理方法），它首先通过调度类对应的select_cpu选择一个合适的（可以被抢占&&在该task对应的cpumask中）的cpu，迁移到cpu对应的rq；目标cpu通过IDLE进程体或者中断返回时检查到了NEED_SCHEDULE标记位，从而调用schedule函数pick新任务，然后进行context_switch切换到目标线程。如此周而复始。

      -
      -

      image-20230118221757367

      -

      下面就来讲讲这个所谓的“线程”以及xv6的上下文切换是怎么实现的。

      -

      context

      上下文切换的操作对象是上下文，因而首先了解一下上下文的结构。各种寄存器的状态即是上下文context。xv6中的context定义如下:

      -
      struct context {
        uint64 ra;
        uint64 sp;

        // callee-saved
        uint64 s0;
        uint64 s1;
        uint64 s2;
        uint64 s3;
        uint64 s4;
        uint64 s5;
        uint64 s6;
        uint64 s7;
        uint64 s8;
        uint64 s9;
        uint64 s10;
        uint64 s11;
      };
      +

      所以，为了以后系统调用能顺利自发进行，我们需要把栈帧也一起换掉。怎么换呢？我们是否还要在一些地方人工把trapframe的值设置为我们自己的内核栈内核页表？答案是，不用！这些会由其他代码自动完成。

      +

      前面说到userinit的进程p被调度，satp换成了我们自己的内核页表。那么，在之后的内核态，satp都将保持我们自己的内核页表。当要返回用户态时，会执行如下代码：

      +
      // in usertrapret
        // 重置trapframe
        p->trapframe->kernel_satp = r_satp();         // kernel page table
        p->trapframe->kernel_sp = p->kstack + PGSIZE; // process's kernel stack
      + +

      satp内的值为我们自己的内核页表，而非全局页表。因而这样栈帧中的页表就会被自然而然地写入为进程的内核页表。之后返回用户态，以及之后之后的各种中断，就都会一直使用自己的内核页表了。【试了一下，这里如果改成非即时从satp读，而是默认的kernel_pagetable的话，会一直死循环】

      +

      不得不说，真是设计精妙啊！！！不过我觉得，要是这里写成kernel_pagetable，然后让我们自己改的话将是薄纱（。当然它应该也不会这么做，因为，kernel_pagetable事实上是不对外发布的。它这里这么写热读，最直接的原因还是因为读不到kernel_pagetable。这算是无心插柳柳成荫吗233

      +
      释放页表但不释放物理内存

      其实答案就在它给的proc_freepagetable里。

      +
      // Free a process's page table, and free the
      // physical memory it refers to.
      void
      proc_freepagetable(pagetable_t pagetable, uint64 sz)
      {
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmunmap(pagetable, TRAPFRAME, 1, 0);
        uvmfree(pagetable, sz);
      }
      + +

      uvmfree遍历页表，对每个存在的页表项，都试图找到其物理内存，并且释放物理内存和表项。如果页表项存在，但页表项对应的物理内存不存在，就会抛出freewalk leaf的异常。

      +

      uvmunmap会释放掉参数给的va的页表项，最后一个参数表示释放or不释放。

      +

      在这里，使用这两个的组合技，就可以达到不释放TRAMPOLINE和TRAPFRAME的物理内存，又不会让uvmfree出错的效果。

      +

      代码

      初始化

      初始化kpgtbl。由于现在内核栈存在各自的内核页表而非global内核页表中，所以在procinit中的对内核栈的初始化也得放在这：

      +
      // in proc.c allocproc()
        // An empty user page table.
        p->pagetable = proc_pagetable(p);
        if(p->pagetable == 0){
          freeproc(p);
          release(&p->lock);
          return 0;
        }

        p->kpgtbl = perproc_kvminit();

        char *pa = kalloc();
        if(pa == 0)
          panic("kalloc");
        uint64 va = KSTACK((int) (p - proc));
        pkvmmap(p->kpgtbl,va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
        p->kstack = va;
      -

      上下文切换需要修改栈和pc，context中确实有sp寄存器，但是没有pc寄存器，这主要还是因为当swtch返回时，会回到ra所指向的地方，所以仅保存ra就足够了。

      -

      swtch

      上下文的切换是通过swtch实现的。

      -
      void            swtch(struct context*, struct context*);
      +
      // in vm.c
      pagetable_t
      perproc_kvminit()
      {
        pagetable_t pt = (pagetable_t) kalloc();
        memset(pt, 0, PGSIZE);

        // uart registers
        pkvmmap(pt,UART0, UART0, PGSIZE, PTE_R | PTE_W);

        // virtio mmio disk interface
        pkvmmap(pt,VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);

        // CLINT
        pkvmmap(pt,CLINT, CLINT, 0x10000, PTE_R | PTE_W);

        // PLIC
        pkvmmap(pt,PLIC, PLIC, 0x400000, PTE_R | PTE_W);

        // map kernel text executable and read-only.
        pkvmmap(pt,KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);

        // map kernel data and the physical RAM we'll make use of.
        pkvmmap(pt,(uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);

        // map the trampoline for trap entry/exit to
        // the highest virtual address in the kernel.
        pkvmmap(pt,TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);
        return pt;
      }
      -

      swtch会把当前进程的上下文保存在第一个context中，再切换到第二个context保存的上下文，具体实现就是写读保存寄存器：

      -
      # in kernel/swtch.S
      # a0和a1分别保存着两个参数的值，也即第一个context的地址和第二个context的地址
      .globl swtch
      swtch:
              sd ra, 0(a0)
              sd sp, 8(a0)
              sd s0, 16(a0)
              sd s1, 24(a0)
              # ...
              sd s11, 104(a0)

              ld ra, 0(a1)
              ld sp, 8(a1)
              ld s0, 16(a1)
              ld s1, 24(a1)
              # ...
              ld 11, 104(a1)
              
              ret
      +
      // in vm.c
      void
      pkvmmap(pagetable_t pgtbl,uint64 va, uint64 pa, uint64 sz, int perm)
      {
        // 当第一个进程开始时，mycpu->proc = null,所以这里不能调用myproc
        if(mappages(pgtbl, va, sz, pa, perm) != 0)
          panic("kvmmap");
      }
      -

      sched

      在sleep、yield和wakeup中，都会通过sched中的swtch进入scheduler线程。

      -
      void
      sched(void)
      {
        int intena;
        struct proc *p = myproc();

        if(!holding(&p->lock))
          panic("sched p->lock");
        if(mycpu()->noff != 1)
          panic("sched locks");
        if(p->state == RUNNING)
          panic("sched running");
        if(intr_get()) // 当持有锁时一定为关中断状态
          panic("sched interruptible");

        intena = mycpu()->intena;
        swtch(&p->context, &mycpu()->context);
        mycpu()->intena = intena;
      }
      +
      swtch时切换页表
      // in proc.c scheduler()
      p->state = RUNNING;
      w_satp(MAKE_SATP(p->kpgtbl));
      sfence_vma();
      c->proc = p;
      swtch(&c->context, &p->context);

      //...

      	#if !defined (LAB_FS)
          if(found == 0) {
            // 没有进程运行时使用全局kernel_pagetable
            kvminithart();
            intr_on();
            asm volatile("wfi");
          }
      -

      cpu中存储着的是scheduler线程的context。因而，这样就可以保存当前进程的context，读取scheduler线程的context，然后转换到scheduler的context执行了。

      -
      -

      可以发现这里是有个很完美的组合技的。由sched()保存context到process结构体中，再由scheduler()读取process对应的context回归到sched()继续执行，我感觉调度设计这点真是帅的一匹。

      -
      -

      scheduler

      void
      scheduler(void)
      {
        struct proc *p;
        struct cpu *c = mycpu();

        c->proc = 0;
        for(;;){
          // Avoid deadlock by ensuring that devices can interrupt.
          intr_on();

          int nproc = 0;
          for(p = proc; p < &proc[NPROC]; p++) {
            acquire(&p->lock);
            if(p->state != UNUSED) {
              nproc++;
            }
            if(p->state == RUNNABLE) {
              // Switch to chosen process.  It is the process's job
              // to release its lock and then reacquire it
              // before jumping back to us.
              p->state = RUNNING;
              c->proc = p;
              swtch(&c->context, &p->context);

              // Process is done running for now.
              // It should have changed its p->state before coming back.
              c->proc = 0;
            }
            release(&p->lock);
          }
          if(nproc <= 2) {   // only init and sh exist
            intr_on();
            asm volatile("wfi");
          }
        }
      }
      +
      修改kvmpa
      #include "spinlock.h"
      #include "proc.h"

      uint64
      kvmpa(uint64 va)
      {
        uint64 off = va % PGSIZE;
        pte_t *pte;
        uint64 pa;

        pte = walk(myproc()->kpgtbl, va, 0);
        if(pte == 0)
          panic("kvmpa");
        if((*pte & PTE_V) == 0)
          panic("kvmpa");
        pa = PTE2PA(*pte);
        return pa+off;
      }
      -

      通过swtch进入scheduler线程后，会继续执行scheduler中swtch的下一个指令，完成下一次调度。

      -

      一些补充

      以上是书本的介绍内容。看到这想必会有很多疑惑，至少有以下两点：

      -
        -
      1. 为什么cpu->context会存储着scheduler的上下文？这是什么时候，又是怎么初始化的？
        2. -
      2. 为什么从sched中swtch会来到scheduler中swtch的下一句？
        3. -
      -

      先从第一点入手。实际上，这个初始化的工作，是在操作系统启动时的main.c中完成的。

      -
      void
      main()
      {
        if(cpuid() == 0){
          // ...
        } else {
          // ...
        }

        scheduler();        
      }
      +
      释放
      // in kernel.proc.c freeproc()
        if(p->kpgtbl)
          proc_freekpgtbl(p->kpgtbl,p->kstack);
        p->kpgtbl = 0;
      -

      在这之前，创建了第一个进程proc。在这里，每个cpu都调用了scheduler。

      -
      void
      scheduler(void)
      {
        struct proc *p;
        struct cpu *c = mycpu();

        c->proc = 0;
        for(;;){
          intr_on();

          int nproc = 0;
          for(p = proc; p < &proc[NPROC]; p++) {
            acquire(&p->lock);
            // ...
            if(p->state == RUNNABLE) {
              p->state = RUNNING;
              c->proc = p;
              swtch(&c->context, &p->context);

              c->proc = 0;
            }
            release(&p->lock);
          }
          // ...
        }
      }
      +
      extern char etext[];  // kernel.ld sets this to end of kernel code.

      void
      proc_freekpgtbl(pagetable_t pagetable,uint64 stack )
      {
        uvmunmap(pagetable, UART0, 1, 0);
        uvmunmap(pagetable, VIRTIO0, 1, 0);
        uvmunmap(pagetable, CLINT, 0x10000/(uint64)PGSIZE, 0);
        uvmunmap(pagetable, PLIC, 0X400000/(uint64)PGSIZE, 0);
        uvmunmap(pagetable, KERNBASE, (uint64)((uint64)etext-KERNBASE)/PGSIZE, 0);
        uvmunmap(pagetable, (uint64)etext,(PHYSTOP-(uint64)etext)/PGSIZE, 0);
        //kvmmap(KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmunmap(pagetable, stack, 1,1 );
        uvmfree(pagetable, 0);
      }
      -

      每个cpu都在scheduler线程的swtch(&c->context, &p->context);中，将当前的context，也即scheduler的context存入了mycpu()->context。随后，CPU中的某个去执行下一个进程，其他的就在scheduler线程的无限循环中等待，直到有别的进程产生。

      -

      去执行进程的CPU通过swtch切换上下文，切到了另一个进程中，此时在swtch中保存的ra是scheduler线程的swtch的下一句（因为scheduler->swtch也是个函数调用的过程）。会切到另一个进程的sched的下一句【因为它正是从那边swtch过来的】，或者是那个进程开始执行的地方【下面会提到是forkret】。另一个进程通过sched切换回来的时候，就正会切到ra所指向的位置，也即切到scheduler中的swtch后面。

      -

      这样一来，两个问题就都得到了解答。

      -

      从这，我们也能知道xv6是如何让CPU运转的：scheduler线程是CPU的IDLE状态。无事的时候在scheduler中等待，并且一直监测是否有进程需要执行。有的话，则去执行该进程；该进程又会通过sched切换回scheduler线程，继续等待。这样一来，就完成了进程管理的基本的自动机图像。

      -

      Code: Scheduling

      sched前要做的事

      -

      A process that wants to give up the CPU must do three things:

      -
        -
      1. acquire its own process lock p->lock, release any other locks it is holding
        2. -
      2. update its own state (p->state)
        3. -
      3. call sched
        4. -
      -

      yield (kernel/proc.c:515) follows this convention, as do sleep and exit.

      -

      sched double-checks those conditions (kernel/proc.c:499-504) and then an implication of those conditions: since a lock is held, interrupts should be disabled.

      +

      Simplify copyin/copyinstr

      +

      参考：

      +

      6.S081学习记录-lab3

      -

      sched与scheduler

      在上面的描述我们可以看到，sched和scheduler联系非常密切，他们俩通过swtch相互切来切去，并且一直都只在这几行切来切去：

      -
      // in scheduler()
      swtch(&c->context, &p->context);
      c->proc = 0;
      // in sched()
      swtch(&p->context, &mycpu()->context);
      mycpu()->intena = intena;
      - -

      在两个线程之间进行这种样式化切换的过程有时被称为协程（coroutines）。

      -

      存在一种情况使得调度程序对swtch的调用没有以sched结束。一个新进程第一次被调度时，它从forkret（kernel/proc.c:527）开始。Forkret是为了释放p->lock而包装的，要不然，新进程可以从usertrapret开始。

      +

      The kernel’s copyin function reads memory pointed to by user pointers. It does this by translating them to physical addresses, which the kernel can directly dereference. It performs this translation by walking the process page-table in software. Your job in this part of the lab is to add user mappings to each process’s kernel page table (created in the previous section) that allow copyin (and the related string function copyinstr) to directly dereference user pointers.

      -

      p->lock保证了并发安全性

      -

      考虑调度代码结构的一种方法是，它为每个进程强制维持一个不变性条件的集合，并在这些不变性条件不成立时持有p->lock。

      -

      其中一个不变性条件是：如果进程是RUNNING状态，计时器中断的yield必须能够安全地从进程中切换出去；这意味着CPU寄存器必须保存进程的寄存器值（即swtch没有将它们移动到context中），并且c->proc必须指向进程。另一个不变性条件是：如果进程是RUNNABLE状态，空闲CPU的调度程序必须安全地运行它；这意味着p->context必须保存进程的寄存器（即，它们实际上不在实际寄存器中），没有CPU在进程的内核栈上执行，并且没有CPU的c->proc引用进程。

      -

      维护上述不变性条件是xv6经常在一个线程中获取p->lock并在另一个线程中释放它的原因，在保持p->lock时，这些属性通常不成立。

      -

      例如在yield中获取并在scheduler中释放。一旦yield开始修改一个RUNNING进程的状态为RUNNABLE，锁必须保持被持有状态，直到不变量恢复：最早的正确释放点是scheduler（在其自身栈上运行）清除c->proc之后。类似地，一旦scheduler开始将RUNNABLE进程转换为RUNNING，在内核线程完全运行之前（在swtch之后，例如在yield中）绝不能释放锁。

      -

      p->lock还保护其他东西：exit和wait之间的相互作用，避免丢失wakeup的机制（参见第7.5节），以及避免一个进程退出和其他进程读写其状态之间的争用（例如，exit系统调用查看p->pid并设置p->killed(kernel/proc.c:611)）。为了清晰起见，也许为了性能起见，有必要考虑一下p->lock的不同功能是否可以拆分。

      +
      +

      Replace the body of copyin in kernel/vm.c with a call to copyin_new (defined in kernel/vmcopyin.c); do the same for copyinstr and copyinstr_new. Add mappings for user addresses to each process’s kernel page table so that copyin_new and copyinstr_new work.

      -

      p->lock在每次scheduler开始的时候获取，swtch到p进程的时候在yield等调用完sched的地方释放。而调用yield时获取的锁，又会在scheduler中释放。

      -
      // Give up the CPU for one scheduling round.
      void
      yield(void)
      {
        struct proc *p = myproc();
        acquire(&p->lock);// 该锁会在scheduler中释放
        p->state = RUNNABLE;
        sched();
        release(&p->lock);// 该锁释放的是scheduler中得到的锁
      }
      - -
      // in kernel/proc.c scheduler()
      	  acquire(&p->lock);// 该锁会在yield等地被释放
              // ...
              swtch(&c->context, &p->context);
      		// ...
            release(&p->lock);// 该锁会释放yield等地中获得的锁
      - -

      不得不说，这结构实在是太精妙了。这中间的如此多的复杂过程，就这样成功地被锁保护了起来。

      -

      Code: mycpu and myproc

      // Per-CPU state.
      struct cpu {
        struct proc *proc;          // The process running on this cpu, or null.
        struct context context;     // swtch() here to enter scheduler().
        int noff;                   // Depth of push_off() nesting.
        int intena;                 // Were interrupts enabled before push_off()?
      };
      - -

      mycpu是通过获取当前cpuid来获取cpu结构的。当前使用的cpuid约定俗成地存在了tp寄存器里。为了让mycpu有效工作，必须确保tp寄存器始终存放的是当前cpu的hartid。

      -

      首先是在操作系统初始化的时候要把cpuid存入tp寄存器。RISC-V规定，mhartid也即cpuid的存放点只能在machine mode被读取。因而这项工作得在start.c中完成：

      -
      // in kernel/start.c 
        // keep each CPU's hartid in its tp register, for cpuid().
        int id = r_mhartid();
        w_tp(id);
      // in kernel/riscv.h
      // which hart (core) is this?
      static inline uint64
      r_mhartid()
      {
        uint64 x;
        asm volatile("csrr %0, mhartid" : "=r" (x) );
        return x;
      }
      - -

      在内核态中，编译器被设置为保证不会以其他方式使用tp寄存器。因而初始化之后，内核态中每个CPU的tp寄存器就始终存放着自己的cpuid。

      -

      但这在用户进程是不成立的。因而必须在用户进程进入陷阱的时候做一些工作。

      -
      # in kernel/trampoline.S uservec
      sd tp, 64(a0)
      # make tp hold the current hartid, from p->trapframe->kernel_hartid
      ld tp, 32(a0)
      +

      感想

      这题很直观的思路是，在每个user pagetable添加映射的地方也添加kpgtbl的映射。但问题是，“每个user pagetable添加映射的地方”都是哪？

      +
      误入幻想

      我一开始想着偷偷懒，直接在proc.c和vm.c中每个操纵pagetable的地方都加上对kpgtbl的操纵。但很快我就给搞晕了。这时候，我心中萌生一计【PS：下面说的最后都没成功】：我直接快进到把proc结构中的pagetable属性给删了，然后每个出现p->pagetable的地方，都用p->kpgtbl代替，直接让两表合为一表，然后之后make的时候哪里报错改哪里，这不就一劳永逸地把所有出现pagetable的地方都改为kpgtbl了嘛。我振奋地去试了一下，将所有地方出现的pagetable都替换成了kpgtbl，把proc.c中的proc_pagetable()和proc_freepagetable()的出现的地方都换成了perproc_kvminit()以及proc_freekpgtbl()，还做了一个小细节，就是在userinit中调用的uvminit中，我把这样：

      +
      void
      uvminit(pagetable_t pagetable, uchar *src, uint sz)
      {
        char *mem;

        if(sz >= PGSIZE)
          panic("inituvm: more than a page");
        mem = kalloc();
        memset(mem, 0, PGSIZE);
        mappages(pagetable, 0, PGSIZE, (uint64)mem, PTE_W|PTE_R|PTE_X|PTE_U);
        memmove(mem, src, sz);
      }
      -
      struct trapframe {
        /*  32 */ uint64 kernel_hartid; // saved kernel tp
        /*  64 */ uint64 tp;
          // ...
      }
      +

      换成了这样：

      +
      void
      uvminit(struct proc* p, uchar *src, uint sz)
      {
        char *mem;

        if(sz >= PGSIZE)
          panic("inituvm: more than a page");
        mem = kalloc();
        memset(mem, 0, PGSIZE);
        mappages(p->kpgtbl, 0, PGSIZE, (uint64)mem, PTE_W|PTE_R|PTE_X|PTE_U);
        memmove(mem, src, sz);
      }
      -

      必须在trampoline保存用户态中使用的tp值，以及内核态中对应的hartid。

      -

      最后再在返回用户态的时候恢复用户态的tp值以及更新trampoline的tp值。

      -
      // in kernel/trap.c usertrapret()
      p->trapframe->kernel_hartid = r_tp();         // hartid for cpuid()
      +

      最后，在启动的时候，卡在了初次调度切换不到initcode这边，没有调用exec。没有panic，似乎只在死循环。我也实在想不出是什么原因，最后把代码删了【悲】想想我应该用git保存一下改前改后的。这下实在是难受了，我的想法也暂时没有机会实践了。等到明年大三说不定还得再交一次这玩意，到时候再探究探究吧hhh

      +
      走上正途

      发现这个最后没成还改了半天的我最后非常沮丧地去看了hints【又一心浮气躁耐心不足的表现，但确实绷不住了】，发现它居然说只用修改三个地方：fork、exec以及sbrk。

      +

      我把kernel/下的每个文件都搜了一遍，发现确实，只有这三个，以及proc.c，vm.c，涉及到对页表项的增删。而在用户态中，想要对进程的内存进行管理，似乎只能通过系统调用sbrk。而proc.c和vm.c中确实没什么好改的。因为里面增加的映射，都是trapframe、trampoline、inicode这种不会一般在copyin中用到的虚拟地址。所以，要改的地方，确确实实，只有fork、exec以及sbrk。

      +
      +

      Xv6 applications ask the kernel for heap memory using the sbrk() system call.

      +
      +

      很悲伤，我的初见思路是错误的（）

      +

      而这三个地方的共同点，就是都会对页表进行大量的copy。

      +
      //in proc.c fork()
        // Copy user memory from parent to child.
        if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
          freeproc(np);
          release(&np->lock);
          return -1;
        }
      -
      # in trampoline.S userret
      ld tp, 64(a0)
      +
      //in exec.c
        // Commit to the user image.
        oldpagetable = p->pagetable;
        p->pagetable = pagetable;
      -

      注意，更新trampoline的tp值这一步很重要。因为如果在用户态发生的是时钟中断，就会引起yield，可能造成CPU的切换。这时候就需要在返回用户态的时候修改一下trapframe中的tp为当前CPU的tp。这样一来才能保证，在本次时钟中断结束，以及到下一次时钟中断修改CPU这一期间，trapframe中的tp寄存器以及内核态中的tp寄存器都是正确的。

      -

      通过mycpu()获取cpuid其实是非常脆弱的。因为你可能获取完cpuid，进程就被切到别的CPU去执行了，这就会有一个先检查后执行的竞态条件，具有并发安全隐患。因而，xv6要求使用mycpu()返回值的这段代码需要关中断，这样就可以避免时钟中断造成的进程切换了。比如说像myproc()这样：

      -
      // Return the current struct proc *, or zero if none.
      struct proc*
      myproc(void) {
        push_off();
        struct cpu *c = mycpu();
        struct proc *p = c->proc;
        pop_off();
        return p;
      }
      +
      //in syscall.c
      uint64
      sys_sbrk(void)
      {
        int addr;
        int n;

        if(argint(0, &n) < 0)
          return -1;
        addr = myproc()->sz;
        if(growproc(n) < 0)
          return -1;
        return addr;
      }
      //in proc.c growproc()
      uvmalloc(p->pagetable, sz, sz + n)) == 0
      -

      注意，不同于mycpu()，使用myproc()的返回值不需要进行开关中断保护。因为当前进程的指针不论处于哪个CPU都是不变的。

      -

      Sleep and wakeup

      前面我们已经介绍了进程隔离性的基本图像，接下来要讲xv6是如何让进程之间互动的。xv6使用的是经典的sleep and wakeup，也叫序列协调（sequence coordination）或条件同步机制（conditional synchronization mechanisms。下面，将从最基本的自旋锁实现信号量开始，来逐步讲解xv6的sleep and wakeup机制。

      -

      自旋锁实现信号量

      image-20230120150659730

      -

      image-20230120150715925

      -

      缺点就是自旋太久了，因而我们需要在等待的时候调用yield，直到资源生产出来之后再继续执行。

      -

      不安全的sleep and wakeup

      -

      Let’s imagine a pair of calls, sleep and wakeup, that work as follows:

      +

      所以，我们要做的事情很简单：写一个坐收渔翁之利的函数，内容为把一个页表的所有内容复制到另一个页表。然后再在这几个地方调用这个函数即可。

      +

      代码

      +

      注意：由于我写得实在是太烦了，已经思考不下去了。为了放过我自己，我写了个虽然能过得去测试但是其实毛病重重的代码。垃圾点为以下几点：

        -

      1. sleep(chan)

        -

        Sleeps on the arbitrary value chan, called the wait channel. Sleep puts the calling process to sleep, releasing the CPU for other work.

        +

      2. 需要去掉freewalk中的panic

        +

        我的kvmcopy的实现是，user pagetable（下面简称up）和tp的相同虚拟地址共用同一页物理内存。也就是说，页表不一样，但所指向的物理内存是同一个。这样设计的目的是为了能够让tp及时用到up的更新后的数据。

        +

        这会导致啥呢？在进程释放时，需要一起调用proc_freepagetable和proc_freekpgtbl。proc_freepagetable调用完后，所指向的那堆物理内存已经寄完了，如果再调用proc_freekpgtbl，显然，就会发生页表未释放但页表对应内存已经释放的问题，freewalk就会panic。因此，我简单粗暴地直接把freewalk的panic删掉了【抖】也许有别的解决方法，但我真是烦得不想想了放过我吧（

        3. -

      3. wakeup(chan)

        -

        Wakes all processes sleeping on chan (if any), causing their sleep calls to return. If no processes are waiting on chan, wakeup does nothing.

        +

      4. 好像暂时没有第二点了（）

      -

      这样一来，信号量实现就可修改为这样了：

      -

      image-20230120151051989

      -

      但是，我们可以注意到，在212-213行这里产生了一个先检查后执行的竞态条件。

      +
      渔翁之利函数
      // in vm.c
      // 效仿的是vm.c中的uvmcopy
      int
      kvmcopy(pagetable_t up, pagetable_t kp, uint64 sz)
      {  
        pte_t *pte;
        uint64 pa, i;
        uint flags;

        for(i = 0; i < sz; i += PGSIZE){ 
          if((pte = walk(up, i, 0)) == 0 || (*pte & PTE_V) == 0){
              if(walk(kp,i,0) == 0){
                  //如果up不存在此项，kp存在，就直接删了
                  uvmunmap(kp,i,PGSIZE,0);
              }
              continue;
          }
          pa = PTE2PA(*pte);
          flags = PTE_FLAGS(*pte);
          // 注意去除PTE_U，否则内核态无法访问
          flags = (flags & (~PTE_U));
          if(mappages(kp, i, PGSIZE, pa, flags) != 0){
            goto err;
          }
        }
        return 0;

       err:
        uvmunmap(kp, 0, i / PGSIZE, 1);
        return -1;
      }
      + +
      修改fork、exec、sbrk
      fork
      // in proc.c fork()
        // Copy user memory from parent to child.
        if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
          freeproc(np);
          release(&np->lock);
          return -1;
        }
        if(kvmcopy(np->pagetable, np->kpgtbl, p->sz) < 0){
          freeproc(np);
          release(&np->lock);
          return -1;
        }
      + +
      exec
      // in exec.c
        // Commit to the user image.
        oldpagetable = p->pagetable;
        p->pagetable = pagetable;

        p->sz = sz;
        p->trapframe->epc = elf.entry;  // initial program counter = main
        p->trapframe->sp = sp; // initial stack pointer
        proc_freepagetable(oldpagetable, oldsz);

        // 添上此句
        kvmcopy(p->pagetable, p->kpgtbl, p->sz);
      + +
      sbrk
      uint64
      sys_sbrk(void)
      {
        int addr;
        int n;

        if(argint(0, &n) < 0)
          return -1;
        addr = myproc()->sz;
        if(addr+n >= PLIC)    return -1;
        if(growproc(n) < 0)
          return -1;
        return addr;
      }
      + +
      // in proc.c
      // Grow or shrink user memory by n bytes.
      // Return 0 on success, -1 on failure.
      int
      growproc(int n)
      {
        uint sz;
        struct proc *p = myproc();

        sz = p->sz;
        // ...
        p->sz = sz;
        // 加这个
        kvmcopy(p->pagetable, p->kpgtbl, p->sz);
        return 0;
      }
      + +
      userinit
      +

      这一步不能忽视，因为内核启动的时候就需要用到copyinstr。

      +
      +
      // in proc.c userinit()
        uvminit(p->pagetable, initcode, sizeof(initcode));
        p->sz = PGSIZE;
        // 加这个！
        kvmcopy(p->pagetable, p->kpgtbl, p->sz);
      + +
      删掉freewalk的panic（我特有的缺点）
      // in vm.c freewalk()    
          if((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0){
            // ...
          } else if(pte & PTE_V){
            //panic("freewalk: leaf");
          }
      +]]> + + + Operating system oganization + /2023/01/10/xv6$chap2/ + Operating system oganization
      +

      Before you start coding, read Chapter 2 of the xv6 book, and Sections 4.3 and 4.4 of Chapter 4, and related source files:

      +
        +
      • The user-space code for systems calls is in user/user.h and user/usys.pl.
        • +
      • The kernel-space code is kernel/syscall.h, kernel/syscall.c.
        • +
      • The process-related code is kernel/proc.h and kernel/proc.c.
        • +
      +
      +

      这章主要是讲了操作系统为了兼顾并发性、隔离性、交互性做出的基本架构。

      +

      Kernel organization

      宏内核与微内核

      操作系统一个很重要的设计问题就是，哪部分的代码需要run在内核态，哪部分的需要run在用户态。

      +

      如果将操作系统所有系统调用统统都在内核态run，这种设计方式就叫宏内核monolithic kernel。

      +

      如果仅将系统调用中必要的部分在内核态run，其他部分都在用户态run，并且采取Client/Server这样的异步通信方式，这种设计方式就叫微内核microkernel。

      +

      image-20230107232802540

      +
      +

      由于客户/服务器（Client/Server）模式，具有非常多的优点，故在单机微内核操作系统中几乎无一例外地都采用客户/服务器模式，将操作系统中最基本的部分放入内核中，而把操作系统的绝大部分功能都放在微内核外面的一组服务器(进程)中实现。

      +
      +

      在微内核中，内核接口由一些用于启动应用程序、发送消息、访问设备硬件等的低级功能组成。这种组织允许内核相对简单，因为大多数操作系统驻留在用户级服务器中。

      +

      像大多数Unix操作系统一样，Xv6是作为一个宏内核实现的。因此，xv6内核接口对应于操作系统接口，内核实现了完整的操作系统。

      +

      Code: xv6 organization

      XV6的源代码位于kernel子目录中，源代码按照模块化的概念划分为多个文件，图2.2列出了这些文件，模块间的接口都被定义在了def.h（kernel/defs.h）。

      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      文件描述
      bio.c文件系统的磁盘块缓存
      console.c连接到用户的键盘和屏幕
      entry.S首次启动指令
      exec.cexec()系统调用
      file.c文件描述符支持
      fs.c文件系统
      kalloc.c物理页面分配器
      kernelvec.S处理来自内核的陷入指令以及计时器中断
      log.c文件系统日志记录以及崩溃修复
      main.c在启动过程中控制其他模块初始化
      pipe.c管道
      plic.cRISC-V中断控制器
      printf.c格式化输出到控制台
      proc.c进程和调度
      sleeplock.cLocks that yield the CPU
      spinlock.cLocks that don’t yield the CPU.
      start.c早期机器模式启动代码
      string.c字符串和字节数组库
      swtch.c线程切换
      syscall.cDispatch system calls to handling function.
      sysfile.c文件相关的系统调用
      sysproc.c进程相关的系统调用
      trampoline.S用于在用户和内核之间切换的汇编代码
      trap.c对陷入指令和中断进行处理并返回的C代码
      uart.c串口控制台设备驱动程序
      virtio_disk.c磁盘设备驱动程序
      vm.c管理页表和地址空间
      +

      图2.2：XV6内核源文件

      +

      Process overview

      内核用来实现进程的机制包括用户态内核态标志、地址空间和进程的时间切片。

      +

      为了帮助加强隔离，进程抽象给程序提供了一种错觉，即它有自己的专用机器。进程为程序提供了一个看起来像是私有内存系统或地址空间的东西，其他进程不能读取或写入。进程还为程序提供了看起来像是自己的CPU来执行程序的指令。

      +

      Xv6使用页表（由硬件实现）为每个进程提供自己的地址空间。RISC-V页表将虚拟地址（RISC-V指令操纵的地址）转换（或“映射”）为物理地址（CPU芯片发送到主存储器的地址）。

      +

      每个进程也有自己的页表，页表中记录了以虚拟地址0开始的内存区域。

      +

      image-20230107233741922

      +

      xv6内核为每个进程维护许多状态片段，并将它们聚集到一个proc(*kernel/proc.h*:86)结构体中。一个进程最重要的内核状态片段是它的页表、内核栈区和运行状态。我们将使用符号p->xxx来引用proc结构体的元素；例如，p->pagetable是一个指向该进程页表的指针。

      -

      如果消费者进程执行到212-213中间，此时生产者进程已经调用结束，也就是说wakeup并没有唤醒任何消费者进程。消费者进程就会一直在sleep中没人唤醒，除非生产者进程再执行一次。这样就会造成lost wake-up 这个问题。

      -
      -

      所以，我们可以选择把这个竞态条件也放入s->lock这个锁区域保护。

      -

      image-20230120151353712

      -

      但是这样一来又会产生死锁问题。因而，我们可以尝试着修改sleep和wakeup的接口定义。

      -

      sleep and wakeup

      -

      We’ll fix the preceding scheme by changing sleep’s interface:

      -

      The caller must pass the condition lock to sleep so it can release the lock after the calling process is marked as asleep and waiting on the sleep channel. The lock will force a concurrent V to wait until P has finished putting itself to sleep, so that the wakeup will find the sleeping consumer and wake it up. Once the consumer is awake again sleep reacquires the lock before returning.

      -

      也即在sleep中：

      -
      sleep(s,&s->lock){
       // do something
      	release(&s->lock);
      	//wait until wakeup
       acquire(&s->lock);
       return;
      }
      +

      这应该相当于pcb表。

      -

      这样一来，信号量就可以完美实现了：

      -

      image-20230120151807102

      -

      image-20230120151820455

      +

      Code: starting xv6 and the first process

      看完一遍说实话还乱乱的。。。。我整理整理跟linux的对比学习一下吧。

      +

      xv6

      加载操作系统

      系统加电，启动BIOS初始化硬件 -> BIOS从引导扇区将加载程序读入内存 -> 加载程序将操作系统镜像读入内存RAM。

      -

      注：严格地说，wakeup只需跟在acquire之后就足够了（也就是说，可以在release之后调用wakeup）

      -

      【想了一下，有一说一确实，放在release前后都不影响】

      +

      这个过程由qemu模拟。

      +

      首先会通过mkfs造出操作系统镜像。然后由qemu将引导扇区，也即下面的filesys这图里的第0块：

      +

      image-20230121162324747

      +

      读入到主存中，然后开始执行引导扇区的程序，下同。

      +

      boot loader目的是把xv6加载进内存到0x8000 0000，然后跳转到xv6初始化程序。

      -

      原始Unix内核的sleep只是禁用了中断，这就足够了，因为Unix运行在单CPU系统上。因为xv6在多处理器上运行，所以它为sleep添加了一个显式锁。

      +

      The reason it places the kernel at 0x80000000 rather than 0x0 is because the address range 0x0:0x80000000 contains I/O devices.

      -

      Code: Sleep and wakeup

      // Atomically release lock and sleep on chan.
      // Reacquires lock when awakened.
      void
      sleep(void *chan, struct spinlock *lk)
      {
        struct proc *p = myproc();

        // Must acquire p->lock in order to
        // change p->state and then call sched.
        // Once we hold p->lock, we can be
        // guaranteed that we won't miss any wakeup
        // (wakeup locks p->lock),
        // so it's okay to release lk.
        if(lk != &p->lock){  //DOC: sleeplock0
          // 获取进程锁，释放外部锁
          // 此进程锁将在scheduler线程中释放
          acquire(&p->lock);  //DOC: sleeplock1
          release(lk);
        }

        // Go to sleep.
        p->chan = chan;
        p->state = SLEEPING;

        sched();
        // 到这里来，说明已经被wakeup且被调度了

        // Tidy up.
        p->chan = 0;

        // Reacquire original lock.
        if(lk != &p->lock){
          //释放进程锁，获取外部锁
          // 此进程锁是在scheduler中获取到的
          release(&p->lock);
          acquire(lk);
        }
      }
      +

      操作系统初始化

      entry.S配置栈空间

      此时，目前的机器状态是，1.没有开启地址映射，也即虚拟地址=真实物理地址。2.运行在machine mode

      +

      xv6会在kernel/entry.S下的这里开始执行，目的是配置好栈，以开始C语言代码start.c的执行：

      +
      .global _entry
      _entry:
              # set up a stack for C.
              # 这段主要是在计算栈顶指针sp
              # stack0 is declared in start.c,
              # with a 4096-byte stack per CPU.
              # sp = stack0 + (hartid * 4096)
              la sp, stack0
              li a0, 1024*4
              csrr a1, mhartid
              addi a1, a1, 1
              mul a0, a0, a1
              add sp, sp, a0
              # 已经有栈了，就可以开始执行C语言代码了
              # jump to start()
              call start
      -

      注意，如果lk为p->lock，那么lk依然会在scheduler线程中被暂时释放。

      -
      // Wake up all processes sleeping on chan.
      // Must be called without any p->lock.
      void
      wakeup(void *chan)
      {
        struct proc *p;

        for(p = proc; p < &proc[NPROC]; p++) {
          acquire(&p->lock);
          if(p->state == SLEEPING && p->chan == chan) {
            p->state = RUNNABLE;
          }
          release(&p->lock);
        }
      }
      +

      其中start0：

      +
      __attribute__ ((aligned (16))) char stack0[4096 * NCPU];
      -

      可以注意到，关于chan这一变量的取值是非常任意的，仅需取一个约定俗成的值就OK。这里取为了信号量的地址，同时满足了逻辑需求和语义需求。

      +
      start.c

      在start.c中，我们的任务是在machine mode下，获取machine mode才能访问到的硬件参数，做在machine mode 下才能做的时钟初始化【 it programs the clock chip to generate timer interrupts】，然后进行machine mode到内核态的切换，最后跳转到main.c进行操作系统的初始化和第一个进程的启动。

      +

      而其中，如果想从machine mode切换到内核态，就需要使用mret指令。但是mret指令除了会切换mode之外，还有一个“ret”的作用，并且是从machine mode ret到内核态。

      -

      Callers of sleep and wakeup can use any mutually convenient number as the channel. Xv6 often uses the address of a kernel data structure involved in the waiting.

      +

      This instruction( mret ) is most often used to return from a previous call from supervisor mode to machine mode.

      -

      这里也解释了为什么需要while循环

      +

      所以，我们实际上可以把最后两步连起来，用mret一个指令就完成。也即，mret指令既完成了从machine mode到内核态的切换，又完成了从start.c到main.c的跳转。

      +

      这其实很容易，只需在栈中将调用者（此时应该是entry.S）的地址替换为main.c的地址，并且将调用者的mode改为内核态，这样就ok了。

      -

      有时，多个进程在同一个通道上睡眠；例如，多个进程读取同一个管道。一个单独的wakeup调用就能把他们全部唤醒。其中一个将首先运行并获取与sleep一同调用的锁，并且（在管道例子中）读取在管道中等待的任何数据。尽管被唤醒，其他进程将发现没有要读取的数据。从他们的角度来看，醒来是“虚假的”，他们必须再次睡眠。因此，在检查条件的循环中总是调用sleep。

      +

      it sets the previous privilege mode to supervisor in the register mstatus, it sets the return address to main by writing main’s address into the register mepc, disables virtual address translation in supervisor mode by writing 0 into the page-table register satp, and delegates all interrupts and exceptions to supervisor mode

      +

      后面两点不大明白。为什么为了mret，就还得让内核态跟machine mode一样关闭虚拟地址映射，还得把什么中断和异常委托给内核态？？

      +

      【我猜测是因为现在页表还没初始化好所以当然得关闭虚拟地址映射（）；后者大概是开中断的意思？】

      -

      Code: Pipes

      pipes很显然就是生产者消费者模式的一个例证。

      -
      struct pipe {
        struct spinlock lock;
        char data[PIPESIZE];
        uint nread;     // number of bytes read
        uint nwrite;    // number of bytes written
        int readopen;   // read fd is still open
        int writeopen;  // write fd is still open
      };
      - -
      int
      piperead(struct pipe *pi, uint64 addr, int n)
      {
        int i;
        struct proc *pr = myproc();
        char ch;

        acquire(&pi->lock);
        while(pi->nread == pi->nwrite && pi->writeopen){  //DOC: pipe-empty并且依然有进程在写
          if(pr->killed){
            release(&pi->lock);
            return -1;
          }
          // 等待直到pipe不为空
          sleep(&pi->nread, &pi->lock); //DOC: piperead-sleep
        }
        for(i = 0; i < n; i++){  //DOC: piperead-copy
          if(pi->nread == pi->nwrite)
            break;
          ch = pi->data[pi->nread++ % PIPESIZE];
          if(copyout(pr->pagetable, addr + i, &ch, 1) == -1)
            break;
        }
        // 唤醒写入管道的进程
        wakeup(&pi->nwrite);  //DOC: piperead-wakeup
        release(&pi->lock);
        return i;
      }
      +

      代码如下：

      +
      // entry.S jumps here in machine mode on stack0.
      void
      start()
      {
        //修改调用者为内核态
        // set M Previous Privilege mode to Supervisor, for mret.
        unsigned long x = r_mstatus();
        x &= ~MSTATUS_MPP_MASK;
        x |= MSTATUS_MPP_S;
        w_mstatus(x);

        // set M Exception Program Counter to main, for mret.
        // requires gcc -mcmodel=medany
        w_mepc((uint64)main);

        // disable paging for now.
        w_satp(0);

        // delegate all interrupts and exceptions to supervisor mode.
        w_medeleg(0xffff);
        w_mideleg(0xffff);
        w_sie(r_sie() | SIE_SEIE | SIE_STIE | SIE_SSIE);

        // configure Physical Memory Protection to give supervisor mode
        // access to all of physical memory.
        w_pmpaddr0(0x3fffffffffffffull);
        w_pmpcfg0(0xf);

        // ask for clock interrupts.
        timerinit();

        // keep each CPU's hartid in its tp register, for cpuid().
        int id = r_mhartid();
        w_tp(id);

        // switch to supervisor mode and jump to main().
        asm volatile("mret");
      }
      -
      int
      pipewrite(struct pipe *pi, uint64 addr, int n)
      {
        int i;
        char ch;
        struct proc *pr = myproc();

        acquire(&pi->lock);
        for(i = 0; i < n; i++){
          while(pi->nwrite == pi->nread + PIPESIZE){  //DOC: pipewrite-full管道满则阻塞
            if(pi->readopen == 0 || pr->killed){
              release(&pi->lock);
              return -1;
            }
            // 唤醒读取管道的进程
            wakeup(&pi->nread);
            sleep(&pi->nwrite, &pi->lock);
          }
          if(copyin(pr->pagetable, &ch, addr + i, 1) == -1)
            break;
          pi->data[pi->nwrite++ % PIPESIZE] = ch;
        }
        wakeup(&pi->nread);
        release(&pi->lock);
        return i;
      }
      +
      main.c

      main.c的作用是做很多很多init。其中，它通过userinit();来创建第一个进程，这个第一个进程再由main调用scheduler()来被调度执行。

      +
      void
      main()
      {
        if(cpuid() == 0){
          consoleinit();
          printfinit();
          printf("\n");
          printf("xv6 kernel is booting\n");
          printf("\n");
      	//...很多很多init
          userinit();      // first user process
          __sync_synchronize();
          started = 1;
        } else {
          while(started == 0)
            ;
          __sync_synchronize();
          /*
          RISC-V的处理器对底层提供了一种特殊的抽象,Hardware Thread,简称为Hart。简单来说,Hart是真实物理CPU(bare metal)提供的一种模拟
          */
          printf("hart %d starting\n", cpuid());
          kvminithart();    // turn on paging
          trapinithart();   // install kernel trap vector
          plicinithart();   // ask PLIC for device interrupts
        }

        //调用第一个scheduler，完成对scheduler线程的初始化，并且调度去执行第一个进程
        scheduler();        
      }
      -

      一个非常有意思且巧妙的点，就是读写管道等待在不同的chan上，这与上面信号量的例子是不一样的。想想也确实，如果使用同一个管道的话，当唤醒的时候，就会把不论是读还是写的全部进程都唤醒过来，这对性能显然损失较大。

      -

      The pipe code uses separate sleep channels for reader and writer (pi->nread and pi->nwrite); this might make the system more effificient in the unlikely event that there are lots of readers and writers waiting for the same pipe.

      -
      -

      Code: Wait, exit, and kill

      exit和wait

      -

      Sleep和wakeup可用于多种等待。第一章介绍的一个有趣的例子是子进程exit和父进程wait之间的交互。

      -

      xv6记录子进程终止直到wait观察到它的方式是让exit将调用方置于ZOMBIE状态，在那里它一直保持到父进程的wait注意到它，将子进程的状态更改为UNUSED，复制子进程的exit状态码，释放子进程，并将子进程ID返回给父进程。

      -

      如果父进程在子进程之前退出，则父进程将子进程交给init进程，init进程将永久调用wait；因此，每个子进程退出后都有一个父进程进行清理。

      +

      注：关于里面的cpuid，我查了一下，指的是CPU的序列号，用来唯一标识cpu的。我想这个if架构的目的应该跟fork()==0差不多。也就是说，一开始的那个init仅有cpuid==0的CPU执行，其他的CPU就乖乖wait，只有CPU0执行初始化的程序。等到CPU0执行完所有init，才置标记位start=1，然后通过条件变量start控制抢占调度，轮流初始化自己。其中__sync_synchronize是GNU内置指令，起内存屏障作用。在竞赛中深刻地了解过了内存屏障，在这里再次跟老熟人再会感觉还是很有意思的。

      -

      又是一个生产者消费者模式。只不过此时的chan是父进程，资源是僵尸子进程【草】。由于涉及到进程间的调度切换，因而实现稍微复杂了点。

      -

      为什么需要涉及到进程间的调度呢？子进程设置完僵尸状态后，直接通过函数ret不行吗？答案是不行，因为ret的话就会去到不知道哪的地方【大概率会变成scause=2的情况】，所以这里子进程想要退出，就得做几件事，一是依靠父进程，让父进程杀死子进程，二是把自己设置为一个特殊的状态，使得自己不会被调度从而执行ret指令出错，三是尽快让父进程杀死自己越快越好。综合上述三个原因，exit最终在调度方面的实现方式，就变成了，子进程设置自己为ZOMBIE态->启用调度->父进程杀死ZOMBIE态的子进程。这期间不变性条件的防护，就得依赖于锁，以及sleep和wakeup了。

      -
      void
      exit(int status)
      {
        struct proc *p = myproc();
        
        // ...
          
        // we need the parent's lock in order to wake it up from wait().
        // the parent-then-child rule says we have to lock it first.
        // 整个xv6都必须遵守相同的顺序（父级，然后是子级）不论是锁定还是释放，都是先父再子
        acquire(&original_parent->lock);
        acquire(&p->lock);

        // Give any children to init.
        // 把自己的所有孩子都托付给init进程
        // init进程就是在操作系统启动时
        reparent(p);

        // Parent might be sleeping in wait().
        // 唤醒wait中的父进程
        // 这里看上去很诡异，明明子进程状态还未完全，怎么就唤醒父亲了呢？但其实很安全。
        // 此时子进程仍持有父进程的锁，如果有别的CPU中断进入scheduler线程，到父进程那时会卡在aquire
        // 直到子进程完成后续工作后父进程才能被真正唤醒执行
        wakeup1(original_parent);

        p->xstate = status;
        // 设为ZOMBIE态
        p->state = ZOMBIE;

        // 完成后续工作，解除父进程的锁
        release(&original_parent->lock);

        // Jump into the scheduler, never to return.
        // 子进程会在父进程中被释放，所以永远不会回来
        sched();
        panic("zombie exit");
      }
      +
      proc.c中的userinit()

      userinit的作用就是新创建一个进程信息proc，然后开始给第一个程序（initcode）填信息填入proc。这个进程创建完后，在main中的scheduler被调度执行。

      +
      void
      userinit(void)
      {
        struct proc *p;

        p = allocproc();
        initproc = p;
        
        // 申请一页，将initcode的指令和数据放进去
        // allocate one user page and copy initcode's instructions
        // and data into it.
        uvmfirst(p->pagetable, initcode, sizeof(initcode));
        p->sz = PGSIZE;

        //为内核态到用户态的转变做准备
        // prepare for the very first "return" from kernel to user.
        /*
        Trap Frame是指中断、自陷、异常进入内核后,在堆栈上形成的一种数据结构
        */
        p->trapframe->epc = 0;      // user program counter
        p->trapframe->sp = PGSIZE;  // user stack pointer

        // 修改进程名
        safestrcpy(p->name, "initcode", sizeof(p->name));
        p->cwd = namei("/");

        //这个也许是为了能被优先调度
        p->state = RUNNABLE;

        release(&p->lock);
      }
      -
      int
      wait(uint64 addr)
      {
        struct proc *np;
        int havekids, pid;
        struct proc *p = myproc();

        // hold p->lock for the whole time to avoid lost
        // wakeups from a child's exit().
        acquire(&p->lock);

        for(;;){
          // Scan through table looking for exited children.
          havekids = 0;
          for(np = proc; np < &proc[NPROC]; np++){
            // this code uses np->parent without holding np->lock.
            // acquiring the lock first would cause a deadlock,
            // since np might be an ancestor, and we already hold p->lock.
            // 下面的第一点其实一句话就可以搞定：
            // 【它违反了先获取父亲锁，再获取子锁的xv6代码规定】
            // 1.要是在这句话之前acquire的话，acquire到你爸，你爸这时候也刚好执行到这句话
            // 那么就会造成你在自旋【此时你爸在wait一开始就得到了锁】，
            // 你爸也在自旋【你也在wait一开始得到了锁】,这样就造成了死锁
            // 2.并且由于np->parent只有parent才能改，所以数据是否过时是没关系的
            // 因为如果不是你儿子，数据过时与否都知道不是你儿子
            // 如果是你儿子，那数据压根就不会过时
            if(np->parent == p){
              // np->parent can't change between the check and the acquire()
              // because only the parent changes it, and we're the parent.
              acquire(&np->lock);
              havekids = 1;
              if(np->state == ZOMBIE){
                // Found one.
                pid = np->pid;
                // 传递返回参数
                if(addr != 0 && copyout(p->pagetable, addr, (char *)&np->xstate,
                                        sizeof(np->xstate)) < 0) {
                  release(&np->lock);
                  release(&p->lock);
                  return -1;
                }
                freeproc(np);
                release(&np->lock);
                release(&p->lock);
                return pid;
              }
              release(&np->lock);
            }
          }

          // No point waiting if we don't have any children.
          if(!havekids || p->killed){
            release(&p->lock);
            return -1;
          }

          // Wait for a child to exit.
          // 暂时释放p锁，等待子进程获取退出
          sleep(p, &p->lock);  //DOC: wait-sleep
        }
      }
      +
      initcode.S

      以上程序都位于kernel/下。这个位于user/下。

      +

      它调用exec系统调用进入了内核态。当exec完成后，它就跳转到了用户态user/init.c中。【这里估计又用了修改返回地址的trick】

      +
      .globl start
      start:
              la a0, init
              la a1, argv
              li a7, SYS_exec
              ecall
      # char init[] = "/init\0";
      init:
        .string "/init\0"

      # char *argv[] = { init, 0 };
      .p2align 2
      argv:
        .long init
        .long 0
      -

      其中值得注意的几个点：

      +
      init.c

      在init.c中，创建了console设备文件，打开了012文件描述符，并且fork了一个子进程，开始执行shell。这样一来，操作系统就完成了全部的启动。

      +

      感想

      +

      我的疑点有三个：

        -

      1. wait中的sleep中释放的条件锁是等待进程的p->lock，这是上面提到的特例。

        +

      2. 见start.c

        3. -

      3. exit会将自己的所有子进程交付给一直在等待着的init进程：

        -
        for(;;){
          printf("init: starting sh\n");
          pid = fork();
          // ...
          for(;;){
            // this call to wait() returns if the shell exits,
            // or if a parentless process exits.
            wpid = wait((int *) 0);
            if(wpid == pid){
              // the shell exited; restart it.
              break;
            } else if(wpid < 0){
              printf("init: wait returned an error\n");
              exit(1);
            } else {
              // 这里！！
              // it was a parentless process; do nothing.
            }
          }
        }
        +

      4. 是怎么完成从内核态到用户态的切换的？是执行了return就会自动切换吗？userinit中设置了initcode的信息为用户态的，然后就直接能进入用户态，这里感觉有点模糊。

        +

        其实用户态和内核态本质上好像差别不大，似乎也就只有两方面，一个是页表（虚拟地址），另一个就是权限问题了。前者很好说，在main.c中完成了页表初始化，开启了虚拟地址：

        +
        kvminit();       // create kernel page table
        kvminithart();   // turn on paging
        -

        如果子进程退出，就会通过init的wait释放它们。然后init释放完它们后进入第三个if分支，继续进行循环。

        +

        后者的话，从用户态切到内核态使用ecall指令，从machine mode到内核态需要修改mstatus寄存器并且使用mret指令：

        +
        // set M Previous Privilege mode to Supervisor, for mret.
        unsigned long x = r_mstatus();
        x &= ~MSTATUS_MPP_MASK;
        x |= MSTATUS_MPP_S;
        w_mstatus(x);
        ...
        // switch to supervisor mode and jump to main().
        asm volatile("mret");
        + +

        因而从内核态切换到用户态应该也是需要类似这段对mstatus寄存器的修改的，并且其对应修改的是sstatus寄存器。

        +

        但是，我只在普通的用户态-trap入内核态-用户态这个过程的usertrapret中看到对sstatus寄存器的写入，并没有在init的时候对这个玩意进行写入。

        +

        所以，最后，我初步猜测，是会在scheduler()中的上下文切换中修改sstatus寄存器的内容为user mode，从而实现由内核态向用户态进程（initcode）的切换。不过这也仅仅是【猜想】，因为我并没有在switch的汇编代码中看到对sstatus的修改。真是令人麻木。。。

        5. -

      5. wakeup1

        -
        -

        Exit calls a specialized wakeup function, wakeup1, that wakes up only the parent, and only if it is sleeping in wait.

        -
        -
        // Wake up p if it is sleeping in wait(); used by exit().
        // Caller must hold p->lock.
        static void
        wakeup1(struct proc *p)
        {
          if(!holding(&p->lock))
            panic("wakeup1");
          if(p->chan == p && p->state == SLEEPING) {
            p->state = RUNNABLE;
          }
        }
      -

      kill

      kill其实做得很温和。它只是会把想鲨的进程的p->killed设置为1，然后如果该进程sleeping，则唤醒它。最后的死亡以及销毁由进程自己来做。

      -
      // Kill the process with the given pid.
      // The victim won't exit until it tries to go
      // to kernel space (see usertrap() in trap.c).
      int
      kill(int pid)
      {
        struct proc *p;

        for(p = proc; p < &proc[NPROC]; p++){
          acquire(&p->lock);
          if(p->pid == pid){
            p->killed = 1;
            if(p->state == SLEEPING){
              // Wake process from sleep().
              p->state = RUNNABLE;
            }
            release(&p->lock);
            return 0;
          }
          release(&p->lock);
        }
        return -1;
      }
      // in trap.c usertrap()
        if(p->killed)
          exit(-1);
      - -

      可能这里有一个疑问：调用完exit后，进程会变成ZOMBIE态。谁最终把它释放了呢？其实答案很简单，只有两种：init进程或者是创建它的父进程。

      -

      如果创建它的父进程处于wait中，那么是由父进程把它销毁的，这没什么好说的。但如果创建它的父进程不在wait呢？那么父进程最后也是会调用exit的。父进程调用完exit后，会将其所有子进程过继给init进程。所以，ZOMBIE进程最终还是会迟早被init进程杀死的。

      -

      由这里，可以窥见xv6进程管理的进一步的冰山一角：

      -

      init进程是所有进程的根系进程。它一直处于wait的死循环中，因而可以将需要被杀死的进程杀死。

      -

      可见，wait和exit，实际上就构筑了进程的生命周期的最后一环。

      -

      这种巧妙地将进程生命周期这个大事完全托付给了wait和exit这两个函数的这种结构，实在是非常精妙，太牛了吧。

      -
      -

      一些XV6的sleep循环不检查p->killed，因为代码在应该是原子操作的多步系统调用的中间。virtio驱动程序（*kernel/virtio_disk.c*:242）就是一个例子：它不检查p->killed，因为一个磁盘操作可能是文件系统保持正确状态所需的一组写入操作之一。等待磁盘I/O时被杀死的进程将不会退出，直到它完成当前系统调用并且usertrap看到killed标志

      -
      -
      -

      Xv6对kill的支持并不完全令人满意：有一些sleep循环可能应该检查p->killed。一个相关的问题是，即使对于检查p->killed的sleep循环，sleep和kill之间也存在竞争；后者可能会设置p->killed，并试图在受害者的循环检查p->killed之后但在调用sleep之前尝试唤醒受害者。如果出现此问题，受害者将不会注意到p->killed，直到其等待的条件发生。这可能比正常情况要晚一点（例如，当virtio驱动程序返回受害者正在等待的磁盘块时）或永远不会发生（例如，如果受害者正在等待来自控制台的输入，但用户没有键入任何输入）。

      -
      -

      是的，所以这个kill的实现其实是相当玄学的。

      -

      Real world

      -

      xv6调度器实现了一个简单的调度策略：它依次运行每个进程。这一策略被称为轮询调度（round robin）。真实的操作系统实施更复杂的策略，例如，允许进程具有优先级。

      -
      -

      我记得linux0.11用的是时间片轮转+优先级队列完美融合的方法，是真的很牛逼

      -
      -

      复杂的策略可能会导致意外的交互，例如优先级反转（priority inversion）和航队（convoys）。当低优先级进程和高优先级进程共享一个锁时，可能会发生优先级反转，当低优先级进程持有该锁时，可能会阻止高优先级进程前进。当许多高优先级进程正在等待一个获得共享锁的低优先级进程时，可能会形成一个长的等待进程航队；一旦航队形成，它可以持续很长时间。为了避免此类问题，在复杂的调度器中需要额外的机制。

      +

      步骤十分直接且有理由：

      +

      加载操作系统——为了能执行C语言需要一个栈，所以得执行造一个的代码，然后再进入C语言zone——做点machine mode才能做的事，然后从machine mode切换到内核态——做点内核态才能做的事，从内核态切换到用户态

      +

      linux0.11

      bootsect -> setup -> head.s ->main.c

      +

      加载操作系统

      系统加电，启动BIOS初始化硬件 -> BIOS从引导扇区将加载程序读入内存 -> 加载程序将操作系统镜像读入内存RAM。

      +

      其中，第二三步做进一步的细化。

      +
      读入bootsect.s

      加载程序的512个字节被读入到内存从0x7c00开始的一段内存中，并且BIOS设置CS=07c0,ip=0，开始执行加载程序的每一条指令。

      +
      bootsect.s

      加载程序的代码为bootsect.s。在bootsect.s中，首先将自身从7c00处移动到了9000处【留下空间放操作系统】，然后分别依次读取磁盘的setup和system模块，最后bootsect将控制权转交给setup。

      +
      setup.s

      setup首先获取操作系统运行的必要硬件参数。

      +

      image-20230108011824655

      +

      再然后，将system代码移到0地址。然后，我们就需要进入system代码块。

      +

      image-20230108012316631

      +

      最后一句jmpi指令本来应该是要跳到system代码段首0地址处的的，可此处却跳到了80处，这显然不合理。但它写的肯定是没错的。之所以会有这样的矛盾，是因为setup在此之前，还做了一件事情：改变寻址方式。jmpi上面的那条mov指令便做了这点。

      +

      我们之前的寻址方式一直是cs<<4+ip。但是这东西只能是16位的内存，无法满足寻址需求。故而setup要从16位切换到32位。32位模式也叫保护模式。

      -

      在wakeup中扫描整个进程列表以查找具有匹配chan的进程效率低下。一个更好的解决方案是用一个数据结构替换sleep和wakeup中的chan，该数据结构包含在该结构上休眠的进程列表，例如Linux的等待队列。

      +

      至于怎么切的呢？要注意到一点，改变寻址方式也即改变cs和ip的地址计算方法，也即换一条硬件电路实现。计算机给我们提供了一个简单的方式操纵保护模式的转变，即修改cr0寄存器的内容。

      -

      是的，linux的那个wakeup真的很牛，我现在都还记得当初学到那的时候的震撼。

      +

      在保护模式下，寻址方式发生了改变。此时cs不再代表基址，而是表示地址在gdb表global description table中的偏移下标。真正的基址放在表项中。cs被称为selector，从表中取得基址，再和ip加在一起得到地址。

      -

      wakeup的实现会唤醒在特定通道上等待的所有进程，可能有许多进程在等待该特定通道。操作系统将安排所有这些进程，它们将竞相检查睡眠条件。进程的这种行为有时被称为惊群效应（thundering herd），最好避免。

      -

      大多数条件变量都有两个用于唤醒的原语：signal用于唤醒一个进程；broadcast用于唤醒所有等待进程。

      +

      gdt表的内容由setup初始化

      +

      image-20230108013156116

      -
      -

      一个实际的操作系统将在固定时间内使用空闲列表找到自由的proc结构体，而不是allocproc中的线性时间搜索；xv6使用线性扫描是为了简单起见。

      +

      这样一来，就正确跳到了system模块。

      +

      操作系统初始化

      head.s

      跳到system第一个文件，也就是head.s去执行。

      +

      head.s也是在保护模式下进行的，是在保护模式下的初始化。

      +

      head.s建立了真正的gdt表，然后就要跳转到main.c执行初始化和Shell的启动。此处有汇编语言和C语言的转化，也就是push参数然后push main的地址。

      +
      main.c

      对各种东西的初始化。

      +

      image-20230108013849664

      +

      最后完成从内核态到用户态的切换。

      +

      感想

      +

      linux0.11的启动的具体思路是：

      +

      加载操作系统，获取硬件参数，进入保护模式，跳转到操作系统第一行代码——操作系统初始化，切换到用户态

      +

      linux0.11相比于xv6更加复杂，上课的时候隐藏了很多实现细节但依旧理解很费劲（。

      +

      这两个步骤思路其实都是差不多的，区别在于linux0.11好像没有machine mode这个概念。感觉也不能锐评什么，因为看完了感觉两个都很有道理，两个都一样很难懂（。

      +

      【注：为什么没有machine mode呢？是因为这个mode的划分是RISC-V架构做的，而linux0.11是基于X86架构。】

      +

      不过linux0.11这里进入保护模式后改变寻址方式是因为机器问题（好像是），xv6难道也是因为硬件问题吗？因为一开始的时候操作系统还未进行内存分页页表初始化，所以用不了地址映射？有待学习。

      +

      关于保护模式，可以看看这篇文章，今天太晚了先睡了：

      +

      Linux从头学08：Linux 是如何保护内核代码的？【从实模式到保护模式】

      -

      Lab: Multithreading

      -

      You will implement switching between threads in a user-level threads package, use multiple threads to speed up a program, and implement a barrier.

      +

      Real world

      现实中，大多数操作系统都会兼顾宏内核与微内核。

      +

      大多数操作系统都支持与xv6类似的process进程概念，也有很多系统还支持线程概念。

      +

      Lab system calls

      +

      To start the lab, switch to the syscall branch:

      +
      $ git fetch
      $ git checkout syscall
      $ make clean
      -

      这个introduction看起来还是非常激动人心的，很早就想了解到底线程是怎么实现的了。不过做完发现思想还是很简单的，就是只用切换上下文和栈就行。可以看看提供给的代码。

      -

      Uthread: switching between threads

      -

      In this exercise you will design the context switch mechanism for a user-level threading system, and then implement it.

      -

      To get you started, your xv6 has two files user/uthread.c and user/uthread_switch.S, and a rule in the Makefile to build a uthread program.

      -

      uthread.c contains most of a user-level threading package, and code for three simple test threads. The threading package is missing some of the code to create a thread and to switch between threads.

      -

      You will need to add code to thread_create() and thread_schedule() in user/uthread.c, and thread_switch in user/uthread_switch.S.

      -

      One goal is ensure that when thread_schedule() runs a given thread for the first time, the thread executes the function passed to thread_create(), on its own stack.

      -

      Another goal is to ensure that thread_switch saves the registers of the thread being switched away from, restores the registers of the thread being switched to, and returns to the point in the latter thread’s instructions where it last left off. You will have to decide where to save/restore registers; modifying struct thread to hold registers is a good plan.

      -

      You’ll need to add a call to thread_switch in thread_schedule; you can pass whatever arguments you need to thread_switch, but the intent is to switch from thread t to next_thread.

      +

      trace

      +

      In this assignment you will add a system call tracing feature that may help you when debugging later labs.

      +

      You’ll create a new trace system call that will control tracing. It should take one argument, an integer “mask”, whose bits specify which system calls to trace.

      +

      For example, to trace the fork system call, a program calls trace(1 << SYS_fork). You have to modify the xv6 kernel to print out a line when each system call is about to return. The line should contain the process id, the name of the system call and the return value; you don’t need to print the system call arguments.

      +

      The trace system call should enable tracing for the process that calls it and any children that it subsequently forks, but should not affect other processes.

      -

      感想

      思路

      看了一遍它这里面写的题目还是有点抽象的，需要结合着给的代码看，那样就清晰多了。

      -

      首先，要补全的地方有这几个：

      -
      // 1. in thread_schedule()
        if (current_thread != next_thread) {         /* switch threads?  */
          next_thread->state = RUNNING;
          t = current_thread;
          current_thread = next_thread;
          /* YOUR CODE HERE
           * Invoke thread_switch to switch from t to next_thread:
           * thread_switch(??, ??);
           */
        } else
          next_thread = 0;
      // 2. in thread_create()
      void
      thread_create(void (*func)())
      {
        struct thread *t;

        for (t = all_thread; t < all_thread + MAX_THREAD; t++) {
          if (t->state == FREE) break;
        }
        t->state = RUNNABLE;
        // YOUR CODE HERE
      }
      // 3. in uthread_switch.S
              /*
               * save the old thread's registers,
               * restore the new thread's registers.
               */

              .globl thread_switch
      thread_switch:
              /* YOUR CODE HERE */
              ret    /* return to ra */
      +

      感想

      一开始为了把trace做得封装性良好一些尽量不改别的代码，想了好久好久，最后就只能想出，在syscall.c获取系统调用返回值处加个条件打印，在trace中维护一个map，映射进程pid和进程当前的mask，并且给外界提供查询当前进程是否对某个系统调用有mask作为syscall条件打印的接口。

      +

      这个最后还是失败了，失败的点在于不知道要创建多大的数组来作为map映射所有进程，因为pid分配估计是递增的，是会超过最大进程数的，所以pid会是多少是不确定的。还有一点就是fork之后子进程不能自动继承父进程的mask，还得手动调用一下trace，这更加不封装了（。

      +

      总之先放上我原来的代码吧。

      +
      // in kernel/syscall.c
      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "riscv.h"
      #include "spinlock.h"
      #include "proc.h"
      #include "syscall.h"
      #include "defs.h"

      //...

      void strcpy(char* buf,const char* tmp){
       int i=0;
        while((*tmp)!='\0'){
          buf[i++] = *tmp;
          tmp++;
        }  
        buf[i] = '\0';

      }

      void getname(int callid,char* buf){
        switch(callid){
          case SYS_fork: strcpy(buf,"fork"); break;
          case SYS_exit: strcpy(buf,"exit"); break;
          case SYS_wait: strcpy(buf,"wait"); break;
          case SYS_pipe: strcpy(buf,"pipe"); break;
          case SYS_read: strcpy(buf,"read"); break;
          case SYS_kill: strcpy(buf,"kill"); break;
          case SYS_exec: strcpy(buf,"exec"); break;
          case SYS_fstat: strcpy(buf,"fstat"); break;
          case SYS_chdir: strcpy(buf,"chdir"); break;
          case SYS_dup: strcpy(buf,"dup"); break;
          case SYS_getpid: strcpy(buf,"getpid"); break;
          case SYS_sbrk: strcpy(buf,"sbrk"); break;
          case SYS_sleep: strcpy(buf,"sleep"); break;
          case SYS_uptime: strcpy(buf,"uptime"); break;
          case SYS_open: strcpy(buf,"open"); break;
          case SYS_write: strcpy(buf,"write"); break;
          case SYS_mknod: strcpy(buf,"mknod"); break;
          case SYS_unlink: strcpy(buf,"unlink"); break;
          case SYS_link: strcpy(buf,"link"); break;
          case SYS_mkdir: strcpy(buf,"mkdir"); break;
          case SYS_close: strcpy(buf,"close"); break;
          case SYS_trace: strcpy(buf,"trace"); break;
          default: return;
        }
      }

      void
      syscall(void)
      {
        int num;
        struct proc *p = myproc();

        num = p->trapframe->a7;
        if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
          p->trapframe->a0 = syscalls[num]();
          char buf[32];
          getname(num,buf);
          // 在此处添加条件打印
          if(istraced(num))
          	printf("syscall %s -> %d\n",buf,p->trapframe->a0);
        } else {
          printf("%d %s: unknown sys call %d\n",
                  p->pid, p->name, num);
          p->trapframe->a0 = -1;
        }
      }
      -

      这几个函数到时候会被如此调用：

      -
      int
      main(int argc, char *argv[])
      {
        a_started = b_started = c_started = 0;
        a_n = b_n = c_n = 0;
        thread_init();
        thread_create(thread_a);
        thread_create(thread_b);
        thread_create(thread_c);
        thread_schedule();
        exit(0);
      }
      +
      // in kernel/trace.c
      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "riscv.h"
      #include "spinlock.h"
      #include "proc.h"
      #include "defs.h"
      #include "elf.h"

      int m_mask[NPROC];

      int
      trace(int mask){
          struct proc *p = myproc();
          m_mask[p->pid] = mask;
          return 1;    
      }

      //提供给外界查询的接口
      int
      istraced(int callid){
          struct proc *p = myproc();
          //printf("from trace ,pid = %d\n",p->pid);
          if(((m_mask[p->pid] >> callid) & 1) == 1){
      	return 1;
          } else{
          	return 0;
          }
      }
      -

      所以，我们在第一个地方要做的，就是要填入swtch的签名。第二个地方要做的，就是要想办法让该线程一被启动就去执行参数的函数指针。第三个地方要做的，就是要完成上下文的切换。

      -

      所以思路其实是很直观的。我们可以模仿进程管理中用来表示上下文的context，在thread_create的时候把里面的ra设置为参数的函数指针入口，sp修改为thread结构体中的栈地址。swtch函数则完全把kernel/swtch.S超过来就行。

      -
      -

      在这个思路中，我们是怎么做到栈的切换的呢？

      -

      每个线程在thread_create的时候，都将自己的context中的sp修改为自己的栈地址。这样一来，在它们被调度的时候，switch会自然而然地从context中读取sp作为之后运行的sp，这样就实现了栈的切换。

      -
      -
      坑

      我觉得其他方面都不难，最坑最细节的【也是我完全没有想到的……】就是这里：

      -
      // 修改sp为栈顶
      t->context.sp = (uint64)t->stack + STACK_SIZE;
      +

      下面是按照hints修改后的正确代码。

      +

      代码步骤

      实际上，标答跟我的思路差不多，只不过它没有像我一样创建数组作为map，而是在proc结构体里添加了一个属性，这本质上也是利用了map。

      +
      在各种文件添加签名
      user/user.h
      user/usys.pl
      syscall.h

      添加系统调用号

      +
      syscall.c

      添加系统调用号和sys_trace映射

      +
      修改Makefile
        +
      1. 在第一个OBJS添加trace.o
        2. +
      2. 在UPROGS添加user中的trace
        3. +
      +
      代码
      修改proc.h
      // Per-process state
      struct proc {
        // ...
        int mask; //记录trace的mask
      };
      -

      需要注意，栈顶并不是t->stack。

      -

      通过测试程序：

      -
      int main(){
      	int a[5]={1,2,3,4,5};
      	for(int i=0;i<5;i++){
      		printf("%p\n",&a[i]);
      	}
      	return 0;
      }
      0062feb8
      0062febc
      0062fec0
      0062fec4
      0062fec8
      +
      编写trace.c
      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "riscv.h"
      #include "spinlock.h"
      #include "proc.h"
      #include "defs.h"
      #include "elf.h"

      int
      trace(int mask){
          struct proc *p = myproc();
          p->mask = mask;
          return 1;    
      }

      int
      istraced(int callid){
          struct proc *p = myproc();
          if(((p->mask >> callid) & 1) == 1){
      	return 1;
          } else{
          	return 0;
          }
      }
      -

      栈是向下增长的，因而，栈顶确实应该是数组的末尾……

      -

      这里完全没有想到，还是吃了基础的亏啊。

      -
      -

      如果这里将t->stack作为sp，那么运行时会出现非常诡异的现象（打印的是abc三个的thread->state）：

      -

      image-20230120232149776

      -

      仅有c【经测试，是仅有最后一个启动的线程】在执行，而ab的state都不是理想中的2，而是很奇怪的值。我确实有想过栈溢出问题，但是马上被我否定了。我完全没有想到是那样错的【悲】

      +
      修改syscall.c
      // in kernel/syscall.c
      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "riscv.h"
      #include "spinlock.h"
      #include "proc.h"
      #include "syscall.h"
      #include "defs.h"

      //...

      void strcpy(char* buf,const char* tmp){
       int i=0;
        while((*tmp)!='\0'){
          buf[i++] = *tmp;
          tmp++;
        }  
        buf[i] = '\0';

      }

      void getname(int callid,char* buf){
        switch(callid){
          case SYS_fork: strcpy(buf,"fork"); break;
          case SYS_exit: strcpy(buf,"exit"); break;
          case SYS_wait: strcpy(buf,"wait"); break;
          case SYS_pipe: strcpy(buf,"pipe"); break;
          case SYS_read: strcpy(buf,"read"); break;
          case SYS_kill: strcpy(buf,"kill"); break;
          case SYS_exec: strcpy(buf,"exec"); break;
          case SYS_fstat: strcpy(buf,"fstat"); break;
          case SYS_chdir: strcpy(buf,"chdir"); break;
          case SYS_dup: strcpy(buf,"dup"); break;
          case SYS_getpid: strcpy(buf,"getpid"); break;
          case SYS_sbrk: strcpy(buf,"sbrk"); break;
          case SYS_sleep: strcpy(buf,"sleep"); break;
          case SYS_uptime: strcpy(buf,"uptime"); break;
          case SYS_open: strcpy(buf,"open"); break;
          case SYS_write: strcpy(buf,"write"); break;
          case SYS_mknod: strcpy(buf,"mknod"); break;
          case SYS_unlink: strcpy(buf,"unlink"); break;
          case SYS_link: strcpy(buf,"link"); break;
          case SYS_mkdir: strcpy(buf,"mkdir"); break;
          case SYS_close: strcpy(buf,"close"); break;
          case SYS_trace: strcpy(buf,"trace"); break;
          default: return;
        }
      }

      void
      syscall(void)
      {
        int num;
        struct proc *p = myproc();

        num = p->trapframe->a7;
        if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
          p->trapframe->a0 = syscalls[num]();
          char buf[32];
          getname(num,buf);
          // 在此处添加条件打印
          if(istraced(num))
          	printf("syscall %s -> %d\n",buf,p->trapframe->a0);
        } else {
          printf("%d %s: unknown sys call %d\n",
                  p->pid, p->name, num);
          p->trapframe->a0 = -1;
        }
      }
      + +
      在sysproc.c中添加系统调用
      uint64
      sys_trace(void)
      {
        int mask;
        if(argint(0,&mask)<0)
          return -1;
        trace(mask);
        return 0;
      }
      + +
      修改fork

      继承父进程的mask

      +
      np->mask = p->mask;
      + +
      在defs.h中添加需要public的函数签名
      // trace.c
      int		trace(int);
      int		istraced(int);
      + +

      sysinfotest

      +

      In this assignment you will add a system call, sysinfo, that collects information about the running system.

      +

      The system call takes one argument: a pointer to a struct sysinfo (see kernel/sysinfo.h).

      +

      The kernel should fill out the fields of this struct: the freemem field should be set to the number of bytes of free memory, and the nproc field should be set to the number of processes whose state is not UNUSED.

      +

      We provide a test program sysinfotest; you pass this assignment if it prints “sysinfotest: OK”.

      -

      代码

      增加context结构体定义，修改thread结构体
      struct context {
        uint64 ra;
        uint64 sp;

        // callee-saved
        uint64 s0;
        uint64 s1;
        uint64 s2;
        uint64 s3;
        uint64 s4;
        uint64 s5;
        uint64 s6;
        uint64 s7;
        uint64 s8;
        uint64 s9;
        uint64 s10;
        uint64 s11;
      };


      struct thread {
        char       stack[STACK_SIZE]; /* the thread's stack */
        int        state;             /* FREE, RUNNING, RUNNABLE */
        struct context context;
      };
      +
      // kernel/sysinfo.h
      struct sysinfo {
        uint64 freemem;   // amount of free memory (bytes)
        uint64 nproc;     // number of process
      };
      + +

      感想

      代码

      系统调用要做的事情同上。

      +

      有一个我在hit实验没想到，在这里依然没有想到的点是，参数的指针来自用户空间，所以不能直接对其指向的空间进行写入，需要借助copyout函数。

      +

      还有一件事，就是不知道该怎么统计free mem的数量，后来在hints提示下才知道要去kalloc.c中找。【之前只找过了vm.c】这里其实是很后悔提前看了提示的。我应该先去看一下上面关于kernel各个文件用途的笔记，再去继续自己找的，不能太过依赖提示。

      +

      还有一点做的不好的地方是，标答是选择了将两个计数函数放在各自的文件中，我是选择直接将成员变量在头文件中extern 公开出来，比如说在proc.h中这么写：

      +
      extern struct proc proc[NPROC];
      -
      修改thread_create
      void
      thread_create(void (*func)())
      {
        struct thread *t;

        for (t = all_thread; t < all_thread + MAX_THREAD; t++) {
          if (t->state == FREE) break;
        }
        t->state = RUNNABLE;
        // YOUR CODE HERE
        // 将当前上下文保存入context
        thread_switch((uint64)(&(t->context)),(uint64)(&(t->context)));
        // 修改sp为栈顶
        t->context.sp = (uint64)t->stack + STACK_SIZE;
        // 修改ra为参数的函数指针入口
        t->context.ra = (uint64)func;
      }
      +

      hints采取了比我封装性更好的操作，这也是非常顺理成章的，我没有想到这样真是有点惭愧（。

      +

      总而言之，这个还是挺简单的，就是我很后悔我心浮气躁看了提示，要不然收获会更多。

      +
      sysinfo.c
      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "riscv.h"
      #include "spinlock.h"
      #include "proc.h"
      #include "defs.h"
      #include "elf.h"
      #include "sysinfo.h"

      int 
      sysinfo(struct sysinfo* info){
        struct sysinfo res;
        res.nproc = countproc();
        res.freemem = countfree();
        struct proc *p = myproc();
        if(copyout(p->pagetable, (uint64)info,(char *)(&res), sizeof(res)) != 0)
          return -1;
        return 1;
      }
      -
      修改thread_schedule
      if (current_thread != next_thread) {         /* switch threads?  */
        next_thread->state = RUNNING;
        t = current_thread;
        current_thread = next_thread;
        /* YOUR CODE HERE
         * Invoke thread_switch to switch from t to next_thread:
         * thread_switch(??, ??);
         */
        thread_switch((uint64)(&(t->context)),(uint64)(&(current_thread->context)));
      } else
        next_thread = 0;
      +
      sysproc.c中
      uint64
      sys_sysinfo(void){
        uint64 addr;
        if(argaddr(0, &addr) < 0)
          return -1;
        return sysinfo((struct sysinfo*)addr);
      }
      -
      修改thread_switch

      全部照搬kernel/swtch.S，没什么好说的

      -

      Using threads

      一步步细粒度化，最后，每个桶用单独一把锁，仅在调用insert处加锁就行。

      -
      pthread_mutex_t locks[NBUCKET];// 在main中初始化

      static
      void put(int key, int value)
      {
        int i = key % NBUCKET;

        // is the key already present?
        struct entry *e = 0;
        for (e = table[i]; e != 0; e = e->next) {
          if (e->key == key)
            break;
        }
        if(e){
          // update the existing key.
          e->value = value;
        } else {
          // the new is new.
          pthread_mutex_lock(&locks[i]);
          insert(key, value, &table[i], table[i]);
          pthread_mutex_unlock(&locks[i]);
        }
      }
      +
      kalloc.c中
      // 采用的是链表结构，run代表一页
      struct run {
        struct run *next;
      };

      struct {
        struct spinlock lock;
        // 指向第一个空闲页
        struct run *freelist;
      } kmem;

      int 
      countfree(){
        int npage = 0;
        struct run* r = kmem.freelist;
        while(r){
          r = r->next;
          npage++;
        }
        return npage*PGSIZE;
      }
      -

      Barrier

      -

      In this assignment you’ll implement a barrier: a point in an application at which all participating threads must wait until all other participating threads reach that point too.

      +
      proc.c中
      struct proc proc[NPROC];
      int
      countproc(){
        int nproc = 0;
        for(int i=0;i<NPROC;i++){
            if(proc[i].state != UNUSED){
      	  nproc++;
            }
        }
        return nproc;
      }
      + +

      附加题

      trace plus
      +

      Print the system call arguments for traced system calls.

      -

      直接上代码，还是比较简单的

      -
      static void
      barrier()
      {
        // YOUR CODE HERE
        //
        // Block until all threads have called barrier() and
        // then increment bstate.round.
        //
         pthread_mutex_lock(&(bstate.barrier_mutex));
         bstate.nthread++;
         while(bstate.nthread < nthread){
          pthread_cond_wait(&(bstate.barrier_cond), &(bstate.barrier_mutex));
          goto end;
         }
         // 此部分仅一个线程会进入
         pthread_cond_broadcast(&(bstate.barrier_cond));
         bstate.nthread = 0;
         bstate.round++;
      end:
         pthread_mutex_unlock(&(bstate.barrier_mutex));
      }
      +

      这个实现起来要说简单也简单，麻烦也麻烦。这里就先摆了【实际上尝试了半小时发现太烦了看别人写的也不大满意就放弃了】

      +
      sysinfo plus
      +

      Compute the load average and export it through sysinfo

      +
      +

      说实话没太看懂，不就加个 running process/ncpu就行了吗？

      ]]> - Page tables - /2023/01/10/xv6$chap3/ - Page tables

      Paging hardware

      为什么需要页表

      将主存储器以及各种外设接口卡里面内置的存储器连接起来，就形成了内存地址空间。内存地址空间中的地址是真实的物理地址。RISC-V架构的指令使用的地址是虚拟地址。为了通过指令中的虚拟地址访问到真实的物理内存，需要进行从虚拟地址到物理地址的转换。从虚拟地址到物理地址的转换，就需要通过页表来实现。

      -

      页表如何运作

      在RISC-V指令集中，当我们需要开启页表服务时，我们需要将我们预先配置好的页表首地址放入 satp 寄存器中。从此之后， 计算机硬件 将把访存的地址 均视为虚拟地址 ，都需要通过硬件查询页表，将其 翻译成为物理地址 ，然后将其作为地址发送给内存进行访存。

      -

      xv6采用的指令集标准为RISC-V标准，其中页表的标准为SV39标准，也就是虚拟地址最多为39位。

      -

      虚实地址翻译流程：

      -
        -
      1. 获得一个虚拟地址。根页表基地址已经被装填至寄存器 satp 中。
        2. -
      2. 通过 satp 找到根页表的物理页帧号，转成物理地址（Offset为0），通过虚拟地址的L2索引，找到对应的页表项。
        3. -
      3. 通过页表项可以找到找到 次页表 的物理页帧号，转成物理地址（Offset为0），通过虚拟地址的L1索引，找到对应的页表项。
        4. -
      4. 通过页表项可以找到找到 叶子页表 的物理页帧号，转成物理地址（Offset为0），通过虚拟地址的L0索引，找到对应的页表项。
        5. -
      5. 通过页表项可以找到找到 物理地址 的物理页帧号，通过虚拟地址的Offset，转成物理地址（Offset和虚拟地址Offset相同）。
        6. -
      -

      页表组成

      页表项

      页表由页表项PTE（Page Table Entries）构成，每个页表项由44位的PPN（Physical Page Number）和一些参数flag组成。

      -

      image-20230109153937459

      -
      -

      Each PTE contains flflag bits that tell the paging hardware how the associated virtual address is allowed to be used. PTE_V indicates whether the PTE is present: if it is not set, a reference to the page causes an exception (i.e. is not allowed). PTE_R controls whether instructions are allowed to read to the page. PTE_W controls whether instructions are allowed to write to the page. PTE_X controls whether the CPU may interpret the content of the page as instructions and execute them. PTE_U controls whether instructions in user mode are allowed to access the page; if PTE_U is not set, the PTE can be used only in supervisor mode.

      -

      这个表项的几个参数定义在kernel/riscv.h中的341行左右。

      + Locking + /2023/01/10/xv6$chap6/ + Locking

      很多概念在看Java并发的时候都学习过，这些重复的地方就不做赘述了。

      +

      Code: spinlock

      +

      spinlock 使用介绍

      +

      一、spinlock 简介
      自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，不断尝试获取锁，直到获取到锁才会退出循环

      +

      二、自旋锁与互斥锁的区别
      自旋锁与互斥锁类似，它们都是为了解决对某项资源的互斥使用，在任何时刻最多只能有一个线程获得锁
      对于互斥锁，如果资源已经被占用，调用者将进入睡眠状态
      对于自旋锁，如果资源已经被占用，调用者就一直循环在那里，看是否自旋锁的保持者已经释放了锁

      +

      三、自旋锁的优缺点
      自旋锁不会发生进程切换，不会使进程进入阻塞状态，减少了不必要的上下文切换，执行速度快。非自旋锁在获取不到锁的时候会进入阻塞状态，从而进入内核态，当获取到锁的时候需要从内核态恢复，需要线程上下文切换，影响性能
      如果某个线程持有锁的时间过长，就会导致其它等待获取锁的线程长时间循环等待消耗CPU，造成CPU使用率极高

      -

      虚拟地址有64bit，其中25bits未使用，39bits包含了27位的PTE索引号以及12位的offset。

      -

      物理地址有56位，由PPN和offset拼接组成。

      -

      单页表和多级页表

      以单页表为例，物理地址形成过程如下图所示。

      -

      image

      -

      每个页表项PTE索引着一页。因而，每一页的大小为2^12=4096B。单页表中PTE的索引号有2^27个，因而单页表中表项有134217728个，即可以代表134217728页。页表实际上也是以页的形式存储的。因而单页表需要的存储空间为(2^27x7)/2^12=2^15x7=229376页。

      -

      RISC-V架构中真实情况是会有三级页表。三级页表结构相比于单级页表结构，会占据更多的物理存储空间。

      -

      image-20230109151346780

      -

      每个页表项PTE索引着一页，这一页可能代表着另一个页表，也可能代表着内存中需要的指令和数据。因而，每一页的大小为2^12=4096B。三页表中，一级页表中PTE的索引号有512个，可以代表的物理内存页数有512x515x512=2^27页，即可以代表134217728页。页表实际上也是以页的形式存储的，一个页表有2^9x7个字节，可以存储在1页中。因而三页表需要的存储空间为1+2^9+2^18 = 262657页。

      -

      三级页表结构相比于单级页表结构，可以节省更多内存空间。

      +

      spinlock

      // Mutual exclusion lock.
      struct spinlock {
        uint locked;       // Is the lock held?

        // For debugging:
        char *name;        // Name of lock.
        struct cpu *cpu;   // The cpu holding the lock.
      };
      + +

      acquire

      大概是这么个原理：

      +

      image-20230115231857670

      +

      当然这有竞态条件。xv6用的是CPU提供的amoswap原子指令来消除竞态条件的。

      +
      // in kernel/spinlock.c
      // Acquire the lock.
      // Loops (spins) until the lock is acquired.
      void
      acquire(struct spinlock *lk)
      {
        // 关中断
        // xv6允许禁止中断。但是由于xv6是一个多核系统,单个core被禁止中断并不会影响其他core。
        push_off(); // disable interrupts to avoid deadlock.
        
        // holding(): Check whether this cpu is holding the lock.
        if(holding(lk))
          panic("acquire");

        // On RISC-V, sync_lock_test_and_set turns into an atomic swap:
        //   a5 = 1
        //   s1 = &lk->locked
        //   amoswap.w.aq a5, a5, (s1)
        // amoswap: 交换a5和(s1)的值，返回(s1)原来的值
        // 也即是如图所示的竞态条件的原子指令
        while(__sync_lock_test_and_set(&lk->locked, 1) != 0)
          ;

        __sync_synchronize();

        // Record info about lock acquisition for holding() and debugging.
        lk->cpu = mycpu();
      }
      + +

      __sync_synchronize();

      代码里的官方注释：

      +
      // Tell the C compiler and the processor to not move loads or stores
      // past this point, to ensure that the critical section's memory
      // references happen strictly after the lock is acquired.
      // On RISC-V, this emits a fence instruction.
      + +

      这个注释其实没太看明白。我去翻了一下asm代码，发现这句话正如它最后一句所说的被翻译成fence指令：

      +

      image-20230115231457971

      -

      参考：页表是啥以及为啥多级页表能够节省空间

      +

      处理器中的存储系统（一）：RISC-V的FENCE、FENCE.I指令

      +

      顾名思义,FENCE指令犹如一道屏障,把前面的存储操作和后面的存储操作隔离开来,前面的决不能到后面再执行,后面的决不能先于FENCE前的指令执行。

      -

      考虑到这样一个进程：

      -

      watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1eXVhbmRl,size_16,color_FFFFFF,t_70

      -

      进程使用页表时，需要将整个页表读入内存。

      -

      如果使用单级页表，尽管一个进程仅使用到页表中的某两项，也需要把整个页表都读入内存，光是页表就占据了2^15x7x4k/2^20 约为1G的内存空间。

      -

      如果使用三级页表，一个进程需要用到某两页。假设这两页存储在不同的二级页表中，则只需要读入1+2+2=5页 约为20K的内存空间。

      -

      两者相对比，显然用三级页表比单级页表顶多了。三级页表相较于一级页表，多用了13%的物理空间，却可以节省99.998%的空间。

      -

      页表使用

      每个进程会保留自己的一份用户级别的页表地址。当轮到自己使用CPU时，会将CPU的satp寄存器更换为自己的页表地址。

      -

      Kernel address space

      介绍了xv6中内核的页表结构。

      -
      -

      这里为了方便，就把三级页表省略了，只留下va和pa的对比

      +

      这个就好明白多了。

      +

      这样一来，acquire和release的两个fence就形成了两道屏障：

      +
      acquire();
      l->nexy = list;
      list = l;
      release();
      + +

      中间那部分的指令可以重排，但是中间的指令就绝不会跑到临界区外。

      +

      push_off和pop_off

      +

      当CPU未持有自旋锁时，xv6重新启用中断；它必须做一些记录来处理嵌套的临界区域。acquire调用push_off (*kernel/spinlock.c*:89) 并且release调用pop_off (*kernel/spinlock.c*:100)来跟踪当前CPU上锁的嵌套级别。当计数达到零时，pop_off恢复最外层临界区域开始时存在的中断使能状态。intr_off和intr_on函数执行RISC-V指令分别用来禁用和启用中断。

      -

      每个进程都有一个用户级别的页表。xv6给内核提供了一个单独的内核地址空间的页表。其层级映射关系如下：

      -

      p3

      -

      在kernel/memlayout.h中正记录了这些参数：

      -
      // Physical memory layout

      // qemu -machine virt is set up like this,
      // based on qemu's hw/riscv/virt.c:
      //
      // 00001000 -- boot ROM, provided by qemu
      // 02000000 -- CLINT
      // 0C000000 -- PLIC
      // 10000000 -- uart0 
      // 10001000 -- virtio disk 
      // 80000000 -- boot ROM jumps here in machine mode
      //             -kernel loads the kernel here
      // unused RAM after 80000000.

      // the kernel uses physical memory thus:
      // 80000000 -- entry.S, then kernel text and data
      // end -- start of kernel page allocation area
      // PHYSTOP -- end RAM used by the kernel

      // qemu puts UART registers here in physical memory.
      #define UART0 0x10000000L
      #define UART0_IRQ 10

      // virtio mmio interface
      #define VIRTIO0 0x10001000
      #define VIRTIO0_IRQ 1

      // core local interruptor (CLINT), which contains the timer.
      // ...
      +

      release

      // in kernel/spinlock.c
      // Release the lock.
      void
      release(struct spinlock *lk)
      {
        if(!holding(lk))
          panic("release");

        lk->cpu = 0;

        __sync_synchronize();

        // Release the lock, equivalent to lk->locked = 0.
        // This code doesn't use a C assignment, since the C standard
        // implies that an assignment might be implemented with
        // multiple store instructions.
        // On RISC-V, sync_lock_release turns into an atomic swap:
        //   s1 = &lk->locked
        //   amoswap.w zero, zero, (s1)
        __sync_lock_release(&lk->locked);

        // 开中断
        pop_off();
      }
      -

      由图可知，一直从0x0到0x86400000，都是采取的直接映射的方式，虚拟地址=物理地址，这段是内核使用的空间。在0x0-0x800000000阶段，物理地址代表着各种IO设备的存储器。

      -

      但是注意，在0x86400000（PHYSTOP）以上的地址都不是直接映射，这些非直接映射的层级包含两类：

      -
        -

      1. trampoline

        -
        -

        It is mapped at the top of the virtual address space; user page tables have this same mapping.

        +

        Code: Using locks

        +

        作为粗粒度锁的一个例子，xv6的kalloc.c有一个由单个锁保护的空闲列表。如果不同CPU上的多个进程试图同时分配页面，每个进程在获得锁之前将必须在acquire中自旋等待。自旋会降低性能，因为它只是无用的等待。如果对锁的争夺浪费了很大一部分CPU时间，也许可以通过改变内存分配的设计来提高性能，使其拥有多个空闲列表，每个列表都有自己的锁，以允许真正的并行分配。【很棒的思路】

        +

        作为细粒度锁的一个例子，xv6对每个文件都有一个单独的锁，这样操作不同文件的进程通常可以不需等待彼此的锁而继续进行。文件锁的粒度可以进一步细化，以允许进程同时写入同一个文件的不同区域。最终的锁粒度决策需要由性能测试和复杂性考量来驱动。

        -

        它有一点很特殊的是，它实际对应的物理内存是0x80000000开始的一段。也就是说，0x80000000开始的这段内存，既被直接映射了，也被trampoline通过虚拟地址映射了。它被映射了两次。

        -
        2. -

      2. 内核栈

        -
        -

        Each process has its own kernel stack, which is mapped high so that below it xv6 can leave an unmapped guard page. The guard page’s PTE is invalid (i.e., PTE_V is not set), so that if the kernel overflflows a kernel stack, it will likely cause an exception and the kernel will panic.

        -

        guard page可以用来防止内核栈溢出。

        + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        锁描述
        bcache.lock保护块缓冲区缓存项（block buffer cache entries）的分配
        cons.lock串行化对控制台硬件的访问，避免混合输出
        ftable.lock串行化文件表中文件结构体的分配
        icache.lock保护索引结点缓存项（inode cache entries）的分配
        vdisk_lock串行化对磁盘硬件和DMA描述符队列的访问
        kmem.lock串行化内存分配
        log.lock串行化事务日志操作
        管道的pi->lock串行化每个管道的操作
        pid_lock串行化next_pid的增量
        进程的p->lock串行化进程状态的改变
        tickslock串行化时钟计数操作
        索引结点的 ip->lock串行化索引结点及其内容的操作
        缓冲区的b->lock串行化每个块缓冲区的操作
        +

        Figure 6.3: Locks in xv6

        +

        Deadlock and lock ordering

        +

        如果在内核中执行的代码路径必须同时持有数个锁，那么所有代码路径以相同的顺序获取这些锁是很重要的。如果它们不这样做，就有死锁的风险。假设xv6中的两个代码路径需要锁A和B，但是代码路径1按照先A后B的顺序获取锁，另一个路径按照先B后A的顺序获取锁。为了避免这种死锁，所有代码路径必须以相同的顺序获取锁。全局锁获取顺序的需求意味着锁实际上是每个函数规范的一部分：调用者必须以一种使锁按照约定顺序被获取的方式调用函数。

        +

        由于sleep的工作方式（见第7章），Xv6有许多包含每个进程的锁（每个struct proc中的锁）在内的长度为2的锁顺序链。例如，consoleintr (*kernel/console.c*:138)是处理键入字符的中断例程。当换行符到达时，任何等待控制台输入的进程都应该被唤醒。为此，consoleintr在调用wakeup时持有cons.lock，wakeup获取等待进程的锁以唤醒它。因此，全局避免死锁的锁顺序包括必须在任何进程锁之前获取cons.lock的规则。【这段不怎么能看懂，学完第七章再回来看看】

        +

        文件系统代码包含xv6最长的锁链。例如，创建一个文件需要同时持有目录上的锁、新文件inode上的锁、磁盘块缓冲区上的锁、磁盘驱动程序的vdisk_lock和调用进程的p->lock。为了避免死锁，文件系统代码总是按照前一句中提到的顺序获取锁。

        -
        3. -
      -

      内核使用PTE_R和PTE_X权限映射trampoline和kernel text。这表明这份内存段可以读，可以被当做指令块执行，但不能写。其他的块都是可读可写的，除了guard page被设置为不可访问。

      -

      Code: creating an address space

      vm.c

      操作地址空间和页表部分的代码都在kernel/vm.c中。代表页表的数据结构是pagetable_t。

      -

      vm.c的主要函数有walk、mappages等。walk用来在三级页表中找到某个虚拟地址表项，或者创建一个新的表项。mappages用来新建一个表项，主要用到了walk函数。

      -

      vm.c中，以kvm开头的代表操纵内核页表，以uvm开头的代表操纵进程里的用户页表。

      -

      以初始化为例介绍各个函数

      创建页表

      一开始操作系统初始化时，会调用vm.c中的kvminit来创建内核页表。主要就是在以内核地址空间的页表结构在填写页表。

      -
      void
      kvminit(void)
      {
        kernel_pagetable = kvmmake();
      }
      // Make a direct-map page table for the kernel.
      pagetable_t
      kvmmake(void)
      {
        //内核页表
        pagetable_t kpgtbl;
        //申请新的一页
        kpgtbl = (pagetable_t) kalloc();
        memset(kpgtbl, 0, PGSIZE);

        //给内核页表初始化表项，结构详见上面的内核地址空间部分
        // uart registers
        kvmmap(kpgtbl, UART0, UART0, PGSIZE, PTE_R | PTE_W);

        // virtio mmio disk interface
        kvmmap(kpgtbl, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);

        // PLIC
        kvmmap(kpgtbl, PLIC, PLIC, 0x400000, PTE_R | PTE_W);

        // map kernel text executable and read-only.
        kvmmap(kpgtbl, KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);

        // map kernel data and the physical RAM we'll make use of.
        kvmmap(kpgtbl, (uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);

        // map the trampoline for trap entry/exit to
        // the highest virtual address in the kernel.
        kvmmap(kpgtbl, TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);

        // allocate and map a kernel stack for each process.
        proc_mapstacks(kpgtbl);
        
        return kpgtbl;
      }
      +

      Locks and interrupt handlers

      +

      Xv6 is more conservative: when a CPU acquires any lock, xv6 always disables interrupts on that CPU. Interrupts may still occur on other CPUs, so an interrupt’s acquire can wait for a thread to release a spinlock; just not on the same CPU.看来是通过开关中断来保护临界区的

      +

      acquire调用push_off (*kernel/spinlock.c*:89) 并且release调用pop_off (*kernel/spinlock.c*:100)来跟踪当前CPU上锁的嵌套级别。当计数达到零时，pop_off恢复最外层临界区域开始时存在的中断使能状态。intr_off和intr_on函数执行RISC-V指令分别用来禁用和启用中断。

      +

      严格的在设置lk->locked (kernel/spinlock.c:28)之前让acquire调用push_off是很重要的。如果两者颠倒，会存在一个既持有锁又启用了中断的短暂窗口期，不幸的话定时器中断会使系统死锁。同样，只有在释放锁之后，release才调用pop_off也是很重要的(*kernel/spinlock.c*:66)。

      +
      +

      一个解决了一半的疑问

      问题

      +

      Xv6更保守：当CPU获取任何锁时，xv6总是禁用该CPU上的中断。中断仍然可能发生在其他CPU上，此时中断的acquire可以等待线程释放自旋锁；由于不在同一CPU上，不会造成死锁。

      +

      进展：似乎书中说到，“sleep atomically yields the CPU and releases the spinlock”。等了解完sleep，也即读完第七章之后再来看看。

      +
      +

      在处理时钟中断的trap.c中：

      +
      // in kernel/trap.c devintr()
          } else if(scause == 0x8000000000000001L){
              
          // 这里！！
          // in kernel/trap.c devintr()
          if(cpuid() == 0){
            clockintr();
          }
              
          w_sip(r_sip() & ~2);
          return 2;
        } 

      void
      clockintr()
      {
        acquire(&tickslock);
        ticks++;
        wakeup(&ticks);
        release(&tickslock);
      }
      -

      其中，kvmmap用来在内核页表中添加一个新的表项。其函数形式为

      -
      // add a mapping to the kernel page table.
      // only used when booting.
      // does not flush TLB or enable paging.
      void
      kvmmap(pagetable_t kpgtbl, uint64 va, uint64 pa, uint64 sz, int perm)
      {
        if(mappages(kpgtbl, va, sz, pa, perm) != 0)
          panic("kvmmap");
      }
      +

      可见只有CPU0才会进入clockintr【因为要求cpuid==0】，锁住ticks引起ticks递增。

      +

      而当sys_sleep获得锁之后，其结束循环的条件是ticks - ticks0 < n:

      +
      uint64
      sys_sleep(void)
      {
        int n;
        uint ticks0;
        if(argint(0, &n) < 0)
          return -1;
        acquire(&tickslock);
        ticks0 = ticks;
        while(ticks - ticks0 < n){
          if(myproc()->killed){
            release(&tickslock);
            return -1;
          }
          sleep(&ticks, &tickslock);
        }
        release(&tickslock);
        return 0;
      }
      -

      实现主要逻辑的是mappages函数

      -
      // Create PTEs for virtual addresses starting at va that refer to
      // physical addresses starting at pa. va and size might not
      // be page-aligned. Returns 0 on success, -1 if walk() couldn't
      // allocate a needed page-table page.
      int
      mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
      {
        uint64 a, last;
        pte_t *pte;

        if(size == 0)
          panic("mappages: size");
        
        a = PGROUNDDOWN(va);
        last = PGROUNDDOWN(va + size - 1);
        for(;;){
          //walk函数通过虚拟地址新建一个第三级页表的表项并返回其指针，之后只需要填这个表项即可
          if((pte = walk(pagetable, a, 1)) == 0)
            return -1;
          //如果pte存在并且标记为已使用，说明该虚拟地址映射已经存在
          if(*pte & PTE_V)
            panic("mappages: remap");
          //填写表项：物理地址 flags
          *pte = PA2PTE(pa) | perm | PTE_V;
          if(a == last)
            break;
          //每两个表项间隔PGSIZE个字节
          a += PGSIZE;
          pa += PGSIZE;
        }
        return 0;
      }
      +

      我认为，这会导致死锁情况。假设计算机为多CPU，且从零开始依次递增编号。对该死锁情况的讨论，可以分为以下两类：

      +
        +

      1. sys_sleep在CPU2（或者其他编号非零的CPU）运行，且先获取了tickslock的锁。这时候，ticks将会停止增长，sys_sleep结束循环的条件将无法结束。

        +

        理由：对于CPU0，它可以进入clockintr的代码段，但是由于锁已经被获取，所以就只能一直在那边死锁等待；对于其他CPU来说，压根执行不了那段增加ticks的代码段，所以ticks压根不会增加。这样一来，CPU2进程等待ticks增加，从而获取结束循环的条件；CPU0等待CPU2进程结束，从而使得ticks增加，就造成了死锁。

        +
        2. +

      2. sys_sleep在CPU0运行，且先获取了tickslock的锁。这时候，ticks将会停止增长，sys_sleep结束循环的条件将无法结束。

        +

        理由：由于xv6会在获取锁和释放锁期间关闭中断，因而CPU0无法进行时钟中断而发生进程的切换，只能一直在sys_sleep中等待，所以ticks更不可能增加，造成了死锁。

        +
        3. +
      +

      暂时没有很充分的理由反驳这两点。。。

      +

      解答

      学习完下一章的内容后可知，sleep(&ticks, &tickslock);会释放掉tickslock的锁，这样CPU0就可以进入clockintr增加ticks了。

      +

      再详细梳理一次，这里的具体机制是这样的：

      +

      可以把ticks看做信号量，sys_sleep为消费者，clockintr为生产者。

      +
      // in sys_sleep()
        acquire(&tickslock);
        while(ticks < 某个数字){
          sleep(&ticks, &tickslock);
        }
        release(&tickslock);
      -

      通过虚拟地址获取表项主要是通过walk实现的

      -
      // Return the address of the PTE in page table pagetable
      // that corresponds to virtual address va.  If alloc!=0,
      // create any required page-table pages.
      //
      // The risc-v Sv39 scheme has three levels of page-table
      // pages. A page-table page contains 512 64-bit PTEs.
      // A 64-bit virtual address is split into five fields:
      //   39..63 -- must be zero.
      //   30..38 -- 9 bits of level-2 index.
      //   21..29 -- 9 bits of level-1 index.
      //   12..20 -- 9 bits of level-0 index.
      //    0..11 -- 12 bits of byte offset within the page.
      // 虚拟地址的格式：UNUSED 页表索引 offset，其中页表索引在三级页表中被划分为了三个，分别是
      // level0-level2，分别代表了第三级、第二级、第一级页表的索引【具体可见页表组成中的图】
      // walk的目的就是要在这三级页表中找到虚拟地址对应的页表项。当alloc!=0时，则要求找不到就新建一个
      pte_t *
      walk(pagetable_t pagetable, uint64 va, int alloc)
      {
        if(va >= MAXVA)
          panic("walk");

        for(int level = 2; level > 0; level--) {
          pte_t *pte = &pagetable[PX(level, va)];
          if(*pte & PTE_V) {
            // 取出PTE中表示下一级页表地址的字节
            pagetable = (pagetable_t)PTE2PA(*pte);
          } else {
            // 页表不存在的情况，要么返回0，要么新建一页
            if(!alloc || (pagetable = (pde_t*)kalloc()) == 0)
              return 0;
            memset(pagetable, 0, PGSIZE);
            *pte = PA2PTE(pagetable) | PTE_V;
          }
        }
        // 最终返回第三级页表的对应表项
        return &pagetable[PX(0, va)];
      }
      +
      void
      clockintr()
      {
        acquire(&tickslock);
        ticks++;
        wakeup(&ticks);
        release(&tickslock);
      }
      -
      装上页表

      使用的是kvminithart函数。它将内核页表的root page table的物理地址写入了satp寄存器。从这个函数之后，就开启了内存映射。

      -
      // Switch h/w page table register to the kernel's page table,
      // and enable paging.
      void
      kvminithart()
      {
        // wait for any previous writes to the page table memory to finish.
        sfence_vma();

        w_satp(MAKE_SATP(kernel_pagetable));

        // flush stale entries from the TLB.
        sfence_vma();
      }
      +

      可以看到，这是非常典型的生产者消费者模型。生产者每生产一次ticks，就会唤醒消费者，让消费者检查条件。如果条件错误，则继续sleep等待消费者下一次唤醒，如此循环往复。

      +

      只不过，还有一个小疑点，就是clockintr这段只有CPU0可以执行这一点是否为真依然存疑。如果确实只有CPU0可以执行的话，假若sys_sleep在CPU0上执行，那么还是依然会造成死锁。所以我猜想是不是CPU0是无法关中断的？也就是说CPU0是一个后盾一般的保护角色？或者是别的CPU也能进入本段代码？如果别的CPU也能进，那是怎么实现的？因为很明显这段代码确实只有CPU0可以进入。

      +

      Sleep locks

      关于sleep lock的由来和优点，书里描述得很详细，简单来说就是：

      +
      +

      Thus we’d like a type of lock that yields the CPU while waiting to acquire, and allows yields (and interrupts) while the lock is held.

      +

      因为等待会浪费CPU时间，所以自旋锁最适合短的临界区域；睡眠锁对于冗长的操作效果很好。

      +
      +
      void
      acquiresleep(struct sleeplock *lk)
      {
        acquire(&lk->lk);
        // 等待
        while (lk->locked) {
          // sleep atomically yields the CPU and releases the spinlock
          sleep(lk, &lk->lk);
        }
        // 占用
        lk->locked = 1;
        lk->pid = myproc()->pid;
        release(&lk->lk);
      }

      void
      releasesleep(struct sleeplock *lk)
      {
        acquire(&lk->lk);
        lk->locked = 0;
        lk->pid = 0;
        // 到时候可以留意一下wakeup是会唤醒一个还是多个
        wakeup(lk);
        release(&lk->lk);
      }
      -

      其中sfence_vma()的用途是强制更新TLB的旧页表，类似于Java volatile的作用。

      -
      疑问

      附上书里的详细解释：

      -

      image-20230109222917346

      -

      TLB与页表类似于cache与主存的关系。TLB保存了页表的一部分。

      -
      我的错误想法

      我怎么感觉怪怪的啊？因为TLB既然是高速缓存，那么读写页表也应该优先从TLB读写【注：应该就是从这里开始错的hhh写应该是直接写入页表】。所以说，会陈旧的应该是主存中的页表，而不是TLB中的页表。但是，书里是说，改完页表必须通知TLB更改。也就是说，读写页表不是从TLB读写的，那该是从哪里？是TLB以外的free memory吗？

      -

      不过，要是从多CPU的角度思考，说不定他这个意思是某个CPU的TLB变了，需要通知其他所有CPU的TLB也变。虽然不同CPU当前执行的进程是不一样的，使用的页表项不一样，切换进程的时候也会把用户地址空间的页表项flush掉。但是内核地址空间的页表项一般是不会随着进程切换而flush掉的。所以内核页表修改就需要手动多CPU同步。

      -

      我认为多CPU角度考虑更加合理，因为它最后说了，xv6会在内核页表init后flush，以及在从内核态切换回用户态的时候flush。这两个（好像）都影响内核页表比较多，所以就需要手动flush一下。

      -
      解答

      之后学了缺页异常后，可以发现这里其实是没问题的。

      -

      计算机体系结构 – 虚拟内存

      -

      v2-e15454bf032baa4dc088b6e41ed4f4a4_1440w

      -

      页表的管理（创建、更新、删除等）是由操作系统负责的。地址转换时，页表检索是由硬件内存管理单元（Memory Management Unit, MMU）负责的。MMU通常由两部分构成：表查找单元（Table Walk Unit, TWU）和转换旁路缓冲（Translation Lookaside Buffer, TLB）[2]。TWU负责链式的访问PDE、PTE，完成上述的查表过程。

      -

      应用多级页表之后，想要完成一次地址转换，需要访问多级目录和页表，这么多次的内存访问会严重降低性能。

      -

      为了优化地址转换速度，人们在MMU中增加了一块高速cache，专门用来缓存虚拟地址到物理地址的映射，这块cache就是TLB[7][8]。MMU在做地址转换的时候，会先检索TLB，如果命中则直接返回对应的物理地址，如果不命中则会调用TWU查找页表。

      -

      TLB中缓存的是虚拟地址到物理地址映射。然而，多级页表的查找是一个链式的过程，对于在虚拟地址空间中连续的两个页，它们的各级目录项可能都是一样的，只有最后一级页号不一样。查找完第一个虚拟页之后，我们可以将相同的前级目录项都缓存起来。查找第二个虚拟页时，可以直接使用缓存好的前几级目录项，节省查找时间。这种缓存叫做Page Structure Cache[9]。

      -

      而当TLB和MMU中都没有该物理页，就会发生缺页异常。但是操作系统仅会对页表更新，而不会被TLB更新。故而，TBL中数据可能陈旧，需要手动flush。

      -

      Physical memory allocation

      在内核运行的时候，需要申请很多空间用来存放各种数据。

      +

      有一点值得注意：

      +
      +

      Because sleep-locks leave interrupts enabled, they cannot be used in interrupt handlers. Because acquiresleep may yield the CPU, sleep-locks cannot be used inside spinlock critical sections (though spinlocks can be used inside sleep-lock critical sections).

      +
      +

      这实际上是因为自旋锁内不能sleep，因而也就不能使用sleep lock。

      +

      为什么不能sleep？我猜测应该是因为sleep中会释放自旋锁然后再调度别的进程。此时，临界区就不受保护了很危险，不符合spinlock在临界区结束才能释放的规范。

      +

      在查阅别人的说法的时候，我还看到了这个讨论：

      -

      The kernel must allocate and free physical memory at run-time for page tables, user memory, kernel stacks, and pipe buffers.

      +

      中断中为什么不能sleep | Linux内核的评论区

      +

      在中断服务程序中，无法sleep的原因应该是sleep后，调度程序将CPU窃走，由于调度的基本单位是线程（中断服务程序不是线程），因此中断服务程序无法再被调度回来，即中断程序中sleep后的部分永远无法得到执行。

      -

      用的是这段空闲内存：

      -

      image-20230109225700837

      -
      -

      It keeps track of which pages are free by threading a linked list through the pages themselves.

      +

      Real world

      +

      大多数操作系统都支持POSIX线程（Pthread），它允许一个用户进程在不同的CPU上同时运行几个线程。Pthread支持用户级锁（user-level locks）、障碍（barriers）等。支持Pthread需要操作系统的支持。例如，如果一个Pthread在系统调用中阻塞，同一进程的另一个Pthread应当能够在该CPU上运行。另一个例子是，如果一个线程改变了其进程的地址空间（例如，映射或取消映射内存），内核必须安排运行同一进程下的线程的其他CPU更新其硬件页表，以反映地址空间的变化。

      -

      kalloc.c中就是这么实现的。

      -

      Code: Physical memory allocator

      内核运行时申请释放空闲物理空间是通过kernel/kalloc.c完成的。它为内核栈、用户进程、页表和管道buffer服务。

      -
      -

      kalloc.c用来在运行时申请分配新的一页，上面的vm.c正是用了kalloc申请一页，要么作为页表，要么作为存储数据的第三级页表指向的物理内存。

      +

      Lab: locks

      +

      In this lab you’ll gain experience in re-designing code to increase parallelism. You’ll do this for the xv6 memory allocator and block cache.

      -

      最后应该会在空闲内存内形成这样的结构：

      -

      内存分成一页一页的，每页内存中的前几个字节存储着其对应队列中下一块内存的物理地址。不一定是从小地址到大地址顺序连接。

      -
      -

      It store each free page’s run structure in the free page itself, since there’s nothing else stored there.

      +

      Memory allocator

      +

      The program user/kalloctest stresses xv6’s memory allocator: three processes grow and shrink their address spaces, resulting in many calls to kalloc and kfree. kalloc and kfree obtain kmem.lock. kalloctest prints (as “#fetch-and-add”) the number of loop iterations in acquire due to attempts to acquire a lock that another core already holds, for the kmem lock and a few other locks. The number of loop iterations in acquire is a rough measure of lock contention.

      +

      To remove lock contention, you will have to redesign the memory allocator to avoid a single lock and list. 也就是说要把kalloc中的整个列表上锁，修改为每个CPU有自己的列表The basic idea is to maintain a free list per CPU, each list with its own lock. Allocations and frees on different CPUs can run in parallel, because each CPU will operate on a different list. The main challenge will be to deal with the case in which one CPU’s free list is empty, but another CPU’s list has free memory; in that case, the one CPU must “steal” part of the other CPU’s free list. Stealing may introduce lock contention, but that will hopefully be infrequent.主要挑战将是处理一个 CPU 的空闲列表为空，但另一个 CPU 的列表有空闲内存的情况； 在这种情况下，一个 CPU 必须“窃取”另一个 CPU 的空闲列表的一部分。

      +

      Your job is to implement per-CPU freelists, and stealing when a CPU’s free list is empty.

      +

      You must give all of your locks names that start with “kmem”. That is, you should call initlock for each of your locks, and pass a name that starts with “kmem”.

      +

      Run kalloctest to see if your implementation has reduced lock contention. To check that it can still allocate all of memory, run usertests sbrkmuch. Your output will look similar to that shown below, with much-reduced contention in total on kmem locks, although the specific numbers will differ.

      -
      // Physical memory allocator, for user processes,
      // kernel stacks, page-table pages,
      // and pipe buffers. Allocates whole 4096-byte pages.

      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "spinlock.h"
      #include "riscv.h"
      #include "defs.h"

      // 释放在这范围内的物理内存空间
      void freerange(void *pa_start, void *pa_end);

      // 也就是上面说的free memory的起始位置
      extern char end[]; // first address after kernel.
                         // defined by kernel.ld.

      // run代表的是一页内存
      struct run {
        struct run *next;
      };

      // 代表了整个内核空闲的物理空间
      struct {
        struct spinlock lock;
        struct run *freelist;
      } kmem;

      void
      kinit()
      {
        initlock(&kmem.lock, "kmem");
        // init的时候先清空空闲空间，建立空闲页队列
        freerange(end, (void*)PHYSTOP);
      }

      void
      freerange(void *pa_start, void *pa_end)
      {
        char *p;
        // PGROUNDUP和PGROUNDDOWN是用于将地址四舍五入到PGSIZE
        p = (char*)PGROUNDUP((uint64)pa_start);
        for(; p + PGSIZE <= (char*)pa_end; p += PGSIZE)
          kfree(p);
      }

      // Free the page of physical memory pointed at by pa,
      // which normally should have been returned by a
      // call to kalloc().  (The exception is when
      // initializing the allocator; see kinit above.)
      void
      kfree(void *pa)
      {
        struct run *r;

        // pa得是整数页，并且得在内核物理内存范围之间
        if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
          panic("kfree");

        // Fill with junk to catch dangling refs.
        memset(pa, 1, PGSIZE);

        // 之后将在pa对应的那一页的前几个字节写入next字段
        r = (struct run*)pa;

        // 这意思就是在空闲内存的链表队列中新增一块
        acquire(&kmem.lock);
        r->next = kmem.freelist;
        kmem.freelist = r;
        release(&kmem.lock);
      }

      // Allocate one 4096-byte page of physical memory.
      // Returns a pointer that the kernel can use.
      // Returns 0 if the memory cannot be allocated.
      void *
      kalloc(void)
      {
        struct run *r;

        acquire(&kmem.lock);
        r = kmem.freelist;
        if(r)
          kmem.freelist = r->next;
        release(&kmem.lock);

        if(r)
          memset((char*)r, 5, PGSIZE); // fill with junk
        return (void*)r;
      }
      - -

      Process address space

      当用户进程叫xv6分配内存时，xv6会用kalloc去取，然后登记在页表上。

      +

      感想

      总之，意思就是kalloc里面本来是多核CPU共用一个空闲页list，现在要做的就是给每一核的CPU独立分配一个空闲页list。我觉得可以分为如下几步来做：

      +
        +

      1. 定义list数组以及对应的锁

        +

        cpu的数量是一定的；cpuid可以用来作为数组下标索引

        +
        2. +

      2. 在init时初始化锁，在freelist的时候把空闲页均分给CPU

        +
        3. +

      3. 当kalloc和kfree的时候，获取当前cpuid上锁

        +
        4. +

      4. 当一个CPU的内存不够的时候，去向另一个CPU窃取。窃取之前，首先应该获取另一个CPU的锁。

        +
        5. +
      +

      以上是初见思路。正确思路确实跟上面的一样，编码过程也比较简单，没有很恶心的细节和奇奇怪怪的bug，没什么好说的。

      +

      第二步中，hints是推荐把所有空闲页都分给CPU0。

      +

      第四步的时候我是一次窃取一页。我看到一个一次窃取多页的做法，我觉得很有想法，在这里附上链接：

      -

      The stack is a single page, and is shown with the initial contents as created by exec. Strings containing the command-line arguments, as well as an array of pointers to them, are at the very top of the stack. Just under that are values that allow a program to start at main as if the function main(argc, argv) had just been called.

      -
      -

      image-20230109234930690

      -

      Code: sbrk

      -

      Sbrk is the system call for a process to shrink or grow its memory. The system call is implemented by the function growproc (kernel/proc.c:239).

      +

      MIT6.S081 lab8 locks

      -
      // Grow or shrink user memory by n bytes.注意单位是bytes，grow n+，shrink n-
      // Return 0 on success, -1 on failure.
      // 主要逻辑还是通过vm.c实现
      int
      growproc(int n)
      {
        uint64 sz;//size
        struct proc *p = myproc();

        sz = p->sz;
        if(n > 0){
          if((sz = uvmalloc(p->pagetable, sz, sz + n, PTE_W)) == 0) {
            return -1;
          }
        } else if(n < 0){
          sz = uvmdealloc(p->pagetable, sz, sz + n);
        }
        p->sz = sz;
        return 0;
      }
      +

      代码

      定义
      struct {
        struct spinlock kmem_locks[NCPU];
        struct run *freelists[NCPU];
      } kmem;
      -
      // Allocate PTEs and physical memory to grow process from oldsz to
      // newsz, which need not be page aligned.不需要页对齐  Returns new size or 0 on error.
      uint64
      uvmalloc(pagetable_t pagetable, uint64 oldsz, uint64 newsz, int xperm)
      {
        char *mem;
        uint64 a;

        if(newsz < oldsz)
          return oldsz;

        // oldsz向上取整
        oldsz = PGROUNDUP(oldsz);
        // 每页alloc
        for(a = oldsz; a < newsz; a += PGSIZE){
          mem = kalloc();
          if(mem == 0){
            // 说明失败，恢复到原状
            // 这里不用像下面一样kfree是因为这里压根没有alloc成功
            uvmdealloc(pagetable, a, oldsz);
            return 0;
          }
          // 除去junk data
          memset(mem, 0, PGSIZE);
          // 放入页表
          if(mappages(pagetable, a, PGSIZE, (uint64)mem, PTE_R|PTE_U|xperm) != 0){
            // 不成功
            // dealloc原理是顺着页表一个个free的。由于mem此处没有成功放入页表，所以就得单独free掉
            kfree(mem);
            uvmdealloc(pagetable, a, oldsz);
            return 0;
          }
        }
        return newsz;
      }
      +
      初始化

      由于kinit仅会由一个cpu执行一次【详情见main.c】，故而我这里在kinit的做法是由一个CPU初始化所有CPU，而没有选择去修改main.c从而使每个CPU都执行一次kinit。

      +
      void
      kinit()
      {
        for(int i=0;i<NCPU;i++){
          char buf[8];
          snprintf(buf,6,"kmem%d",i);
          initlock(&kmem.kmem_locks[i], buf);
        }
        freerange(end, (void*)PHYSTOP);
      }

      // 多带一个参数表示cpuid，仅在kinit的freerange中使用
      void
      kfree_init(void *pa,int i)
      {
        struct run *r;

        if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
          panic("kfree");

        // Fill with junk to catch dangling refs.
        memset(pa, 1, PGSIZE);

        r = (struct run*)pa;

        r->next = kmem.freelists[i];
        kmem.freelists[i] = r;
      }
      void
      freerange(void *pa_start, void *pa_end)
      {
        char *p;
        p = (char*)PGROUNDUP((uint64)pa_start);
         
        // 把空闲内存页均分给每个CPU
        uint64 sz = ((uint64)pa_end - (uint64)pa_start)/NCPU;
        uint64 tmp = PGROUNDDOWN(sz) + (uint64)p;
        for(int i=0;i<NCPU;i++){
          for(; p + PGSIZE <= (char*)tmp; p += PGSIZE)
            kfree_init(p,i);
          tmp += PGROUNDDOWN(sz);
          if(i == NCPU-2){
            tmp = (uint64)pa_end;
          }
        }
      }
      -

      Code:exec

      -

      Exec is the system call that creates the user part of an address space. It initializes the user part of an address space from a fifile stored in the fifile system.

      -

      exec是创建地址空间的用户部分的系统调用。它使用一个存储在文件系统中的文件初始化地址空间的用户部分。

      -
      -
      int
      exec(char *path, char **argv)
      {
        char *s, *last;
        int i, off;
        uint64 argc, sz = 0, sp, ustack[MAXARG], stackbase;
        struct elfhdr elf;
        struct inode *ip;
        struct proghdr ph;
        pagetable_t pagetable = 0, oldpagetable;
        struct proc *p = myproc();

        //开始打开文件的意思吧（
        begin_op();

        //ip是一个inode
        //打开路径为path的文件
        if((ip = namei(path)) == 0){
          end_op();
          return -1;
        }
        //暂时锁住文件，别人不许动
        ilock(ip);

        //之后应该就是把文件读入内存吧
        // Check ELF header
        if(readi(ip, 0, (uint64)&elf, 0, sizeof(elf)) != sizeof(elf))
          goto bad;

        if(elf.magic != ELF_MAGIC)
          goto bad;

        //分配新页表
        if((pagetable = proc_pagetable(p)) == 0)
          goto bad;

        //elfhd应该指的是可执行文件头
        // Load program into memory.
        for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
          if(readi(ip, 0, (uint64)&ph, off, sizeof(ph)) != sizeof(ph))
            goto bad;
          if(ph.type != ELF_PROG_LOAD)
            continue;
          if(ph.memsz < ph.filesz)
            goto bad;
          if(ph.vaddr + ph.memsz < ph.vaddr)
            goto bad;
          if(ph.vaddr % PGSIZE != 0)
            goto bad;
          //总之顺利读到了
          uint64 sz1;
          //读到了就给它分配新空间并且填入页表
          if((sz1 = uvmalloc(pagetable, sz, ph.vaddr + ph.memsz, flags2perm(ph.flags))) == 0)
            goto bad;
          sz = sz1;
          if(loadseg(pagetable, ph.vaddr, ip, ph.off, ph.filesz) < 0)
            goto bad;
        }
        //在这里解锁
        iunlockput(ip);
        end_op();
        ip = 0;

        p = myproc();
        uint64 oldsz = p->sz;

        //读完文件，开始造一个新的用户栈【fork之后用户栈是不会清空的】
        // Allocate two pages at the next page boundary.
        // Make the first inaccessible as a stack guard.
        // Use the second as the user stack.
        sz = PGROUNDUP(sz);
        uint64 sz1;
        if((sz1 = uvmalloc(pagetable, sz, sz + 2*PGSIZE, PTE_W)) == 0)
          goto bad;
        sz = sz1;
        // mark a PTE invalid for user access.造guard page
        uvmclear(pagetable, sz-2*PGSIZE);
        // sp为栈顶
        sp = sz;
        // 应该指的是栈尾
        stackbase = sp - PGSIZE;

        // 开始往栈中填入执行参数
        // Push argument strings, prepare rest of stack in ustack.
        for(argc = 0; argv[argc]; argc++) {
          if(argc >= MAXARG)
            goto bad;
          sp -= strlen(argv[argc]) + 1;
          sp -= sp % 16; // riscv sp must be 16-byte aligned
          if(sp < stackbase)
            goto bad;
          //argv来自用户空间，所以需要使用copyout
          if(copyout(pagetable, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
            goto bad;
          //这什么东西
          //exec一次将参数中的一个字符串复制到栈顶，并在ustack中记录指向它们的指针
          ustack[argc] = sp;
        }
        //放置空指针
        ustack[argc] = 0;

        // push the array of argv[] pointers.
        sp -= (argc+1) * sizeof(uint64);
        sp -= sp % 16;
        if(sp < stackbase)
          goto bad;
        if(copyout(pagetable, sp, (char *)ustack, (argc+1)*sizeof(uint64)) < 0)
          goto bad;

        // arguments to user main(argc, argv)
        // argc is returned via the system call return
        // value, which goes in a0.
        p->trapframe->a1 = sp;

        // Save program name for debugging.
        for(last=s=path; *s; s++)
          if(*s == '/')
            last = s+1;
        safestrcpy(p->name, last, sizeof(p->name));
         
        //只有成功了才会来到这，才会覆盖掉旧的内存镜像
        // Commit to the user image.
        oldpagetable = p->pagetable;
        p->pagetable = pagetable;
        p->sz = sz;
        p->trapframe->epc = elf.entry;  // initial program counter = main
        p->trapframe->sp = sp; // initial stack pointer
        proc_freepagetable(oldpagetable, oldsz);

        return argc; // this ends up in a0, the first argument to main(argc, argv)

       bad:
        //释放新镜像，不改变旧镜像
        if(pagetable)
          proc_freepagetable(pagetable, sz);
        if(ip){
          iunlockput(ip);
          end_op();
        }
        return -1;
      }
      +
      kfree
      void
      kfree(void *pa)
      {
        // ...

        r = (struct run*)pa;
        // 在这
        push_off();
        int id = cpuid();

        acquire(&kmem.kmem_locks[id]);
        r->next = kmem.freelists[id];
        kmem.freelists[id] = r;
        release(&kmem.kmem_locks[id]);
        pop_off();
      }
      -

      Real world

      image-20230110010651653

      -

      xv6内核缺少一个类似malloc可以为小对象提供内存的分配器，这使得内核无法使用需要动态分配的复杂数据结构。【确实，感觉一分配就是一页（】

      -

      内存分配是一个长期的热门话题，基本问题是有效使用有限的内存并为将来的未知请求做好准备。今天，人们更关心速度而不是空间效率。此外，一个更复杂的内核可能会分配许多不同大小的小块，而不是（如xv6中）只有4096字节的块；一个真正的内核分配器需要处理小分配和大分配。

      -

      Lab：Pagetable

      -

      In this lab you will explore page tables and modify them to to speed up certain system calls and to detect which pages have been accessed.

      -
      -

      不过遗憾的是usertests还有好几个没通过，具体都标注了。

      -

      Speed up system calls

      -

      When each process is created, map one read-only page at USYSCALL (a VA defined in memlayout.h). At the start of this page, store a struct usyscall (also defined in memlayout.h), and initialize it to store the PID of the current process. For this lab, ugetpid() has been provided on the userspace side and will automatically use the USYSCALL mapping. You will receive full credit for this part of the lab if the ugetpid test case passes when running pgtbltest.

      -

      参考文章：MIT 6.S081 2021: Lab page tables

      -
      -

      感想

      乌龙

      这里好像是因为实验改版了，我下的是2020年的实验包，在memlayout压根找不到USYSCALL和struct usyscall这俩东西。最后翻了下网上的总算找到了。

      -

      我一开始没找到，还以为USYSCALL以及usyscall这两个都得自己写在memlayout里面，想了很久都没想出来USYSCALL的值应该设置为多少。我认为只需满足两个条件即可：1.所处内存段应该是free memory那段，也即自kernel结束（PHYSTOP）到MAXVA这一大块。2.得确保能被用户和内核都能访问到。

      -

      前者意为虚拟地址在MAXVA和PHYSTOP之间，后者意为那段内存应该标记为PTE_U。这个范围是很宽泛的，我实在不知道要分配这期间的哪块内存，感觉也不大可能是真的自由度那么大。所以我就偷偷看了hints【悲】，想看它对这个USYSCALL应该写什么值有没有建议。结果发现这东西是实验给我们定的。遂去网上找到了它给的真正的USYSCALL值。

      -
      #define USYSCALL (TRAPFRAME - PGSIZE)

      struct usyscall{
        int pid;
      };
      +
      kalloc
      void *
      kalloc(void)
      {
        struct run *r;

        push_off();
        int id = cpuid();

        acquire(&kmem.kmem_locks[id]);
        r = kmem.freelists[id];
        if(r){
          kmem.freelists[id] = r->next;
        }
        release(&kmem.kmem_locks[id]);
        pop_off();

        // 如果无空闲页，则窃取
        if(!r){
          for(int i=NCPU-1;i>=0;i--){
            acquire(&kmem.kmem_locks[i]);
            r = kmem.freelists[i];
            if(r){
              kmem.freelists[i] = r->next;
              release(&kmem.kmem_locks[i]);
              break;
            }
            release(&kmem.kmem_locks[i]);
          }
        }
        
        if(r)
          memset((char*)r, 5, PGSIZE); // fill with junk
        return (void*)r;
      }
      -

      用户的ugetpid只找到了一个截图：

      -

      v2-0c2603da4c8102e46ae390a0d0b1191d_1440w

      -

      恕我愚钝实在不知道该把这段代码放在哪orz于是接下来写的东西就没有自测。

      -
      panic:freewalk leaf

      一开始写好代码准备启动xv6的时候爆出了这么一个panic，搜了一下得到如下解答：

      +

      Buffer cache

      buffer cache的结构其实跟kalloc的内存分配结构有一定的类似之处，都是采用链表管理，但是buffer cache的实现相较于kalloc更为复杂。

      -

      来源：MIT-6.S081-2020实验（xv6-riscv64）十：mmap

      -

      这时运行会发现freewalk函数panic：freewalk: leaf，这是因为freewalk希望所有虚拟地址已经被解绑并释放对应的物理空间了，该函数只负责释放页表。

      +

      Reducing contention in the block cache is more tricky than for kalloc, because bcache buffers are truly shared among processes (and thus CPUs).

      +

      For kalloc, one could eliminate most contention by giving each CPU its own allocator; that won’t work for the block cache.

      +

      We suggest you look up block numbers in the cache with a hash table that has a lock per hash bucket.

      -

      让我得知freewalk在vm.c下面【吐槽，我一开始还以为是自由自在地走（，看到这个才反应过来是free walk，跟页表有关的】。结合freewalk的代码

      -

      image-20230110225359361

      -

      可以知道，造成这个panic的原因是需要手动释放页表项。而在这里

      -
      // in proc.c  freeproc()
      if(p->usyscall)
          kfree((void*)p->usyscall);
        p->usyscall = 0;
      - -

      仅仅是释放掉了对应的物理页，页表项并没有被释放。

      -

      对比了一下别人写的，才发现原来这里也需要修改：

      -
      // Free a process's page table, and free the
      // physical memory it refers to.
      void
      proc_freepagetable(pagetable_t pagetable, uint64 sz)
      {
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmunmap(pagetable, TRAPFRAME, 1, 0);
        //添加此句
        uvmunmap(pagetable, USYSCALL, 1, 0);
        uvmfree(pagetable, sz);
      }
      +

      感想

      初见思路

      我想我们可以这么实现：

      +

      首先有一个双向链表，接收着所有空闲无设备分配的buf。然后再有多个双向链表桶，以设备号为索引值。

      +

      设备号数量，也即hash table的大小定义在kernel/param.h中：

      +
      #define NDEV         10
      -

      这样一来，问题就解决了。

      -
      总结

      因而，可以看到，如果进程想使用页的话，需要经历以下四步：

      +

      在bget中，第一个循环仅需在设备链表中查找即可，第二个循环需要先看设备链表是否有空闲的对象，如果没有，则去接收所有空闲无设备分配的那个双向链表中窃取一个对象。

      +

      在brelse中，则把要释放的buf对象添加在head中即可。

      +

      因而，我们要做以下几件事：

        -
      1. 通过kalloc获取物理页地址（可以通过该地址对页进行读写），并且记录在进程proc结构中（否则之后就获取不了了）
        2. -
      2. 建立mappages映射
        3. -
      3. 释放物理页
        4. -
      4. 释放PTE映射
        5. +

      5. 修改bcache的定义

        +

        添加数量为设备号的head数组，以及对应的锁

        +
        6. +

      6. 初始化bcache

        +
        7. +

      7. 添加工具函数：将一个buf加入一个双向链表；从一个双向链表中得到一个buf

        +
        8. +

      8. 写bget和brelse

        +
      -

      可见12和34都是分别一一对应的。

      -

      代码

      // Look in the process table for an UNUSED proc.
      // If found, initialize state required to run in the kernel,
      // and return with p->lock held.
      // If there are no free procs, or a memory allocation fails, return 0.
      static struct proc*
      allocproc(void)
      {
        struct proc *p;

        //有线程池那味了
        for(p = proc; p < &proc[NPROC]; p++) {
          acquire(&p->lock);
          if(p->state == UNUSED) {
            goto found;
          } else {
            release(&p->lock);
          }
        }
        return 0;

      found:
        p->pid = allocpid();

        // Allocate a trapframe page.
        if((p->trapframe = (struct trapframe *)kalloc()) == 0){
          release(&p->lock);
          return 0;
        }
        // Allocate a usyscall page.
        if((p->usyscall = (struct usyscall *)kalloc()) == 0){
          release(&p->lock);
          return 0;
        }
        //在USYSCALL写入usyscall结构体
        p->usyscall->pid = p->pid;

        // An empty user page table.
        p->pagetable = proc_pagetable(p);
        if(p->pagetable == 0){
          freeproc(p);
          release(&p->lock);
          return 0;
        }

        // Set up new context to start executing at forkret,
        // which returns to user space.
        memset(&p->context, 0, sizeof(p->context));
        p->context.ra = (uint64)forkret;
        p->context.sp = p->kstack + PGSIZE;

        return p;
      }

      // free a proc structure and the data hanging from it,
      // including user pages.
      // p->lock must be held.
      static void
      freeproc(struct proc *p)
      {
        if(p->trapframe)
          kfree((void*)p->trapframe);
        p->trapframe = 0;
        if(p->pagetable)
          proc_freepagetable(p->pagetable, p->sz);
        p->pagetable = 0;
        if(p->usyscall)
          kfree((void*)p->usyscall);
        p->usyscall = 0;
        p->sz = 0;
        p->pid = 0;
        p->parent = 0;
        p->name[0] = 0;
        p->chan = 0;
        p->killed = 0;
        p->xstate = 0;
        p->state = UNUSED;
      }

      // Create a user page table for a given process,
      // with no user memory, but with trampoline pages.
      pagetable_t
      proc_pagetable(struct proc *p)
      {
        pagetable_t pagetable;

        // An empty page table.
        pagetable = uvmcreate();
        if(pagetable == 0)
          return 0;

        // map the trampoline code (for system call return)
        // at the highest user virtual address.
        // only the supervisor uses it, on the way
        // to/from user space, so not PTE_U.
        if(mappages(pagetable, TRAMPOLINE, PGSIZE,
                    (uint64)trampoline, PTE_R | PTE_X) < 0){
          uvmfree(pagetable, 0);
          return 0;
        }

        // map the trapframe just below TRAMPOLINE, for trampoline.S.
        if(mappages(pagetable, TRAPFRAME, PGSIZE,
                    (uint64)(p->trapframe), PTE_R | PTE_W) < 0){
          uvmunmap(pagetable, TRAMPOLINE, 1, 0);
          uvmfree(pagetable, 0);
          return 0;
        }

       // 映射USYSCALL
        if(mappages(pagetable, USYSCALL, PGSIZE,
                    (uint64)(p->usyscall), PTE_R|PTE_U) < 0){
          uvmunmap(pagetable, TRAMPOLINE, 1, 0);
          uvmunmap(pagetable, TRAPFRAME, 1, 0);
          uvmfree(pagetable, 0);
          return 0;
       }
        return pagetable;
      }

      // Free a process's page table, and free the
      // physical memory it refers to.
      void
      proc_freepagetable(pagetable_t pagetable, uint64 sz)
      {
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmunmap(pagetable, TRAPFRAME, 1, 0);
        uvmunmap(pagetable, USYSCALL, 1, 0);
        uvmfree(pagetable, sz);
      }
      +

      看起来确实好像可以实现的样子，但是这个问题在于，这么做就直接破坏了LRU的这个规则。所以还是不能这么写的。但总之先把我的代码放上来。

      +

      以下代码是不能正常运行的。比如说在执行ls命令时，会发生如下错误：

      +

      image-20230122163938601

      +

      会打印出一些乱七八糟的东西，并且这些东西似乎是固定的，每次都会发生，看来应该不是多进程的问题，而是代码有哪里出现逻辑错误了。不过注意到会产生“stopforking”、“bigarg-ok”，这两个似乎是在usertest中的两个文件名，很奇怪。

      +

      很遗憾我暂时没有精力debug了。姑且先把错误代码放在这里吧。

      +
      struct {
        struct spinlock lock;
        struct buf buf[NBUF];

        // Linked list of all buffers, through prev/next.
        // Sorted by how recently the buffer was used.
        // head.next is most recent, head.prev is least.
        struct buf head;
        struct buf dev_heads[NDEV];
        struct spinlock dev_locks[NDEV];
      } bcache;
      -

      问答题

      -

      Which other xv6 system call(s) could be made faster using this shared page? Explain how.

      -
      -

      我觉得如果能在fork的父子进程用shared page共享页表应该会节省很多时间和空间，用个读时写。其他的倒是想不到了。不过这题会不会问的是那些在内核态和用户态穿梭频繁的system call呢？这个的话我就想不出来了。

      -

      Print a page table

      -

      write a function that prints the contents of a page table.

      -

      Define a function called vmprint().

      -

      It should take a pagetable_t argument, and print that pagetable in the format described below.

      -

      Insert if(p->pid==1) vmprint(p->pagetable) in exec.c just before the return argc, to print the first process’s page table.

      -

      image-20230110231020570

      -

      The first line displays the argument to vmprint. After that there is a line for each PTE, including PTEs that refer to page-table pages deeper in the tree. Each PTE line is indented by a number of " .." that indicates its depth in the tree.

      -

      Each PTE line shows the PTE index in its page-table page, the pte bits, and the physical address extracted from the PTE. Don’t print PTEs that are not valid.

      -

      In the above example, the top-level page-table page has mappings for entries 0 and 255. The next level down for entry 0 has only index 0 mapped, and the bottom-level for that index 0 has entries 0, 1, and 2 mapped.

      -
      -

      感想

      image-20230111000329475

      -

      很可惜，我在上面检索freewalk leaf到底是什么东西的时候，不小心看到了这题需要去参照freewalk这个提示【悲】其实我觉得这点还是需要绕点弯才能想到的，可能直接想到有点难【谁知道呢，世界线已经变动了】。

      -

      它这个打印页表其实最主要是考查如何遍历页表，这让人想起了walk这样的东西。但是walk是根据虚拟地址一级级找PTE的，中间很多地方会被跳过。有没有一个过程会在做事的时候遍历整个页表呢？答案是，这个过程就是释放页表的过程。释放页表才会一个个地看是否需要释放。释放页表的函数是freewalk，因而这道题参考freewalk的代码即可。

      -

      我觉得从“遍历页表”联想到“释放页表”这点是很巧的。不过也不会很突兀，毕竟学数据结构时就知道释放就需要遍历，逆向思维有点难但问题不大。

      -

      其他的就都挺简单的，不多赘述。

      -

      代码

      记得在defs.h中添加声明

      -
      //在vm.c下
      void
      vmprint_helper(pagetable_t pagetable,int level)
      {
        // there are 2^9 = 512 PTEs in a page table.
        for(int i = 0; i < 512; i++){
          pte_t pte = pagetable[i];
          if(pte & PTE_V){
            for(int j=0;j<level;j++){
      		printf(" ..");
            }
            printf("%d: pte %p pa %p\n",i,(uint64)pte,(uint64)(PTE2PA(pte)));
            if((pte & (PTE_R|PTE_W|PTE_X)) == 0){
              // this PTE points to a lower-level page table.
              uint64 child = PTE2PA(pte);
              vmprint_helper((pagetable_t)child,level+1);
            }
          }
        }
      }

      // 打印页表
      void
      vmprint(pagetable_t pagetable)
      {
        // typedef uint64 *pagetable_t;所以pagetable可以以%p形式打印
        printf("page table %p\n",(uint64)pagetable);
        vmprint_helper(pagetable,1);
      }
      +
      void
      binit(void)
      {
        struct buf *b;

        initlock(&bcache.lock, "bcache");
        for(int i=0;i<NDEV;i++){
          char buf[10];
          snprintf(buf,9,"bcache%02d",i);
          initlock(&(bcache.dev_locks[i]), buf);
          bcache.dev_heads[i].prev = &(bcache.dev_heads[i]);
          bcache.dev_heads[i].next = &(bcache.dev_heads[i]);
        }

        // 初始时，每一个桶内都有一个buf结点
        b = bcache.buf;
        for(int i=0;i<NDEV;i++){
          b->next = bcache.dev_heads[i].next;
          b->prev = &bcache.dev_heads[i];
          initsleeplock(&b->lock, "buffer");
          bcache.dev_heads[i].next->prev = b;
          bcache.dev_heads[i].next = b;
          b++;
        }

        // Create linked list of buffers
        bcache.head.prev = &bcache.head;
        bcache.head.next = &bcache.head;
        for(; b < bcache.buf+NBUF; b++){
          b->next = bcache.head.next;
          b->prev = &bcache.head;
          initsleeplock(&b->lock, "buffer");
          bcache.head.next->prev = b;
          bcache.head.next = b;
        }
      }
      -

      问答题

      -

      Explain the output of vmprint in terms of Fig 3-4 from the text.

      -

      What does page 0 contain?

      -

      What is in page 2? When running in user mode, could the process read/write the memory mapped by page 1?

      -

      What does the third to last page contain?

      -
      -

      从上面操作系统的启动来看，进程1应该是在main.c中的userinit()中创建的进程，也是shell的父进程。【确实，经实践可得shell的pid为2】

      -

      可以来看一下userint的代码：

      -
      void
      userinit(void)
      {
        struct proc *p;

        p = allocproc();
        initproc = p;
        
        // 申请一页，将initcode的指令和数据放进去
        // allocate one user page and copy initcode's instructions
        // and data into it.
        /*
        uvminit的注释：
        	// Load the user initcode into address 0 of pagetable,
      	// for the very first process.
      	// sz must be less than a page.
        */
        uvminit(p->pagetable, initcode, sizeof(initcode));
        p->sz = PGSIZE;

        //为内核态到用户态的转变做准备
        // prepare for the very first "return" from kernel to user.
        /*
        Trap Frame是指中断、自陷、异常进入内核后,在堆栈上形成的一种数据结构
        */
        p->trapframe->epc = 0;      // user program counter
        p->trapframe->sp = PGSIZE;  // user stack pointer

        // 修改进程名
        safestrcpy(p->name, "initcode", sizeof(p->name));
        p->cwd = namei("/");

        //这个也许是为了能被优先调度
        p->state = RUNNABLE;

        release(&p->lock);
      }
      +
      void
      brelse(struct buf *b)
      {
        if(!holdingsleep(&b->lock))
          panic("brelse");

        uint dev = b->dev;
        releasesleep(&b->lock);

        acquire(&(bcache.dev_locks[dev]));
        b->refcnt--;
        if (b->refcnt == 0) {
          b->next->prev = b->prev;
          b->prev->next = b->next;
          release(&(bcache.dev_locks[dev]));

          acquire(&bcache.lock);
          b->next = bcache.head.next;
          b->prev = &bcache.head;
          bcache.head.next->prev = b;
          bcache.head.next = b;
          release(&bcache.lock);
        }else
          release(&(bcache.dev_locks[dev]));
      }
      -

      可见，page0是initcode的代码和数据，page1和page2用作了进程的栈，其中page1应该是guard page，page2是stack。

      -

      不过这里从exec的角度解释其实更通用：

      -
      int
      exec(char *path, char **argv)
      {
        //分配新页表
        if((pagetable = proc_pagetable(p)) == 0)
          goto bad;

        //elfhd应该指的是可执行文件头
        // Load program into memory.
        for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
      	//...
          //总之顺利读到了
          uint64 sz1;
          //读到了就给它分配新空间并且填入页表
          if((sz1 = uvmalloc(pagetable, sz, ph.vaddr + ph.memsz, flags2perm(ph.flags))) == 0)
            goto bad;
          sz = sz1;
        }

        //读完文件，开始造一个新的用户栈【fork之后用户栈是不会清空的】
        sz = PGROUNDUP(sz);
        uint64 sz1;
        if((sz1 = uvmalloc(pagetable, sz, sz + 2*PGSIZE, PTE_W)) == 0)
          goto bad;
        sz = sz1;
        // mark a PTE invalid for user access.造guard page
        uvmclear(pagetable, sz-2*PGSIZE);
        // sp为栈顶
        sp = sz;
        // 应该指的是栈尾
        stackbase = sp - PGSIZE;
        //...
      }
      +
      static struct buf*
      bget(uint dev, uint blockno)
      {
        acquire(&(bcache.dev_locks[dev]));

        // Is the block already cached?
        for(struct buf* b = bcache.dev_heads[dev].next; b != &(bcache.dev_heads[dev]); b = b->next){
          if(b->blockno == blockno){
            b->refcnt++;
            release(&(bcache.dev_locks[dev]));
            acquiresleep(&b->lock);
            return b;
          }
        }
        release(&(bcache.dev_locks[dev]));

        // 在head中找
        acquire(&bcache.lock);
        // Recycle the least recently used (LRU) unused buffer.
        for(struct buf* b = bcache.head.prev; b != &(bcache.head); b = b->prev){
          if(b->refcnt == 0) {
            b->dev = dev;
            b->blockno = blockno;
            b->valid = 0;
            b->refcnt = 1;
            release(&bcache.lock);
            acquiresleep(&b->lock);
            return b;
          }
        }
        panic("bget: no buffers");
      }
      -

      page0就填程序。这里重点说明一下为什么page1和page2分别是guard page和stack。

      -

      按照它的那个算术关系，stack和guard page的虚拟内存位置关系应该是这样的：

      -

      image-20230111004330079

      -

      那为什么最后在页表中，变成了page1是gurad page，page2是stack这样上下颠倒了呢？看vm.c中的uvmalloc就能明白。

      -

      image-20230111004500827

      -

      在253行设置了新映射。可以看到，这里设置映射的顺序是sz->sz+PGSIZE，也即先设置guard page的映射，再设置stack的映射。所以，这两位才会上下颠倒了。

      -

      Detecting which pages have been accessed

      -

      Some garbage collectors (a form of automatic memory management) can benefit from information about which pages have been accessed (read or write). In this part of the lab, you will add a new feature to xv6 that detects and reports this information to userspace by inspecting the access bits in the RISC-V page table. The RISC-V hardware page walker marks these bits in the PTE whenever it resolves a TLB miss.

      -
      -
      -

      Your job is to implement pgaccess(), a system call that reports which pages have been accessed.

      -

      The system call takes three arguments. First, it takes the starting virtual address of the first user page to check. Second, it takes the number of pages to check. Finally, it takes a user address to a buffer to store the results into a bitmask (a datastructure that uses one bit per page and where the first page corresponds to the least significant bit).

      -

      You will receive full credit for this part of the lab if the pgaccess test case passes when running pgtbltest.

      -
      -

      感想

      实验内容：

      -

      实现void pgaccess(uint64 sva,int pgnum,int* bitmask);，一个系统调用。在这里面，我们要做的是，访问从sva到sva+pgnum*PGSIZE这一范围内的虚拟地址对应的PTE，然后查看PTE的标记项是否有PTE_A。有的话则在bitmask对应位标记为1.

      -

      应该注意的点：

      -

      1.需要进行内核态到用户态的参数传递 2.需要进行系统调用的必要步骤 3.PTE_A需要自己定义

      -

      以上是初见。做完了发现，确实就是那么简单，我主要时间花费在下的实验版本不对，折腾来折腾去了可能有一个小时，最后还是选择了直接把测试函数搬过来手工调用。已经换到正确的年份版本了【泪目】

      -

      有一点我忽视了，看了提示才知道：

      +
      正确思路

      首先，大家似乎都是用blockno来hash的，这点就跟我的原始思路不一样了（。其实也很对，因为每个设备的使用频率是不平均的，用blockno来hash比用dev来hash其实会让访问次数更加平均。

      +

      然后就是怎么保证LRU依然OK。hints的做法是使用时间戳。我们可以在brelse的时候记录时间戳字段，在bget缺块的时候遍历hash table，找出对应timestamp最小的block即可。

      +

      历经了几小时的debug，代码最终正确。正确版本在下面的代码模块处。

      +
      debug过程

      coding过程其实很短暂，毕竟思路很直观。我一开始是按初见思路写的代码，然后再从初见思路改到正确思路，这个过程，给我埋下了极大的安全隐患【悲】

      +

      其实几个小时下来，很多细节都已经忘记了，接下来就说点印象比较深的吧。

      +

      首先，我使用了正确思路以来，依然出现了跟初见思路一样的错误，也即xv6正常boot，但是执行ls命令会有错误。但是，当我make clean之后再次make qemu，错误改变了，变成了xv6 boot失败，并且爆出错误panic:ilock:no type。

      -

      Be sure to clear PTE_A after checking if it is set. Otherwise, it won’t be possible to determine if the page was accessed since the last time pgaccess() was called (i.e., the bit will be set forever).

      +

      注：关于此处的make clean，有两点需要解释。一是为什么会做出make clean的行为，二是这个变化的原理是什么。

      +

      此处突然做出make clean的行为，是因为参照了该文章：

      +

      MIT6.S081 lab8 locks

      +

      image-20230123172138766

      +

      没想到我make clean之后反而就变成了他这样的问题23333也是感觉蛮惊讶的

      +

      这个的原理说实话我不大清楚。猜想可能是make qemu的某段访问磁盘初始化之类的代码只会执行一次，只有make clean之后才会让其执行第二次。所以我们手动完全boot了一遍操作系统，才会导致这个错误爆出来，否则，操作系统就会使用原本的正确boot版本启动，之后再执行命令就当然是错误的了。

      +

      我想知乎文章里也应该是这个原因。操作系统本来使用的是错误版本，make clean后才会重新使用正确版本。

      +

      我之后写对了又尝试了一下，觉得我的猜想应该是对的。我的执行路线：

      +
        +
      1. make qemu，得到正确结果
        2. +
      2. 将bio.c改回错误版本
        3. +
      3. 再次make qemu，发现xv6正常boot，但是执行ls命令会出以上同样的错误
        4. +
      4. make clean，然后make qemu，爆出panic:ilock: no type
        5. +
      +

      挺完美地符合了我的猜想。

      +

      【来自之后的学习：

      +

      in lab file system：

      +

      mkfs 程序创建 xv6 文件系统磁盘映像并确定文件系统总共有多少个块； 这个大小由 kernel/param.h 中的 FSSIZE 控制。 您会看到本实验存储库中的 FSSIZE 设置为 200,000 个块。 您应该在 make 输出中看到 mkfs/mkfs 的以下输出：
      nmeta 70 (boot, super, log blocks 30 inode blocks 13, bitmap blocks 25) blocks 199930 total 200000
      这一行描述了 mkfs/mkfs 构建的文件系统：它有 70 个元数据块（用于描述文件系统的块）和 199,930 个数据块，共计 200,000 个块。
      如果在实验期间的任何时候您发现自己必须从头开始重建文件系统，您可以运行 make clean 来强制 make 重建 fs.img。

      +

      可以看到，我们上面就是做了强制重构fs.img。】

      -

      也就是说每次检查到一个，就需要手动清除掉PTE_A标记。

      -

      还有一点以前一直没注意到的，头文件的引用需要注意次序。比如说要是把spinlock.h放在proc.h后面，就会寄得很彻底。

      -

      代码

      那些系统调用的登记步骤就先省略了。

      -
      // kernel/sysproc.c
      uint64
      sys_pgaccess(void)
      {
        uint64 sva;
        int pgnum;
        uint64 bitmask;

        if(argaddr(0,&sva) < 0 || argint(1, &pgnum) < 0 || argaddr(2, &bitmask) < 0)
          return -1;
        return pgaccess((void*)sva,pgnum,(void*)bitmask);
      }
      +

      我想来想去不知道这个错到底怎么爆的，看了下ilock()对应报错点：

      +
      // in fs.c ilock()
        if(ip->valid == 0){
          //printf("ilock begin.\n");
          bp = bread(ip->dev, IBLOCK(ip->inum, sb));
          dip = (struct dinode*)bp->data + ip->inum%IPB;
          ip->type = dip->type;
      	// ...
          ip->size = dip->size;
          memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
          brelse(bp);
          ip->valid = 1;
          if(ip->type == 0){
            //print_buf();
            printf("bp->blockno = %d, bp->refcnt = %d\n",bp->blockno,bp->refcnt);
            panic("ilock: no type");
          }
        }
      -
      // kernel/pgaccess.c
      #include "types.h"
      #include "param.h"
      #include "memlayout.h"
      #include "riscv.h"
      #include "spinlock.h"
      #include "defs.h"
      #include "proc.h"
      int
      pgaccess(void* sva,int pgnum,void* bitmask){
          if(pgnum > 32){
              printf("pgaccess: range too big.\n");
      		exit(1);
          }
          int kmask = 0;
          struct proc* p = myproc();
          for(int i=0;i<pgnum;i++){
              pte_t* pte = walk(p->pagetable,(uint64)sva+i*PGSIZE,0);
              // 映射不存在，或者没有被访问过
              if(!pte || !(*pte & PTE_A)){
                  continue;
              }
              kmask = (kmask | (1<<i));
              *pte = (*pte & (~PTE_A));
          }
          copyout(p->pagetable,(uint64)bitmask,(char*)(&kmask),sizeof(int)); 
          return 1;
      }
      +

      可知大概就是，ip的type为0这个非法数值就报错了，而ip的type来源于dip，dip又指向了bp的data，bp也就是我们在bio.c一直在打交道的buf结构体。所以说，其实问题是出在了buf上，我们的bread返回的是一个错误的buf。

      +

      那么，究竟是buf的哪里出错了呢？这个问题想了我很久很久很久，依然没想出来。我一直认为是我的hashtable+双向链表这个数据结构哪里写错了，反反复复看了三四遍，其他地方的逻辑也反反复复研究了好几遍，依然没有结论。当然此过程也抓出了很多bug，但抓完bug后报错仍在，非常坚挺。

      +

      快要放弃的时候，我发现了错误。这很大一部分归功于我用于调试的这个函数：

      +
      // 打印出hashtable的所有结点
      void
      print_buf(){
        printf("**********************\n");
        printf("cnt = %d,dec = %d\n",cnt,dec);
        for(int i=0;i<NBUCKET;i++){
        int should = !holding(&(bcache.dev_locks[i]));
         if(should)
           acquire(&(bcache.dev_locks[i]));
         printf("--------------\n");
         int tmp_cnt = 0;
         struct buf* b;
         for(b = bcache.dev_heads[i].next; b != &(bcache.dev_heads[i]); b = b->next){
         //for(b = bcache.dev_heads[i].prev; b != &(bcache.dev_heads[i]); b = b->prev){
           tmp_cnt++;
           printf("b.refcnt = %d,b.dev = %d,b.blockno = %d\n",b->refcnt,b->dev,b->blockno);
         }
         printf("%d:total:%d\n",i,tmp_cnt);
         printf("--------------\n");
         if(should)
           release(&(bcache.dev_locks[i]));
        }
      }
      -

      A kernel page table per process

      -

      The goal of this section and the next is to allow the kernel to directly dereference user pointers.

      -
      -
      -

      Your first job is to modify the kernel so that every process uses its own copy of the kernel page table when executing in the kernel.

      -

      Modify struct proc to maintain a kernel page table for each process, and modify the scheduler to switch kernel page tables when switching processes. For this step, each per-process kernel page table should be identical to the existing global kernel page table. You pass this part of the lab if usertests runs correctly.

      -
      -

      感想

      这个其实平心而论不难，思路很简单。写着不难是不难，但想明白花费了我很多时间。

      -

      它这个要求我们修改kernel，使得每个进程都有一份自己的kernel page。至于要改什么，围绕着proc.c中，参照pagetable的生命周期摁改就行。还有一个地方它也提示了，就是要在swtch之前更换一下satp的值。

      -

      接下来，我说说我思考的几个点以及犯错的地方。

      -
      为什么要这么干

      看完题目，我的第一印象是，这么干有啥用。。。因为我觉得以前那个所有进程共用内核页表确实很好了，没有必要每个进程配一个后来才发现，这个跟下面那个是连在一起的，目的是 allow the kernel to directly dereference user pointers.。所以，我们下面会把用户的pgtbl和这里dump出来的kpgtbl合在一起。

      -

      具体来说：

      -

      通常，进行地址翻译的时候，计算机硬件（即内存管理单元MMU）都会自动的查找对应的映射进行翻译（需要设置satp寄存器，将需要使用的页表的地址交给该寄存器）。

      -

      然而，在xv6内核需要翻译用户的虚拟地址时，因为内核页表不含对应的映射，计算机硬件不能自动帮助完成这件事。因此，我们需要先找到用户程序的页表，仿照硬件翻译的流程，一步一步的找到对应的物理地址，再对其进行访问。【walkaddr】这也就会导致copyin之类需要涉及内核和用户态交互的函数效率低下。

      -

      为了解决这个问题，我们尝试将用户页表也囊括进内核页表映射来。但是，如果将所有进程的用户页表都合并到同一个内核全局页表是不现实的。因而，我们决定换一个角度，让每个进程都仅有一张内核态和用户态共用的页表，每次切换进程时切换页表，这样就构造出了个全局的假象。

      -

      这两次实验就是为了实现该任务。在本次实验中，我们首先先实现内核页表的分离。

      -
      关于myproc()

      在allocproc中初始化的时候，我一开始是这么写的：

      -
      // in proc.c allocproc()
      perproc_kvminit();
      +

      我在ilock()的panic前面调用了这个函数，并且打印了出问题的buf的blockno：

      +
      if(ip->type == 0){
        print_buf();
        printf("bp->blockno = %d, bp->refcnt = %d\n",bp->blockno,bp->refcnt);
        panic("ilock: no type");
      }
      + +

      image-20230123174332113

      +

      可以看到，出问题的这里blockno=33，而在桶7中，首先有两个blockno==33的结点，这已经违反了不变性条件；其次有一个refcnt==1的结点，那个是所需结点，但我们却没有找到那个结点，反而去新申请了一个结点。这显然非常地古怪。

      +

      于是随后，我就在bio.c的bget()中添加了这么几句话：

      +

      image-20230123174620818

      +

      最终结果是会打印出两个blockno==0的结点，但是blockno==33的结点没有访问到。

      +

      这就很奇怪了。print_buf中以及bget的这个地方，都是遍历hashtable的某个双向链表，但是，为什么print_buf可以访问到，但是bget不行呢？

      +

      我首先对比出来的，是print_buf是逆序遍历，而bget是顺序遍历，所以我就又猜想是因为我的数据结构写错了，然而又看了一遍发现并不是。

      +

      这时候，可能我的视力恢复了吧，我猛然发现：：

      +

      image-20230123174921100

      +

      我超，这里是不是应该用hash。。。。。改完这处之后，果然就非常顺利地pass了所有测试【悲】

      +

      可以看到伏笔回收了。我是在旧思路代码基础上改过来的。旧思路代码是用dev作为index的，这个for循环忘记改了。因而，就这样，就这么寄了，看了我三四个小时【悲】

      +

      不过这倒是可以解释得通所有的错误了。之所以ilock中buf出错，没有正确找到已经映射在cache中的buf而是自己新建了一个，是因为，我压根就没有在正确的桶里找，而是在别的桶中找，这样自然就找不到了，就会自己新建一个，然后就寄了。

      +

      这个故事告诉我们，还是得谨慎写代码（）以及，我在旧代码基础上改的时候，其实可以用更聪明的替换方法：修改dev的变量名为hash->把参数里的dev变量名改为dev。这样就不会出错了。很遗憾，我并没有想到，只是很急很急地手动一个个改了，之后也没有检查，才发生如此错误。忏悔。

      +

      本次bug虽然很sb，但确实让我在debug过程中收获了些许，至少毅力变强了（）途中无数次想要放弃，还好我坚持了下来，才能看到如此感动的OK一片：

      +

      image-20230123170805666

      +

      代码

      +

      之后写学校实验时回过头来看，发现之前的实现是不对的，在同时进入bfree函数时有死锁风险。经过修改后虽然粒度大了但是安全了。对了，额外附上一版不知道为啥错了的细粒度版本……看了真感觉没什么问题，但依然是会在bfree时panic两次free。等以后有精力再继续研究吧（泪目）

      +

      错误版本的思路就是，使用每个block块自己的锁(b->lock)和每个桶的锁来实现细粒度加锁。我是左看右看感觉每个block从在bget中获取一直到brelse释放的b->lock锁是一直持有的，但确实依然有可能发生两个进程同时获取同一个block的锁的情况。实在不知道怎么办了，想了很久还是没想出细粒度好方法（泪）总之代码先放在这里。

      +
      +
      正确版本

      请见我的github。

      +
      错误版本
      static struct buf*
      bget(uint dev, uint blockno)
      {
        // printf("bget\n");
        uint hash = blockno % 13;

        acquire(&(bcache.dev_locks[hash]));

        // Is the block already cached?
        for(struct buf* b = bcache.dev_heads[hash].next; b != &(bcache.dev_heads[hash]); b = b->next){
          int initial_hold = holdingsleep(&b->lock);
          release(&(bcache.dev_locks[hash]));

          if (!initial_hold)
            acquiresleep(&b->lock);

          if(b->blockno == blockno&&b->dev == dev){ // 找到了
            b->refcnt++;
            b->timestamp = ticks;
            // release(&(bcache.dev_locks[hash]));
            // acquiresleep(&b->lock);
            return b;
          }

          if (!initial_hold)
            releasesleep(&b->lock);
          acquire(&(bcache.dev_locks[hash]));
        }

        release(&(bcache.dev_locks[hash]));

        // 没找到，进行LRU
        // 遍历hash table，找到LRU，也即时间戳最小的且refcnt小于0的那一项

        uint min_time = 4294967295;// uint的最大值。此处不能使用(uint)(-1)
        struct buf* goal = 0;
        for(int i = 0; i < NBUCKET; i++) {
          uint time = 0;
          acquire(&(bcache.dev_locks[i]));
          for(struct buf* b = bcache.dev_heads[i].prev; b != &(bcache.dev_heads[i]); b = b->prev){
            int initial_hold = holdingsleep(&b->lock);
            release(&(bcache.dev_locks[i]));
            if (!initial_hold) 
              acquiresleep(&b->lock);
            
            if(b->refcnt == 0) {
                time = b->timestamp;
                if(time < min_time){
                  min_time = time;
                  if (goal) releasesleep(&goal->lock);
                  goal = b;
                }
            }
            if (!initial_hold && goal != b)  releasesleep(&b->lock);
            acquire(&(bcache.dev_locks[i]));
          }
          release(&(bcache.dev_locks[i]));
        }
        // hashtable中存在着空闲buf
        if(goal != 0){
            // acquiresleep(&goal->lock);
            goal->dev = dev;
            goal->blockno = blockno;
            goal->valid = 0;
            goal->refcnt = 1;

            // 将goal从其所在双向链表中移除
            acquire(&(bcache.dev_locks[hash]));

            goal->prev->next = goal->next;
            goal->next->prev = goal->prev;

            // 在新双向链表中添加goal
            goal->prev = &(bcache.dev_heads[hash]);
            goal->next = bcache.dev_heads[hash].next;

            bcache.dev_heads[hash].next->prev = goal;
            bcache.dev_heads[hash].next = goal;

            release(&(bcache.dev_locks[hash]));

            return goal;
        }
        panic("bget: no buffers");
      }
      -
      // in vm.c
      pagetable_t
      perproc_kvminit()
      {
        struct proc* p = myproc();
        p->kpgtbl = (pagetable_t) kalloc();
        memset(p->kpgtbl, 0, PGSIZE);

        // uart registers
        pkvmmap(p->kpgtbl,UART0, UART0, PGSIZE, PTE_R | PTE_W);
        // ...
        return pt;
      }
      +
      void
      brelse(struct buf *b)
      {
        if(!holdingsleep(&b->lock))
          panic("brelse");

        uint hash = b->blockno%NBUCKET;

        acquire(&(bcache.dev_locks[hash]));
        b->refcnt--;
        b->timestamp = ticks;
        if (b->refcnt == 0) {
          // no one is waiting for it.
          b->next->prev = b->prev;
          b->prev->next = b->next;
          
          b->next = bcache.dev_heads[hash].next;
          b->prev = &bcache.dev_heads[hash];
          bcache.dev_heads[hash].next->prev = b;
          bcache.dev_heads[hash].next = b;
        }
        release(&(bcache.dev_locks[hash]));
        releasesleep(&b->lock);
      }
      -

      这样会死得很惨，爆出如下panic：

      -

      image-20230114011100370

      -

      通过hints的调试贴士

      +]]> + + + Interrupts and device drivers + /2023/01/10/xv6$chap5/ + Interrupts and device drivers
      +

      A driver is the code in an operating system that manages a particular device:

      +
        +
      1. configures the device hardware
        2. +
      2. tells the device to perform operations
        3. +
      3. handles the resulting interrupts
        4. +
      4. interacts with processes that may be waiting for I/O from the device
        5. +
      +

      Driver code can be tricky because a driver executes concurrently with the device that it manages.

      +

      In addition, the driver must understand the device’s hardware interface, which can be complex and poorly documented.

      +
      +

      如果devices需要让操作系统对某些事情做出响应，就要采取中断的方法。在kerneltrap中，内核响应中断，并且根据设备类型来决定中断处理函数。

      -

      A missing page table mapping will likely cause the kernel to encounter a page fault. It will print an error that includes sepc=0x00000000XXXXXXXX. You can find out where the fault occurred by searching for XXXXXXXX in kernel/kernel.asm.

      +

      image-20230115160523827

      +

      这段对设备中断的概述总结得非常到位

      +

      也就是说，一个device driver可以分为两部分实现，一部分是接收请求，然后开启read/write；另一部分是接收中断，这个中断有可能是设备完成IO，也可能是设备需要IO，它会通知设备具体怎么做，它也会唤醒恰当的进程。

      -

      我发现程序在这里绷掉了：

      -
      p->kpgtbl = (pagetable_t) kalloc();
      - -

      而且显而易见，是系统启动时崩的。

      -

      经过了漫长的思考，我震惊地发现了它为什么崩了（）

      -

      首先，这段代码语法上是没有问题的。它固然犯了发布未初始化完成的对象这样的并发错误【我有罪】，也破坏了proc的封装性【proc中的很多私有属性本来应该作用域仅在proc.c中的。此处为了能让vm.c访问到proc中的属性，不得不给vm.c添上了proc.h的头文件】，但是它并不是语法错误，还是能用的。我做了这样的测试样例证明它没有问题：

      -
      #include <stdio.h>
      #define MAX 10
      typedef int pagetable_t;

      struct proc{
      	pagetable_t kpgtbl;
      }; 

      struct proc processes[MAX];

      struct proc* myproc(){
      	return &processes[0];
      };

      void kvminit(){
      	myproc()->kpgtbl = 1;
      }

      int main(){
      	struct proc* p = &processes[0];
      	kvminit();
      	printf("%d",p->kpgtbl);
      	return 0;
      }
      - -

      我一路顺着os启动的路径找，也想不出来这能有什么错，因而非常迷茫。

      -

      此时我灵光一闪，会不会是myproc()在os刚启动的时候是发挥不了作用的？于是我一路顺着myproc的代码看下去：

      -
      struct proc*
      myproc(void) {
        push_off();
        struct cpu *c = mycpu();
        struct proc *p = c->proc;
        pop_off();
        return p;
      }
      - -

      那么，mycpu()获得的cpu的proc是怎么得到的呢？

      -

      我搜寻了一下os启动代码，发现了cpu的proc得到的路径。

      -
      void
      main()
      {
        if(cpuid() == 0){
          consoleinit();
          printfinit();
          printf("\n");
          printf("xv6 kernel is booting\n");
          printf("\n");
      	//...很多很多init
          userinit();      // first user process
          __sync_synchronize();
          started = 1;
        } else {
      	// ...
        }

        //调度执行第一个进程
        scheduler();        
      }
      +

      Code: Console input

      console driver是driver structure的一个实现案例。

      +

      上层逻辑

      shell获取用户输入console的信息是通过系统调用read()实现的。read通过文件描述符，最终转向consoleread()来实现具体的逻辑。

      +
      // in file.c fileread()
        } else if(f->type == FD_DEVICE){
          if(f->major < 0 || f->major >= NDEV || !devsw[f->major].read)
            return -1;
          r = devsw[f->major].read(1, addr, n);// 在这里转向console
        } 
      // in console.c consoleinit()
      void
      consoleinit(void)
      {
        initlock(&cons.lock, "cons");

        uartinit();

        // 在这里完成devsw的初始化
        // connect read and write system calls
        // to consoleread and consolewrite.
        devsw[CONSOLE].read = consoleread;
        devsw[CONSOLE].write = consolewrite;
      }
      -

      创建完进程后，就进入scheduler进行进程的调度：

      -
      void
      scheduler(void)
      {
        struct proc *p;
        struct cpu *c = mycpu();
        // ...
          int found = 0;
          for(p = proc; p < &proc[NPROC]; p++) {
      		// ...
              //在这里！！！！
              c->proc = p;
              swtch(&c->context, &p->context);

              c->proc = 0;
      // ...
      +

      对console的读写事实上是对cons结构体里buf的读写。这个buf则是由底层逻辑管理的。consoleread()每次读取buf中的一行，当未读满一行且无字符输入时会阻塞，直到底层逻辑将字符放入buf。读满了一行后，consoleread将该行copy进用户空间，随后返回read。

      +
      // in kernel/console.c 

      #define INPUT_BUF_SIZE 128
      struct {
        struct spinlock lock;
        char buf[INPUT_BUF_SIZE];
        uint r;  // Read index
        uint w;  // Write index
        uint e;  // Edit index
      } cons;


      // user read()s from the console go here.
      // copy (up to) a whole input line to dst.
      // user_dist indicates whether dst is a user
      // or kernel address.
      int
      consoleread(int user_dst, uint64 dst, int n)
      {
        uint target;
        int c;
        char cbuf;

        target = n;
        acquire(&cons.lock);
        while(n > 0){
          // wait until interrupt handler has put some
          // input into cons.buffer.
          // read和write的index一样，说明此时没有数据输入，阻塞
          while(cons.r == cons.w){
            if(killed(myproc())){
              release(&cons.lock);
              return -1;
            }
            sleep(&cons.r, &cons.lock);
          }
          // 产生数据输入，接收数据
          c = cons.buf[cons.r++ % INPUT_BUF_SIZE];

          if(c == C('D')){  // end-of-file
            if(n < target){
              // Save ^D for next time, to make sure
              // caller gets a 0-byte result.
              // 这样下一次也能访问到eof
              cons.r--;
            }
            break;
          }

          // copy the input byte to the user-space buffer.
          cbuf = c;
          if(either_copyout(user_dst, dst, &cbuf, 1) == -1)
            break;

          dst++;
          --n;

          if(c == '\n'){
            // a whole line has arrived, return to
            // the user-level read().
            break;
          }
        }
        release(&cons.lock);

        return target - n;
      }
      -

      因而，c->proc是在创建进程的第一次调度后初始化的，也即，myproc只有在执行第一次scheduler之后才可以调用。而！！！

      -

      当执行调度前的userinit时：

      -
      void
      userinit(void)
      {
        struct proc *p;

        p = allocproc();
        initproc = p;
      +

      底层逻辑

      底层逻辑维护了与上层逻辑交互的buf。

      +

      console接收数据对buf的读，是通过中断来实现的。

      +

      当用户输入字符，UART硬件检测到读，会向操作系统发送中断。中断在kerneltrap()中被接收处理，然后通过devintr()对该中断分门别类地进行转发。console的转发路径为devintr->uartintr->consoleintr。

      +

      UART

      UART的全称是Universal Asynchronous Receiver and Transmitter，即异步发送和接收。它的软件上的表示形式是a set of memory-mapped control registers。CPU通过物理地址与这些寄存器交互，也即它们跟RAM是同一个地址空间。在xv6中，UART的地址空间从UART0(0x1000 0000)开始。这些寄存器地址关于UART0的偏移量定义如下：

      +
      // the UART control registers.
      // some have different meanings for read vs write.
      // see http://byterunner.com/16550.html
      #define RHR 0                 // 接收寄存器receive holding register (for input bytes)
      #define THR 0                 // 发送寄存器transmit holding register (for output bytes)
      #define IER 1                 // 开关中断寄存器
      #define IER_RX_ENABLE (1<<0)  // 如果该位被设置，则在接收寄存器有数据，即想向外界发送数据时，UART会搓出一个中断
      #define IER_TX_ENABLE (1<<1)  // 如果该位被设置，则在发送寄存器有数据，即外界向硬件发送数据时，UART会搓出一个中断
      #define FCR 2                 // FIFO control register
      #define FCR_FIFO_ENABLE (1<<0)
      #define FCR_FIFO_CLEAR (3<<1) // clear the content of the two FIFOs
      // ...
      #define LCR 3                 // line control register
      // ...
      #define LSR 5                 // line status register
      #define LSR_RX_READY (1<<0)   // input is waiting to be read from RHR
      #define LSR_TX_IDLE (1<<5)    // THR can accept another character to send
      -

      它进行了allocproc。我们亲爱的allocproc接下来就会调用perproc_kvminit，然后perproc_kvminit中调用myproc。此时尚未进行初次调度，因而c->proc未初始化，myproc返回的是0，也即null。这样一来，myproc()->kpgtbl就发生了空指针异常，也即scause = 15——写入页错误。

      -

      因而，对于myproc()的调用需要慎之又慎。

      -
      系统调用

      系统调用时，是如何知道要用的是p中的内核页表而非global内核页表呢？

      -

      依然还是从os的启动说起。

      -

      在main.c中，kvminithart开启了页表，此时的页表为全局的内核页表：

      -
      // Switch h/w page table register to the kernel's page table,
      // and enable paging.
      void
      kvminithart()
      {
        w_satp(MAKE_SATP(kernel_pagetable));
        sfence_vma();
      }
      +
      +

      image-20230115170107044

      +

      例如，LSR寄存器包含指示输入字符是否正在等待软件读取的位。这些字符（如果有的话）可用于从RHR寄存器读取。每次读取一个字符，UART硬件都会从等待字符的内部FIFO寄存器中删除它，并在FIFO为空时清除LSR中的“就绪”位。UART传输硬件在很大程度上独立于接收硬件；如果软件向THR写入一个字节，则UART传输该字节。

      +
      +

      kerneltrap

      // in kerneltrap()
        // 在此处的devintr对不同的设备进行不同的处理方式
        if((which_dev = devintr()) == 0){
          printf("scause %p\n", scause);
          printf("sepc=%p stval=%p\n", r_sepc(), r_stval());
          panic("kerneltrap");
        }
      -

      当userinit被调度时，全局的内核页表被换成了proc中的内核页表：

      -
      // in proc.c scheduler()
      p->state = RUNNING;
      w_satp(MAKE_SATP(p->kpgtbl));
      sfence_vma();
      c->proc = p;
      swtch(&c->context, &p->context);
      +

      devintr

      devintr处在trap.c中，作用是对中断归类，然后分门别类地转发到下一层级的handler。

      +
      +

      注：

      +
        +

      1. 外中断和内中断

        +

        外部中断和内部中断详解

        +

        根据中断源的不同，可以把中断分为硬件中断和软件中断两大类，而硬件中断又可以分为外部中断和内部中断两类。

        +

        外部中断一般是指由计算机外设发出的中断请求，如：键盘中断、打印机中断、定时器中断等。外部中断是可以屏蔽的中断，也就是说，利用中断控制器可以屏蔽这些外部设备的中断请求。

        +

        内部中断是指因硬件出错（如突然掉电、奇偶校验错等）或运算出错（除数为零、运算溢出、单步中断等）所引起的中断。内部中断是不可屏蔽的中断。

        +

        软件中断其实并不是真正的中断，它们只是可被调用执行的一般程序。例如：ROM BIOS中的各种外部设备管理中断服务程序（键盘管理中断、显示器管理中断、打印机管理 中断等，）以及DOS的系统功能调用（INT 21H）等都是软件中断。【比如说系统调用之类的】

        +
        2. +
      +
      +
      // check if it's an external interrupt or software interrupt,
      // and handle it.
      // returns 2 if timer interrupt,
      // 1 if other device,
      // 0 if not recognized.
      int
      devintr()
      {
        // 获取scause，辨析中断类型
        uint64 scause = r_scause();

        // 如果来自外中断（在这里应该只指device interrupt）
        if((scause & 0x8000000000000000L) &&
           (scause & 0xff) == 9){
          // this is a supervisor external interrupt, via PLIC.

          // irq indicates which device interrupted.
          // 通过PLIC硬件获取中断设备信息
          int irq = plic_claim();

          // 分别转发
          if(irq == UART0_IRQ){
            uartintr();
          } else if(irq == VIRTIO0_IRQ){
            virtio_disk_intr();
          } else if(irq){
            printf("unexpected interrupt irq=%d\n", irq);
          }

          // 中断处理完成了，可以再次开启中断
          // the PLIC allows each device to raise at most one
          // interrupt at a time; tell the PLIC the device is
          // now allowed to interrupt again.
          if(irq)
            plic_complete(irq);

          return 1;
        // 来自时钟中断
        } else if(scause == 0x8000000000000001L){
          // ...
          return 2;
        } else {
          return 0;
        }
      }
      -

      但是这样还没有结束。因为我们除了得更换目前的页表，还得更换trapframe中的内核页表相关的东西：

      -
      struct trapframe {
        /*   0 */ uint64 kernel_satp;   // kernel page table
        /*   8 */ uint64 kernel_sp;     // top of process's kernel stack
      }
      +

      uartintr

      这代码其实乍一看是看不懂的，这是因为uartintr不止负责读中断。它还负责另一个中断（发送区空余中断），下面会细说。

      +
      // handle a uart interrupt, raised because input has
      // arrived, or the uart is ready for more output, or
      // both. called from devintr().
      void
      uartintr(void)
      {
        // read and process incoming characters.
        while(1){
          int c = uartgetc();
          // return -1 if none is waiting,说明读完了
          if(c == -1)
            break;
          // 每读入一个字符就转交给console
          consoleintr(c);
        }

        // send buffered characters.
        acquire(&uart_tx_lock);
        uartstart();
        release(&uart_tx_lock);
      }
      -

      为啥还要更换trapframe中的呢？因为以后系统调用的时候，uservec是从这里读取值来作为内核栈和内核页表的来源的：

      -
      # in uservec
      		# restore kernel stack pointer from p->trapframe->kernel_sp
              # 完成了内核栈的切换
              ld sp, 8(a0)

      		# 完成了页表的切换
              # restore kernel page table from p->trapframe->kernel_satp
              ld t1, 0(a0)
              csrw satp, t1
              sfence.vma zero, zero
      +

      consoleintr

      向buf中放入字符c

      +
      void
      consoleintr(int c)
      {
        acquire(&cons.lock);

        switch(c){
            case C('P'):  // Print process list.
            // ...一堆特殊情况处理...
            default:
              if(c != 0 && cons.e-cons.r < INPUT_BUF_SIZE){
                c = (c == '\r') ? '\n' : c;

                // echo back to the user.
                consputc(c);

                // store for consumption by consoleread().
                cons.buf[cons.e++ % INPUT_BUF_SIZE] = c;

                if(c == '\n' || c == C('D') || cons.e-cons.r == INPUT_BUF_SIZE){
                  // wake up consoleread() if a whole line (or end-of-file)
                  // has arrived.
                  // 中断处理并不会做很多事情，只是会与缓冲区交互
                  // 涉及到复杂的事情，比如说将数据拷贝到用户空间
                  //就唤醒上层逻辑来做
                  cons.w = cons.e;
                  wakeup(&cons.r);
                }
          	}
          	break;
        }
        
        release(&cons.lock);
      }
      -

      所以，为了以后系统调用能顺利自发进行，我们需要把栈帧也一起换掉。怎么换呢？我们是否还要在一些地方人工把trapframe的值设置为我们自己的内核栈内核页表？答案是，不用！这些会由其他代码自动完成。

      -

      前面说到userinit的进程p被调度，satp换成了我们自己的内核页表。那么，在之后的内核态，satp都将保持我们自己的内核页表。当要返回用户态时，会执行如下代码：

      -
      // in usertrapret
        // 重置trapframe
        p->trapframe->kernel_satp = r_satp();         // kernel page table
        p->trapframe->kernel_sp = p->kstack + PGSIZE; // process's kernel stack
      +

      Code: Console output

      外部通过write这个系统调用来对console写。

      +

      uartputc

      最先到达这里。

      +

      uart内置了一个缓冲区。

      +
      char uart_tx_buf[UART_TX_BUF_SIZE];
      -

      satp内的值为我们自己的内核页表，而非全局页表。因而这样栈帧中的页表就会被自然而然地写入为进程的内核页表。之后返回用户态，以及之后之后的各种中断，就都会一直使用自己的内核页表了。【试了一下，这里如果改成非即时从satp读，而是默认的kernel_pagetable的话，会一直死循环】

      -

      不得不说，真是设计精妙啊！！！不过我觉得，要是这里写成kernel_pagetable，然后让我们自己改的话将是薄纱（。当然它应该也不会这么做，因为，kernel_pagetable事实上是不对外发布的。它这里这么写热读，最直接的原因还是因为读不到kernel_pagetable。这算是无心插柳柳成荫吗233

      -
      释放页表但不释放物理内存

      其实答案就在它给的proc_freepagetable里。

      -
      // Free a process's page table, and free the
      // physical memory it refers to.
      void
      proc_freepagetable(pagetable_t pagetable, uint64 sz)
      {
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmunmap(pagetable, TRAPFRAME, 1, 0);
        uvmfree(pagetable, sz);
      }
      +

      用户仅需通过uartputc对buf进行写入即可，具体的buf数据向UART转移由uartputc通过调用uartstart实现。

      +
      // add a character to the output buffer and tell the
      // UART to start sending if it isn't already.
      // blocks if the output buffer is full.缓冲区满则阻塞
      // because it may block, it can't be called
      // from interrupts; it's only suitable for use
      // by write().这段话很有意思，说它由于会阻塞所以最好别在中断的时候用。
      void
      uartputc(int c)
      {
        acquire(&uart_tx_lock);

        if(panicked){
          for(;;)
            ;
        }
        // 阻塞
        while(uart_tx_w == uart_tx_r + UART_TX_BUF_SIZE){
          // buffer is full.
          // wait for uartstart() to open up space in the buffer.
          sleep(&uart_tx_r, &uart_tx_lock);
        }
        uart_tx_buf[uart_tx_w % UART_TX_BUF_SIZE] = c;
        uart_tx_w += 1;
        uartstart();
        release(&uart_tx_lock);
      }
      -

      uvmfree遍历页表，对每个存在的页表项，都试图找到其物理内存，并且释放物理内存和表项。如果页表项存在，但页表项对应的物理内存不存在，就会抛出freewalk leaf的异常。

      -

      uvmunmap会释放掉参数给的va的页表项，最后一个参数表示释放or不释放。

      -

      在这里，使用这两个的组合技，就可以达到不释放TRAMPOLINE和TRAPFRAME的物理内存，又不会让uvmfree出错的效果。

      -

      代码

      初始化

      初始化kpgtbl。由于现在内核栈存在各自的内核页表而非global内核页表中，所以在procinit中的对内核栈的初始化也得放在这：

      -
      // in proc.c allocproc()
        // An empty user page table.
        p->pagetable = proc_pagetable(p);
        if(p->pagetable == 0){
          freeproc(p);
          release(&p->lock);
          return 0;
        }

        p->kpgtbl = perproc_kvminit();

        char *pa = kalloc();
        if(pa == 0)
          panic("kalloc");
        uint64 va = KSTACK((int) (p - proc));
        pkvmmap(p->kpgtbl,va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
        p->kstack = va;
      +

      uartstart

      uartstart的作用是从缓冲区取数据向UART硬件发送。不阻塞。

      +
      // if the UART is idle, and a character is waiting
      // in the transmit buffer, send it.
      // caller must hold uart_tx_lock.
      // called from both the top- and bottom-half.
      void
      uartstart()
      {
        while(1){
          if(uart_tx_w == uart_tx_r){
            // transmit buffer is empty.
            return;
          }
          
          if((ReadReg(LSR) & LSR_TX_IDLE) == 0){
            // the UART transmit holding register is full,
            // so we cannot give it another byte.
            // it will interrupt when it's ready for a new byte.
            // 当缓冲区满没有选择阻塞，而是先结束
            // 当UART硬件准备好继续接收的时候，UART会发送transmit complete中断，到时候会再继续从buf读取
            return;
          }
          
          // 一个字符一个字符写
          int c = uart_tx_buf[uart_tx_r % UART_TX_BUF_SIZE];
          uart_tx_r += 1;
          
          // maybe uartputc() is waiting for space in the buffer.
          wakeup(&uart_tx_r);
          
          WriteReg(THR, c);
        }
      }
      -
      // in vm.c
      pagetable_t
      perproc_kvminit()
      {
        pagetable_t pt = (pagetable_t) kalloc();
        memset(pt, 0, PGSIZE);

        // uart registers
        pkvmmap(pt,UART0, UART0, PGSIZE, PTE_R | PTE_W);

        // virtio mmio disk interface
        pkvmmap(pt,VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);

        // CLINT
        pkvmmap(pt,CLINT, CLINT, 0x10000, PTE_R | PTE_W);

        // PLIC
        pkvmmap(pt,PLIC, PLIC, 0x400000, PTE_R | PTE_W);

        // map kernel text executable and read-only.
        pkvmmap(pt,KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);

        // map kernel data and the physical RAM we'll make use of.
        pkvmmap(pt,(uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);

        // map the trampoline for trap entry/exit to
        // the highest virtual address in the kernel.
        pkvmmap(pt,TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);
        return pt;
      }
      +

      当传输过程非常流畅，UART硬件没有阻塞时，以上的代码就能完美阐述发送的过程。但是当UART硬件的transmit阻塞时，过程就会有许多改动。

      +

      transmit complete interrupt

      在uartstart中，当UART硬件的transmit满，uartstart就直接return了。

      +

      当UART硬件的transmit空，就会发送transmit complete中断。中断在kerneltrap被接收，经过devintr转发，最终来到了uartintr：

      +
      // handle a uart interrupt, raised because input has
      // arrived, or the uart is ready for more output, or
      // both. called from devintr().
      void
      uartintr(void)
      {
        // read and process incoming characters.
        while(1){
          int c = uartgetc();
          if(c == -1)
            break;
          consoleintr(c);
        }

        // send buffered characters.
        acquire(&uart_tx_lock);
        uartstart();
        release(&uart_tx_lock);
      }
      -
      // in vm.c
      void
      pkvmmap(pagetable_t pgtbl,uint64 va, uint64 pa, uint64 sz, int perm)
      {
        // 当第一个进程开始时，mycpu->proc = null,所以这里不能调用myproc
        if(mappages(pgtbl, va, sz, pa, perm) != 0)
          panic("kvmmap");
      }
      +

      此时，第一个while循环会直接退出，因为压根没有get到字符。所以，这时候，就会去执行uartstart，然后继续读未完成读取的缓冲区。

      +

      等到所有都读完了，最后一次发送transmit complete中断时，会在uartstart进入该分支：

      +
      if(uart_tx_w == uart_tx_r){
        // transmit buffer is empty.
        return;
      }
      -
      swtch时切换页表
      // in proc.c scheduler()
      p->state = RUNNING;
      w_satp(MAKE_SATP(p->kpgtbl));
      sfence_vma();
      c->proc = p;
      swtch(&c->context, &p->context);

      //...

      	#if !defined (LAB_FS)
          if(found == 0) {
            // 没有进程运行时使用全局kernel_pagetable
            kvminithart();
            intr_on();
            asm volatile("wfi");
          }
      +

      然后就不会再发送transmit中断了。

      +

      感觉这点是真的牛逼。uartintr这个函数完美兼顾了两种情况【这也归功于uartstart做得很健壮】：1. 外部输入数据到console，2. 接收数据未结束，继续接收

      +

      Concurrency in drivers

      用户进程与设备之间的读写交流，比如说上面的console，重点依靠于uart_tx_buf和cons.buf这两个的正确性。因而，就需要保障它们的并发安全。在上面的代码中，使用到这两个的地方都被锁保护着。

      +

      在kernel中还需要格外注意的一点并发是，一个进程A在等待来自设备的中断，但此时另一个进程B在运行。这时候设备发出中断信号，CPU转入中断处理程序处理中断。此时，中断处理程序的执行不应该涉及到当前被中断进程的代码。例如，中断处理程序不能安全地使用当前进程的页表调用copyout（页表正是跟当前进程息息相关的）。中断处理程序通常做相对较少的工作（例如，只需将输入数据复制到缓冲区），并唤醒上半部分代码来完成其余工作。

      +

      Timer interrupts

      +

      Xv6 uses timer interrupts to maintain its clock and to enable it to switch among compute-bound processes; the yield calls in usertrap and kerneltrap cause this switching.

      +
      +
      // in kernel/trap.c usertrap()
        // give up the CPU if this is a timer interrupt.
        if(which_dev == 2)
          yield();
      -
      修改kvmpa
      #include "spinlock.h"
      #include "proc.h"

      uint64
      kvmpa(uint64 va)
      {
        uint64 off = va % PGSIZE;
        pte_t *pte;
        uint64 pa;

        pte = walk(myproc()->kpgtbl, va, 0);
        if(pte == 0)
          panic("kvmpa");
        if((*pte & PTE_V) == 0)
          panic("kvmpa");
        pa = PTE2PA(*pte);
        return pa+off;
      }
      +
      // in kernel/trap.c kerneltrap()
        // give up the CPU if this is a timer interrupt.
        if(which_dev == 2 && myproc() != 0 && myproc()->state == RUNNING)
          yield();
      -
      释放
      // in kernel.proc.c freeproc()
        if(p->kpgtbl)
          proc_freekpgtbl(p->kpgtbl,p->kstack);
        p->kpgtbl = 0;
      +
      +

      RISC-V requires that timer interrupts be taken in machine mode, not supervisor mode. As a result, xv6 handles timer interrupts completely separately from the trap mechanism laid out above.

      +
      +

      xv6启动时调用过start.c。start.c处于机器态，并准备向内核态过渡。start.c中就对时钟进行了初始化timeinit()。要做的有以下几件事：

      +
        +
      1. program the CLINT hardware (core-local interruptor) to generate an interrupt after a certain delay.
        2. +
      2. set up a scratch area to help the timer interrupt handler save registers and the address of the CLINT registers
        3. +
      3. start sets mtvec to timervec and enables timer interrupts.
        4. +
      +
      // arrange to receive timer interrupts.
      // they will arrive in machine mode at
      // at timervec in kernelvec.S,
      // which turns them into software interrupts for
      // devintr() in trap.c.
      void
      timerinit()
      {
        // each CPU has a separate source of timer interrupts.
        int id = r_mhartid();

        // ask the CLINT for a timer interrupt.
        int interval = 1000000; // cycles; about 1/10th second in qemu.
        *(uint64*)CLINT_MTIMECMP(id) = *(uint64*)CLINT_MTIME + interval;

        // prepare information in scratch[] for timervec.
        // scratch[0..2] : space for timervec to save registers.
        // scratch[3] : address of CLINT MTIMECMP register.
        // scratch[4] : desired interval (in cycles) between timer interrupts.
        uint64 *scratch = &timer_scratch[id][0];
        scratch[3] = CLINT_MTIMECMP(id);
        scratch[4] = interval;
        w_mscratch((uint64)scratch);

        // set the machine-mode trap handler.
        w_mtvec((uint64)timervec);

        // enable machine-mode interrupts.
        w_mstatus(r_mstatus() | MSTATUS_MIE);

        // enable machine-mode timer interrupts.
        w_mie(r_mie() | MIE_MTIE);
      }
      -
      extern char etext[];  // kernel.ld sets this to end of kernel code.

      void
      proc_freekpgtbl(pagetable_t pagetable,uint64 stack )
      {
        uvmunmap(pagetable, UART0, 1, 0);
        uvmunmap(pagetable, VIRTIO0, 1, 0);
        uvmunmap(pagetable, CLINT, 0x10000/(uint64)PGSIZE, 0);
        uvmunmap(pagetable, PLIC, 0X400000/(uint64)PGSIZE, 0);
        uvmunmap(pagetable, KERNBASE, (uint64)((uint64)etext-KERNBASE)/PGSIZE, 0);
        uvmunmap(pagetable, (uint64)etext,(PHYSTOP-(uint64)etext)/PGSIZE, 0);
        //kvmmap(KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);
        uvmunmap(pagetable, TRAMPOLINE, 1, 0);
        uvmunmap(pagetable, stack, 1,1 );
        uvmfree(pagetable, 0);
      }
      +
      +

      计时器中断处理程序必须保证不干扰中断的内核代码。基本策略是处理程序要求RISC-V发出“软件中断”并立即返回。RISC-V用普通陷阱机制将软件中断传递给内核，并允许内核禁用它们。处理由定时器中断产生的软件中断的代码可以在devintr (kernel/trap.c:204)中看到：

      +
      +
      // in kernel/trap.c devintr()
         } else if(scause == 0x8000000000000001L){
          // software interrupt from a machine-mode timer interrupt,
          // forwarded by timervec in kernelvec.S.

          // 只看其中一个CPU的时钟中断计数的意思吗？确实，要是好几个一起来加倍了非常不合理
          if(cpuid() == 0){
            clockintr();
          }
          
          // acknowledge the software interrupt by clearing
          // the SSIP bit in sip.
          w_sip(r_sip() & ~2);

          return 2;
        } 

      void
      clockintr()
      {
        acquire(&tickslock);
        ticks++;
        wakeup(&ticks);
        release(&tickslock);
      }
      -

      Simplify copyin/copyinstr

      -

      参考：

      -

      6.S081学习记录-lab3

      +

      注意，w_sip(r_sip() & ~2);就对应着“RISC-V用普通陷阱机制将软件中断传递给内核”。【应该吧个人理解】

      +
      +

      来源：rCore 手册（rCore tutorial doc）

      +

      riscv 中的中断寄存器

      +

      S 态的中断寄存器主要有 sie（Supervisor Interrupt Enable，监管中断使能）, sip （Supervisor Interrupt Pending，监管中断待处理）两个，其中 s 表示 S 态，i 表示中断， e/p 表示 enable (使能)/ pending (提交申请)。 处理的中断分为三种：

      +
        +
      1. SI(Software Interrupt)，软件中断
        2. +
      2. TI(Timer Interrupt)，时钟中断
        3. +
      3. EI(External Interrupt)，外部中断
        4. +
      +

      比如 sie 有一个 STIE 位， 对应 sip 有一个 STIP 位，与时钟中断 TI 有关。当硬件决定触发时钟中断时，会将 STIP 设置为 1，当一条指令执行完毕后，如果发现 STIP 为 1，此时如果时钟中断使能，即 sie 的 STIE 位也为 1 ，就会进入 S 态时钟中断的处理程序。

      +

      可能SSIP跟这里的STIP差不多吧，都是时钟中断的标志。如果把SSIP clear掉，那么则说明不是时钟中断了，而是软中断了。

      +
      +

      Real world

      +

      UART驱动程序读取UART控制寄存器，一次检索一字节的数据；因为软件驱动数据移动，这种模式被称为程序I/O（Programmed I/O）。程序I/O很简单，但速度太慢，无法在高数据速率下使用。需要高速移动大量数据的设备通常使用直接内存访问（DMA）。DMA设备硬件直接将传入数据写入内存，并从内存中读取传出数据。现代磁盘和网络设备使用DMA。DMA设备的驱动程序将在RAM中准备数据，然后使用对控制寄存器的单次写入来告诉设备处理准备好的数据。

      +

      当一个设备在不可预知的时间需要注意时，中断是有意义的，而且不是太频繁。但是中断有很高的CPU开销。因此，如网络和磁盘控制器的高速设备，使用一些技巧减少中断需求。一个技巧是对整批传入或传出的请求发出单个中断。另一个技巧是驱动程序完全禁用中断，并定期检查设备是否需要注意。这种技术被称为轮询（polling）。如果设备执行操作非常快，轮询是有意义的，但是如果设备大部分空闲，轮询会浪费CPU时间。一些驱动程序根据当前设备负载在轮询和中断之间动态切换。

      +

      UART驱动程序首先将传入的数据复制到内核中的缓冲区，然后复制到用户空间。这在低数据速率下是可行的，但是这种双重复制会显著降低快速生成或消耗数据的设备的性能。一些操作系统能够直接在用户空间缓冲区和设备硬件之间移动数据，通常带有DMA。

      +
      +

      Lab: networking

      +

      In this lab you will write an xv6 device driver for a network interface card (NIC).

      +

      这个概述光是听起来就让人觉得热血沸腾。网络的本质其实就是IO设备，这一点我一直觉得很牛逼，而现在我居然要亲手实现网络……That’s very cool.

      -

      The kernel’s copyin function reads memory pointed to by user pointers. It does this by translating them to physical addresses, which the kernel can directly dereference. It performs this translation by walking the process page-table in software. Your job in this part of the lab is to add user mappings to each process’s kernel page table (created in the previous section) that allow copyin (and the related string function copyinstr) to directly dereference user pointers.

      +

      On this emulated LAN, xv6 (the “guest”) has an IP address of 10.0.2.15.

      +

      Qemu also arranges for the computer running qemu to appear on the LAN with IP address 10.0.2.2.

      +

      When xv6 uses the E1000 to send a packet to 10.0.2.2, qemu delivers the packet to the appropriate application on the (real) computer on which you’re running qemu (the “host”).

      -

      Replace the body of copyin in kernel/vm.c with a call to copyin_new (defined in kernel/vmcopyin.c); do the same for copyinstr and copyinstr_new. Add mappings for user addresses to each process’s kernel page table so that copyin_new and copyinstr_new work.

      +

      We’ve added some files to the xv6 repository for this lab.

      +

      The file kernel/e1000.c contains initialization code for the E1000 as well as empty functions for transmitting and receiving packets, which you’ll fill in.

      +

      kernel/e1000_dev.h contains definitions for registers and flag bits defined by the E1000 and described in the Intel E1000 Software Developer’s Manual.

      +

      kernel/net.c and kernel/net.h contain a simple network stack that implements the IP, UDP, and ARP protocols.

      +

      These files also contain code for a flexible data structure to hold packets, called an mbuf.

      +

      Finally, kernel/pci.c contains code that searches for an E1000 card on the PCI bus when xv6 boots.

      -

      感想

      这题很直观的思路是，在每个user pagetable添加映射的地方也添加kpgtbl的映射。但问题是，“每个user pagetable添加映射的地方”都是哪？

      -
      误入幻想

      我一开始想着偷偷懒，直接在proc.c和vm.c中每个操纵pagetable的地方都加上对kpgtbl的操纵。但很快我就给搞晕了。这时候，我心中萌生一计【PS：下面说的最后都没成功】：我直接快进到把proc结构中的pagetable属性给删了，然后每个出现p->pagetable的地方，都用p->kpgtbl代替，直接让两表合为一表，然后之后make的时候哪里报错改哪里，这不就一劳永逸地把所有出现pagetable的地方都改为kpgtbl了嘛。我振奋地去试了一下，将所有地方出现的pagetable都替换成了kpgtbl，把proc.c中的proc_pagetable()和proc_freepagetable()的出现的地方都换成了perproc_kvminit()以及proc_freekpgtbl()，还做了一个小细节，就是在userinit中调用的uvminit中，我把这样：

      -
      void
      uvminit(pagetable_t pagetable, uchar *src, uint sz)
      {
        char *mem;

        if(sz >= PGSIZE)
          panic("inituvm: more than a page");
        mem = kalloc();
        memset(mem, 0, PGSIZE);
        mappages(pagetable, 0, PGSIZE, (uint64)mem, PTE_W|PTE_R|PTE_X|PTE_U);
        memmove(mem, src, sz);
      }
      - -

      换成了这样：

      -
      void
      uvminit(struct proc* p, uchar *src, uint sz)
      {
        char *mem;

        if(sz >= PGSIZE)
          panic("inituvm: more than a page");
        mem = kalloc();
        memset(mem, 0, PGSIZE);
        mappages(p->kpgtbl, 0, PGSIZE, (uint64)mem, PTE_W|PTE_R|PTE_X|PTE_U);
        memmove(mem, src, sz);
      }
      - -

      最后，在启动的时候，卡在了初次调度切换不到initcode这边，没有调用exec。没有panic，似乎只在死循环。我也实在想不出是什么原因，最后把代码删了【悲】想想我应该用git保存一下改前改后的。这下实在是难受了，我的想法也暂时没有机会实践了。等到明年大三说不定还得再交一次这玩意，到时候再探究探究吧hhh

      -
      走上正途

      发现这个最后没成还改了半天的我最后非常沮丧地去看了hints【又一心浮气躁耐心不足的表现，但确实绷不住了】，发现它居然说只用修改三个地方：fork、exec以及sbrk。

      -

      我把kernel/下的每个文件都搜了一遍，发现确实，只有这三个，以及proc.c，vm.c，涉及到对页表项的增删。而在用户态中，想要对进程的内存进行管理，似乎只能通过系统调用sbrk。而proc.c和vm.c中确实没什么好改的。因为里面增加的映射，都是trapframe、trampoline、inicode这种不会一般在copyin中用到的虚拟地址。所以，要改的地方，确确实实，只有fork、exec以及sbrk。

      -

      Xv6 applications ask the kernel for heap memory using the sbrk() system call.

      +

      Your job：

      +

      Your job is to complete e1000_transmit() and e1000_recv(), both in kernel/e1000.c, so that the driver can transmit and receive packets. You are done when make grade says your solution passes all the tests.

      -

      很悲伤，我的初见思路是错误的（）

      -

      而这三个地方的共同点，就是都会对页表进行大量的copy。

      -
      //in proc.c fork()
        // Copy user memory from parent to child.
        if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
          freeproc(np);
          release(&np->lock);
          return -1;
        }
      - -
      //in exec.c
        // Commit to the user image.
        oldpagetable = p->pagetable;
        p->pagetable = pagetable;
      - -
      //in syscall.c
      uint64
      sys_sbrk(void)
      {
        int addr;
        int n;

        if(argint(0, &n) < 0)
          return -1;
        addr = myproc()->sz;
        if(growproc(n) < 0)
          return -1;
        return addr;
      }
      //in proc.c growproc()
      uvmalloc(p->pagetable, sz, sz + n)) == 0
      - -

      所以，我们要做的事情很简单：写一个坐收渔翁之利的函数，内容为把一个页表的所有内容复制到另一个页表。然后再在这几个地方调用这个函数即可。

      -

      代码

      -

      注意：由于我写得实在是太烦了，已经思考不下去了。为了放过我自己，我写了个虽然能过得去测试但是其实毛病重重的代码。垃圾点为以下几点：

      +

      感想

      说实话，一开始看题的时候真是感觉非常地哈人……但其实文档看着看着，心中也逐渐有了个大概，最后再结合下指导书的提示【当然不是后面那些保姆级的Hints】，最后写的也就八九不离十了。总体上来说，我觉得这次实验的代码还是很简单的，它主要难在探究过程，也就是从一开始什么也不懂，然后去阅读硬件设备的文档，结合代码尝试去理解，最后一步步写出来的过程。本次实验耗时六小时，我觉得肯定有不少于一半，甚至可能达到2/3的时间都耗费在理解上。这种从零开始探究的过程给了我很大的收获，同时也稍微提高了我面对挫折的能力。

      +

      这个实验确实设计得很有教育意义。除了我上面说的它锻炼了我的能力以外，它其实还具有比较深刻的工业意义。在看书的时候，书中这么写道：

      +
      +

      In addition, the driver must understand the device’s hardware interface, which can be complex and poorly documented.

      +
      +

      本次实验正是上述描述的简化版：E1000的文档很详细，并且我们只用掌握一部分它的功能就行了。但虽然简化了，其探究过程的内在逻辑还是不会改变的。

      +

      总之，我很喜欢这次实验的设计。我的评价是牛逼。

      +

      思路

      正确思路

      Hints写得很详细，不做赘述了。主要就是明确一下数据结构的问题：

        -

      1. 需要去掉freewalk中的panic

        -

        我的kvmcopy的实现是，user pagetable（下面简称up）和tp的相同虚拟地址共用同一页物理内存。也就是说，页表不一样，但所指向的物理内存是同一个。这样设计的目的是为了能够让tp及时用到up的更新后的数据。

        -

        这会导致啥呢？在进程释放时，需要一起调用proc_freepagetable和proc_freekpgtbl。proc_freepagetable调用完后，所指向的那堆物理内存已经寄完了，如果再调用proc_freekpgtbl，显然，就会发生页表未释放但页表对应内存已经释放的问题，freewalk就会panic。因此，我简单粗暴地直接把freewalk的panic删掉了【抖】也许有别的解决方法，但我真是烦得不想想了放过我吧（

        +

      2. rx_ring和tx_ring是两个分开的队列

        +

        它们只是结构一模一样，都是阴影部分表示software持有，白色部分表示硬件持有。

        +

        因而，对于rx来说，白色部分表示需要传给协议栈的包，因而我们需要把白色部分转化为阴影部分；对于tx来说，白色部分表示网卡将要发送的包，因而我们需要把阴影部分转化为白色部分。

        +

        image-20230220234406239

        3. -

      3. 好像暂时没有第二点了（）

        +

      4. rx_mbufs和tx_mbufs

        +

        一开始不知道这俩是啥，后来才意识到，这俩和第1点的那俩其实是下标一一对应的关系。也就是说rx_ring[i]这个descriptor接收到的数据存在rx_mbufs[i]，tx_ring[i]要发送的数据存在tx_mbufs[i]。知道了这个之后，代码就简单了。

        +
        +

        忏悔：我一开始真没反应过来。计网我记得是有一模一样的结构的，看来算是白做了2333

        +
      +

      个人的推理过程

      一开始就先懵懵懂懂地看指导书，直到看到这句话：

      +
      +

      Browse the E1000 Software Developer’s Manual.

      -
      渔翁之利函数
      // in vm.c
      // 效仿的是vm.c中的uvmcopy
      int
      kvmcopy(pagetable_t up, pagetable_t kp, uint64 sz)
      {  
        pte_t *pte;
        uint64 pa, i;
        uint flags;

        for(i = 0; i < sz; i += PGSIZE){ 
          if((pte = walk(up, i, 0)) == 0 || (*pte & PTE_V) == 0){
              if(walk(kp,i,0) == 0){
                  //如果up不存在此项，kp存在，就直接删了
                  uvmunmap(kp,i,PGSIZE,0);
              }
              continue;
          }
          pa = PTE2PA(*pte);
          flags = PTE_FLAGS(*pte);
          // 注意去除PTE_U，否则内核态无法访问
          flags = (flags & (~PTE_U));
          if(mappages(kp, i, PGSIZE, pa, flags) != 0){
            goto err;
          }
        }
        return 0;

       err:
        uvmunmap(kp, 0, i / PGSIZE, 1);
        return -1;
      }
      - -
      修改fork、exec、sbrk
      fork
      // in proc.c fork()
        // Copy user memory from parent to child.
        if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
          freeproc(np);
          release(&np->lock);
          return -1;
        }
        if(kvmcopy(np->pagetable, np->kpgtbl, p->sz) < 0){
          freeproc(np);
          release(&np->lock);
          return -1;
        }
      - -
      exec
      // in exec.c
        // Commit to the user image.
        oldpagetable = p->pagetable;
        p->pagetable = pagetable;

        p->sz = sz;
        p->trapframe->epc = elf.entry;  // initial program counter = main
        p->trapframe->sp = sp; // initial stack pointer
        proc_freepagetable(oldpagetable, oldsz);

        // 添上此句
        kvmcopy(p->pagetable, p->kpgtbl, p->sz);
      - -
      sbrk
      uint64
      sys_sbrk(void)
      {
        int addr;
        int n;

        if(argint(0, &n) < 0)
          return -1;
        addr = myproc()->sz;
        if(addr+n >= PLIC)    return -1;
        if(growproc(n) < 0)
          return -1;
        return addr;
      }
      - -
      // in proc.c
      // Grow or shrink user memory by n bytes.
      // Return 0 on success, -1 on failure.
      int
      growproc(int n)
      {
        uint sz;
        struct proc *p = myproc();

        sz = p->sz;
        // ...
        p->sz = sz;
        // 加这个
        kvmcopy(p->pagetable, p->kpgtbl, p->sz);
        return 0;
      }
      +

      然后我这时连自己要干什么都迷迷糊糊，但姑且还是按他下面说的，准备先浏览第二章了。然而，我发现要我看我也还是看不懂啊，所以我就直接放弃了。【经验1：看不懂就算了，别死磕了】

      +

      我放弃了第二章后，就再次从头开始细细看了一遍这句话之前的指导书，也结合了一下它给的代码。这次总算是差不多弄懂这次要做什么了：

      +

      实现driver的两个函数，从而实现对网卡进行数据的取出和送入。数据是eth frame。数据取出后要通过net_rx传递给上层协议栈。数据是mbuf类型的。

      +

      所以我们只需实现协议栈最底下的部分，也即从网卡读写数据，其他一些别的东西比如协议栈什么的都已经写好了。

      +

      但是那些什么rx_ring，还有各种奇奇怪怪的寄存器，我都看不懂，所以我就去看第三章了。初次略过一遍感觉还是一脸懵逼不知道干什么，但我带着“我们要做的是driver”这样的想法，在第二遍细看的时候有意区分开什么是网卡硬件帮我们做的，什么是我们的driver软件需要做的（经验2：明确要做什么。我们需要做的是软件部分，它的文档一般会说Software should XXX，密切关注这部分就行），就差不多有了点实现的雏形：

      +
      for recv:
        // 通过net_rx，网络包可以发送到udp顶层.
        // 所以说，我们在这里的目的就是，通过与硬件网卡e1000进行交互，
        // 取出e1000所接收到的数据包，检查数据的完整性，然后再把数据封装进mbuf结构体中，再通过net_rx传到上层

        // 取出数据包
        // 数据包存储在网卡的缓冲区中
        // 一是获取网卡缓冲区长度的长度
        // 网卡缓冲区长度存储在RCTL.BSIZE & RCTL.BSEX中
        /*
         *RCTL.BSEX = 0b:
      00b = 2048 Bytes.
      01b = 1024 Bytes.
      10b = 512 Bytes.
      1b1 = 256 Bytes.
      RCTL.BSEX = 1b:
      00b = Reserved; software should not program this value.
      01b = 16384 Bytes.
      10b = 8192 Bytes.
      11b = 4096 Bytes
         *
         * */
        // 二是获取数据包存放在哪个地址
        // 数据包的buffer cache的地址存储在descriptor的字段中
        // 必须读取多个descriptor以确定跨越多个接收缓冲区的数据包的完整长度。
        // 那么我们要读取的这些descriptor存放在哪呢？
        // 看文档，似乎差不多意思是这些descriptor被以环形队列的形式组织在一起，也许正是
        // 本文件内的rx_ring这个数组。
        // 当有descriptor到达e1000，e1000就会把它从host memory中取出来，存入到descriptor ring
        // 也即我们rx_ring数组
        //
        // 所以我们要做的，就是遍历rx_ring数组，如果rx_ring数组中的元素是used的，那么表明它就是数据包的一部分
        // 也即它地址所指向的buf里存放的是数据包的一部分数据
        // 
        // 那么我们怎么知道这个rx_ring的元素有没有used，以及它是第几个呢?
        // 检查descriptor有没有used：status字段不为全0则为used
        // 并且硬件要求，我们在发现这个descriptor的status不为0，并且用完这个descriptor之后，需要将
        // 其status字段置零，以供硬件使用
        // Status information indicates whether the descriptor has been used and whether the referenced 
        // buffer is the last one for the packet.

        // 三是获取数据包的数据
        // 我们需要获取decriptor的该字段，然后再从这个地址读取数据包数据
        // 网卡和内存统一编址，这个数据实际上就是网卡的buffer
        // 我们应该直接通过read这个系统调用就可以对其进行读写了

        // check数据包
        // 检查RDESC.ERRORS位，如果包发生了错误，再检查，如果发现RCTL.SBP、RCTL.UPE/MPE都被标记，
        // 就接收这个包，否则直接丢弃
      -
      userinit
      -

      这一步不能忽视，因为内核启动的时候就需要用到copyinstr。

      +

      可以看到，跟正确思路虽然很多细节理解上有点问题，但是大体框架还是大差不差。然后再阅读指导书：

      +
      +

      When the E1000 receives each packet from the ethernet, it first DMAs the packet to the mbuf pointed to by the next RX (receive) ring descriptor, and then generates an interrupt. 【这句话可得知，descriptor们存放在代码中的rx_ring中。】

      +

      Your e1000_recv() code must scan the RX ring and deliver each new packet’s mbuf to the network stack (in net.c) by calling net_rx(). You will then need to allocate a new mbuf and place it into the descriptor, so that when the E1000 reaches that point in the RX ring again it finds a fresh buffer into which to DMA a new packet.

      +
      +

      就差不多是正确思路了。transmit的实现也是同理

      +

      代码

      +

      以下代码不知道为什么过不了test，我跟别人的逻辑一模一样也还是不行emmm

      +

      它的问题是，不会接收到外界的返ping，导致进程一直等待网卡IO，所以kerneltrap一直触发不了，无法正常网卡读写，从而导致fileread会一直处于sleep等待状态，整个系统就沉睡了【】我感觉应该是transmit没发成功。

      +

      等以后有精力再来看看吧。

      -
      // in proc.c userinit()
        uvminit(p->pagetable, initcode, sizeof(initcode));
        p->sz = PGSIZE;
        // 加这个！
        kvmcopy(p->pagetable, p->kpgtbl, p->sz);
      - -
      删掉freewalk的panic（我特有的缺点）
      // in vm.c freewalk()    
          if((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0){
            // ...
          } else if(pte & PTE_V){
            //panic("freewalk: leaf");
          }
      +
      int
      e1000_transmit(struct mbuf *m)
      {
        acquire(&e1000_lock);
        struct tx_desc tx = tx_ring[regs[E1000_TDT]];
        if((tx.status & 1) == 0){
          release(&e1000_lock);
          return -1;
        }
        if(tx_mbufs[regs[E1000_TDT]] != 0)    mbuffree(tx_mbufs[regs[E1000_TDT]]);
        tx.addr = (uint64) m->head;
        tx.length = m->len;
        tx.status |= 1;// EOP
        tx.cmd |= 1;//EOP
        tx.cmd |= 8;//RS
        tx_mbufs[regs[E1000_TDT]] = m;
        regs[E1000_TDT] = (regs[E1000_TDT]+1)%TX_RING_SIZE;
        // printf("send successful!\n");
        release(&e1000_lock);
        return 0;
      }

      static void
      e1000_recv(void)
      {
        printf("go into e1000_recv\n");
        acquire(&e1000_lock);
        while(1){
        //while(regs[E1000_RDT]!=regs[E1000_RDH]){
          printf("go into while\n");
          regs[E1000_RDT] = (regs[E1000_RDT] + 1)%RX_RING_SIZE;
          int i=regs[E1000_RDT];
          if(rx_ring[i].status != 0){
            // 包含所需数据包
            // 检查是否发生了错误
            //if((rx_ring[i].status & 1) !=0 && (rx_ring[i].status & 2) != 0){
        //      // error字段有效
        //    if(rx_ring[i].errors != 0){
                // 发生错误，直接丢弃
        //      goto end;
        //    }
            if((rx_ring[i].status & 1) == 0){
            release(&e1000_lock);
              return ;
            }
            // 将地址对应数据包发送
            struct mbuf* m = rx_mbufs[i];
            m->len = rx_ring[i].length;
            net_rx(m);
          rx_ring[i].status = 0;
            struct mbuf* mbuf = mbufalloc(MBUF_DEFAULT_HEADROOM);
            rx_ring[i].addr = (uint64) mbuf->head;
            rx_mbufs[i] = mbuf;
          }
        }

        release(&e1000_lock);
      }
      ]]> - xv6 - /2023/01/10/xv6/ - -

      总耗时：120h 约27天

      -

      部分地方的翻译和表格来源参考：xv6指导书翻译

      -

      部分文本来自：操作系统实验指导书 - 2023秋季 | 哈工大（深圳）

      -

      实验官网：6.S081

      -

      代码以github为准，此处记录的有些小瑕疵

      -

      笔记的结构【以第一章Operating system interface为例】：

      -

      image-20230124235649128

      -
      -

      Operating system interface

      Operating system oganization

      Page tables

      Traps and system calls

      Interrupts and device drivers

      Locking

      Scheduling

      File system

      其他的对实验未涉及的思考

      ]]> - - labs - + 各种配环境中遇到的问题 + /2023/10/12/%E5%90%84%E7%A7%8D%E9%85%8D%E7%8E%AF%E5%A2%83%E4%B8%AD%E9%81%87%E5%88%B0%E7%9A%84%E9%97%AE%E9%A2%98/ + 记录一次vm扩容

      +

      开发中遇到的链接小问题

      +

      rtt硬件环境搭建

      +

      内核编译

      +]]>       其他的对实验未涉及的思考 @@ -10659,851 +10573,1140 @@ url访问填写http://localhost/webdemo4_war/*.do。

      3. QEMU在初始化过程中会创建好模拟芯片组和必要的模拟设备，包括南北桥芯片、PCI根总线、ISA根总线等总线系统，以及各种PCI设备、ISA设备等。

      外设虚拟化主要有如下几种方式：

        -

      1. 纯软件模拟（完全虚拟化）

        -

        QEMU最早的方案，虚拟机内核不用做任何修改，每一次对设备的寄存器读写都会陷入到KVM，进而到QEMU，QEMU再对这些请求进行处理并模拟硬件行为。

        -

        软件模拟会导致非常多的QEMU/KVM接入，效率低下。

        -
        2. -

      2. virtio设备（半虚拟化）

        -

        virtio设备是一类特殊的设备，并没有对应的物理设备，所以需要虚拟机内部操作系统安装特殊的virtio驱动。

        -

        相比软件模拟，virtio方案提高了虚拟设备的性能。

        +

      3. 纯软件模拟（完全虚拟化）

        +

        QEMU最早的方案，虚拟机内核不用做任何修改，每一次对设备的寄存器读写都会陷入到KVM，进而到QEMU，QEMU再对这些请求进行处理并模拟硬件行为。

        +

        软件模拟会导致非常多的QEMU/KVM接入，效率低下。

        +
        4. +

      4. virtio设备（半虚拟化）

        +

        virtio设备是一类特殊的设备，并没有对应的物理设备，所以需要虚拟机内部操作系统安装特殊的virtio驱动。

        +

        相比软件模拟，virtio方案提高了虚拟设备的性能。

        +
        5. +

      5. 设备直通

        +

        将物理硬件设备直接挂到虚拟机上，虚拟机直接与物理设备交互，尽可能在I/O路径上减少QEMU/KVM的参与。

        +

        设备直通经常搭配硬件虚拟化支持技术SRIOV（Single Root I/O Virtualization，单根输入/输出虚拟化）使用，SRIOV能够将单个的物理硬件高效地虚拟出多个虚拟硬件。

        +
        6. +
      +

      v2-555d017ce5b65457f98617a5fdf232af_1440w

      +
      中断处理虚拟化

      操作系统通过写设备的I/O端口或者MMIO地址来与设备交互，设备通过发送中断来通知操作系统事件。

      +

      QEMU/KVM一方面需要完成这项中断设备的模拟，另一方面需要模拟中断的请求处理。

      +
      +

      QEMU支持单CPU的Intel 8259中断控制器以及SMP的I/O APIC（I/O Advanced Programmable Interrupt Controller）和LAPIC（Local Advanced Programmable Interrupt Controller）中断控制器。在这种方式下，虚拟外设通过QEMU向虚拟机注入中断，需要先陷入到KVM，然后由KVM向虚拟机注入中断，这是一个非常费时的操作。

      +

      为了提高虚拟机的效率，KVM自己也实现了中断控制器Intel 8259、I/O APIC以及LAPIC。用户可以有选择地让QEMU或者KVM模拟全部中断控制器，也可以让QEMU模拟Intel 8259中断控制器和I/O APIC，让KVM模拟LAPIC。

      +
      +

      xv6的全启动运行过程梳理

      介绍完上述的qemu虚拟化，接下来就可以对xv6的全启动进行一个梳理了。

      +

      首先，在宿主机执行make qemu。

      +

      在Makefile中可以看到：

      +
      qemu: $K/kernel fs.img
              $(QEMU) $(QEMUOPTS)
      QEMU = qemu-system-riscv64
      + +

      在log中可以看到：

      +
      ...
      mkfs/mkfs fs.img README user/xargstest.sh user/_cat user/_echo user/_forktest user/_grep user/_init user/_kill user/_ln user/_ls user/_mkdir user/_rm user/_sh user/_stressfs user/_usertests user/_grind user/_wc user/_zombie user/_mmaptest
      ...
      qemu-system-riscv64 -machine virt -bios none -kernel kernel/kernel -m 128M -smp 3 -nographic -drive file=fs.img,if=none,format=raw,id=x0 -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0

      xv6 kernel is booting

      hart 2 starting
      hart 1 starting
      init: starting sh
      $
      + +

      具体的Makefile相关内容我不大了解，但结合输出，我想大概是先通过riscv64-linux-gnu-gcc编译链接完所有文件，然后再执行mkfs产生fs.img镜像（mkfs后面那些东西应该是文件参数，对应于源码中的读取可执行程序进磁盘的部分），最后再运行qemu-system-riscv64开始对虚拟机进行boot。

      +

      boot直至启动后的所有代码，都是通过QEMU-KVM架构处理，直接运行在宿主机的CPU上的。其余的各种管理，可以详见小标题虚拟机在QEMU-KVM架构的执行方法。

      +

      mkfs的作用及源码解读

      作用

      上面的知识表明，操作系统的启动在于文件系统初始化之后，这是因为操作系统本身的启动代码，放在磁盘映像fs.img中，而fs.img正是由文件系统初始化时弄出来的。也就是说，文件系统是操作系统的爸爸。【我以前一直以为是反过来的】

      +

      image-20230121162324747

      +
      +

      图中的boot块就是操作系统的引导扇区。

      +
      +

      而mkfs的作用，正是把宿主机提供的虚拟地址空间作为虚拟磁盘，把虚拟地址空间划分为如上图所示的地址结构。它是运行在宿主机当中的。有了mkfs，才能有我们的虚拟机。

      +
      代码解读

      xv6分析–mkfs源代码注释

      +

      yysy这个就写得很好了。

      +

      user mem-allocator

      +

      linux的堆管理

      +

      那么malloc到底是怎么实现的呢？不是每次要申请内存就调一下系统调用，而是程序向操作系统申请⼀块适当⼤⼩的堆空间，然后由程序⾃⼰管理这块空间，⽽具体来讲，管理着堆空间分配的往往是程序的运⾏库。

      +

      也就是说，malloc本质上是以运行库而非系统调用形式出现的。它里面用到的是sbrk和mmap这两个系统调用来进货。

      +

      glibc的malloc函数是这样处理⽤户的空间请求的：对于⼩于128KB的请求来说，它会在现有的堆空间⾥⾯，按照堆分配算法为它分配⼀块空间并返回；对于⼤于128KB的请求来说，它会使⽤mmap()函数为它分配⼀块匿名空间，然后在这个匿名空间中为⽤户分配空间。

      +
      +

      在内核态中，我们使用kalloc和kfree来申请和释放内存页。在用户态中，我们使用malloc和free来对动态内存进行管理。【也就是说这个实现的是堆管理】

      +

      内核中的最小单位只能是页，但user mem-allocator对外提供的申请内存服务的最小单位不是页，而是sizeof(Header)。因而，这就需要我们的user mem-allocator进行数据结构的管理，来统一这二者的实现。

      +

      数据结构

      环形链表

      user mem-allocator的数据结构是环形链表，起始结点为一个空数据载体。

      +

      image-20230316140158908

      +

      image-20230316140450988

      +

      地址从低到高

      链表的头结点的存储地址/所代表的内存地址的地址数值最小，并且其余结点按遍历顺序地址递增。

      +

      具体实现

      user mem-allocator由三个主要函数组成，分别是morecore、malloc和free。一个一个地来说未免有点不符合正常人的思路，所以我接下来会以用户初次调用malloc为例，来整理user mem-allocator的具体实现。

      +

      malloc

      当用户初次调用malloc，此时freep仍为空指针，因而会进入如下分支：

      +
      if((prevp = freep) == 0){
        // 空闲mem为空的情况
        base.s.ptr = freep = prevp = &base;
        base.s.size = 0;
      }
      + +

      也即初始化为这种情况：

      +

      image-20230316143711888

      +

      随后，由于prevp->ptr == freep，故而会在循环中进入该分支：

      +
      for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
        // ...
        if(p == freep) // 一般情况下，此处表明已经完整遍历了一遍环形链表，因为prev的初值是freep，而我们是从prev->next开始遍历的
          if((p = morecore(nunits)) == 0)
            return 0;
      }
      + +

      调用morecore。

      +

      morecore

      进入morecore后，首先会对堆内存进行扩容：

      +
      if(nu < 4096)
        nu = 4096;
      p = sbrk(nu * sizeof(Header));
      if(p == (char*)-1)
        return 0;
      + +

      其中，nu表示要申请的内存单元数，一个内存单元为sizeof(Header)，因而nu在malloc中计算如下：

      +
      nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
      + +

      为了满足内核以一页为最小内存单位的需求，以及避免过多陷入内核态，它每次会申请至少4096*内存单元的堆空间。

      +

      对堆内存进行扩容完之后，morecore会手动调用一次free，将新申请到的内存加入数据结构中。【此处类似于在knit中调用kfree的原理】

      +

      free

      void free(void *ap){
        Header *bp, *p;

        bp = (Header*)ap - 1;
        for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
          if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
            break;
      + +

      由于此时freep == freep->str == base，并且我们在morecore中新申请的内存空间ap满足ap > base，故而会跳出循环。

      +
      +

      为什么ap > base呢？

      +

      别忘了我们扩容的原理。我们是以proc->size为起始地址扩容的。ap处在扩容内存中，因而ap>旧size；base处在扩容前内存内，因而base<=旧size。故而有ap>base。

      +
      +
      if(bp + bp->s.size == p->s.ptr){
        bp->s.size += p->s.ptr->s.size;
        bp->s.ptr = p->s.ptr->s.ptr;
      } else
        bp->s.ptr = p->s.ptr;
      if(p + p->s.size == bp){
        p->s.size += bp->s.size;
        p->s.ptr = bp->s.ptr;
      } else
        p->s.ptr = bp;
      freep = p;
      + +

      跳出循环后，我们会进入第一个if的第二个分支，以及第二个if的第二个分支。经过这些指针操作后，此时我们的数据结构如下图所示：

      +

      image-20230316145733160

      +

      也即形成了一个两节点的环形链表。

      +

      malloc

      经历完上述调用后，我们回到malloc的循环中：

      +
      for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
        // ...
        if(p == freep)
          if((p = morecore(nunits)) == 0)
            return 0;
      }
      + +

      由morecore的返回值可知，此时我们的p应该指向freep。本轮循环结束后执行 p = p->s.ptr，此时我们的p指向了我们刚在morecore中扩容出来的那一大段内存。

      +

      image-20230316150327569

      +

      在下一轮循环中，由于我们刚刚通过morecore申请了至少nunits的空间，因而我们将进入该分支：

      +
      if(p->s.size >= nunits){
        if(p->s.size == nunits)
          // 如果与所需的内存刚好相等，那就直接返回该小单元就行
          prevp->s.ptr = p->s.ptr;
        else {
          // 不等的话就只划分出一小部分
          // 一次划出几个header单元
          p->s.size -= nunits;
          p += p->s.size;
          p->s.size = nunits;
        }
        freep = prevp;
        return (void*)(p + 1);
      }
      + +

      当nunits >= 4096，也即p->s.size == nunits，p所指向的地址恰好就是我们接下来会用的地址。因而，我们就将这部分内存空间从我们的freelist中剔除，在之后返回p的地址即可。

      +

      当nunits < 4096，也即p->s.size != nunits，说明p所指向的这块内存空间比我们需要的大，那么我们就仅将该段内存空间切割出需要的那一小部分，再把p指向那一小部分开头的地方，返回p地址即可，如图所示。

      +

      image-20230316150846709

      +

      这样一来，我们就成功给用户它所需要的内存空间了。

      +

      free

      进行malloc之后，用户还需要调用free来手动释放内存，防止内存泄漏。

      +

      image-20230316151116462

      +
      for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
        if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
          break;
      + +

      由于ap > base且ap > 旧p->size = base->ptr且base < base->ptr，故而首先会进行一轮循环。再然后，由于p = 旧p->size，并且p > p->ptr = base，并且ap > 旧size，故而跳出循环。

      +
      +

      此处循环中，循环语句内部的这个循环实际上是对遍历到环形链表尾部，即将从头开始遍历，这个边界情况的处理。比较符合逻辑的还是循环语句内的那个条件。

      +
      +
      if(bp + bp->s.size == p->s.ptr){
        bp->s.size += p->s.ptr->s.size;
        bp->s.ptr = p->s.ptr->s.ptr;
      } else
        bp->s.ptr = p->s.ptr;
      if(p + p->s.size == bp){
        p->s.size += bp->s.size;
        p->s.ptr = bp->s.ptr;
      } else
        p->s.ptr = bp;
      freep = p;
      + +

      此时会进入第二个if的第一个分支。具体情况看图就行，不多bb。

      +

      总结

      主要就是这个数据结构用得很巧妙但也很复杂。它吸取了内核态中分配内存使用一个freelist的特点，同时又巧妙地利用了内存地址有序的特点，从而实现碎片内存管理。我的建议是多画图。

      +

      还有其实有一点我不是很理解。我觉得freep这个变量的用意非常不明，它似乎并不是指代整个freelist的头，因为它在很多个地方都诡异地赋值了一次。我想，它也许始终指向上一次被alloc/被free的内存的前一个吧。。。我猜测这样设计是为了蕴含一些LRU的思想。不大明白。

      +

      m-s-u权限切换

      由os知识可知，机器态、内核态、用户态分别有三种不同的操作权限。xv6是如何对权限切换进行管理的呢？

      +

      这部分知识我在正文的一个小地方记录了下来，详见 chapter2 - Code: starting xv6 and the fifirst process - xv6 - 感想 的第二点。

      +

      Lock实验的评测机制

      在xv6该次实验中，为了实现评测可视化，引入了statistics机制对结果进行评估。下面，我将通过源码简单介绍其实现机制。

      +

      来讲讲这玩意是怎么实现用户态读取锁争用次数的。我们从statistics函数可看出，它的本质是通过读取“文件”，来从内核中读取争用次数的相关数据：

      +
      int statistics(void *buf, int sz) {
        fd = open("statistics", O_RDONLY);
        ...
          if ((n = read(fd, buf+i, sz-i)) < 0) {
      }
      + +

      那么安装以前所学的内容，我们很容易联系到这玩意应该并不是个文件，而是类似于proc文件系统那样的虚拟文件。它应该会在open、read中根据其特有的文件类型进行转发。在init.c中，我们可以看到：

      +
      main(void)
      {
        if(open("console", O_RDWR) < 0){
          mknod("console", CONSOLE, 0);
          mknod("statistics", STATS, 0);
          open("console", O_RDWR);
        }
      + +

      这玩意的文件结点实际上是在创建console时整的，并且其有一个特殊的文件类型“STATS”。我们可以进一步追溯到kernel中的main.c：

      +
      void main()
      {
        if(cpuid() == 0){
      #if defined(LAB_PGTBL) || defined(LAB_LOCK)
          statsinit();
      + +
      void
      statsinit(void)
      {
        initlock(&stats.lock, "stats");

        devsw[STATS].read = statsread;
        devsw[STATS].write = statswrite;
      }
      + +

      可以看到，它给这个STATS文件类型注册了这两个函数。当我们调用read和write时，实际上就是在调用这俩玩意。我们可以看下这两个handler都干了啥。

      +
      #define BUFSZ 4096
      static struct {
        struct spinlock lock;
        char buf[BUFSZ];
        int sz;
        int off;
      } stats;

      int statsread(int user_dst, uint64 dst, int n) {
        int m;
        acquire(&stats.lock);

        if(stats.sz == 0) {
      #ifdef LAB_LOCK
          stats.sz = statslock(stats.buf, BUFSZ); // 把信息copy进自己的缓冲区里
      #endif
        }
        m = stats.sz - stats.off;

        if (m > 0) { // 如果有新东西，就copy到用户缓冲区里
          if(m > n)	m  = n;
          if(either_copyout(user_dst, dst, stats.buf+stats.off, m) != -1) {
            stats.off += m;
          }
        } else {
          m = -1;
          stats.sz = 0;
          stats.off = 0;
        }
        release(&stats.lock);
        return m;
      }
      + +
      int statswrite(int user_src, uint64 src, int n) { // WARNING: READ ONLY!!!
        return -1;
      }
      + +

      可以看到其本质就是把statslock返回的东西copy到用户空间了。我们来结合最后的输出效果看看statslock的具体实现：

      +

      image-20231024232632816

      +
      int statslock(char *buf, int sz) {
        int n;
        int tot = 0;
        int found = 0;

        acquire(&lock_locks);
        n = snprintf(buf, sz, "--- lock kmem/bcache stats\n");
        for(int i = 0; i < NLOCK; i++) {
          if(locks[i] == 0)	break;
          if(strncmp(locks[i]->name, "bcache", strlen("bcache")) == 0 ||
             strncmp(locks[i]->name, "kmem", strlen("kmem")) == 0) {
            tot += locks[i]->nts; // 记入->nts计数
            /*
              snprint_lock: lock: %s: #fetch-and-add %d #acquire() %d\n
            */
            n += snprint_lock(buf +n, sz-n, locks[i]);
            found += 1;
          }
        }

        // Require at least two locks name after kmem/bcache.
        if (found < 2) {
          tot = -1;
        }
        
        // 简单粗暴地计算前五多争用的进程
        n += snprintf(buf+n, sz-n, "--- top 5 contended locks:\n");
        int last = 100000000;
        // stupid way to compute top 5 contended locks
        for(int t = 0; t < 5; t++) {
          int top = 0;
          for(int i = 0; i < NLOCK; i++) {
            if(locks[i] == 0)
              break;
            if(locks[i]->nts > locks[top]->nts && locks[i]->nts < last) {
              top = i;
            }
          }
          /*
            snprint_lock: lock: %s: #fetch-and-add %d #acquire() %d\n
          */
          n += snprint_lock(buf+n, sz-n, locks[top]);
          last = locks[top]->nts;
        }
        n += snprintf(buf+n, sz-n, "tot= %d\n", tot);
        release(&lock_locks);  
        return n;
      }
      + +

      可以看到其争用本质计算是通过spinlock::nts字段记录。我们来看看这玩意的引用：

      +
      void initlock(struct spinlock *lk, char *name) {
      #ifdef LAB_LOCK
        lk->nts = 0;
      #endif  
      }

      void acquire(struct spinlock *lk) {
        ...
        while(__sync_lock_test_and_set(&lk->locked, 1) != 0) {
      #ifdef LAB_LOCK
          __sync_fetch_and_add(&(lk->nts), 1);
      #else
         ;
      #endif
      }
      + +

      很好，逻辑很简单，就是记录acquire时等待的次数，非常简单粗暴（（（

      +

      总的来说这个思路还是挺酷的，而且这个“一切皆文件”的思想再次震撼了我，一个小小的xv6确实能做到那么多。

      +]]> + + + File system + /2023/01/10/xv6$chap8/ + File system
      +

      来到指导书最高点！太美丽了xv6。哎呀那不文件系统吗（

      +

      这里是自底向上讲起的。之后可以看看hit网课的自顶向下。

      +
      +
      +

      image-20230121160555370

      +
      +

      Overview

      image-20230121160641718

      +
      +

      The disk layer reads and writes blocks on an virtio hard drive.

      +

      The buffer cache layer caches disk blocks and synchronizes access to them, making sure that only one kernel process at a time can modify the data stored in any particular block.

      +

      The logging layer allows higher layers to wrap updates to several blocks in a transaction, and ensures that the blocks are updated atomically in the face of crashes (i.e., all of them are updated or none). 【日志记录层允许更高层将更新包装到一个事务中的多个块，并确保在崩溃时以原子方式更新块（即，所有块都更新或不更新）。可以类比一下数据库的那个概念。】

      +

      The inode layer provides individual files, each represented as an inode with a unique i-number and some blocks holding the file’s data.

      +

      The directory layer implements each directory as a special kind of inode whose content is a sequence of directory entries, each of which contains a file’s name and i-number.

      +

      The pathname layer provides hierarchical path names like /usr/rtm/xv6/fs.c, and resolves them with recursive lookup.

      +

      The file descriptor layer abstracts many Unix resources (e.g., pipes, devices, fifiles, etc.) using the file system interface, simplifying the lives of application programmers.

      +
      +

      image-20230121162324747

      +
      +

      The file system must have a plan for where it stores inodes and content blocks on the disk. To do so, xv6 divides the disk into several sections, as Figure 8.2 shows.

      +

      The file system does not use block 0 (it holds the boot sector).

      +

      Block 1 is called the superblock; it contains metadata about the file system (the file system size in blocks, the number of data blocks, the number of inodes, and the number of blocks in the log). The superblock is filled in by a separate program, called mkfs, which builds an initial file system.

      +

      Blocks starting at 2 hold the log.

      +

      After the log are the inodes, with multiple inodes per block.

      +

      After those come bitmap blocks tracking which data blocks are in use. 【应该是用来标识每个块是否空闲的吧】

      +

      The remaining blocks are data blocks; each is either marked free in the bitmap block, or holds content for a file or directory【要么空闲要么是文件或目录】.

      +
      +

      Buffer cache

      +

      The buffer cache has two jobs:

      +
        +
      1. synchronize access to disk blocks to ensure that only one copy of a block is in memory and that only one kernel thread at a time uses that copy;
        2. +
      2. cache popular blocks so that they don’t need to be re-read from the slow disk.
        3. +
      +

      The code is in bio.c.

      +

      Buffer cache中保存磁盘块的缓冲区数量固定，这意味着如果文件系统请求还未存放在缓存中的块，Buffer cache必须回收当前保存其他块内容的缓冲区。Buffer cache为新块回收最近使用最少的缓冲区。这样做的原因是认为最近使用最少的缓冲区是最不可能近期再次使用的缓冲区。

      +
      +

      image-20230124151719288

      +

      数据结构定义

      struct buf {
        int valid;   // has data been read from disk?缓冲区是否包含块的副本
        int disk;    // does disk "own" buf?缓冲区内容是否已交给磁盘
        uint dev;
        uint blockno;
        struct sleeplock lock;
        uint refcnt;
        struct buf *prev; // LRU cache list
        struct buf *next;
        uchar data[BSIZE];
      };
      + +

      这应该代表着一个磁盘块。

      +
      struct {
        struct spinlock lock;
        struct buf buf[NBUF];

        // Linked list of all buffers, through prev/next.
        // Sorted by how recently the buffer was used.
        // head.next is most recent, head.prev is least.
        struct buf head;
      } bcache;
      + +

      大概buf数组里存储着所有buf的内容。buf本身通过最近使用排序的双向链表连接，head是链表的头。

      +

      初始化

      // called by main.c
      void
      binit(void)
      {
        struct buf *b;

        initlock(&bcache.lock, "bcache");

        // Create linked list of buffers
        // 把b插在head之后
        bcache.head.prev = &bcache.head;
        bcache.head.next = &bcache.head;
        for(b = bcache.buf; b < bcache.buf+NBUF; b++){
          b->next = bcache.head.next;
          b->prev = &bcache.head;
          initsleeplock(&b->lock, "buffer");
          bcache.head.next->prev = b;
          bcache.head.next = b;
        }
      }
      + +

      上层接口

      +

      The main interface exported by the buffer cache consists of bread and bwrite.

      +

      The buffer cache uses a per-buffer sleep-lock to ensure concurrent security.

      +
      +

      bread

      +

      bread obtains a buf containing a copy of a block which can be read or modified in memory.

      +

      依据给定设备号和给定扇区号寻找cache的buf。返回的buf是locked的。

      +
      +
      // Return a locked buf with the contents of the indicated block.
      struct buf*
      bread(uint dev, uint blockno)
      {
        struct buf *b;

        // 获取buf块
        b = bget(dev, blockno);
        if(!b->valid) {
          // 说明cache未命中，需要从磁盘读入
          virtio_disk_rw(b, 0);
          b->valid = 1;
        }
        return b;
      }
      + +

      bwrite

      +

      writes a modified buffer to the appropriate block on the disk

      +
      +
      // Write b's contents to disk.  Must be locked.
      void
      bwrite(struct buf *b)
      {
        // 必须持有b的锁
        if(!holdingsleep(&b->lock))
          panic("bwrite");
        // 写入磁盘
        virtio_disk_rw(b, 1);
      }
      + +

      brelse

      +

      A kernel thread must release a buffer by calling brelse when it is done with it.

      +
      +
      // Release a locked buffer.
      // Move to the head of the most-recently-used list.
      void
      brelse(struct buf *b)
      {
        if(!holdingsleep(&b->lock))
          panic("brelse");

        releasesleep(&b->lock);

        acquire(&bcache.lock);
        b->refcnt--;
        if (b->refcnt == 0) {
          // no one is waiting for it.
          // 移动到头结点和头结点的下一个结点之间的位置
          b->next->prev = b->prev;
          b->prev->next = b->next;
          b->next = bcache.head.next;
          b->prev = &bcache.head;
          bcache.head.next->prev = b;
          bcache.head.next = b;
        }

        release(&bcache.lock);
      }
      + +

      具体细节

      bget

      用于获取cache中是否存在block。如果不存在，则新申请一个buf，并把该buf以上锁状态返回

      +
      // Look through buffer cache for block on device dev.
      // If not found, allocate a buffer.
      // In either case, return locked buffer.
      static struct buf*
      bget(uint dev, uint blockno)
      {
        struct buf *b;

        acquire(&bcache.lock);

        // Is the block already cached?
        // 这个循环条件很有意思，充分用到了双向链表的特性
        for(b = bcache.head.next; b != &bcache.head; b = b->next){
          if(b->dev == dev && b->blockno == blockno){
            // 引用数增加
            b->refcnt++;
            release(&bcache.lock);
            // 锁定
            acquiresleep(&b->lock);
            return b;
          }
        }

        // Not cached.
        // Recycle the least recently used (LRU) unused buffer.
        // 从尾部开始遍历，确实就是最少使用的了
        for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
          // 如果该buf空闲
          if(b->refcnt == 0) {
            b->dev = dev;
            b->blockno = blockno;
            // 仅是新建了一个buf，还未从磁盘读取对应磁盘块的副本，因而设valid为0以供上层函数调用处理
            b->valid = 0;
            b->refcnt = 1;
            release(&bcache.lock);
            // 锁定
            acquiresleep(&b->lock);
            return b;
          }
        }
        // cache不够用了
        panic("bget: no buffers");
      }
      + +

      Logging layer

      简介

      +

      Xv6通过简单的日志记录形式解决了文件系统操作期间的崩溃问题。

      +

      xv6系统调用不会直接写入磁盘上的文件系统数据结构。相反，它会在磁盘上的log（日志）中放置它希望进行的所有磁盘写入的描述。一旦系统调用记录了它的所有写入操作，它就会向磁盘写入一条特殊的commit（提交）记录，表明日志包含一个完整的操作。此时，系统调用将写操作复制到磁盘上的文件系统数据结构。完成这些写入后，系统调用将擦除磁盘上的日志。

      +
      +
      +

      如果系统崩溃并重新启动，则在运行任何进程之前，文件系统代码将按如下方式从崩溃中恢复：

      +

      如果日志标记为包含完整操作，则恢复代码会将写操作复制到磁盘文件系统中它们所属的位置，然后擦除日志。如果日志没有标记为包含完整操作，则恢复代码将忽略该日志，然后擦除日志。

      +
      +

      这就保证了原子性。

      +

      Log design

      image-20230121162324747

      +

      superblock记录了log的存储位置。

      +
      +

      它由一个头块（header block）和一系列更新块的副本（logged block）组成。

      +

      头块包含一个扇区号（sector）数组（每个logged block对应一个扇区号）以及日志块的计数。

      +

      磁盘上的头块中的计数为零表示日志中没有事务，为非零表示日志包含一个完整的已提交事务，并具有指定数量的logged block。

      +

      在事务提交（commit）时Xv6才向头块写入数据，在此之前不会写入。在将logged blocks复制到文件系统后，头块的计数将被设置为零。

      +

      因此，事务中途崩溃将导致日志头块中的计数为零；提交后的崩溃将导致非零计数。

      +
      +
      +

      为了允许不同进程并发执行文件系统操作，日志系统可以将多个系统调用的写入累积到一个事务中。因此，单个提交可能涉及多个完整系统调用的写入。为了避免在事务之间拆分系统调用，日志系统仅在没有文件系统调用进行时提交。

      +

      同时提交多个事务的想法称为组提交（group commit）。组提交减少了磁盘操作的数量，因为成本固定的一次提交分摊了多个操作。组提交还同时为磁盘系统提供更多并发写操作，可能允许磁盘在一个磁盘旋转时间内写入所有这些操作。Xv6的virtio驱动程序不支持这种批处理，但是Xv6的文件系统设计允许这样做。

      +

      【这感觉实现得也还挺简略的】

      +
      +
      +

      Xv6在磁盘上留出固定的空间来保存日志。事务中系统调用写入的块总数必须可容纳于该空间。这导致两个后果：

      +
        +

      1. 任何单个系统调用都不允许写入超过日志空间的不同块。

        +

        【这段话我一个字没看懂】

        +

        这对于大多数系统调用来说都不是问题，但其中两个可能会写入许多块：write和unlink。一个大文件的write可以写入多个数据块和多个位图块以及一个inode块；unlink大文件可能会写入许多位图块和inode。Xv6的write系统调用将大的写入分解为适合日志的多个较小的写入，unlink不会导致此问题，因为实际上Xv6文件系统只使用一个位图块。

        2. -

      2. 设备直通

        -

        将物理硬件设备直接挂到虚拟机上，虚拟机直接与物理设备交互，尽可能在I/O路径上减少QEMU/KVM的参与。

        -

        设备直通经常搭配硬件虚拟化支持技术SRIOV（Single Root I/O Virtualization，单根输入/输出虚拟化）使用，SRIOV能够将单个的物理硬件高效地虚拟出多个虚拟硬件。

        +

      3. 日志空间有限的另一个后果是，除非确定系统调用的写入将可容纳于日志中剩余的空间，否则日志系统无法允许启动系统调用。

      -

      v2-555d017ce5b65457f98617a5fdf232af_1440w

      -
      中断处理虚拟化

      操作系统通过写设备的I/O端口或者MMIO地址来与设备交互，设备通过发送中断来通知操作系统事件。

      -

      QEMU/KVM一方面需要完成这项中断设备的模拟，另一方面需要模拟中断的请求处理。

      -
      -

      QEMU支持单CPU的Intel 8259中断控制器以及SMP的I/O APIC（I/O Advanced Programmable Interrupt Controller）和LAPIC（Local Advanced Programmable Interrupt Controller）中断控制器。在这种方式下，虚拟外设通过QEMU向虚拟机注入中断，需要先陷入到KVM，然后由KVM向虚拟机注入中断，这是一个非常费时的操作。

      -

      为了提高虚拟机的效率，KVM自己也实现了中断控制器Intel 8259、I/O APIC以及LAPIC。用户可以有选择地让QEMU或者KVM模拟全部中断控制器，也可以让QEMU模拟Intel 8259中断控制器和I/O APIC，让KVM模拟LAPIC。

      -

      xv6的全启动运行过程梳理

      介绍完上述的qemu虚拟化，接下来就可以对xv6的全启动进行一个梳理了。

      -

      首先，在宿主机执行make qemu。

      -

      在Makefile中可以看到：

      -
      qemu: $K/kernel fs.img
              $(QEMU) $(QEMUOPTS)
      QEMU = qemu-system-riscv64
      +

      Code: logging

      +

      log的原理是这样的：

      +

      在每个系统调用的开始调用begin_op表示事务开始，然后之后新申请一块block，也即把该block的内容读入内存，并且把该block的blockno记录到log的header中。此后程序正常修改在内存中的block，磁盘中的block保持不变。最后commit的时候遍历log header中的blockno，一块块地把内存中的block写入日志和磁盘中。

      +

      如果程序在commit前崩溃，则内存消失，同时磁盘也不会写入；如果在commit后崩溃，那也无事发生。

      +

      在每次启动的时候，都会执行log的初始化，届时可以顺便恢复数据。

      +

      完美实现了日志的功能。

      +
      +

      image-20230123212753931

      +

      数据结构

      // Contents of the header block, used for both the on-disk header block
      // and to keep track in memory of logged block# before commit.
      struct logheader {
        int n;
        // 扇区号也即blockno的数组
        int block[LOGSIZE];
      };

      // 代表log磁盘块
      struct log {
        struct spinlock lock;
        int start;// log磁盘块的开始。start开始的第一块为log header，之后皆为写入的block
        int size;
        int outstanding; // how many FS sys calls are executing.
        int committing;  // in commit(), please wait.
        int dev;
        struct logheader lh;
      };
      struct log log;
      -

      在log中可以看到：

      -
      ...
      mkfs/mkfs fs.img README user/xargstest.sh user/_cat user/_echo user/_forktest user/_grep user/_init user/_kill user/_ln user/_ls user/_mkdir user/_rm user/_sh user/_stressfs user/_usertests user/_grind user/_wc user/_zombie user/_mmaptest
      ...
      qemu-system-riscv64 -machine virt -bios none -kernel kernel/kernel -m 128M -smp 3 -nographic -drive file=fs.img,if=none,format=raw,id=x0 -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0

      xv6 kernel is booting

      hart 2 starting
      hart 1 starting
      init: starting sh
      $
      +

      关键函数

      begin_op()
      +

      begin_op等待直到日志系统当前未处于提交中，并且直到有足够的未被占用的日志空间来保存此调用的写入。

      +

      log.outstanding统计预定了日志空间的系统调用数；为此保留的总空间为log.outstanding乘以MAXOPBLOCKS（10）。递增log.outstanding会预定空间并防止在此系统调用期间发生提交（if的第二个分支）。代码保守地假设每个系统调用最多可以写入MAXOPBLOCKS（10）个不同的块。

      +
      +
      // called at the start of each FS system call.
      void
      begin_op(void)
      {
        acquire(&log.lock);
        while(1){
          // 正在提交则等待日志空闲
          if(log.committing){
            sleep(&log, &log.lock);
          // 日志空间不足则等待空间充足
          } else if(log.lh.n + (log.outstanding+1)*MAXOPBLOCKS > LOGSIZE){
            // this op might exhaust log space此操作可能会耗尽日志空间; wait for commit.
            sleep(&log, &log.lock);
          } else {
            log.outstanding += 1;
            release(&log.lock);
            break;
          }
        }
      }
      -

      具体的Makefile相关内容我不大了解，但结合输出，我想大概是先通过riscv64-linux-gnu-gcc编译链接完所有文件，然后再执行mkfs产生fs.img镜像（mkfs后面那些东西应该是文件参数，对应于源码中的读取可执行程序进磁盘的部分），最后再运行qemu-system-riscv64开始对虚拟机进行boot。

      -

      boot直至启动后的所有代码，都是通过QEMU-KVM架构处理，直接运行在宿主机的CPU上的。其余的各种管理，可以详见小标题虚拟机在QEMU-KVM架构的执行方法。

      -

      mkfs的作用及源码解读

      作用

      上面的知识表明，操作系统的启动在于文件系统初始化之后，这是因为操作系统本身的启动代码，放在磁盘映像fs.img中，而fs.img正是由文件系统初始化时弄出来的。也就是说，文件系统是操作系统的爸爸。【我以前一直以为是反过来的】

      -

      image-20230121162324747

      -
      -

      图中的boot块就是操作系统的引导扇区。

      +
      log_write
      +

      log_write充当bwrite的代理。它将块的扇区号记录在内存中，在磁盘上的日志中预定一个槽位，并调用bpin将缓存固定在block cache中，以防止block cache将其逐出【具体原理就是让refcnt++，这样就不会被当成空闲block用掉了】。

      +

      为啥要防止换出呢？换出不是就正好自动写入磁盘了吗？这里一是为了保障前面提到的原子性，防止换入换出导致的单一写入磁盘；二是换出自动写入的是磁盘对应位而不一定是日志所在的blocks。

      -

      而mkfs的作用，正是把宿主机提供的虚拟地址空间作为虚拟磁盘，把虚拟地址空间划分为如上图所示的地址结构。它是运行在宿主机当中的。有了mkfs，才能有我们的虚拟机。

      -
      代码解读

      xv6分析–mkfs源代码注释

      -

      yysy这个就写得很好了。

      -

      user mem-allocator

      -

      linux的堆管理

      -

      那么malloc到底是怎么实现的呢？不是每次要申请内存就调一下系统调用，而是程序向操作系统申请⼀块适当⼤⼩的堆空间，然后由程序⾃⼰管理这块空间，⽽具体来讲，管理着堆空间分配的往往是程序的运⾏库。

      -

      也就是说，malloc本质上是以运行库而非系统调用形式出现的。它里面用到的是sbrk和mmap这两个系统调用来进货。

      -

      glibc的malloc函数是这样处理⽤户的空间请求的：对于⼩于128KB的请求来说，它会在现有的堆空间⾥⾯，按照堆分配算法为它分配⼀块空间并返回；对于⼤于128KB的请求来说，它会使⽤mmap()函数为它分配⼀块匿名空间，然后在这个匿名空间中为⽤户分配空间。

      +
      void
      log_write(struct buf *b)
      {
        int i;
        // #define LOGSIZE      (MAXOPBLOCKS*3)  // max data blocks in on-disk log
        // 30
        if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
          panic("too big a transaction");
        if (log.outstanding < 1)
          panic("log_write outside of trans");

        acquire(&log.lock);
        // log_write会注意到在单个事务中多次写入一个块的情况，并在日志中为该块分配相同的槽位。
        // 这种优化通常称为合并（absorption）
        for (i = 0; i < log.lh.n; i++) {
          if (log.lh.block[i] == b->blockno)   // log absorbtion
            break;
        }
        // 这里还是挺巧妙的。
        // 如果存在log.lh.block[i] == b->blockno的情况，执行此句话也无妨
        // 如果不存在，则给log新增一块，填入log.lh.block[log.lh.n]的位置，再++log.lh.n
        log.lh.block[i] = b->blockno;
        if (i == log.lh.n) {  // Add new block to log?
          bpin(b);
          log.lh.n++;
        }
        release(&log.lock);
      }
      + +
      end_op
      // called at the end of each FS system call.
      // 如果这是最后一层outstanding就会执行commit操作
      // commits if this was the last outstanding operation.
      void
      end_op(void)
      {
        int do_commit = 0;

        acquire(&log.lock);
        log.outstanding -= 1;
        if(log.committing)
          panic("log.committing");
        if(log.outstanding == 0){
          do_commit = 1;
          log.committing = 1;
        } else {
          // begin_op() may be waiting for log space,
          // and decrementing log.outstanding has decreased
          // the amount of reserved space.
          wakeup(&log);
        }
        release(&log.lock);

        if(do_commit){
          // call commit w/o holding locks, since not allowed
          // to sleep with locks.
          commit();
          acquire(&log.lock);
          log.committing = 0;
          wakeup(&log);
          release(&log.lock);
        }
      }
      + +
      commit
      static void
      commit()
      {
        if (log.lh.n > 0) {
          // cache -> log block
          write_log();     // Write modified blocks from cache to log
          // head(in stack/heap) -> log block
          // 此可以说为commit完成的标志。
          // 因为无论接下来是否崩溃，数据最终都会被写入disk，不同在于是在recover时还是接下来写入
          write_head();    // Write header to disk -- the real commit
          // log block -> real position
          install_trans(0); // Now install writes to home locations
          log.lh.n = 0;
          // 擦除
          write_head();    // Erase the transaction from the log
        }
      }
      + +
      write_log
      // Copy modified blocks from cache to log.
      static void
      write_log(void)
      {
        int tail;

        for (tail = 0; tail < log.lh.n; tail++) {
          struct buf *to = bread(log.dev, log.start+tail+1); // log block
          struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
          memmove(to->data, from->data, BSIZE);
          bwrite(to);  // write the log
          brelse(from);// 此处的brelse呼应了外界调用的bread
          brelse(to);
        }
      }
      + +
      write_head
      // Write in-memory log header to disk.
      // 这是事务提交的标志
      // This is the true point at which the
      // current transaction commits.
      static void
      write_head(void)
      {
        struct buf *buf = bread(log.dev, log.start);
        struct logheader *hb = (struct logheader *) (buf->data);
        int i;
        hb->n = log.lh.n;
        for (i = 0; i < log.lh.n; i++) {
          hb->block[i] = log.lh.block[i];
        }
        bwrite(buf);
        brelse(buf);
      }
      + +
      install_trans
      // Copy committed blocks from log to their home location
      static void
      install_trans(int recovering)
      {
        int tail;

        for (tail = 0; tail < log.lh.n; tail++) {
          struct buf *lbuf = bread(log.dev, log.start+tail+1); // read log block
          struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
          memmove(dbuf->data, lbuf->data, BSIZE);  // copy block to dst
          bwrite(dbuf);  // write dst to disk
          if(recovering == 0)
            bunpin(dbuf);// 如果不是在recover的过程中
          brelse(lbuf);
          brelse(dbuf);
        }
      }
      + +

      恢复与初始化

      上面介绍了log的一次事务提交的流程。接下来介绍它是怎么恢复的。

      +
      +

      recover_from_log是由initlog调用的，而它又是在第一个用户进程运行之前的引导期间由fsinit调用的。

      -

      在内核态中，我们使用kalloc和kfree来申请和释放内存页。在用户态中，我们使用malloc和free来对动态内存进行管理。【也就是说这个实现的是堆管理】

      -

      内核中的最小单位只能是页，但user mem-allocator对外提供的申请内存服务的最小单位不是页，而是sizeof(Header)。因而，这就需要我们的user mem-allocator进行数据结构的管理，来统一这二者的实现。

      -

      数据结构

      环形链表

      user mem-allocator的数据结构是环形链表，起始结点为一个空数据载体。

      -

      image-20230316140158908

      -

      image-20230316140450988

      -

      地址从低到高

      链表的头结点的存储地址/所代表的内存地址的地址数值最小，并且其余结点按遍历顺序地址递增。

      -

      具体实现

      user mem-allocator由三个主要函数组成，分别是morecore、malloc和free。一个一个地来说未免有点不符合正常人的思路，所以我接下来会以用户初次调用malloc为例，来整理user mem-allocator的具体实现。

      -

      malloc

      当用户初次调用malloc，此时freep仍为空指针，因而会进入如下分支：

      -
      if((prevp = freep) == 0){
        // 空闲mem为空的情况
        base.s.ptr = freep = prevp = &base;
        base.s.size = 0;
      }
      +
      第一个进程运行之前

      由前面scheduler一章的知识可知，每个进程被初次调度的时候会先来执行forkret。这时候就做了log的恢复工作。

      +

      注释解释了为什么不选择在main.c中初始化，而选择在此处初始化。确实，它需要调用sleep，如果在main.c中调用sleep感觉会乱套（）毕竟那时候scheduler线程尚未被初始化。

      +
      // A fork child's very first scheduling by scheduler()
      // will swtch to forkret.
      void
      forkret(void)
      {
        // static变量仅会被初始化一次
        static int first = 1;

        // Still holding p->lock from scheduler.
        release(&myproc()->lock);

        // 如果是第一个进程
        if (first) {
          // File system initialization must be run in the context of a
          // regular process (e.g., because it calls sleep), and thus cannot
          // be run from main().
          first = 0;
          fsinit(ROOTDEV);
        }

        usertrapret();
      }
      -

      也即初始化为这种情况：

      -

      image-20230316143711888

      -

      随后，由于prevp->ptr == freep，故而会在循环中进入该分支：

      -
      for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
        // ...
        if(p == freep) // 一般情况下，此处表明已经完整遍历了一遍环形链表，因为prev的初值是freep，而我们是从prev->next开始遍历的
          if((p = morecore(nunits)) == 0)
            return 0;
      }
      +
      fsinit
      // Init fs
      void
      fsinit(int dev) {
        // ...
        initlog(dev, &sb);
      }
      -

      调用morecore。

      -

      morecore

      进入morecore后，首先会对堆内存进行扩容：

      -
      if(nu < 4096)
        nu = 4096;
      p = sbrk(nu * sizeof(Header));
      if(p == (char*)-1)
        return 0;
      +
      initlog
      void
      initlog(int dev, struct superblock *sb)
      {
        if (sizeof(struct logheader) >= BSIZE)
          panic("initlog: too big logheader");

        initlock(&log.lock, "log");
        // 从super block中获取必要参数
        log.start = sb->logstart;
        log.size = sb->nlog;
        log.dev = dev;
        recover_from_log();
      }
      -

      其中，nu表示要申请的内存单元数，一个内存单元为sizeof(Header)，因而nu在malloc中计算如下：

      -
      nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
      +
      recover_from_log
      static void
      recover_from_log(void)
      {
        // 读取head
        read_head();
        // 注意，commit中会把header写入log block，而这里从log block读出header
        // 也就是说，如果header的n不为零，那么说明已经commit了，但可能未写入，重复写入保障安全
        // 如果header的n为零，说明未commit，在install_trans的逻辑中会什么也不做
        // 两种情况完美满足
        install_trans(1); // if committed, copy from log to disk
        log.lh.n = 0;
        // 擦除
        write_head(); // clear the log
      }
      -

      为了满足内核以一页为最小内存单位的需求，以及避免过多陷入内核态，它每次会申请至少4096*内存单元的堆空间。

      -

      对堆内存进行扩容完之后，morecore会手动调用一次free，将新申请到的内存加入数据结构中。【此处类似于在knit中调用kfree的原理】

      -

      free

      void free(void *ap){
        Header *bp, *p;

        bp = (Header*)ap - 1;
        for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
          if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
            break;
      +

      Code: Block allocator

      个人理解

      说实话没怎么懂，也不大清楚它有什么用，先大概推测一下：

      +

      之前的bread和bwrite这些，就是你给一个设备号和扇区号，它就帮你加载进内存cache。你如果要用的话，肯定还是使用地址方便。所以block allocator的作用之一就是给bread和bwrite加一层封装，将获取的block封装为地址返回，你可以直接操纵这个地址，而无需知道下层的细节。

      +

      这个过程要注意的有两点：

      +
        +

      1. 封装返回的地址具体是什么，怎么工作的

        +

        封装返回的地址实质上是buffer cache中的buf的data字段的地址【差不多】。之后的上层应用在该地址上写入，也即写入了buf，最后会通过log层真正写入磁盘。

        +
        2. +

      2. 结合bcache的LRU，详细谈谈工作机制

        +

        我们可以看到，在balloc中有这么一段逻辑：

        +
        bp = bread(dev, BBLOCK(b, sb));
        // ...
            log_write(bp);
            brelse(bp);
            return b + bi;
        -

        由于此时freep == freep->str == base，并且我们在morecore中新申请的内存空间ap满足ap > base，故而会跳出循环。

        +

        看到的第一反应就是，我们需求的那块buf是bp，但是这里先是bread了一次，又是brelse了一次，这样bp的refcnt不就为0，很容易被替换掉了吗？

        +

        会有这个反应，一定程度上是因为没有很好地理解LRU。事实上，正是它可能被替换掉，才满足了LRU的条件。因为它可能被替掉才能说明它可能是最近最少使用的。

        +
        3. +
      +

      bitmap

      +

      文件和目录内容存储在磁盘块中，磁盘块必须从空闲池中分配。xv6的块分配器在磁盘上维护一个空闲位图，每一位代表一个块。0表示对应的块是空闲的；1表示它正在使用中。

      +

      引导扇区、超级块、日志块、inode块和位图块的比特位是由程序mkfs初始化设置的：

      +

      image-20230123234919055

      +
      +

      allocator

      类似于memory allocator，块分配器也提供了两个函数：bfree和balloc。

      +

      balloc

      +

      Balloc从块0到sb.size（文件系统中的块数）遍历每个块。它查找位图中位为零的空闲块。如果balloc找到这样一个块，它将更新位图并返回该块。

      +

      为了提高效率，循环被分成两部分。外部循环读取位图中的每个块。内部循环检查单个位图块中的所有BPB位。由于任何一个位图块在buffer cache中一次只允许一个进程使用【 bread(dev, BBLOCK(b, sb))会返回一个上锁的block，bread和brelse隐含的独占使用避免了显式锁定的需要】，因此，如果两个进程同时尝试分配一个块也是并发安全的。

      +
      +
      // Allocate a zeroed disk block.
      static uint
      balloc(uint dev)
      {
        int b, bi, m;
        struct buf *bp;

        bp = 0;
        for(b = 0; b < sb.size; b += BPB){
          bp = bread(dev, BBLOCK(b, sb));
          for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
            m = 1 << (bi % 8);
            if((bp->data[bi/8] & m) == 0){  // Is block free?
              bp->data[bi/8] |= m;  // Mark block in use.
              log_write(bp);
              brelse(bp);
              bzero(dev, b + bi);
              return b + bi;
            }
          }
          brelse(bp);
        }
        panic("balloc: out of blocks");
      }
      + +

      bfree

      // Free a disk block.
      static void
      bfree(int dev, uint b)
      {
        struct buf *bp;
        int bi, m;

        bp = bread(dev, BBLOCK(b, sb));
        bi = b % BPB;
        m = 1 << (bi % 8);
        if((bp->data[bi/8] & m) == 0)
          panic("freeing free block");
        bp->data[bi/8] &= ~m;
        log_write(bp);
        brelse(bp);
      }
      + +

      Inode layer

      inode

      +

      术语inode（即索引结点）可以具有两种相关含义之一。它可能是指包含文件大小和数据块编号列表的磁盘上的数据结构【on-disk inode】。或者“inode”可能指内存中的inode【in-memory inode】，它包含磁盘上inode的副本以及内核中所需的额外信息。

      +
      +

      image-20230121162324747

      +

      on-disk inode

      +

      The on-disk inodes are packed into a contiguous area of disk called the inode blocks.

      +

      Every inode is the same size, so it is easy, given a number n, to find the nth inode on the disk. In fact, this number n, called the inode number or i-number, is how inodes are identifified in the implementation.

      +
      +
      // in fs.h
      // On-disk inode structure
      struct dinode {
        // 为0表示free
        short type;           // File type
        short major;          // Major device number (T_DEVICE only)
        short minor;          // Minor device number (T_DEVICE only)
        //  The nlink field counts the number of directory entries that refer to this inode,
        //  in order to recognize when the on-disk inode and its data blocks should be freed.
        short nlink;          // Number of links to inode in file system
        uint size;            // Size of file (bytes)
        uint addrs[NDIRECT+1];   // Data block addresses
      };
      + +

      in-memory inode

      +

      The kernel keeps the set of active inodes in memory.

      +

      The kernel stores an inode in memory only if there are C pointers referring to that inode.当且仅当ref==0才会从内核中释放。

      +

      如果nlinks==0就会从物理block中释放。

      +

      The iget and iput functions acquire and release pointers to an inode, modifying the reference count.【相当于buffer cache的balloc和bfree】Pointers to an inode can come from file descriptors, current working directories, and transient kernel code such as exec.

      +

      iget返回的struct inode可能没有任何有用的内容。为了确保它保存磁盘inode的副本，代码必须调用ilock。这将锁定inode（以便没有其他进程可以对其进行ilock），并从磁盘读取尚未读取的inode。iunlock释放inode上的锁。将inode指针的获取与锁定分离有助于在某些情况下避免死锁，例如在目录查找期间。多个进程可以持有指向iget返回的inode的C指针，但一次只能有一个进程锁定inode。

      +
      +
      //in file.h
      // in-memory copy of an inode
      struct inode {
        uint dev;           // Device number
        uint inum;          // Inode number
        int ref;            // Reference count
        struct sleeplock lock; // protects everything below here
        int valid;          // inode has been read from disk?

        short type;         // copy of disk inode
        short major;
        short minor;
        short nlink;
        uint size;
        uint addrs[NDIRECT+1];// 存储着inode数据的blocks的地址，从balloc中获取
      };
      + +

      Code: inode

      +

      主要是在讲inode layer这一层的方法，以及给上层提供的接口。

      +
      +

      Overview

      image-20230124153309132

      +

      底层接口

      +

      iget iput

      +
      +
      iget

      逻辑还是跟buffer cache非常相似的，不过可以看出这个的数据结构简单许多，也不用实现LRU。

      -

      为什么ap > base呢？

      -

      别忘了我们扩容的原理。我们是以proc->size为起始地址扩容的。ap处在扩容内存中，因而ap>旧size；base处在扩容前内存内，因而base<=旧size。故而有ap>base。

      +

      A struct inode pointer returned by iget() is guaranteed to be valid until the corresponding call to iput()： the inode won’t be deleted, and the memory referred to by the pointer won’t be re-used for a different inode. 【通过ref++实现。】

      +

      不同于buffer cache的bget，iget()提供对inode的非独占访问，因此可以有许多指向同一inode的指针。文件系统代码的许多部分都依赖于iget()的这种行为，既可以保存对inode的长期引用（如打开的文件和当前目录），也可以防止争用，同时避免操纵多个inode（如路径名查找）的代码产生死锁。

      -
      if(bp + bp->s.size == p->s.ptr){
        bp->s.size += p->s.ptr->s.size;
        bp->s.ptr = p->s.ptr->s.ptr;
      } else
        bp->s.ptr = p->s.ptr;
      if(p + p->s.size == bp){
        p->s.size += bp->s.size;
        p->s.ptr = bp->s.ptr;
      } else
        p->s.ptr = bp;
      freep = p;
      +
      // Find the inode with number inum on device dev
      // and return the in-memory copy. Does not lock
      // the inode and does not read it from disk.
      static struct inode*
      iget(uint dev, uint inum)
      {
        struct inode *ip, *empty;

        acquire(&icache.lock);

        // Is the inode already cached?
        empty = 0;
        for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
          if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
            ip->ref++;
            release(&icache.lock);
            return ip;
          }
          // 由于不用实现LRU，所以只需一次循环记录即可。
          if(empty == 0 && ip->ref == 0)    // Remember empty slot.
            empty = ip;
        }

        // Recycle an inode cache entry.
        if(empty == 0)
          panic("iget: no inodes");

        ip = empty;
        ip->dev = dev;
        ip->inum = inum;
        ip->ref = 1;
        // does not read from disk
        ip->valid = 0;
        release(&icache.lock);

        return ip;
      }
      -

      跳出循环后，我们会进入第一个if的第二个分支，以及第二个if的第二个分支。经过这些指针操作后，此时我们的数据结构如下图所示：

      -

      image-20230316145733160

      -

      也即形成了一个两节点的环形链表。

      -

      malloc

      经历完上述调用后，我们回到malloc的循环中：

      -
      for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
        // ...
        if(p == freep)
          if((p = morecore(nunits)) == 0)
            return 0;
      }
      +
      iput
      +

      iput()可以写入磁盘。这意味着任何使用文件系统的系统调用都可能写入磁盘，因为系统调用可能是最后一个引用该文件的系统调用。即使像read()这样看起来是只读的调用，也可能最终调用iput()。这反过来意味着，即使是只读系统调用，如果它们使用文件系统，也必须在事务中进行包装。

      +

      iput()和崩溃之间存在一种具有挑战性的交互。iput()不会在文件的链接计数降至零时立即截断文件，因为某些进程可能仍在内存中保留对inode的引用：进程可能仍在读取和写入该文件，因为它已成功打开该文件。但是，如果在最后一个进程关闭该文件的文件描述符之前发生崩溃，则该文件将被标记为已在磁盘上分配，但没有目录项指向它。如果不做任何处理措施的话，这块磁盘就再也用不了了。

      +

      文件系统以两种方式之一处理这种情况。简单的解决方案用于恢复时：重新启动后，文件系统会扫描整个文件系统，以查找标记为已分配但没有指向它们的目录项的文件。如果存在任何此类文件，接下来可以将其释放。

      +

      第二种解决方案不需要扫描文件系统。在此解决方案中，文件系统在磁盘（例如在超级块中）上记录链接计数降至零但引用计数不为零的文件的i-number。如果文件系统在其引用计数达到0时删除该文件，则会通过从列表中删除该inode来更新磁盘列表。重新启动时，文件系统将释放列表中的所有文件。

      +

      Xv6没有实现这两种解决方案，这意味着inode可能被标记为已在磁盘上分配，即使它们不再使用。这意味着随着时间的推移，xv6可能会面临磁盘空间不足的风险。

      +
      +
      // Drop a reference to an in-memory inode.
      // If that was the last reference, the inode cache entry can
      // be recycled.【refvnt==0 可以回收】
      // 注意这个回收过程无需特别处理，只需自然--refcnt就行，不用像buffer cache那么烦
      // If that was the last reference and the inode has no links
      // to it, free the inode (and its content) on disk.【nlinks==0 copy和本体都得扔掉】
      // All calls to iput() must be inside a transaction in
      // case it has to free the inode.任何需要iput的地方都需要包裹在事务内，因为它可能会释放inode
      void
      iput(struct inode *ip)
      {
        acquire(&icache.lock);

        if(ip->ref == 1 && ip->valid && ip->nlink == 0){
          // inode has no links and no other references: truncate and free.

          // ip->ref == 1 means no other process can have ip locked,
          // so this acquiresleep() won't block (or deadlock).
          acquiresleep(&ip->lock);

          release(&icache.lock);

          // 最终调用bfree，会标记bitmap，完全释放block
          itrunc(ip);
          ip->type = 0;
            
          /*iupdate:
          // Copy a modified in-memory inode to disk.
          // Must be called after every change to an ip->xxx field
      	// that lives on disk, since i-node cache is write-through.
      	write-through:
      	CPU向cache写入数据时，同时向memory(后端存储)也写一份，使cache和memory的数据保持一致。
          */
          // 这里修改的type是dinode也有的字段，所以需要update一下。
          // 下面的valid是dinode没有的字段，所以随便改，无需update
          iupdate(ip);
          ip->valid = 0;

          releasesleep(&ip->lock);

          acquire(&icache.lock);
        }

        ip->ref--;
        release(&icache.lock);
      }
      -

      由morecore的返回值可知，此时我们的p应该指向freep。本轮循环结束后执行 p = p->s.ptr，此时我们的p指向了我们刚在morecore中扩容出来的那一大段内存。

      -

      image-20230316150327569

      -

      在下一轮循环中，由于我们刚刚通过morecore申请了至少nunits的空间，因而我们将进入该分支：

      -
      if(p->s.size >= nunits){
        if(p->s.size == nunits)
          // 如果与所需的内存刚好相等，那就直接返回该小单元就行
          prevp->s.ptr = p->s.ptr;
        else {
          // 不等的话就只划分出一小部分
          // 一次划出几个header单元
          p->s.size -= nunits;
          p += p->s.size;
          p->s.size = nunits;
        }
        freep = prevp;
        return (void*)(p + 1);
      }
      +

      上层接口

      获取和释放inode
      ialloc
      // Allocate an inode on device dev.
      // Mark it as allocated by  giving it type type.
      // Returns an unlocked but allocated and referenced inode.
      struct inode*
      ialloc(uint dev, short type)
      {
        int inum;
        struct buf *bp;
        struct dinode *dip;

        for(inum = 1; inum < sb.ninodes; inum++){
          bp = bread(dev, IBLOCK(inum, sb));
          dip = (struct dinode*)bp->data + inum%IPB;
          if(dip->type == 0){  // a free inode通过type判断是否free
            memset(dip, 0, sizeof(*dip));// zerod
            dip->type = type;
            log_write(bp);   // mark it allocated on the disk
            brelse(bp);
            return iget(dev, inum);
          }
          brelse(bp);
        }
        panic("ialloc: no inodes");
      }
      -

      当nunits >= 4096，也即p->s.size == nunits，p所指向的地址恰好就是我们接下来会用的地址。因而，我们就将这部分内存空间从我们的freelist中剔除，在之后返回p的地址即可。

      -

      当nunits < 4096，也即p->s.size != nunits，说明p所指向的这块内存空间比我们需要的大，那么我们就仅将该段内存空间切割出需要的那一小部分，再把p指向那一小部分开头的地方，返回p地址即可，如图所示。

      -

      image-20230316150846709

      -

      这样一来，我们就成功给用户它所需要的内存空间了。

      -

      free

      进行malloc之后，用户还需要调用free来手动释放内存，防止内存泄漏。

      -

      image-20230316151116462

      -
      for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
        if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
          break;
      +
      inode的锁保护

      前面说到，inode的设计使得有多个指针同时指向一个inode成为了可能。因而，修改使用inode的时候就要对其进行独占访问。使用ialloc获取和用ifree释放的inode必须被保护在ilock和iunlock区域中。

      +
      ilock

      ilock既可以实现对inode的独占访问，同时也可以给未初始化的inode进行初始化工作。

      +
      +

      iget返回的struct inode可能没有任何有用的内容。为了确保它保存磁盘inode的副本，代码必须调用ilock。这将锁定inode（以便没有其他进程可以对其进行ilock），并从磁盘读取尚未读取的inode。

      +
      +
      // Lock the given inode and reads the inode from disk if necessary.
      void
      ilock(struct inode *ip)
      {
        struct buf *bp;
        struct dinode *dip;

        if(ip == 0 || ip->ref < 1)
          panic("ilock");

        acquiresleep(&ip->lock);

        if(ip->valid == 0){
          // 通过inode索引号和superblock算出扇区号
          bp = bread(ip->dev, IBLOCK(ip->inum, sb));
          dip = (struct dinode*)bp->data + ip->inum%IPB;
          // 填充ip
          ip->type = dip->type;
          ip->major = dip->major;
          ip->minor = dip->minor;
          ip->nlink = dip->nlink;
          ip->size = dip->size;
          memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
          brelse(bp);
          ip->valid = 1;
          if(ip->type == 0)
            panic("ilock: no type");
        }
      }
      -

      由于ap > base且ap > 旧p->size = base->ptr且base < base->ptr，故而首先会进行一轮循环。再然后，由于p = 旧p->size，并且p > p->ptr = base，并且ap > 旧size，故而跳出循环。

      +
      iunlock
      +

      iunlock释放inode上的锁。

      +

      将inode指针的获取与锁定分离有助于在某些情况下避免死锁，例如在目录查找期间。多个进程可以持有指向iget返回的inode的C指针，但一次只能有一个进程锁定inode。

      +
      +
      // Unlock the given inode.
      void
      iunlock(struct inode *ip)
      {
        if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
          panic("iunlock");

        releasesleep(&ip->lock);
      }
      + +

      Code: inode content

      Overview

      +

      主要讲的是inode本身存储数据的结构

      +
      -

      此处循环中，循环语句内部的这个循环实际上是对遍历到环形链表尾部，即将从头开始遍历，这个边界情况的处理。比较符合逻辑的还是循环语句内的那个条件。

      +

      磁盘上的inode结构体struct dinode包含一个size和一个块号数组（见图8.3），数组内罗列着存储着该inode数据的块号。

      +

      前面的NDIRECT个数据块被列在数组中的前NDIRECT个元素中；这些块称为直接块（direct blocks）。接下来的NINDIRECT个数据块不在inode中列出，而是在称为间接块（indirect block）的数据块中列出。addrs数组中的最后一个元素给出了间接块的地址。

      +

      因此，可以从inode中列出的块加载文件的前12 kB（NDIRECT x BSIZE）字节，而只有在查阅间接块后才能加载下一个256 kB（NINDIRECT x BSIZE）字节。

      -
      if(bp + bp->s.size == p->s.ptr){
        bp->s.size += p->s.ptr->s.size;
        bp->s.ptr = p->s.ptr->s.ptr;
      } else
        bp->s.ptr = p->s.ptr;
      if(p + p->s.size == bp){
        p->s.size += bp->s.size;
        p->s.ptr = bp->s.ptr;
      } else
        p->s.ptr = bp;
      freep = p;
      +
      // On-disk inode structure
      struct dinode {
        // ...
        uint addrs[NDIRECT+1];   // Data block addresses
      };
      -

      此时会进入第二个if的第一个分支。具体情况看图就行，不多bb。

      -

      总结

      主要就是这个数据结构用得很巧妙但也很复杂。它吸取了内核态中分配内存使用一个freelist的特点，同时又巧妙地利用了内存地址有序的特点，从而实现碎片内存管理。我的建议是多画图。

      -

      还有其实有一点我不是很理解。我觉得freep这个变量的用意非常不明，它似乎并不是指代整个freelist的头，因为它在很多个地方都诡异地赋值了一次。我想，它也许始终指向上一次被alloc/被free的内存的前一个吧。。。我猜测这样设计是为了蕴含一些LRU的思想。不大明白。

      -

      m-s-u权限切换

      由os知识可知，机器态、内核态、用户态分别有三种不同的操作权限。xv6是如何对权限切换进行管理的呢？

      -

      这部分知识我在正文的一个小地方记录了下来，详见 chapter2 - Code: starting xv6 and the fifirst process - xv6 - 感想 的第二点。

      -

      Lock实验的评测机制

      在xv6该次实验中，为了实现评测可视化，引入了statistics机制对结果进行评估。下面，我将通过源码简单介绍其实现机制。

      -

      来讲讲这玩意是怎么实现用户态读取锁争用次数的。我们从statistics函数可看出，它的本质是通过读取“文件”，来从内核中读取争用次数的相关数据：

      -
      int statistics(void *buf, int sz) {
        fd = open("statistics", O_RDONLY);
        ...
          if ((n = read(fd, buf+i, sz-i)) < 0) {
      }
      +

      image-20230124163025094

      +

      bmap

      +

      函数bmap负责封装这个寻找数据块的过程，以便实现我们将很快看到的如readi和writei这样的更高级例程。

      +

      bmap(struct inode *ip, uint bn)返回inodeip的第bn个数据块的磁盘块号。如果ip还没有这样的块，bmap会分配一个。

      +

      Bmap使readi和writei很容易获取inode的数据。

      +
      +
      // Inode content
      //
      // The content (data) associated with each inode is stored
      // in blocks on the disk. The first NDIRECT block numbers
      // are listed in ip->addrs[].  The next NINDIRECT blocks are
      // listed in block ip->addrs[NDIRECT].

      // Return the disk block address of the nth block in inode ip.
      // If there is no such block, bmap allocates one.
      static uint
      bmap(struct inode *ip, uint bn)
      {
        uint addr, *a;
        struct buf *bp;

        // 如果为direct block
        if(bn < NDIRECT){
          if((addr = ip->addrs[bn]) == 0)
            ip->addrs[bn] = addr = balloc(ip->dev);
          return addr;
        }
        bn -= NDIRECT;
          
        // 如果为indirect block
        if(bn < NINDIRECT){
          // Load indirect block, allocating if necessary.
          if((addr = ip->addrs[NDIRECT]) == 0)
            ip->addrs[NDIRECT] = addr = balloc(ip->dev);
          bp = bread(ip->dev, addr);
          a = (uint*)bp->data;
          if((addr = a[bn]) == 0){
            // 如果没有，会分配一个
            a[bn] = addr = balloc(ip->dev);
            log_write(bp);
          }
          brelse(bp);
          return addr;
        }

        panic("bmap: out of range");
      }
      -

      那么安装以前所学的内容，我们很容易联系到这玩意应该并不是个文件，而是类似于proc文件系统那样的虚拟文件。它应该会在open、read中根据其特有的文件类型进行转发。在init.c中，我们可以看到：

      -
      main(void)
      {
        if(open("console", O_RDWR) < 0){
          mknod("console", CONSOLE, 0);
          mknod("statistics", STATS, 0);
          open("console", O_RDWR);
        }
      +

      itrunc

      +

      itrunc释放文件的块，将inode的size重置为零。

      +

      Itrunc首先释放直接块，然后释放间接块中列出的块，最后释放间接块本身。

      +
      +

      readi

      +

      readi和writei都是从检查ip->type == T_DEV开始的。这种情况处理的是数据不在文件系统中的特殊设备；我们将在文件描述符层返回到这种情况。

      +
      +
      // Read data from inode.数据大小为n，从off开始，读到dst处
      // Caller must hold ip->lock.
      // If user_dst==1, then dst is a user virtual address;
      // otherwise, dst is a kernel address.
      int
      readi(struct inode *ip, int user_dst, uint64 dst, uint off, uint n)
      {
        uint tot, m;
        struct buf *bp;

        if(off > ip->size || off + n < off)
          return 0;
        if(off + n > ip->size)
          n = ip->size - off;

        // 主循环处理文件的每个块，将数据从缓冲区复制到dst
        for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
          bp = bread(ip->dev, bmap(ip, off/BSIZE));
          m = min(n - tot, BSIZE - off%BSIZE);
          if(either_copyout(user_dst, dst, bp->data + (off % BSIZE), m) == -1) {
            brelse(bp);
            tot = -1;
            break;
          }
          brelse(bp);
        }
        return tot;
      }
      -

      这玩意的文件结点实际上是在创建console时整的，并且其有一个特殊的文件类型“STATS”。我们可以进一步追溯到kernel中的main.c：

      -
      void main()
      {
        if(cpuid() == 0){
      #if defined(LAB_PGTBL) || defined(LAB_LOCK)
          statsinit();
      +

      writei

      // Write data to inode.
      // Caller must hold ip->lock.
      // If user_src==1, then src is a user virtual address;
      // otherwise, src is a kernel address.
      int
      writei(struct inode *ip, int user_src, uint64 src, uint off, uint n)
      {
        uint tot, m;
        struct buf *bp;

        if(off > ip->size || off + n < off)
          return -1;
        // writei会自动增长文件，除非达到文件的最大大小
        if(off + n > MAXFILE*BSIZE)
          return -1;

        for(tot=0; tot<n; tot+=m, off+=m, src+=m){
          bp = bread(ip->dev, bmap(ip, off/BSIZE));
          m = min(n - tot, BSIZE - off%BSIZE);
          if(either_copyin(bp->data + (off % BSIZE), user_src, src, m) == -1) {
            brelse(bp);
            n = -1;
            break;
          }
          log_write(bp);
          brelse(bp);
        }

        if(n > 0){
          if(off > ip->size)
            // 说明扩大了文件大小，需要修改
            ip->size = off;
          // write the i-node back to disk even if the size didn't change
          // because the loop above might have called bmap() and added a new
          // block to ip->addrs[].
          iupdate(ip);
        }

        return n;
      }
      -
      void
      statsinit(void)
      {
        initlock(&stats.lock, "stats");

        devsw[STATS].read = statsread;
        devsw[STATS].write = statswrite;
      }
      +

      stati

      +

      函数stati将inode元数据复制到stat结构体中，该结构通过stat系统调用向用户程序公开。

      +
      +

      在defs.h中可看到inode结构体是private的，而stat是public的。

      +

      Directory layer

      数据结构

      +

      目录的内部实现很像文件。其inode的type为T_DIR，其数据是directory entries的集合。

      +

      每个entry都是一个struct dirent。

      +
      +

      也就是说这一层其实本质上是一个大小一定的map，该map自身也存放在inode中，大小为inode的大小，每个表项entry映射了目录名和文件inode。所以接下来介绍的函数我们完全可以从hashmap增删改查的角度去理解。

      +
      // Directory is a file containing a sequence of dirent structures.
      #define DIRSIZ 14

      struct dirent {
        ushort inum;// 如果为0，说明该entry free
        char name[DIRSIZ];
      };
      -

      可以看到，它给这个STATS文件类型注册了这两个函数。当我们调用read和write时，实际上就是在调用这俩玩意。我们可以看下这两个handler都干了啥。

      -
      #define BUFSZ 4096
      static struct {
        struct spinlock lock;
        char buf[BUFSZ];
        int sz;
        int off;
      } stats;

      int statsread(int user_dst, uint64 dst, int n) {
        int m;
        acquire(&stats.lock);

        if(stats.sz == 0) {
      #ifdef LAB_LOCK
          stats.sz = statslock(stats.buf, BUFSZ); // 把信息copy进自己的缓冲区里
      #endif
        }
        m = stats.sz - stats.off;

        if (m > 0) { // 如果有新东西，就copy到用户缓冲区里
          if(m > n)	m  = n;
          if(either_copyout(user_dst, dst, stats.buf+stats.off, m) != -1) {
            stats.off += m;
          }
        } else {
          m = -1;
          stats.sz = 0;
          stats.off = 0;
        }
        release(&stats.lock);
        return m;
      }
      +

      image-20230124173241241

      +

      相关函数

      dirlookup

      +

      函数dirlookup在directory中搜索具有给定名称的entry。

      +

      它返回的指向enrty.inum相应的inode是非独占的【通过iget获取】，也即无锁状态。它还会把*poff设置为所需的entry的字节偏移量。

      +

      为什么要返回未锁定的inode？是因为调用者已锁定dp，因此，如果对.进行查找，则在返回之前尝试锁定inode将导致重新锁定dp并产生死锁【确实】(还有更复杂的死锁场景，涉及多个进程和..，父目录的别名。.不是唯一的问题。）

      +

      所以锁定交给caller来做。caller可以解锁dp，然后锁定该函数返回的ip，确保它一次只持有一个锁。

      +
      +
      // Look for a directory entry in a directory.
      // If found, set *poff to byte offset of entry.
      struct inode*
      dirlookup(struct inode *dp, char *name, uint *poff)
      {
        uint off, inum;
        struct dirent de;

        if(dp->type != T_DIR)
          panic("dirlookup not DIR");
        // new level of abstraction,可以把directory的inode看作一个表文件，每个表项都是一个entry
        for(off = 0; off < dp->size; off += sizeof(de)){
          // 从directory中获取entry，也即从inode中获取数据
          if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
            panic("dirlookup read");
          // free
          if(de.inum == 0)
            continue;
          if(namecmp(name, de.name) == 0){
            // entry matches path element
            if(poff)
              *poff = off;
            inum = de.inum;
            return iget(dp->dev, inum);
          }
        }

        return 0;
      }
      -
      int statswrite(int user_src, uint64 src, int n) { // WARNING: READ ONLY!!!
        return -1;
      }
      +
      // Write a new directory entry (name, inum) into the directory dp.
      int
      dirlink(struct inode *dp, char *name, uint inum)
      {
        int off;
        struct dirent de;
        struct inode *ip;

        // Check that name is not present.
        if((ip = dirlookup(dp, name, 0)) != 0){
          iput(ip);
          return -1;
        }

        // Look for an empty dirent.
        for(off = 0; off < dp->size; off += sizeof(de)){
          if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
            panic("dirlink read");
          if(de.inum == 0)
            break;
        }

        // 如果没找到空闲的则调用writei自动增长inode，添加新表项
        strncpy(de.name, name, DIRSIZ);
        de.inum = inum;
        if(writei(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
          panic("dirlink");

        return 0;
      }
      -

      可以看到其本质就是把statslock返回的东西copy到用户空间了。我们来结合最后的输出效果看看statslock的具体实现：

      -

      image-20231024232632816

      -
      int statslock(char *buf, int sz) {
        int n;
        int tot = 0;
        int found = 0;

        acquire(&lock_locks);
        n = snprintf(buf, sz, "--- lock kmem/bcache stats\n");
        for(int i = 0; i < NLOCK; i++) {
          if(locks[i] == 0)	break;
          if(strncmp(locks[i]->name, "bcache", strlen("bcache")) == 0 ||
             strncmp(locks[i]->name, "kmem", strlen("kmem")) == 0) {
            tot += locks[i]->nts; // 记入->nts计数
            /*
              snprint_lock: lock: %s: #fetch-and-add %d #acquire() %d\n
            */
            n += snprint_lock(buf +n, sz-n, locks[i]);
            found += 1;
          }
        }

        // Require at least two locks name after kmem/bcache.
        if (found < 2) {
          tot = -1;
        }
        
        // 简单粗暴地计算前五多争用的进程
        n += snprintf(buf+n, sz-n, "--- top 5 contended locks:\n");
        int last = 100000000;
        // stupid way to compute top 5 contended locks
        for(int t = 0; t < 5; t++) {
          int top = 0;
          for(int i = 0; i < NLOCK; i++) {
            if(locks[i] == 0)
              break;
            if(locks[i]->nts > locks[top]->nts && locks[i]->nts < last) {
              top = i;
            }
          }
          /*
            snprint_lock: lock: %s: #fetch-and-add %d #acquire() %d\n
          */
          n += snprint_lock(buf+n, sz-n, locks[top]);
          last = locks[top]->nts;
        }
        n += snprintf(buf+n, sz-n, "tot= %d\n", tot);
        release(&lock_locks);  
        return n;
      }
      +

      Pathname layer

      +

      Path name lookup involves a succession of calls to dirlookup, one for each path component.

      +
      +

      namei和nameiparent

      +

      Namei (kernel/fs.c:661) evaluates path and returns the corresponding inode.

      +

      函数nameiparent是一个变体：它在最后一个元素之前停止，返回父目录的inode并将最后一个元素复制到name中。两者都调用通用函数namex来完成实际工作。

      +
      +
      struct inode*
      namei(char *path)
      {
        char name[DIRSIZ];
        return namex(path, 0, name);
      }
      -

      可以看到其争用本质计算是通过spinlock::nts字段记录。我们来看看这玩意的引用：

      -
      void initlock(struct spinlock *lk, char *name) {
      #ifdef LAB_LOCK
        lk->nts = 0;
      #endif  
      }

      void acquire(struct spinlock *lk) {
        ...
        while(__sync_lock_test_and_set(&lk->locked, 1) != 0) {
      #ifdef LAB_LOCK
          __sync_fetch_and_add(&(lk->nts), 1);
      #else
         ;
      #endif
      }
      +
      struct inode*
      nameiparent(char *path, char *name)
      {
        return namex(path, 1, name);
      }
      -

      很好，逻辑很简单，就是记录acquire时等待的次数，非常简单粗暴（（（

      -

      总的来说这个思路还是挺酷的，而且这个“一切皆文件”的思想再次震撼了我，一个小小的xv6确实能做到那么多。

      -]]> - - - 各种配环境中遇到的问题 - /2023/10/12/%E5%90%84%E7%A7%8D%E9%85%8D%E7%8E%AF%E5%A2%83%E4%B8%AD%E9%81%87%E5%88%B0%E7%9A%84%E9%97%AE%E9%A2%98/ - 记录一次vm扩容

      -

      开发中遇到的链接小问题

      -

      rtt硬件环境搭建

      -]]>       -       - - File system - /2023/01/10/xv6$chap8/ - File system
      -

      来到指导书最高点！太美丽了xv6。哎呀那不文件系统吗（

      -

      这里是自底向上讲起的。之后可以看看hit网课的自顶向下。

      +

      namex

      +

      Namex首先决定路径解析的开始位置。

      +

      如果路径以“ / ”开始，则从根目录开始解析；否则，从当前目录开始。

      +

      然后，它使用skipelem依次考察路径的每个元素。循环的每次迭代都必须在当前索引结点ip中查找name。

      +

      迭代首先给ip上锁并检查它是否是一个目录。如果不是，则查找失败。

      +

      如果caller是nameiparent，并且这是最后一个路径元素，则根据nameiparent的定义，循环会提前停止；最后一个路径元素已经复制到name中【在上一轮循坏中做了这件事】，因此namex只需返回解锁的ip。

      +

      最后，循环将使用dirlookup查找路径元素，并通过设置ip = next为下一次迭代做准备。当循环用完路径元素时，它返回ip。

      +

      注：

      +
        +
      1. 在每次迭代中锁定ip是必要的，不是因为ip->type可以被更改，而是因为在ilock运行之前，ip->type不能保证已从磁盘加载，所以得用到ilock保证一定会被加载的这个性质。
        2. +
      +
      // Look up and return the inode for a path name.
      // If parent != 0, return the inode for the parent and copy the final
      // path element into name, which must have room for DIRSIZ bytes.
      // Must be called inside a transaction since it calls iput().
      static struct inode*
      namex(char *path, int nameiparent, char *name)
      {
        struct inode *ip, *next;

        if(*path == '/')
          ip = iget(ROOTDEV, ROOTINO);
        else
          ip = idup(myproc()->cwd);

        // 使用skipelem依次考察路径的每个元素
        while((path = skipelem(path, name)) != 0){
          ilock(ip);
          if(ip->type != T_DIR){
            iunlockput(ip);
            return 0;
          }
          if(nameiparent && *path == '\0'){
            // Stop one level early.
            iunlock(ip);
            return ip;
          }
          if((next = dirlookup(ip, name, 0)) == 0){
            iunlockput(ip);
            return 0;
          }
          iunlockput(ip);
          ip = next;
        }
        if(nameiparent){
          iput(ip);
          return 0;
        }
        return ip;
      }
      +
      -

      image-20230121160555370

      +

      namex过程可能需要很长时间才能完成：它可能涉及多个磁盘操作来读取路径名中所遍历目录的索引节点和目录块（如果它们不在buffer cache中）。

      +

      Xv6 is carefully designed，如果一个内核线程对namex的调用在磁盘I/O上阻塞，另一个查找不同路径名的内核线程可以同时进行。Namex locks each directory in the path separately so that lookups in different directories can proceed in parallel.锁细粒度化

      +

      This concurrency introduces some challenges. For example, while one kernel thread is looking up a pathname another kernel thread may be changing the directory tree by unlinking a directory. A potential risk is that a lookup may be searching a directory that has been deleted by another kernel thread and its blocks have been re-used for another directory or file.一个潜在的风险是，查找可能正在搜索已被另一个内核线程删除且其块已被重新用于另一个目录或文件的目录。

      +

      Xv6避免了这种竞争，也就是说，你查到的inode保证暂时不会被释放，里面的内容还是真的，而不会被重新利用从而导致里面的内容变样。

      +

      例如，在namex中执行dirlookup时，lookup线程持有目录上的锁，dirlookup返回使用iget获得的inode。Iget增加索引节点的引用计数。只有在从dirlookup接收inode之后，namex才会释放目录上的锁。现在，另一个线程可以从目录中取消inode的链接，但是xv6还不会删除inode，因为inode的引用计数仍然大于零。

      +

      另一个风险是死锁。例如，查找“.”时，next指向与ip相同的inode【确实】。在释放ip上的锁之前锁定next将导致死锁【为什么？？？难道不是会由于在acquire时已经持有锁，从而爆panic("acquire")吗？】。为了避免这种死锁，namex在获得下一个目录的锁之前解锁该目录。这里我们再次看到为什么iget和ilock之间的分离很重要。

      -

      Overview

      image-20230121160641718

      -
      -

      The disk layer reads and writes blocks on an virtio hard drive.

      -

      The buffer cache layer caches disk blocks and synchronizes access to them, making sure that only one kernel process at a time can modify the data stored in any particular block.

      -

      The logging layer allows higher layers to wrap updates to several blocks in a transaction, and ensures that the blocks are updated atomically in the face of crashes (i.e., all of them are updated or none). 【日志记录层允许更高层将更新包装到一个事务中的多个块，并确保在崩溃时以原子方式更新块（即，所有块都更新或不更新）。可以类比一下数据库的那个概念。】

      -

      The inode layer provides individual files, each represented as an inode with a unique i-number and some blocks holding the file’s data.

      -

      The directory layer implements each directory as a special kind of inode whose content is a sequence of directory entries, each of which contains a file’s name and i-number.

      -

      The pathname layer provides hierarchical path names like /usr/rtm/xv6/fs.c, and resolves them with recursive lookup.

      -

      The file descriptor layer abstracts many Unix resources (e.g., pipes, devices, fifiles, etc.) using the file system interface, simplifying the lives of application programmers.

      +

      File descriptor layer

      +

      Unix的一个很酷的方面是，Unix中的大多数资源都表示为文件，包括控制台、管道等设备，当然还有真实文件。文件描述符层是实现这种一致性的层。

      -

      image-20230121162324747

      -
      -

      The file system must have a plan for where it stores inodes and content blocks on the disk. To do so, xv6 divides the disk into several sections, as Figure 8.2 shows.

      -

      The file system does not use block 0 (it holds the boot sector).

      -

      Block 1 is called the superblock; it contains metadata about the file system (the file system size in blocks, the number of data blocks, the number of inodes, and the number of blocks in the log). The superblock is filled in by a separate program, called mkfs, which builds an initial file system.

      -

      Blocks starting at 2 hold the log.

      -

      After the log are the inodes, with multiple inodes per block.

      -

      After those come bitmap blocks tracking which data blocks are in use. 【应该是用来标识每个块是否空闲的吧】

      -

      The remaining blocks are data blocks; each is either marked free in the bitmap block, or holds content for a file or directory【要么空闲要么是文件或目录】.

      +

      数据结构

      +

      Xv6为每个进程提供了自己的打开文件表或文件描述符。每个打开的文件都由一个struct file表示，它是inode或管道的封装，加上一个I/O偏移量。

      +

      每次调用open都会创建一个新的打开文件（一个新的struct file）：如果多个进程独立地打开同一个文件，那么不同的实例将具有不同的I/O偏移量。

      +

      另一方面，单个打开的文件（同一个struct file）可以多次出现在一个进程的文件表中，也可以出现在多个进程的文件表中。如果一个进程使用open打开文件，然后使用dup创建别名，或使用fork与子进程共享，就会发生这种情况。

      -

      Buffer cache

      -

      The buffer cache has two jobs:

      -
        -
      1. synchronize access to disk blocks to ensure that only one copy of a block is in memory and that only one kernel thread at a time uses that copy;
        2. -
      2. cache popular blocks so that they don’t need to be re-read from the slow disk.
        3. -
      -

      The code is in bio.c.

      -

      Buffer cache中保存磁盘块的缓冲区数量固定，这意味着如果文件系统请求还未存放在缓存中的块，Buffer cache必须回收当前保存其他块内容的缓冲区。Buffer cache为新块回收最近使用最少的缓冲区。这样做的原因是认为最近使用最少的缓冲区是最不可能近期再次使用的缓冲区。

      +
      struct file {
        enum { FD_NONE, FD_PIPE, FD_INODE, FD_DEVICE } type;
        int ref; // reference count
        char readable;
        char writable;
        struct pipe *pipe; // FD_PIPE
        struct inode *ip;  // FD_INODE and FD_DEVICE
        uint off;          // FD_INODE
        short major;       // FD_DEVICE
      };
      + +

      ftable

      +

      所有在系统中打开的文件都会被放入global file tableftable中。

      +

      ftable具有分配文件（filealloc）、创建重复引用（filedup）、释放引用（fileclose）以及读取和写入数据（fileread和filewrite）的函数。

      +

      前三个都很常规，跟之前的xxalloc、xxfree的思路是一样的。

      +

      函数filestat、fileread和filewrite实现对文件的stat、read和write操作。

      -

      image-20230124151719288

      -

      数据结构定义

      struct buf {
        int valid;   // has data been read from disk?缓冲区是否包含块的副本
        int disk;    // does disk "own" buf?缓冲区内容是否已交给磁盘
        uint dev;
        uint blockno;
        struct sleeplock lock;
        uint refcnt;
        struct buf *prev; // LRU cache list
        struct buf *next;
        uchar data[BSIZE];
      };
      +

      filealloc

      // Allocate a file structure.
      struct file*
      filealloc(void)
      {
        struct file *f;

        acquire(&ftable.lock);
        for(f = ftable.file; f < ftable.file + NFILE; f++){
          if(f->ref == 0){
            f->ref = 1;
            release(&ftable.lock);
            return f;
          }
        }
        release(&ftable.lock);
        return 0;
      }
      -

      这应该代表着一个磁盘块。

      -
      struct {
        struct spinlock lock;
        struct buf buf[NBUF];

        // Linked list of all buffers, through prev/next.
        // Sorted by how recently the buffer was used.
        // head.next is most recent, head.prev is least.
        struct buf head;
      } bcache;
      +

      filedup

      // Increment ref count for file f.
      struct file*
      filedup(struct file *f)
      {
        acquire(&ftable.lock);
        if(f->ref < 1)
          panic("filedup");
        f->ref++;
        release(&ftable.lock);
        return f;
      }
      -

      大概buf数组里存储着所有buf的内容。buf本身通过最近使用排序的双向链表连接，head是链表的头。

      -

      初始化

      // called by main.c
      void
      binit(void)
      {
        struct buf *b;

        initlock(&bcache.lock, "bcache");

        // Create linked list of buffers
        // 把b插在head之后
        bcache.head.prev = &bcache.head;
        bcache.head.next = &bcache.head;
        for(b = bcache.buf; b < bcache.buf+NBUF; b++){
          b->next = bcache.head.next;
          b->prev = &bcache.head;
          initsleeplock(&b->lock, "buffer");
          bcache.head.next->prev = b;
          bcache.head.next = b;
        }
      }
      +

      fileclose

      // Close file f.  (Decrement ref count, close when reaches 0.)
      void
      fileclose(struct file *f)
      {
        struct file ff;

        acquire(&ftable.lock);
        if(f->ref < 1)
          panic("fileclose");
        if(--f->ref > 0){
          release(&ftable.lock);
          return;
        }
        ff = *f;
        f->ref = 0;
        f->type = FD_NONE;
        release(&ftable.lock);

        if(ff.type == FD_PIPE){
          pipeclose(ff.pipe, ff.writable);
        } else if(ff.type == FD_INODE || ff.type == FD_DEVICE){
          begin_op();
          iput(ff.ip);
          end_op();
        }
      }
      -

      上层接口

      -

      The main interface exported by the buffer cache consists of bread and bwrite.

      -

      The buffer cache uses a per-buffer sleep-lock to ensure concurrent security.

      +

      filestat

      +

      Filestat只允许在inode上操作并且调用了stati

      -

      bread

      -

      bread obtains a buf containing a copy of a block which can be read or modified in memory.

      -

      依据给定设备号和给定扇区号寻找cache的buf。返回的buf是locked的。

      +
      // Get metadata about file f.
      // addr is a user virtual address, pointing to a struct stat.
      int
      filestat(struct file *f, uint64 addr)
      {
        struct proc *p = myproc();
        struct stat st;

        // 仅允许文件/设备执行
        if(f->type == FD_INODE || f->type == FD_DEVICE){
          ilock(f->ip);
          stati(f->ip, &st);
          iunlock(f->ip);
          if(copyout(p->pagetable, addr, (char *)&st, sizeof(st)) < 0)
            return -1;
          return 0;
        }
        return -1;
      }
      + +

      fileread

      // Read from file f.
      // addr is a user virtual address.
      int
      fileread(struct file *f, uint64 addr, int n)
      {
        int r = 0;
        
        // 首先检查是否可读
        if(f->readable == 0)
          return -1;

        if(f->type == FD_PIPE){
          r = piperead(f->pipe, addr, n);
        } else if(f->type == FD_DEVICE){
          if(f->major < 0 || f->major >= NDEV || !devsw[f->major].read)
            return -1;
          r = devsw[f->major].read(1, addr, n);
        } else if(f->type == FD_INODE){
          ilock(f->ip);
          if((r = readi(f->ip, 1, addr, f->off, n)) > 0)
            // 移动文件指针偏移量
            f->off += r;
          iunlock(f->ip);
        } else {
          panic("fileread");
        }

        return r;
      }
      + +

      Code: System calls

      +

      通过使用底层提供的函数，大多数系统调用的实现都很简单（请参阅***kernel/sysfile.c***）。有几个调用值得仔细看看。

      +

      以下介绍的函数都在kernel/sysfile.c中。

      -
      // Return a locked buf with the contents of the indicated block.
      struct buf*
      bread(uint dev, uint blockno)
      {
        struct buf *b;

        // 获取buf块
        b = bget(dev, blockno);
        if(!b->valid) {
          // 说明cache未命中，需要从磁盘读入
          virtio_disk_rw(b, 0);
          b->valid = 1;
        }
        return b;
      }
      +

      这个函数的功能是给文件old加上一个链接，这个链接存在于文件new的父目录。感觉也就相当于把文件从old复制到new处了。具体实现逻辑就是要给该文件所在目录添加一个entry，name=新名字，inode=该文件的inode。

      +
      // Create the path new as a link to the same inode as old.
      uint64
      sys_link(void)
      {
        char name[DIRSIZ], new[MAXPATH], old[MAXPATH];
        struct inode *dp, *ip;

        if(argstr(0, old, MAXPATH) < 0 || argstr(1, new, MAXPATH) < 0)
          return -1;

        // 首先先增加nlink
        begin_op();
        // 通过path找到ip结点
        if((ip = namei(old)) == 0){
          end_op();
          return -1;
        }

        ilock(ip);
        // directory不能被link
        if(ip->type == T_DIR){
          iunlockput(ip);
          end_op();
          return -1;
        }

        ip->nlink++;
        // 修改一次字段就需要update一次
        iupdate(ip);
        iunlock(ip);

        // 然后再在目录中登记新的entry
        // 找到new的parent，也即new所在目录
        if((dp = nameiparent(new, name)) == 0)
          goto bad;
        ilock(dp);
        // 在目录中添加一个entry，名字为给定的新名字，inode依旧为原来的inode
        // new的父目录必须存在并且与现有inode位于同一设备上
        if(dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0){
          iunlockput(dp);
          goto bad;
        }
        iunlockput(dp);
        iput(ip);

        end_op();

        return 0;

      bad:
        ilock(ip);
        ip->nlink--;
        iupdate(ip);
        iunlockput(ip);
        end_op();
        return -1;
      }
      -

      bwrite

      -

      writes a modified buffer to the appropriate block on the disk

      +

      create

      +

      它是三个文件创建系统调用的泛化：带有O_CREATE标志的open生成一个新的普通文件，mkdir生成一个新目录，mkdev生成一个新的设备文件。

      -
      // Write b's contents to disk.  Must be locked.
      void
      bwrite(struct buf *b)
      {
        // 必须持有b的锁
        if(!holdingsleep(&b->lock))
          panic("bwrite");
        // 写入磁盘
        virtio_disk_rw(b, 1);
      }
      +

      创建一个新的inode结点，结点名包含在path内。返回一个锁定的inode。

      +

      由于使用了iupdate等，所以该函数只能在事务中被调用。

      +
      static struct inode*
      create(char *path, short type, short major, short minor)
      {
        struct inode *ip, *dp;
        char name[DIRSIZ];

        // 获取结点父目录
        if((dp = nameiparent(path, name)) == 0)
          return 0;

        ilock(dp);

        if((ip = dirlookup(dp, name, 0)) != 0){
          // 说明文件已存在
          iunlockput(dp);
          ilock(ip);
          if(type == T_FILE && (ip->type == T_FILE || ip->type == T_DEVICE))
            // 说明此时caller为open（type == T_FILE），open调用create只能是用于创建文件
            return ip;
          iunlockput(ip);
          return 0;
        }

        if((ip = ialloc(dp->dev, type)) == 0)
          panic("create: ialloc");

        ilock(ip);
        ip->major = major;
        ip->minor = minor;
        ip->nlink = 1;
        iupdate(ip);

        if(type == T_DIR){  // Create . and .. entries.
          dp->nlink++;  // for ".."
          iupdate(dp);
          // No ip->nlink++ for ".": avoid cyclic ref count.
          // 所以其实.和..本质上是link
          if(dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
            panic("create dots");
        }

        if(dirlink(dp, name, ip->inum) < 0)
          panic("create: dirlink");

        iunlockput(dp);

        return ip;
      }
      -

      brelse

      -

      A kernel thread must release a buffer by calling brelse when it is done with it.

      +

      sys_mkdir

      uint64
      sys_mkdir(void)
      {
        char path[MAXPATH];
        struct inode *ip;

        begin_op();
        if(argstr(0, path, MAXPATH) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0){
          end_op();
          return -1;
        }
        iunlockput(ip);
        end_op();
        return 0;
      }
      + +

      sys_open

      +

      Sys_open是最复杂的，因为创建一个新文件只是它能做的一小部分。

      -
      // Release a locked buffer.
      // Move to the head of the most-recently-used list.
      void
      brelse(struct buf *b)
      {
        if(!holdingsleep(&b->lock))
          panic("brelse");

        releasesleep(&b->lock);

        acquire(&bcache.lock);
        b->refcnt--;
        if (b->refcnt == 0) {
          // no one is waiting for it.
          // 移动到头结点和头结点的下一个结点之间的位置
          b->next->prev = b->prev;
          b->prev->next = b->next;
          b->next = bcache.head.next;
          b->prev = &bcache.head;
          bcache.head.next->prev = b;
          bcache.head.next = b;
        }

        release(&bcache.lock);
      }
      +
      uint64
      sys_open(void)
      {
        char path[MAXPATH];
        int fd, omode;
        struct file *f;
        struct inode *ip;
        int n;

        if((n = argstr(0, path, MAXPATH)) < 0 || argint(1, &omode) < 0)
          return -1;

        begin_op();

        if(omode & O_CREATE){
          ip = create(path, T_FILE, 0, 0);
          // 创建失败
          if(ip == 0){
            end_op();
            return -1;
          }
        } else {
          // 文件不存在
          if((ip = namei(path)) == 0){
            end_op();
            return -1;
          }
          // Create返回一个锁定的inode，但namei不锁定，因此sys_open必须锁定inode本身。
          ilock(ip);
          // 非文件，为目录并且非只读
          // 所以说想要open一个目录的话只能以只读模式打开
          if(ip->type == T_DIR && omode != O_RDONLY){
            iunlockput(ip);
            end_op();
            return -1;
          }
        }

        if(ip->type == T_DEVICE && (ip->major < 0 || ip->major >= NDEV)){
          iunlockput(ip);
          end_op();
          return -1;
        }

        // 获取file结构体和文件描述符。
        if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){
          if(f)
            fileclose(f);
          iunlockput(ip);
          end_op();
          return -1;
        }

        // 没有其他进程可以访问部分初始化的文件，因为它仅位于当前进程的表中，因而这里可以不用上锁
        if(ip->type == T_DEVICE){
          f->type = FD_DEVICE;
          f->major = ip->major;
        } else {
          f->type = FD_INODE;
          f->off = 0;
        }
        f->ip = ip;
        f->readable = !(omode & O_WRONLY);
        f->writable = (omode & O_WRONLY) || (omode & O_RDWR);

        // 如果使用了这个标志,调用 open 函数打开文件的时候会将文件原本的内容全部丢弃,文件大小变为 0。
        if((omode & O_TRUNC) && ip->type == T_FILE){
          itrunc(ip);
        }

        iunlock(ip);
        end_op();

        return fd;
      }
      -

      具体细节

      bget

      用于获取cache中是否存在block。如果不存在，则新申请一个buf，并把该buf以上锁状态返回

      -
      // Look through buffer cache for block on device dev.
      // If not found, allocate a buffer.
      // In either case, return locked buffer.
      static struct buf*
      bget(uint dev, uint blockno)
      {
        struct buf *b;

        acquire(&bcache.lock);

        // Is the block already cached?
        // 这个循环条件很有意思，充分用到了双向链表的特性
        for(b = bcache.head.next; b != &bcache.head; b = b->next){
          if(b->dev == dev && b->blockno == blockno){
            // 引用数增加
            b->refcnt++;
            release(&bcache.lock);
            // 锁定
            acquiresleep(&b->lock);
            return b;
          }
        }

        // Not cached.
        // Recycle the least recently used (LRU) unused buffer.
        // 从尾部开始遍历，确实就是最少使用的了
        for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
          // 如果该buf空闲
          if(b->refcnt == 0) {
            b->dev = dev;
            b->blockno = blockno;
            // 仅是新建了一个buf，还未从磁盘读取对应磁盘块的副本，因而设valid为0以供上层函数调用处理
            b->valid = 0;
            b->refcnt = 1;
            release(&bcache.lock);
            // 锁定
            acquiresleep(&b->lock);
            return b;
          }
        }
        // cache不够用了
        panic("bget: no buffers");
      }
      +

      sys_pipe

      uint64
      sys_pipe(void)
      {
        uint64 fdarray; // user pointer to array of two integers用来接收pipe两端的文件描述符
        struct file *rf, *wf;
        int fd0, fd1;
        struct proc *p = myproc();

        if(argaddr(0, &fdarray) < 0)
          return -1;
        if(pipealloc(&rf, &wf) < 0)
          return -1;
        fd0 = -1;
        if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
          if(fd0 >= 0)
            p->ofile[fd0] = 0;
          fileclose(rf);
          fileclose(wf);
          return -1;
        }
        if(copyout(p->pagetable, fdarray, (char*)&fd0, sizeof(fd0)) < 0 ||
           copyout(p->pagetable, fdarray+sizeof(fd0), (char *)&fd1, sizeof(fd1)) < 0){
          p->ofile[fd0] = 0;
          p->ofile[fd1] = 0;
          fileclose(rf);
          fileclose(wf);
          return -1;
        }
        return 0;
      }
      -

      Logging layer

      简介

      -

      Xv6通过简单的日志记录形式解决了文件系统操作期间的崩溃问题。

      -

      xv6系统调用不会直接写入磁盘上的文件系统数据结构。相反，它会在磁盘上的log（日志）中放置它希望进行的所有磁盘写入的描述。一旦系统调用记录了它的所有写入操作，它就会向磁盘写入一条特殊的commit（提交）记录，表明日志包含一个完整的操作。此时，系统调用将写操作复制到磁盘上的文件系统数据结构。完成这些写入后，系统调用将擦除磁盘上的日志。

      +

      Real world

      +

      实际操作系统中的buffer cache比xv6复杂得多，但它有两个相同的用途：缓存和同步对磁盘的访问。

      +

      与UNIX V6一样，Xv6的buffer cache使用简单的最近最少使用（LRU）替换策略；有许多更复杂的策略可以实现，每种策略都适用于某些工作场景，而不适用于其他工作场景。更高效的LRU缓存将消除链表，而改为使用哈希表进行查找，并使用堆进行LRU替换【跟我们在lock中实现的一样，再多个堆优化】。现代buffer cache通常与虚拟内存系统集成，以支持内存映射文件。

      +

      Xv6的日志系统效率低下。提交不能与文件系统调用同时发生。系统记录整个块，即使一个块中只有几个字节被更改。它执行同步日志写入，每次写入一个块，每个块可能需要整个磁盘旋转时间。真正的日志系统解决了所有这些问题。

      +

      文件系统布局中最低效的部分是目录，它要求在每次查找期间对所有磁盘块进行线性扫描【确实】。当目录只有几个磁盘块时，这是合理的，但对于包含许多文件的目录来说，开销巨大。Microsoft Windows的NTFS、Mac OS X的HFS和Solaris的ZFS（仅举几例）将目录实现为磁盘上块的平衡树。这很复杂，但可以保证目录查找在对数时间内完成（即时间复杂度为O(logn)）。

      +

      Xv6对于磁盘故障的解决很初级：如果磁盘操作失败，Xv6就会调用panic。这是否合理取决于硬件：如果操作系统位于使用冗余屏蔽磁盘故障的特殊硬件之上，那么操作系统可能很少看到故障，因此panic是可以的。另一方面，使用普通磁盘的操作系统应该预料到会出现故障，并能更优雅地处理它们，这样一个文件中的块丢失不会影响文件系统其余部分的使用。

      +

      Xv6要求文件系统安装在单个磁盘设备上，且大小不变。随着大型数据库和多媒体文件对存储的要求越来越高，操作系统正在开发各种方法来消除“每个文件系统一个磁盘”的瓶颈。基本方法是将多个物理磁盘组合成一个逻辑磁盘。RAID等硬件解决方案仍然是最流行的，但当前的趋势是在软件中尽可能多地实现这种逻辑。这些软件实现通常允许通过动态添加或删除磁盘来扩展或缩小逻辑设备等丰富功能。当然，一个能够动态增长或收缩的存储层需要一个能够做到这一点的文件系统：xv6使用的固定大小的inode块阵列在这样的环境中无法正常工作。将磁盘管理与文件系统分离可能是最干净的设计，但两者之间复杂的接口导致了一些系统（如Sun的ZFS）将它们结合起来。

      +

      Xv6的文件系统缺少现代文件系统的许多其他功能；例如，它缺乏对快照和增量备份的支持。

      +

      现代Unix系统允许使用与磁盘存储相同的系统调用访问多种资源：命名管道、网络连接、远程访问的网络文件系统以及监视和控制接口，如/proc。不同于xv6中fileread和filewrite的if语句，这些系统通常为每个打开的文件提供一个函数指针表【确实有印象】，每个操作一个，并通过函数指针来援引inode的调用实现。网络文件系统和用户级文件系统提供了将这些调用转换为网络RPC并在返回之前等待响应的函数。

      +

      （注：Linux 内核提供了一种通过/proc文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。）

      -
      -

      如果系统崩溃并重新启动，则在运行任何进程之前，文件系统代码将按如下方式从崩溃中恢复：

      -

      如果日志标记为包含完整操作，则恢复代码会将写操作复制到磁盘文件系统中它们所属的位置，然后擦除日志。如果日志没有标记为包含完整操作，则恢复代码将忽略该日志，然后擦除日志。

      +

      Lab: file system

      +

      In this lab you will add large files【大文件支持】 and symbolic links【软链接】 to the xv6 file system.

      +

      不过做完这个实验，给我的一种感觉就是磁盘管理和内存管理真的有很多相似之处，不过也许它们所代表的思想也很普遍。

      -

      这就保证了原子性。

      -

      Log design

      image-20230121162324747

      -

      superblock记录了log的存储位置。

      -
      -

      它由一个头块（header block）和一系列更新块的副本（logged block）组成。

      -

      头块包含一个扇区号（sector）数组（每个logged block对应一个扇区号）以及日志块的计数。

      -

      磁盘上的头块中的计数为零表示日志中没有事务，为非零表示日志包含一个完整的已提交事务，并具有指定数量的logged block。

      -

      在事务提交（commit）时Xv6才向头块写入数据，在此之前不会写入。在将logged blocks复制到文件系统后，头块的计数将被设置为零。

      -

      因此，事务中途崩溃将导致日志头块中的计数为零；提交后的崩溃将导致非零计数。

      +

      Large files

      实验内容

      Overview
      +

      In this assignment you’ll increase the maximum size of an xv6 file.

      +

      Currently xv6 files are limited to 268 blocks, or 268*BSIZE bytes (BSIZE is 1024 in xv6). This limit comes from the fact that an xv6 inode contains 12 “direct” block numbers and one “singly-indirect” block number, which refers to a block that holds up to 256 more block numbers, for a total of 12+256=268 blocks.

      +

      You’ll change the xv6 file system code to support a “doubly-indirect” block in each inode, containing 256 addresses of singly-indirect blocks, each of which can contain up to 256 addresses of data blocks. The result will be that a file will be able to consist of up to 65803 blocks, or 256*256+256+11 blocks (11 instead of 12, because we will sacrifice one of the direct block numbers for the double-indirect block).

      -
      -

      为了允许不同进程并发执行文件系统操作，日志系统可以将多个系统调用的写入累积到一个事务中。因此，单个提交可能涉及多个完整系统调用的写入。为了避免在事务之间拆分系统调用，日志系统仅在没有文件系统调用进行时提交。

      -

      同时提交多个事务的想法称为组提交（group commit）。组提交减少了磁盘操作的数量，因为成本固定的一次提交分摊了多个操作。组提交还同时为磁盘系统提供更多并发写操作，可能允许磁盘在一个磁盘旋转时间内写入所有这些操作。Xv6的virtio驱动程序不支持这种批处理，但是Xv6的文件系统设计允许这样做。

      -

      【这感觉实现得也还挺简略的】

      +
      Preliminaries
      +

      If at any point during the lab you find yourself having to rebuild the file system from scratch, you can run make clean which forces make to rebuild fs.img.

      +
      +
      What to Look At

      意思就是要我们去看一眼fs.h，bmap，以及了解一下逻辑地址bn如何转化为blockno。这个我是知道的。

      +
      Your Job
      +

      Modify bmap() so that it implements a doubly-indirect block, in addition to direct blocks and a singly-indirect block.

      +

      You’ll have to have only 11 direct blocks, rather than 12, to make room for your new doubly-indirect block; you’re not allowed to change the size of an on-disk inode.

      +

      The first 11 elements of ip->addrs[] should be direct blocks; the 12th should be a singly-indirect block (just like the current one); the 13th should be your new doubly-indirect block. You are done with this exercise when bigfile writes 65803 blocks and usertests runs successfully.

      +
      +

      感想

      意外地很简单（）在此不多做赘述，直接上代码。

      +

      唯一要注意的一点就是记得在itrunc中free掉

      +

      image-20230124232433793

      +

      代码

      修改定义
      // in fs.h
      #define NDIRECT 11
      #define NINDIRECT (BSIZE / sizeof(uint))
      #define NDOUBLEINDIRECT ((BSIZE/sizeof(uint))*(BSIZE/sizeof(uint)))
      #define MAXFILE (NDIRECT + NINDIRECT + NDOUBLEINDIRECT)

      // On-disk inode structure
      struct dinode {
        // ...
        uint addrs[NDIRECT+2];   // Data block addresses
      };
      + +
      // in file.h
      // in-memory copy of an inode
      struct inode {
        // ...
        uint addrs[NDIRECT+2];
      };
      + +
      修改bmap()
      // in fs.c
      // 调试用
      static int cnt = 0;

      static uint
      bmap(struct inode *ip, uint bn)
      {
        uint addr, *a;
        struct buf *bp;

        if(bn < NDIRECT){
          if((addr = ip->addrs[bn]) == 0)
            ip->addrs[bn] = addr = balloc(ip->dev);
          return addr;
        }
        bn -= NDIRECT;

        if(bn < NINDIRECT){
          // Load indirect block, allocating if necessary.
          if((addr = ip->addrs[NDIRECT]) == 0)
            ip->addrs[NDIRECT] = addr = balloc(ip->dev);
          bp = bread(ip->dev, addr);
          a = (uint*)bp->data;
          if((addr = a[bn]) == 0){
            a[bn] = addr = balloc(ip->dev);
            log_write(bp);
          }
          brelse(bp);
          return addr;
        }
          
        // CODE HERE
        bn -= NINDIRECT;
        if(bn < NDOUBLEINDIRECT){
          // 调试用
          if(bn/10000 > cnt){
            cnt++;
            printf("double_indirect:%d\n",bn);
          }
          // 第一层
          if((addr = ip->addrs[NDIRECT+1]) == 0)
            ip->addrs[NDIRECT+1] = addr = balloc(ip->dev);
          // 第二层
          bp = bread(ip->dev,addr);
          a = (uint*)bp->data;
          if((addr = a[(bn >> 8)]) == 0){
            a[(bn >> 8)] = addr = balloc(ip->dev);
            log_write(bp);
          }
          brelse(bp);
          // 第三层
          bp = bread(ip->dev,addr);
          a = (uint*)bp->data;
          if((addr = a[(bn & 0x00FF)]) == 0){
            a[(bn & 0x00FF)] = addr = balloc(ip->dev);
            log_write(bp);
          }
          brelse(bp);
          return addr;
        }

        panic("bmap: out of range");
      }
      + +
      修改itrunc
      // Truncate inode (discard contents).
      // Caller must hold ip->lock.
      void
      itrunc(struct inode *ip)
      {
        int i, j;
        struct buf *bp;
        uint *a;

        for(i = 0; i < NDIRECT; i++){
          if(ip->addrs[i]){
            bfree(ip->dev, ip->addrs[i]);
            ip->addrs[i] = 0;
          }
        }

        if(ip->addrs[NDIRECT]){
          bp = bread(ip->dev, ip->addrs[NDIRECT]);
          a = (uint*)bp->data;
          for(j = 0; j < NINDIRECT; j++){
            if(a[j])
              bfree(ip->dev, a[j]);
          }
          brelse(bp);
          bfree(ip->dev, ip->addrs[NDIRECT]);
          ip->addrs[NDIRECT] = 0;
        }

        // CODE HERE
        if(ip->addrs[NDIRECT+1]){
          bp = bread(ip->dev, ip->addrs[NDIRECT+1]);
          a = (uint*)bp->data;
          // 双层循环。这里其实不应该用NINDIRECT这个宏定义的，因为意义其实不大一样。
          // 但是由于数值一样，这里就先凑合着用了
          for(j = 0; j < NINDIRECT; j++){
            if(a[j]){
              struct buf* tmp_bp = bread(ip->dev,a[j]);
              uint* tmp_a = (uint*)tmp_bp->data;
              for(int k = 0;k < NINDIRECT; k++){
                if(tmp_a[k])
                  bfree(ip->dev,tmp_a[k]);
              }
              brelse(tmp_bp);
              bfree(ip->dev,a[j]);
            }
          }
          brelse(bp);
          bfree(ip->dev, ip->addrs[NDIRECT+1]);
          ip->addrs[NDIRECT+1] = 0;
        }

        ip->size = 0;
        iupdate(ip);
      }
      + +
      +

      In this exercise you will add symbolic links to xv6.

      +

      Symbolic links (or soft links) refer to a linked file by pathname; when a symbolic link is opened, the kernel follows the link to the referred file.

      +

      Symbolic links resembles hard links, but hard links are restricted to pointing to file on the same disk, while symbolic links can cross disk devices.

      +

      Although xv6 doesn’t support multiple devices, implementing this system call is a good exercise to understand how pathname lookup works.

      +

      You will implement the symlink(char *target, char *path) system call, which creates a new symbolic link at path that refers to file named by target. For further information, see the man page symlink. To test, add symlinktest to the Makefile and run it.

      -

      Xv6在磁盘上留出固定的空间来保存日志。事务中系统调用写入的块总数必须可容纳于该空间。这导致两个后果：

      +

      linux：硬链接和软链接

      +

      硬链接不会创建新的物理文件，但是会使得当前物理文件的引用数加1。当硬链接产生的文件存在时，删除源文件，不会清除实际的物理文件，即对于硬链接“生成的新文件”不会产生任何影响。

      +

      软链接就更像一个指针，只是指向实际物理文件位置，当源文件移动或者删除时，软链接就会失效。

      +

      【所以说，意思就是软链接不会让inode->ulinks++的意思？】

      +
      +

      感想

      这个实验比上个实验稍难一些，但也确实只是moderate的水平，其复杂程度主要来源于对文件系统的理解，还有如何判断环，以及对锁的获取和释放的应用。我做这个实验居然是没看提示的【非常骄傲<-】，让我有一种自己水平上升了的感觉hhh

      +
      正确思路

      本实验要求实现软链接。首先需要实现创建软链接：写一个系统调用 symlink(char *target, char *path) 用于创建一个指向target的在path的软链接；然后需要实现打开软链接进行自动的跳转：在sys_open中添加对文件类型为软链接的特殊处理。

      +
      初见思路

      我的初见思路是觉得可以完全参照sys_link来写。但其实还是很不一样的。

      +

      sys_link的逻辑：

        -

      1. 任何单个系统调用都不允许写入超过日志空间的不同块。

        -

        【这段话我一个字没看懂】

        -

        这对于大多数系统调用来说都不是问题，但其中两个可能会写入许多块：write和unlink。一个大文件的write可以写入多个数据块和多个位图块以及一个inode块；unlink大文件可能会写入许多位图块和inode。Xv6的write系统调用将大的写入分解为适合日志的多个较小的写入，unlink不会导致此问题，因为实际上Xv6文件系统只使用一个位图块。

        +
      2. 获取old的inode
        3. +
      3. 获取new所在目录的inode，称为dp
        4. +
      4. 在dp中添加一项entry指向old
        5. +
      +

      sys_symlink的逻辑：

      +
        +

      1. 通过path创建一个新的inode，作为软链接的文件

        +

        这里选择新建inode，而不是像link那样做，主要还是为了能遵从symlinktest给的接口使用方法（朴实无华的理由）。而且这么做也很方便，符合“一切皆文件”的思想，也能简单化对其在open中的处理。

        2. -

      2. 日志空间有限的另一个后果是，除非确定系统调用的写入将可容纳于日志中剩余的空间，否则日志系统无法允许启动系统调用。

        +

      3. 在inode中填入target的地址

        +

        我们可以把软链接视为文件，文件内容是其target的path。

      -
      -

      Code: logging

      -

      log的原理是这样的：

      -

      在每个系统调用的开始调用begin_op表示事务开始，然后之后新申请一块block，也即把该block的内容读入内存，并且把该block的blockno记录到log的header中。此后程序正常修改在内存中的block，磁盘中的block保持不变。最后commit的时候遍历log header中的blockno，一块块地把内存中的block写入日志和磁盘中。

      -

      如果程序在commit前崩溃，则内存消失，同时磁盘也不会写入；如果在commit后崩溃，那也无事发生。

      -

      在每次启动的时候，都会执行log的初始化，届时可以顺便恢复数据。

      -

      完美实现了日志的功能。

      -
      -

      image-20230123212753931

      -

      数据结构

      // Contents of the header block, used for both the on-disk header block
      // and to keep track in memory of logged block# before commit.
      struct logheader {
        int n;
        // 扇区号也即blockno的数组
        int block[LOGSIZE];
      };

      // 代表log磁盘块
      struct log {
        struct spinlock lock;
        int start;// log磁盘块的开始。start开始的第一块为log header，之后皆为写入的block
        int size;
        int outstanding; // how many FS sys calls are executing.
        int committing;  // in commit(), please wait.
        int dev;
        struct logheader lh;
      };
      struct log log;
      - -

      关键函数

      begin_op()
      -

      begin_op等待直到日志系统当前未处于提交中，并且直到有足够的未被占用的日志空间来保存此调用的写入。

      -

      log.outstanding统计预定了日志空间的系统调用数；为此保留的总空间为log.outstanding乘以MAXOPBLOCKS（10）。递增log.outstanding会预定空间并防止在此系统调用期间发生提交（if的第二个分支）。代码保守地假设每个系统调用最多可以写入MAXOPBLOCKS（10）个不同的块。

      -
      -
      // called at the start of each FS system call.
      void
      begin_op(void)
      {
        acquire(&log.lock);
        while(1){
          // 正在提交则等待日志空闲
          if(log.committing){
            sleep(&log, &log.lock);
          // 日志空间不足则等待空间充足
          } else if(log.lh.n + (log.outstanding+1)*MAXOPBLOCKS > LOGSIZE){
            // this op might exhaust log space此操作可能会耗尽日志空间; wait for commit.
            sleep(&log, &log.lock);
          } else {
            log.outstanding += 1;
            release(&log.lock);
            break;
          }
        }
      }
      - -
      log_write
      -

      log_write充当bwrite的代理。它将块的扇区号记录在内存中，在磁盘上的日志中预定一个槽位，并调用bpin将缓存固定在block cache中，以防止block cache将其逐出【具体原理就是让refcnt++，这样就不会被当成空闲block用掉了】。

      -

      为啥要防止换出呢？换出不是就正好自动写入磁盘了吗？这里一是为了保障前面提到的原子性，防止换入换出导致的单一写入磁盘；二是换出自动写入的是磁盘对应位而不一定是日志所在的blocks。

      -
      -
      void
      log_write(struct buf *b)
      {
        int i;
        // #define LOGSIZE      (MAXOPBLOCKS*3)  // max data blocks in on-disk log
        // 30
        if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
          panic("too big a transaction");
        if (log.outstanding < 1)
          panic("log_write outside of trans");

        acquire(&log.lock);
        // log_write会注意到在单个事务中多次写入一个块的情况，并在日志中为该块分配相同的槽位。
        // 这种优化通常称为合并（absorption）
        for (i = 0; i < log.lh.n; i++) {
          if (log.lh.block[i] == b->blockno)   // log absorbtion
            break;
        }
        // 这里还是挺巧妙的。
        // 如果存在log.lh.block[i] == b->blockno的情况，执行此句话也无妨
        // 如果不存在，则给log新增一块，填入log.lh.block[log.lh.n]的位置，再++log.lh.n
        log.lh.block[i] = b->blockno;
        if (i == log.lh.n) {  // Add new block to log?
          bpin(b);
          log.lh.n++;
        }
        release(&log.lock);
      }
      - -
      end_op
      // called at the end of each FS system call.
      // 如果这是最后一层outstanding就会执行commit操作
      // commits if this was the last outstanding operation.
      void
      end_op(void)
      {
        int do_commit = 0;

        acquire(&log.lock);
        log.outstanding -= 1;
        if(log.committing)
          panic("log.committing");
        if(log.outstanding == 0){
          do_commit = 1;
          log.committing = 1;
        } else {
          // begin_op() may be waiting for log space,
          // and decrementing log.outstanding has decreased
          // the amount of reserved space.
          wakeup(&log);
        }
        release(&log.lock);

        if(do_commit){
          // call commit w/o holding locks, since not allowed
          // to sleep with locks.
          commit();
          acquire(&log.lock);
          log.committing = 0;
          wakeup(&log);
          release(&log.lock);
        }
      }
      +

      可以说是毫不相干，所以还是直接自起炉灶比较好。

      +
      一些错误

      其实没什么好说的，虽然debug过程挺久，但是靠常规的printf追踪就都可以看出来是哪里错了。下面我说说一个我印象比较深刻的吧。

      +

      symlinktest中有一个检测点是，软链接不能成环，也即b->a->b是非法的。于是，我就选择了用快慢指针来检测环形链表这个思想，用来看是否出现环。

      +

      在symlinktest的另一个检测点中：

      +

      image-20230125173143735

      +

      我出现了如下错误：

      +

      image-20230125162542807

      +

      此时的结构是1[27]->2[28]->3[29]->4，[]内为inode的inum。

      +

      快慢指针的实现方式是当cnt为奇数的时候，慢指针才会移动。而上图中，cnt==0时，两个指针的值都发生了变化，这就非常诡异。

      +

      这其实是因为slow指针所指向的那个inode被释放了，然后又被fast指针的下一个inode捡过来用了，从而导致值覆盖。

      +

      为什么会被释放呢？

      +
            // 快指针移动
            readi(ip,0,(uint64)path,0,MAXPATH);
            iunlock(ip);
            if((ip = namei(path)) == 0){
              end_op();
              return -1;
            }
      // 在这里！！！
            ilockput(ip);
      -
      commit
      static void
      commit()
      {
        if (log.lh.n > 0) {
          // cache -> log block
          write_log();     // Write modified blocks from cache to log
          // head(in stack/heap) -> log block
          // 此可以说为commit完成的标志。
          // 因为无论接下来是否崩溃，数据最终都会被写入disk，不同在于是在recover时还是接下来写入
          write_head();    // Write header to disk -- the real commit
          // log block -> real position
          install_trans(0); // Now install writes to home locations
          log.lh.n = 0;
          // 擦除
          write_head();    // Erase the transaction from the log
        }
      }
      +

      在这里，我错误地调用了ilockput，从而使inode的ref–，使得它在下一次fast指针调用namei，namei调用iget时，该inode被当做free inode使用，于是就这么寄了。

      +

      所以我们需要把ilockput的调用换成ilock，这样一来就能防止inode被free。至于什么时候再iput？我想还是交给操作系统启动时的清理工作来做吧23333【开摆】

      +

      代码

      image-20230125165612112

      +
      添加定义
      fcntl.c

      open参数

      +
      // 意为只用获取软链接文件本身，而不用顺着软链接去找它的target文件
      #define O_NOFOLLOW 0x100
      -
      write_log
      // Copy modified blocks from cache to log.
      static void
      write_log(void)
      {
        int tail;

        for (tail = 0; tail < log.lh.n; tail++) {
          struct buf *to = bread(log.dev, log.start+tail+1); // log block
          struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
          memmove(to->data, from->data, BSIZE);
          bwrite(to);  // write the log
          brelse(from);// 此处的brelse呼应了外界调用的bread
          brelse(to);
        }
      }
      +
      stat.h

      文件类型

      +
      #define T_DIR     1   // Directory
      #define T_FILE    2   // File
      #define T_DEVICE  3   // Device
      #define T_SYMLINK  4   // symbol links
      -
      write_head
      // Write in-memory log header to disk.
      // 这是事务提交的标志
      // This is the true point at which the
      // current transaction commits.
      static void
      write_head(void)
      {
        struct buf *buf = bread(log.dev, log.start);
        struct logheader *hb = (struct logheader *) (buf->data);
        int i;
        hb->n = log.lh.n;
        for (i = 0; i < log.lh.n; i++) {
          hb->block[i] = log.lh.block[i];
        }
        bwrite(buf);
        brelse(buf);
      }
      +
      添加sys_symlink系统调用
      // in sysfile.c
      uint64
      sys_symlink(void)
      {
        char target[MAXPATH], path[MAXPATH];
        struct inode *ip;

        if(argstr(0, target, MAXPATH) < 0 || argstr(1, path, MAXPATH) < 0)
          return -1;

        begin_op();

        // 创建软链接结点
        ip = create(path,T_SYMLINK,0,0);
        //printf("symlink:before writei,inum = %d\n",ip->inum);
        // 此处可以防止住一些并发错误
        if(ip ==0){
          end_op();
          return 0;
        }
        // 向软链接结点文件内写入其所指向的路径
        writei(ip,0,(uint64)target,0,MAXPATH);
        //printf("symlink:after writei\n");
          
        // 软链接不需要让nlink++
          
        // 记得要释放在create()中申请的锁
        iunlockput(ip);

        end_op();

        return 0;
      }
      -
      install_trans
      // Copy committed blocks from log to their home location
      static void
      install_trans(int recovering)
      {
        int tail;

        for (tail = 0; tail < log.lh.n; tail++) {
          struct buf *lbuf = bread(log.dev, log.start+tail+1); // read log block
          struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
          memmove(dbuf->data, lbuf->data, BSIZE);  // copy block to dst
          bwrite(dbuf);  // write dst to disk
          if(recovering == 0)
            bunpin(dbuf);// 如果不是在recover的过程中
          brelse(lbuf);
          brelse(dbuf);
        }
      }
      +
      修改open
      uint64
      sys_open(void)
      {
        // ...

        begin_op();

        if(omode & O_CREATE){
          ip = create(path, T_FILE, 0, 0);
          if(ip == 0){
            end_op();
            return -1;
          }
        } else {
          // 软链接不可能是以O_CREATE的形式创建的
          if((ip = namei(path)) == 0){
            end_op();
            return -1;
          }
          ilock(ip);
          if(ip->type == T_DIR && omode != O_RDONLY){
            iunlockput(ip);
            end_op();
            return -1;
          }

          // 修改从这里开始
          // 快慢指针
          // ip为快指针，slow为慢指针
          uint cnt = 0;
          struct inode* slow = ip;
          // 可能有多重链接，因而需要持续跳转
          while(ip->type == T_SYMLINK){
            //printf("slow = %d,fast = %d,cnt = %d\n",slow->inum,ip->inum,cnt);
            // 其实这个只需要检测一次就够了。但为了编码方便，仍然把它保留在while循环中
            if(omode & O_NOFOLLOW){
              break;
            }else{
              // 检测到cycle
              if(slow == ip && cnt!=0){
                iunlockput(ip);
                end_op();
                return -1;
              }
              // 快指针移动
              readi(ip,0,(uint64)path,0,MAXPATH);
              // 此处不能用iunlockput()，具体原因见 感想-一些错误
              iunlock(ip);
              if((ip = namei(path)) == 0){
                end_op();
                return -1;
              }
              ilock(ip);
              // 慢指针移动
              // 注意，我慢指针移动的时候没有锁保护，因为用锁太麻烦了（）其实还是用锁比较合适
              if(cnt & 1){
                //printf("%d\n",cnt);
                readi(slow,0,(uint64)path,0,MAXPATH);
                if((slow = namei(path) )== 0){
                  end_op();
                  return -1;
                }
              }
              cnt++;
            }
          }
          // 当跳出循环时，此时的ip必定是锁住的
        }

        if(ip->type == T_DEVICE && (ip->major < 0 || ip->major >= NDEV)){
          iunlockput(ip);
          end_op();
          return -1;
        }
        // ...
      }
      -

      恢复与初始化

      上面介绍了log的一次事务提交的流程。接下来介绍它是怎么恢复的。

      -
      -

      recover_from_log是由initlog调用的，而它又是在第一个用户进程运行之前的引导期间由fsinit调用的。

      +

      Lab mmap

      +

      The mmap and munmap system calls allow UNIX programs to exert detailed control over their address spaces.

      +

      They can be used to:

      +
        +
      1. share memory among processes
        2. +
      2. map files into process address spaces
        3. +
      3. as part of user-level page fault schemes such as the garbage-collection algorithms discussed in lecture.
        4. +
      +

      In this lab you’ll add mmap and munmap to xv6, focusing on memory-mapped files.

      +

      mmap是系统调用，在用户态被使用。我们这次实验仅实现mmap功能的子集，也即memory-mapped files。

      -
      第一个进程运行之前

      由前面scheduler一章的知识可知，每个进程被初次调度的时候会先来执行forkret。这时候就做了log的恢复工作。

      -

      注释解释了为什么不选择在main.c中初始化，而选择在此处初始化。确实，它需要调用sleep，如果在main.c中调用sleep感觉会乱套（）毕竟那时候scheduler线程尚未被初始化。

      -
      // A fork child's very first scheduling by scheduler()
      // will swtch to forkret.
      void
      forkret(void)
      {
        // static变量仅会被初始化一次
        static int first = 1;

        // Still holding p->lock from scheduler.
        release(&myproc()->lock);

        // 如果是第一个进程
        if (first) {
          // File system initialization must be run in the context of a
          // regular process (e.g., because it calls sleep), and thus cannot
          // be run from main().
          first = 0;
          fsinit(ROOTDEV);
        }

        usertrapret();
      }
      - -
      fsinit
      // Init fs
      void
      fsinit(int dev) {
        // ...
        initlog(dev, &sb);
      }
      - -
      initlog
      void
      initlog(int dev, struct superblock *sb)
      {
        if (sizeof(struct logheader) >= BSIZE)
          panic("initlog: too big logheader");

        initlock(&log.lock, "log");
        // 从super block中获取必要参数
        log.start = sb->logstart;
        log.size = sb->nlog;
        log.dev = dev;
        recover_from_log();
      }
      - -
      recover_from_log
      static void
      recover_from_log(void)
      {
        // 读取head
        read_head();
        // 注意，commit中会把header写入log block，而这里从log block读出header
        // 也就是说，如果header的n不为零，那么说明已经commit了，但可能未写入，重复写入保障安全
        // 如果header的n为零，说明未commit，在install_trans的逻辑中会什么也不做
        // 两种情况完美满足
        install_trans(1); // if committed, copy from log to disk
        log.lh.n = 0;
        // 擦除
        write_head(); // clear the log
      }
      +
      +

      declaration for mmap:

      +
      void *mmap(void *addr, size_t length, int prot, int flags,
           int fd, off_t offset);
      -

      Code: Block allocator

      个人理解

      说实话没怎么懂，也不大清楚它有什么用，先大概推测一下：

      -

      之前的bread和bwrite这些，就是你给一个设备号和扇区号，它就帮你加载进内存cache。你如果要用的话，肯定还是使用地址方便。所以block allocator的作用之一就是给bread和bwrite加一层封装，将获取的block封装为地址返回，你可以直接操纵这个地址，而无需知道下层的细节。

      -

      这个过程要注意的有两点：

        -

      1. 封装返回的地址具体是什么，怎么工作的

        -

        封装返回的地址实质上是buffer cache中的buf的data字段的地址【差不多】。之后的上层应用在该地址上写入，也即写入了buf，最后会通过log层真正写入磁盘。

        +

      2. 参数

        +
          +

        1. addr is always zero.

          +

          You can assume that addr will always be zero, meaning that the kernel should decide the virtual address at which to map the file.【addr由kernel决定，因而用户态只需传入0即可】

          2. -

        2. 结合bcache的LRU，详细谈谈工作机制

          -

          我们可以看到，在balloc中有这么一段逻辑：

          -
          bp = bread(dev, BBLOCK(b, sb));
          // ...
              log_write(bp);
              brelse(bp);
              return b + bi;
          - -

          看到的第一反应就是，我们需求的那块buf是bp，但是这里先是bread了一次，又是brelse了一次，这样bp的refcnt不就为0，很容易被替换掉了吗？

          -

          会有这个反应，一定程度上是因为没有很好地理解LRU。事实上，正是它可能被替换掉，才满足了LRU的条件。因为它可能被替掉才能说明它可能是最近最少使用的。

          +

        3. length is the number of bytes to map

          +

          Might not be the same as the file’s length.

          +
          4. +

        4. prot indicates whether the memory should be mapped readable, writeable, and/or executable.

          +

          you can assume that prot is PROT_READ or PROT_WRITE or both.

          +
          5. +

        5. flags has two values.

          +
            +

          1. MAP_SHARED

            +

            meaning that modifications to the mapped memory should be written back to the file,

            +

            如果标记为此，则当且仅当file本身权限为RW或者WRITABLE的时候，prot才可以标记为PROT_WRITE

            +
            2. +

          2. MAP_PRIVATE

            +

            meaning that they should not.

            +

            如果标记为此，则无论file本身权限如何，prot都可以标记为PROT_WRITE

          -

          bitmap

          -

          文件和目录内容存储在磁盘块中，磁盘块必须从空闲池中分配。xv6的块分配器在磁盘上维护一个空闲位图，每一位代表一个块。0表示对应的块是空闲的；1表示它正在使用中。

          -

          引导扇区、超级块、日志块、inode块和位图块的比特位是由程序mkfs初始化设置的：

          -

          image-20230123234919055

          -
          -

          allocator

          类似于memory allocator，块分配器也提供了两个函数：bfree和balloc。

          -

          balloc

          -

          Balloc从块0到sb.size（文件系统中的块数）遍历每个块。它查找位图中位为零的空闲块。如果balloc找到这样一个块，它将更新位图并返回该块。

          -

          为了提高效率，循环被分成两部分。外部循环读取位图中的每个块。内部循环检查单个位图块中的所有BPB位。由于任何一个位图块在buffer cache中一次只允许一个进程使用【 bread(dev, BBLOCK(b, sb))会返回一个上锁的block，bread和brelse隐含的独占使用避免了显式锁定的需要】，因此，如果两个进程同时尝试分配一个块也是并发安全的。

          -
          -
          // Allocate a zeroed disk block.
          static uint
          balloc(uint dev)
          {
            int b, bi, m;
            struct buf *bp;

            bp = 0;
            for(b = 0; b < sb.size; b += BPB){
              bp = bread(dev, BBLOCK(b, sb));
              for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
                m = 1 << (bi % 8);
                if((bp->data[bi/8] & m) == 0){  // Is block free?
                  bp->data[bi/8] |= m;  // Mark block in use.
                  log_write(bp);
                  brelse(bp);
                  bzero(dev, b + bi);
                  return b + bi;
                }
              }
              brelse(bp);
            }
            panic("balloc: out of blocks");
          }
          - -

          bfree

          // Free a disk block.
          static void
          bfree(int dev, uint b)
          {
            struct buf *bp;
            int bi, m;

            bp = bread(dev, BBLOCK(b, sb));
            bi = b % BPB;
            m = 1 << (bi % 8);
            if((bp->data[bi/8] & m) == 0)
              panic("freeing free block");
            bp->data[bi/8] &= ~m;
            log_write(bp);
            brelse(bp);
          }
          - -

          Inode layer

          inode

          -

          术语inode（即索引结点）可以具有两种相关含义之一。它可能是指包含文件大小和数据块编号列表的磁盘上的数据结构【on-disk inode】。或者“inode”可能指内存中的inode【in-memory inode】，它包含磁盘上inode的副本以及内核中所需的额外信息。

          -
          -

          image-20230121162324747

          -

          on-disk inode

          -

          The on-disk inodes are packed into a contiguous area of disk called the inode blocks.

          -

          Every inode is the same size, so it is easy, given a number n, to find the nth inode on the disk. In fact, this number n, called the inode number or i-number, is how inodes are identifified in the implementation.

          -
          -
          // in fs.h
          // On-disk inode structure
          struct dinode {
            // 为0表示free
            short type;           // File type
            short major;          // Major device number (T_DEVICE only)
            short minor;          // Minor device number (T_DEVICE only)
            //  The nlink field counts the number of directory entries that refer to this inode,
            //  in order to recognize when the on-disk inode and its data blocks should be freed.
            short nlink;          // Number of links to inode in file system
            uint size;            // Size of file (bytes)
            uint addrs[NDIRECT+1];   // Data block addresses
          };
          - -

          in-memory inode

          -

          The kernel keeps the set of active inodes in memory.

          -

          The kernel stores an inode in memory only if there are C pointers referring to that inode.当且仅当ref==0才会从内核中释放。

          -

          如果nlinks==0就会从物理block中释放。

          -

          The iget and iput functions acquire and release pointers to an inode, modifying the reference count.【相当于buffer cache的balloc和bfree】Pointers to an inode can come from file descriptors, current working directories, and transient kernel code such as exec.

          -

          iget返回的struct inode可能没有任何有用的内容。为了确保它保存磁盘inode的副本，代码必须调用ilock。这将锁定inode（以便没有其他进程可以对其进行ilock），并从磁盘读取尚未读取的inode。iunlock释放inode上的锁。将inode指针的获取与锁定分离有助于在某些情况下避免死锁，例如在目录查找期间。多个进程可以持有指向iget返回的inode的C指针，但一次只能有一个进程锁定inode。

          -
          -
          //in file.h
          // in-memory copy of an inode
          struct inode {
            uint dev;           // Device number
            uint inum;          // Inode number
            int ref;            // Reference count
            struct sleeplock lock; // protects everything below here
            int valid;          // inode has been read from disk?

            short type;         // copy of disk inode
            short major;
            short minor;
            short nlink;
            uint size;
            uint addrs[NDIRECT+1];// 存储着inode数据的blocks的地址，从balloc中获取
          };
          - -

          Code: inode

          -

          主要是在讲inode layer这一层的方法，以及给上层提供的接口。

          -
          -

          Overview

          image-20230124153309132

          -

          底层接口

          -

          iget iput

          +
          6. +

        6. You can assume offset is zero (it’s the starting point in the file at which to map)

          +
          7. +
        +
        3. +

      3. return

        +

        mmap returns that kernel-decided address, or 0xffffffffffffffff if it fails.

        +
        4. +
      +

      如果两个进程同时对某个文件进行memory map，那么这两个进程可以不共享物理页面。

      -
      iget

      逻辑还是跟buffer cache非常相似的，不过可以看出这个的数据结构简单许多，也不用实现LRU。

      -

      A struct inode pointer returned by iget() is guaranteed to be valid until the corresponding call to iput()： the inode won’t be deleted, and the memory referred to by the pointer won’t be re-used for a different inode. 【通过ref++实现。】

      -

      不同于buffer cache的bget，iget()提供对inode的非独占访问，因此可以有许多指向同一inode的指针。文件系统代码的许多部分都依赖于iget()的这种行为，既可以保存对inode的长期引用（如打开的文件和当前目录），也可以防止争用，同时避免操纵多个inode（如路径名查找）的代码产生死锁。

      -
      -
      // Find the inode with number inum on device dev
      // and return the in-memory copy. Does not lock
      // the inode and does not read it from disk.
      static struct inode*
      iget(uint dev, uint inum)
      {
        struct inode *ip, *empty;

        acquire(&icache.lock);

        // Is the inode already cached?
        empty = 0;
        for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
          if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
            ip->ref++;
            release(&icache.lock);
            return ip;
          }
          // 由于不用实现LRU，所以只需一次循环记录即可。
          if(empty == 0 && ip->ref == 0)    // Remember empty slot.
            empty = ip;
        }

        // Recycle an inode cache entry.
        if(empty == 0)
          panic("iget: no inodes");

        ip = empty;
        ip->dev = dev;
        ip->inum = inum;
        ip->ref = 1;
        // does not read from disk
        ip->valid = 0;
        release(&icache.lock);

        return ip;
      }
      - -
      iput
      -

      iput()可以写入磁盘。这意味着任何使用文件系统的系统调用都可能写入磁盘，因为系统调用可能是最后一个引用该文件的系统调用。即使像read()这样看起来是只读的调用，也可能最终调用iput()。这反过来意味着，即使是只读系统调用，如果它们使用文件系统，也必须在事务中进行包装。

      -

      iput()和崩溃之间存在一种具有挑战性的交互。iput()不会在文件的链接计数降至零时立即截断文件，因为某些进程可能仍在内存中保留对inode的引用：进程可能仍在读取和写入该文件，因为它已成功打开该文件。但是，如果在最后一个进程关闭该文件的文件描述符之前发生崩溃，则该文件将被标记为已在磁盘上分配，但没有目录项指向它。如果不做任何处理措施的话，这块磁盘就再也用不了了。

      -

      文件系统以两种方式之一处理这种情况。简单的解决方案用于恢复时：重新启动后，文件系统会扫描整个文件系统，以查找标记为已分配但没有指向它们的目录项的文件。如果存在任何此类文件，接下来可以将其释放。

      -

      第二种解决方案不需要扫描文件系统。在此解决方案中，文件系统在磁盘（例如在超级块中）上记录链接计数降至零但引用计数不为零的文件的i-number。如果文件系统在其引用计数达到0时删除该文件，则会通过从列表中删除该inode来更新磁盘列表。重新启动时，文件系统将释放列表中的所有文件。

      -

      Xv6没有实现这两种解决方案，这意味着inode可能被标记为已在磁盘上分配，即使它们不再使用。这意味着随着时间的推移，xv6可能会面临磁盘空间不足的风险。

      +

      munmap(addr, length) should remove mmap mappings in the indicated address range.

      +

      If the process has modified the memory and has it mapped MAP_SHARED, the modifications should first be written to the file. 【如果两个进程的修改发生冲突了怎么办？】

      +

      An munmap call might cover only a portion of an mmap-ed region, but you can assume that it will either unmap at the start, or at the end, or the whole region (but not punch a hole in the middle of a region).

      -
      // Drop a reference to an in-memory inode.
      // If that was the last reference, the inode cache entry can
      // be recycled.【refvnt==0 可以回收】
      // 注意这个回收过程无需特别处理，只需自然--refcnt就行，不用像buffer cache那么烦
      // If that was the last reference and the inode has no links
      // to it, free the inode (and its content) on disk.【nlinks==0 copy和本体都得扔掉】
      // All calls to iput() must be inside a transaction in
      // case it has to free the inode.任何需要iput的地方都需要包裹在事务内，因为它可能会释放inode
      void
      iput(struct inode *ip)
      {
        acquire(&icache.lock);

        if(ip->ref == 1 && ip->valid && ip->nlink == 0){
          // inode has no links and no other references: truncate and free.

          // ip->ref == 1 means no other process can have ip locked,
          // so this acquiresleep() won't block (or deadlock).
          acquiresleep(&ip->lock);

          release(&icache.lock);

          // 最终调用bfree，会标记bitmap，完全释放block
          itrunc(ip);
          ip->type = 0;
            
          /*iupdate:
          // Copy a modified in-memory inode to disk.
          // Must be called after every change to an ip->xxx field
      	// that lives on disk, since i-node cache is write-through.
      	write-through:
      	CPU向cache写入数据时，同时向memory(后端存储)也写一份，使cache和memory的数据保持一致。
          */
          // 这里修改的type是dinode也有的字段，所以需要update一下。
          // 下面的valid是dinode没有的字段，所以随便改，无需update
          iupdate(ip);
          ip->valid = 0;

          releasesleep(&ip->lock);

          acquire(&icache.lock);
        }

        ip->ref--;
        release(&icache.lock);
      }
      - -

      上层接口

      获取和释放inode
      ialloc
      // Allocate an inode on device dev.
      // Mark it as allocated by  giving it type type.
      // Returns an unlocked but allocated and referenced inode.
      struct inode*
      ialloc(uint dev, short type)
      {
        int inum;
        struct buf *bp;
        struct dinode *dip;

        for(inum = 1; inum < sb.ninodes; inum++){
          bp = bread(dev, IBLOCK(inum, sb));
          dip = (struct dinode*)bp->data + inum%IPB;
          if(dip->type == 0){  // a free inode通过type判断是否free
            memset(dip, 0, sizeof(*dip));// zerod
            dip->type = type;
            log_write(bp);   // mark it allocated on the disk
            brelse(bp);
            return iget(dev, inum);
          }
          brelse(bp);
        }
        panic("ialloc: no inodes");
      }
      - -
      inode的锁保护

      前面说到，inode的设计使得有多个指针同时指向一个inode成为了可能。因而，修改使用inode的时候就要对其进行独占访问。使用ialloc获取和用ifree释放的inode必须被保护在ilock和iunlock区域中。

      -
      ilock

      ilock既可以实现对inode的独占访问，同时也可以给未初始化的inode进行初始化工作。

      +

      感想

      这个实验做得我……怎么说，感觉非常地难受吧。虽然我认为我这次做得挺不错的，因为我没有怎么看hints，我的代码差不多全都是我自己想出来的，没有依赖保姆级教学，我认为是一个很好的进步。不过，正因为我没有看hints，导致我的想法比起答案来思路非常地奇诡，导致我第一次错误想法写了一天，看了hints后决心痛改前非，结果第二次错误想法又写了一天emmm

      +

      下面的第一个代码版本虽然可以过掉mmaptest，但确实还是有一个很致命的bug，并且lazy也没有lazy到位，最后的版本离正确思路还有偏差，也就是下面放的第一个代码版本是错误的，但我认为它也不是完全没有亮点。第二个版本才是经过改正的正确版本，但写得着实有点潦草。

      +

      笔记整理得也有点匆忙，毕竟我真的话比较多而且心里很烦。总之，先记录我的全部思路过程，至于价值如何，先不管了2333

      +

      初见思路

      所以说，我们要做的，就是实现一个系统调用mmap，在mmap中，应该首先申请几页用来放file的内容，并且在页表中填入该项，然后再返回该项的虚拟地址。然后在munmap中，再将该file页内容写入file。

      +

      也就是说，直接在mmap把文件的全部内容写入内存，然后各进程读写自己的那块内容块，最后在munmap的时候把修改内容写入文件然后释放该内存块就行了

      +
      问题：在哪里放置file的内容

      题目要求the kernel should decide the **virtual address** at which to map the file.也就是说，在我们的mmap中，需要决定我们要讲文件内容放在哪里。那要放在哪呢……

      +

      我第一反应很奇葩：扫描页表，找到空闲页。但我自己也知道这样不可行，文件内容不止一页，这种零零散散存储需要的数据结构实现起来太麻烦了。

      +

      那怎么办？可以在heap内分配。那么到底怎么样才能在heap里分配？你该怎么知道heap哪里开始是空闲的，哪里是用过的，不还是得扫描页表吗？【思维大僵化】

      +

      其实……道理很简单。我们之间把proc->sz作为mapped-file的起始地址就好了。相信看到这里，你也明白这是什么原理了。能想到这个，我感觉确实很不容易。

      +

      正确思路

      初见思路虽然简单，但是很粗暴，如果文件很大，宝贵的内存空间就会被我们浪费。所以我们借用lazy allocation的思想，先建立memory-file的映射，再在缺页中断中通过文件读写申请内存空间，把文件内容读入内存。

      +

      问题就在于如何“先建立memory-file的映射”。在lazy allocation中，我们是先填好所有的对应页表项，仅是不申请对应的物理内存，也即占着XX不XX。在这次实验中，我们也是这么做，只不过新增了一个难点，那就是如何管理这些页。因为lazy allocation页与页之间没有比较紧密的关系，但是在mmap中页却可以被所属文件这个关键字划分。因而，我们需要一个数据结构，来给页分门别类地组织在一起，并且记录它们的meta data比如说所属文件之类的，这也就是hints里的VMA结构，也即我的filemap结构。

      +

      我们可以将这样的数据结构池化，并且存储在proc域中，以避免对象的重复创建。

      -

      iget返回的struct inode可能没有任何有用的内容。为了确保它保存磁盘inode的副本，代码必须调用ilock。这将锁定inode（以便没有其他进程可以对其进行ilock），并从磁盘读取尚未读取的inode。

      -
      -
      // Lock the given inode and reads the inode from disk if necessary.
      void
      ilock(struct inode *ip)
      {
        struct buf *bp;
        struct dinode *dip;

        if(ip == 0 || ip->ref < 1)
          panic("ilock");

        acquiresleep(&ip->lock);

        if(ip->valid == 0){
          // 通过inode索引号和superblock算出扇区号
          bp = bread(ip->dev, IBLOCK(ip->inum, sb));
          dip = (struct dinode*)bp->data + ip->inum%IPB;
          // 填充ip
          ip->type = dip->type;
          ip->major = dip->major;
          ip->minor = dip->minor;
          ip->nlink = dip->nlink;
          ip->size = dip->size;
          memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
          brelse(bp);
          ip->valid = 1;
          if(ip->type == 0)
            panic("ilock: no type");
        }
      }
      - -
      iunlock
      -

      iunlock释放inode上的锁。

      -

      将inode指针的获取与锁定分离有助于在某些情况下避免死锁，例如在目录查找期间。多个进程可以持有指向iget返回的inode的C指针，但一次只能有一个进程锁定inode。

      +

      我的lazy法与别人不大一样……我没有想得像他们那么完美。我的做法是，在需要读某个地址的文件内容时，直接确保这个地址前面的所有文件内容都读了进来。也即在filemap中维护一个okva，表明vaokva这段内存已经读入，之后就仅需再读入okvaneed_va这段地址就行。这样虽然lazy了，但没完全lazy。

      +

      我认为这不能体现lazy的思想……因为一读读一坨，还是很占空间啊。

      -
      // Unlock the given inode.
      void
      iunlock(struct inode *ip)
      {
        if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
          panic("iunlock");

        releasesleep(&ip->lock);
      }
      - -

      Code: inode content

      Overview

      -

      主要讲的是inode本身存储数据的结构

      +

      因而，我们需要做的就是：

      +
        +

      1. 在mmap中将信息填入该数据结构

        +
          +
        1. 依据传入的长度扩容proc，原sz作为mapped-file起始地址va
          2. +
        2. 从对象池中寻找到一个空闲的filemap，对其填写信息
          3. +
        3. 返回1所得的va
          4. +
        +

        在我的代码中，还针对proc->sz不满足page-align做出了对策：先把文件的PGROUNDUP(sz)-sz这部分的信息读入，并且更新okva，这样一来，之后在usertrap中，就可以从okva开始一页页地分配地址，做到自然地page-align了。

        +
        +

        为什么要对不满足page-align的情况进行处理？

        +

        这是因为，growproc的时候一次性扩充一页，但proc->sz却可以不满足page-align，也就是说，proc->sz所处的这一页已经被分配了。

        +

        在我们的lazy思路中，我们如果不预先读入文件页，是只能等待用户陷入缺页中断的情况下才能读入文件内容。

        +

        但是，proc->sz这一页已经被分配了。因而，在用户态读取这一页地址的时候，并不会发生缺页中断。因而，就会发生文件内容未读入，用户读到脏数据的情况。

        +

        其实还有一种更简单的办法可以强制page-align，那就是，直接让起始地址为PGROUNDUP(proc->sz)……至于为什么我不用这个，而要写这么多麻烦的东西呢？答案是我没想到。（）

        +
        2. +

      2. 在usertrap增加对缺页中断的处理

        +
          +
        1. 依据va找到对应filemap
          2. +
        2. 根据对应filemap的信息，使用readi（正确）fileread（错误）读取文件内容并存入物理内存
          3. +
        +
        3. +

      3. 在munmap中进行释放

        +
          +
        1. 根据标记写入文件页，并且释放对应物理内存
          2. +
        2. 修改filemap结构的参数，并且在其失效的时候放回对象池
          3. +
        +
        4. +

      4. 修改fork和exit

        +
          +

        1. exit

          +

          手动释放map-file域

          -

          磁盘上的inode结构体struct dinode包含一个size和一个块号数组（见图8.3），数组内罗列着存储着该inode数据的块号。

          -

          前面的NDIRECT个数据块被列在数组中的前NDIRECT个元素中；这些块称为直接块（direct blocks）。接下来的NINDIRECT个数据块不在inode中列出，而是在称为间接块（indirect block）的数据块中列出。addrs数组中的最后一个元素给出了间接块的地址。

          -

          因此，可以从inode中列出的块加载文件的前12 kB（NDIRECT x BSIZE）字节，而只有在查阅间接块后才能加载下一个256 kB（NINDIRECT x BSIZE）字节。

          +

          为什么不能把这些合并到wait中调用的freepagetable进行释放呢？

          +

          因为freepagetable只会释放对应的物理页，没有达到munmap减少文件引用等功能。

          -
          // On-disk inode structure
          struct dinode {
            // ...
            uint addrs[NDIRECT+1];   // Data block addresses
          };
          - -

          image-20230124163025094

          -

          bmap

          -

          函数bmap负责封装这个寻找数据块的过程，以便实现我们将很快看到的如readi和writei这样的更高级例程。

          -

          bmap(struct inode *ip, uint bn)返回inodeip的第bn个数据块的磁盘块号。如果ip还没有这样的块，bmap会分配一个。

          -

          Bmap使readi和writei很容易获取inode的数据。

          +
          2. +

        2. fork

          +

          手动复制filemap池

          +
          3. +
        +
        5. +
      +

      我的错误思路们

      第一次错误思路

      上面说到：

      +
      +

      问题就在于如何“先建立memory-file的映射”。在lazy allocation中，我们是先填好所有的对应页表项，仅是不申请对应的物理内存，也即占着XX不XX。在这次实验中，我们也是这么做，只不过新增了一个难点，那就是如何管理这些页。因为lazy allocation页与页之间没有比较紧密的关系，但是在mmap中页却可以被所属文件这个关键字划分。因而，我们需要一个数据结构，来给页分门别类地组织在一起，并且记录它们的meta data比如说所属文件之类的，这也就是hints里的VMA结构，也即我的filemap结构。

      -
      // Inode content
      //
      // The content (data) associated with each inode is stored
      // in blocks on the disk. The first NDIRECT block numbers
      // are listed in ip->addrs[].  The next NINDIRECT blocks are
      // listed in block ip->addrs[NDIRECT].

      // Return the disk block address of the nth block in inode ip.
      // If there is no such block, bmap allocates one.
      static uint
      bmap(struct inode *ip, uint bn)
      {
        uint addr, *a;
        struct buf *bp;

        // 如果为direct block
        if(bn < NDIRECT){
          if((addr = ip->addrs[bn]) == 0)
            ip->addrs[bn] = addr = balloc(ip->dev);
          return addr;
        }
        bn -= NDIRECT;
          
        // 如果为indirect block
        if(bn < NINDIRECT){
          // Load indirect block, allocating if necessary.
          if((addr = ip->addrs[NDIRECT]) == 0)
            ip->addrs[NDIRECT] = addr = balloc(ip->dev);
          bp = bread(ip->dev, addr);
          a = (uint*)bp->data;
          if((addr = a[bn]) == 0){
            // 如果没有，会分配一个
            a[bn] = addr = balloc(ip->dev);
            log_write(bp);
          }
          brelse(bp);
          return addr;
        }

        panic("bmap: out of range");
      }
      +

      官方给出的答案是在proc域里的pool。我……额……是把这些信息，存入在页中（真是自找麻烦呀）

      +

      具体来说，就是，我在mmap的时候给每个文件申请一页，然后在页的开头填上和filemap结构相差无几的那些参数，再加上一个next指针，表示下一个文件页的地址。页的剩下部分就用来存储数据。总的就是一个链表结构。

      +

      这个思路其实很不错，比起上面的直接在proc内存的尾巴扩容，这个空间利用率应该更大，并且不仅能节省物理内存，还能节省虚拟地址空间，实现了lazy上加lazy。

      +

      但问题是……我为什么非要傻瓜式操纵内存，在页的开头填入参数数据，而不是把这种页抽象为一个个node，最终形成一个十字链表的形式（差不多的意思，鱼骨状），组织进proc域，这样不挺好的吗……唔，有时候我头脑昏迷程度让我自己都感到十分震惊。归根结底，还是想得太少就动手了，失策。

      +

      总之放上代码。我没有实现next指针，仅假设文件内容不超过一页。也就是这一页开头在mmap中填meta data，其余部分在usertrap中填入文件内容。【这个分开的点也让我迷惑至极……】

      +
      #define ERRORADDR 0xffffffffffffffff

      void* mmap(void* address,size_t length,int prot,int flags,struct file* file,uint64 offset){
          struct proc* p = myproc();
          // 获取va,也即真正的address
          uint64 va = p->sz;
          if(growproc(PGSIZE) < 0)
                  return (void*)ERRORADDR;
          char* mem = kalloc();
          if(mem == 0){
                  return (void*)ERRORADDR;
          }
          memset(mem, 0, PGSIZE);
          // 保存信息：file指针、prot（这就是傻瓜式操纵内存的典范）
          uint64* pointer = (uint64*)mem;
          *pointer = (uint64)file;
          pointer++;
          *pointer = (uint64)prot;
          pointer++;
          *pointer = (uint64)length;
          pointer++;
          *pointer = (uint64)flags;
          pointer++;
          *pointer = (uint64)offset;
          pointer++;
          filedup(file);

          if(mappages(p->pagetable, va+PGSIZE, PGSIZE, (uint64)mem, PTE_M|PTE_X|PTE_U) != 0){
            kfree(mem);
                  return (void*)ERRORADDR;
          }
          // return start of free memory
          return (void*)(va + (uint64)pointer - (uint64)mem);
      }
      int munmap(void* address,size_t length){
          struct proc* p = myproc();
          pte_t *pte;
          uint64* pa;

          if((pte = walk(p->pagetable, (uint64)address, 0)) == 0)
                  return -1;
          if((*pte & PTE_V) == 0 ||(*pte & PTE_M) == 0)
                  return -1;
          // the start is where the params save
          pa = (uint64*)(PGROUNDDOWN(PTE2PA(*pte)));
          struct file* file = (struct file*)(*pa);
          pa++;
          int prot = (int)(*pa);
          pa++;
          pa++;
          int flags = (int)(*pa);
          pa++;
          pa++;

          if(flags == MAP_SHARED&&(prot&PROT_WRITE) != 0){
              // 需要更新写内容
              filewrite(file,(uint64)address,length);
          }
          // 最后释放内存
          uvmunmap(p->pagetable, PGROUNDDOWN((uint64)address), 1, 1);
          return 0;
      }
      -

      itrunc

      -

      itrunc释放文件的块，将inode的size重置为零。

      -

      Itrunc首先释放直接块，然后释放间接块中列出的块，最后释放间接块本身。

      -
      -

      readi

      -

      readi和writei都是从检查ip->type == T_DEV开始的。这种情况处理的是数据不在文件系统中的特殊设备；我们将在文件描述符层返回到这种情况。

      -
      -
      // Read data from inode.数据大小为n，从off开始，读到dst处
      // Caller must hold ip->lock.
      // If user_dst==1, then dst is a user virtual address;
      // otherwise, dst is a kernel address.
      int
      readi(struct inode *ip, int user_dst, uint64 dst, uint off, uint n)
      {
        uint tot, m;
        struct buf *bp;

        if(off > ip->size || off + n < off)
          return 0;
        if(off + n > ip->size)
          n = ip->size - off;

        // 主循环处理文件的每个块，将数据从缓冲区复制到dst
        for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
          bp = bread(ip->dev, bmap(ip, off/BSIZE));
          m = min(n - tot, BSIZE - off%BSIZE);
          if(either_copyout(user_dst, dst, bp->data + (off % BSIZE), m) == -1) {
            brelse(bp);
            tot = -1;
            break;
          }
          brelse(bp);
        }
        return tot;
      }
      +
      } else if(r_scause() == 13 || r_scause() == 15){
        uint64 va = r_stval();
        pte_t *pte;
        uint64* pa;
        uint flags;

        if((pte = walk(p->pagetable, va, 0)) == 0)
          p->killed = 1;
        else if((*pte & PTE_V) == 0 ||(*pte & PTE_M) == 0)
          p->killed = 1;
        else {
          // the start is where the params save
          pa = (uint64*)(PGROUNDDOWN(PTE2PA(*pte)));
          flags = PTE_FLAGS(*pte);
          struct file* file = (struct file*)(*pa);
          pa++;
          int prot = (int)(*pa);
          pa++;
          size_t length = (size_t)(*pa);
          pa++;
          pa++;
          pa++;

          if((prot&PROT_READ) != 0){
            fileread(file,va,length);
            flags |= PTE_R;
            if((prot&PROT_WRITE) != 0)    flags |= PTE_W;
            else if(r_scause() == 15)     p->killed = 1;
            *pte = ((*pte) | flags);
          } else  p->killed = 1;
        }
      }
      -

      writei

      // Write data to inode.
      // Caller must hold ip->lock.
      // If user_src==1, then src is a user virtual address;
      // otherwise, src is a kernel address.
      int
      writei(struct inode *ip, int user_src, uint64 src, uint off, uint n)
      {
        uint tot, m;
        struct buf *bp;

        if(off > ip->size || off + n < off)
          return -1;
        // writei会自动增长文件，除非达到文件的最大大小
        if(off + n > MAXFILE*BSIZE)
          return -1;

        for(tot=0; tot<n; tot+=m, off+=m, src+=m){
          bp = bread(ip->dev, bmap(ip, off/BSIZE));
          m = min(n - tot, BSIZE - off%BSIZE);
          if(either_copyin(bp->data + (off % BSIZE), user_src, src, m) == -1) {
            brelse(bp);
            n = -1;
            break;
          }
          log_write(bp);
          brelse(bp);
        }

        if(n > 0){
          if(off > ip->size)
            // 说明扩大了文件大小，需要修改
            ip->size = off;
          // write the i-node back to disk even if the size didn't change
          // because the loop above might have called bmap() and added a new
          // block to ip->addrs[].
          iupdate(ip);
        }

        return n;
      }
      +
      为什么下面的代码是错的

      正如开头所说的那样，我并没有完美做好这次实验，下面代码有一个致命的bug。

      +

      先说说致命bug是什么。

      +

      我的filemap结构体其实隐藏了两个具有“offset”这一含义的状态。一个是filemap里面的成员变量offset，另一个是filemap里面的成员变量file的成员变量off：

      +
      // in proc.h
      struct filemap{
        struct file* file;//文件
        uint64 offset;//va相对于file开头的offset
      };
      // in file.h
      struct file {
        uint off;          // FD_INODE
      };
      -

      stati

      -

      函数stati将inode元数据复制到stat结构体中，该结构通过stat系统调用向用户程序公开。

      +

      在我的代码里，它们被赋予了不同的含义。

      +

      filemap->file->off被用于trap.c中，表示的是当前未读入文件内容的起始位置（实际上也就是okva-va的值），用于自然地使用fileread进行文件读入。

      +
      +

      比如说，这次读入PGSIZE，那么off就会在fileread中自增PGSIZE。下次调用fileread就可以直接从下一个位置读入了，这样使代码更加简洁

      -

      在defs.h中可看到inode结构体是private的，而stat是public的。

      -

      Directory layer

      数据结构

      -

      目录的内部实现很像文件。其inode的type为T_DIR，其数据是directory entries的集合。

      -

      每个entry都是一个struct dirent。

      +

      filemap->offset被用于munmap中。filewrite同fileread一样，都是从file->off处开始取数据。munmap所需要取数据的起始位置和trap.c中需要取数据的起始位置肯定不一样，

      +
      +

      想想它们的功能。trap.c的off需要始终指向有效内存段的末尾，但munmap由于要对特定内存段进行写入文件操作，因而off要求可以随机指向。

      -

      也就是说这一层其实本质上是一个大小一定的map，该map自身也存放在inode中，大小为inode的大小，每个表项entry映射了目录名和文件inode。所以接下来介绍的函数我们完全可以从hashmap增删改查的角度去理解。

      -
      // Directory is a file containing a sequence of dirent structures.
      #define DIRSIZ 14

      struct dirent {
        ushort inum;// 如果为0，说明该entry free
        char name[DIRSIZ];
      };
      +

      因而，我们可以将当前va对应的文件位置记录在offset中。届时，我们只需要从p->filemaps[i].offset+va-p->filemaps[i].va取数据就行。

      +

      上述两个变量相辅相成，看上去似乎能够完美无缺地实现我们的功能。但是，实际上，不行。为什么呢？因为它们的file指针，filemap->file，如果被两个mmap区域同时使用的话，就会出问题。

      +

      可以来看看mmaptest.c中的这一段代码：

      +
        makefile(f);
        if ((fd = open(f, O_RDONLY)) == -1)
          err("open");

        unlink(f);
        char *p1 = mmap(0, PGSIZE*2, PROT_READ, MAP_SHARED, fd, 0);
        char *p2 = mmap(0, PGSIZE*2, PROT_READ, MAP_SHARED, fd, 0);

        // read just 2nd page.
        if(*(p1+PGSIZE) != 'A')
          err("fork mismatch (1)");
        if((pid = fork()) < 0)
          err("fork");

        if (pid == 0) {
          // v1是用来触发缺页中断的函数
          _v1(p1);
          munmap(p1, PGSIZE); // just the first page
          exit(0); // tell the parent that the mapping looks OK.
        }

        int status = -1;
        wait(&status);

        if(status != 0){
          printf("fork_test failed\n");
          exit(1);
        }

        // check that the parent's mappings are still there.
        printf("before v1,p1 = %d\n",(uint64)p1);
        _v1(p1);
        printf("after v1,p1 = %d\n",(uint64)p1);
        _v1(p2);


        printf("fork_test OK\n");

      /*输出：
      fork_test starting
      trap:map a page at 53248,okva = 53248
      trap:mem[0]=65,off = 4096,size = 6144
      trap:map a page at 57344,okva = 53248
      trap:mem[0]=65,off = 6144,size = 6144
      before v1,p1 = 53248
      after v1,p1 = 53248
      trap:map a page at 61440,okva = 61440
      trap:mem[0]=0,off = 6144,size = 6144
      mismatch at 0, wanted 'A', got 0x0
      mmaptest: fork_test failed: v1 mismatch (1), pid=3
      */
      -

      image-20230124173241241

      -

      相关函数

      dirlookup

      -

      函数dirlookup在directory中搜索具有给定名称的entry。

      -

      它返回的指向enrty.inum相应的inode是非独占的【通过iget获取】，也即无锁状态。它还会把*poff设置为所需的entry的字节偏移量。

      -

      为什么要返回未锁定的inode？是因为调用者已锁定dp，因此，如果对.进行查找，则在返回之前尝试锁定inode将导致重新锁定dp并产生死锁【确实】(还有更复杂的死锁场景，涉及多个进程和..，父目录的别名。.不是唯一的问题。）

      -

      所以锁定交给caller来做。caller可以解锁dp，然后锁定该函数返回的ip，确保它一次只持有一个锁。

      -
      -
      // Look for a directory entry in a directory.
      // If found, set *poff to byte offset of entry.
      struct inode*
      dirlookup(struct inode *dp, char *name, uint *poff)
      {
        uint off, inum;
        struct dirent de;

        if(dp->type != T_DIR)
          panic("dirlookup not DIR");
        // new level of abstraction,可以把directory的inode看作一个表文件，每个表项都是一个entry
        for(off = 0; off < dp->size; off += sizeof(de)){
          // 从directory中获取entry，也即从inode中获取数据
          if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
            panic("dirlookup read");
          // free
          if(de.inum == 0)
            continue;
          if(namecmp(name, de.name) == 0){
            // entry matches path element
            if(poff)
              *poff = off;
            inum = de.inum;
            return iget(dp->dev, inum);
          }
        }

        return 0;
      }
      +
      // in trap.c
      printf("trap:map a page at %d,okva = %d\n",start_va,p->filemaps[i].okva);

      fileread(p->filemaps[i].file,start_va,PGSIZE);

      printf("trap:mem[0]=%d,off = %d,size = %d\n",
             mem[0],p->filemaps[i].file->off,p->filemaps[i].file->ip->size);
      -
      // Write a new directory entry (name, inum) into the directory dp.
      int
      dirlink(struct inode *dp, char *name, uint inum)
      {
        int off;
        struct dirent de;
        struct inode *ip;

        // Check that name is not present.
        if((ip = dirlookup(dp, name, 0)) != 0){
          iput(ip);
          return -1;
        }

        // Look for an empty dirent.
        for(off = 0; off < dp->size; off += sizeof(de)){
          if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
            panic("dirlink read");
          if(de.inum == 0)
            break;
        }

        // 如果没找到空闲的则调用writei自动增长inode，添加新表项
        strncpy(de.name, name, DIRSIZ);
        de.inum = inum;
        if(writei(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
          panic("dirlink");

        return 0;
      }
      +

      这段代码因为共用fd，导致file指针被两个mmap区域同时使用。

      +
      +

      共用fd，为什么file指针也一起共用了？

      +

      可以追踪一下它们的生命周期：

      +
      // in sys_open()
      // 获取file结构体和文件描述符。
      if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){

      // in sysfile.c
      // Allocate a file descriptor for the given file.
      // Takes over file reference from caller on success.
      static int
      fdalloc(struct file *f)
      {
      int fd;
      struct proc *p = myproc();

      for(fd = 0; fd < NOFILE; fd++){
       if(p->ofile[fd] == 0){
         p->ofile[fd] = f;
         return fd;
       }
      }
      return -1;
      }
      -

      Pathname layer

      -

      Path name lookup involves a succession of calls to dirlookup, one for each path component.

      +

      可以看到，它实际上是有一个文件描述符表，key为fd，value为file指针。因而，同一张表，fd相同，file指针相同。

      +

      注：父子进程，同样的fd，file指针也是相同的

      +

      fork出来的父子进程同一个句柄对同一个文件的偏移量是相同的，这个原理应该是因为，父子进程共享的是文件句柄这个结构体对象本身，也就是拷贝的时候是浅拷贝而不是深拷贝。

      +
      // in fork()
      // increment reference counts on open file descriptors.
      for(i = 0; i < NOFILE; i++)
       if(p->ofile[i])
         np->ofile[i] = filedup(p->ofile[i]);
      -

      namei和nameiparent

      -

      Namei (kernel/fs.c:661) evaluates path and returns the corresponding inode.

      -

      函数nameiparent是一个变体：它在最后一个元素之前停止，返回父目录的inode并将最后一个元素复制到name中。两者都调用通用函数namex来完成实际工作。

      +

      最后的check that the parent's mappings are still there.环节中，_v1(p1)执行时并没有陷入trap，这是正常的。不正常的是_v1(p2)的执行结果。它陷入了trap，但是却因file->off == file size，导致被判定为已全部读入文件，事实上却是并没有读入文件。

      +

      为什么会这样呢？

      +

      这是因为p1和p2共用同一个fd，也就共用了同一个file指针。共用了一个file指针，那么p1和p2面对的file->off相同。上面说到，file->off用于控制文件映射。那么，当p1完成了对文件的映射，p1的off指针如果不加重置，就会永远停留在file size处。这样一来，当p2想要使用同样的file指针进行文件映射时，就会出问题。

      +

      这个问题的一个解决方法是每次mmap都深拷贝一个船新file结构体。但是这样的话，file域里的ref变量就失去了它的意义，并且file对象池应该也很快就会爆满，非常不符合设计方案。

      +

      这个问题的完美解，是不要赋予file->off这个意义，而是使用readi替代fileread。

      +
      fileread(struct file *f, uint64 addr, int n)
      readi(struct inode *ip, int user_dst, uint64 dst, uint off, uint n)
      + +

      这样做的好处是，我们可以实时计算offset（前面提到，其恰恰等于okva-va），而不用把这个东西用file的off来表示。

      +
      +

      也确实，我之所以弯弯绕绕那么曲折，是因为只想到了fileread这个函数，压根没注意到还有一个readi……

      -
      struct inode*
      namei(char *path)
      {
        char name[DIRSIZ];
        return namex(path, 0, name);
      }
      +

      我在下面的代码仅做了一个能够通过测试，但是上面的bug依然存在的功利性折中代码。我是这么实现的：

      +
      // 在`mmap`的时候初始化`file->off`
      p->filemaps[i].file->off = offset;
      // 在`munmap`的时候清零`file->off`
      p->filemaps[i].file->off = 0;
      -
      struct inode*
      nameiparent(char *path, char *name)
      {
        return namex(path, 1, name);
      }
      -

      namex

      -

      Namex首先决定路径解析的开始位置。

      -

      如果路径以“ / ”开始，则从根目录开始解析；否则，从当前目录开始。

      -

      然后，它使用skipelem依次考察路径的每个元素。循环的每次迭代都必须在当前索引结点ip中查找name。

      -

      迭代首先给ip上锁并检查它是否是一个目录。如果不是，则查找失败。

      -

      如果caller是nameiparent，并且这是最后一个路径元素，则根据nameiparent的定义，循环会提前停止；最后一个路径元素已经复制到name中【在上一轮循坏中做了这件事】，因此namex只需返回解锁的ip。

      -

      最后，循环将使用dirlookup查找路径元素，并通过设置ip = next为下一次迭代做准备。当循环用完路径元素时，它返回ip。

      -

      注：

      + +

      因而，结论是，一步错步步错，一个错误需要更多的错误来弥补，最后还是错的（悲）

      +
      如何把下面的错误思路改成正确思路

      可以做以下几点：

        -
      1. 在每次迭代中锁定ip是必要的，不是因为ip->type可以被更改，而是因为在ilock运行之前，ip->type不能保证已从磁盘加载，所以得用到ilock保证一定会被加载的这个性质。
        2. +

      2. 正确地lazy

        +

        每次trap仅分配一页。

        +
        3. +

      3. 改用readi函数，修改file->off的语义

        +
      -
      -
      // Look up and return the inode for a path name.
      // If parent != 0, return the inode for the parent and copy the final
      // path element into name, which must have room for DIRSIZ bytes.
      // Must be called inside a transaction since it calls iput().
      static struct inode*
      namex(char *path, int nameiparent, char *name)
      {
        struct inode *ip, *next;

        if(*path == '/')
          ip = iget(ROOTDEV, ROOTINO);
        else
          ip = idup(myproc()->cwd);

        // 使用skipelem依次考察路径的每个元素
        while((path = skipelem(path, name)) != 0){
          ilock(ip);
          if(ip->type != T_DIR){
            iunlockput(ip);
            return 0;
          }
          if(nameiparent && *path == '\0'){
            // Stop one level early.
            iunlock(ip);
            return ip;
          }
          if((next = dirlookup(ip, name, 0)) == 0){
            iunlockput(ip);
            return 0;
          }
          iunlockput(ip);
          ip = next;
        }
        if(nameiparent){
          iput(ip);
          return 0;
        }
        return ip;
      }
      +

      这样一来，大概就可以完美地正确了。

      +

      其他的一些小细节

      file指针的生命周期

      在数据结构中存储file指针至关重要。但仔细想一想，file指针的生命周期似乎长到过分：从sys_mmap被调用，一直到usertrap处理缺页中断，最后到munmap释放，我们要求file指针的值需要保持稳定不变。

      +

      这么长的生命周期，它真的可以做到吗？毕竟file指针归根到底只是一个局部变量，在syscall mmap结束之后，它还有效吗？答案是有效的，这个有效性由mmap实现中对ref的增加来实现保障。

      +

      在用户态中关闭一个文件，需要使用syscallclose(int fd)。不妨来看看close的代码。

      +
      // in kernel/sysfile.c
      uint64
      sys_close(void)
      {
      int fd;
      struct file *f;

      if(argfd(0, &fd, &f) < 0)
       return -1;
      // 一个进程打开的文件都会放入一个以fd为index的文件表里，
      // 在xv6中，这个文件表便是`myproc()->ofile`。
      // 可以看到，关闭一个文件首先需要把它移出文件表
      myproc()->ofile[fd] = 0;
      // 对file指针关闭的主要操作
      fileclose(f);
      return 0;
      }

      // in kernel/file.c
      // Close file f.  (Decrement ref count, close when reaches 0.)
      void
      fileclose(struct file *f)
      {
      struct file ff;

      acquire(&ftable.lock);
      // 若ref数<0，就会直接return
      if(--f->ref > 0){
       release(&ftable.lock);
       return;
      }
      // 释放file
      // close不会显式地释放file指针，只会释放file指针所指向的文件，让file指针失效。
      ff = *f;
      f->ref = 0;
      f->type = FD_NONE;
      release(&ftable.lock);

      if(ff.type == FD_PIPE){
       pipeclose(ff.pipe, ff.writable);
      } else if(ff.type == FD_INODE || ff.type == FD_DEVICE){
       begin_op();
       iput(ff.ip);
       end_op();
      }
      }
      +

      可以看到，当ref数>1时，file指针就不会失效。

      +

      这就是为什么我们还需要在mmap中让file的ref数++。

      +
      缺页中断蕴含的设计思想

      如果只存入file指针，用户态要如何对对应的文件进行读写呢？

      +

      我们可以自然想到也许需要设计一个函数，让用户在想要对这块内存读写的时候调用这个函数即可。但是，这样的方法使得用户对内存不能自然地读写，还需要使用我们新设计的这个函数，这显然十分地不美观。所以，我们需要找到一个方法，让上层的用户可以统一地读取任何的内存块，包括memory-mapped file内存块，而隐藏memory-mapped file与其他内存块读写方式不同的这些复杂细节。经历过前面几次实验的你看到这里一定能想到，有一个更加优美更加符合设计规范的方法，那就是：缺页中断！

      -

      namex过程可能需要很长时间才能完成：它可能涉及多个磁盘操作来读取路径名中所遍历目录的索引节点和目录块（如果它们不在buffer cache中）。

      -

      Xv6 is carefully designed，如果一个内核线程对namex的调用在磁盘I/O上阻塞，另一个查找不同路径名的内核线程可以同时进行。Namex locks each directory in the path separately so that lookups in different directories can proceed in parallel.锁细粒度化

      -

      This concurrency introduces some challenges. For example, while one kernel thread is looking up a pathname another kernel thread may be changing the directory tree by unlinking a directory. A potential risk is that a lookup may be searching a directory that has been deleted by another kernel thread and its blocks have been re-used for another directory or file.一个潜在的风险是，查找可能正在搜索已被另一个内核线程删除且其块已被重新用于另一个目录或文件的目录。

      -

      Xv6避免了这种竞争，也就是说，你查到的inode保证暂时不会被释放，里面的内容还是真的，而不会被重新利用从而导致里面的内容变样。

      -

      例如，在namex中执行dirlookup时，lookup线程持有目录上的锁，dirlookup返回使用iget获得的inode。Iget增加索引节点的引用计数。只有在从dirlookup接收inode之后，namex才会释放目录上的锁。现在，另一个线程可以从目录中取消inode的链接，但是xv6还不会删除inode，因为inode的引用计数仍然大于零。

      -

      另一个风险是死锁。例如，查找“.”时，next指向与ip相同的inode【确实】。在释放ip上的锁之前锁定next将导致死锁【为什么？？？难道不是会由于在acquire时已经持有锁，从而爆panic("acquire")吗？】。为了避免这种死锁，namex在获得下一个目录的锁之前解锁该目录。这里我们再次看到为什么iget和ilock之间的分离很重要。

      -
      -

      File descriptor layer

      -

      Unix的一个很酷的方面是，Unix中的大多数资源都表示为文件，包括控制台、管道等设备，当然还有真实文件。文件描述符层是实现这种一致性的层。

      -
      -

      数据结构

      -

      Xv6为每个进程提供了自己的打开文件表或文件描述符。每个打开的文件都由一个struct file表示，它是inode或管道的封装，加上一个I/O偏移量。

      -

      每次调用open都会创建一个新的打开文件（一个新的struct file）：如果多个进程独立地打开同一个文件，那么不同的实例将具有不同的I/O偏移量。

      -

      另一方面，单个打开的文件（同一个struct file）可以多次出现在一个进程的文件表中，也可以出现在多个进程的文件表中。如果一个进程使用open打开文件，然后使用dup创建别名，或使用fork与子进程共享，就会发生这种情况。

      +

      没做这个实验之前就知道mmap需要借助缺页中断来实现了，但实际自己的第一印象是觉得并不需要缺页中断，直到分析到这里才恍然大悟。

      +

      “让上层的用户可以统一地读取任何的内存块，而隐藏不同类型的内存块读写方式不同的这些复杂细节”

      +

      仔细想想，前面几个关于缺页中断的实验，比如说cow fork，lazy allocation，事实上都是基于这个思想。它们并不是不能与缺页中断分离，只是有了缺页中断，它们的实现更加简洁，更加优美。

      +

      再次感慨os的博大精深。小小一个缺页中断，原理那么简单，居然集中了这么多设计思想，不禁叹服。

      -
      struct file {
        enum { FD_NONE, FD_PIPE, FD_INODE, FD_DEVICE } type;
        int ref; // reference count
        char readable;
        char writable;
        struct pipe *pipe; // FD_PIPE
        struct inode *ip;  // FD_INODE and FD_DEVICE
        uint off;          // FD_INODE
        short major;       // FD_DEVICE
      };
      +
      正确答案的munmap中如果遇到未映射的页怎么办

      在正确答案的munmap中：

      +
      //释放已经申请的页表项、内存，并且看看是不是需要写回
      while(start_va < bounder){
        if(p->filemaps[i].flags == MAP_SHARED){
          //写回
          filewrite(p->filemaps[i].file,start_va,PGSIZE);
        }
        uvmunmap(p->pagetable,start_va,1,1);
        start_va += PGSIZE;
      }
      -

      ftable

      -

      所有在系统中打开的文件都会被放入global file tableftable中。

      -

      ftable具有分配文件（filealloc）、创建重复引用（filedup）、释放引用（fileclose）以及读取和写入数据（fileread和filewrite）的函数。

      -

      前三个都很常规，跟之前的xxalloc、xxfree的思路是一样的。

      -

      函数filestat、fileread和filewrite实现对文件的stat、read和write操作。

      -
      -

      filealloc

      // Allocate a file structure.
      struct file*
      filealloc(void)
      {
        struct file *f;

        acquire(&ftable.lock);
        for(f = ftable.file; f < ftable.file + NFILE; f++){
          if(f->ref == 0){
            f->ref = 1;
            release(&ftable.lock);
            return f;
          }
        }
        release(&ftable.lock);
        return 0;
      }
      +

      如果map类型为MAP_SHARED，并且该页尚未映射，会怎么样呢？

      +

      追踪filewrite的路径

      +
      // in file.c
      	  begin_op();
            ilock(f->ip);
            if ((r = writei(f->ip, 1, addr + i, f->off, n1)) > 0)
              f->off += r;
            iunlock(f->ip);
            end_op();
      // in fs.c
          if(either_copyin(bp->data + (off % BSIZE), user_src, src, m) == -1) {
            brelse(bp);
            break;
          }
          log_write(bp);
      // in vm.c copyin()
      int
      copyin(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len)
      {
        uint64 n, va0, pa0;

        while(len > 0){
          va0 = PGROUNDDOWN(srcva);
          pa0 = walkaddr(pagetable, va0);
          if(pa0 == 0)
            return -1;
      // ...
      -

      filedup

      // Increment ref count for file f.
      struct file*
      filedup(struct file *f)
      {
        acquire(&ftable.lock);
        if(f->ref < 1)
          panic("filedup");
        f->ref++;
        release(&ftable.lock);
        return f;
      }
      +

      copyin最终会在 if(pa0 == 0) return -1;这里终结，但writei并不会在接收到-1的时候爆出panic或者是引发缺页中断，而只会把它当做文件结尾，默默地返回。

      +

      并且，在munmap中是一页一页地释放，而不是直接传参length全部释放，这一点也很重要。因为我们的lazy allocation很可能导致va~va+length这一区间内只是部分页被映射，部分页没有。如果直接传参length释放，那么在遇到第一页未被映射的时候，filewrite就会终止，该页之后的页就没有被写回文件的机会了。

      +

      所以结论是，在正确实现的munmap中遇到未映射的页会自动跳过，什么也不会发生。

      +

      代码

      数据结构

      // in param.h
      #define NFILEMAP 32

      // in proc.h
      struct filemap{
        uint isused;//对象池思想。该filemap是否正在被使用
        uint64 va;//该文件的起始内存页地址
        uint64 okva;//该文件的起始未被读入部分对应的内存地址
        struct file* file;//文件
        size_t length;//需要映射到内存的长度
        int flags;//MAP_SHARED OR MAP_PRIVATE
        int prot;//PROT_READ OR PROT_WRITE
        uint64 offset;//va相对于file开头的offset
      };

      // Per-process state
      struct proc {
        struct filemap filemaps[NFILEMAP];
      };
      -

      fileclose

      // Close file f.  (Decrement ref count, close when reaches 0.)
      void
      fileclose(struct file *f)
      {
        struct file ff;

        acquire(&ftable.lock);
        if(f->ref < 1)
          panic("fileclose");
        if(--f->ref > 0){
          release(&ftable.lock);
          return;
        }
        ff = *f;
        f->ref = 0;
        f->type = FD_NONE;
        release(&ftable.lock);

        if(ff.type == FD_PIPE){
          pipeclose(ff.pipe, ff.writable);
        } else if(ff.type == FD_INODE || ff.type == FD_DEVICE){
          begin_op();
          iput(ff.ip);
          end_op();
        }
      }
      +

      mmap

      具体系统调用注册过程略。

      +
      // in sysproc.c
      uint64
      sys_mmap(void){
        uint64 addr;
        int length,prot,flags,offset;
        struct file* file;
        if(argaddr(0,&addr) < 0 || argint(1,&length) < 0 || argint(2,&prot) < 0 || argint(3,&flags) < 0 || argfd(4,0,&file) ||argint(5,&offset) < 0)
          return -1;
        return (uint64)mmap((void*)addr,(size_t)length,prot,flags,file,(uint)offset);
      }
      -

      filestat

      -

      Filestat只允许在inode上操作并且调用了stati

      -
      -
      // Get metadata about file f.
      // addr is a user virtual address, pointing to a struct stat.
      int
      filestat(struct file *f, uint64 addr)
      {
        struct proc *p = myproc();
        struct stat st;

        // 仅允许文件/设备执行
        if(f->type == FD_INODE || f->type == FD_DEVICE){
          ilock(f->ip);
          stati(f->ip, &st);
          iunlock(f->ip);
          if(copyout(p->pagetable, addr, (char *)&st, sizeof(st)) < 0)
            return -1;
          return 0;
        }
        return -1;
      }
      +
      #define ERRORADDR 0xffffffffffffffff

      // 映射file从offset开始长度为length的内容到内存中，返回内存中的文件内容起始地址
      void* mmap(void* address,size_t length,int prot,int flags,struct file* file,uint64 offset){
          // mmap的prot权限必须与file的权限对应，不能file只读但是mmap却可写且shared
          if((prot&PROT_WRITE) != 0&&flags == MAP_SHARED &&file->writable == 0)       
              return (void*)ERRORADDR;
          
          struct proc* p = myproc();
          uint64 va = 0;
          int i=0;
          
          //找到filemap池中第一个空闲的filemap
          for(i=0;i<NFILEMAP;i++){
            if(!p->filemaps[i].isused){
              // 获取va,也即真正的address
              va = p->sz;
              p->sz += length;
              // 其实这里用一个memcpy会更加优雅，可惜我忘记了（）
              p->filemaps[i].isused = 1;
              p->filemaps[i].va = va;
              p->filemaps[i].okva = va;
              p->filemaps[i].length = length;
              p->filemaps[i].prot = prot;
              p->filemaps[i].flags = flags;
              p->filemaps[i].file = file;
              p->filemaps[i].file->off = offset;
              p->filemaps[i].offset = offset;
              // 增加文件引用数
              filedup(file);
              break;
            }
          }
          if(va == 0)  return (void*)ERRORADDR;
          // return start of free memory
          uint64 start_va = PGROUNDUP(va);
          // 先读入处于proc已申请的内存页区域（也即没有内存对齐情况下）
          uint64 off = start_va - va;
          if(off < PGSIZE){
              fileread(file,va,off);
              file->off += off;
              p->filemaps[i].okva = va+off;
          }
          return (void*)va;
      }
      -

      fileread

      // Read from file f.
      // addr is a user virtual address.
      int
      fileread(struct file *f, uint64 addr, int n)
      {
        int r = 0;
        
        // 首先检查是否可读
        if(f->readable == 0)
          return -1;

        if(f->type == FD_PIPE){
          r = piperead(f->pipe, addr, n);
        } else if(f->type == FD_DEVICE){
          if(f->major < 0 || f->major >= NDEV || !devsw[f->major].read)
            return -1;
          r = devsw[f->major].read(1, addr, n);
        } else if(f->type == FD_INODE){
          ilock(f->ip);
          if((r = readi(f->ip, 1, addr, f->off, n)) > 0)
            // 移动文件指针偏移量
            f->off += r;
          iunlock(f->ip);
        } else {
          panic("fileread");
        }

        return r;
      }
      +

      usertrap

      错的
      } else if(r_scause() == 13 || r_scause() == 15){
         uint64 va = r_stval();

         for(int i=0;i<NFILEMAP;i++){
             // 找到va对应的filemap
           if(p->filemaps[i].isused&&va>=p->filemaps[i].va 
              && va<p->filemaps[i].va+p->filemaps[i].length){
             // 说明本来就不应该写
             if(r_scause() == 15 && ((p->filemaps[i].prot)&PROT_WRITE) == 0){
               p->killed = 1;
               break;
             }
             //说明地址不在文件范围内
             if(p->filemaps[i].va+p->filemaps[i].file->ip->size <= va){
               p->killed = 1;
               break;
             }
             // 能进到这里来的都是产生了缺页中断，也就是说va对应文件数据不存在
             // 我们需要维护一个okva，表示从filemaps.va到okva这段地址已经加载了文件
             // 这样一来，我们这里就只需加载okva~va地址对应的文件了
             // file结构体自带的off成员会由于fileread而自动增长到对应位置，所以文件可以自然地读写
             uint64 start_va = p->filemaps[i].okva;// okva一定是page-align的
             // 加载文件内容
             while(start_va <= va){
               char* mem = kalloc();
               if(mem == 0){
                 p->killed = 1;
                 break;
               }
               memset(mem, 0, PGSIZE);
               int flag = PTE_X|PTE_R|PTE_U;
               if(((p->filemaps[i].prot)&PROT_WRITE) != 0){
                 flag |= PTE_W;
               }
               if(mappages(p->pagetable, start_va, PGSIZE, (uint64)mem, flag) != 0){
                 p->killed = 1;
                 kfree(mem);
                 break;
               }
               // 读入文件内容
               fileread(p->filemaps[i].file,start_va,PGSIZE);
               start_va += PGSIZE;
             }
             p->filemaps[i].okva = start_va;
             break;
           }
         }
       }
      -

      Code: System calls

      -

      通过使用底层提供的函数，大多数系统调用的实现都很简单（请参阅***kernel/sysfile.c***）。有几个调用值得仔细看看。

      -

      以下介绍的函数都在kernel/sysfile.c中。

      -
      -

      这个函数的功能是给文件old加上一个链接，这个链接存在于文件new的父目录。感觉也就相当于把文件从old复制到new处了。具体实现逻辑就是要给该文件所在目录添加一个entry，name=新名字，inode=该文件的inode。

      -
      // Create the path new as a link to the same inode as old.
      uint64
      sys_link(void)
      {
        char name[DIRSIZ], new[MAXPATH], old[MAXPATH];
        struct inode *dp, *ip;

        if(argstr(0, old, MAXPATH) < 0 || argstr(1, new, MAXPATH) < 0)
          return -1;

        // 首先先增加nlink
        begin_op();
        // 通过path找到ip结点
        if((ip = namei(old)) == 0){
          end_op();
          return -1;
        }

        ilock(ip);
        // directory不能被link
        if(ip->type == T_DIR){
          iunlockput(ip);
          end_op();
          return -1;
        }

        ip->nlink++;
        // 修改一次字段就需要update一次
        iupdate(ip);
        iunlock(ip);

        // 然后再在目录中登记新的entry
        // 找到new的parent，也即new所在目录
        if((dp = nameiparent(new, name)) == 0)
          goto bad;
        ilock(dp);
        // 在目录中添加一个entry，名字为给定的新名字，inode依旧为原来的inode
        // new的父目录必须存在并且与现有inode位于同一设备上
        if(dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0){
          iunlockput(dp);
          goto bad;
        }
        iunlockput(dp);
        iput(ip);

        end_op();

        return 0;

      bad:
        ilock(ip);
        ip->nlink--;
        iupdate(ip);
        iunlockput(ip);
        end_op();
        return -1;
      }
      +
      对的
      } else if(r_scause() == 13 || r_scause() == 15){
        uint64 va = r_stval();
        for(int i=0;i<NFILEMAP;i++){
          if(p->filemaps[i].isused&&va>=p->filemaps[i].va && va<p->filemaps[i].va+p->filemaps[i].length){
            if(r_scause() == 15 && ((p->filemaps[i].prot)&PROT_WRITE) == 0){
              // 说明本来就不应该写
              p->killed = 1;
              break;
            }
            if(p->filemaps[i].va+p->filemaps[i].file->ip->size <= va){
              //说明地址不在文件范围内
              p->killed = 1;
              break;
            }
            uint64 start_va = PGROUNDDOWN(va);
              char* mem = kalloc();
              if(mem == 0){
                p->killed = 1;
                break;
              }
              memset(mem, 0, PGSIZE);
              int flag = PTE_X|PTE_R|PTE_U;
              if(((p->filemaps[i].prot)&PROT_WRITE) != 0){
               flag |= PTE_W;
              }
              if(mappages(p->pagetable, start_va, PGSIZE, (uint64)mem, flag) != 0){
                p->killed = 1;
                kfree(mem);
                break;
              }
              readi(p->filemaps[i].file->ip,0,(uint64)mem,va-p->filemaps[i].va+p->filemaps[i].offset,PGSIZE);
            break;
          }
        }
      }
      -

      create

      -

      它是三个文件创建系统调用的泛化：带有O_CREATE标志的open生成一个新的普通文件，mkdir生成一个新目录，mkdev生成一个新的设备文件。

      -
      -

      创建一个新的inode结点，结点名包含在path内。返回一个锁定的inode。

      -

      由于使用了iupdate等，所以该函数只能在事务中被调用。

      -
      static struct inode*
      create(char *path, short type, short major, short minor)
      {
        struct inode *ip, *dp;
        char name[DIRSIZ];

        // 获取结点父目录
        if((dp = nameiparent(path, name)) == 0)
          return 0;

        ilock(dp);

        if((ip = dirlookup(dp, name, 0)) != 0){
          // 说明文件已存在
          iunlockput(dp);
          ilock(ip);
          if(type == T_FILE && (ip->type == T_FILE || ip->type == T_DEVICE))
            // 说明此时caller为open（type == T_FILE），open调用create只能是用于创建文件
            return ip;
          iunlockput(ip);
          return 0;
        }

        if((ip = ialloc(dp->dev, type)) == 0)
          panic("create: ialloc");

        ilock(ip);
        ip->major = major;
        ip->minor = minor;
        ip->nlink = 1;
        iupdate(ip);

        if(type == T_DIR){  // Create . and .. entries.
          dp->nlink++;  // for ".."
          iupdate(dp);
          // No ip->nlink++ for ".": avoid cyclic ref count.
          // 所以其实.和..本质上是link
          if(dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
            panic("create dots");
        }

        if(dirlink(dp, name, ip->inum) < 0)
          panic("create: dirlink");

        iunlockput(dp);

        return ip;
      }
      +

      munmap

      错的
      uint64 min(uint64 a,uint64 b){return a>b?b:a;}

      // 释放文件映射以address为起始地址，length为长度这个范围内的内存地址空间
      int munmap(void* address,size_t length){
          struct proc* p = myproc();
          uint64 va = (uint64)address;
          
          // 找到对应的filemap
          for(int i=0;i<NFILEMAP;i++){
            if(p->filemaps[i].isused&&p->filemaps[i].va<=va&&p->filemaps[i].va+length>va){
              // 开始释放的内存地址
              uint64 start_va;
              if(va == p->filemaps[i].va)
                  start_va = PGROUNDUP(p->filemaps[i].va);
              else
                  start_va = PGROUNDDOWN(va);
              // 结束释放的内存地址
              uint64 bounder = p->filemaps[i].va + min(p->filemaps[i].file->ip->size,length);
                
              //file的off在trap中用于表示文件已加载的位置
              //在这里需要用off进行filewrite，所以需要对原本在usertrap用于记录加载位置的off进行手动保存
              uint64 tmp_off = p->filemaps[i].file->off;
              p->filemaps[i].file->off = p->filemaps[i].offset+va-p->filemaps[i].va;

              //释放已经申请的页表项、内存，并且看看是不是需要写回
              while(start_va < bounder && start_va < p->filemaps[i].okva){
                if(p->filemaps[i].flags == MAP_SHARED){
                  //写回
                  filewrite(p->filemaps[i].file,start_va,PGSIZE);
                }
                uvmunmap(p->pagetable,start_va,1,1);
                start_va += PGSIZE;
              }

              //修改filemap结构体的起始地址va和长度，offset也要变，因为他记录va对应的是文件哪个位置
              if(va == p->filemaps[i].va){
                //释放的是头几页
                p->filemaps[i].offset += length;
                p->filemaps[i].va = va+length;
                p->filemaps[i].length -= length;
              }else {
                //释放的是尾几页
                p->filemaps[i].length -= p->filemaps[i].length - va;
              }
              p->filemaps[i].file->off = tmp_off;
              // 检验map的合理性
              if(p->filemaps[i].length == 0 || p->filemaps[i].va >= p->filemaps[i].va+length
                              || p->filemaps[i].file->off > p->filemaps[i].file->ip->size){
                p->filemaps[i].isused = 0;//释放
                
                // 注意！！！！这句话对我的错误代码来说非常重要
                p->filemaps[i].file->off = 0;
                fileclose(p->filemaps[i].file);
              }
            }
          }
          return 0;
      }
      -

      sys_mkdir

      uint64
      sys_mkdir(void)
      {
        char path[MAXPATH];
        struct inode *ip;

        begin_op();
        if(argstr(0, path, MAXPATH) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0){
          end_op();
          return -1;
        }
        iunlockput(ip);
        end_op();
        return 0;
      }
      +
      对的
      uint64 min(uint64 a,uint64 b){return a>b?b:a;}

      int munmap(void* address,size_t length){
          struct proc* p = myproc();
          uint64 va = (uint64)address;
          for(int i=0;i<NFILEMAP;i++){
            if(p->filemaps[i].isused&&p->filemaps[i].va<=va&&p->filemaps[i].va+length>va){
              uint64 start_va;
              if(va == p->filemaps[i].va)
                      start_va = PGROUNDUP(p->filemaps[i].va);
              else
                      start_va = PGROUNDDOWN(va);
              uint64 bounder = p->filemaps[i].va + min(p->filemaps[i].file->ip->size,length);
              //在这里需要用off进行读写，所以需要对原本的加载处off手动保存
              uint64 tmp_off = p->filemaps[i].file->off;
              p->filemaps[i].file->off = p->filemaps[i].offset+va-p->filemaps[i].va;

              //释放已经申请的页表项、内存，并且看看是不是需要写回
              while(start_va < bounder){
                if(p->filemaps[i].flags == MAP_SHARED){
                  //写回
                  filewrite(p->filemaps[i].file,start_va,PGSIZE);
                }
                uvmunmap(p->pagetable,start_va,1,1);
                start_va += PGSIZE;
              }

              //修改filemap结构体的起始地址va和长度，offset也要变，因为他记录va对应的是文件哪个位置
              if(va == p->filemaps[i].va){
                //释放的是头几页
                p->filemaps[i].offset += length;
                p->filemaps[i].va = va+length;
                p->filemaps[i].length -= length;
              }else {
                //释放的是尾几页
                p->filemaps[i].length -= p->filemaps[i].length - va;
              }
              // 检验map的合理性
              if(p->filemaps[i].length == 0 || p->filemaps[i].va >= p->filemaps[i].va+length
                              || p->filemaps[i].file->off > p->filemaps[i].file->ip->size){
                p->filemaps[i].isused = 0;//释放
                fileclose(p->filemaps[i].file);
              }
              p->filemaps[i].file->off = tmp_off;
            }
          }
          return 0;
      }
      -

      sys_open

      -

      Sys_open是最复杂的，因为创建一个新文件只是它能做的一小部分。

      -
      -
      uint64
      sys_open(void)
      {
        char path[MAXPATH];
        int fd, omode;
        struct file *f;
        struct inode *ip;
        int n;

        if((n = argstr(0, path, MAXPATH)) < 0 || argint(1, &omode) < 0)
          return -1;

        begin_op();

        if(omode & O_CREATE){
          ip = create(path, T_FILE, 0, 0);
          // 创建失败
          if(ip == 0){
            end_op();
            return -1;
          }
        } else {
          // 文件不存在
          if((ip = namei(path)) == 0){
            end_op();
            return -1;
          }
          // Create返回一个锁定的inode，但namei不锁定，因此sys_open必须锁定inode本身。
          ilock(ip);
          // 非文件，为目录并且非只读
          // 所以说想要open一个目录的话只能以只读模式打开
          if(ip->type == T_DIR && omode != O_RDONLY){
            iunlockput(ip);
            end_op();
            return -1;
          }
        }

        if(ip->type == T_DEVICE && (ip->major < 0 || ip->major >= NDEV)){
          iunlockput(ip);
          end_op();
          return -1;
        }

        // 获取file结构体和文件描述符。
        if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){
          if(f)
            fileclose(f);
          iunlockput(ip);
          end_op();
          return -1;
        }

        // 没有其他进程可以访问部分初始化的文件，因为它仅位于当前进程的表中，因而这里可以不用上锁
        if(ip->type == T_DEVICE){
          f->type = FD_DEVICE;
          f->major = ip->major;
        } else {
          f->type = FD_INODE;
          f->off = 0;
        }
        f->ip = ip;
        f->readable = !(omode & O_WRONLY);
        f->writable = (omode & O_WRONLY) || (omode & O_RDWR);

        // 如果使用了这个标志,调用 open 函数打开文件的时候会将文件原本的内容全部丢弃,文件大小变为 0。
        if((omode & O_TRUNC) && ip->type == T_FILE){
          itrunc(ip);
        }

        iunlock(ip);
        end_op();

        return fd;
      }
      +

      exit和fork

      exit
      // 关闭map-file
      for(int i=0;i<NFILEMAP;i++){
        if(p->filemaps[i].isused){
          munmap((void*)(p->filemaps[i].va),p->filemaps[i].length);
        }
      }
      -

      sys_pipe

      uint64
      sys_pipe(void)
      {
        uint64 fdarray; // user pointer to array of two integers用来接收pipe两端的文件描述符
        struct file *rf, *wf;
        int fd0, fd1;
        struct proc *p = myproc();

        if(argaddr(0, &fdarray) < 0)
          return -1;
        if(pipealloc(&rf, &wf) < 0)
          return -1;
        fd0 = -1;
        if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
          if(fd0 >= 0)
            p->ofile[fd0] = 0;
          fileclose(rf);
          fileclose(wf);
          return -1;
        }
        if(copyout(p->pagetable, fdarray, (char*)&fd0, sizeof(fd0)) < 0 ||
           copyout(p->pagetable, fdarray+sizeof(fd0), (char *)&fd1, sizeof(fd1)) < 0){
          p->ofile[fd0] = 0;
          p->ofile[fd1] = 0;
          fileclose(rf);
          fileclose(wf);
          return -1;
        }
        return 0;
      }
      +
      fork
      for(int i=0;i<NFILEMAP;i++){
        np->filemaps[i].isused = p->filemaps[i].isused;
        np->filemaps[i].va = p->filemaps[i].va;
        np->filemaps[i].okva = p->filemaps[i].okva;
        np->filemaps[i].file = p->filemaps[i].file;
        np->filemaps[i].length = p->filemaps[i].length;
        np->filemaps[i].flags = p->filemaps[i].flags;
        np->filemaps[i].offset = p->filemaps[i].offset;
        np->filemaps[i].prot = p->filemaps[i].prot;
        if(np->filemaps[i].file)
          filedup(np->filemaps[i].file);
      }
      -

      Real world

      -

      实际操作系统中的buffer cache比xv6复杂得多，但它有两个相同的用途：缓存和同步对磁盘的访问。

      -

      与UNIX V6一样，Xv6的buffer cache使用简单的最近最少使用（LRU）替换策略；有许多更复杂的策略可以实现，每种策略都适用于某些工作场景，而不适用于其他工作场景。更高效的LRU缓存将消除链表，而改为使用哈希表进行查找，并使用堆进行LRU替换【跟我们在lock中实现的一样，再多个堆优化】。现代buffer cache通常与虚拟内存系统集成，以支持内存映射文件。

      -

      Xv6的日志系统效率低下。提交不能与文件系统调用同时发生。系统记录整个块，即使一个块中只有几个字节被更改。它执行同步日志写入，每次写入一个块，每个块可能需要整个磁盘旋转时间。真正的日志系统解决了所有这些问题。

      -

      文件系统布局中最低效的部分是目录，它要求在每次查找期间对所有磁盘块进行线性扫描【确实】。当目录只有几个磁盘块时，这是合理的，但对于包含许多文件的目录来说，开销巨大。Microsoft Windows的NTFS、Mac OS X的HFS和Solaris的ZFS（仅举几例）将目录实现为磁盘上块的平衡树。这很复杂，但可以保证目录查找在对数时间内完成（即时间复杂度为O(logn)）。

      -

      Xv6对于磁盘故障的解决很初级：如果磁盘操作失败，Xv6就会调用panic。这是否合理取决于硬件：如果操作系统位于使用冗余屏蔽磁盘故障的特殊硬件之上，那么操作系统可能很少看到故障，因此panic是可以的。另一方面，使用普通磁盘的操作系统应该预料到会出现故障，并能更优雅地处理它们，这样一个文件中的块丢失不会影响文件系统其余部分的使用。

      -

      Xv6要求文件系统安装在单个磁盘设备上，且大小不变。随着大型数据库和多媒体文件对存储的要求越来越高，操作系统正在开发各种方法来消除“每个文件系统一个磁盘”的瓶颈。基本方法是将多个物理磁盘组合成一个逻辑磁盘。RAID等硬件解决方案仍然是最流行的，但当前的趋势是在软件中尽可能多地实现这种逻辑。这些软件实现通常允许通过动态添加或删除磁盘来扩展或缩小逻辑设备等丰富功能。当然，一个能够动态增长或收缩的存储层需要一个能够做到这一点的文件系统：xv6使用的固定大小的inode块阵列在这样的环境中无法正常工作。将磁盘管理与文件系统分离可能是最干净的设计，但两者之间复杂的接口导致了一些系统（如Sun的ZFS）将它们结合起来。

      -

      Xv6的文件系统缺少现代文件系统的许多其他功能；例如，它缺乏对快照和增量备份的支持。

      -

      现代Unix系统允许使用与磁盘存储相同的系统调用访问多种资源：命名管道、网络连接、远程访问的网络文件系统以及监视和控制接口，如/proc。不同于xv6中fileread和filewrite的if语句，这些系统通常为每个打开的文件提供一个函数指针表【确实有印象】，每个操作一个，并通过函数指针来援引inode的调用实现。网络文件系统和用户级文件系统提供了将这些调用转换为网络RPC并在返回之前等待响应的函数。

      -

      （注：Linux 内核提供了一种通过/proc文件系统，在运行时访问内核内部数据结构、改变内核设置的机制。proc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。）

      -
      -

      Lab: file system

      -

      In this lab you will add large files【大文件支持】 and symbolic links【软链接】 to the xv6 file system.

      -

      不过做完这个实验，给我的一种感觉就是磁盘管理和内存管理真的有很多相似之处，不过也许它们所代表的思想也很普遍。

      -
      -

      Large files

      实验内容

      Overview
      -

      In this assignment you’ll increase the maximum size of an xv6 file.

      -

      Currently xv6 files are limited to 268 blocks, or 268*BSIZE bytes (BSIZE is 1024 in xv6). This limit comes from the fact that an xv6 inode contains 12 “direct” block numbers and one “singly-indirect” block number, which refers to a block that holds up to 256 more block numbers, for a total of 12+256=268 blocks.

      -

      You’ll change the xv6 file system code to support a “doubly-indirect” block in each inode, containing 256 addresses of singly-indirect blocks, each of which can contain up to 256 addresses of data blocks. The result will be that a file will be able to consist of up to 65803 blocks, or 256*256+256+11 blocks (11 instead of 12, because we will sacrifice one of the direct block numbers for the double-indirect block).

      -
      -
      Preliminaries
      -

      If at any point during the lab you find yourself having to rebuild the file system from scratch, you can run make clean which forces make to rebuild fs.img.

      -
      -
      What to Look At

      意思就是要我们去看一眼fs.h，bmap，以及了解一下逻辑地址bn如何转化为blockno。这个我是知道的。

      -
      Your Job
      -

      Modify bmap() so that it implements a doubly-indirect block, in addition to direct blocks and a singly-indirect block.

      -

      You’ll have to have only 11 direct blocks, rather than 12, to make room for your new doubly-indirect block; you’re not allowed to change the size of an on-disk inode.

      -

      The first 11 elements of ip->addrs[] should be direct blocks; the 12th should be a singly-indirect block (just like the current one); the 13th should be your new doubly-indirect block. You are done with this exercise when bigfile writes 65803 blocks and usertests runs successfully.

      +

      修改uvmcopy和uvmunmap

      // in uvmunmap()
          if((*pte & PTE_V) == 0){
            *pte = 0;
            continue;
          }
      // in uvmcopy()
          if((*pte & PTE_V) == 0)
            //panic("uvmcopy: page not present");
            continue;
      +]]> + + + Scheduling + /2023/01/10/xv6$chap7/ + Scheduling

      Code: Context switching

      xv6中，每个CPU中的scheduler都有一个专用的线程。这里线程的概念是，有自己的栈，有自己的寄存器状态。

      +

      当发生时钟中断时，当前进程调用yield，yield再通过swtch切换到scheduler线程。scheduler线程会通过swtch跳转到另外一个进程去执行。当另外一个进程发生时钟中断，又会通过yield回到scheduler，scheduler再调度原进程继续执行，如此周而复始。

      +
      +

      Linux的调度原理也差不多类似这样。每个CPU都有一个调度类为SCHED_CLASS_IDLE的IDLE进程，IDLE进程体大概就是间歇不断地执行__schedule()函数，CPU空闲时就会不断执行IDLE线程。

      +

      而当有新的任务产生时（或任务被唤醒。可以从此看出task new和task wakeup的共通点，可以联想到竞赛中对该消息的处理方法），它首先通过调度类对应的select_cpu选择一个合适的（可以被抢占&&在该task对应的cpumask中）的cpu，迁移到cpu对应的rq；目标cpu通过IDLE进程体或者中断返回时检查到了NEED_SCHEDULE标记位，从而调用schedule函数pick新任务，然后进行context_switch切换到目标线程。如此周而复始。

      -

      感想

      意外地很简单（）在此不多做赘述，直接上代码。

      -

      唯一要注意的一点就是记得在itrunc中free掉

      -

      image-20230124232433793

      -

      代码

      修改定义
      // in fs.h
      #define NDIRECT 11
      #define NINDIRECT (BSIZE / sizeof(uint))
      #define NDOUBLEINDIRECT ((BSIZE/sizeof(uint))*(BSIZE/sizeof(uint)))
      #define MAXFILE (NDIRECT + NINDIRECT + NDOUBLEINDIRECT)

      // On-disk inode structure
      struct dinode {
        // ...
        uint addrs[NDIRECT+2];   // Data block addresses
      };
      +

      image-20230118221757367

      +

      下面就来讲讲这个所谓的“线程”以及xv6的上下文切换是怎么实现的。

      +

      context

      上下文切换的操作对象是上下文，因而首先了解一下上下文的结构。各种寄存器的状态即是上下文context。xv6中的context定义如下:

      +
      struct context {
        uint64 ra;
        uint64 sp;

        // callee-saved
        uint64 s0;
        uint64 s1;
        uint64 s2;
        uint64 s3;
        uint64 s4;
        uint64 s5;
        uint64 s6;
        uint64 s7;
        uint64 s8;
        uint64 s9;
        uint64 s10;
        uint64 s11;
      };
      -
      // in file.h
      // in-memory copy of an inode
      struct inode {
        // ...
        uint addrs[NDIRECT+2];
      };
      +

      上下文切换需要修改栈和pc，context中确实有sp寄存器，但是没有pc寄存器，这主要还是因为当swtch返回时，会回到ra所指向的地方，所以仅保存ra就足够了。

      +

      swtch

      上下文的切换是通过swtch实现的。

      +
      void            swtch(struct context*, struct context*);
      -
      修改bmap()
      // in fs.c
      // 调试用
      static int cnt = 0;

      static uint
      bmap(struct inode *ip, uint bn)
      {
        uint addr, *a;
        struct buf *bp;

        if(bn < NDIRECT){
          if((addr = ip->addrs[bn]) == 0)
            ip->addrs[bn] = addr = balloc(ip->dev);
          return addr;
        }
        bn -= NDIRECT;

        if(bn < NINDIRECT){
          // Load indirect block, allocating if necessary.
          if((addr = ip->addrs[NDIRECT]) == 0)
            ip->addrs[NDIRECT] = addr = balloc(ip->dev);
          bp = bread(ip->dev, addr);
          a = (uint*)bp->data;
          if((addr = a[bn]) == 0){
            a[bn] = addr = balloc(ip->dev);
            log_write(bp);
          }
          brelse(bp);
          return addr;
        }
          
        // CODE HERE
        bn -= NINDIRECT;
        if(bn < NDOUBLEINDIRECT){
          // 调试用
          if(bn/10000 > cnt){
            cnt++;
            printf("double_indirect:%d\n",bn);
          }
          // 第一层
          if((addr = ip->addrs[NDIRECT+1]) == 0)
            ip->addrs[NDIRECT+1] = addr = balloc(ip->dev);
          // 第二层
          bp = bread(ip->dev,addr);
          a = (uint*)bp->data;
          if((addr = a[(bn >> 8)]) == 0){
            a[(bn >> 8)] = addr = balloc(ip->dev);
            log_write(bp);
          }
          brelse(bp);
          // 第三层
          bp = bread(ip->dev,addr);
          a = (uint*)bp->data;
          if((addr = a[(bn & 0x00FF)]) == 0){
            a[(bn & 0x00FF)] = addr = balloc(ip->dev);
            log_write(bp);
          }
          brelse(bp);
          return addr;
        }

        panic("bmap: out of range");
      }
      +

      swtch会把当前进程的上下文保存在第一个context中，再切换到第二个context保存的上下文，具体实现就是写读保存寄存器：

      +
      # in kernel/swtch.S
      # a0和a1分别保存着两个参数的值，也即第一个context的地址和第二个context的地址
      .globl swtch
      swtch:
              sd ra, 0(a0)
              sd sp, 8(a0)
              sd s0, 16(a0)
              sd s1, 24(a0)
              # ...
              sd s11, 104(a0)

              ld ra, 0(a1)
              ld sp, 8(a1)
              ld s0, 16(a1)
              ld s1, 24(a1)
              # ...
              ld 11, 104(a1)
              
              ret
      -
      修改itrunc
      // Truncate inode (discard contents).
      // Caller must hold ip->lock.
      void
      itrunc(struct inode *ip)
      {
        int i, j;
        struct buf *bp;
        uint *a;

        for(i = 0; i < NDIRECT; i++){
          if(ip->addrs[i]){
            bfree(ip->dev, ip->addrs[i]);
            ip->addrs[i] = 0;
          }
        }

        if(ip->addrs[NDIRECT]){
          bp = bread(ip->dev, ip->addrs[NDIRECT]);
          a = (uint*)bp->data;
          for(j = 0; j < NINDIRECT; j++){
            if(a[j])
              bfree(ip->dev, a[j]);
          }
          brelse(bp);
          bfree(ip->dev, ip->addrs[NDIRECT]);
          ip->addrs[NDIRECT] = 0;
        }

        // CODE HERE
        if(ip->addrs[NDIRECT+1]){
          bp = bread(ip->dev, ip->addrs[NDIRECT+1]);
          a = (uint*)bp->data;
          // 双层循环。这里其实不应该用NINDIRECT这个宏定义的，因为意义其实不大一样。
          // 但是由于数值一样，这里就先凑合着用了
          for(j = 0; j < NINDIRECT; j++){
            if(a[j]){
              struct buf* tmp_bp = bread(ip->dev,a[j]);
              uint* tmp_a = (uint*)tmp_bp->data;
              for(int k = 0;k < NINDIRECT; k++){
                if(tmp_a[k])
                  bfree(ip->dev,tmp_a[k]);
              }
              brelse(tmp_bp);
              bfree(ip->dev,a[j]);
            }
          }
          brelse(bp);
          bfree(ip->dev, ip->addrs[NDIRECT+1]);
          ip->addrs[NDIRECT+1] = 0;
        }

        ip->size = 0;
        iupdate(ip);
      }
      +

      sched

      在sleep、yield和wakeup中，都会通过sched中的swtch进入scheduler线程。

      +
      void
      sched(void)
      {
        int intena;
        struct proc *p = myproc();

        if(!holding(&p->lock))
          panic("sched p->lock");
        if(mycpu()->noff != 1)
          panic("sched locks");
        if(p->state == RUNNING)
          panic("sched running");
        if(intr_get()) // 当持有锁时一定为关中断状态
          panic("sched interruptible");

        intena = mycpu()->intena;
        swtch(&p->context, &mycpu()->context);
        mycpu()->intena = intena;
      }
      -
      -

      In this exercise you will add symbolic links to xv6.

      -

      Symbolic links (or soft links) refer to a linked file by pathname; when a symbolic link is opened, the kernel follows the link to the referred file.

      -

      Symbolic links resembles hard links, but hard links are restricted to pointing to file on the same disk, while symbolic links can cross disk devices.

      -

      Although xv6 doesn’t support multiple devices, implementing this system call is a good exercise to understand how pathname lookup works.

      -

      You will implement the symlink(char *target, char *path) system call, which creates a new symbolic link at path that refers to file named by target. For further information, see the man page symlink. To test, add symlinktest to the Makefile and run it.

      -
      +

      cpu中存储着的是scheduler线程的context。因而，这样就可以保存当前进程的context，读取scheduler线程的context，然后转换到scheduler的context执行了。

      -

      linux：硬链接和软链接

      -

      硬链接不会创建新的物理文件，但是会使得当前物理文件的引用数加1。当硬链接产生的文件存在时，删除源文件，不会清除实际的物理文件，即对于硬链接“生成的新文件”不会产生任何影响。

      -

      软链接就更像一个指针，只是指向实际物理文件位置，当源文件移动或者删除时，软链接就会失效。

      -

      【所以说，意思就是软链接不会让inode->ulinks++的意思？】

      +

      可以发现这里是有个很完美的组合技的。由sched()保存context到process结构体中，再由scheduler()读取process对应的context回归到sched()继续执行，我感觉调度设计这点真是帅的一匹。

      -

      感想

      这个实验比上个实验稍难一些，但也确实只是moderate的水平，其复杂程度主要来源于对文件系统的理解，还有如何判断环，以及对锁的获取和释放的应用。我做这个实验居然是没看提示的【非常骄傲<-】，让我有一种自己水平上升了的感觉hhh

      -
      正确思路

      本实验要求实现软链接。首先需要实现创建软链接：写一个系统调用 symlink(char *target, char *path) 用于创建一个指向target的在path的软链接；然后需要实现打开软链接进行自动的跳转：在sys_open中添加对文件类型为软链接的特殊处理。

      -
      初见思路

      我的初见思路是觉得可以完全参照sys_link来写。但其实还是很不一样的。

      -

      sys_link的逻辑：

      -
        -
      1. 获取old的inode
        2. -
      2. 获取new所在目录的inode，称为dp
        3. -
      3. 在dp中添加一项entry指向old
        4. -
      -

      sys_symlink的逻辑：

      +

      scheduler

      void
      scheduler(void)
      {
        struct proc *p;
        struct cpu *c = mycpu();

        c->proc = 0;
        for(;;){
          // Avoid deadlock by ensuring that devices can interrupt.
          intr_on();

          int nproc = 0;
          for(p = proc; p < &proc[NPROC]; p++) {
            acquire(&p->lock);
            if(p->state != UNUSED) {
              nproc++;
            }
            if(p->state == RUNNABLE) {
              // Switch to chosen process.  It is the process's job
              // to release its lock and then reacquire it
              // before jumping back to us.
              p->state = RUNNING;
              c->proc = p;
              swtch(&c->context, &p->context);

              // Process is done running for now.
              // It should have changed its p->state before coming back.
              c->proc = 0;
            }
            release(&p->lock);
          }
          if(nproc <= 2) {   // only init and sh exist
            intr_on();
            asm volatile("wfi");
          }
        }
      }
      + +

      通过swtch进入scheduler线程后，会继续执行scheduler中swtch的下一个指令，完成下一次调度。

      +

      一些补充

      以上是书本的介绍内容。看到这想必会有很多疑惑，至少有以下两点：

        -

      1. 通过path创建一个新的inode，作为软链接的文件

        -

        这里选择新建inode，而不是像link那样做，主要还是为了能遵从symlinktest给的接口使用方法（朴实无华的理由）。而且这么做也很方便，符合“一切皆文件”的思想，也能简单化对其在open中的处理。

        -
        2. -

      2. 在inode中填入target的地址

        -

        我们可以把软链接视为文件，文件内容是其target的path。

        -
        3. +
      3. 为什么cpu->context会存储着scheduler的上下文？这是什么时候，又是怎么初始化的？
        4. +
      4. 为什么从sched中swtch会来到scheduler中swtch的下一句？
      -

      可以说是毫不相干，所以还是直接自起炉灶比较好。

      -
      一些错误

      其实没什么好说的，虽然debug过程挺久，但是靠常规的printf追踪就都可以看出来是哪里错了。下面我说说一个我印象比较深刻的吧。

      -

      symlinktest中有一个检测点是，软链接不能成环，也即b->a->b是非法的。于是，我就选择了用快慢指针来检测环形链表这个思想，用来看是否出现环。

      -

      在symlinktest的另一个检测点中：

      -

      image-20230125173143735

      -

      我出现了如下错误：

      -

      image-20230125162542807

      -

      此时的结构是1[27]->2[28]->3[29]->4，[]内为inode的inum。

      -

      快慢指针的实现方式是当cnt为奇数的时候，慢指针才会移动。而上图中，cnt==0时，两个指针的值都发生了变化，这就非常诡异。

      -

      这其实是因为slow指针所指向的那个inode被释放了，然后又被fast指针的下一个inode捡过来用了，从而导致值覆盖。

      -

      为什么会被释放呢？

      -
            // 快指针移动
            readi(ip,0,(uint64)path,0,MAXPATH);
            iunlock(ip);
            if((ip = namei(path)) == 0){
              end_op();
              return -1;
            }
      // 在这里！！！
            ilockput(ip);
      - -

      在这里，我错误地调用了ilockput，从而使inode的ref–，使得它在下一次fast指针调用namei，namei调用iget时，该inode被当做free inode使用，于是就这么寄了。

      -

      所以我们需要把ilockput的调用换成ilock，这样一来就能防止inode被free。至于什么时候再iput？我想还是交给操作系统启动时的清理工作来做吧23333【开摆】

      -

      代码

      image-20230125165612112

      -
      添加定义
      fcntl.c

      open参数

      -
      // 意为只用获取软链接文件本身，而不用顺着软链接去找它的target文件
      #define O_NOFOLLOW 0x100
      - -
      stat.h

      文件类型

      -
      #define T_DIR     1   // Directory
      #define T_FILE    2   // File
      #define T_DEVICE  3   // Device
      #define T_SYMLINK  4   // symbol links
      - -
      添加sys_symlink系统调用
      // in sysfile.c
      uint64
      sys_symlink(void)
      {
        char target[MAXPATH], path[MAXPATH];
        struct inode *ip;

        if(argstr(0, target, MAXPATH) < 0 || argstr(1, path, MAXPATH) < 0)
          return -1;

        begin_op();

        // 创建软链接结点
        ip = create(path,T_SYMLINK,0,0);
        //printf("symlink:before writei,inum = %d\n",ip->inum);
        // 此处可以防止住一些并发错误
        if(ip ==0){
          end_op();
          return 0;
        }
        // 向软链接结点文件内写入其所指向的路径
        writei(ip,0,(uint64)target,0,MAXPATH);
        //printf("symlink:after writei\n");
          
        // 软链接不需要让nlink++
          
        // 记得要释放在create()中申请的锁
        iunlockput(ip);

        end_op();

        return 0;
      }
      +

      先从第一点入手。实际上，这个初始化的工作，是在操作系统启动时的main.c中完成的。

      +
      void
      main()
      {
        if(cpuid() == 0){
          // ...
        } else {
          // ...
        }

        scheduler();        
      }
      -
      修改open
      uint64
      sys_open(void)
      {
        // ...

        begin_op();

        if(omode & O_CREATE){
          ip = create(path, T_FILE, 0, 0);
          if(ip == 0){
            end_op();
            return -1;
          }
        } else {
          // 软链接不可能是以O_CREATE的形式创建的
          if((ip = namei(path)) == 0){
            end_op();
            return -1;
          }
          ilock(ip);
          if(ip->type == T_DIR && omode != O_RDONLY){
            iunlockput(ip);
            end_op();
            return -1;
          }

          // 修改从这里开始
          // 快慢指针
          // ip为快指针，slow为慢指针
          uint cnt = 0;
          struct inode* slow = ip;
          // 可能有多重链接，因而需要持续跳转
          while(ip->type == T_SYMLINK){
            //printf("slow = %d,fast = %d,cnt = %d\n",slow->inum,ip->inum,cnt);
            // 其实这个只需要检测一次就够了。但为了编码方便，仍然把它保留在while循环中
            if(omode & O_NOFOLLOW){
              break;
            }else{
              // 检测到cycle
              if(slow == ip && cnt!=0){
                iunlockput(ip);
                end_op();
                return -1;
              }
              // 快指针移动
              readi(ip,0,(uint64)path,0,MAXPATH);
              // 此处不能用iunlockput()，具体原因见 感想-一些错误
              iunlock(ip);
              if((ip = namei(path)) == 0){
                end_op();
                return -1;
              }
              ilock(ip);
              // 慢指针移动
              // 注意，我慢指针移动的时候没有锁保护，因为用锁太麻烦了（）其实还是用锁比较合适
              if(cnt & 1){
                //printf("%d\n",cnt);
                readi(slow,0,(uint64)path,0,MAXPATH);
                if((slow = namei(path) )== 0){
                  end_op();
                  return -1;
                }
              }
              cnt++;
            }
          }
          // 当跳出循环时，此时的ip必定是锁住的
        }

        if(ip->type == T_DEVICE && (ip->major < 0 || ip->major >= NDEV)){
          iunlockput(ip);
          end_op();
          return -1;
        }
        // ...
      }
      +

      在这之前，创建了第一个进程proc。在这里，每个cpu都调用了scheduler。

      +
      void
      scheduler(void)
      {
        struct proc *p;
        struct cpu *c = mycpu();

        c->proc = 0;
        for(;;){
          intr_on();

          int nproc = 0;
          for(p = proc; p < &proc[NPROC]; p++) {
            acquire(&p->lock);
            // ...
            if(p->state == RUNNABLE) {
              p->state = RUNNING;
              c->proc = p;
              swtch(&c->context, &p->context);

              c->proc = 0;
            }
            release(&p->lock);
          }
          // ...
        }
      }
      -

      Lab mmap

      -

      The mmap and munmap system calls allow UNIX programs to exert detailed control over their address spaces.

      -

      They can be used to:

      +

      每个cpu都在scheduler线程的swtch(&c->context, &p->context);中，将当前的context，也即scheduler的context存入了mycpu()->context。随后，CPU中的某个去执行下一个进程，其他的就在scheduler线程的无限循环中等待，直到有别的进程产生。

      +

      去执行进程的CPU通过swtch切换上下文，切到了另一个进程中，此时在swtch中保存的ra是scheduler线程的swtch的下一句（因为scheduler->swtch也是个函数调用的过程）。会切到另一个进程的sched的下一句【因为它正是从那边swtch过来的】，或者是那个进程开始执行的地方【下面会提到是forkret】。另一个进程通过sched切换回来的时候，就正会切到ra所指向的位置，也即切到scheduler中的swtch后面。

      +

      这样一来，两个问题就都得到了解答。

      +

      从这，我们也能知道xv6是如何让CPU运转的：scheduler线程是CPU的IDLE状态。无事的时候在scheduler中等待，并且一直监测是否有进程需要执行。有的话，则去执行该进程；该进程又会通过sched切换回scheduler线程，继续等待。这样一来，就完成了进程管理的基本的自动机图像。

      +

      Code: Scheduling

      sched前要做的事

      +

      A process that wants to give up the CPU must do three things:

        -
      1. share memory among processes
        2. -
      2. map files into process address spaces
        3. -
      3. as part of user-level page fault schemes such as the garbage-collection algorithms discussed in lecture.
        4. +
      4. acquire its own process lock p->lock, release any other locks it is holding
        5. +
      5. update its own state (p->state)
        6. +
      6. call sched
      -

      In this lab you’ll add mmap and munmap to xv6, focusing on memory-mapped files.

      -

      mmap是系统调用，在用户态被使用。我们这次实验仅实现mmap功能的子集，也即memory-mapped files。

      +

      yield (kernel/proc.c:515) follows this convention, as do sleep and exit.

      +

      sched double-checks those conditions (kernel/proc.c:499-504) and then an implication of those conditions: since a lock is held, interrupts should be disabled.

      +

      sched与scheduler

      在上面的描述我们可以看到，sched和scheduler联系非常密切，他们俩通过swtch相互切来切去，并且一直都只在这几行切来切去：

      +
      // in scheduler()
      swtch(&c->context, &p->context);
      c->proc = 0;
      // in sched()
      swtch(&p->context, &mycpu()->context);
      mycpu()->intena = intena;
      + +

      在两个线程之间进行这种样式化切换的过程有时被称为协程（coroutines）。

      -

      declaration for mmap:

      -
      void *mmap(void *addr, size_t length, int prot, int flags,
           int fd, off_t offset);
      +

      存在一种情况使得调度程序对swtch的调用没有以sched结束。一个新进程第一次被调度时，它从forkret（kernel/proc.c:527）开始。Forkret是为了释放p->lock而包装的，要不然，新进程可以从usertrapret开始。

      +
      +

      p->lock保证了并发安全性

      +

      考虑调度代码结构的一种方法是，它为每个进程强制维持一个不变性条件的集合，并在这些不变性条件不成立时持有p->lock。

      +

      其中一个不变性条件是：如果进程是RUNNING状态，计时器中断的yield必须能够安全地从进程中切换出去；这意味着CPU寄存器必须保存进程的寄存器值（即swtch没有将它们移动到context中），并且c->proc必须指向进程。另一个不变性条件是：如果进程是RUNNABLE状态，空闲CPU的调度程序必须安全地运行它；这意味着p->context必须保存进程的寄存器（即，它们实际上不在实际寄存器中），没有CPU在进程的内核栈上执行，并且没有CPU的c->proc引用进程。

      +

      维护上述不变性条件是xv6经常在一个线程中获取p->lock并在另一个线程中释放它的原因，在保持p->lock时，这些属性通常不成立。

      +

      例如在yield中获取并在scheduler中释放。一旦yield开始修改一个RUNNING进程的状态为RUNNABLE，锁必须保持被持有状态，直到不变量恢复：最早的正确释放点是scheduler（在其自身栈上运行）清除c->proc之后。类似地，一旦scheduler开始将RUNNABLE进程转换为RUNNING，在内核线程完全运行之前（在swtch之后，例如在yield中）绝不能释放锁。

      +

      p->lock还保护其他东西：exit和wait之间的相互作用，避免丢失wakeup的机制（参见第7.5节），以及避免一个进程退出和其他进程读写其状态之间的争用（例如，exit系统调用查看p->pid并设置p->killed(kernel/proc.c:611)）。为了清晰起见，也许为了性能起见，有必要考虑一下p->lock的不同功能是否可以拆分。

      +
      +

      p->lock在每次scheduler开始的时候获取，swtch到p进程的时候在yield等调用完sched的地方释放。而调用yield时获取的锁，又会在scheduler中释放。

      +
      // Give up the CPU for one scheduling round.
      void
      yield(void)
      {
        struct proc *p = myproc();
        acquire(&p->lock);// 该锁会在scheduler中释放
        p->state = RUNNABLE;
        sched();
        release(&p->lock);// 该锁释放的是scheduler中得到的锁
      }
      +
      // in kernel/proc.c scheduler()
      	  acquire(&p->lock);// 该锁会在yield等地被释放
              // ...
              swtch(&c->context, &p->context);
      		// ...
            release(&p->lock);// 该锁会释放yield等地中获得的锁
      + +

      不得不说，这结构实在是太精妙了。这中间的如此多的复杂过程，就这样成功地被锁保护了起来。

      +

      Code: mycpu and myproc

      // Per-CPU state.
      struct cpu {
        struct proc *proc;          // The process running on this cpu, or null.
        struct context context;     // swtch() here to enter scheduler().
        int noff;                   // Depth of push_off() nesting.
        int intena;                 // Were interrupts enabled before push_off()?
      };
      + +

      mycpu是通过获取当前cpuid来获取cpu结构的。当前使用的cpuid约定俗成地存在了tp寄存器里。为了让mycpu有效工作，必须确保tp寄存器始终存放的是当前cpu的hartid。

      +

      首先是在操作系统初始化的时候要把cpuid存入tp寄存器。RISC-V规定，mhartid也即cpuid的存放点只能在machine mode被读取。因而这项工作得在start.c中完成：

      +
      // in kernel/start.c 
        // keep each CPU's hartid in its tp register, for cpuid().
        int id = r_mhartid();
        w_tp(id);
      // in kernel/riscv.h
      // which hart (core) is this?
      static inline uint64
      r_mhartid()
      {
        uint64 x;
        asm volatile("csrr %0, mhartid" : "=r" (x) );
        return x;
      }
      + +

      在内核态中，编译器被设置为保证不会以其他方式使用tp寄存器。因而初始化之后，内核态中每个CPU的tp寄存器就始终存放着自己的cpuid。

      +

      但这在用户进程是不成立的。因而必须在用户进程进入陷阱的时候做一些工作。

      +
      # in kernel/trampoline.S uservec
      sd tp, 64(a0)
      # make tp hold the current hartid, from p->trapframe->kernel_hartid
      ld tp, 32(a0)
      + +
      struct trapframe {
        /*  32 */ uint64 kernel_hartid; // saved kernel tp
        /*  64 */ uint64 tp;
          // ...
      }
      + +

      必须在trampoline保存用户态中使用的tp值，以及内核态中对应的hartid。

      +

      最后再在返回用户态的时候恢复用户态的tp值以及更新trampoline的tp值。

      +
      // in kernel/trap.c usertrapret()
      p->trapframe->kernel_hartid = r_tp();         // hartid for cpuid()
      + +
      # in trampoline.S userret
      ld tp, 64(a0)
      + +

      注意，更新trampoline的tp值这一步很重要。因为如果在用户态发生的是时钟中断，就会引起yield，可能造成CPU的切换。这时候就需要在返回用户态的时候修改一下trapframe中的tp为当前CPU的tp。这样一来才能保证，在本次时钟中断结束，以及到下一次时钟中断修改CPU这一期间，trapframe中的tp寄存器以及内核态中的tp寄存器都是正确的。

      +

      通过mycpu()获取cpuid其实是非常脆弱的。因为你可能获取完cpuid，进程就被切到别的CPU去执行了，这就会有一个先检查后执行的竞态条件，具有并发安全隐患。因而，xv6要求使用mycpu()返回值的这段代码需要关中断，这样就可以避免时钟中断造成的进程切换了。比如说像myproc()这样：

      +
      // Return the current struct proc *, or zero if none.
      struct proc*
      myproc(void) {
        push_off();
        struct cpu *c = mycpu();
        struct proc *p = c->proc;
        pop_off();
        return p;
      }
      + +

      注意，不同于mycpu()，使用myproc()的返回值不需要进行开关中断保护。因为当前进程的指针不论处于哪个CPU都是不变的。

      +

      Sleep and wakeup

      前面我们已经介绍了进程隔离性的基本图像，接下来要讲xv6是如何让进程之间互动的。xv6使用的是经典的sleep and wakeup，也叫序列协调（sequence coordination）或条件同步机制（conditional synchronization mechanisms。下面，将从最基本的自旋锁实现信号量开始，来逐步讲解xv6的sleep and wakeup机制。

      +

      自旋锁实现信号量

      image-20230120150659730

      +

      image-20230120150715925

      +

      缺点就是自旋太久了，因而我们需要在等待的时候调用yield，直到资源生产出来之后再继续执行。

      +

      不安全的sleep and wakeup

      +

      Let’s imagine a pair of calls, sleep and wakeup, that work as follows:

        -

      1. 参数

        -
          -

        1. addr is always zero.

          -

          You can assume that addr will always be zero, meaning that the kernel should decide the virtual address at which to map the file.【addr由kernel决定，因而用户态只需传入0即可】

          -
          2. -

        2. length is the number of bytes to map

          -

          Might not be the same as the file’s length.

          -
          3. -

        3. prot indicates whether the memory should be mapped readable, writeable, and/or executable.

          -

          you can assume that prot is PROT_READ or PROT_WRITE or both.

          -
          4. -

        4. flags has two values.

          -
            -

          1. MAP_SHARED

            -

            meaning that modifications to the mapped memory should be written back to the file,

            -

            如果标记为此，则当且仅当file本身权限为RW或者WRITABLE的时候，prot才可以标记为PROT_WRITE

            -
            2. -

          2. MAP_PRIVATE

            -

            meaning that they should not.

            -

            如果标记为此，则无论file本身权限如何，prot都可以标记为PROT_WRITE

            -
            3. -
          -
          5. -

        5. You can assume offset is zero (it’s the starting point in the file at which to map)

          -
          6. -
        +

      2. sleep(chan)

        +

        Sleeps on the arbitrary value chan, called the wait channel. Sleep puts the calling process to sleep, releasing the CPU for other work.

        3. -

      3. return

        -

        mmap returns that kernel-decided address, or 0xffffffffffffffff if it fails.

        +

      4. wakeup(chan)

        +

        Wakes all processes sleeping on chan (if any), causing their sleep calls to return. If no processes are waiting on chan, wakeup does nothing.

      -

      如果两个进程同时对某个文件进行memory map，那么这两个进程可以不共享物理页面。

      +

      这样一来，信号量实现就可修改为这样了：

      +

      image-20230120151051989

      +

      但是，我们可以注意到，在212-213行这里产生了一个先检查后执行的竞态条件。

      -

      munmap(addr, length) should remove mmap mappings in the indicated address range.

      -

      If the process has modified the memory and has it mapped MAP_SHARED, the modifications should first be written to the file. 【如果两个进程的修改发生冲突了怎么办？】

      -

      An munmap call might cover only a portion of an mmap-ed region, but you can assume that it will either unmap at the start, or at the end, or the whole region (but not punch a hole in the middle of a region).

      +

      如果消费者进程执行到212-213中间，此时生产者进程已经调用结束，也就是说wakeup并没有唤醒任何消费者进程。消费者进程就会一直在sleep中没人唤醒，除非生产者进程再执行一次。这样就会造成lost wake-up 这个问题。

      -

      感想

      这个实验做得我……怎么说，感觉非常地难受吧。虽然我认为我这次做得挺不错的，因为我没有怎么看hints，我的代码差不多全都是我自己想出来的，没有依赖保姆级教学，我认为是一个很好的进步。不过，正因为我没有看hints，导致我的想法比起答案来思路非常地奇诡，导致我第一次错误想法写了一天，看了hints后决心痛改前非，结果第二次错误想法又写了一天emmm

      -

      下面的第一个代码版本虽然可以过掉mmaptest，但确实还是有一个很致命的bug，并且lazy也没有lazy到位，最后的版本离正确思路还有偏差，也就是下面放的第一个代码版本是错误的，但我认为它也不是完全没有亮点。第二个版本才是经过改正的正确版本，但写得着实有点潦草。

      -

      笔记整理得也有点匆忙，毕竟我真的话比较多而且心里很烦。总之，先记录我的全部思路过程，至于价值如何，先不管了2333

      -

      初见思路

      所以说，我们要做的，就是实现一个系统调用mmap，在mmap中，应该首先申请几页用来放file的内容，并且在页表中填入该项，然后再返回该项的虚拟地址。然后在munmap中，再将该file页内容写入file。

      -

      也就是说，直接在mmap把文件的全部内容写入内存，然后各进程读写自己的那块内容块，最后在munmap的时候把修改内容写入文件然后释放该内存块就行了

      -
      问题：在哪里放置file的内容

      题目要求the kernel should decide the **virtual address** at which to map the file.也就是说，在我们的mmap中，需要决定我们要讲文件内容放在哪里。那要放在哪呢……

      -

      我第一反应很奇葩：扫描页表，找到空闲页。但我自己也知道这样不可行，文件内容不止一页，这种零零散散存储需要的数据结构实现起来太麻烦了。

      -

      那怎么办？可以在heap内分配。那么到底怎么样才能在heap里分配？你该怎么知道heap哪里开始是空闲的，哪里是用过的，不还是得扫描页表吗？【思维大僵化】

      -

      其实……道理很简单。我们之间把proc->sz作为mapped-file的起始地址就好了。相信看到这里，你也明白这是什么原理了。能想到这个，我感觉确实很不容易。

      -

      正确思路

      初见思路虽然简单，但是很粗暴，如果文件很大，宝贵的内存空间就会被我们浪费。所以我们借用lazy allocation的思想，先建立memory-file的映射，再在缺页中断中通过文件读写申请内存空间，把文件内容读入内存。

      -

      问题就在于如何“先建立memory-file的映射”。在lazy allocation中，我们是先填好所有的对应页表项，仅是不申请对应的物理内存，也即占着XX不XX。在这次实验中，我们也是这么做，只不过新增了一个难点，那就是如何管理这些页。因为lazy allocation页与页之间没有比较紧密的关系，但是在mmap中页却可以被所属文件这个关键字划分。因而，我们需要一个数据结构，来给页分门别类地组织在一起，并且记录它们的meta data比如说所属文件之类的，这也就是hints里的VMA结构，也即我的filemap结构。

      -

      我们可以将这样的数据结构池化，并且存储在proc域中，以避免对象的重复创建。

      +

      所以，我们可以选择把这个竞态条件也放入s->lock这个锁区域保护。

      +

      image-20230120151353712

      +

      但是这样一来又会产生死锁问题。因而，我们可以尝试着修改sleep和wakeup的接口定义。

      +

      sleep and wakeup

      +

      We’ll fix the preceding scheme by changing sleep’s interface:

      +

      The caller must pass the condition lock to sleep so it can release the lock after the calling process is marked as asleep and waiting on the sleep channel. The lock will force a concurrent V to wait until P has finished putting itself to sleep, so that the wakeup will find the sleeping consumer and wake it up. Once the consumer is awake again sleep reacquires the lock before returning.

      +

      也即在sleep中：

      +
      sleep(s,&s->lock){
       // do something
      	release(&s->lock);
      	//wait until wakeup
       acquire(&s->lock);
       return;
      }
      +
      +

      这样一来，信号量就可以完美实现了：

      +

      image-20230120151807102

      +

      image-20230120151820455

      -

      我的lazy法与别人不大一样……我没有想得像他们那么完美。我的做法是，在需要读某个地址的文件内容时，直接确保这个地址前面的所有文件内容都读了进来。也即在filemap中维护一个okva，表明vaokva这段内存已经读入，之后就仅需再读入okvaneed_va这段地址就行。这样虽然lazy了，但没完全lazy。

      -

      我认为这不能体现lazy的思想……因为一读读一坨，还是很占空间啊。

      +

      注：严格地说，wakeup只需跟在acquire之后就足够了（也就是说，可以在release之后调用wakeup）

      +

      【想了一下，有一说一确实，放在release前后都不影响】

      -

      因而，我们需要做的就是：

      -
        -

      1. 在mmap中将信息填入该数据结构

        -
          -
        1. 依据传入的长度扩容proc，原sz作为mapped-file起始地址va
          2. -
        2. 从对象池中寻找到一个空闲的filemap，对其填写信息
          3. -
        3. 返回1所得的va
          4. -
        -

        在我的代码中，还针对proc->sz不满足page-align做出了对策：先把文件的PGROUNDUP(sz)-sz这部分的信息读入，并且更新okva，这样一来，之后在usertrap中，就可以从okva开始一页页地分配地址，做到自然地page-align了。

        -

        为什么要对不满足page-align的情况进行处理？

        -

        这是因为，growproc的时候一次性扩充一页，但proc->sz却可以不满足page-align，也就是说，proc->sz所处的这一页已经被分配了。

        -

        在我们的lazy思路中，我们如果不预先读入文件页，是只能等待用户陷入缺页中断的情况下才能读入文件内容。

        -

        但是，proc->sz这一页已经被分配了。因而，在用户态读取这一页地址的时候，并不会发生缺页中断。因而，就会发生文件内容未读入，用户读到脏数据的情况。

        -

        其实还有一种更简单的办法可以强制page-align，那就是，直接让起始地址为PGROUNDUP(proc->sz)……至于为什么我不用这个，而要写这么多麻烦的东西呢？答案是我没想到。（）

        +

        原始Unix内核的sleep只是禁用了中断，这就足够了，因为Unix运行在单CPU系统上。因为xv6在多处理器上运行，所以它为sleep添加了一个显式锁。

        -
        2. -

      2. 在usertrap增加对缺页中断的处理

        +

        Code: Sleep and wakeup

        // Atomically release lock and sleep on chan.
        // Reacquires lock when awakened.
        void
        sleep(void *chan, struct spinlock *lk)
        {
          struct proc *p = myproc();

          // Must acquire p->lock in order to
          // change p->state and then call sched.
          // Once we hold p->lock, we can be
          // guaranteed that we won't miss any wakeup
          // (wakeup locks p->lock),
          // so it's okay to release lk.
          if(lk != &p->lock){  //DOC: sleeplock0
            // 获取进程锁，释放外部锁
            // 此进程锁将在scheduler线程中释放
            acquire(&p->lock);  //DOC: sleeplock1
            release(lk);
          }

          // Go to sleep.
          p->chan = chan;
          p->state = SLEEPING;

          sched();
          // 到这里来，说明已经被wakeup且被调度了

          // Tidy up.
          p->chan = 0;

          // Reacquire original lock.
          if(lk != &p->lock){
            //释放进程锁，获取外部锁
            // 此进程锁是在scheduler中获取到的
            release(&p->lock);
            acquire(lk);
          }
        }
        + +

        注意，如果lk为p->lock，那么lk依然会在scheduler线程中被暂时释放。

        +
        // Wake up all processes sleeping on chan.
        // Must be called without any p->lock.
        void
        wakeup(void *chan)
        {
          struct proc *p;

          for(p = proc; p < &proc[NPROC]; p++) {
            acquire(&p->lock);
            if(p->state == SLEEPING && p->chan == chan) {
              p->state = RUNNABLE;
            }
            release(&p->lock);
          }
        }
        + +

        可以注意到，关于chan这一变量的取值是非常任意的，仅需取一个约定俗成的值就OK。这里取为了信号量的地址，同时满足了逻辑需求和语义需求。

        +
        +

        Callers of sleep and wakeup can use any mutually convenient number as the channel. Xv6 often uses the address of a kernel data structure involved in the waiting.

        +
        +

        这里也解释了为什么需要while循环

        +
        +

        有时，多个进程在同一个通道上睡眠；例如，多个进程读取同一个管道。一个单独的wakeup调用就能把他们全部唤醒。其中一个将首先运行并获取与sleep一同调用的锁，并且（在管道例子中）读取在管道中等待的任何数据。尽管被唤醒，其他进程将发现没有要读取的数据。从他们的角度来看，醒来是“虚假的”，他们必须再次睡眠。因此，在检查条件的循环中总是调用sleep。

        +
        +

        Code: Pipes

        pipes很显然就是生产者消费者模式的一个例证。

        +
        struct pipe {
          struct spinlock lock;
          char data[PIPESIZE];
          uint nread;     // number of bytes read
          uint nwrite;    // number of bytes written
          int readopen;   // read fd is still open
          int writeopen;  // write fd is still open
        };
        + +
        int
        piperead(struct pipe *pi, uint64 addr, int n)
        {
          int i;
          struct proc *pr = myproc();
          char ch;

          acquire(&pi->lock);
          while(pi->nread == pi->nwrite && pi->writeopen){  //DOC: pipe-empty并且依然有进程在写
            if(pr->killed){
              release(&pi->lock);
              return -1;
            }
            // 等待直到pipe不为空
            sleep(&pi->nread, &pi->lock); //DOC: piperead-sleep
          }
          for(i = 0; i < n; i++){  //DOC: piperead-copy
            if(pi->nread == pi->nwrite)
              break;
            ch = pi->data[pi->nread++ % PIPESIZE];
            if(copyout(pr->pagetable, addr + i, &ch, 1) == -1)
              break;
          }
          // 唤醒写入管道的进程
          wakeup(&pi->nwrite);  //DOC: piperead-wakeup
          release(&pi->lock);
          return i;
        }
        + +
        int
        pipewrite(struct pipe *pi, uint64 addr, int n)
        {
          int i;
          char ch;
          struct proc *pr = myproc();

          acquire(&pi->lock);
          for(i = 0; i < n; i++){
            while(pi->nwrite == pi->nread + PIPESIZE){  //DOC: pipewrite-full管道满则阻塞
              if(pi->readopen == 0 || pr->killed){
                release(&pi->lock);
                return -1;
              }
              // 唤醒读取管道的进程
              wakeup(&pi->nread);
              sleep(&pi->nwrite, &pi->lock);
            }
            if(copyin(pr->pagetable, &ch, addr + i, 1) == -1)
              break;
            pi->data[pi->nwrite++ % PIPESIZE] = ch;
          }
          wakeup(&pi->nread);
          release(&pi->lock);
          return i;
        }
        + +

        一个非常有意思且巧妙的点，就是读写管道等待在不同的chan上，这与上面信号量的例子是不一样的。想想也确实，如果使用同一个管道的话，当唤醒的时候，就会把不论是读还是写的全部进程都唤醒过来，这对性能显然损失较大。

        +
        +

        The pipe code uses separate sleep channels for reader and writer (pi->nread and pi->nwrite); this might make the system more effificient in the unlikely event that there are lots of readers and writers waiting for the same pipe.

        +
        +

        Code: Wait, exit, and kill

        exit和wait

        +

        Sleep和wakeup可用于多种等待。第一章介绍的一个有趣的例子是子进程exit和父进程wait之间的交互。

        +

        xv6记录子进程终止直到wait观察到它的方式是让exit将调用方置于ZOMBIE状态，在那里它一直保持到父进程的wait注意到它，将子进程的状态更改为UNUSED，复制子进程的exit状态码，释放子进程，并将子进程ID返回给父进程。

        +

        如果父进程在子进程之前退出，则父进程将子进程交给init进程，init进程将永久调用wait；因此，每个子进程退出后都有一个父进程进行清理。

        +
        +

        又是一个生产者消费者模式。只不过此时的chan是父进程，资源是僵尸子进程【草】。由于涉及到进程间的调度切换，因而实现稍微复杂了点。

        +

        为什么需要涉及到进程间的调度呢？子进程设置完僵尸状态后，直接通过函数ret不行吗？答案是不行，因为ret的话就会去到不知道哪的地方【大概率会变成scause=2的情况】，所以这里子进程想要退出，就得做几件事，一是依靠父进程，让父进程杀死子进程，二是把自己设置为一个特殊的状态，使得自己不会被调度从而执行ret指令出错，三是尽快让父进程杀死自己越快越好。综合上述三个原因，exit最终在调度方面的实现方式，就变成了，子进程设置自己为ZOMBIE态->启用调度->父进程杀死ZOMBIE态的子进程。这期间不变性条件的防护，就得依赖于锁，以及sleep和wakeup了。

        +
        void
        exit(int status)
        {
          struct proc *p = myproc();
          
          // ...
            
          // we need the parent's lock in order to wake it up from wait().
          // the parent-then-child rule says we have to lock it first.
          // 整个xv6都必须遵守相同的顺序（父级，然后是子级）不论是锁定还是释放，都是先父再子
          acquire(&original_parent->lock);
          acquire(&p->lock);

          // Give any children to init.
          // 把自己的所有孩子都托付给init进程
          // init进程就是在操作系统启动时
          reparent(p);

          // Parent might be sleeping in wait().
          // 唤醒wait中的父进程
          // 这里看上去很诡异，明明子进程状态还未完全，怎么就唤醒父亲了呢？但其实很安全。
          // 此时子进程仍持有父进程的锁，如果有别的CPU中断进入scheduler线程，到父进程那时会卡在aquire
          // 直到子进程完成后续工作后父进程才能被真正唤醒执行
          wakeup1(original_parent);

          p->xstate = status;
          // 设为ZOMBIE态
          p->state = ZOMBIE;

          // 完成后续工作，解除父进程的锁
          release(&original_parent->lock);

          // Jump into the scheduler, never to return.
          // 子进程会在父进程中被释放，所以永远不会回来
          sched();
          panic("zombie exit");
        }
        + +
        int
        wait(uint64 addr)
        {
          struct proc *np;
          int havekids, pid;
          struct proc *p = myproc();

          // hold p->lock for the whole time to avoid lost
          // wakeups from a child's exit().
          acquire(&p->lock);

          for(;;){
            // Scan through table looking for exited children.
            havekids = 0;
            for(np = proc; np < &proc[NPROC]; np++){
              // this code uses np->parent without holding np->lock.
              // acquiring the lock first would cause a deadlock,
              // since np might be an ancestor, and we already hold p->lock.
              // 下面的第一点其实一句话就可以搞定：
              // 【它违反了先获取父亲锁，再获取子锁的xv6代码规定】
              // 1.要是在这句话之前acquire的话，acquire到你爸，你爸这时候也刚好执行到这句话
              // 那么就会造成你在自旋【此时你爸在wait一开始就得到了锁】，
              // 你爸也在自旋【你也在wait一开始得到了锁】,这样就造成了死锁
              // 2.并且由于np->parent只有parent才能改，所以数据是否过时是没关系的
              // 因为如果不是你儿子，数据过时与否都知道不是你儿子
              // 如果是你儿子，那数据压根就不会过时
              if(np->parent == p){
                // np->parent can't change between the check and the acquire()
                // because only the parent changes it, and we're the parent.
                acquire(&np->lock);
                havekids = 1;
                if(np->state == ZOMBIE){
                  // Found one.
                  pid = np->pid;
                  // 传递返回参数
                  if(addr != 0 && copyout(p->pagetable, addr, (char *)&np->xstate,
                                          sizeof(np->xstate)) < 0) {
                    release(&np->lock);
                    release(&p->lock);
                    return -1;
                  }
                  freeproc(np);
                  release(&np->lock);
                  release(&p->lock);
                  return pid;
                }
                release(&np->lock);
              }
            }

            // No point waiting if we don't have any children.
            if(!havekids || p->killed){
              release(&p->lock);
              return -1;
            }

            // Wait for a child to exit.
            // 暂时释放p锁，等待子进程获取退出
            sleep(p, &p->lock);  //DOC: wait-sleep
          }
        }
        + +

        其中值得注意的几个点：

          -
        1. 依据va找到对应filemap
          2. -
        2. 根据对应filemap的信息，使用readi（正确）fileread（错误）读取文件内容并存入物理内存
          3. -
        +

      3. wait中的sleep中释放的条件锁是等待进程的p->lock，这是上面提到的特例。

        4. -

      4. 在munmap中进行释放

        -
          -
        1. 根据标记写入文件页，并且释放对应物理内存
          2. -
        2. 修改filemap结构的参数，并且在其失效的时候放回对象池
          3. -
        +

      5. exit会将自己的所有子进程交付给一直在等待着的init进程：

        +
        for(;;){
          printf("init: starting sh\n");
          pid = fork();
          // ...
          for(;;){
            // this call to wait() returns if the shell exits,
            // or if a parentless process exits.
            wpid = wait((int *) 0);
            if(wpid == pid){
              // the shell exited; restart it.
              break;
            } else if(wpid < 0){
              printf("init: wait returned an error\n");
              exit(1);
            } else {
              // 这里！！
              // it was a parentless process; do nothing.
            }
          }
        }
        + +

        如果子进程退出，就会通过init的wait释放它们。然后init释放完它们后进入第三个if分支，继续进行循环。

        6. -

      6. 修改fork和exit

        -
          -

        1. exit

          -

          手动释放map-file域

          +

        2. wakeup1

          -

          为什么不能把这些合并到wait中调用的freepagetable进行释放呢？

          -

          因为freepagetable只会释放对应的物理页，没有达到munmap减少文件引用等功能。

          +

          Exit calls a specialized wakeup function, wakeup1, that wakes up only the parent, and only if it is sleeping in wait.

          -
          3. -

        3. fork

          -

          手动复制filemap池

          -
          4. -
        -
        7. +
        // Wake up p if it is sleeping in wait(); used by exit().
        // Caller must hold p->lock.
        static void
        wakeup1(struct proc *p)
        {
          if(!holding(&p->lock))
            panic("wakeup1");
          if(p->chan == p && p->state == SLEEPING) {
            p->state = RUNNABLE;
          }
        }
      -

      我的错误思路们

      第一次错误思路

      上面说到：

      +

      kill

      kill其实做得很温和。它只是会把想鲨的进程的p->killed设置为1，然后如果该进程sleeping，则唤醒它。最后的死亡以及销毁由进程自己来做。

      +
      // Kill the process with the given pid.
      // The victim won't exit until it tries to go
      // to kernel space (see usertrap() in trap.c).
      int
      kill(int pid)
      {
        struct proc *p;

        for(p = proc; p < &proc[NPROC]; p++){
          acquire(&p->lock);
          if(p->pid == pid){
            p->killed = 1;
            if(p->state == SLEEPING){
              // Wake process from sleep().
              p->state = RUNNABLE;
            }
            release(&p->lock);
            return 0;
          }
          release(&p->lock);
        }
        return -1;
      }
      // in trap.c usertrap()
        if(p->killed)
          exit(-1);
      + +

      可能这里有一个疑问：调用完exit后，进程会变成ZOMBIE态。谁最终把它释放了呢？其实答案很简单，只有两种：init进程或者是创建它的父进程。

      +

      如果创建它的父进程处于wait中，那么是由父进程把它销毁的，这没什么好说的。但如果创建它的父进程不在wait呢？那么父进程最后也是会调用exit的。父进程调用完exit后，会将其所有子进程过继给init进程。所以，ZOMBIE进程最终还是会迟早被init进程杀死的。

      +

      由这里，可以窥见xv6进程管理的进一步的冰山一角：

      +

      init进程是所有进程的根系进程。它一直处于wait的死循环中，因而可以将需要被杀死的进程杀死。

      +

      可见，wait和exit，实际上就构筑了进程的生命周期的最后一环。

      +

      这种巧妙地将进程生命周期这个大事完全托付给了wait和exit这两个函数的这种结构，实在是非常精妙，太牛了吧。

      -

      问题就在于如何“先建立memory-file的映射”。在lazy allocation中，我们是先填好所有的对应页表项，仅是不申请对应的物理内存，也即占着XX不XX。在这次实验中，我们也是这么做，只不过新增了一个难点，那就是如何管理这些页。因为lazy allocation页与页之间没有比较紧密的关系，但是在mmap中页却可以被所属文件这个关键字划分。因而，我们需要一个数据结构，来给页分门别类地组织在一起，并且记录它们的meta data比如说所属文件之类的，这也就是hints里的VMA结构，也即我的filemap结构。

      +

      一些XV6的sleep循环不检查p->killed，因为代码在应该是原子操作的多步系统调用的中间。virtio驱动程序（*kernel/virtio_disk.c*:242）就是一个例子：它不检查p->killed，因为一个磁盘操作可能是文件系统保持正确状态所需的一组写入操作之一。等待磁盘I/O时被杀死的进程将不会退出，直到它完成当前系统调用并且usertrap看到killed标志

      -

      官方给出的答案是在proc域里的pool。我……额……是把这些信息，存入在页中（真是自找麻烦呀）

      -

      具体来说，就是，我在mmap的时候给每个文件申请一页，然后在页的开头填上和filemap结构相差无几的那些参数，再加上一个next指针，表示下一个文件页的地址。页的剩下部分就用来存储数据。总的就是一个链表结构。

      -

      这个思路其实很不错，比起上面的直接在proc内存的尾巴扩容，这个空间利用率应该更大，并且不仅能节省物理内存，还能节省虚拟地址空间，实现了lazy上加lazy。

      -

      但问题是……我为什么非要傻瓜式操纵内存，在页的开头填入参数数据，而不是把这种页抽象为一个个node，最终形成一个十字链表的形式（差不多的意思，鱼骨状），组织进proc域，这样不挺好的吗……唔，有时候我头脑昏迷程度让我自己都感到十分震惊。归根结底，还是想得太少就动手了，失策。

      -

      总之放上代码。我没有实现next指针，仅假设文件内容不超过一页。也就是这一页开头在mmap中填meta data，其余部分在usertrap中填入文件内容。【这个分开的点也让我迷惑至极……】

      -
      #define ERRORADDR 0xffffffffffffffff

      void* mmap(void* address,size_t length,int prot,int flags,struct file* file,uint64 offset){
          struct proc* p = myproc();
          // 获取va,也即真正的address
          uint64 va = p->sz;
          if(growproc(PGSIZE) < 0)
                  return (void*)ERRORADDR;
          char* mem = kalloc();
          if(mem == 0){
                  return (void*)ERRORADDR;
          }
          memset(mem, 0, PGSIZE);
          // 保存信息：file指针、prot（这就是傻瓜式操纵内存的典范）
          uint64* pointer = (uint64*)mem;
          *pointer = (uint64)file;
          pointer++;
          *pointer = (uint64)prot;
          pointer++;
          *pointer = (uint64)length;
          pointer++;
          *pointer = (uint64)flags;
          pointer++;
          *pointer = (uint64)offset;
          pointer++;
          filedup(file);

          if(mappages(p->pagetable, va+PGSIZE, PGSIZE, (uint64)mem, PTE_M|PTE_X|PTE_U) != 0){
            kfree(mem);
                  return (void*)ERRORADDR;
          }
          // return start of free memory
          return (void*)(va + (uint64)pointer - (uint64)mem);
      }
      int munmap(void* address,size_t length){
          struct proc* p = myproc();
          pte_t *pte;
          uint64* pa;

          if((pte = walk(p->pagetable, (uint64)address, 0)) == 0)
                  return -1;
          if((*pte & PTE_V) == 0 ||(*pte & PTE_M) == 0)
                  return -1;
          // the start is where the params save
          pa = (uint64*)(PGROUNDDOWN(PTE2PA(*pte)));
          struct file* file = (struct file*)(*pa);
          pa++;
          int prot = (int)(*pa);
          pa++;
          pa++;
          int flags = (int)(*pa);
          pa++;
          pa++;

          if(flags == MAP_SHARED&&(prot&PROT_WRITE) != 0){
              // 需要更新写内容
              filewrite(file,(uint64)address,length);
          }
          // 最后释放内存
          uvmunmap(p->pagetable, PGROUNDDOWN((uint64)address), 1, 1);
          return 0;
      }
      - -
      } else if(r_scause() == 13 || r_scause() == 15){
        uint64 va = r_stval();
        pte_t *pte;
        uint64* pa;
        uint flags;

        if((pte = walk(p->pagetable, va, 0)) == 0)
          p->killed = 1;
        else if((*pte & PTE_V) == 0 ||(*pte & PTE_M) == 0)
          p->killed = 1;
        else {
          // the start is where the params save
          pa = (uint64*)(PGROUNDDOWN(PTE2PA(*pte)));
          flags = PTE_FLAGS(*pte);
          struct file* file = (struct file*)(*pa);
          pa++;
          int prot = (int)(*pa);
          pa++;
          size_t length = (size_t)(*pa);
          pa++;
          pa++;
          pa++;

          if((prot&PROT_READ) != 0){
            fileread(file,va,length);
            flags |= PTE_R;
            if((prot&PROT_WRITE) != 0)    flags |= PTE_W;
            else if(r_scause() == 15)     p->killed = 1;
            *pte = ((*pte) | flags);
          } else  p->killed = 1;
        }
      }
      - -
      为什么下面的代码是错的

      正如开头所说的那样，我并没有完美做好这次实验，下面代码有一个致命的bug。

      -

      先说说致命bug是什么。

      -

      我的filemap结构体其实隐藏了两个具有“offset”这一含义的状态。一个是filemap里面的成员变量offset，另一个是filemap里面的成员变量file的成员变量off：

      -
      // in proc.h
      struct filemap{
        struct file* file;//文件
        uint64 offset;//va相对于file开头的offset
      };
      // in file.h
      struct file {
        uint off;          // FD_INODE
      };
      - -

      在我的代码里，它们被赋予了不同的含义。

      -

      filemap->file->off被用于trap.c中，表示的是当前未读入文件内容的起始位置（实际上也就是okva-va的值），用于自然地使用fileread进行文件读入。

      -

      比如说，这次读入PGSIZE，那么off就会在fileread中自增PGSIZE。下次调用fileread就可以直接从下一个位置读入了，这样使代码更加简洁

      +

      Xv6对kill的支持并不完全令人满意：有一些sleep循环可能应该检查p->killed。一个相关的问题是，即使对于检查p->killed的sleep循环，sleep和kill之间也存在竞争；后者可能会设置p->killed，并试图在受害者的循环检查p->killed之后但在调用sleep之前尝试唤醒受害者。如果出现此问题，受害者将不会注意到p->killed，直到其等待的条件发生。这可能比正常情况要晚一点（例如，当virtio驱动程序返回受害者正在等待的磁盘块时）或永远不会发生（例如，如果受害者正在等待来自控制台的输入，但用户没有键入任何输入）。

      +
      +

      是的，所以这个kill的实现其实是相当玄学的。

      +

      Real world

      +

      xv6调度器实现了一个简单的调度策略：它依次运行每个进程。这一策略被称为轮询调度（round robin）。真实的操作系统实施更复杂的策略，例如，允许进程具有优先级。

      +
      +

      我记得linux0.11用的是时间片轮转+优先级队列完美融合的方法，是真的很牛逼

      +
      +

      复杂的策略可能会导致意外的交互，例如优先级反转（priority inversion）和航队（convoys）。当低优先级进程和高优先级进程共享一个锁时，可能会发生优先级反转，当低优先级进程持有该锁时，可能会阻止高优先级进程前进。当许多高优先级进程正在等待一个获得共享锁的低优先级进程时，可能会形成一个长的等待进程航队；一旦航队形成，它可以持续很长时间。为了避免此类问题，在复杂的调度器中需要额外的机制。

      -

      filemap->offset被用于munmap中。filewrite同fileread一样，都是从file->off处开始取数据。munmap所需要取数据的起始位置和trap.c中需要取数据的起始位置肯定不一样，

      -

      想想它们的功能。trap.c的off需要始终指向有效内存段的末尾，但munmap由于要对特定内存段进行写入文件操作，因而off要求可以随机指向。

      +

      在wakeup中扫描整个进程列表以查找具有匹配chan的进程效率低下。一个更好的解决方案是用一个数据结构替换sleep和wakeup中的chan，该数据结构包含在该结构上休眠的进程列表，例如Linux的等待队列。

      -

      因而，我们可以将当前va对应的文件位置记录在offset中。届时，我们只需要从p->filemaps[i].offset+va-p->filemaps[i].va取数据就行。

      -

      上述两个变量相辅相成，看上去似乎能够完美无缺地实现我们的功能。但是，实际上，不行。为什么呢？因为它们的file指针，filemap->file，如果被两个mmap区域同时使用的话，就会出问题。

      -

      可以来看看mmaptest.c中的这一段代码：

      -
        makefile(f);
        if ((fd = open(f, O_RDONLY)) == -1)
          err("open");

        unlink(f);
        char *p1 = mmap(0, PGSIZE*2, PROT_READ, MAP_SHARED, fd, 0);
        char *p2 = mmap(0, PGSIZE*2, PROT_READ, MAP_SHARED, fd, 0);

        // read just 2nd page.
        if(*(p1+PGSIZE) != 'A')
          err("fork mismatch (1)");
        if((pid = fork()) < 0)
          err("fork");

        if (pid == 0) {
          // v1是用来触发缺页中断的函数
          _v1(p1);
          munmap(p1, PGSIZE); // just the first page
          exit(0); // tell the parent that the mapping looks OK.
        }

        int status = -1;
        wait(&status);

        if(status != 0){
          printf("fork_test failed\n");
          exit(1);
        }

        // check that the parent's mappings are still there.
        printf("before v1,p1 = %d\n",(uint64)p1);
        _v1(p1);
        printf("after v1,p1 = %d\n",(uint64)p1);
        _v1(p2);


        printf("fork_test OK\n");

      /*输出：
      fork_test starting
      trap:map a page at 53248,okva = 53248
      trap:mem[0]=65,off = 4096,size = 6144
      trap:map a page at 57344,okva = 53248
      trap:mem[0]=65,off = 6144,size = 6144
      before v1,p1 = 53248
      after v1,p1 = 53248
      trap:map a page at 61440,okva = 61440
      trap:mem[0]=0,off = 6144,size = 6144
      mismatch at 0, wanted 'A', got 0x0
      mmaptest: fork_test failed: v1 mismatch (1), pid=3
      */
      - -
      // in trap.c
      printf("trap:map a page at %d,okva = %d\n",start_va,p->filemaps[i].okva);

      fileread(p->filemaps[i].file,start_va,PGSIZE);

      printf("trap:mem[0]=%d,off = %d,size = %d\n",
             mem[0],p->filemaps[i].file->off,p->filemaps[i].file->ip->size);
      - -

      这段代码因为共用fd，导致file指针被两个mmap区域同时使用。

      +

      是的，linux的那个wakeup真的很牛，我现在都还记得当初学到那的时候的震撼。

      -

      共用fd，为什么file指针也一起共用了？

      -

      可以追踪一下它们的生命周期：

      -
      // in sys_open()
      // 获取file结构体和文件描述符。
      if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){

      // in sysfile.c
      // Allocate a file descriptor for the given file.
      // Takes over file reference from caller on success.
      static int
      fdalloc(struct file *f)
      {
      int fd;
      struct proc *p = myproc();

      for(fd = 0; fd < NOFILE; fd++){
       if(p->ofile[fd] == 0){
         p->ofile[fd] = f;
         return fd;
       }
      }
      return -1;
      }
      - -

      可以看到，它实际上是有一个文件描述符表，key为fd，value为file指针。因而，同一张表，fd相同，file指针相同。

      -

      注：父子进程，同样的fd，file指针也是相同的

      -

      fork出来的父子进程同一个句柄对同一个文件的偏移量是相同的，这个原理应该是因为，父子进程共享的是文件句柄这个结构体对象本身，也就是拷贝的时候是浅拷贝而不是深拷贝。

      -
      // in fork()
      // increment reference counts on open file descriptors.
      for(i = 0; i < NOFILE; i++)
       if(p->ofile[i])
         np->ofile[i] = filedup(p->ofile[i]);
      +

      wakeup的实现会唤醒在特定通道上等待的所有进程，可能有许多进程在等待该特定通道。操作系统将安排所有这些进程，它们将竞相检查睡眠条件。进程的这种行为有时被称为惊群效应（thundering herd），最好避免。

      +

      大多数条件变量都有两个用于唤醒的原语：signal用于唤醒一个进程；broadcast用于唤醒所有等待进程。

      -

      最后的check that the parent's mappings are still there.环节中，_v1(p1)执行时并没有陷入trap，这是正常的。不正常的是_v1(p2)的执行结果。它陷入了trap，但是却因file->off == file size，导致被判定为已全部读入文件，事实上却是并没有读入文件。

      -

      为什么会这样呢？

      -

      这是因为p1和p2共用同一个fd，也就共用了同一个file指针。共用了一个file指针，那么p1和p2面对的file->off相同。上面说到，file->off用于控制文件映射。那么，当p1完成了对文件的映射，p1的off指针如果不加重置，就会永远停留在file size处。这样一来，当p2想要使用同样的file指针进行文件映射时，就会出问题。

      -

      这个问题的一个解决方法是每次mmap都深拷贝一个船新file结构体。但是这样的话，file域里的ref变量就失去了它的意义，并且file对象池应该也很快就会爆满，非常不符合设计方案。

      -

      这个问题的完美解，是不要赋予file->off这个意义，而是使用readi替代fileread。

      -
      fileread(struct file *f, uint64 addr, int n)
      readi(struct inode *ip, int user_dst, uint64 dst, uint off, uint n)
      - -

      这样做的好处是，我们可以实时计算offset（前面提到，其恰恰等于okva-va），而不用把这个东西用file的off来表示。

      -

      也确实，我之所以弯弯绕绕那么曲折，是因为只想到了fileread这个函数，压根没注意到还有一个readi……

      +

      一个实际的操作系统将在固定时间内使用空闲列表找到自由的proc结构体，而不是allocproc中的线性时间搜索；xv6使用线性扫描是为了简单起见。

      -

      我在下面的代码仅做了一个能够通过测试，但是上面的bug依然存在的功利性折中代码。我是这么实现的：

      -
      // 在`mmap`的时候初始化`file->off`
      p->filemaps[i].file->off = offset;
      // 在`munmap`的时候清零`file->off`
      p->filemaps[i].file->off = 0;
      - - +

      Lab: Multithreading

      +

      You will implement switching between threads in a user-level threads package, use multiple threads to speed up a program, and implement a barrier.

      +
      +

      这个introduction看起来还是非常激动人心的，很早就想了解到底线程是怎么实现的了。不过做完发现思想还是很简单的，就是只用切换上下文和栈就行。可以看看提供给的代码。

      +

      Uthread: switching between threads

      +

      In this exercise you will design the context switch mechanism for a user-level threading system, and then implement it.

      +

      To get you started, your xv6 has two files user/uthread.c and user/uthread_switch.S, and a rule in the Makefile to build a uthread program.

      +

      uthread.c contains most of a user-level threading package, and code for three simple test threads. The threading package is missing some of the code to create a thread and to switch between threads.

      +

      You will need to add code to thread_create() and thread_schedule() in user/uthread.c, and thread_switch in user/uthread_switch.S.

      +

      One goal is ensure that when thread_schedule() runs a given thread for the first time, the thread executes the function passed to thread_create(), on its own stack.

      +

      Another goal is to ensure that thread_switch saves the registers of the thread being switched away from, restores the registers of the thread being switched to, and returns to the point in the latter thread’s instructions where it last left off. You will have to decide where to save/restore registers; modifying struct thread to hold registers is a good plan.

      +

      You’ll need to add a call to thread_switch in thread_schedule; you can pass whatever arguments you need to thread_switch, but the intent is to switch from thread t to next_thread.

      +
      +

      感想

      思路

      看了一遍它这里面写的题目还是有点抽象的，需要结合着给的代码看，那样就清晰多了。

      +

      首先，要补全的地方有这几个：

      +
      // 1. in thread_schedule()
        if (current_thread != next_thread) {         /* switch threads?  */
          next_thread->state = RUNNING;
          t = current_thread;
          current_thread = next_thread;
          /* YOUR CODE HERE
           * Invoke thread_switch to switch from t to next_thread:
           * thread_switch(??, ??);
           */
        } else
          next_thread = 0;
      // 2. in thread_create()
      void
      thread_create(void (*func)())
      {
        struct thread *t;

        for (t = all_thread; t < all_thread + MAX_THREAD; t++) {
          if (t->state == FREE) break;
        }
        t->state = RUNNABLE;
        // YOUR CODE HERE
      }
      // 3. in uthread_switch.S
              /*
               * save the old thread's registers,
               * restore the new thread's registers.
               */

              .globl thread_switch
      thread_switch:
              /* YOUR CODE HERE */
              ret    /* return to ra */
      -

      因而，结论是，一步错步步错，一个错误需要更多的错误来弥补，最后还是错的（悲）

      -
      如何把下面的错误思路改成正确思路

      可以做以下几点：

      -
        -

      1. 正确地lazy

        -

        每次trap仅分配一页。

        -
        2. -

      2. 改用readi函数，修改file->off的语义

        -
        3. -
      -

      这样一来，大概就可以完美地正确了。

      -

      其他的一些小细节

      file指针的生命周期

      在数据结构中存储file指针至关重要。但仔细想一想，file指针的生命周期似乎长到过分：从sys_mmap被调用，一直到usertrap处理缺页中断，最后到munmap释放，我们要求file指针的值需要保持稳定不变。

      -

      这么长的生命周期，它真的可以做到吗？毕竟file指针归根到底只是一个局部变量，在syscall mmap结束之后，它还有效吗？答案是有效的，这个有效性由mmap实现中对ref的增加来实现保障。

      -

      在用户态中关闭一个文件，需要使用syscallclose(int fd)。不妨来看看close的代码。

      -
      // in kernel/sysfile.c
      uint64
      sys_close(void)
      {
      int fd;
      struct file *f;

      if(argfd(0, &fd, &f) < 0)
       return -1;
      // 一个进程打开的文件都会放入一个以fd为index的文件表里，
      // 在xv6中，这个文件表便是`myproc()->ofile`。
      // 可以看到，关闭一个文件首先需要把它移出文件表
      myproc()->ofile[fd] = 0;
      // 对file指针关闭的主要操作
      fileclose(f);
      return 0;
      }

      // in kernel/file.c
      // Close file f.  (Decrement ref count, close when reaches 0.)
      void
      fileclose(struct file *f)
      {
      struct file ff;

      acquire(&ftable.lock);
      // 若ref数<0，就会直接return
      if(--f->ref > 0){
       release(&ftable.lock);
       return;
      }
      // 释放file
      // close不会显式地释放file指针，只会释放file指针所指向的文件，让file指针失效。
      ff = *f;
      f->ref = 0;
      f->type = FD_NONE;
      release(&ftable.lock);

      if(ff.type == FD_PIPE){
       pipeclose(ff.pipe, ff.writable);
      } else if(ff.type == FD_INODE || ff.type == FD_DEVICE){
       begin_op();
       iput(ff.ip);
       end_op();
      }
      }
      +

      这几个函数到时候会被如此调用：

      +
      int
      main(int argc, char *argv[])
      {
        a_started = b_started = c_started = 0;
        a_n = b_n = c_n = 0;
        thread_init();
        thread_create(thread_a);
        thread_create(thread_b);
        thread_create(thread_c);
        thread_schedule();
        exit(0);
      }
      -

      可以看到，当ref数>1时，file指针就不会失效。

      -

      这就是为什么我们还需要在mmap中让file的ref数++。

      -
      缺页中断蕴含的设计思想

      如果只存入file指针，用户态要如何对对应的文件进行读写呢？

      -

      我们可以自然想到也许需要设计一个函数，让用户在想要对这块内存读写的时候调用这个函数即可。但是，这样的方法使得用户对内存不能自然地读写，还需要使用我们新设计的这个函数，这显然十分地不美观。所以，我们需要找到一个方法，让上层的用户可以统一地读取任何的内存块，包括memory-mapped file内存块，而隐藏memory-mapped file与其他内存块读写方式不同的这些复杂细节。经历过前面几次实验的你看到这里一定能想到，有一个更加优美更加符合设计规范的方法，那就是：缺页中断！

      +

      所以，我们在第一个地方要做的，就是要填入swtch的签名。第二个地方要做的，就是要想办法让该线程一被启动就去执行参数的函数指针。第三个地方要做的，就是要完成上下文的切换。

      +

      所以思路其实是很直观的。我们可以模仿进程管理中用来表示上下文的context，在thread_create的时候把里面的ra设置为参数的函数指针入口，sp修改为thread结构体中的栈地址。swtch函数则完全把kernel/swtch.S超过来就行。

      -

      没做这个实验之前就知道mmap需要借助缺页中断来实现了，但实际自己的第一印象是觉得并不需要缺页中断，直到分析到这里才恍然大悟。

      -

      “让上层的用户可以统一地读取任何的内存块，而隐藏不同类型的内存块读写方式不同的这些复杂细节”

      -

      仔细想想，前面几个关于缺页中断的实验，比如说cow fork，lazy allocation，事实上都是基于这个思想。它们并不是不能与缺页中断分离，只是有了缺页中断，它们的实现更加简洁，更加优美。

      -

      再次感慨os的博大精深。小小一个缺页中断，原理那么简单，居然集中了这么多设计思想，不禁叹服。

      +

      在这个思路中，我们是怎么做到栈的切换的呢？

      +

      每个线程在thread_create的时候，都将自己的context中的sp修改为自己的栈地址。这样一来，在它们被调度的时候，switch会自然而然地从context中读取sp作为之后运行的sp，这样就实现了栈的切换。

      -
      正确答案的munmap中如果遇到未映射的页怎么办

      在正确答案的munmap中：

      -
      //释放已经申请的页表项、内存，并且看看是不是需要写回
      while(start_va < bounder){
        if(p->filemaps[i].flags == MAP_SHARED){
          //写回
          filewrite(p->filemaps[i].file,start_va,PGSIZE);
        }
        uvmunmap(p->pagetable,start_va,1,1);
        start_va += PGSIZE;
      }
      - -

      如果map类型为MAP_SHARED，并且该页尚未映射，会怎么样呢？

      -

      追踪filewrite的路径

      -
      // in file.c
      	  begin_op();
            ilock(f->ip);
            if ((r = writei(f->ip, 1, addr + i, f->off, n1)) > 0)
              f->off += r;
            iunlock(f->ip);
            end_op();
      // in fs.c
          if(either_copyin(bp->data + (off % BSIZE), user_src, src, m) == -1) {
            brelse(bp);
            break;
          }
          log_write(bp);
      // in vm.c copyin()
      int
      copyin(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len)
      {
        uint64 n, va0, pa0;

        while(len > 0){
          va0 = PGROUNDDOWN(srcva);
          pa0 = walkaddr(pagetable, va0);
          if(pa0 == 0)
            return -1;
      // ...
      - -

      copyin最终会在 if(pa0 == 0) return -1;这里终结，但writei并不会在接收到-1的时候爆出panic或者是引发缺页中断，而只会把它当做文件结尾，默默地返回。

      -

      并且，在munmap中是一页一页地释放，而不是直接传参length全部释放，这一点也很重要。因为我们的lazy allocation很可能导致va~va+length这一区间内只是部分页被映射，部分页没有。如果直接传参length释放，那么在遇到第一页未被映射的时候，filewrite就会终止，该页之后的页就没有被写回文件的机会了。

      -

      所以结论是，在正确实现的munmap中遇到未映射的页会自动跳过，什么也不会发生。

      -

      代码

      数据结构

      // in param.h
      #define NFILEMAP 32

      // in proc.h
      struct filemap{
        uint isused;//对象池思想。该filemap是否正在被使用
        uint64 va;//该文件的起始内存页地址
        uint64 okva;//该文件的起始未被读入部分对应的内存地址
        struct file* file;//文件
        size_t length;//需要映射到内存的长度
        int flags;//MAP_SHARED OR MAP_PRIVATE
        int prot;//PROT_READ OR PROT_WRITE
        uint64 offset;//va相对于file开头的offset
      };

      // Per-process state
      struct proc {
        struct filemap filemaps[NFILEMAP];
      };
      - -

      mmap

      具体系统调用注册过程略。

      -
      // in sysproc.c
      uint64
      sys_mmap(void){
        uint64 addr;
        int length,prot,flags,offset;
        struct file* file;
        if(argaddr(0,&addr) < 0 || argint(1,&length) < 0 || argint(2,&prot) < 0 || argint(3,&flags) < 0 || argfd(4,0,&file) ||argint(5,&offset) < 0)
          return -1;
        return (uint64)mmap((void*)addr,(size_t)length,prot,flags,file,(uint)offset);
      }
      - -
      #define ERRORADDR 0xffffffffffffffff

      // 映射file从offset开始长度为length的内容到内存中，返回内存中的文件内容起始地址
      void* mmap(void* address,size_t length,int prot,int flags,struct file* file,uint64 offset){
          // mmap的prot权限必须与file的权限对应，不能file只读但是mmap却可写且shared
          if((prot&PROT_WRITE) != 0&&flags == MAP_SHARED &&file->writable == 0)       
              return (void*)ERRORADDR;
          
          struct proc* p = myproc();
          uint64 va = 0;
          int i=0;
          
          //找到filemap池中第一个空闲的filemap
          for(i=0;i<NFILEMAP;i++){
            if(!p->filemaps[i].isused){
              // 获取va,也即真正的address
              va = p->sz;
              p->sz += length;
              // 其实这里用一个memcpy会更加优雅，可惜我忘记了（）
              p->filemaps[i].isused = 1;
              p->filemaps[i].va = va;
              p->filemaps[i].okva = va;
              p->filemaps[i].length = length;
              p->filemaps[i].prot = prot;
              p->filemaps[i].flags = flags;
              p->filemaps[i].file = file;
              p->filemaps[i].file->off = offset;
              p->filemaps[i].offset = offset;
              // 增加文件引用数
              filedup(file);
              break;
            }
          }
          if(va == 0)  return (void*)ERRORADDR;
          // return start of free memory
          uint64 start_va = PGROUNDUP(va);
          // 先读入处于proc已申请的内存页区域（也即没有内存对齐情况下）
          uint64 off = start_va - va;
          if(off < PGSIZE){
              fileread(file,va,off);
              file->off += off;
              p->filemaps[i].okva = va+off;
          }
          return (void*)va;
      }
      - -

      usertrap

      错的
      } else if(r_scause() == 13 || r_scause() == 15){
         uint64 va = r_stval();

         for(int i=0;i<NFILEMAP;i++){
             // 找到va对应的filemap
           if(p->filemaps[i].isused&&va>=p->filemaps[i].va 
              && va<p->filemaps[i].va+p->filemaps[i].length){
             // 说明本来就不应该写
             if(r_scause() == 15 && ((p->filemaps[i].prot)&PROT_WRITE) == 0){
               p->killed = 1;
               break;
             }
             //说明地址不在文件范围内
             if(p->filemaps[i].va+p->filemaps[i].file->ip->size <= va){
               p->killed = 1;
               break;
             }
             // 能进到这里来的都是产生了缺页中断，也就是说va对应文件数据不存在
             // 我们需要维护一个okva，表示从filemaps.va到okva这段地址已经加载了文件
             // 这样一来，我们这里就只需加载okva~va地址对应的文件了
             // file结构体自带的off成员会由于fileread而自动增长到对应位置，所以文件可以自然地读写
             uint64 start_va = p->filemaps[i].okva;// okva一定是page-align的
             // 加载文件内容
             while(start_va <= va){
               char* mem = kalloc();
               if(mem == 0){
                 p->killed = 1;
                 break;
               }
               memset(mem, 0, PGSIZE);
               int flag = PTE_X|PTE_R|PTE_U;
               if(((p->filemaps[i].prot)&PROT_WRITE) != 0){
                 flag |= PTE_W;
               }
               if(mappages(p->pagetable, start_va, PGSIZE, (uint64)mem, flag) != 0){
                 p->killed = 1;
                 kfree(mem);
                 break;
               }
               // 读入文件内容
               fileread(p->filemaps[i].file,start_va,PGSIZE);
               start_va += PGSIZE;
             }
             p->filemaps[i].okva = start_va;
             break;
           }
         }
       }
      +
      坑

      我觉得其他方面都不难，最坑最细节的【也是我完全没有想到的……】就是这里：

      +
      // 修改sp为栈顶
      t->context.sp = (uint64)t->stack + STACK_SIZE;
      -
      对的
      } else if(r_scause() == 13 || r_scause() == 15){
        uint64 va = r_stval();
        for(int i=0;i<NFILEMAP;i++){
          if(p->filemaps[i].isused&&va>=p->filemaps[i].va && va<p->filemaps[i].va+p->filemaps[i].length){
            if(r_scause() == 15 && ((p->filemaps[i].prot)&PROT_WRITE) == 0){
              // 说明本来就不应该写
              p->killed = 1;
              break;
            }
            if(p->filemaps[i].va+p->filemaps[i].file->ip->size <= va){
              //说明地址不在文件范围内
              p->killed = 1;
              break;
            }
            uint64 start_va = PGROUNDDOWN(va);
              char* mem = kalloc();
              if(mem == 0){
                p->killed = 1;
                break;
              }
              memset(mem, 0, PGSIZE);
              int flag = PTE_X|PTE_R|PTE_U;
              if(((p->filemaps[i].prot)&PROT_WRITE) != 0){
               flag |= PTE_W;
              }
              if(mappages(p->pagetable, start_va, PGSIZE, (uint64)mem, flag) != 0){
                p->killed = 1;
                kfree(mem);
                break;
              }
              readi(p->filemaps[i].file->ip,0,(uint64)mem,va-p->filemaps[i].va+p->filemaps[i].offset,PGSIZE);
            break;
          }
        }
      }
      +

      需要注意，栈顶并不是t->stack。

      +

      通过测试程序：

      +
      int main(){
      	int a[5]={1,2,3,4,5};
      	for(int i=0;i<5;i++){
      		printf("%p\n",&a[i]);
      	}
      	return 0;
      }
      0062feb8
      0062febc
      0062fec0
      0062fec4
      0062fec8
      -

      munmap

      错的
      uint64 min(uint64 a,uint64 b){return a>b?b:a;}

      // 释放文件映射以address为起始地址，length为长度这个范围内的内存地址空间
      int munmap(void* address,size_t length){
          struct proc* p = myproc();
          uint64 va = (uint64)address;
          
          // 找到对应的filemap
          for(int i=0;i<NFILEMAP;i++){
            if(p->filemaps[i].isused&&p->filemaps[i].va<=va&&p->filemaps[i].va+length>va){
              // 开始释放的内存地址
              uint64 start_va;
              if(va == p->filemaps[i].va)
                  start_va = PGROUNDUP(p->filemaps[i].va);
              else
                  start_va = PGROUNDDOWN(va);
              // 结束释放的内存地址
              uint64 bounder = p->filemaps[i].va + min(p->filemaps[i].file->ip->size,length);
                
              //file的off在trap中用于表示文件已加载的位置
              //在这里需要用off进行filewrite，所以需要对原本在usertrap用于记录加载位置的off进行手动保存
              uint64 tmp_off = p->filemaps[i].file->off;
              p->filemaps[i].file->off = p->filemaps[i].offset+va-p->filemaps[i].va;

              //释放已经申请的页表项、内存，并且看看是不是需要写回
              while(start_va < bounder && start_va < p->filemaps[i].okva){
                if(p->filemaps[i].flags == MAP_SHARED){
                  //写回
                  filewrite(p->filemaps[i].file,start_va,PGSIZE);
                }
                uvmunmap(p->pagetable,start_va,1,1);
                start_va += PGSIZE;
              }

              //修改filemap结构体的起始地址va和长度，offset也要变，因为他记录va对应的是文件哪个位置
              if(va == p->filemaps[i].va){
                //释放的是头几页
                p->filemaps[i].offset += length;
                p->filemaps[i].va = va+length;
                p->filemaps[i].length -= length;
              }else {
                //释放的是尾几页
                p->filemaps[i].length -= p->filemaps[i].length - va;
              }
              p->filemaps[i].file->off = tmp_off;
              // 检验map的合理性
              if(p->filemaps[i].length == 0 || p->filemaps[i].va >= p->filemaps[i].va+length
                              || p->filemaps[i].file->off > p->filemaps[i].file->ip->size){
                p->filemaps[i].isused = 0;//释放
                
                // 注意！！！！这句话对我的错误代码来说非常重要
                p->filemaps[i].file->off = 0;
                fileclose(p->filemaps[i].file);
              }
            }
          }
          return 0;
      }
      +

      栈是向下增长的，因而，栈顶确实应该是数组的末尾……

      +

      这里完全没有想到，还是吃了基础的亏啊。

      +
      +

      如果这里将t->stack作为sp，那么运行时会出现非常诡异的现象（打印的是abc三个的thread->state）：

      +

      image-20230120232149776

      +

      仅有c【经测试，是仅有最后一个启动的线程】在执行，而ab的state都不是理想中的2，而是很奇怪的值。我确实有想过栈溢出问题，但是马上被我否定了。我完全没有想到是那样错的【悲】

      +
      +

      代码

      增加context结构体定义，修改thread结构体
      struct context {
        uint64 ra;
        uint64 sp;

        // callee-saved
        uint64 s0;
        uint64 s1;
        uint64 s2;
        uint64 s3;
        uint64 s4;
        uint64 s5;
        uint64 s6;
        uint64 s7;
        uint64 s8;
        uint64 s9;
        uint64 s10;
        uint64 s11;
      };


      struct thread {
        char       stack[STACK_SIZE]; /* the thread's stack */
        int        state;             /* FREE, RUNNING, RUNNABLE */
        struct context context;
      };
      -
      对的
      uint64 min(uint64 a,uint64 b){return a>b?b:a;}

      int munmap(void* address,size_t length){
          struct proc* p = myproc();
          uint64 va = (uint64)address;
          for(int i=0;i<NFILEMAP;i++){
            if(p->filemaps[i].isused&&p->filemaps[i].va<=va&&p->filemaps[i].va+length>va){
              uint64 start_va;
              if(va == p->filemaps[i].va)
                      start_va = PGROUNDUP(p->filemaps[i].va);
              else
                      start_va = PGROUNDDOWN(va);
              uint64 bounder = p->filemaps[i].va + min(p->filemaps[i].file->ip->size,length);
              //在这里需要用off进行读写，所以需要对原本的加载处off手动保存
              uint64 tmp_off = p->filemaps[i].file->off;
              p->filemaps[i].file->off = p->filemaps[i].offset+va-p->filemaps[i].va;

              //释放已经申请的页表项、内存，并且看看是不是需要写回
              while(start_va < bounder){
                if(p->filemaps[i].flags == MAP_SHARED){
                  //写回
                  filewrite(p->filemaps[i].file,start_va,PGSIZE);
                }
                uvmunmap(p->pagetable,start_va,1,1);
                start_va += PGSIZE;
              }

              //修改filemap结构体的起始地址va和长度，offset也要变，因为他记录va对应的是文件哪个位置
              if(va == p->filemaps[i].va){
                //释放的是头几页
                p->filemaps[i].offset += length;
                p->filemaps[i].va = va+length;
                p->filemaps[i].length -= length;
              }else {
                //释放的是尾几页
                p->filemaps[i].length -= p->filemaps[i].length - va;
              }
              // 检验map的合理性
              if(p->filemaps[i].length == 0 || p->filemaps[i].va >= p->filemaps[i].va+length
                              || p->filemaps[i].file->off > p->filemaps[i].file->ip->size){
                p->filemaps[i].isused = 0;//释放
                fileclose(p->filemaps[i].file);
              }
              p->filemaps[i].file->off = tmp_off;
            }
          }
          return 0;
      }
      +
      修改thread_create
      void
      thread_create(void (*func)())
      {
        struct thread *t;

        for (t = all_thread; t < all_thread + MAX_THREAD; t++) {
          if (t->state == FREE) break;
        }
        t->state = RUNNABLE;
        // YOUR CODE HERE
        // 将当前上下文保存入context
        thread_switch((uint64)(&(t->context)),(uint64)(&(t->context)));
        // 修改sp为栈顶
        t->context.sp = (uint64)t->stack + STACK_SIZE;
        // 修改ra为参数的函数指针入口
        t->context.ra = (uint64)func;
      }
      -

      exit和fork

      exit
      // 关闭map-file
      for(int i=0;i<NFILEMAP;i++){
        if(p->filemaps[i].isused){
          munmap((void*)(p->filemaps[i].va),p->filemaps[i].length);
        }
      }
      +
      修改thread_schedule
      if (current_thread != next_thread) {         /* switch threads?  */
        next_thread->state = RUNNING;
        t = current_thread;
        current_thread = next_thread;
        /* YOUR CODE HERE
         * Invoke thread_switch to switch from t to next_thread:
         * thread_switch(??, ??);
         */
        thread_switch((uint64)(&(t->context)),(uint64)(&(current_thread->context)));
      } else
        next_thread = 0;
      -
      fork
      for(int i=0;i<NFILEMAP;i++){
        np->filemaps[i].isused = p->filemaps[i].isused;
        np->filemaps[i].va = p->filemaps[i].va;
        np->filemaps[i].okva = p->filemaps[i].okva;
        np->filemaps[i].file = p->filemaps[i].file;
        np->filemaps[i].length = p->filemaps[i].length;
        np->filemaps[i].flags = p->filemaps[i].flags;
        np->filemaps[i].offset = p->filemaps[i].offset;
        np->filemaps[i].prot = p->filemaps[i].prot;
        if(np->filemaps[i].file)
          filedup(np->filemaps[i].file);
      }
      +
      修改thread_switch

      全部照搬kernel/swtch.S，没什么好说的

      +

      Using threads

      一步步细粒度化，最后，每个桶用单独一把锁，仅在调用insert处加锁就行。

      +
      pthread_mutex_t locks[NBUCKET];// 在main中初始化

      static
      void put(int key, int value)
      {
        int i = key % NBUCKET;

        // is the key already present?
        struct entry *e = 0;
        for (e = table[i]; e != 0; e = e->next) {
          if (e->key == key)
            break;
        }
        if(e){
          // update the existing key.
          e->value = value;
        } else {
          // the new is new.
          pthread_mutex_lock(&locks[i]);
          insert(key, value, &table[i], table[i]);
          pthread_mutex_unlock(&locks[i]);
        }
      }
      -

      修改uvmcopy和uvmunmap

      // in uvmunmap()
          if((*pte & PTE_V) == 0){
            *pte = 0;
            continue;
          }
      // in uvmcopy()
          if((*pte & PTE_V) == 0)
            //panic("uvmcopy: page not present");
            continue;
      +

      Barrier

      +

      In this assignment you’ll implement a barrier: a point in an application at which all participating threads must wait until all other participating threads reach that point too.

      +
      +

      直接上代码，还是比较简单的

      +
      static void
      barrier()
      {
        // YOUR CODE HERE
        //
        // Block until all threads have called barrier() and
        // then increment bstate.round.
        //
         pthread_mutex_lock(&(bstate.barrier_mutex));
         bstate.nthread++;
         while(bstate.nthread < nthread){
          pthread_cond_wait(&(bstate.barrier_cond), &(bstate.barrier_mutex));
          goto end;
         }
         // 此部分仅一个线程会进入
         pthread_cond_broadcast(&(bstate.barrier_cond));
         bstate.nthread = 0;
         bstate.round++;
      end:
         pthread_mutex_unlock(&(bstate.barrier_mutex));
      }
      ]]> + + xv6 + /2023/01/10/xv6/ + +

      总耗时：120h 约27天

      +

      部分地方的翻译和表格来源参考：xv6指导书翻译

      +

      部分文本来自：操作系统实验指导书 - 2023秋季 | 哈工大（深圳）

      +

      实验官网：6.S081

      +

      代码以github为准，此处记录的有些小瑕疵

      +

      笔记的结构【以第一章Operating system interface为例】：

      +

      image-20230124235649128

      +
      +

      Operating system interface

      Operating system oganization

      Page tables

      Traps and system calls

      Interrupts and device drivers

      Locking

      Scheduling

      File system

      其他的对实验未涉及的思考

      ]]>       + + labs + +       哈工大操作系统实验 /2022/10/04/%E5%93%88%E5%B7%A5%E5%A4%A7%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AE%9E%E9%AA%8C/ @@ -11884,6 +12087,50 @@ url访问填写http://localhost/webdemo4_war/*.do。 labs + + 状态机 + /2023/03/10/%E5%AF%B9moore%E5%9E%8B%E5%92%8Cmealy%E5%9E%8B%E7%8A%B6%E6%80%81%E6%9C%BA%E7%9A%84%E7%90%86%E8%A7%A3/ + 复习数电时，一道密码锁题令我十分不解：

      +image-20230213201519568 + +

      看到题目时，我首先联想到的是mealy型状态机，因为我联想到了序列检测。课内的序列检测讲的时候是把它当做mealy型的。但看了标准作答之后，才发现它其实应该是moore型。这让我对这二者的区别产生了深深的不解。

      +

      原来对于moore型状态机和mealy型状态机的理解仅仅停留在概念上，“moore型状态机的输出与输入无关，只与当前状态有关”“mealy型状态机输出与输入和现态都有关”。但这其实是一句非常抽象的话：什么是“无关”，什么是“有关”？moore型状态机的状态不也是依据输入进行转移的吗？那么这算不算“有关”？

      +

      探究之后，我得到了更精确的“有关”“无关”的定义。

      +
      +

      来自：Moore状态机和Mealy状态机的区别

      +image-20230213202110900 + +image-20230213202124943 +
      +
      +

      来自：Moore状态机和Mealy状态机的区别(以序列检测器为例)

      +

      Moore状态机输出只与此时的状态有关，因此假如需要检测宽度为4的序列，则需要五个状态。

      +

      Mealy状态机输出与此时的状态以及输入有关，因此假如需要检测宽度为4的序列，只需要四个状态即可。

      +
      +

      联想到我们课上学习的序列检测：

      +image-20230213202320825 + +

      它这明明长度为3的序列用了4个状态，应该算是moore型，为什么我们却被教说序列检测器是mealy型状态机呢？

      +

      原因是因为，我们进行了状态化简这一步，将moore型状态机转化为了mealy型状态机。

      +
      +

      这俩是可以相互转化的

      +

      来自：[转载][FPGA]有限状态机FSM学习笔记（二）

      +

      把Moore机转换为Mealy机的办法为，把次态的输出修改为对应现态的输出，同时合并一些具有等价性能的状态。把Mealy机转换为Moore机的办法是，把当前态的输出修改为对应次态的输出，同时添加一些状态。如图1所示，为把Mealy机状态图转化为Moore机状态图。

      +

      img
      　　　　　　　　图1　　Mealy型机转换为Moore型机

      +

      　　如图1所示，把Mealy型机转换为Moore型机，只要把现时输出改变为下一时刻输出。对于状态A，有4个箭头指向它，表示在当前状态下有4个状态可以转换为下一状态的A；同时当前输出均为0，可以把0移入状态A内部，表示在Moore机中状态A的输出为0。同理，可以把0分别移位B/C状态。但对于状态D，有两个箭头指向且具有不同的输出值，需要把状态D分解成两个状态D1和D2（每个状态对应一个输出，当输出不同需要利用不同的状态表示，这即是Moore机具有更多状态的原因），得到完整的Moore机状态模型。

      +

      　　同理，若把上图的Moore机转换为Mealy机，只要把Moore机中下一状态的输出改变成Mealy机中当前状态的输出，由于D1/D2两状态处于A/C两状态之间，且相当于A/C节点之间的一个等效节点，可以把D1/D2两状态合并为一个状态。

      +
      +
      +

      来自：Moore型状态机和Mealy型状态机

      +

      并非所有时序电路都可以使用Mealy模型实现。 一些时序电路只能作为摩尔机器实现。

      +
      +

      所以，我们可以出此暴论：在课程范围内，首先以moore的思想来设计状态机。如果该状态机可以被化简，那么这道题就要用mealy型的来做；如果不能，那么这道题就是得用moore型状态机来做。

      +

      一开始的那个时序锁的moore状态机不能化简，因此它是moore型。

      +
      +

      这个点本来可以讲得更清楚一些的……只教会我们做题的套路有啥意思呢←_←

      +
      +]]>       +       存储简单入门 /2023/10/06/%E5%AD%98%E5%82%A8%E7%AE%80%E5%8D%95%E5%85%A5%E9%97%A8/ @@ -12126,74 +12373,30 @@ url访问填写http://localhost/webdemo4_war/*.do。

      我们可以在GRUB界面选中所需内核，按下e键：

      image-20230616151122738

      然后就可以对启动参数进行修改，^X退出。

      -

      值得注意的是，此修改仅对本次启动有效。如果需要长期修改，建议还是通过第一种方法去修改。

      -

      initramfs

      GRUB程序会通过initrd.img启动initramfs，从而进行真正的根文件系统挂载。

      -
      -

      initrd.img是一个Linux系统中的初始化内存盘（initial RAM disk）的映像文件。它是一个压缩的文件系统映像，通常在引导过程中加载到内存中，并提供了一种临时的根文件系统，以便在正式的根文件系统（通常位于硬盘上）可用之前提供必要的功能和模块。

      -
      -

      我们可以通过unmkinitramfs /boot/initrd.img-6.4.0-rc3+ /tmp/initrd/命令解压initrd，探究里面到底有什么玩意。

      -
      ├── bin -> usr/bin
      ├── conf
      ├── etc
      ├── init
      ├── lib -> usr/lib
      ├── lib32 -> usr/lib32
      ├── lib64 -> usr/lib64
      ├── libx32 -> usr/libx32
      ├── run
      ├── sbin -> usr/sbin
      ├── scripts
      ├── usr
      └── var
      init
      - -

      可以看到，这实际上就是一个小型的文件系统，也即initramfs。它有自己的built-in Shell（BusyBox）：

      -

      image-20230616151938951

      -

      有一些较少的Shell命令（bin和sbin目录下），以及用来挂载真正的根文件系统的代码逻辑（存储在scripts目录下）。【我猜】在正常情况下，系统会执行scripts下的脚本代码挂载真正的文件系统。当挂载出现异常时，系统就会将控制权交给initramfs内置的Shell BusyBox，由用户自己探究出了什么问题。

      -

      我们接下来可以追踪下initramfs的script目录下的文件系统挂载流程。

      -

      挂载真正文件系统的主要函数为local_mount_root：

      -
      # 仅展示主要流程代码
      local_mount_root()
      {
      	# 预处理，获取参数等（也即上面grub.cfg配置的root=UUID）
      	local_top
      	if [ -z "${ROOT}" ]; then
      		panic "No root device specified. Boot arguments must include a root= parameter."
      	fi
      	
      	# 根据UUID获取对应的块设备
      	local_device_setup "${ROOT}" "root file system"
      	ROOT="${DEV}"

      	# 挂载前的预处理
      	local_premount
      	
      	# 挂载
      	mount ${roflag} ${FSTYPE:+-t "${FSTYPE}"} ${ROOTFLAGS} "${ROOT}" "${rootmnt?}"
      }
      - -

      由于研究这个是错误驱动（乐），因而我只主要看了下local_device_setup：

      -
      # $1=device ID to mount设备ID
      # $2=optionname (for root and etc)要挂载的是什么玩意，此处应为root file system
      # $3=panic if device is missing (true or false, default: true)
      # Sets $DEV to the resolved device node $DEV是最终获取到的块设备
      local_device_setup()
      {
      	local dev_id="$1"
      	local name="$2"
      	local may_panic="${3:-true}"
      	local real_dev
      	local time_elapsed
      	local count

      	# 获取grub.cfg的rootdelay参数的设备等待时间。如果没有该参数，默认是30秒
      	local slumber=30
      	if [ "${ROOTDELAY:-0}" -gt $slumber ]; then
      		slumber=$ROOTDELAY
      	fi

      	# 等待设备
      	case "$dev_id" in
      	UUID=*|LABEL=*|PARTUUID=*|/dev/*)
      		FSTYPE=$( wait-for-root "$dev_id" "$slumber" )
      		;;
      	*)
      		wait_for_udev 10
      		;;
      	esac

      	# 等待结束了。如果条件为真，说明还是获取不到对应的设备，那就只能说明这个设备死了
      	# 所以我们就得把问题告诉用户，让用户自己解决，并且进入BusyBox Shell
      	# We've given up, but we'll let the user fix matters if they can
      	while ! real_dev=$(resolve_device "${dev_id}") ||
      	      ! get_fstype "${real_dev}" >/dev/null; do
      		if ! $may_panic; then
      			echo "Gave up waiting for ${name}"
      			return 1
      		fi
      		echo "Gave up waiting for ${name} device.  Common problems:"
      		echo " - Boot args (cat /proc/cmdline)"
      		echo "   - Check rootdelay= (did the system wait long enough?)"
      		if [ "${name}" = root ]; then
      			echo "   - Check root= (did the system wait for the right device?)"
      		fi
      		echo " - Missing modules (cat /proc/modules; ls /dev)"
      		panic "ALERT!  ${dev_id} does not exist.  Dropping to a shell!"
      	done

      	DEV="${real_dev}"
      }
      - -

      可以看到，这里如果进入错误状态，最终就是这样的效果2333：

      -

      image-20230616153420011

      -]]> - - os竞赛 - -       - - 状态机 - /2023/03/10/%E5%AF%B9moore%E5%9E%8B%E5%92%8Cmealy%E5%9E%8B%E7%8A%B6%E6%80%81%E6%9C%BA%E7%9A%84%E7%90%86%E8%A7%A3/ - 复习数电时，一道密码锁题令我十分不解：

      -image-20230213201519568 - -

      看到题目时，我首先联想到的是mealy型状态机，因为我联想到了序列检测。课内的序列检测讲的时候是把它当做mealy型的。但看了标准作答之后，才发现它其实应该是moore型。这让我对这二者的区别产生了深深的不解。

      -

      原来对于moore型状态机和mealy型状态机的理解仅仅停留在概念上，“moore型状态机的输出与输入无关，只与当前状态有关”“mealy型状态机输出与输入和现态都有关”。但这其实是一句非常抽象的话：什么是“无关”，什么是“有关”？moore型状态机的状态不也是依据输入进行转移的吗？那么这算不算“有关”？

      -

      探究之后，我得到了更精确的“有关”“无关”的定义。

      -
      -

      来自：Moore状态机和Mealy状态机的区别

      -image-20230213202110900 - -image-20230213202124943 -
      -
      -

      来自：Moore状态机和Mealy状态机的区别(以序列检测器为例)

      -

      Moore状态机输出只与此时的状态有关，因此假如需要检测宽度为4的序列，则需要五个状态。

      -

      Mealy状态机输出与此时的状态以及输入有关，因此假如需要检测宽度为4的序列，只需要四个状态即可。

      -
      -

      联想到我们课上学习的序列检测：

      -image-20230213202320825 - -

      它这明明长度为3的序列用了4个状态，应该算是moore型，为什么我们却被教说序列检测器是mealy型状态机呢？

      -

      原因是因为，我们进行了状态化简这一步，将moore型状态机转化为了mealy型状态机。

      -
      -

      这俩是可以相互转化的

      -

      来自：[转载][FPGA]有限状态机FSM学习笔记（二）

      -

      把Moore机转换为Mealy机的办法为，把次态的输出修改为对应现态的输出，同时合并一些具有等价性能的状态。把Mealy机转换为Moore机的办法是，把当前态的输出修改为对应次态的输出，同时添加一些状态。如图1所示，为把Mealy机状态图转化为Moore机状态图。

      -

      img
      　　　　　　　　图1　　Mealy型机转换为Moore型机

      -

      　　如图1所示，把Mealy型机转换为Moore型机，只要把现时输出改变为下一时刻输出。对于状态A，有4个箭头指向它，表示在当前状态下有4个状态可以转换为下一状态的A；同时当前输出均为0，可以把0移入状态A内部，表示在Moore机中状态A的输出为0。同理，可以把0分别移位B/C状态。但对于状态D，有两个箭头指向且具有不同的输出值，需要把状态D分解成两个状态D1和D2（每个状态对应一个输出，当输出不同需要利用不同的状态表示，这即是Moore机具有更多状态的原因），得到完整的Moore机状态模型。

      -

      　　同理，若把上图的Moore机转换为Mealy机，只要把Moore机中下一状态的输出改变成Mealy机中当前状态的输出，由于D1/D2两状态处于A/C两状态之间，且相当于A/C节点之间的一个等效节点，可以把D1/D2两状态合并为一个状态。

      -
      -
      -

      来自：Moore型状态机和Mealy型状态机

      -

      并非所有时序电路都可以使用Mealy模型实现。 一些时序电路只能作为摩尔机器实现。

      -
      -

      所以，我们可以出此暴论：在课程范围内，首先以moore的思想来设计状态机。如果该状态机可以被化简，那么这道题就要用mealy型的来做；如果不能，那么这道题就是得用moore型状态机来做。

      -

      一开始的那个时序锁的moore状态机不能化简，因此它是moore型。

      +

      值得注意的是，此修改仅对本次启动有效。如果需要长期修改，建议还是通过第一种方法去修改。

      +

      initramfs

      GRUB程序会通过initrd.img启动initramfs，从而进行真正的根文件系统挂载。

      -

      这个点本来可以讲得更清楚一些的……只教会我们做题的套路有啥意思呢←_←

      +

      initrd.img是一个Linux系统中的初始化内存盘（initial RAM disk）的映像文件。它是一个压缩的文件系统映像，通常在引导过程中加载到内存中，并提供了一种临时的根文件系统，以便在正式的根文件系统（通常位于硬盘上）可用之前提供必要的功能和模块。

      +

      我们可以通过unmkinitramfs /boot/initrd.img-6.4.0-rc3+ /tmp/initrd/命令解压initrd，探究里面到底有什么玩意。

      +
      ├── bin -> usr/bin
      ├── conf
      ├── etc
      ├── init
      ├── lib -> usr/lib
      ├── lib32 -> usr/lib32
      ├── lib64 -> usr/lib64
      ├── libx32 -> usr/libx32
      ├── run
      ├── sbin -> usr/sbin
      ├── scripts
      ├── usr
      └── var
      init
      + +

      可以看到，这实际上就是一个小型的文件系统，也即initramfs。它有自己的built-in Shell（BusyBox）：

      +

      image-20230616151938951

      +

      有一些较少的Shell命令（bin和sbin目录下），以及用来挂载真正的根文件系统的代码逻辑（存储在scripts目录下）。【我猜】在正常情况下，系统会执行scripts下的脚本代码挂载真正的文件系统。当挂载出现异常时，系统就会将控制权交给initramfs内置的Shell BusyBox，由用户自己探究出了什么问题。

      +

      我们接下来可以追踪下initramfs的script目录下的文件系统挂载流程。

      +

      挂载真正文件系统的主要函数为local_mount_root：

      +
      # 仅展示主要流程代码
      local_mount_root()
      {
      	# 预处理，获取参数等（也即上面grub.cfg配置的root=UUID）
      	local_top
      	if [ -z "${ROOT}" ]; then
      		panic "No root device specified. Boot arguments must include a root= parameter."
      	fi
      	
      	# 根据UUID获取对应的块设备
      	local_device_setup "${ROOT}" "root file system"
      	ROOT="${DEV}"

      	# 挂载前的预处理
      	local_premount
      	
      	# 挂载
      	mount ${roflag} ${FSTYPE:+-t "${FSTYPE}"} ${ROOTFLAGS} "${ROOT}" "${rootmnt?}"
      }
      + +

      由于研究这个是错误驱动（乐），因而我只主要看了下local_device_setup：

      +
      # $1=device ID to mount设备ID
      # $2=optionname (for root and etc)要挂载的是什么玩意，此处应为root file system
      # $3=panic if device is missing (true or false, default: true)
      # Sets $DEV to the resolved device node $DEV是最终获取到的块设备
      local_device_setup()
      {
      	local dev_id="$1"
      	local name="$2"
      	local may_panic="${3:-true}"
      	local real_dev
      	local time_elapsed
      	local count

      	# 获取grub.cfg的rootdelay参数的设备等待时间。如果没有该参数，默认是30秒
      	local slumber=30
      	if [ "${ROOTDELAY:-0}" -gt $slumber ]; then
      		slumber=$ROOTDELAY
      	fi

      	# 等待设备
      	case "$dev_id" in
      	UUID=*|LABEL=*|PARTUUID=*|/dev/*)
      		FSTYPE=$( wait-for-root "$dev_id" "$slumber" )
      		;;
      	*)
      		wait_for_udev 10
      		;;
      	esac

      	# 等待结束了。如果条件为真，说明还是获取不到对应的设备，那就只能说明这个设备死了
      	# 所以我们就得把问题告诉用户，让用户自己解决，并且进入BusyBox Shell
      	# We've given up, but we'll let the user fix matters if they can
      	while ! real_dev=$(resolve_device "${dev_id}") ||
      	      ! get_fstype "${real_dev}" >/dev/null; do
      		if ! $may_panic; then
      			echo "Gave up waiting for ${name}"
      			return 1
      		fi
      		echo "Gave up waiting for ${name} device.  Common problems:"
      		echo " - Boot args (cat /proc/cmdline)"
      		echo "   - Check rootdelay= (did the system wait long enough?)"
      		if [ "${name}" = root ]; then
      			echo "   - Check root= (did the system wait for the right device?)"
      		fi
      		echo " - Missing modules (cat /proc/modules; ls /dev)"
      		panic "ALERT!  ${dev_id} does not exist.  Dropping to a shell!"
      	done

      	DEV="${real_dev}"
      }
      + +

      可以看到，这里如果进入错误状态，最终就是这样的效果2333：

      +

      image-20230616153420011

      ]]>       + + os竞赛 +       网络是怎样连接的 @@ -12388,14 +12591,254 @@ url访问填写http://localhost/webdemo4_war/*.do。

    3. 在vmware中扩展磁盘容量

      image-20230927191636392

      4. -

    4. sudo fdisk /dev/sda，进行磁盘分区

      -

      在fdisk中输入n，新建sda4分区，然后w保存。

      +

    5. sudo fdisk /dev/sda，进行磁盘分区

      +

      在fdisk中输入n，新建sda4分区，然后w保存。

      +
      6. +

    6. 执行下列命令：

      +
      sudo pvcreate /dev/sda4
      sudo vgcreate ubuntu-vg /dev/sda4
      sudo vgextend ubuntu-vg /dev/sda4
      sudo vgdisplay # 此时应发现FREE变成了100G
      sudo lvresize -l  +100%FREE /dev/mapper/ubuntu--vg-ubuntu--lv
      sudo resize2fs /dev/mapper/ubuntu--vg-ubuntu--lv
      sudo df -h # 验证成功
      7. +
    +

    一开始按照的这个，然后被坑惨了（悲）把lvm sig给抹了，导致之后resize2fs的时候报错，然后之后又不小心重启了，最后的最后只能重装。。。又是一晚上配环境。。。。

    +]]> + + + 阅读JDK容器部分源码的心得体会2【Map部分】 + /2022/10/22/%E9%98%85%E8%AF%BBJDK%E5%AE%B9%E5%99%A8%E9%83%A8%E5%88%86%E6%BA%90%E7%A0%81%E7%9A%84%E5%BF%83%E5%BE%97%E4%BD%93%E4%BC%9A2%E3%80%90Map%E9%83%A8%E5%88%86%E3%80%91/ + +

    idea 替换注释正则表达式/\*{1,2}[\s\S]*?\*/

    +

    typora 替换图片asset

    +

    \!\[.*\]\(D:\\aWorkStorage\\hexo\\blog\\source\\_posts\\阅读JDK容器部分源码的心得体会2【Map部分】\\(.*)\.png\)，

    +

    替换结果{% asset_img $1.png %}

    +
    +

    Map(I)

    +

    A map cannot contain duplicate keys; each key can map to at most one value.

    +

    This interface takes the place of the Dictionary class.

    +

    The Map interface provides three collection views, which allow a map’s contents to be viewed as a set of keys, collection of values, or set of key-value mappings.

    +

    The order of a map is defined as the order in which the iterators on the map’s collection views return their elements. map的元素顺序取决于集合元素顺序的意思？

    +

    Note: great care must be exercised if mutable objects are used as map keys. The behavior of a map is not specified if the value of an object is changed in a manner that affects equals comparisons while the object is a key in the map. 【这个跟set的那个是一样的】

    +
    +

    map没有迭代器

    + + +

    代码：

    public interface Map<K,V> {
        // Query Operations
        
        int size();
        
        boolean isEmpty();
        
        boolean containsKey(Object key);
        
        //This operation will probably require time linear in the map size 
        //for most implementations of the Map interface.
        boolean containsValue(Object value);
        
        //1
        V get(Object key);

        // Modification Operations
        
        V put(K key, V value);
        
        V remove(Object key);

        // Bulk Operations
        
        void putAll(Map<? extends K, ? extends V> m);
        
        void clear();

        // Views
        
        //Returns a Set view of the keys contained in this map.
        //The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. 
        //The set supports element removal, 
        //which removes the corresponding mapping from the map, 
        //via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. 
        //It does not support the add or addAll operations.
        //2
        Set<K> keySet();
        
        //跟上面一样，也只支持remove，不支持add
        Collection<V> values();
        
        //3
        //跟上面一样，也只支持remove，不支持add
        Set<Map.Entry<K, V>> entrySet();

        //The only way to obtain a reference to a map entry is from the iterator of this collection-view.
        //These Map.Entry objects are valid only for the duration of the iteration;
        //more formally, the behavior of a map entry is undefined if the backing map has been
        //modified after the entry was returned by the iterator, 
        //except through the setValue operation on the map entry.迭代器也不行了
        //可见度为default，包内可见
        interface Entry<K,V> {
            
            K getKey();
            
            V getValue();
            
            V setValue(V value);
            
            boolean equals(Object o);
            
            int hashCode();
            
            public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
                return (Comparator<Map.Entry<K, V>> & Serializable)
                        (c1, c2) -> c1.getKey().compareTo(c2.getKey());
            }
            
            public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
                return (Comparator<Map.Entry<K, V>> & Serializable)
                        (c1, c2) -> c1.getValue().compareTo(c2.getValue());
            }
            
            public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
                Objects.requireNonNull(cmp);
                return (Comparator<Map.Entry<K, V>> & Serializable)
                        (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
            }
            
            public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
                Objects.requireNonNull(cmp);
                return (Comparator<Map.Entry<K, V>> & Serializable)
                        (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
            }
        }
        
        // Comparison and hashing
        
        boolean equals(Object o);
        
        int hashCode();

        // Defaultable methods
        
        //1
        default V getOrDefault(Object key, V defaultValue) {
            V v;
            return (((v = get(key)) != null) || containsKey(key))
                    ? v
                    : defaultValue;
        }
        
        default void forEach(BiConsumer<? super K, ? super V> action) {
            Objects.requireNonNull(action);
            for (Map.Entry<K, V> entry : entrySet()) {
                K k;
                V v;
                try {
                    k = entry.getKey();
                    v = entry.getValue();
                } catch(IllegalStateException ise) {
                    // this usually means the entry is no longer in the map.
                    //确实说明这时候应该并发修改异常了
                    throw new ConcurrentModificationException(ise);
                }
                action.accept(k, v);
            }
        }
        
        default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            Objects.requireNonNull(function);
            for (Map.Entry<K, V> entry : entrySet()) {
                K k;
                V v;
                try {
                    k = entry.getKey();
                    v = entry.getValue();
                } catch(IllegalStateException ise) {
                    // this usually means the entry is no longer in the map.
                    throw new ConcurrentModificationException(ise);
                }

                // ise thrown from function is not a cme.
                v = function.apply(k, v);

                try {
                    entry.setValue(v);
                } catch(IllegalStateException ise) {
                    // this usually means the entry is no longer in the map.
                    throw new ConcurrentModificationException(ise);
                }
            }
        }

        //If the specified key 没有mapping或者对应值为空
        //associates it with the given value and returns null, 
        //else returns the current value.
        default V putIfAbsent(K key, V value) {
            V v = get(key);
            if (v == null) {
                v = put(key, value);
            }

            return v;
        }

        //当所给的key对应的curValue==value时，就remove掉这对mapping
        default boolean remove(Object key, Object value) {
            Object curValue = get(key);
            if (!Objects.equals(curValue, value) ||
                    (curValue == null && !containsKey(key))) {
                return false;
            }
            remove(key);
            return true;
        }

        default boolean replace(K key, V oldValue, V newValue) {
            Object curValue = get(key);
            if (!Objects.equals(curValue, oldValue) ||
                    (curValue == null && !containsKey(key))) {
                return false;
            }
            put(key, newValue);
            return true;
        }

        //如果映射存在就replace，返回旧值
        default V replace(K key, V value) {
            V curValue;
            if (((curValue = get(key)) != null) || containsKey(key)) {
                curValue = put(key, value);
            }
            return curValue;
        }

        //通过mappingFunction来用key计算value
        //4
        default V computeIfAbsent(K key,
                                  Function<? super K, ? extends V> mappingFunction) {
            Objects.requireNonNull(mappingFunction);
            V v;
            if ((v = get(key)) == null) {
                V newValue;
                if ((newValue = mappingFunction.apply(key)) != null) {
                    put(key, newValue);
                    return newValue;
                }
            }

            return v;
        }
        
        //If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
    	//If the function returns null, the mapping is removed.【此时传入的function计算得出value=NULL】
        //If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.
        default V computeIfPresent(K key,
                                   BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            Objects.requireNonNull(remappingFunction);
            V oldValue;
            if ((oldValue = get(key)) != null) {
                V newValue = remappingFunction.apply(key, oldValue);
                if (newValue != null) {
                    put(key, newValue);
                    return newValue;
                } else {
                    remove(key);
                    return null;
                }
            } else {
                return null;
            }
        }
        
        //跟上面那个的差别好像在，当oldValue==NULL，newValue不等于NULL时，下面这个会放入mapp(key,new)
        //上面那个什么也不做。毕竟上面的叫computeIfPresent嘛
        default V compute(K key,
                          BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            Objects.requireNonNull(remappingFunction);
            V oldValue = get(key);

            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue == null) {
                // delete mapping
                //新value==NULL，就delete
                if (oldValue != null || containsKey(key)) {
                    // something to remove
                    remove(key);
                    return null;
                } else {
                    // nothing to do. Leave things as they were.
                    return null;
                }
            } else {
                // add or replace old mapping
                put(key, newValue);
                return newValue;
            }
        }
        
        //把新旧值通过function合并
        //5
        default V merge(K key, V value,
                        BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
            Objects.requireNonNull(remappingFunction);
            Objects.requireNonNull(value);
            V oldValue = get(key);
            //传入function的必定非空
            V newValue = (oldValue == null) ? value :
                    remappingFunction.apply(oldValue, value);
            if(newValue == null) {
                remove(key);
            } else {
                put(key, newValue);
            }
            return newValue;
        }
        
        //6 迭代
    }
    + +

    其中：

      +

    1. get return null时的情况

      get return null when value==NULL or key不存在。

      +

      为了区分这两种情况，写代码时可以用：

      +
      if !containsKey(key){
      	key不存在
      }
      Obj obj=get(key);
      + +

      其实源码中的getordefault方法就给出了应用典范

      +
      default V getOrDefault(Object key, V defaultValue) {
          V v;
          return (((v = get(key)) != null) || containsKey(key))
              ? v
              : defaultValue;
      }
      2. +

    2. view

      +

      //Returns a Set view of the keys contained in this map.

      +

      //The set is backed by the map, so changes to the map are reflected in the set, and vice-versa.

      +
      +

      如下代码测试：

      +
          public static void main(String[] args) {
              HashMap<String,Integer> map = new HashMap<>();
              map.put("Lily",15);
              map.put("Sam",20);
              map.put("Mary",11);
              map.put("Lee",111);
              Set set=map.keySet();
              for( Object str : set){
                  System.out.print((String) str+" ");
              }
              System.out.println();
              set.remove("Lee");
              //set.add("haha");
              for( Object str : set){
                  System.out.print((String) str+" ");
              }
              System.out.println();
              for (Object str : map.keySet()){
                  System.out.print((String) str+" ");
              }
              System.out.println();
              System.out.println(map.containsKey("Lee"));
          }
      /*
      Lee Lily Sam Mary 
      Lily Sam Mary 
      Lily Sam Mary 
      false
      */
      + +

      可得，与之前的List一样，这个view都是纯粹基于原数组的，实时变化的。

      +

      在应用中可发现，可以通过map的key和value的set来对map进行遍历。

      +
      3. +

    3. entrySet

      +
      //The map can be modified while an iteration over the set is in progress 
      //when using the setValue operation on a map entry returned by the iterator
      //or through the iterator's own remove operation
      +
      +

      相比于其它的view，多了第二句话

      +
      4. +

    4. computeIfAbsent

      +

      If the function returns null no mapping is recorded.

      +

      If the function itself throws an (unchecked) exception, the exception is rethrown, and no mapping is recorded.

      +

      The most common usage is to construct a new object serving as an initial mapped value or memoized result, as in:

      +
      map.computeIfAbsent(key, k -> new Value(f(k)));
      + +

      Or to implement a multi-value map, Map<K,Collection>, supporting multiple values per key:

      +
      map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
      +
      +

      它这说的还是很抽象的，下面给出一个使用computeIfAbsent的优雅实例：

      +

      TreeMap()) Treemap With Object

      +
      +

      computeIfAbsent returns the value that is already present in the map, or otherwise evaluates the lambda and puts that into the map, and returns that value.

      +
      +
      var line = "line";      
      var mp = new TreeMap<String,TreeMap<String,Integer>>();     
      var m = mp.computeIfAbsent(line, k -> new TreeMap<>());
      m.put("content", 5);
      System.out.println(mp);
      //output:{line={content=5}}
      + +

      computIfAbsent发现此时map里面没有这个“line”key，就执行第二个参数的lambda表达式，把一个new TreeMap<>以line为关键字放入，并且返回该TreeMap。

      +
      5. +

    5. merge

      +

      看起来非常实用：

      +

      This method may be of use when combining multiple mapped values for a key【相同key不同value合并】. For example, to either create or append a String msg to a value mapping:

      +
      map.merge(key, msg, String::concat)
      + +

      所举代码段意为把新值通过字符串拼接接在旧值后面。

      +

      应该也可以用于集合合并。总之具体实现方法取决于传入的function参数，非常实用

      +
      +
      6. +

    6. 迭代器

      map本身没有迭代器。

      +

      因而在对map进行遍历时，只能通过其keyset、valueset以及entryset来实现。

      +

      具体详见：HashMap的四种遍历方式

      +
      7. +
    +

    AbstractMap

    +

    To implement an unmodifiable map, the programmer needs only to extend this class and provide an implementation for the entrySet method, which returns a set-view of the map’s mappings. Typically, the returned set will, in turn, be implemented atop AbstractSet. This set should not support the add or remove methods, and its iterator should not support the remove method.

    +

    To implement a modifiable map, the programmer must additionally override this class’s put method (which otherwise throws an UnsupportedOperationException), and the iterator returned by entrySet().iterator() must additionally implement its remove method.

    +
    + + +

    最核心的还是entrySet。其余所有的方法，都是通过enrtSet实现的。而给定了enrty这个数据结构的实现方式，剩下的就是entrySet具体怎么实现了。AbstractMap把entrySet的实现抽象了出来，交给了其实现类去具体实现。

    +

    代码：

    public abstract class AbstractMap<K,V> implements Map<K,V> {
        
        protected AbstractMap() {
        }

        // Query Operations
        
        public int size() {
            //还真确实是set的大小
            return entrySet().size();
        }
        
        public boolean isEmpty() {
            return size() == 0;
        }
        
        public boolean containsValue(Object value) {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            if (value==null) {
                while (i.hasNext()) {
                    //entrySet的元素是Entry
                    Entry<K,V> e = i.next();
                    if (e.getValue()==null)
                        return true;
                }
            } else {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (value.equals(e.getValue()))
                        return true;
                }
            }
            return false;
        }
        
        public boolean containsKey(Object key) {
            Iterator<Map.Entry<K,V>> i = entrySet().iterator();
            if (key==null) {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (e.getKey()==null)
                        return true;
                }
            } else {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (key.equals(e.getKey()))
                        return true;
                }
            }
            return false;
        }
        
        public V get(Object key) {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            if (key==null) {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (e.getKey()==null)
                        return e.getValue();
                }
            } else {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (key.equals(e.getKey()))
                        return e.getValue();
                }
            }
            return null;
        }

        // Modification Operations
        
        public V put(K key, V value) {
            throw new UnsupportedOperationException();
        }
        
        //为啥unmodifiable map还可以remove
        public V remove(Object key) {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            Entry<K,V> correctEntry = null;
            if (key==null) {
                while (correctEntry==null && i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (e.getKey()==null)
                        correctEntry = e;
                }
            } else {
                while (correctEntry==null && i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (key.equals(e.getKey()))
                        correctEntry = e;
                }
            }

            V oldValue = null;
            if (correctEntry !=null) {
                oldValue = correctEntry.getValue();
                i.remove();
            }
            return oldValue;
        }

        // Bulk Operations
        
        public void putAll(Map<? extends K, ? extends V> m) {
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
                put(e.getKey(), e.getValue());
        }
        
        public void clear() {
            //还真是
            entrySet().clear();
        }

        // Views
        //1
        transient Set<K>        keySet;
        transient Collection<V> values;
        
        //The set supports element removal via 
        //the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. 
        //It does not support the add or addAll operations.
        //只删不加
        public Set<K> keySet() {
            //引用成员变量，减少访问堆次数
            Set<K> ks = keySet;
            //首次建立视图
            if (ks == null) {
                ks = new AbstractSet<K>() {
                    public Iterator<K> iterator() {
                        return new Iterator<K>() {
                            private Iterator<Entry<K,V>> i = entrySet().iterator();
                        
                            public boolean hasNext() {
                                return i.hasNext();
                            }
                            
                            public K next() {
                                return i.next().getKey();
                            }

                            public void remove() {
                                i.remove();
                            }
                        };
                    }
    				
                    //AbtractMap的这些方法都是通过其entryset实现的。因此其实最主要的还是entryset怎么实现的
                    public int size() {
                        return AbstractMap.this.size();
                    }

                    public boolean isEmpty() {
                        return AbstractMap.this.isEmpty();
                    }

                    public void clear() {
                        AbstractMap.this.clear();
                    }

                    public boolean contains(Object k) {
                        return AbstractMap.this.containsKey(k);
                    }
                };
                //赋值回给成员变量
                keySet = ks;
            }
            return ks;
        }
        
        public Collection<V> values() {
            Collection<V> vals = values;
            if (vals == null) {
                vals = new AbstractCollection<V>() {
                    public Iterator<V> iterator() {
                        return new Iterator<V>() {
                            private Iterator<Entry<K,V>> i = entrySet().iterator();

                            public boolean hasNext() {
                                return i.hasNext();
                            }

                            public V next() {
                                return i.next().getValue();
                            }

                            public void remove() {
                                i.remove();
                            }
                        };
                    }

                    public int size() {
                        return AbstractMap.this.size();
                    }

                    public boolean isEmpty() {
                        return AbstractMap.this.isEmpty();
                    }

                    public void clear() {
                        AbstractMap.this.clear();
                    }

                    public boolean contains(Object v) {
                        return AbstractMap.this.containsValue(v);
                    }
                };
                values = vals;
            }
            return vals;
        }

        //有待不同的数据结构实现了
        public abstract Set<Entry<K,V>> entrySet();

        // Comparison and hashing
        
        public boolean equals(Object o) {
            if (o == this)
                return true;

            if (!(o instanceof Map))
                return false;
            Map<?,?> m = (Map<?,?>) o;
            if (m.size() != size())
                return false;

            try {
                Iterator<Entry<K,V>> i = entrySet().iterator();
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    K key = e.getKey();
                    V value = e.getValue();
                    if (value == null) {
                        if (!(m.get(key)==null && m.containsKey(key)))
                            return false;
                    } else {
                        if (!value.equals(m.get(key)))
                            return false;
                    }
                }
            } catch (ClassCastException unused) {
                return false;
            } catch (NullPointerException unused) {
                return false;
            }

            return true;
        }
        
        public int hashCode() {
            int h = 0;
            Iterator<Entry<K,V>> i = entrySet().iterator();
            while (i.hasNext())
                h += i.next().hashCode();
            return h;
        }
        
        public String toString() {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            if (! i.hasNext())
                return "{}";

            StringBuilder sb = new StringBuilder();
            sb.append('{');
            for (;;) {
                Entry<K,V> e = i.next();
                K key = e.getKey();
                V value = e.getValue();
                //经典防自环
                sb.append(key   == this ? "(this Map)" : key);
                sb.append('=');
                sb.append(value == this ? "(this Map)" : value);
                if (! i.hasNext())
                    return sb.append('}').toString();
                sb.append(',').append(' ');
            }
        }
        
        protected Object clone() throws CloneNotSupportedException {
            AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone();
            //也就只有这两个成员变量了
            result.keySet = null;
            result.values = null;
            return result;
        }
        
        private static boolean eq(Object o1, Object o2) {
            return o1 == null ? o2 == null : o1.equals(o2);
        }

        // Implementation Note: SimpleEntry and SimpleImmutableEntry
        // are distinct unrelated classes, even though they share
        // some code. Since you can't add or subtract final-ness
        // of a field in a subclass, they can't share representations,
        // and the amount of duplicated code is too small to warrant
        // exposing a common abstract class.
        //意思就是说，这两个类一个表示key不可变value可变的entry，也就是可变map，
        //另一个表示key和value都不可变的entry，也就是固定map，
        //这俩有很多重复代码，但不能统一到一起，是因为前者有一个final字段，后者有两个，
        //无法对这个final字段做一个统一，因此只能分成两个了
        
        //静态内部类
        //对Entry接口的一个简单实现【key不可变，value可变】
        public static class SimpleEntry<K,V>
                implements Entry<K,V>, java.io.Serializable
        {
            private static final long serialVersionUID = -8499721149061103585L;

            //key不可修改，value可修改
            private final K key;
            private V value;
            
            public SimpleEntry(K key, V value) {
                this.key   = key;
                this.value = value;
            }
            
            public SimpleEntry(Entry<? extends K, ? extends V> entry) {
                this.key   = entry.getKey();
                this.value = entry.getValue();
            }
            
            public K getKey() {
                return key;
            }
            
            public V getValue() {
                return value;
            }
            
            public V setValue(V value) {
                V oldValue = this.value;
                this.value = value;
                return oldValue;
            }
            
            public boolean equals(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                return eq(key, e.getKey()) && eq(value, e.getValue());
            }
            
            public int hashCode() {
                //注意这里是异或
                return (key   == null ? 0 :   key.hashCode()) ^
                        (value == null ? 0 : value.hashCode());
            }
            
            public String toString() {
                return key + "=" + value;
            }

        }
        
        //静态内部类
        //对Entry接口的一个简单实现【key不可变，value不可变】
        public static class SimpleImmutableEntry<K,V>
                implements Entry<K,V>, java.io.Serializable
        {
            private static final long serialVersionUID = 7138329143949025153L;

            private final K key;
            private final V value;
            
            public SimpleImmutableEntry(K key, V value) {
                this.key   = key;
                this.value = value;
            }
            
            public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
                this.key   = entry.getKey();
                this.value = entry.getValue();
            }
            
            public K getKey() {
                return key;
            }
            
            public V getValue() {
                return value;
            }
            
            public V setValue(V value) {
                //exception
                throw new UnsupportedOperationException();
            }
            
            public boolean equals(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                return eq(key, e.getKey()) && eq(value, e.getValue());
            }
            
            public int hashCode() {
                return (key   == null ? 0 :   key.hashCode()) ^
                        (value == null ? 0 : value.hashCode());
            }
            
            public String toString() {
                return key + "=" + value;
            }
        }
    }
    + +

    其中：

      +

    1. view

      +

      Each of these fields are initialized to contain an instance of the appropriate view the first time this view is requested. The views are stateless, so there’s no reason to create more than one of each.

      +
      +

      不同于之前List的sublist和sorted set的subset，它俩是调用创建view方法时才构造出一个新的对象，map是直接把values和keys视图放入成员变量了，因为Collection的视图从实用角度来说有起始和终点更实用，map不需要这个性质，因此作为成员变量花费更小

      +
      2. +
    +

    HashMap

    哈希表+链表/红黑树

    +
    +

    permits null values and the null key允许空，其hash应该是0

    +

    The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls.不同步

    +

    This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.无序

    +

    这应该差不多就是个桶链表

    +

    An instance of HashMap has two parameters that affect its performance: initial capacity and load factor.

    +

    The capacity is the number of buckets in the hash table.桶数量=capacity

    +

    The load factor is a measure of how full the hash table is allowed to get before its capacity is automatically increased. 如果装载百分比达到load factor，hashmap的capacity就会自动增长。

    +

    When the number of entries in the hash table exceeds the product of the load factor and the current capacity, the hash table is rehashed.如果元素数量>=load factor*capacity，就会自动增长并且重新hash。

    +

    默认的load factor是0.75.【我其实觉得这个数很有意思。它是二进制意义上的整除数，因而计算应该很方便：它可以被整整表示，并且计算时可以拆成“2^-1+2^-2”以供移位简化】

    +

    我们设置capacity和load factor的意图应该是要尽量减少rehash的次数。

    +

    Note that using many keys with the same hashCode() is a sure way to slow down performance of any hash table使用多个相同的key【指hashcode相同】会降低性能【？】

    +

    https://stackoverflow.com/questions/43911369/hashmap-java-8-implementation等会看看

    +
    +

    总之意思差不多就是，hashmap的数据结构：

    +

    table数组，每个成员都是一个桶，桶里面装着结点。table默认长度为16

    +

    每个桶内结点的结构依具体情况（该桶内元素多少）来决定，桶内元素多则用树状结构，少就用简单的线性表结构。线性结构为Node<K,V>，树状结构为TreeNode<K,V>。

    +

    当一个线性表桶内结点多于临界值，就需要进行树化，会从链表变成红黑树；当整个hashmap结点数多于临界值，就需要增长capacity并且进行rehash。

    +

    hashmap的桶的装配：首先通过key的hashcode算出一个hash值，然后再把该hash值与n-1相与就能得到桶编号。接下来再在桶内找到应插入的结点就行。

    +

    代码：

    public class HashMap<K,V> extends AbstractMap<K,V>
            implements Map<K,V>, Cloneable, Serializable {
        
        private static final long serialVersionUID = 362498820763181265L;
        
        /*
        此映射通常充当分箱（分桶）哈希表，但当箱变得太大时，它们会转换为 TreeNode 的箱，
        每个结构类似于 java.util.TreeMap 中的结构。 
        大多数方法尝试使用正常的 bin，但出于实用性有时候会过渡到 TreeNode 方法（只需检查节点的实例）。
        TreeNode 的 bin 可以像任何其他 bin 一样被遍历和使用，但在填充过多时还支持更快的查找。 
        但是，由于绝大多数正常使用的 bin 并没有过度填充，
        因此在 table 方法的过程中检查树 bin 的存在可能会白花时间。
        
        因为 TreeNode 的大小大约是常规节点的两倍，
        所以我们仅在 bin 包含足够的节点以保证使用时才使用它们（请参阅 TREEIFY_THRESHOLD）。 
        当它们变得太小（由于移除或调整大小）时，它们会被转换回plain bins。
        */
        
        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
        
        static final int MAXIMUM_CAPACITY = 1 << 30;
        
        static final float DEFAULT_LOAD_FACTOR = 0.75f;
        
        /*
        The bin count 临界值 for using a tree rather than list for a bin. 
        当桶内节点数大于等于该值时，桶将由链表连接转化为树状结构。 
        该值必须大于 2 并且应该至少为 8，以便与树移除中关于在收缩时转换回普通 bin 的假设相吻合。
        */
        static final int TREEIFY_THRESHOLD = 8;
        
        //The bin count threshold for untreeifying a (split) bin during a resize operation. 
        static final int UNTREEIFY_THRESHOLD = 6;
        
        /*
        The smallest table capacity for which bins may be treeified.
        (Otherwise the table is resized if too many nodes in a bin.) 
        Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts between 
        resizing and treeification thresholds.
        */
        static final int MIN_TREEIFY_CAPACITY = 64;
        
        static class Node<K,V> implements Map.Entry<K,V> {
            //一旦被构造器初始化，就不可变。
            final int hash;
            //结点的键不变，但值可变
            final K key;
            V value;
            //链表结构
            Node<K,V> next;

            Node(int hash, K key, V value, Node<K,V> next) {
                this.hash = hash;
                this.key = key;
                this.value = value;
                this.next = next;
            }

            public final K getKey()        { return key; }
            public final V getValue()      { return value; }
            public final String toString() { return key + "=" + value; }

            //也就是说它自己的hashcode和构造时给它的hash是不一样的
            public final int hashCode() {
                return Objects.hashCode(key) ^ Objects.hashCode(value);
            }

            public final V setValue(V newValue) {
                V oldValue = value;
                value = newValue;
                return oldValue;
            }

            public final boolean equals(Object o) {
                if (o == this)
                    return true;
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                    if (Objects.equals(key, e.getKey()) &&
                            Objects.equals(value, e.getValue()))
                        return true;
                }
                return false;
            }
        }
        
        /* ----------------静态共用方法-------------- */
        
        //hash的计算方法
        //1
        static final int hash(Object key) {
            int h;
            //逻辑右移
            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        }
        
        //3
        static Class<?> comparableClassFor(Object x) {
            if (x instanceof Comparable) {
                Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
                if ((c = x.getClass()) == String.class) // bypass checks
                    return c;
                //检查所有接口
                if ((ts = c.getGenericInterfaces()) != null) {
                    for (int i = 0; i < ts.length; ++i) {
                        if (((t = ts[i]) instanceof ParameterizedType) &&
                                ((p = (ParameterizedType)t).getRawType() ==
                                        Comparable.class) &&
                                (as = p.getActualTypeArguments()) != null &&
                                as.length == 1 && as[0] == c) // type arg is c
                            return c;
                    }
                }
            }
            return null;
        }
        
        @SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
        static int compareComparables(Class<?> kc, Object k, Object x) {
            return (x == null || x.getClass() != kc ? 0 :
                    //会调用最新版本的方法
                    ((Comparable)k).compareTo(x));
        }
        
        //这一通操作可以得到比cap大的，且离cap最近的2的幂次方数
        static final int tableSizeFor(int cap) {
            int n = cap - 1;
            n |= n >>> 1;
            n |= n >>> 2;
            n |= n >>> 4;
            n |= n >>> 8;
            n |= n >>> 16;
            return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
        }
        
        /* ---------------- Fields -------------- */
        
        /*
        The table, initialized on first use, and resized as necessary. 
        长度是2的幂次或者0【初始】
        */
        transient Node<K,V>[] table;
        
        //4
        transient Set<Map.Entry<K,V>> entrySet;
        
        //初始为0，每put一次元素就++。
        transient int size;
        
        transient int modCount;
        
        //达到此值时hashmap需要增长capacity并且rehash
        // (可序列化
        // Additionally, if the table array has not been allocated, this
        // field holds the initial array capacity, or zero signifying
        // DEFAULT_INITIAL_CAPACITY.)
        int threshold;
        
        final float loadFactor;
        
        /* ---------------- Public operations -------------- */
        
        public HashMap(int initialCapacity, float loadFactor) {
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal initial capacity: " +
                        initialCapacity);
            if (initialCapacity > MAXIMUM_CAPACITY)
                initialCapacity = MAXIMUM_CAPACITY;
            if (loadFactor <= 0 || Float.isNaN(loadFactor))
                throw new IllegalArgumentException("Illegal load factor: " +
                        loadFactor);
            this.loadFactor = loadFactor;
            this.threshold = tableSizeFor(initialCapacity);
        }
        
        public HashMap(int initialCapacity) {
            this(initialCapacity, DEFAULT_LOAD_FACTOR);
        }
        
        public HashMap() {
            this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
        }
        
        public HashMap(Map<? extends K, ? extends V> m) {
            this.loadFactor = DEFAULT_LOAD_FACTOR;
            putMapEntries(m, false);
        }
        
        //Implements Map.putAll and 上面的Map constructor的辅助方法
        //evict – false when initially constructing this map, else true 
        final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
            int s = m.size();
            if (s > 0) {
                if (table == null) { // pre-size
                    //+1保证了至少比m大
                    float ft = ((float)s / loadFactor) + 1.0F;
                    int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                            (int)ft : MAXIMUM_CAPACITY);
                    if (t > threshold)
                        threshold = tableSizeFor(t);
                    //延迟resize，随处可见的懒汉思想，很聪明
                }
                else if (s > threshold)
                    //就地resize
                    resize();
                for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                    K key = e.getKey();
                    V value = e.getValue();
                    putVal(hash(key), key, value, false, evict);
                }
            }
        }
        
        public int size() {
            return size;
        }
        
        public boolean isEmpty() {
            return size == 0;
        }
        
        public V get(Object key) {
            Node<K,V> e;
            return (e = getNode(hash(key), key)) == null ? null : e.value;
        }
        
        final Node<K,V> getNode(int hash, Object key) {
            Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
            if ((tab = table) != null && (n = tab.length) > 0 &&
                    (first = tab[(n - 1) & hash]) != null) {
                if (first.hash == hash && // always check first node
                        ((k = first.key) == key || (key != null && key.equals(k))))
                    return first;
                if ((e = first.next) != null) {
                    if (first instanceof TreeNode)
                        return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                    do {
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))
                            return e;
                    } while ((e = e.next) != null);
                }
            }
            return null;
        }
        
        public boolean containsKey(Object key) {
            return getNode(hash(key), key) != null;
        }

        //put方法的实现
        public V put(K key, V value) {
            //计算key的哈希值
            return putVal(hash(key), key, value, false, true);
        }

        //evict – false when initially constructing this map, else true 
        //Implements Map.put and related methods.
        final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                       boolean evict) {
            Node<K,V>[] tab; Node<K,V> p; int n, i;
            if ((tab = table) == null || (n = tab.length) == 0)
                //此处调用resize初始化
                n = (tab = resize()).length;
            //n为table大小
            //首先先找到所在桶
            //如果所在桶不存在，就直接申请一个新桶（结点）放
            //2此处找桶的方式
            if ((p = tab[i = (n - 1) & hash]) == null)
                tab[i] = newNode(hash, key, value, null);
            //所在桶存在
            else {
                //e为要塞进去value的结点，k为临时变量，用于存储key值
                Node<K,V> e; K k;
                //如果p的哈希值为key的哈希值，并且p的key==key，说明键本来就存在，并且正好是桶内第一个元素，只需修改旧键值对的value就行
                if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                    //e=旧结点
                    e = p;
                //否则需要沿着桶的结构继续往下找，这时候就需要看桶内用的是树状结构还是顺序结构了
                //如果此时用的是树状结构
                else if (p instanceof TreeNode)
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                //用的是顺序结构
                else {
                    for (int binCount = 0; ; ++binCount) {
                        //走到桶尽头，此时e==NULL
                        if ((e = p.next) == null) {
                            p.next = newNode(hash, key, value, null);
                            //到达临界点，需要树化
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                treeifyBin(tab, hash);
                            break;
                        }
                        //一直走，直到找到
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))
                            break;
                        //两个指针来回交替往下走
                        p = e;
                    }
                }
                //上面可以看到，只有原来就存在键值对才会满足此条件
                if (e != null) { // existing mapping for key
                    V oldValue = e.value;
                    //onlyIfAbsent – if true, don't change existing value 除非旧值为空
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value;
                    //空操作，方便LinkedHashMap的后续实现
                    afterNodeAccess(e);
                    //存在旧键值对的情况至此结束
                    return oldValue;
                }
            }
            //走到这说明是新建了一个结点
            ++modCount;
            if (++size > threshold)
                resize();
            //空操作，方便LinkedHashMap的后续实现
            afterNodeInsertion(evict);
            return null;
        }

        //Initializes or doubles table size. 
        final Node<K,V>[] resize() {
            Node<K,V>[] oldTab = table;
            int oldCap = (oldTab == null) ? 0 : oldTab.length;
            int oldThr = threshold;
            int newCap, newThr = 0;
            
            //决定newCap和newThr
            if (oldCap > 0) {
                if (oldCap >= MAXIMUM_CAPACITY) {
                    threshold = Integer.MAX_VALUE;
                    return oldTab;
                }
                //扩容两倍
                else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                        oldCap >= DEFAULT_INITIAL_CAPACITY)
                    newThr = oldThr << 1; // double threshold
            }
            else if (oldThr > 0) // initial capacity was placed in threshold
                //因为此时capacity已经需要向threshold转变了，因而newThr需要再计算
                newCap = oldThr;
            else {               // zero initial threshold signifies using defaults
                newCap = DEFAULT_INITIAL_CAPACITY;
                newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
            }
            if (newThr == 0) {
                float ft = (float)newCap * loadFactor;
                newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                        (int)ft : Integer.MAX_VALUE);
            }
            threshold = newThr;
            
            @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
            table = newTab;
            if (oldTab != null) {
                //需要复制原oldTab中的每个结点
                for (int j = 0; j < oldCap; ++j) {
                    Node<K,V> e;
                    if ((e = oldTab[j]) != null) {
                        oldTab[j] = null;
                        //该桶只有一个结点
                        if (e.next == null)
                            newTab[e.hash & (newCap - 1)] = e;
                        else if (e instanceof TreeNode)
                            ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                        else { // preserve order
                            //5
                            Node<K,V> loHead = null, loTail = null;
                            Node<K,V> hiHead = null, hiTail = null;
                            Node<K,V> next;
                            do {
                                next = e.next;
                                if ((e.hash & oldCap) == 0) {
                                    if (loTail == null)
                                        loHead = e;
                                    else
                                        loTail.next = e;
                                    loTail = e;
                                }
                                else {
                                    if (hiTail == null)
                                        hiHead = e;
                                    else
                                        hiTail.next = e;
                                    hiTail = e;
                                }
                            } while ((e = next) != null);
                            if (loTail != null) {
                                loTail.next = null;
                                newTab[j] = loHead;
                            }
                            if (hiTail != null) {
                                hiTail.next = null;
                                newTab[j + oldCap] = hiHead;
                            }
                        }
                    }
                }
            }
            return newTab;
        }
        
        //树化桶
        final void treeifyBin(Node<K,V>[] tab, int hash) {
            int n, index; Node<K,V> e;
            //如果表的一个桶结点数大于8（TREEIFY_THRESHOLD），但是表的总结点数小于64（MIN_TREEIFY_CAPACITY）也是不会树化的，只会resize重新hash
            if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                resize();
            //需要树化
            //取得该桶的头结点e
            else if ((e = tab[index = (n - 1) & hash]) != null) {
                TreeNode<K,V> hd = null, tl = null;
                do {
                    //replacementTreeNode return new TreeNode<>(p.hash, p.key, p.value, next);
                    TreeNode<K,V> p = replacementTreeNode(e, null);
                    if (tl == null)
                        //此时有0个结点
                        hd = p;
                    else {
                        p.prev = tl;
                        tl.next = p;
                    }
                    tl = p;
                } while ((e = e.next) != null);
                if ((tab[index] = hd) != null)
                    //只树化该桶
                    hd.treeify(tab);
            }
        }
        
        //对于重复键需替换
        public void putAll(Map<? extends K, ? extends V> m) {
            putMapEntries(m, true);
        }
        
        //Returns:the previous value
        public V remove(Object key) {
            Node<K,V> e;
            return (e = removeNode(hash(key), key, null, false, true)) == null ?
                    null : e.value;
        }
        
        //matchValue – if true only remove if value is equal
        //value – the value to match if matchValue, else ignored
        //movable – if false do not move other nodes while removing用于树
        final Node<K,V> removeNode(int hash, Object key, Object value,
                                   boolean matchValue, boolean movable) {
            Node<K,V>[] tab; Node<K,V> p; int n, index;
            //table和键都存在
            if ((tab = table) != null && (n = tab.length) > 0 &&
                    (p = tab[index = (n - 1) & hash]) != null) {
                //node为要移走的结点
                Node<K,V> node = null, e; K k; V v;
                //检查头结点
                if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                    node = p;
                else if ((e = p.next) != null) {
                    if (p instanceof TreeNode)
                        node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                    else {
                        do {
                            if (e.hash == hash &&
                                    ((k = e.key) == key ||
                                            (key != null && key.equals(k)))) {
                                node = e;
                                break;
                            }
                            p = e;
                        } while ((e = e.next) != null);
                    }
                }
                //需要移走
                if (node != null && (!matchValue || (v = node.value) == value ||
                        (value != null && value.equals(v)))) {
                    if (node instanceof TreeNode)
                        ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                    //由上文可知，此时node==p==头结点
                    //能找到这个差异点也是真牛逼
                    else if (node == p)
                        tab[index] = node.next;
                    //此时p.next=node
                    else
                        p.next = node.next;
                    ++modCount;
                    --size;
                    afterNodeRemoval(node);
                    return node;
                }
            }
            return null;
        }
        
        public void clear() {
            Node<K,V>[] tab;
            modCount++;
            if ((tab = table) != null && size > 0) {
                size = 0;
                for (int i = 0; i < tab.length; ++i)
                    tab[i] = null;//我知道你要说什么：let GC do its work
            }
        }
        
        //遍历。有树优化的话可以减少时间开销。
        public boolean containsValue(Object value) {
            Node<K,V>[] tab; V v;
            if ((tab = table) != null && size > 0) {
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                        if ((v = e.value) == value ||
                                (value != null && value.equals(v)))
                            return true;
                    }
                }
            }
            return false;
        }
        
        public Set<K> keySet() {
            Set<K> ks = keySet;
            if (ks == null) {
                //是HashMap自己实现的keyset
                ks = new KeySet();
                keySet = ks;
            }
            return ks;
        }

        final class KeySet extends AbstractSet<K> {
            public final int size()                 { return size; }
            public final void clear()               { HashMap.this.clear(); }
            public final Iterator<K> iterator()     { return new KeyIterator(); }
            public final boolean contains(Object o) { return containsKey(o); }
            public final boolean remove(Object key) {
                return removeNode(hash(key), key, null, false, true) != null;
            }
            public final Spliterator<K> spliterator() {
                return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
            }
            public final void forEach(Consumer<? super K> action) {
                Node<K,V>[] tab;
                if (action == null)
                    throw new NullPointerException();
                if (size > 0 && (tab = table) != null) {
                    int mc = modCount;
                    for (int i = 0; i < tab.length; ++i) {
                        for (Node<K,V> e = tab[i]; e != null; e = e.next)
                            action.accept(e.key);
                    }
                    if (modCount != mc)
                        throw new ConcurrentModificationException();
                }
            }
        }
        
        public Collection<V> values() {
            Collection<V> vs = values;
            if (vs == null) {
                vs = new Values();
                values = vs;
            }
            return vs;
        }

        final class Values extends AbstractCollection<V> {
            public final int size()                 { return size; }
            public final void clear()               { HashMap.this.clear(); }
            public final Iterator<V> iterator()     { return new ValueIterator(); }
            public final boolean contains(Object o) { return containsValue(o); }
            public final Spliterator<V> spliterator() {
                return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
            }
            public final void forEach(Consumer<? super V> action) {
                Node<K,V>[] tab;
                if (action == null)
                    throw new NullPointerException();
                if (size > 0 && (tab = table) != null) {
                    int mc = modCount;
                    for (int i = 0; i < tab.length; ++i) {
                        for (Node<K,V> e = tab[i]; e != null; e = e.next)
                            action.accept(e.value);
                    }
                    if (modCount != mc)
                        throw new ConcurrentModificationException();
                }
            }
        }
        
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }

        final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
            public final int size()                 { return size; }
            public final void clear()               { HashMap.this.clear(); }
            public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
            //不如直接用map的contains、remove等等等
            public final boolean contains(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                Object key = e.getKey();
                Node<K,V> candidate = getNode(hash(key), key);
                return candidate != null && candidate.equals(e);
            }
            public final boolean remove(Object o) {
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                    Object key = e.getKey();
                    Object value = e.getValue();
                    //只在值相等的时候remove
                    return removeNode(hash(key), key, value, true, true) != null;
                }
                return false;
            }
            public final Spliterator<Map.Entry<K,V>> spliterator() {
                return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
            }
            public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
                Node<K,V>[] tab;
                if (action == null)
                    throw new NullPointerException();
                if (size > 0 && (tab = table) != null) {
                    int mc = modCount;
                    for (int i = 0; i < tab.length; ++i) {
                        for (Node<K,V> e = tab[i]; e != null; e = e.next)
                            action.accept(e);
                    }
                    if (modCount != mc)
                        throw new ConcurrentModificationException();
                }
            }
        }

        // Overrides of JDK8 Map extension methods

        //Returns the value to which the specified key is mapped, 
        //or defaultValue if this map contains no mapping for the key.
        @Override
        public V getOrDefault(Object key, V defaultValue) {
            Node<K,V> e;
            return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
        }

        //If the specified key is not already associated with a value (or is mapped to null)
        //associates it with the given value and returns null, 
        //else returns the current value.
        @Override
        public V putIfAbsent(K key, V value) {
            return putVal(hash(key), key, value, true, true);
        }

        //只有在curVal==value且key存在的情况下才remove掉键值对
        @Override
        public boolean remove(Object key, Object value) {
            return removeNode(hash(key), key, value, true, true) != null;
        }

        @Override
        public boolean replace(K key, V oldValue, V newValue) {
            Node<K,V> e; V v;
            if ((e = getNode(hash(key), key)) != null &&
                    ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
                e.value = newValue;
                afterNodeAccess(e);
                return true;
            }
            return false;
        }

        @Override
        public V replace(K key, V value) {
            Node<K,V> e;
            if ((e = getNode(hash(key), key)) != null) {
                V oldValue = e.value;
                e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
            return null;
        }

        //如果key对应键值对不存在，就创建一个新的，并把它的值置为paramFunction(key)
        //返回的是修改后的值。
        //其他详见Map的第4点
        @Override
        public V computeIfAbsent(K key,
                                 Function<? super K, ? extends V> mappingFunction) {
            if (mappingFunction == null)
                throw new NullPointerException();
            int hash = hash(key);
            Node<K,V>[] tab; Node<K,V> first; int n, i;
            int binCount = 0;
            TreeNode<K,V> t = null;
            Node<K,V> old = null;
            if (size > threshold || (tab = table) == null ||
                    (n = tab.length) == 0)
                n = (tab = resize()).length;
            if ((first = tab[i = (n - 1) & hash]) != null) {
                if (first instanceof TreeNode)
                    old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
                else {
                    Node<K,V> e = first; K k;
                    do {
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k)))) {
                            old = e;
                            break;
                        }
                        ++binCount;
                    } while ((e = e.next) != null);
                }
                V oldValue;
                if (old != null && (oldValue = old.value) != null) {
                    afterNodeAccess(old);
                    return oldValue;
                }
            }
            V v = mappingFunction.apply(key);
            if (v == null) {
                return null;
            } else if (old != null) {
                old.value = v;
                afterNodeAccess(old);
                return v;
            }
            else if (t != null)
                t.putTreeVal(this, tab, hash, key, v);
            else {
                tab[i] = newNode(hash, key, v, first);
                if (binCount >= TREEIFY_THRESHOLD - 1)
                    treeifyBin(tab, hash);
            }
            ++modCount;
            //++size后不用再check是否>threshold吗 ?为啥要交给上面一开始的时候判断
            ++size;
            afterNodeInsertion(true);
            return v;
        }

        //return 新值
        public V computeIfPresent(K key,
                                  BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            if (remappingFunction == null)
                throw new NullPointerException();
            Node<K,V> e; V oldValue;
            int hash = hash(key);
            if ((e = getNode(hash, key)) != null &&
                    (oldValue = e.value) != null) {
                V v = remappingFunction.apply(key, oldValue);
                if (v != null) {
                    e.value = v;
                    afterNodeAccess(e);
                    return v;
                }
                else
                    removeNode(hash, key, null, false, true);
            }
            return null;
        }

        @Override
        public V compute(K key,
                         BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            if (remappingFunction == null)
                throw new NullPointerException();
            int hash = hash(key);
            Node<K,V>[] tab; Node<K,V> first; int n, i;
            int binCount = 0;
            TreeNode<K,V> t = null;
            Node<K,V> old = null;
            if (size > threshold || (tab = table) == null ||
                    (n = tab.length) == 0)
                n = (tab = resize()).length;
            if ((first = tab[i = (n - 1) & hash]) != null) {
                if (first instanceof TreeNode)
                    old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
                else {
                    Node<K,V> e = first; K k;
                    do {
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k)))) {
                            old = e;
                            break;
                        }
                        ++binCount;
                    } while ((e = e.next) != null);
                }
            }
            V oldValue = (old == null) ? null : old.value;
            V v = remappingFunction.apply(key, oldValue);
            if (old != null) {
                if (v != null) {
                    old.value = v;
                    afterNodeAccess(old);
                }
                else
                    removeNode(hash, key, null, false, true);
            }
            else if (v != null) {
                if (t != null)
                    t.putTreeVal(this, tab, hash, key, v);
                else {
                    tab[i] = newNode(hash, key, v, first);
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                }
                ++modCount;
                ++size;
                afterNodeInsertion(true);
            }
            return v;
        }

        @Override
        public V merge(K key, V value,
                       BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
            if (value == null)
                throw new NullPointerException();
            if (remappingFunction == null)
                throw new NullPointerException();
            int hash = hash(key);
            Node<K,V>[] tab; Node<K,V> first; int n, i;
            int binCount = 0;
            TreeNode<K,V> t = null;
            Node<K,V> old = null;
            if (size > threshold || (tab = table) == null ||
                    (n = tab.length) == 0)
                n = (tab = resize()).length;
            if ((first = tab[i = (n - 1) & hash]) != null) {
                if (first instanceof TreeNode)
                    old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
                else {
                    Node<K,V> e = first; K k;
                    do {
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k)))) {
                            old = e;
                            break;
                        }
                        ++binCount;
                    } while ((e = e.next) != null);
                }
            }
            if (old != null) {
                V v;
                if (old.value != null)
                    v = remappingFunction.apply(old.value, value);
                else
                    v = value;
                if (v != null) {
                    old.value = v;
                    afterNodeAccess(old);
                }
                else
                    removeNode(hash, key, null, false, true);
                return v;
            }
            if (value != null) {
                if (t != null)
                    t.putTreeVal(this, tab, hash, key, value);
                else {
                    tab[i] = newNode(hash, key, value, first);
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                }
                ++modCount;
                ++size;
                afterNodeInsertion(true);
            }
            return value;
        }

        @Override
        public void forEach(BiConsumer<? super K, ? super V> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next)
                        action.accept(e.key, e.value);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }

        @Override
        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            Node<K,V>[] tab;
            if (function == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                        e.value = function.apply(e.key, e.value);
                    }
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
        
        // Cloning and serialization
        
        @SuppressWarnings("unchecked")
        @Override
        public Object clone() {
            HashMap<K,V> result;
            try {
                result = (HashMap<K,V>)super.clone();
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError(e);
            }
            result.reinitialize();
            result.putMapEntries(this, false);
            return result;
        }

        // These methods are also used when serializing HashSets
        final float loadFactor() { return loadFactor; }
        final int capacity() {
            return (table != null) ? table.length :
                    (threshold > 0) ? threshold :
                            DEFAULT_INITIAL_CAPACITY;
        }
        
        private void writeObject(java.io.ObjectOutputStream s)
                throws IOException {...}
        
        private void readObject(ObjectInputStream s)
                throws IOException, ClassNotFoundException {...}

        // Support for resetting final field during deserializing
        private static final class UnsafeHolder {...}
        
        // iterators

        //7
        abstract class HashIterator {
            Node<K,V> next;        // next entry to return
            Node<K,V> current;     // current entry
            int expectedModCount;  // for fast-fail
            int index;             // current slot

            HashIterator() {
                expectedModCount = modCount;
                Node<K,V>[] t = table;
                current = next = null;
                index = 0;
                //指向第一个非空表项
                if (t != null && size > 0) { // advance to first entry
                    do {} while (index < t.length && (next = t[index++]) == null);
                }
            }

            public final boolean hasNext() {
                return next != null;
            }

            final Node<K,V> nextNode() {
                Node<K,V>[] t;
                Node<K,V> e = next;
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                if (e == null)
                    throw new NoSuchElementException();
                //移动桶内指针
                if ((next = (current = e).next) == null && (t = table) != null) {
                    //如果桶内表到达尽头，则移动选择桶的指针
                    do {} while (index < t.length && (next = t[index++]) == null);
                }
                return e;
            }

            public final void remove() {
                Node<K,V> p = current;
                if (p == null)
                    throw new IllegalStateException();
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                current = null;
                K key = p.key;
                removeNode(hash(key), key, null, false, false);
                expectedModCount = modCount;
            }
        }

        final class KeyIterator extends HashIterator
                implements Iterator<K> {
            public final K next() { return nextNode().key; }
        }

        final class ValueIterator extends HashIterator
                implements Iterator<V> {
            public final V next() { return nextNode().value; }
        }

        final class EntryIterator extends HashIterator
                implements Iterator<Map.Entry<K,V>> {
            public final Map.Entry<K,V> next() { return nextNode(); }
        }
        
        // spliterators

        static class HashMapSpliterator<K,V> {...}

        static final class KeySpliterator<K,V>
                extends HashMapSpliterator<K,V>
                implements Spliterator<K> {...}

        static final class ValueSpliterator<K,V>
                extends HashMapSpliterator<K,V>
                implements Spliterator<V> {...}

        static final class EntrySpliterator<K,V>
                extends HashMapSpliterator<K,V>
                implements Spliterator<Map.Entry<K,V>> {...}

        // LinkedHashMap support

        // Create a regular (non-tree) node
        Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
            return new Node<>(hash, key, value, next);
        }

        // For conversion from TreeNodes to plain nodes
        Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
            return new Node<>(p.hash, p.key, p.value, next);
        }

        // Create a tree bin node
        TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
            return new TreeNode<>(hash, key, value, next);
        }

        // For treeifyBin
        TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
            return new TreeNode<>(p.hash, p.key, p.value, next);
        }
        
        void reinitialize() {
            table = null;
            entrySet = null;
            keySet = null;
            values = null;
            modCount = 0;
            threshold = 0;
            size = 0;
        }

        // Callbacks to allow LinkedHashMap post-actions
        void afterNodeAccess(Node<K,V> p) { }
        void afterNodeInsertion(boolean evict) { }
        void afterNodeRemoval(Node<K,V> p) { }

        // Called only from writeObject, to ensure compatible ordering.
        void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {...}
        
        // Tree bins

        //6红黑树介绍，此部分具体的红黑树实现省略
        static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {...}
    }
    + +

    其中：

      +

    1. hash()

      + +

      hash=原hashcode^（原hashcode逻辑右移16位)

      +

      这样的话，由于右移16位补零，此时高位的所有比特位都跟原来一样，低位的比特位变成了融合高低位特点的东西，这样就可以减少冲突，增加均匀性

      +
      2. +

    2. table[(n-1)&hash]

      具体看这个视频，讲得非常不错

      +

      【Java面试必问】HashMap中是如何计算数组下标的？

      +

      假设table此时为默认长度16.则n-1=15

      +

      写出15的二进制形式：0000 1111，可以发现，任何数跟它相与，结果都一定为0000 xxxx，永不越界。

      +

      写出16的二进制形式：0001 0000，可以发现，任何数跟它相与，结果都一定为16或者0.

      +

      可以发现15有非常好的性质。

      +

      而扩展出来，任何2的幂次方-1都具有这样的良好的性质。**这也是为什么hashmap要求表的长度应该为2的幂次。**

      +

      而且，除了不会越界，还有一点就是，这个任何数与15相与的与操作就相当于，任何数对16取余的取余操作。这点实在是佩服啊，把复杂的取余操作在该场景下直接用一个位运算就搞定了。

      +
      3. +

    3. comparableClassFor

      树状结构时结点的默认排序方式是by hashCode。但如果两个结点元素之间是同一个class C，并且这个C实现了Comparable方法，那么就不会按照它们的hashCode比较，而是会调用class C的compareTo方法。

      +

      (We conservatively（保守地） check generic types via reflection to validate（证实） this – see method comparableClassFor).

      +

      也就是说这个comparableClassFor方法的意图就是，如果这个类是comparable的，就返回它具体类型，如果不是返回null。

      +
      4. +

    4. entrySet

      不同于AbstractMap中entrySet的核心作用，HashMap的put、get、clear等等等核心函数都不依赖于entrySet了，毕竟结构改变得比较多了。因而这里的entrySet字段保留，只是为了呼应AbstractMap中keyset和valueset的实现，以及补充AbstractMap中未给出的EntrySet实现。

      +
      5. +

    5. resize()扩容旧表到新表的转移

      此时需要复制oldTab中的所有结点。但注意，由于此时发生了扩容，hash的计算发生了变化，因而不能全部照搬不动oldTab中的下标，否则产生错误。因而我们需要了解一下如何调整下标。

      +

      首先由代码可得，对于oldTab!=NULL的情况下，newCap一定是扩为原来的两倍的。因而以下只需讨论扩容为两倍的情况。

      +

      由第2点可知，假设现在容量为16，扩容为原来的两倍，则hash掩码应该为0000 1111，扩容后，hash掩码应该为0001 1111，可见就只是多了一位，因而，oldTab中，若这一位的值为0，则在新表和旧表中位置的下标应该是一样的；若这一位的值为1，则新表下标=旧表下标+offset，offset正是等于0001 0000.而这个“0001 0000”，正是oldCap！

      +

      对于容量为其他值，全部道理都是一样的。

      +

      因而我们要做的，是对旧表的每一个桶内的所有结点，把它们分成两类，一类为(e.hash & oldCap) == 0【也就是这一位值为0 情况】和(e.hash & oldCap) == 1，然后对这两类进行在新表中分别映射即可。这段代码便做了这样的事。

      +
                        //5
      //low index head，下标保持不变
                        Node<K,V> loHead = null, loTail = null;
      //high index head,下标需要增长偏移量
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            //第一类
                            if ((e.hash & oldCap) == 0) {
                                //一个简单的队列操作
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            //第二类
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
      //对于第一类
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
      //对于第二类
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
      6. +

    6. 红黑树

      红黑树快速入门

      +

      这篇文章也写得很好：

      +

      算法：基于红黑树的 TreeMap

      +
      7. +

    7. HashIterator

      注意点有二：

      +

      ①不继承Iterator接口

      +

      ②抽象，具体实现类为EntryIterator、KeyIterator和ValueIterator

      +

      ③map的接口定义是没有iterator的，因此map不能通过hashiterator迭代，只能通过其vie来实现【三个具体实现类】

      +
      8. +
    +

    LinkedHashMap

    哈希表+链表/红黑树+有序队列

    +
    +

    Hash table and linked list implementation of the Map interface, with predictable iteration order.

    +

    This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries.

    +

    This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order).有序，顺序为元素插入的顺序

    +

    Note that insertion order is not affected if a key is re-inserted into the map. 当修改key的value值时，key的插入序不变

    +

    此实现既让hashmap变得有序，又不会像TreeMap一样有高成本。

    +

    It can be used to produce a copy of a map that has the same order as the original, regardless of the original map’s implementation.

    + + +

    这样可以保持copymap的原有顺序

    +

    A special constructor is provided to create a linked hash map whose order of iteration is the order in which its entries were last accessed, from least-recently accessed to most-recently (access-order). This kind of map is well-suited to building LRU caches. 可以有一个排序方式，顺序为最近最少访问->最近访问，这可以用来构建LRU cache【LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。】

    +

    至于这个“access”怎么定义：

    +
    +

    Invoking the put, putIfAbsent, get, getOrDefault, compute, computeIfAbsent, computeIfPresent, or merge methods results in an access to the corresponding entry (assuming it exists after the invocation completes). The replace methods only result in an access of the entry if the value is replaced. The putAll method generates one entry access for each mapping in the specified map, in the order that key-value mappings are provided by the specified map’s entry set iterator.

    +

    注意没有remove

    +
    +

    也因此，对map视图【各个set】的访问不算access。【因为不调用任意一个上面方法】

    +

    可以重写 removeEldestEntry(Map.Entry) 方法，以在将新映射添加到映射时自动删除陈旧映射的策略。

    + + + + +

    //1

    +

    Iteration over the collection-views of a LinkedHashMap requires time proportional to the size of the map, regardless of its capacity.不同于hashmap，迭代时间与容量无关。

    +

    In access-ordered linked hash maps, merely querying the map with get is a structural modification.注意，对于access-ordered的lhm来说，**get也是一个structural modification，因为可能会修改排序顺序**。所以迭代时只能使用Iterator的next方法来得到结点，迭代器访问不会对accessorder有影响。

    +

    代码测试：

    +
            LinkedHashMap<String,Integer> map = new LinkedHashMap<>(16,0.75f,true);
            map.put("Lily",15);
            map.put("Sam",20);
            map.put("Mary",11);
            map.put("Lee",111);

            for(Iterator i = map.entrySet().iterator();i.hasNext();){
                map.get("Lily");
                System.out.println(i.next().toString());
            }
    /*
    Exception in thread "main" java.util.ConcurrentModificationException
    	at java.util.LinkedHashMap$LinkedHashIterator.nextNode(LinkedHashMap.java:719)
    */
    +
    +

    总之意思就是，LinkedHashMap的数据结构：

    +

    在HashMap哈希表+链表/红黑树的基础上，添加一个双端队列，该双端队列的作用是来维持内部的有序，因而开销比较大。应该只提供插入序和LRU序，其他需要用到compare的排序方法需要对某些方法（如afternodeXXX）进行重写，或者直接使用sorted map。

    +

    LHM的一个很特殊的地方就是，它可以实现一个LRU这样的cache结构，只需要你重载removeEldestEntry return true。还可以在LHM的基础上实现有限长度map，只需要你重载removeEldestEntry 当元素>=某值时返回true。总而言之，你可以建造一个类在LHM的基础上，如果需要对map的长度有限制。

    +

    LHM对LRU的实现是，一旦某个结点用到了，就立刻把他移到最队尾，然后每次淘汰淘汰队首。

    +

    代码：

    public class LinkedHashMap<K,V>
            extends HashMap<K,V>
            implements Map<K,V>
    {
        
        static class Entry<K,V> extends HashMap.Node<K,V> {
            //原来只有next的
            //双端队列
            Entry<K,V> before, after;
            Entry(int hash, K key, V value, Node<K,V> next) {
                super(hash, key, value, next);
            }
        }

        private static final long serialVersionUID = 3801124242820219131L;

        //The head (eldest) of the doubly linked list.
        transient LinkedHashMap.Entry<K,V> head;

        //The tail (youngest) of the doubly linked list.
        transient LinkedHashMap.Entry<K,V> tail;

        //true:access顺序  false:插入顺序
        final boolean accessOrder;

        // internal utilities

        // link at the end of list
        private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
            LinkedHashMap.Entry<K,V> last = tail;
            tail = p;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
        }

        // apply src's links to dst
        //相当于用dst把src取代了
        private void transferLinks(LinkedHashMap.Entry<K,V> src,
                                   LinkedHashMap.Entry<K,V> dst) {
            LinkedHashMap.Entry<K,V> b = dst.before = src.before;
            LinkedHashMap.Entry<K,V> a = dst.after = src.after;
            if (b == null)
                head = dst;
            else
                b.after = dst;
            if (a == null)
                tail = dst;
            else
                a.before = dst;
        }

        // overrides of HashMap hook methods

        void reinitialize() {
            super.reinitialize();
            head = tail = null;
        }

        Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
            LinkedHashMap.Entry<K,V> p =
                    new LinkedHashMap.Entry<K,V>(hash, key, value, e);
            linkNodeLast(p);
            return p;
        }

        Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
            LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
            LinkedHashMap.Entry<K,V> t =
                    new LinkedHashMap.Entry<K,V>(q.hash, q.key, q.value, next);
            transferLinks(q, t);
            return t;
        }

        TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
            TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
            linkNodeLast(p);
            return p;
        }

        TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
            LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
            TreeNode<K,V> t = new TreeNode<K,V>(q.hash, q.key, q.value, next);
            transferLinks(q, t);
            return t;
        }

        //用于reove结点之后，之所以要存在就是因为LHM和HM的Node结构不一样，前者多了after和before
        void afterNodeRemoval(Node<K,V> e) { // unlink
            LinkedHashMap.Entry<K,V> p =
                    (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.before = p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a == null)
                tail = b;
            else
                a.before = b;
        }

        //调用于put、各种compute、merge
        void afterNodeInsertion(boolean evict) { // possibly remove eldest
            LinkedHashMap.Entry<K,V> first;
            //head是最老的结点
            //如果需要插入新节点同时移去旧结点
            if (evict && (first = head) != null && removeEldestEntry(first)) {
                K key = first.key;
                removeNode(hash(key), key, null, false, true);
            }
        }

        void afterNodeAccess(Node<K,V> e) { // move node to last把用到的结点移到队尾
            LinkedHashMap.Entry<K,V> last;
            if (accessOrder && (last = tail) != e) {
                LinkedHashMap.Entry<K,V> p =
                        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
                p.after = null;
                if (b == null)
                    head = a;
                else
                    b.after = a;
                if (a != null)
                    a.before = b;
                else
                    last = b;
                if (last == null)
                    head = p;
                else {
                    p.before = last;
                    last.after = p;
                }
                tail = p;
                ++modCount;
            }
        }

        void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
                s.writeObject(e.key);
                s.writeObject(e.value);
            }
        }
        
        public LinkedHashMap(int initialCapacity, float loadFactor) {
            super(initialCapacity, loadFactor);
            accessOrder = false;
        }
        
        public LinkedHashMap(int initialCapacity) {
            super(initialCapacity);
            accessOrder = false;
        }
        
        public LinkedHashMap() {
            super();
            accessOrder = false;
        }
        
        public LinkedHashMap(Map<? extends K, ? extends V> m) {
            super();
            accessOrder = false;
            putMapEntries(m, false);
        }
        
        //用以构造accessOrder==true的情况
        public LinkedHashMap(int initialCapacity,
                             float loadFactor,
                             boolean accessOrder) {
            super(initialCapacity, loadFactor);
            this.accessOrder = accessOrder;
        }
        
        //遍历构造的队列
        public boolean containsValue(Object value) {
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
                V v = e.value;
                if (v == value || (value != null && value.equals(v)))
                    return true;
            }
            return false;
        }
        
        public V get(Object key) {
            Node<K,V> e;
            if ((e = getNode(hash(key), key)) == null)
                return null;
            if (accessOrder)
                //structural modification
                afterNodeAccess(e);
            return e.value;
        }
        
        public V getOrDefault(Object key, V defaultValue) {
            Node<K,V> e;
            if ((e = getNode(hash(key), key)) == null)
                return defaultValue;
            if (accessOrder)
                //structural modification
                afterNodeAccess(e);
            return e.value;
        }
        
        public void clear() {
            super.clear();
            head = tail = null;
        }

        /*
        Returns true if this map should remove its eldest entry. 
        It provides the implementor with the opportunity to remove the eldest entry each time a new one is added.
        This is useful if the map represents a LRU cache or other interesting implementations
        */
        protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
            return false;
        }
        
        public Set<K> keySet() {
            Set<K> ks = keySet;
            if (ks == null) {
                ks = new LinkedKeySet();
                keySet = ks;
            }
            return ks;
        }

        //HashMap中这几个类都是final，所以继承不了了
        final class LinkedKeySet extends AbstractSet<K> {
            public final int size()                 { return size; }
            public final void clear()               { LinkedHashMap.this.clear(); }
            public final Iterator<K> iterator() {
                return new LinkedKeyIterator();
            }
            public final boolean contains(Object o) { return containsKey(o); }
            public final boolean remove(Object key) {
                return removeNode(hash(key), key, null, false, true) != null;
            }
            public final Spliterator<K> spliterator()  {
                return Spliterators.spliterator(this, Spliterator.SIZED |
                        Spliterator.ORDERED |
                        Spliterator.DISTINCT);
            }
            public final void forEach(Consumer<? super K> action) {
                if (action == null)
                    throw new NullPointerException();
                int mc = modCount;
                //遍历队列
                for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                    action.accept(e.key);
                //保证此间代码同步
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
        
        public Collection<V> values() {
            Collection<V> vs = values;
            if (vs == null) {
                vs = new LinkedValues();
                values = vs;
            }
            return vs;
        }

        final class LinkedValues extends AbstractCollection<V> {
            public final int size()                 { return size; }
            public final void clear()               { LinkedHashMap.this.clear(); }
            public final Iterator<V> iterator() {
                return new LinkedValueIterator();
            }
            public final boolean contains(Object o) { return containsValue(o); }
            public final Spliterator<V> spliterator() {
                return Spliterators.spliterator(this, Spliterator.SIZED |
                        Spliterator.ORDERED);
            }
            public final void forEach(Consumer<? super V> action) {
                if (action == null)
                    throw new NullPointerException();
                int mc = modCount;
                for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                    action.accept(e.value);
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
        
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
        }

        final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
            public final int size()                 { return size; }
            public final void clear()               { LinkedHashMap.this.clear(); }
            public final Iterator<Map.Entry<K,V>> iterator() {
                return new LinkedEntryIterator();
            }
            public final boolean contains(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                Object key = e.getKey();
                Node<K,V> candidate = getNode(hash(key), key);
                return candidate != null && candidate.equals(e);
            }
            public final boolean remove(Object o) {
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                    Object key = e.getKey();
                    Object value = e.getValue();
                    return removeNode(hash(key), key, value, true, true) != null;
                }
                return false;
            }
            public final Spliterator<Map.Entry<K,V>> spliterator() {
                return Spliterators.spliterator(this, Spliterator.SIZED |
                        Spliterator.ORDERED |
                        Spliterator.DISTINCT);
            }
            public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
                if (action == null)
                    throw new NullPointerException();
                int mc = modCount;
                for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                    action.accept(e);
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }

        // Map overrides

        public void forEach(BiConsumer<? super K, ? super V> action) {
            if (action == null)
                throw new NullPointerException();
            int mc = modCount;
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                action.accept(e.key, e.value);
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }

        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            if (function == null)
                throw new NullPointerException();
            int mc = modCount;
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                e.value = function.apply(e.key, e.value);
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }

        // Iterators

        abstract class LinkedHashIterator {
            LinkedHashMap.Entry<K,V> next;
            LinkedHashMap.Entry<K,V> current;
            int expectedModCount;

            LinkedHashIterator() {
                next = head;
                expectedModCount = modCount;
                current = null;
            }

            public final boolean hasNext() {
                return next != null;
            }

            final LinkedHashMap.Entry<K,V> nextNode() {
                LinkedHashMap.Entry<K,V> e = next;
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                if (e == null)
                    throw new NoSuchElementException();
                current = e;
                next = e.after;
                return e;
            }

            public final void remove() {
                Node<K,V> p = current;
                if (p == null)
                    throw new IllegalStateException();
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                current = null;
                K key = p.key;
                removeNode(hash(key), key, null, false, false);
                expectedModCount = modCount;
            }
        }

        final class LinkedKeyIterator extends LinkedHashIterator
                implements Iterator<K> {
            public final K next() { return nextNode().getKey(); }
        }

        final class LinkedValueIterator extends LinkedHashIterator
                implements Iterator<V> {
            public final V next() { return nextNode().value; }
        }

        final class LinkedEntryIterator extends LinkedHashIterator
                implements Iterator<Map.Entry<K,V>> {
            public final Map.Entry<K,V> next() { return nextNode(); }
        }

    }
    + +

    其中：

      +

    1. 迭代时间与容量无关

      LinkedHashMap的结构跟HashMap是一样的，也就是都baked by array。此处为什么“迭代时间与容量无关”，是因为LinkedHashMap内部维护了一个简单的链表队列【包含所有元素】，迭代的时候是对这个队列进行迭代，而不是像HashMap一样通过表迭代。

      +

      怪不得读源码时觉得有些地方明明不重写HashMap也可以它却重写了。原来是因为这个性能问题啊

      +
      2. +
    +

    SortedMap(I)

    +

    A Map that further provides a total ordering on its keys.

    +

    The map is ordered according to the natural ordering of its keys, or by a Comparator typically provided at sorted map creation time.

    +

    All keys inserted into a sorted map must implement the Comparable interface (or be accepted by the specified comparator).

    + + +

    关于这部分，详细见sorted set

    +
    +

    最大的特点就是可以人为定义有序并且有sub map

    +

    代码：

    public interface SortedMap<K,V> extends Map<K,V> {
        
        Comparator<? super K> comparator();
        
        SortedMap<K,V> subMap(K fromKey, K toKey);
        
        SortedMap<K,V> headMap(K toKey);
        
        SortedMap<K,V> tailMap(K fromKey);
        
        //也是默认第一个是低的最后一个是高的，就跟LHM的第一个是最少使用，最后一个是最近使用一样
        //Returns the first (lowest) key currently in this map.
        K firstKey();

        //Returns the last (highest) key currently in this map.
        K lastKey();
        
        Set<K> keySet();
        
        Collection<V> values();
        
        Set<Map.Entry<K, V>> entrySet();
    }
    + +
    +

    A SortedMap extended with navigation methods returning the closest matches for given search targets.

    +

    The performance of ascending operations and views is likely to be faster than that of descending ones.

    +

    submap都多加了几个参数：inclusive or exclusive

    +

    其entry不支持setValue，只能通过map自身的put方法改变value。因为要求前者只是map的快照

    +
    +

    跟navigable set差不多的定义

    +

    代码：

    public interface NavigableMap<K,V> extends SortedMap<K,V> {
        
        Map.Entry<K,V> lowerEntry(K key);
        
        K lowerKey(K key);
        
        Map.Entry<K,V> floorEntry(K key);
        
        K floorKey(K key);
        
        Map.Entry<K,V> ceilingEntry(K key);
        
        K ceilingKey(K key);
        
        Map.Entry<K,V> higherEntry(K key);
        
        K higherKey(K key);
        
        Map.Entry<K,V> firstEntry();
        
        Map.Entry<K,V> lastEntry();
        
        Map.Entry<K,V> pollFirstEntry();
        
        Map.Entry<K,V> pollLastEntry();
        
        NavigableMap<K,V> descendingMap();
        
        NavigableSet<K> navigableKeySet();
        
        NavigableSet<K> descendingKeySet();
        
        NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                                 K toKey,   boolean toInclusive);
        
        NavigableMap<K,V> headMap(K toKey, boolean inclusive);
       
        NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
        
        SortedMap<K,V> subMap(K fromKey, K toKey);
        
        SortedMap<K,V> headMap(K toKey);
        
        SortedMap<K,V> tailMap(K fromKey);
    }
    + +

    TreeMap

    +

    NavigableMap的红黑树实现

    +

    key不允许空，空会抛出异常

    +

    Note that this implementation is not synchronized.

    +

    fail-fast

    +

    All Map.Entry pairs returned by methods in this class and its views represent snapshots of mappings at the time they were produced. They do not support the Entry.setValue method. (Note however that it is possible to change mappings in the associated map using put.)【navigable map的性质】

    +
    +

    具体代码就不看了

    +

    对Collection和Map的总结

      +

    1. fail-fast

      +

      The iterators returned by all of this class’s “collection view methods” are fail-fast: if the map is structurally modified at any time after the iterator is created, in any way except through the iterator’s own remove method, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

      +

      Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

      +
      +

      都使用了modcount进行并发检查，都具有fail-fast的特点（关于此的详细解说，可见AbstractList第四点和List第二点），因而只允许在迭代中使用迭代器的remove方法进行结构性改变。【注意：对于LinkedHashMap中access order排序，get方法也是structural modification，因而也只能通过迭代器的next方法获取元素】

      +
      2. +

    2. not synchronized

      上面介绍到的几个类，除了Vector外，都是线程不同步的。可以用此方式让其线程同步。

      +
      Map m = Collections.synchronizedMap(new LinkedHashMap(...));
      3. +

    3. 是否允许null

      除了TreeSet、TreeMap、ArrayDeque之外，都是允许空（key/value）的

      +
      4. +

    4. 是否有序

      List都是插入序，HashSet无需，HashMap也无序（但其实算是有内部桶序的），LinkedHashMap有插入序和LRU序（依靠内部增加简单队列的消耗），TreeSet有序，TreeMap有序【这俩靠红黑树的遍历顺序（二叉搜索树嘛）】。

      +
      5. +

    5. 实现的约定接口

      都Cloneable，Serializable

      +

      ArrayList/Vector：RandomAccess

      6. -

    6. 执行下列命令：

      -
      sudo pvcreate /dev/sda4
      sudo vgcreate ubuntu-vg /dev/sda4
      sudo vgextend ubuntu-vg /dev/sda4
      sudo vgdisplay # 此时应发现FREE变成了100G
      sudo lvresize -l  +100%FREE /dev/mapper/ubuntu--vg-ubuntu--lv
      sudo resize2fs /dev/mapper/ubuntu--vg-ubuntu--lv
      sudo df -h # 验证成功
    -

    一开始按照的这个，然后被坑惨了（悲）把lvm sig给抹了，导致之后resize2fs的时候报错，然后之后又不小心重启了，最后的最后只能重装。。。又是一晚上配环境。。。。

    ]]>     + + Java +     链接、装载与运行库 @@ -12679,246 +13122,6 @@ url访问填写http://localhost/webdemo4_war/*.do。 books - - 阅读JDK容器部分源码的心得体会2【Map部分】 - /2022/10/22/%E9%98%85%E8%AF%BBJDK%E5%AE%B9%E5%99%A8%E9%83%A8%E5%88%86%E6%BA%90%E7%A0%81%E7%9A%84%E5%BF%83%E5%BE%97%E4%BD%93%E4%BC%9A2%E3%80%90Map%E9%83%A8%E5%88%86%E3%80%91/ - -

    idea 替换注释正则表达式/\*{1,2}[\s\S]*?\*/

    -

    typora 替换图片asset

    -

    \!\[.*\]\(D:\\aWorkStorage\\hexo\\blog\\source\\_posts\\阅读JDK容器部分源码的心得体会2【Map部分】\\(.*)\.png\)，

    -

    替换结果{% asset_img $1.png %}

    -
    -

    Map(I)

    -

    A map cannot contain duplicate keys; each key can map to at most one value.

    -

    This interface takes the place of the Dictionary class.

    -

    The Map interface provides three collection views, which allow a map’s contents to be viewed as a set of keys, collection of values, or set of key-value mappings.

    -

    The order of a map is defined as the order in which the iterators on the map’s collection views return their elements. map的元素顺序取决于集合元素顺序的意思？

    -

    Note: great care must be exercised if mutable objects are used as map keys. The behavior of a map is not specified if the value of an object is changed in a manner that affects equals comparisons while the object is a key in the map. 【这个跟set的那个是一样的】

    -
    -

    map没有迭代器

    - - -

    代码：

    public interface Map<K,V> {
        // Query Operations
        
        int size();
        
        boolean isEmpty();
        
        boolean containsKey(Object key);
        
        //This operation will probably require time linear in the map size 
        //for most implementations of the Map interface.
        boolean containsValue(Object value);
        
        //1
        V get(Object key);

        // Modification Operations
        
        V put(K key, V value);
        
        V remove(Object key);

        // Bulk Operations
        
        void putAll(Map<? extends K, ? extends V> m);
        
        void clear();

        // Views
        
        //Returns a Set view of the keys contained in this map.
        //The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. 
        //The set supports element removal, 
        //which removes the corresponding mapping from the map, 
        //via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. 
        //It does not support the add or addAll operations.
        //2
        Set<K> keySet();
        
        //跟上面一样，也只支持remove，不支持add
        Collection<V> values();
        
        //3
        //跟上面一样，也只支持remove，不支持add
        Set<Map.Entry<K, V>> entrySet();

        //The only way to obtain a reference to a map entry is from the iterator of this collection-view.
        //These Map.Entry objects are valid only for the duration of the iteration;
        //more formally, the behavior of a map entry is undefined if the backing map has been
        //modified after the entry was returned by the iterator, 
        //except through the setValue operation on the map entry.迭代器也不行了
        //可见度为default，包内可见
        interface Entry<K,V> {
            
            K getKey();
            
            V getValue();
            
            V setValue(V value);
            
            boolean equals(Object o);
            
            int hashCode();
            
            public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
                return (Comparator<Map.Entry<K, V>> & Serializable)
                        (c1, c2) -> c1.getKey().compareTo(c2.getKey());
            }
            
            public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
                return (Comparator<Map.Entry<K, V>> & Serializable)
                        (c1, c2) -> c1.getValue().compareTo(c2.getValue());
            }
            
            public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
                Objects.requireNonNull(cmp);
                return (Comparator<Map.Entry<K, V>> & Serializable)
                        (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
            }
            
            public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
                Objects.requireNonNull(cmp);
                return (Comparator<Map.Entry<K, V>> & Serializable)
                        (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
            }
        }
        
        // Comparison and hashing
        
        boolean equals(Object o);
        
        int hashCode();

        // Defaultable methods
        
        //1
        default V getOrDefault(Object key, V defaultValue) {
            V v;
            return (((v = get(key)) != null) || containsKey(key))
                    ? v
                    : defaultValue;
        }
        
        default void forEach(BiConsumer<? super K, ? super V> action) {
            Objects.requireNonNull(action);
            for (Map.Entry<K, V> entry : entrySet()) {
                K k;
                V v;
                try {
                    k = entry.getKey();
                    v = entry.getValue();
                } catch(IllegalStateException ise) {
                    // this usually means the entry is no longer in the map.
                    //确实说明这时候应该并发修改异常了
                    throw new ConcurrentModificationException(ise);
                }
                action.accept(k, v);
            }
        }
        
        default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            Objects.requireNonNull(function);
            for (Map.Entry<K, V> entry : entrySet()) {
                K k;
                V v;
                try {
                    k = entry.getKey();
                    v = entry.getValue();
                } catch(IllegalStateException ise) {
                    // this usually means the entry is no longer in the map.
                    throw new ConcurrentModificationException(ise);
                }

                // ise thrown from function is not a cme.
                v = function.apply(k, v);

                try {
                    entry.setValue(v);
                } catch(IllegalStateException ise) {
                    // this usually means the entry is no longer in the map.
                    throw new ConcurrentModificationException(ise);
                }
            }
        }

        //If the specified key 没有mapping或者对应值为空
        //associates it with the given value and returns null, 
        //else returns the current value.
        default V putIfAbsent(K key, V value) {
            V v = get(key);
            if (v == null) {
                v = put(key, value);
            }

            return v;
        }

        //当所给的key对应的curValue==value时，就remove掉这对mapping
        default boolean remove(Object key, Object value) {
            Object curValue = get(key);
            if (!Objects.equals(curValue, value) ||
                    (curValue == null && !containsKey(key))) {
                return false;
            }
            remove(key);
            return true;
        }

        default boolean replace(K key, V oldValue, V newValue) {
            Object curValue = get(key);
            if (!Objects.equals(curValue, oldValue) ||
                    (curValue == null && !containsKey(key))) {
                return false;
            }
            put(key, newValue);
            return true;
        }

        //如果映射存在就replace，返回旧值
        default V replace(K key, V value) {
            V curValue;
            if (((curValue = get(key)) != null) || containsKey(key)) {
                curValue = put(key, value);
            }
            return curValue;
        }

        //通过mappingFunction来用key计算value
        //4
        default V computeIfAbsent(K key,
                                  Function<? super K, ? extends V> mappingFunction) {
            Objects.requireNonNull(mappingFunction);
            V v;
            if ((v = get(key)) == null) {
                V newValue;
                if ((newValue = mappingFunction.apply(key)) != null) {
                    put(key, newValue);
                    return newValue;
                }
            }

            return v;
        }
        
        //If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
    	//If the function returns null, the mapping is removed.【此时传入的function计算得出value=NULL】
        //If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.
        default V computeIfPresent(K key,
                                   BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            Objects.requireNonNull(remappingFunction);
            V oldValue;
            if ((oldValue = get(key)) != null) {
                V newValue = remappingFunction.apply(key, oldValue);
                if (newValue != null) {
                    put(key, newValue);
                    return newValue;
                } else {
                    remove(key);
                    return null;
                }
            } else {
                return null;
            }
        }
        
        //跟上面那个的差别好像在，当oldValue==NULL，newValue不等于NULL时，下面这个会放入mapp(key,new)
        //上面那个什么也不做。毕竟上面的叫computeIfPresent嘛
        default V compute(K key,
                          BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            Objects.requireNonNull(remappingFunction);
            V oldValue = get(key);

            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue == null) {
                // delete mapping
                //新value==NULL，就delete
                if (oldValue != null || containsKey(key)) {
                    // something to remove
                    remove(key);
                    return null;
                } else {
                    // nothing to do. Leave things as they were.
                    return null;
                }
            } else {
                // add or replace old mapping
                put(key, newValue);
                return newValue;
            }
        }
        
        //把新旧值通过function合并
        //5
        default V merge(K key, V value,
                        BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
            Objects.requireNonNull(remappingFunction);
            Objects.requireNonNull(value);
            V oldValue = get(key);
            //传入function的必定非空
            V newValue = (oldValue == null) ? value :
                    remappingFunction.apply(oldValue, value);
            if(newValue == null) {
                remove(key);
            } else {
                put(key, newValue);
            }
            return newValue;
        }
        
        //6 迭代
    }
    - -

    其中：

      -

    1. get return null时的情况

      get return null when value==NULL or key不存在。

      -

      为了区分这两种情况，写代码时可以用：

      -
      if !containsKey(key){
      	key不存在
      }
      Obj obj=get(key);
      - -

      其实源码中的getordefault方法就给出了应用典范

      -
      default V getOrDefault(Object key, V defaultValue) {
          V v;
          return (((v = get(key)) != null) || containsKey(key))
              ? v
              : defaultValue;
      }
      2. -

    2. view

      -

      //Returns a Set view of the keys contained in this map.

      -

      //The set is backed by the map, so changes to the map are reflected in the set, and vice-versa.

      -
      -

      如下代码测试：

      -
          public static void main(String[] args) {
              HashMap<String,Integer> map = new HashMap<>();
              map.put("Lily",15);
              map.put("Sam",20);
              map.put("Mary",11);
              map.put("Lee",111);
              Set set=map.keySet();
              for( Object str : set){
                  System.out.print((String) str+" ");
              }
              System.out.println();
              set.remove("Lee");
              //set.add("haha");
              for( Object str : set){
                  System.out.print((String) str+" ");
              }
              System.out.println();
              for (Object str : map.keySet()){
                  System.out.print((String) str+" ");
              }
              System.out.println();
              System.out.println(map.containsKey("Lee"));
          }
      /*
      Lee Lily Sam Mary 
      Lily Sam Mary 
      Lily Sam Mary 
      false
      */
      - -

      可得，与之前的List一样，这个view都是纯粹基于原数组的，实时变化的。

      -

      在应用中可发现，可以通过map的key和value的set来对map进行遍历。

      -
      3. -

    3. entrySet

      -
      //The map can be modified while an iteration over the set is in progress 
      //when using the setValue operation on a map entry returned by the iterator
      //or through the iterator's own remove operation
      -
      -

      相比于其它的view，多了第二句话

      -
      4. -

    4. computeIfAbsent

      -

      If the function returns null no mapping is recorded.

      -

      If the function itself throws an (unchecked) exception, the exception is rethrown, and no mapping is recorded.

      -

      The most common usage is to construct a new object serving as an initial mapped value or memoized result, as in:

      -
      map.computeIfAbsent(key, k -> new Value(f(k)));
      - -

      Or to implement a multi-value map, Map<K,Collection>, supporting multiple values per key:

      -
      map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
      -
      -

      它这说的还是很抽象的，下面给出一个使用computeIfAbsent的优雅实例：

      -

      TreeMap()) Treemap With Object

      -
      -

      computeIfAbsent returns the value that is already present in the map, or otherwise evaluates the lambda and puts that into the map, and returns that value.

      -
      -
      var line = "line";      
      var mp = new TreeMap<String,TreeMap<String,Integer>>();     
      var m = mp.computeIfAbsent(line, k -> new TreeMap<>());
      m.put("content", 5);
      System.out.println(mp);
      //output:{line={content=5}}
      - -

      computIfAbsent发现此时map里面没有这个“line”key，就执行第二个参数的lambda表达式，把一个new TreeMap<>以line为关键字放入，并且返回该TreeMap。

      -
      5. -

    5. merge

      -

      看起来非常实用：

      -

      This method may be of use when combining multiple mapped values for a key【相同key不同value合并】. For example, to either create or append a String msg to a value mapping:

      -
      map.merge(key, msg, String::concat)
      - -

      所举代码段意为把新值通过字符串拼接接在旧值后面。

      -

      应该也可以用于集合合并。总之具体实现方法取决于传入的function参数，非常实用

      -
      -
      6. -

    6. 迭代器

      map本身没有迭代器。

      -

      因而在对map进行遍历时，只能通过其keyset、valueset以及entryset来实现。

      -

      具体详见：HashMap的四种遍历方式

      -
      7. -
    -

    AbstractMap

    -

    To implement an unmodifiable map, the programmer needs only to extend this class and provide an implementation for the entrySet method, which returns a set-view of the map’s mappings. Typically, the returned set will, in turn, be implemented atop AbstractSet. This set should not support the add or remove methods, and its iterator should not support the remove method.

    -

    To implement a modifiable map, the programmer must additionally override this class’s put method (which otherwise throws an UnsupportedOperationException), and the iterator returned by entrySet().iterator() must additionally implement its remove method.

    -
    - - -

    最核心的还是entrySet。其余所有的方法，都是通过enrtSet实现的。而给定了enrty这个数据结构的实现方式，剩下的就是entrySet具体怎么实现了。AbstractMap把entrySet的实现抽象了出来，交给了其实现类去具体实现。

    -

    代码：

    public abstract class AbstractMap<K,V> implements Map<K,V> {
        
        protected AbstractMap() {
        }

        // Query Operations
        
        public int size() {
            //还真确实是set的大小
            return entrySet().size();
        }
        
        public boolean isEmpty() {
            return size() == 0;
        }
        
        public boolean containsValue(Object value) {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            if (value==null) {
                while (i.hasNext()) {
                    //entrySet的元素是Entry
                    Entry<K,V> e = i.next();
                    if (e.getValue()==null)
                        return true;
                }
            } else {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (value.equals(e.getValue()))
                        return true;
                }
            }
            return false;
        }
        
        public boolean containsKey(Object key) {
            Iterator<Map.Entry<K,V>> i = entrySet().iterator();
            if (key==null) {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (e.getKey()==null)
                        return true;
                }
            } else {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (key.equals(e.getKey()))
                        return true;
                }
            }
            return false;
        }
        
        public V get(Object key) {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            if (key==null) {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (e.getKey()==null)
                        return e.getValue();
                }
            } else {
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (key.equals(e.getKey()))
                        return e.getValue();
                }
            }
            return null;
        }

        // Modification Operations
        
        public V put(K key, V value) {
            throw new UnsupportedOperationException();
        }
        
        //为啥unmodifiable map还可以remove
        public V remove(Object key) {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            Entry<K,V> correctEntry = null;
            if (key==null) {
                while (correctEntry==null && i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (e.getKey()==null)
                        correctEntry = e;
                }
            } else {
                while (correctEntry==null && i.hasNext()) {
                    Entry<K,V> e = i.next();
                    if (key.equals(e.getKey()))
                        correctEntry = e;
                }
            }

            V oldValue = null;
            if (correctEntry !=null) {
                oldValue = correctEntry.getValue();
                i.remove();
            }
            return oldValue;
        }

        // Bulk Operations
        
        public void putAll(Map<? extends K, ? extends V> m) {
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
                put(e.getKey(), e.getValue());
        }
        
        public void clear() {
            //还真是
            entrySet().clear();
        }

        // Views
        //1
        transient Set<K>        keySet;
        transient Collection<V> values;
        
        //The set supports element removal via 
        //the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. 
        //It does not support the add or addAll operations.
        //只删不加
        public Set<K> keySet() {
            //引用成员变量，减少访问堆次数
            Set<K> ks = keySet;
            //首次建立视图
            if (ks == null) {
                ks = new AbstractSet<K>() {
                    public Iterator<K> iterator() {
                        return new Iterator<K>() {
                            private Iterator<Entry<K,V>> i = entrySet().iterator();
                        
                            public boolean hasNext() {
                                return i.hasNext();
                            }
                            
                            public K next() {
                                return i.next().getKey();
                            }

                            public void remove() {
                                i.remove();
                            }
                        };
                    }
    				
                    //AbtractMap的这些方法都是通过其entryset实现的。因此其实最主要的还是entryset怎么实现的
                    public int size() {
                        return AbstractMap.this.size();
                    }

                    public boolean isEmpty() {
                        return AbstractMap.this.isEmpty();
                    }

                    public void clear() {
                        AbstractMap.this.clear();
                    }

                    public boolean contains(Object k) {
                        return AbstractMap.this.containsKey(k);
                    }
                };
                //赋值回给成员变量
                keySet = ks;
            }
            return ks;
        }
        
        public Collection<V> values() {
            Collection<V> vals = values;
            if (vals == null) {
                vals = new AbstractCollection<V>() {
                    public Iterator<V> iterator() {
                        return new Iterator<V>() {
                            private Iterator<Entry<K,V>> i = entrySet().iterator();

                            public boolean hasNext() {
                                return i.hasNext();
                            }

                            public V next() {
                                return i.next().getValue();
                            }

                            public void remove() {
                                i.remove();
                            }
                        };
                    }

                    public int size() {
                        return AbstractMap.this.size();
                    }

                    public boolean isEmpty() {
                        return AbstractMap.this.isEmpty();
                    }

                    public void clear() {
                        AbstractMap.this.clear();
                    }

                    public boolean contains(Object v) {
                        return AbstractMap.this.containsValue(v);
                    }
                };
                values = vals;
            }
            return vals;
        }

        //有待不同的数据结构实现了
        public abstract Set<Entry<K,V>> entrySet();

        // Comparison and hashing
        
        public boolean equals(Object o) {
            if (o == this)
                return true;

            if (!(o instanceof Map))
                return false;
            Map<?,?> m = (Map<?,?>) o;
            if (m.size() != size())
                return false;

            try {
                Iterator<Entry<K,V>> i = entrySet().iterator();
                while (i.hasNext()) {
                    Entry<K,V> e = i.next();
                    K key = e.getKey();
                    V value = e.getValue();
                    if (value == null) {
                        if (!(m.get(key)==null && m.containsKey(key)))
                            return false;
                    } else {
                        if (!value.equals(m.get(key)))
                            return false;
                    }
                }
            } catch (ClassCastException unused) {
                return false;
            } catch (NullPointerException unused) {
                return false;
            }

            return true;
        }
        
        public int hashCode() {
            int h = 0;
            Iterator<Entry<K,V>> i = entrySet().iterator();
            while (i.hasNext())
                h += i.next().hashCode();
            return h;
        }
        
        public String toString() {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            if (! i.hasNext())
                return "{}";

            StringBuilder sb = new StringBuilder();
            sb.append('{');
            for (;;) {
                Entry<K,V> e = i.next();
                K key = e.getKey();
                V value = e.getValue();
                //经典防自环
                sb.append(key   == this ? "(this Map)" : key);
                sb.append('=');
                sb.append(value == this ? "(this Map)" : value);
                if (! i.hasNext())
                    return sb.append('}').toString();
                sb.append(',').append(' ');
            }
        }
        
        protected Object clone() throws CloneNotSupportedException {
            AbstractMap<?,?> result = (AbstractMap<?,?>)super.clone();
            //也就只有这两个成员变量了
            result.keySet = null;
            result.values = null;
            return result;
        }
        
        private static boolean eq(Object o1, Object o2) {
            return o1 == null ? o2 == null : o1.equals(o2);
        }

        // Implementation Note: SimpleEntry and SimpleImmutableEntry
        // are distinct unrelated classes, even though they share
        // some code. Since you can't add or subtract final-ness
        // of a field in a subclass, they can't share representations,
        // and the amount of duplicated code is too small to warrant
        // exposing a common abstract class.
        //意思就是说，这两个类一个表示key不可变value可变的entry，也就是可变map，
        //另一个表示key和value都不可变的entry，也就是固定map，
        //这俩有很多重复代码，但不能统一到一起，是因为前者有一个final字段，后者有两个，
        //无法对这个final字段做一个统一，因此只能分成两个了
        
        //静态内部类
        //对Entry接口的一个简单实现【key不可变，value可变】
        public static class SimpleEntry<K,V>
                implements Entry<K,V>, java.io.Serializable
        {
            private static final long serialVersionUID = -8499721149061103585L;

            //key不可修改，value可修改
            private final K key;
            private V value;
            
            public SimpleEntry(K key, V value) {
                this.key   = key;
                this.value = value;
            }
            
            public SimpleEntry(Entry<? extends K, ? extends V> entry) {
                this.key   = entry.getKey();
                this.value = entry.getValue();
            }
            
            public K getKey() {
                return key;
            }
            
            public V getValue() {
                return value;
            }
            
            public V setValue(V value) {
                V oldValue = this.value;
                this.value = value;
                return oldValue;
            }
            
            public boolean equals(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                return eq(key, e.getKey()) && eq(value, e.getValue());
            }
            
            public int hashCode() {
                //注意这里是异或
                return (key   == null ? 0 :   key.hashCode()) ^
                        (value == null ? 0 : value.hashCode());
            }
            
            public String toString() {
                return key + "=" + value;
            }

        }
        
        //静态内部类
        //对Entry接口的一个简单实现【key不可变，value不可变】
        public static class SimpleImmutableEntry<K,V>
                implements Entry<K,V>, java.io.Serializable
        {
            private static final long serialVersionUID = 7138329143949025153L;

            private final K key;
            private final V value;
            
            public SimpleImmutableEntry(K key, V value) {
                this.key   = key;
                this.value = value;
            }
            
            public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
                this.key   = entry.getKey();
                this.value = entry.getValue();
            }
            
            public K getKey() {
                return key;
            }
            
            public V getValue() {
                return value;
            }
            
            public V setValue(V value) {
                //exception
                throw new UnsupportedOperationException();
            }
            
            public boolean equals(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                return eq(key, e.getKey()) && eq(value, e.getValue());
            }
            
            public int hashCode() {
                return (key   == null ? 0 :   key.hashCode()) ^
                        (value == null ? 0 : value.hashCode());
            }
            
            public String toString() {
                return key + "=" + value;
            }
        }
    }
    - -

    其中：

      -

    1. view

      -

      Each of these fields are initialized to contain an instance of the appropriate view the first time this view is requested. The views are stateless, so there’s no reason to create more than one of each.

      -
      -

      不同于之前List的sublist和sorted set的subset，它俩是调用创建view方法时才构造出一个新的对象，map是直接把values和keys视图放入成员变量了，因为Collection的视图从实用角度来说有起始和终点更实用，map不需要这个性质，因此作为成员变量花费更小

      -
      2. -
    -

    HashMap

    哈希表+链表/红黑树

    -
    -

    permits null values and the null key允许空，其hash应该是0

    -

    The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls.不同步

    -

    This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.无序

    -

    这应该差不多就是个桶链表

    -

    An instance of HashMap has two parameters that affect its performance: initial capacity and load factor.

    -

    The capacity is the number of buckets in the hash table.桶数量=capacity

    -

    The load factor is a measure of how full the hash table is allowed to get before its capacity is automatically increased. 如果装载百分比达到load factor，hashmap的capacity就会自动增长。

    -

    When the number of entries in the hash table exceeds the product of the load factor and the current capacity, the hash table is rehashed.如果元素数量>=load factor*capacity，就会自动增长并且重新hash。

    -

    默认的load factor是0.75.【我其实觉得这个数很有意思。它是二进制意义上的整除数，因而计算应该很方便：它可以被整整表示，并且计算时可以拆成“2^-1+2^-2”以供移位简化】

    -

    我们设置capacity和load factor的意图应该是要尽量减少rehash的次数。

    -

    Note that using many keys with the same hashCode() is a sure way to slow down performance of any hash table使用多个相同的key【指hashcode相同】会降低性能【？】

    -

    https://stackoverflow.com/questions/43911369/hashmap-java-8-implementation等会看看

    -
    -

    总之意思差不多就是，hashmap的数据结构：

    -

    table数组，每个成员都是一个桶，桶里面装着结点。table默认长度为16

    -

    每个桶内结点的结构依具体情况（该桶内元素多少）来决定，桶内元素多则用树状结构，少就用简单的线性表结构。线性结构为Node<K,V>，树状结构为TreeNode<K,V>。

    -

    当一个线性表桶内结点多于临界值，就需要进行树化，会从链表变成红黑树；当整个hashmap结点数多于临界值，就需要增长capacity并且进行rehash。

    -

    hashmap的桶的装配：首先通过key的hashcode算出一个hash值，然后再把该hash值与n-1相与就能得到桶编号。接下来再在桶内找到应插入的结点就行。

    -

    代码：

    public class HashMap<K,V> extends AbstractMap<K,V>
            implements Map<K,V>, Cloneable, Serializable {
        
        private static final long serialVersionUID = 362498820763181265L;
        
        /*
        此映射通常充当分箱（分桶）哈希表，但当箱变得太大时，它们会转换为 TreeNode 的箱，
        每个结构类似于 java.util.TreeMap 中的结构。 
        大多数方法尝试使用正常的 bin，但出于实用性有时候会过渡到 TreeNode 方法（只需检查节点的实例）。
        TreeNode 的 bin 可以像任何其他 bin 一样被遍历和使用，但在填充过多时还支持更快的查找。 
        但是，由于绝大多数正常使用的 bin 并没有过度填充，
        因此在 table 方法的过程中检查树 bin 的存在可能会白花时间。
        
        因为 TreeNode 的大小大约是常规节点的两倍，
        所以我们仅在 bin 包含足够的节点以保证使用时才使用它们（请参阅 TREEIFY_THRESHOLD）。 
        当它们变得太小（由于移除或调整大小）时，它们会被转换回plain bins。
        */
        
        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
        
        static final int MAXIMUM_CAPACITY = 1 << 30;
        
        static final float DEFAULT_LOAD_FACTOR = 0.75f;
        
        /*
        The bin count 临界值 for using a tree rather than list for a bin. 
        当桶内节点数大于等于该值时，桶将由链表连接转化为树状结构。 
        该值必须大于 2 并且应该至少为 8，以便与树移除中关于在收缩时转换回普通 bin 的假设相吻合。
        */
        static final int TREEIFY_THRESHOLD = 8;
        
        //The bin count threshold for untreeifying a (split) bin during a resize operation. 
        static final int UNTREEIFY_THRESHOLD = 6;
        
        /*
        The smallest table capacity for which bins may be treeified.
        (Otherwise the table is resized if too many nodes in a bin.) 
        Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts between 
        resizing and treeification thresholds.
        */
        static final int MIN_TREEIFY_CAPACITY = 64;
        
        static class Node<K,V> implements Map.Entry<K,V> {
            //一旦被构造器初始化，就不可变。
            final int hash;
            //结点的键不变，但值可变
            final K key;
            V value;
            //链表结构
            Node<K,V> next;

            Node(int hash, K key, V value, Node<K,V> next) {
                this.hash = hash;
                this.key = key;
                this.value = value;
                this.next = next;
            }

            public final K getKey()        { return key; }
            public final V getValue()      { return value; }
            public final String toString() { return key + "=" + value; }

            //也就是说它自己的hashcode和构造时给它的hash是不一样的
            public final int hashCode() {
                return Objects.hashCode(key) ^ Objects.hashCode(value);
            }

            public final V setValue(V newValue) {
                V oldValue = value;
                value = newValue;
                return oldValue;
            }

            public final boolean equals(Object o) {
                if (o == this)
                    return true;
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                    if (Objects.equals(key, e.getKey()) &&
                            Objects.equals(value, e.getValue()))
                        return true;
                }
                return false;
            }
        }
        
        /* ----------------静态共用方法-------------- */
        
        //hash的计算方法
        //1
        static final int hash(Object key) {
            int h;
            //逻辑右移
            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        }
        
        //3
        static Class<?> comparableClassFor(Object x) {
            if (x instanceof Comparable) {
                Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
                if ((c = x.getClass()) == String.class) // bypass checks
                    return c;
                //检查所有接口
                if ((ts = c.getGenericInterfaces()) != null) {
                    for (int i = 0; i < ts.length; ++i) {
                        if (((t = ts[i]) instanceof ParameterizedType) &&
                                ((p = (ParameterizedType)t).getRawType() ==
                                        Comparable.class) &&
                                (as = p.getActualTypeArguments()) != null &&
                                as.length == 1 && as[0] == c) // type arg is c
                            return c;
                    }
                }
            }
            return null;
        }
        
        @SuppressWarnings({"rawtypes","unchecked"}) // for cast to Comparable
        static int compareComparables(Class<?> kc, Object k, Object x) {
            return (x == null || x.getClass() != kc ? 0 :
                    //会调用最新版本的方法
                    ((Comparable)k).compareTo(x));
        }
        
        //这一通操作可以得到比cap大的，且离cap最近的2的幂次方数
        static final int tableSizeFor(int cap) {
            int n = cap - 1;
            n |= n >>> 1;
            n |= n >>> 2;
            n |= n >>> 4;
            n |= n >>> 8;
            n |= n >>> 16;
            return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
        }
        
        /* ---------------- Fields -------------- */
        
        /*
        The table, initialized on first use, and resized as necessary. 
        长度是2的幂次或者0【初始】
        */
        transient Node<K,V>[] table;
        
        //4
        transient Set<Map.Entry<K,V>> entrySet;
        
        //初始为0，每put一次元素就++。
        transient int size;
        
        transient int modCount;
        
        //达到此值时hashmap需要增长capacity并且rehash
        // (可序列化
        // Additionally, if the table array has not been allocated, this
        // field holds the initial array capacity, or zero signifying
        // DEFAULT_INITIAL_CAPACITY.)
        int threshold;
        
        final float loadFactor;
        
        /* ---------------- Public operations -------------- */
        
        public HashMap(int initialCapacity, float loadFactor) {
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal initial capacity: " +
                        initialCapacity);
            if (initialCapacity > MAXIMUM_CAPACITY)
                initialCapacity = MAXIMUM_CAPACITY;
            if (loadFactor <= 0 || Float.isNaN(loadFactor))
                throw new IllegalArgumentException("Illegal load factor: " +
                        loadFactor);
            this.loadFactor = loadFactor;
            this.threshold = tableSizeFor(initialCapacity);
        }
        
        public HashMap(int initialCapacity) {
            this(initialCapacity, DEFAULT_LOAD_FACTOR);
        }
        
        public HashMap() {
            this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
        }
        
        public HashMap(Map<? extends K, ? extends V> m) {
            this.loadFactor = DEFAULT_LOAD_FACTOR;
            putMapEntries(m, false);
        }
        
        //Implements Map.putAll and 上面的Map constructor的辅助方法
        //evict – false when initially constructing this map, else true 
        final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
            int s = m.size();
            if (s > 0) {
                if (table == null) { // pre-size
                    //+1保证了至少比m大
                    float ft = ((float)s / loadFactor) + 1.0F;
                    int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                            (int)ft : MAXIMUM_CAPACITY);
                    if (t > threshold)
                        threshold = tableSizeFor(t);
                    //延迟resize，随处可见的懒汉思想，很聪明
                }
                else if (s > threshold)
                    //就地resize
                    resize();
                for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                    K key = e.getKey();
                    V value = e.getValue();
                    putVal(hash(key), key, value, false, evict);
                }
            }
        }
        
        public int size() {
            return size;
        }
        
        public boolean isEmpty() {
            return size == 0;
        }
        
        public V get(Object key) {
            Node<K,V> e;
            return (e = getNode(hash(key), key)) == null ? null : e.value;
        }
        
        final Node<K,V> getNode(int hash, Object key) {
            Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
            if ((tab = table) != null && (n = tab.length) > 0 &&
                    (first = tab[(n - 1) & hash]) != null) {
                if (first.hash == hash && // always check first node
                        ((k = first.key) == key || (key != null && key.equals(k))))
                    return first;
                if ((e = first.next) != null) {
                    if (first instanceof TreeNode)
                        return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                    do {
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))
                            return e;
                    } while ((e = e.next) != null);
                }
            }
            return null;
        }
        
        public boolean containsKey(Object key) {
            return getNode(hash(key), key) != null;
        }

        //put方法的实现
        public V put(K key, V value) {
            //计算key的哈希值
            return putVal(hash(key), key, value, false, true);
        }

        //evict – false when initially constructing this map, else true 
        //Implements Map.put and related methods.
        final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                       boolean evict) {
            Node<K,V>[] tab; Node<K,V> p; int n, i;
            if ((tab = table) == null || (n = tab.length) == 0)
                //此处调用resize初始化
                n = (tab = resize()).length;
            //n为table大小
            //首先先找到所在桶
            //如果所在桶不存在，就直接申请一个新桶（结点）放
            //2此处找桶的方式
            if ((p = tab[i = (n - 1) & hash]) == null)
                tab[i] = newNode(hash, key, value, null);
            //所在桶存在
            else {
                //e为要塞进去value的结点，k为临时变量，用于存储key值
                Node<K,V> e; K k;
                //如果p的哈希值为key的哈希值，并且p的key==key，说明键本来就存在，并且正好是桶内第一个元素，只需修改旧键值对的value就行
                if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                    //e=旧结点
                    e = p;
                //否则需要沿着桶的结构继续往下找，这时候就需要看桶内用的是树状结构还是顺序结构了
                //如果此时用的是树状结构
                else if (p instanceof TreeNode)
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                //用的是顺序结构
                else {
                    for (int binCount = 0; ; ++binCount) {
                        //走到桶尽头，此时e==NULL
                        if ((e = p.next) == null) {
                            p.next = newNode(hash, key, value, null);
                            //到达临界点，需要树化
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                treeifyBin(tab, hash);
                            break;
                        }
                        //一直走，直到找到
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))
                            break;
                        //两个指针来回交替往下走
                        p = e;
                    }
                }
                //上面可以看到，只有原来就存在键值对才会满足此条件
                if (e != null) { // existing mapping for key
                    V oldValue = e.value;
                    //onlyIfAbsent – if true, don't change existing value 除非旧值为空
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value;
                    //空操作，方便LinkedHashMap的后续实现
                    afterNodeAccess(e);
                    //存在旧键值对的情况至此结束
                    return oldValue;
                }
            }
            //走到这说明是新建了一个结点
            ++modCount;
            if (++size > threshold)
                resize();
            //空操作，方便LinkedHashMap的后续实现
            afterNodeInsertion(evict);
            return null;
        }

        //Initializes or doubles table size. 
        final Node<K,V>[] resize() {
            Node<K,V>[] oldTab = table;
            int oldCap = (oldTab == null) ? 0 : oldTab.length;
            int oldThr = threshold;
            int newCap, newThr = 0;
            
            //决定newCap和newThr
            if (oldCap > 0) {
                if (oldCap >= MAXIMUM_CAPACITY) {
                    threshold = Integer.MAX_VALUE;
                    return oldTab;
                }
                //扩容两倍
                else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                        oldCap >= DEFAULT_INITIAL_CAPACITY)
                    newThr = oldThr << 1; // double threshold
            }
            else if (oldThr > 0) // initial capacity was placed in threshold
                //因为此时capacity已经需要向threshold转变了，因而newThr需要再计算
                newCap = oldThr;
            else {               // zero initial threshold signifies using defaults
                newCap = DEFAULT_INITIAL_CAPACITY;
                newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
            }
            if (newThr == 0) {
                float ft = (float)newCap * loadFactor;
                newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                        (int)ft : Integer.MAX_VALUE);
            }
            threshold = newThr;
            
            @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
            table = newTab;
            if (oldTab != null) {
                //需要复制原oldTab中的每个结点
                for (int j = 0; j < oldCap; ++j) {
                    Node<K,V> e;
                    if ((e = oldTab[j]) != null) {
                        oldTab[j] = null;
                        //该桶只有一个结点
                        if (e.next == null)
                            newTab[e.hash & (newCap - 1)] = e;
                        else if (e instanceof TreeNode)
                            ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                        else { // preserve order
                            //5
                            Node<K,V> loHead = null, loTail = null;
                            Node<K,V> hiHead = null, hiTail = null;
                            Node<K,V> next;
                            do {
                                next = e.next;
                                if ((e.hash & oldCap) == 0) {
                                    if (loTail == null)
                                        loHead = e;
                                    else
                                        loTail.next = e;
                                    loTail = e;
                                }
                                else {
                                    if (hiTail == null)
                                        hiHead = e;
                                    else
                                        hiTail.next = e;
                                    hiTail = e;
                                }
                            } while ((e = next) != null);
                            if (loTail != null) {
                                loTail.next = null;
                                newTab[j] = loHead;
                            }
                            if (hiTail != null) {
                                hiTail.next = null;
                                newTab[j + oldCap] = hiHead;
                            }
                        }
                    }
                }
            }
            return newTab;
        }
        
        //树化桶
        final void treeifyBin(Node<K,V>[] tab, int hash) {
            int n, index; Node<K,V> e;
            //如果表的一个桶结点数大于8（TREEIFY_THRESHOLD），但是表的总结点数小于64（MIN_TREEIFY_CAPACITY）也是不会树化的，只会resize重新hash
            if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                resize();
            //需要树化
            //取得该桶的头结点e
            else if ((e = tab[index = (n - 1) & hash]) != null) {
                TreeNode<K,V> hd = null, tl = null;
                do {
                    //replacementTreeNode return new TreeNode<>(p.hash, p.key, p.value, next);
                    TreeNode<K,V> p = replacementTreeNode(e, null);
                    if (tl == null)
                        //此时有0个结点
                        hd = p;
                    else {
                        p.prev = tl;
                        tl.next = p;
                    }
                    tl = p;
                } while ((e = e.next) != null);
                if ((tab[index] = hd) != null)
                    //只树化该桶
                    hd.treeify(tab);
            }
        }
        
        //对于重复键需替换
        public void putAll(Map<? extends K, ? extends V> m) {
            putMapEntries(m, true);
        }
        
        //Returns:the previous value
        public V remove(Object key) {
            Node<K,V> e;
            return (e = removeNode(hash(key), key, null, false, true)) == null ?
                    null : e.value;
        }
        
        //matchValue – if true only remove if value is equal
        //value – the value to match if matchValue, else ignored
        //movable – if false do not move other nodes while removing用于树
        final Node<K,V> removeNode(int hash, Object key, Object value,
                                   boolean matchValue, boolean movable) {
            Node<K,V>[] tab; Node<K,V> p; int n, index;
            //table和键都存在
            if ((tab = table) != null && (n = tab.length) > 0 &&
                    (p = tab[index = (n - 1) & hash]) != null) {
                //node为要移走的结点
                Node<K,V> node = null, e; K k; V v;
                //检查头结点
                if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                    node = p;
                else if ((e = p.next) != null) {
                    if (p instanceof TreeNode)
                        node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                    else {
                        do {
                            if (e.hash == hash &&
                                    ((k = e.key) == key ||
                                            (key != null && key.equals(k)))) {
                                node = e;
                                break;
                            }
                            p = e;
                        } while ((e = e.next) != null);
                    }
                }
                //需要移走
                if (node != null && (!matchValue || (v = node.value) == value ||
                        (value != null && value.equals(v)))) {
                    if (node instanceof TreeNode)
                        ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                    //由上文可知，此时node==p==头结点
                    //能找到这个差异点也是真牛逼
                    else if (node == p)
                        tab[index] = node.next;
                    //此时p.next=node
                    else
                        p.next = node.next;
                    ++modCount;
                    --size;
                    afterNodeRemoval(node);
                    return node;
                }
            }
            return null;
        }
        
        public void clear() {
            Node<K,V>[] tab;
            modCount++;
            if ((tab = table) != null && size > 0) {
                size = 0;
                for (int i = 0; i < tab.length; ++i)
                    tab[i] = null;//我知道你要说什么：let GC do its work
            }
        }
        
        //遍历。有树优化的话可以减少时间开销。
        public boolean containsValue(Object value) {
            Node<K,V>[] tab; V v;
            if ((tab = table) != null && size > 0) {
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                        if ((v = e.value) == value ||
                                (value != null && value.equals(v)))
                            return true;
                    }
                }
            }
            return false;
        }
        
        public Set<K> keySet() {
            Set<K> ks = keySet;
            if (ks == null) {
                //是HashMap自己实现的keyset
                ks = new KeySet();
                keySet = ks;
            }
            return ks;
        }

        final class KeySet extends AbstractSet<K> {
            public final int size()                 { return size; }
            public final void clear()               { HashMap.this.clear(); }
            public final Iterator<K> iterator()     { return new KeyIterator(); }
            public final boolean contains(Object o) { return containsKey(o); }
            public final boolean remove(Object key) {
                return removeNode(hash(key), key, null, false, true) != null;
            }
            public final Spliterator<K> spliterator() {
                return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
            }
            public final void forEach(Consumer<? super K> action) {
                Node<K,V>[] tab;
                if (action == null)
                    throw new NullPointerException();
                if (size > 0 && (tab = table) != null) {
                    int mc = modCount;
                    for (int i = 0; i < tab.length; ++i) {
                        for (Node<K,V> e = tab[i]; e != null; e = e.next)
                            action.accept(e.key);
                    }
                    if (modCount != mc)
                        throw new ConcurrentModificationException();
                }
            }
        }
        
        public Collection<V> values() {
            Collection<V> vs = values;
            if (vs == null) {
                vs = new Values();
                values = vs;
            }
            return vs;
        }

        final class Values extends AbstractCollection<V> {
            public final int size()                 { return size; }
            public final void clear()               { HashMap.this.clear(); }
            public final Iterator<V> iterator()     { return new ValueIterator(); }
            public final boolean contains(Object o) { return containsValue(o); }
            public final Spliterator<V> spliterator() {
                return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
            }
            public final void forEach(Consumer<? super V> action) {
                Node<K,V>[] tab;
                if (action == null)
                    throw new NullPointerException();
                if (size > 0 && (tab = table) != null) {
                    int mc = modCount;
                    for (int i = 0; i < tab.length; ++i) {
                        for (Node<K,V> e = tab[i]; e != null; e = e.next)
                            action.accept(e.value);
                    }
                    if (modCount != mc)
                        throw new ConcurrentModificationException();
                }
            }
        }
        
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }

        final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
            public final int size()                 { return size; }
            public final void clear()               { HashMap.this.clear(); }
            public final Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
            //不如直接用map的contains、remove等等等
            public final boolean contains(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                Object key = e.getKey();
                Node<K,V> candidate = getNode(hash(key), key);
                return candidate != null && candidate.equals(e);
            }
            public final boolean remove(Object o) {
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                    Object key = e.getKey();
                    Object value = e.getValue();
                    //只在值相等的时候remove
                    return removeNode(hash(key), key, value, true, true) != null;
                }
                return false;
            }
            public final Spliterator<Map.Entry<K,V>> spliterator() {
                return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
            }
            public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
                Node<K,V>[] tab;
                if (action == null)
                    throw new NullPointerException();
                if (size > 0 && (tab = table) != null) {
                    int mc = modCount;
                    for (int i = 0; i < tab.length; ++i) {
                        for (Node<K,V> e = tab[i]; e != null; e = e.next)
                            action.accept(e);
                    }
                    if (modCount != mc)
                        throw new ConcurrentModificationException();
                }
            }
        }

        // Overrides of JDK8 Map extension methods

        //Returns the value to which the specified key is mapped, 
        //or defaultValue if this map contains no mapping for the key.
        @Override
        public V getOrDefault(Object key, V defaultValue) {
            Node<K,V> e;
            return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
        }

        //If the specified key is not already associated with a value (or is mapped to null)
        //associates it with the given value and returns null, 
        //else returns the current value.
        @Override
        public V putIfAbsent(K key, V value) {
            return putVal(hash(key), key, value, true, true);
        }

        //只有在curVal==value且key存在的情况下才remove掉键值对
        @Override
        public boolean remove(Object key, Object value) {
            return removeNode(hash(key), key, value, true, true) != null;
        }

        @Override
        public boolean replace(K key, V oldValue, V newValue) {
            Node<K,V> e; V v;
            if ((e = getNode(hash(key), key)) != null &&
                    ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
                e.value = newValue;
                afterNodeAccess(e);
                return true;
            }
            return false;
        }

        @Override
        public V replace(K key, V value) {
            Node<K,V> e;
            if ((e = getNode(hash(key), key)) != null) {
                V oldValue = e.value;
                e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
            return null;
        }

        //如果key对应键值对不存在，就创建一个新的，并把它的值置为paramFunction(key)
        //返回的是修改后的值。
        //其他详见Map的第4点
        @Override
        public V computeIfAbsent(K key,
                                 Function<? super K, ? extends V> mappingFunction) {
            if (mappingFunction == null)
                throw new NullPointerException();
            int hash = hash(key);
            Node<K,V>[] tab; Node<K,V> first; int n, i;
            int binCount = 0;
            TreeNode<K,V> t = null;
            Node<K,V> old = null;
            if (size > threshold || (tab = table) == null ||
                    (n = tab.length) == 0)
                n = (tab = resize()).length;
            if ((first = tab[i = (n - 1) & hash]) != null) {
                if (first instanceof TreeNode)
                    old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
                else {
                    Node<K,V> e = first; K k;
                    do {
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k)))) {
                            old = e;
                            break;
                        }
                        ++binCount;
                    } while ((e = e.next) != null);
                }
                V oldValue;
                if (old != null && (oldValue = old.value) != null) {
                    afterNodeAccess(old);
                    return oldValue;
                }
            }
            V v = mappingFunction.apply(key);
            if (v == null) {
                return null;
            } else if (old != null) {
                old.value = v;
                afterNodeAccess(old);
                return v;
            }
            else if (t != null)
                t.putTreeVal(this, tab, hash, key, v);
            else {
                tab[i] = newNode(hash, key, v, first);
                if (binCount >= TREEIFY_THRESHOLD - 1)
                    treeifyBin(tab, hash);
            }
            ++modCount;
            //++size后不用再check是否>threshold吗 ?为啥要交给上面一开始的时候判断
            ++size;
            afterNodeInsertion(true);
            return v;
        }

        //return 新值
        public V computeIfPresent(K key,
                                  BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            if (remappingFunction == null)
                throw new NullPointerException();
            Node<K,V> e; V oldValue;
            int hash = hash(key);
            if ((e = getNode(hash, key)) != null &&
                    (oldValue = e.value) != null) {
                V v = remappingFunction.apply(key, oldValue);
                if (v != null) {
                    e.value = v;
                    afterNodeAccess(e);
                    return v;
                }
                else
                    removeNode(hash, key, null, false, true);
            }
            return null;
        }

        @Override
        public V compute(K key,
                         BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            if (remappingFunction == null)
                throw new NullPointerException();
            int hash = hash(key);
            Node<K,V>[] tab; Node<K,V> first; int n, i;
            int binCount = 0;
            TreeNode<K,V> t = null;
            Node<K,V> old = null;
            if (size > threshold || (tab = table) == null ||
                    (n = tab.length) == 0)
                n = (tab = resize()).length;
            if ((first = tab[i = (n - 1) & hash]) != null) {
                if (first instanceof TreeNode)
                    old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
                else {
                    Node<K,V> e = first; K k;
                    do {
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k)))) {
                            old = e;
                            break;
                        }
                        ++binCount;
                    } while ((e = e.next) != null);
                }
            }
            V oldValue = (old == null) ? null : old.value;
            V v = remappingFunction.apply(key, oldValue);
            if (old != null) {
                if (v != null) {
                    old.value = v;
                    afterNodeAccess(old);
                }
                else
                    removeNode(hash, key, null, false, true);
            }
            else if (v != null) {
                if (t != null)
                    t.putTreeVal(this, tab, hash, key, v);
                else {
                    tab[i] = newNode(hash, key, v, first);
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                }
                ++modCount;
                ++size;
                afterNodeInsertion(true);
            }
            return v;
        }

        @Override
        public V merge(K key, V value,
                       BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
            if (value == null)
                throw new NullPointerException();
            if (remappingFunction == null)
                throw new NullPointerException();
            int hash = hash(key);
            Node<K,V>[] tab; Node<K,V> first; int n, i;
            int binCount = 0;
            TreeNode<K,V> t = null;
            Node<K,V> old = null;
            if (size > threshold || (tab = table) == null ||
                    (n = tab.length) == 0)
                n = (tab = resize()).length;
            if ((first = tab[i = (n - 1) & hash]) != null) {
                if (first instanceof TreeNode)
                    old = (t = (TreeNode<K,V>)first).getTreeNode(hash, key);
                else {
                    Node<K,V> e = first; K k;
                    do {
                        if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k)))) {
                            old = e;
                            break;
                        }
                        ++binCount;
                    } while ((e = e.next) != null);
                }
            }
            if (old != null) {
                V v;
                if (old.value != null)
                    v = remappingFunction.apply(old.value, value);
                else
                    v = value;
                if (v != null) {
                    old.value = v;
                    afterNodeAccess(old);
                }
                else
                    removeNode(hash, key, null, false, true);
                return v;
            }
            if (value != null) {
                if (t != null)
                    t.putTreeVal(this, tab, hash, key, value);
                else {
                    tab[i] = newNode(hash, key, value, first);
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                }
                ++modCount;
                ++size;
                afterNodeInsertion(true);
            }
            return value;
        }

        @Override
        public void forEach(BiConsumer<? super K, ? super V> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next)
                        action.accept(e.key, e.value);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }

        @Override
        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            Node<K,V>[] tab;
            if (function == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                        e.value = function.apply(e.key, e.value);
                    }
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
        
        // Cloning and serialization
        
        @SuppressWarnings("unchecked")
        @Override
        public Object clone() {
            HashMap<K,V> result;
            try {
                result = (HashMap<K,V>)super.clone();
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError(e);
            }
            result.reinitialize();
            result.putMapEntries(this, false);
            return result;
        }

        // These methods are also used when serializing HashSets
        final float loadFactor() { return loadFactor; }
        final int capacity() {
            return (table != null) ? table.length :
                    (threshold > 0) ? threshold :
                            DEFAULT_INITIAL_CAPACITY;
        }
        
        private void writeObject(java.io.ObjectOutputStream s)
                throws IOException {...}
        
        private void readObject(ObjectInputStream s)
                throws IOException, ClassNotFoundException {...}

        // Support for resetting final field during deserializing
        private static final class UnsafeHolder {...}
        
        // iterators

        //7
        abstract class HashIterator {
            Node<K,V> next;        // next entry to return
            Node<K,V> current;     // current entry
            int expectedModCount;  // for fast-fail
            int index;             // current slot

            HashIterator() {
                expectedModCount = modCount;
                Node<K,V>[] t = table;
                current = next = null;
                index = 0;
                //指向第一个非空表项
                if (t != null && size > 0) { // advance to first entry
                    do {} while (index < t.length && (next = t[index++]) == null);
                }
            }

            public final boolean hasNext() {
                return next != null;
            }

            final Node<K,V> nextNode() {
                Node<K,V>[] t;
                Node<K,V> e = next;
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                if (e == null)
                    throw new NoSuchElementException();
                //移动桶内指针
                if ((next = (current = e).next) == null && (t = table) != null) {
                    //如果桶内表到达尽头，则移动选择桶的指针
                    do {} while (index < t.length && (next = t[index++]) == null);
                }
                return e;
            }

            public final void remove() {
                Node<K,V> p = current;
                if (p == null)
                    throw new IllegalStateException();
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                current = null;
                K key = p.key;
                removeNode(hash(key), key, null, false, false);
                expectedModCount = modCount;
            }
        }

        final class KeyIterator extends HashIterator
                implements Iterator<K> {
            public final K next() { return nextNode().key; }
        }

        final class ValueIterator extends HashIterator
                implements Iterator<V> {
            public final V next() { return nextNode().value; }
        }

        final class EntryIterator extends HashIterator
                implements Iterator<Map.Entry<K,V>> {
            public final Map.Entry<K,V> next() { return nextNode(); }
        }
        
        // spliterators

        static class HashMapSpliterator<K,V> {...}

        static final class KeySpliterator<K,V>
                extends HashMapSpliterator<K,V>
                implements Spliterator<K> {...}

        static final class ValueSpliterator<K,V>
                extends HashMapSpliterator<K,V>
                implements Spliterator<V> {...}

        static final class EntrySpliterator<K,V>
                extends HashMapSpliterator<K,V>
                implements Spliterator<Map.Entry<K,V>> {...}

        // LinkedHashMap support

        // Create a regular (non-tree) node
        Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
            return new Node<>(hash, key, value, next);
        }

        // For conversion from TreeNodes to plain nodes
        Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
            return new Node<>(p.hash, p.key, p.value, next);
        }

        // Create a tree bin node
        TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
            return new TreeNode<>(hash, key, value, next);
        }

        // For treeifyBin
        TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
            return new TreeNode<>(p.hash, p.key, p.value, next);
        }
        
        void reinitialize() {
            table = null;
            entrySet = null;
            keySet = null;
            values = null;
            modCount = 0;
            threshold = 0;
            size = 0;
        }

        // Callbacks to allow LinkedHashMap post-actions
        void afterNodeAccess(Node<K,V> p) { }
        void afterNodeInsertion(boolean evict) { }
        void afterNodeRemoval(Node<K,V> p) { }

        // Called only from writeObject, to ensure compatible ordering.
        void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {...}
        
        // Tree bins

        //6红黑树介绍，此部分具体的红黑树实现省略
        static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {...}
    }
    - -

    其中：

      -

    1. hash()

      - -

      hash=原hashcode^（原hashcode逻辑右移16位)

      -

      这样的话，由于右移16位补零，此时高位的所有比特位都跟原来一样，低位的比特位变成了融合高低位特点的东西，这样就可以减少冲突，增加均匀性

      -
      2. -

    2. table[(n-1)&hash]

      具体看这个视频，讲得非常不错

      -

      【Java面试必问】HashMap中是如何计算数组下标的？

      -

      假设table此时为默认长度16.则n-1=15

      -

      写出15的二进制形式：0000 1111，可以发现，任何数跟它相与，结果都一定为0000 xxxx，永不越界。

      -

      写出16的二进制形式：0001 0000，可以发现，任何数跟它相与，结果都一定为16或者0.

      -

      可以发现15有非常好的性质。

      -

      而扩展出来，任何2的幂次方-1都具有这样的良好的性质。**这也是为什么hashmap要求表的长度应该为2的幂次。**

      -

      而且，除了不会越界，还有一点就是，这个任何数与15相与的与操作就相当于，任何数对16取余的取余操作。这点实在是佩服啊，把复杂的取余操作在该场景下直接用一个位运算就搞定了。

      -
      3. -

    3. comparableClassFor

      树状结构时结点的默认排序方式是by hashCode。但如果两个结点元素之间是同一个class C，并且这个C实现了Comparable方法，那么就不会按照它们的hashCode比较，而是会调用class C的compareTo方法。

      -

      (We conservatively（保守地） check generic types via reflection to validate（证实） this – see method comparableClassFor).

      -

      也就是说这个comparableClassFor方法的意图就是，如果这个类是comparable的，就返回它具体类型，如果不是返回null。

      -
      4. -

    4. entrySet

      不同于AbstractMap中entrySet的核心作用，HashMap的put、get、clear等等等核心函数都不依赖于entrySet了，毕竟结构改变得比较多了。因而这里的entrySet字段保留，只是为了呼应AbstractMap中keyset和valueset的实现，以及补充AbstractMap中未给出的EntrySet实现。

      -
      5. -

    5. resize()扩容旧表到新表的转移

      此时需要复制oldTab中的所有结点。但注意，由于此时发生了扩容，hash的计算发生了变化，因而不能全部照搬不动oldTab中的下标，否则产生错误。因而我们需要了解一下如何调整下标。

      -

      首先由代码可得，对于oldTab!=NULL的情况下，newCap一定是扩为原来的两倍的。因而以下只需讨论扩容为两倍的情况。

      -

      由第2点可知，假设现在容量为16，扩容为原来的两倍，则hash掩码应该为0000 1111，扩容后，hash掩码应该为0001 1111，可见就只是多了一位，因而，oldTab中，若这一位的值为0，则在新表和旧表中位置的下标应该是一样的；若这一位的值为1，则新表下标=旧表下标+offset，offset正是等于0001 0000.而这个“0001 0000”，正是oldCap！

      -

      对于容量为其他值，全部道理都是一样的。

      -

      因而我们要做的，是对旧表的每一个桶内的所有结点，把它们分成两类，一类为(e.hash & oldCap) == 0【也就是这一位值为0 情况】和(e.hash & oldCap) == 1，然后对这两类进行在新表中分别映射即可。这段代码便做了这样的事。

      -
                        //5
      //low index head，下标保持不变
                        Node<K,V> loHead = null, loTail = null;
      //high index head,下标需要增长偏移量
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            //第一类
                            if ((e.hash & oldCap) == 0) {
                                //一个简单的队列操作
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            //第二类
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
      //对于第一类
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
      //对于第二类
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
      6. -

    6. 红黑树

      红黑树快速入门

      -

      这篇文章也写得很好：

      -

      算法：基于红黑树的 TreeMap

      -
      7. -

    7. HashIterator

      注意点有二：

      -

      ①不继承Iterator接口

      -

      ②抽象，具体实现类为EntryIterator、KeyIterator和ValueIterator

      -

      ③map的接口定义是没有iterator的，因此map不能通过hashiterator迭代，只能通过其vie来实现【三个具体实现类】

      -
      8. -
    -

    LinkedHashMap

    哈希表+链表/红黑树+有序队列

    -
    -

    Hash table and linked list implementation of the Map interface, with predictable iteration order.

    -

    This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries.

    -

    This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order).有序，顺序为元素插入的顺序

    -

    Note that insertion order is not affected if a key is re-inserted into the map. 当修改key的value值时，key的插入序不变

    -

    此实现既让hashmap变得有序，又不会像TreeMap一样有高成本。

    -

    It can be used to produce a copy of a map that has the same order as the original, regardless of the original map’s implementation.

    - - -

    这样可以保持copymap的原有顺序

    -

    A special constructor is provided to create a linked hash map whose order of iteration is the order in which its entries were last accessed, from least-recently accessed to most-recently (access-order). This kind of map is well-suited to building LRU caches. 可以有一个排序方式，顺序为最近最少访问->最近访问，这可以用来构建LRU cache【LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。】

    -

    至于这个“access”怎么定义：

    -
    -

    Invoking the put, putIfAbsent, get, getOrDefault, compute, computeIfAbsent, computeIfPresent, or merge methods results in an access to the corresponding entry (assuming it exists after the invocation completes). The replace methods only result in an access of the entry if the value is replaced. The putAll method generates one entry access for each mapping in the specified map, in the order that key-value mappings are provided by the specified map’s entry set iterator.

    -

    注意没有remove

    -
    -

    也因此，对map视图【各个set】的访问不算access。【因为不调用任意一个上面方法】

    -

    可以重写 removeEldestEntry(Map.Entry) 方法，以在将新映射添加到映射时自动删除陈旧映射的策略。

    - - - - -

    //1

    -

    Iteration over the collection-views of a LinkedHashMap requires time proportional to the size of the map, regardless of its capacity.不同于hashmap，迭代时间与容量无关。

    -

    In access-ordered linked hash maps, merely querying the map with get is a structural modification.注意，对于access-ordered的lhm来说，**get也是一个structural modification，因为可能会修改排序顺序**。所以迭代时只能使用Iterator的next方法来得到结点，迭代器访问不会对accessorder有影响。

    -

    代码测试：

    -
            LinkedHashMap<String,Integer> map = new LinkedHashMap<>(16,0.75f,true);
            map.put("Lily",15);
            map.put("Sam",20);
            map.put("Mary",11);
            map.put("Lee",111);

            for(Iterator i = map.entrySet().iterator();i.hasNext();){
                map.get("Lily");
                System.out.println(i.next().toString());
            }
    /*
    Exception in thread "main" java.util.ConcurrentModificationException
    	at java.util.LinkedHashMap$LinkedHashIterator.nextNode(LinkedHashMap.java:719)
    */
    -
    -

    总之意思就是，LinkedHashMap的数据结构：

    -

    在HashMap哈希表+链表/红黑树的基础上，添加一个双端队列，该双端队列的作用是来维持内部的有序，因而开销比较大。应该只提供插入序和LRU序，其他需要用到compare的排序方法需要对某些方法（如afternodeXXX）进行重写，或者直接使用sorted map。

    -

    LHM的一个很特殊的地方就是，它可以实现一个LRU这样的cache结构，只需要你重载removeEldestEntry return true。还可以在LHM的基础上实现有限长度map，只需要你重载removeEldestEntry 当元素>=某值时返回true。总而言之，你可以建造一个类在LHM的基础上，如果需要对map的长度有限制。

    -

    LHM对LRU的实现是，一旦某个结点用到了，就立刻把他移到最队尾，然后每次淘汰淘汰队首。

    -

    代码：

    public class LinkedHashMap<K,V>
            extends HashMap<K,V>
            implements Map<K,V>
    {
        
        static class Entry<K,V> extends HashMap.Node<K,V> {
            //原来只有next的
            //双端队列
            Entry<K,V> before, after;
            Entry(int hash, K key, V value, Node<K,V> next) {
                super(hash, key, value, next);
            }
        }

        private static final long serialVersionUID = 3801124242820219131L;

        //The head (eldest) of the doubly linked list.
        transient LinkedHashMap.Entry<K,V> head;

        //The tail (youngest) of the doubly linked list.
        transient LinkedHashMap.Entry<K,V> tail;

        //true:access顺序  false:插入顺序
        final boolean accessOrder;

        // internal utilities

        // link at the end of list
        private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
            LinkedHashMap.Entry<K,V> last = tail;
            tail = p;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
        }

        // apply src's links to dst
        //相当于用dst把src取代了
        private void transferLinks(LinkedHashMap.Entry<K,V> src,
                                   LinkedHashMap.Entry<K,V> dst) {
            LinkedHashMap.Entry<K,V> b = dst.before = src.before;
            LinkedHashMap.Entry<K,V> a = dst.after = src.after;
            if (b == null)
                head = dst;
            else
                b.after = dst;
            if (a == null)
                tail = dst;
            else
                a.before = dst;
        }

        // overrides of HashMap hook methods

        void reinitialize() {
            super.reinitialize();
            head = tail = null;
        }

        Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
            LinkedHashMap.Entry<K,V> p =
                    new LinkedHashMap.Entry<K,V>(hash, key, value, e);
            linkNodeLast(p);
            return p;
        }

        Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
            LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
            LinkedHashMap.Entry<K,V> t =
                    new LinkedHashMap.Entry<K,V>(q.hash, q.key, q.value, next);
            transferLinks(q, t);
            return t;
        }

        TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
            TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
            linkNodeLast(p);
            return p;
        }

        TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
            LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
            TreeNode<K,V> t = new TreeNode<K,V>(q.hash, q.key, q.value, next);
            transferLinks(q, t);
            return t;
        }

        //用于reove结点之后，之所以要存在就是因为LHM和HM的Node结构不一样，前者多了after和before
        void afterNodeRemoval(Node<K,V> e) { // unlink
            LinkedHashMap.Entry<K,V> p =
                    (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.before = p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a == null)
                tail = b;
            else
                a.before = b;
        }

        //调用于put、各种compute、merge
        void afterNodeInsertion(boolean evict) { // possibly remove eldest
            LinkedHashMap.Entry<K,V> first;
            //head是最老的结点
            //如果需要插入新节点同时移去旧结点
            if (evict && (first = head) != null && removeEldestEntry(first)) {
                K key = first.key;
                removeNode(hash(key), key, null, false, true);
            }
        }

        void afterNodeAccess(Node<K,V> e) { // move node to last把用到的结点移到队尾
            LinkedHashMap.Entry<K,V> last;
            if (accessOrder && (last = tail) != e) {
                LinkedHashMap.Entry<K,V> p =
                        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
                p.after = null;
                if (b == null)
                    head = a;
                else
                    b.after = a;
                if (a != null)
                    a.before = b;
                else
                    last = b;
                if (last == null)
                    head = p;
                else {
                    p.before = last;
                    last.after = p;
                }
                tail = p;
                ++modCount;
            }
        }

        void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
                s.writeObject(e.key);
                s.writeObject(e.value);
            }
        }
        
        public LinkedHashMap(int initialCapacity, float loadFactor) {
            super(initialCapacity, loadFactor);
            accessOrder = false;
        }
        
        public LinkedHashMap(int initialCapacity) {
            super(initialCapacity);
            accessOrder = false;
        }
        
        public LinkedHashMap() {
            super();
            accessOrder = false;
        }
        
        public LinkedHashMap(Map<? extends K, ? extends V> m) {
            super();
            accessOrder = false;
            putMapEntries(m, false);
        }
        
        //用以构造accessOrder==true的情况
        public LinkedHashMap(int initialCapacity,
                             float loadFactor,
                             boolean accessOrder) {
            super(initialCapacity, loadFactor);
            this.accessOrder = accessOrder;
        }
        
        //遍历构造的队列
        public boolean containsValue(Object value) {
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
                V v = e.value;
                if (v == value || (value != null && value.equals(v)))
                    return true;
            }
            return false;
        }
        
        public V get(Object key) {
            Node<K,V> e;
            if ((e = getNode(hash(key), key)) == null)
                return null;
            if (accessOrder)
                //structural modification
                afterNodeAccess(e);
            return e.value;
        }
        
        public V getOrDefault(Object key, V defaultValue) {
            Node<K,V> e;
            if ((e = getNode(hash(key), key)) == null)
                return defaultValue;
            if (accessOrder)
                //structural modification
                afterNodeAccess(e);
            return e.value;
        }
        
        public void clear() {
            super.clear();
            head = tail = null;
        }

        /*
        Returns true if this map should remove its eldest entry. 
        It provides the implementor with the opportunity to remove the eldest entry each time a new one is added.
        This is useful if the map represents a LRU cache or other interesting implementations
        */
        protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
            return false;
        }
        
        public Set<K> keySet() {
            Set<K> ks = keySet;
            if (ks == null) {
                ks = new LinkedKeySet();
                keySet = ks;
            }
            return ks;
        }

        //HashMap中这几个类都是final，所以继承不了了
        final class LinkedKeySet extends AbstractSet<K> {
            public final int size()                 { return size; }
            public final void clear()               { LinkedHashMap.this.clear(); }
            public final Iterator<K> iterator() {
                return new LinkedKeyIterator();
            }
            public final boolean contains(Object o) { return containsKey(o); }
            public final boolean remove(Object key) {
                return removeNode(hash(key), key, null, false, true) != null;
            }
            public final Spliterator<K> spliterator()  {
                return Spliterators.spliterator(this, Spliterator.SIZED |
                        Spliterator.ORDERED |
                        Spliterator.DISTINCT);
            }
            public final void forEach(Consumer<? super K> action) {
                if (action == null)
                    throw new NullPointerException();
                int mc = modCount;
                //遍历队列
                for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                    action.accept(e.key);
                //保证此间代码同步
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
        
        public Collection<V> values() {
            Collection<V> vs = values;
            if (vs == null) {
                vs = new LinkedValues();
                values = vs;
            }
            return vs;
        }

        final class LinkedValues extends AbstractCollection<V> {
            public final int size()                 { return size; }
            public final void clear()               { LinkedHashMap.this.clear(); }
            public final Iterator<V> iterator() {
                return new LinkedValueIterator();
            }
            public final boolean contains(Object o) { return containsValue(o); }
            public final Spliterator<V> spliterator() {
                return Spliterators.spliterator(this, Spliterator.SIZED |
                        Spliterator.ORDERED);
            }
            public final void forEach(Consumer<? super V> action) {
                if (action == null)
                    throw new NullPointerException();
                int mc = modCount;
                for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                    action.accept(e.value);
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
        
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
        }

        final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
            public final int size()                 { return size; }
            public final void clear()               { LinkedHashMap.this.clear(); }
            public final Iterator<Map.Entry<K,V>> iterator() {
                return new LinkedEntryIterator();
            }
            public final boolean contains(Object o) {
                if (!(o instanceof Map.Entry))
                    return false;
                Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                Object key = e.getKey();
                Node<K,V> candidate = getNode(hash(key), key);
                return candidate != null && candidate.equals(e);
            }
            public final boolean remove(Object o) {
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                    Object key = e.getKey();
                    Object value = e.getValue();
                    return removeNode(hash(key), key, value, true, true) != null;
                }
                return false;
            }
            public final Spliterator<Map.Entry<K,V>> spliterator() {
                return Spliterators.spliterator(this, Spliterator.SIZED |
                        Spliterator.ORDERED |
                        Spliterator.DISTINCT);
            }
            public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
                if (action == null)
                    throw new NullPointerException();
                int mc = modCount;
                for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                    action.accept(e);
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }

        // Map overrides

        public void forEach(BiConsumer<? super K, ? super V> action) {
            if (action == null)
                throw new NullPointerException();
            int mc = modCount;
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                action.accept(e.key, e.value);
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }

        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            if (function == null)
                throw new NullPointerException();
            int mc = modCount;
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                e.value = function.apply(e.key, e.value);
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }

        // Iterators

        abstract class LinkedHashIterator {
            LinkedHashMap.Entry<K,V> next;
            LinkedHashMap.Entry<K,V> current;
            int expectedModCount;

            LinkedHashIterator() {
                next = head;
                expectedModCount = modCount;
                current = null;
            }

            public final boolean hasNext() {
                return next != null;
            }

            final LinkedHashMap.Entry<K,V> nextNode() {
                LinkedHashMap.Entry<K,V> e = next;
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                if (e == null)
                    throw new NoSuchElementException();
                current = e;
                next = e.after;
                return e;
            }

            public final void remove() {
                Node<K,V> p = current;
                if (p == null)
                    throw new IllegalStateException();
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                current = null;
                K key = p.key;
                removeNode(hash(key), key, null, false, false);
                expectedModCount = modCount;
            }
        }

        final class LinkedKeyIterator extends LinkedHashIterator
                implements Iterator<K> {
            public final K next() { return nextNode().getKey(); }
        }

        final class LinkedValueIterator extends LinkedHashIterator
                implements Iterator<V> {
            public final V next() { return nextNode().value; }
        }

        final class LinkedEntryIterator extends LinkedHashIterator
                implements Iterator<Map.Entry<K,V>> {
            public final Map.Entry<K,V> next() { return nextNode(); }
        }

    }
    - -

    其中：

      -

    1. 迭代时间与容量无关

      LinkedHashMap的结构跟HashMap是一样的，也就是都baked by array。此处为什么“迭代时间与容量无关”，是因为LinkedHashMap内部维护了一个简单的链表队列【包含所有元素】，迭代的时候是对这个队列进行迭代，而不是像HashMap一样通过表迭代。

      -

      怪不得读源码时觉得有些地方明明不重写HashMap也可以它却重写了。原来是因为这个性能问题啊

      -
      2. -
    -

    SortedMap(I)

    -

    A Map that further provides a total ordering on its keys.

    -

    The map is ordered according to the natural ordering of its keys, or by a Comparator typically provided at sorted map creation time.

    -

    All keys inserted into a sorted map must implement the Comparable interface (or be accepted by the specified comparator).

    - - -

    关于这部分，详细见sorted set

    -
    -

    最大的特点就是可以人为定义有序并且有sub map

    -

    代码：

    public interface SortedMap<K,V> extends Map<K,V> {
        
        Comparator<? super K> comparator();
        
        SortedMap<K,V> subMap(K fromKey, K toKey);
        
        SortedMap<K,V> headMap(K toKey);
        
        SortedMap<K,V> tailMap(K fromKey);
        
        //也是默认第一个是低的最后一个是高的，就跟LHM的第一个是最少使用，最后一个是最近使用一样
        //Returns the first (lowest) key currently in this map.
        K firstKey();

        //Returns the last (highest) key currently in this map.
        K lastKey();
        
        Set<K> keySet();
        
        Collection<V> values();
        
        Set<Map.Entry<K, V>> entrySet();
    }
    - -
    -

    A SortedMap extended with navigation methods returning the closest matches for given search targets.

    -

    The performance of ascending operations and views is likely to be faster than that of descending ones.

    -

    submap都多加了几个参数：inclusive or exclusive

    -

    其entry不支持setValue，只能通过map自身的put方法改变value。因为要求前者只是map的快照

    -
    -

    跟navigable set差不多的定义

    -

    代码：

    public interface NavigableMap<K,V> extends SortedMap<K,V> {
        
        Map.Entry<K,V> lowerEntry(K key);
        
        K lowerKey(K key);
        
        Map.Entry<K,V> floorEntry(K key);
        
        K floorKey(K key);
        
        Map.Entry<K,V> ceilingEntry(K key);
        
        K ceilingKey(K key);
        
        Map.Entry<K,V> higherEntry(K key);
        
        K higherKey(K key);
        
        Map.Entry<K,V> firstEntry();
        
        Map.Entry<K,V> lastEntry();
        
        Map.Entry<K,V> pollFirstEntry();
        
        Map.Entry<K,V> pollLastEntry();
        
        NavigableMap<K,V> descendingMap();
        
        NavigableSet<K> navigableKeySet();
        
        NavigableSet<K> descendingKeySet();
        
        NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                                 K toKey,   boolean toInclusive);
        
        NavigableMap<K,V> headMap(K toKey, boolean inclusive);
       
        NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
        
        SortedMap<K,V> subMap(K fromKey, K toKey);
        
        SortedMap<K,V> headMap(K toKey);
        
        SortedMap<K,V> tailMap(K fromKey);
    }
    - -

    TreeMap

    -

    NavigableMap的红黑树实现

    -

    key不允许空，空会抛出异常

    -

    Note that this implementation is not synchronized.

    -

    fail-fast

    -

    All Map.Entry pairs returned by methods in this class and its views represent snapshots of mappings at the time they were produced. They do not support the Entry.setValue method. (Note however that it is possible to change mappings in the associated map using put.)【navigable map的性质】

    -
    -

    具体代码就不看了

    -

    对Collection和Map的总结

      -

    1. fail-fast

      -

      The iterators returned by all of this class’s “collection view methods” are fail-fast: if the map is structurally modified at any time after the iterator is created, in any way except through the iterator’s own remove method, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

      -

      Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

      -
      -

      都使用了modcount进行并发检查，都具有fail-fast的特点（关于此的详细解说，可见AbstractList第四点和List第二点），因而只允许在迭代中使用迭代器的remove方法进行结构性改变。【注意：对于LinkedHashMap中access order排序，get方法也是structural modification，因而也只能通过迭代器的next方法获取元素】

      -
      2. -

    2. not synchronized

      上面介绍到的几个类，除了Vector外，都是线程不同步的。可以用此方式让其线程同步。

      -
      Map m = Collections.synchronizedMap(new LinkedHashMap(...));
      3. -

    3. 是否允许null

      除了TreeSet、TreeMap、ArrayDeque之外，都是允许空（key/value）的

      -
      4. -

    4. 是否有序

      List都是插入序，HashSet无需，HashMap也无序（但其实算是有内部桶序的），LinkedHashMap有插入序和LRU序（依靠内部增加简单队列的消耗），TreeSet有序，TreeMap有序【这俩靠红黑树的遍历顺序（二叉搜索树嘛）】。

      -
      5. -

    5. 实现的约定接口

      都Cloneable，Serializable

      -

      ArrayList/Vector：RandomAccess

      -
      6. -
    -]]> - - Java - - 阅读JDK容器部分源码的心得体会1【Collection部分】 /2022/10/16/%E9%98%85%E8%AF%BBJDK%E5%AE%B9%E5%99%A8%E9%83%A8%E5%88%86%E6%BA%90%E7%A0%81%E7%9A%84%E5%BF%83%E5%BE%97%E4%BD%93%E4%BC%9A1%E3%80%90Collection%E9%83%A8%E5%88%86%E3%80%91/ diff --git a/tags/Java/index.html b/tags/Java/index.html index 9e967b95..2aa4b42a 100644 --- a/tags/Java/index.html +++ b/tags/Java/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file +};
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file diff --git a/tags/books/index.html b/tags/books/index.html index 86d185d2..ed5e4eda 100644 --- a/tags/books/index.html +++ b/tags/books/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    books

    2023

    2022

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file +};

    books

    2023

    2022

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file diff --git a/tags/intern/index.html b/tags/intern/index.html index 7fcd07e2..ba5891fd 100644 --- a/tags/intern/index.html +++ b/tags/intern/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    intern

    2023

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file +};

    intern

    2023

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file diff --git a/tags/labs/index.html b/tags/labs/index.html index 29b47dcd..4c7c6429 100644 --- a/tags/labs/index.html +++ b/tags/labs/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    labs

    2023

    2022

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file +};

    labs

    2023

    2022

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file diff --git a/tags/mylife/index.html b/tags/mylife/index.html index 0ab08b0b..bae4d947 100644 --- a/tags/mylife/index.html +++ b/tags/mylife/index.html @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    mylife

    2023

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file +};

    mylife

    2023

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file diff --git "a/tags/os\347\253\236\350\265\233/index.html" "b/tags/os\347\253\236\350\265\233/index.html" index d8aca5d4..90924193 100644 --- "a/tags/os\347\253\236\350\265\233/index.html" +++ "b/tags/os\347\253\236\350\265\233/index.html" @@ -31,4 +31,4 @@ // Wait for 1 second before switching API hosts rotate: 1000, }, -};

    os竞赛

    2023

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file +};

    os竞赛

    2023

    没有更多的黑历史了_(:з」∠)_
    © 2019 – 2023 修年
    由 Hexo 驱动 v5.4.2|主题 - Yun v1.10.11
    \ No newline at end of file