bob的博客

main函数中调用newSubnetManager创建子网管理，具体流程如下；如果命令行opts中指定了子网管理，则通过命令行中的参数调用NewSubnetManagerBuildConfigFromFlags尝试从一个master url或者kubeconfig配置文件中构建配置，它们作为集群组件的命令行标志传。如果没有配置master url和kubeconfig文件路径，会回调InClusterConfig，若失败，则会使用默认etcd配置NewNonInteractiveDefer

main函数中LookupExtIface查找网卡，主要流程如下通过ParseIP解析IP，并用net.IP存储GetInterfaceByIP，将ip传入，net.Interfaces获取所有网卡端口，遍历判断是否存在ip或者直接调用InterfaceByName获取网卡端口如果指定了正则表达式ifregex，则需要匹配，不细说查找到网卡设备，通过iface结构体保存type Interface struct { Index int // positive i

在main函数run后端之后，会创建协程调用WatchLeases，如下：for循环中轮询，调用kube.go中对manager接口的实现，接口如下：type kubeSubnetManager struct { annotations annotations client clientset.Interface nodeName string nodeStore listers.NodeLister nodeController cache.C

当main进程启动后端后，会触发handleSubnetEvents处理事件新建vxlanRoute路由，用作流量封包，结构如下：netlink.Route{ LinkIndex: nw.dev.link.Attrs().Index, Scope: netlink.SCOPE_UNIVERSE, Dst: sn.ToIPNet(), Gw: sn.IP.ToIP(),}新建directRoute路由，若远程主机在一个子网内，则不需要走vxlan..

main函数中RegisterNetwork会根据不同的后端类型调用不同的RegisterNetwork，这里以vxlan为例：定义cfg变量匿名结构体，并使用Unmarshal解析配置文件初始化cfg，结构体如下：struct { VNI int Port int GBP bool Learning bool DirectRouting bool}初始化vxlanDeviceAttrs结构体变量devAttrs

1、initinit函数：进行flannelFlags的初始化，有etcd、iface（网卡）、iface-regex（接口匹配正则）、subnetFile（子网配置）、public-ip（外部访问IP）、subnet-lease-renew-margin（租约）、ip-masq（ip伪装，SANT）、kube-subnet-mgr（subnet api）、kube-api-url（api server url）、kubeconfig-file（kube配置文件）、healthz（healthz地址访问）

mbuf表示memory buffer或message buffer, 是DPDK中非常重要的数据结构, 一般用于存放网卡收发的报文, 但也可以用于存储控制消息, 事件等各种数据.本文基于DPDK 17.11版本的mbuf实现进行描述与编码.1 设计思想1.1 存储mbuf主要由元信息和数据两部分组成, 这两部分存放在一个连续的内存块中. 元信息和数据的关系类似于TCP/IP协议首部与协议数据的关系, 其中元信息描述了数据的属性, 如报文类型, 数据长度与起始地址, RSS hash值等等.mbu

Memory barrier 简介程序在运行时内存实际的访问顺序和程序代码编写的访问顺序不一定一致，这就是内存乱序访问。内存乱序访问行为出现的理由是为了提升程序运行时的性能。内存乱序访问主要发生在两个阶段：编译时，编译器优化导致内存乱序访问（指令重排）运行时，多 CPU 间交互引起内存乱序访问Memory barrier 能够让 CPU 或编译器在内存访问上有序。一个 Memory barrier 之前的内存访问操作必定先于其之后的完成。Memory barrier 包括两类：编译器 bar

感叹号要写在-d的前面才行，而且要用空格隔开。iptables -A OUTPUT -o eth0 -p tcp ! -d xxx.xxx.xxx.xxx -j DROP原文链接：https://www.cnblogs.com/litifeng/p/5616502.html

比方说我们使用docker容器，一定会在iptables的NAT表中看到下在这样的一条配置规则：-A PREROUTING -m addrtype --dst-type LOCAL -j DOCKER从整体上看，这条规则是要把符合什么匹配规则的数据包，在数据包进入NAT表PREROUTING链时，让它直接jump到一个名为DOCKER的链。至于在这个DOCKER的链中有哪些继续生效的NAT规则，不是我们要讨论的。我们主要是分析一下“-m addrtype --dst-type”的数据包匹配规则该做怎

一个网卡设置多个IP的作用就是连接多个网段。举个例子：有两个局域网LAN1(192.168.0.0/24)，LAN2(192.168.1.0/24)，LAN1和LAN2通过交换机物理相连。因为LAN1的网络号是192.168.0，LAN2的网络号是192.168.1，所以LAN1下的主机和LAN2下的主机无法通讯。如何才能让他们相互通讯呢？有两种方法。【方法一】通过路由器连接LAN1和LAN2。【方法二】将LAN1或LAN2下的主机设置两个IP地址，一个是LAN1网络号的主机地址，一个是LAN2网络

yum install https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpmcurl -o /etc/yum.repos.d/jdoss-wireguard-epel-7.repo https://copr.fedorainfracloud.org/coprs/jdoss/wireguard/repo/epel-7/jdoss-wireguard-epel-7.repoyum install wireguard-dk

IntroLinux针对VM/Container提供了丰富的网络功能,下面介绍一些在云环境下常用的网络接口Bridge概况一个Linux网桥扮演一个类似网络交换机的角色。网桥主要负责在连接到它的接口之间转发流量。路由器上流量转发，网关路由观法，或者虚拟机之间，或者同一个主机的不同的namespace之间。支持STP，VLAN过滤，支持多播监听。适用场景当你需要在虚拟机之间/容器之间/主机之间建立一个通信隧道那么就可以使用bridgebond概况Linux的bonding 驱动提供一种将多

本文主要就macvlan和ipvlan的工作模式以及差异做简要介绍；同时，为便于形象的理解，还会涉及到一些实际操作命令。macvlan这里的macvlan是linux kernel提供的一种network driver类型，它有别于传统交换机上提供的mac based vlan功能。可以在linux命令行执行lsmod | grep macvlan 查看当前内核是否加载了该driver；如果没有查看到，可以通过modprobe macvlan来载入，然后重新查看。如果要查看内核源码，可以到以下路径：/

Linux的网卡驱动中内含了很多“虚拟网卡”。早先的文章曾经详细分析过tun，ifb等虚拟网卡，类似的思路，在虚拟化大行其道的趋势下，Linux源码树中不断增加对“网络虚拟化”的支持，不光是为了支持“虚拟机”技术，更多的是给了用户和程序员更多的选择。这些对网络虚拟化的支持技术包括任何重量级的虚拟化技术，比较重的比如对虚拟机技术的支持，轻量级的则是net namespace技术。近期的工作基于net namespace技术，关于这个技术我也不多说了，它主要是提供了每个namespace独立的协议栈以及网卡，

1、Macvlan 简介在 Macvlan 出现之前，我们只能为一块以太网卡添加多个 IP 地址，却不能添加多个 MAC 地址，因为 MAC 地址正是通过其全球唯一性来标识一块以太网卡的，即便你使用了创建 ethx:y 这样的方式，你会发现所有这些“网卡”的 MAC 地址和 ethx 都是一样的，本质上，它们还是一块网卡，这将限制你做很多二层的操作。有了 Macvlan 技术，你可以这么做了。Macvlan 允许你在主机的一个网络接口上配置多个虚拟的网络接口，这些网络 interface 有自己独立的

常见的 if 语句大约是这个样子的（C++）：Event event = getEvent();if (event == EventA) { processA(event);} else { processB(event);}这样有一个问题：变量 event 定义在了 if 语句的外面，也就是说，在 if 语句之后，也可以继续使用 event 变量；而如果后续的操作中不需要 event 变量了，它实际上就造成了命名空间的污染。这并不是一个严重的问题，多数情况下不会造成任何问题，而如果一定

截止到目前，只有一条时间线，在Git里，这个分支叫主分支，即master分支。HEAD严格来说不是指向提交，而是指向master，master才是指向提交的，所以，HEAD指向的就是当前分支。一开始的时候，master分支是一条线，Git用master指向最新的提交，再用HEAD指向master，就能确定当前分支，以及当前分支的提交点：每次提交，master分支都会向前移动一步，这样，随着你不断提交，master分支的线也越来越长。当我们创建新的分支，例如dev时，Git新建了一个指针叫dev，指向

在使用 Git 作为版本控制的时候，我们可能会由于各种各样的原因提交了许多临时的 commit，而这些 commit 拼接起来才是完整的任务。那么我们为了避免太多的 commit 而造成版本控制的混乱，通常我们推荐将这些 commit 合并成一个。一、查看提交历史–git log首先你要知道自己想合并的是哪几个提交，可以使用git log命令来查看提交历史，假如最近4条历史如下：commit 3ca6ec340edc66df13423f36f52919dfa3......commit 1b4056

系统：CentOS 7.8内核：3.10.0一、Master、Node节点都要安装Docker1、 卸载原来的dockersudo yum remove docker \ docker-client \ docker-client-latest \ docker-common \ docker-latest \ docke

Ctrl+a：光标回到命令行首。 （a：ahead）Ctrl+e：光标回到命令行尾。 （e：end） Ctrl+b：光标向行首移动一个字符。 （b：backwards） Ctrl+ f：光标向行尾移动一个字符。 （f：forwards） Ctrl+w: 按照空格为间隔删除单词。Ctrl+k：删除光标处到行尾的字符。Ctrl+u：删除光标处到行首的字符。Ctrl+h：向行首删除一个字符。Ctrl+d：向行尾删除一个字符。Ctrl+y:：粘贴Ctrl+u，Ctrl+k，Ctrl+w删除的文本

原题链接：https://leetcode-cn.com/problems/merge-two-sorted-lists/ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode* head = new ListNode(); ListNode* p = head; while (l1 && l2) { if (l1->val

一、安装前准备apt-get autoremove cmaketar xf cmake-3.12.0.tar.gz && cd cmake-3.12.0./configure && make && make installcmake -version二、安装daqtar xf daq-2.2.2.tar.gz && daq-2.2.2./configure && make && make inst

系统：ubuntu14.04.1内核：4.4.01、安装qemu2、搭建网桥sudo apt-get install bridge-utils修改网络配置文件vi /etc/network/interfaces如果固定ip，添加auto eth0 iface eth0 inet manual auto br0 iface br0 inet static address 192.168.200.130 network 192.168.200.0 netmask 255.255.

系统：ubuntu14.04.1内核：4.4.0Install OVS1. Download OVScd /usr/srcwget http://openvswitch.org/releases/openvswitch-2.6.6.tar.gztar -zxvf openvswitch-2.6.6.tar.gzexport OVS_DIR=/usr/src/openvswitch-2.6.62. Install OVS dependenciessudo apt-get updates

一、安装apt install zlib1g libpcre3 libdnet tcpdump libpcap-dev libdumbnet-dev -ycd /usr/src/daq-2.0.7 ./configure make -j4 && make install cd /usr/src/snort-2.9.8.0./configuremake -j4 && make installldconfig二、卸载cd /usr/src/daq-2.0.7

1. 执行aclocal，产生aclocal.m4文件aclocal根据configure.ac文件的内容，自动生成aclocal.m4文件。而aclocal.m4文件中，包含了生成configure文件所必须的宏。2. 执行autoconf，生成configure文件autoconf会根据configure.ac和aclocal.m4文件，生成configure文件。3. 执行automake命令，产生Makefile.inautomake会根据Makefile.am文件产生一些文件，包含最重

gcc从4.1.2提供了__sync_*系列的built-in函数，用于提供加减和逻辑运算的原子操作。其声明如下：type __sync_fetch_and_add (type *ptr, type value, ...)type __sync_fetch_and_sub (type *ptr, type value, ...)type __sync_fetch_and_or (type *ptr, type value, ...)type __sync_fetch_and_and (type *

一、kfifo概述kfifo是一种"First In First Out "数据结构，它采用了前面提到的环形缓冲区来实现，提供一个无边界的字节流服务。采用环形缓冲区的好处为，当一个数据元素被用掉后，其余数据元素不需要移动其存储位置，从而减少拷贝提高效率。更重要的是，kfifo采用了并行无锁技术，kfifo实现的单生产/单消费模式的共享队列是不需要加锁同步的。struct kfifo { unsigned char *buffer; /* the buffer holding the d

Linux kernel里面从来就不缺少简洁，优雅和高效的代码，只是我们缺少发现和品味的眼光。在Linux kernel里面，简洁并不表示代码使用神出鬼没的超然技巧，相反，它使用的不过是大家非常熟悉的基础数据结构，但是kernel开发者能从基础的数据结构中，提炼出优美的特性。kfifo就是这样的一类优美代码，它十分简洁，绝无多余的一行代码，却非常高效。关于kfifo信息如下：本文分析的原代码版本： 2.6.24.4kfifo的定义文件： kernel/kfifo.ckfifo的头文件： inclu

Install DPDK1. Download DPDKcd /usr/src/wget http://fast.dpdk.org/rel/dpdk-16.07.2.tar.xztar xf dpdk-16.07.2.tar.xzexport DPDK_DIR=/usr/src/dpdk-stable-16.07.2cd $DPDK_DIR2. Configure and Install DPDK注意：以下有些操作DPDK提供了工具供使用者快捷配置，在dpdk/tools/dpdk-set

memcopy和memmove函数在linux下看了一下两个函数的源码。两个函数都在头文件string.h中定义，函数原型为：void * __cdecl memcpy ( void * dst,const void * src,size_t count)；void * __cdecl memmove ( void * dst,const void * src,size_t count)；实现代码如下：void * __cdecl memcpy ( void * dst,const void *

实现 cgroups的主要目的是为不同用户层面的资源管理,提供一个统一化的接口。从单个任务的资源控制到操作系统层面的虚拟化, groups提供了以下四大功能。资源限制：groups可以对任务使用的资源总额进行限制。如设定应用运行时使用内存的上限,一旦超过这个配额就发出OOM( Out of Memory)提示。优先级分配：通过分配的CPU时间片数量及磁盘O带宽大小,实际上就相当于控制了任务运行的优先级。资源统计： groups可以统计系统的资源使用量,如CPU使用时长、内存用量等,这个功能非常适用于

1. UTS namespaceUTS（UNIX Time-sharing System）namespace提供了主机名和域名的隔离，这样每个Docker容器就可以拥有独立的主机名和域名了，在网络上可以被视为一个独立的节点，而非宿主机上的一个进程。Docker中，每个镜像基本都以只身所提供的服务名称来命名镜像的hostname，且不会对宿主机产生任何影响，其原理就是利用了UTS namespace。2. IPC namespace进程间通信（Inter-Process Communication，IP

原题链接：https://leetcode-cn.com/problems/gou-jian-cheng-ji-shu-zu-lcof/vector<int> constructArr(vector<int>& a) { int n = a.size(); if (n == 0) return {}; vector<int> b(n, 0); b[0] = 1; for (int i = 1; i < n; i++

原题链接：https://leetcode-cn.com/problems/qiu-12n-lcof/int sumNums(int n) { n && (n += sumNums(n - 1)); return n;}

原题链接：https://leetcode-cn.com/problems/dui-lie-de-zui-da-zhi-lcof/deque<int> Q1;deque<int> Q2;MaxQueue() {}int max_value() { if (Q1.empty()) return -1; return Q2.front();}void push_back(int value) { Q1.push_back(value);

原题链接：https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-ii-lcof/int singleNumber(vector<int>& nums) { int ones = 0, twos = 0; for (int num : nums) { ones = ones ^ num & ~twos; twos = twos ^ num &a

原题链接：https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof/vector<int> singleNumbers(vector<int>& nums) { int ret = 0; for (int n : nums) ret ^= n; int div = 1; while ((div & ret) == 0) div <

原题链接：https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/动态规划dp[i][j]表示到(i,j)这个点的最大价值状态转移dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]代码int maxValue(vector<vector<int>>& grid) { int m = grid.size(), n = grid[

原题链接：https://leetcode-cn.com/problems/ba-shu-zi-fan-yi-cheng-zi-fu-chuan-lcof/相似题目：解码方法动态规划：dp[i]表示以位置i为结尾的字符串情况有多少种状态转移dp[i] = dp[i - 1] + dp[i - 2] //当s[i - 1]s[i]构成字符串dp[i] = dp[i - 1] //当s[i - 1]s[i]不构成字符串代码：int translateNum(int num) { ma

原题链接：https://leetcode-cn.com/problems/ba-shu-zu-pai-cheng-zui-xiao-de-shu-lcof/string minNumber(vector<int>& nums) { vector<string> str; string ans; for (int i = 0; i < nums.size(); i++) { str.push_back(to_string(num

原题链接：https://leetcode-cn.com/problems/shu-zi-xu-lie-zhong-mou-yi-wei-de-shu-zi-lcof/int findNthDigit(int n) { int digit = 1; long start = 1; long count = 9; while (n > count) { n -= count; digit += 1; start *= 10

原题链接：https://leetcode-cn.com/problems/1nzheng-shu-zhong-1chu-xian-de-ci-shu-lcof/int countDigitOne(int n) { long digit = 1, res = 0; int high = n / 10, cur = n % 10, low = 0; while (high != 0 || cur != 0) { if (cur == 0) {//当cur=0时，1的出

原题链接：https://leetcode-cn.com/problems/zi-fu-chuan-de-pai-lie-lcof/vector<string> res; vector<string> permutation(string s) { dfs(0, s); return res;}void dfs(int x, string s) { if (x == s.size() - 1) { res.push_back(s);

原文链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-yu-shuang-xiang-lian-biao-lcof/Node *pre = NULL, *head;Node* treeToDoublyList(Node* root) { if (root == NULL) return NULL; dfs(root); head->left = pre;//head指向头节点，pre指向尾节点 pre-&g

原题链接：https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/vector<vector<int>> res;vector<int> path;vector<vector<int>> pathSum(TreeNode* root, int sum) { recur(root, sum); return res;

strcpy函数实现strcpy函数的原型为：char* strcpy(char* _Dest, const char* _Source);//实现1char * strcpy(char* _Dest, const char* _Source){ //检查传入参数的有效性 assert(NULL != _Dest); assert(NULL != _Source); if (NULL ==_Dest || NULL == _Source) retur

1. Bridge模式当Docker进程启动时，会在主机上创建一个名为docker0的虚拟网桥，此主机上启动的Docker容器会连接到这个虚拟网桥上。虚拟网桥的工作方式和物理交换机类似，这样主机上的所有容器就通过交换机连在了一个二层网络中。这里有个比较坑的地方，这个 Docker bridge模式的名字和桥接很像，但是实际上关系不大，Docker bridge模式有点像虚拟机中的 NAT 模式。2. Host 模式如果启动容器的时候使用host模式，那么这个容器将不会获得一个独立的Network

1.容器技术简介对于容器，它首先是一个相对独立的运行环境，在这一点有点类似于虚拟机，但是不像虚拟机那样彻底。在容器内，应该最小化其对外界的影响，比如不能在容器内把宿主机上的资源全部消耗，这就是资源控制。2.容器与虚拟机的区别容器和虚拟机之间的主要区别在于虚拟化层的位置和操作系统资源的使用方式。容器与虚拟机拥有着类似的使命：对应用程序及其关联性进行隔离，从而构建起一套能够随处运行的自容纳单元。此外，容器与虚拟机还摆脱了对物理硬件的需求，允许我们更为高效地使用计算资源，从而提升能源效率与成本效益。　　

关于虚函数的背景知识用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。存在虚函数的类都有一个一维的虚函数表叫做虚表。每一个类的对象都有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。多态性是一个接口多种实现，是面向对象的核心。分为编译多态性和运行多态性。运行多态用虚函数来实现，结合动态绑定。纯虚函数是虚函数再加上=0。并且该函数只有声明，没有实现。抽象类是指包括至少一个纯虚函数的类。详细原理：编译器在编译的时候，发现Base类中有虚函数，此时编译器

属性new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持。参数使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。返回类型new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。分配失败.

semaphore mutex = 1;semaphore fillCount = 0;semaphore emptyCount = BUFFER_SIZE;procedure producer() { while (true) { item = produceItem(); down(emptyCount); down(mutex); putItemIntoBuffer(item);

原题链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-hou-xu-bian-li-xu-lie-lcof/bool verifyPostorder(vector<int>& postorder) { return recur(postorder, 0, postorder.size() - 1);}bool recur(vector<int> postorder, int i, int j)

原题链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/vector<int> levelOrder(TreeNode* root) { if (root == NULL) return {}; vector<int> ans; queue<TreeNode*> Q; Q.push(root); while (!Q.empty(

原题链接：https://leetcode-cn.com/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof/bool validateStackSequences(vector<int>& pushed, vector<int>& popped) { stack<int> sk; int i = 0; for (int num : pushed) { sk.push(num);

指针和引用在C++中很常用，但是对于它们之间的区别很多初学者都不是太熟悉，下面来谈谈他们2者之间的区别和用法。指针和引用的定义和性质区别：(1)指针：指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。如：int a=1;int *p=&a;int a=1;int &b=a;上面定义了一个整形变量和一个指针变量p，该指针变量指向a的存储单元，即p的值是a存储单元的地址。而下面2句定义了一个整形

自旋锁(Spin lock)自旋锁与互斥锁有点类似，只是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是 否该自旋锁的保持者已经释放了锁，"自旋"一词就是因此而得名。其作用是为了解决某项资源的互斥使用。因为自旋锁不会引起调用者睡眠，所以自旋锁的效率远 高于互斥锁。虽然它的效率比互斥锁高，但是它也有些不足之处：自旋锁一直占用CPU，他在未获得锁的情况下，一直运行－－自旋，所以占用着CPU，如果不能在很短的时 间内获得锁，这无疑会使CPU效率降低。在用自旋锁时有可能

POSIX threads(简称Pthreads)是在多核平台上进行并行编程的一套API。线程同步是并行编程中非常重要的通讯手段，其中最典型的应用就是用Pthreads提供的锁机制(lock)来对多个线程之间的共享临界区(Critical Section)进行保护(另一种常用的同步机制是barrier)。Pthreads提供了多种锁机制：Mutex(互斥量)：pthread_mutex_tSpin lock(自旋锁): pthread_spin_tCondition Variable(条件变量)

如果你的程序中使用dlopen、dlsym、dlclose、dlerror 显示加载动态库，需要设置链接选项 -ldl加载动态链接库，首先为共享库分配物理内存，然后在进程对应的页表项中建立虚拟页和物理页面之间的映射。你可以认为系统中存在一种引用计数机制， 每当一个进程加载了共享库（在该进程的页表中进行一次映射），引用计数加一；一个进程显式卸载（通过dlclose等）共享库或进程退出时，引用计数减 一，当减少到0时，系统卸载共享库。(1)打开动态链接库：dlopen，函数原型void *dlopen

ISO规范里定义了7层网络模型，实际常用的仍为TCPIP四层网络模型。注：本文章插图均来自《图解TCP/IP》。数据链路层帧格式经常说的帧格式为以太网帧格式，由于类型和帧长度字段不重复，所以两种类型帧格式易于区分。常用的上层协议类型为：IPv4(0800)，ARP（0806），RARP（8035）。IP层协议格式IPv4首部IPv6arp包传输层协议格式UDP首部TCP首部原文链接：https://www.cnblogs.com/embedded-linux/p/69

一、什么是单例模式单例模式(Singleton Pattern，也称为单件模式)，使用最广泛的设计模式之一。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。定义一个单例类，私有化它的构造函数，以防止外界创建单例类的对象；使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法获取该实例。二、懒汉版（Lazy Singleton）教学版，即懒汉版（Lazy Singleton）：单例实例在第一次被使用时才进行初始化，这叫做延迟初始化。// versio

C++11 中推出了三种智能指针，unique_ptr、shared_ptr 和 weak_ptr，同时也将 auto_ptr 置为废弃 (deprecated)。但是在实际的使用过程中，很多人都会有这样的问题：不知道三种智能指针的具体使用场景无脑只使用 shared_ptr认为应该禁用 raw pointer(裸指针，即 Widget *这种形式)，全部使用智能指针本文将从这几方面讲解智能指针：智能指针的应用场景分析智能指针的性能分析: 为什么 shared_ptr 性能比 uniqu

TCP和UDP区别OSI 和 TCP/IP 模型在传输层定义两种传输协议：TCP（或传输控制协议）和 UDP（或用户数据报协议）。UDPUDP 与 TCP 的主要区别在于 UDP 不一定提供可靠的数据传输。事实上，该协议不能保证数据准确无误地到达目的地。UDP 在许多方面非常有效。当某个程序的目标是尽快地传输尽可能多的信息时（其中任意给定数据的重要性相对较低），可使用 UDP。ICQ 短消息使用 UDP 协议发送消息。许多程序将使用单独的TCP连接和单独的UDP连接。重要的状态信息随可靠的TCP连

本文分别对Cookie与Session做一个介绍和总结，并分别对两个知识点进行对比分析，让大家对Cookie和Session有一个更深入的了解，并对自己的开发工作中灵活运用带来启示。cookie机制Cookies是服务器在本地机器上存储的小段文本并随每一个请求发送至同一个服务器。IETF RFC 2965 HTTP State Management Mechanism 是通用cookie规范。网络服务器用HTTP头向客户端发送cookies，在客户终端，浏览器解析这些cookies并将它们保存为一个本地

原题链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof/1、递归TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { if (root->val < p->val && root->val < q->val) return l

原题链接：https://leetcode-cn.com/problems/bu-yong-jia-jian-cheng-chu-zuo-jia-fa-lcof/int add(int a, int b) { while (b != 0) { int c = (unsigned int)(a & b) << 1; a ^= b; b = c; } return a;}

原题链接：https://leetcode-cn.com/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/int lastRemaining(int n, int m) { int ans = 0; // 最后一轮剩下2个人，所以从2开始反推 for (int i = 2; i <= n; i++) { ans = (ans + m) % i; } return ans;}

原题链接：https://leetcode-cn.com/problems/bu-ke-pai-zhong-de-shun-zi-lcof/bool isStraight(vector<int>& nums) { set<int> st; int ma = 0, mi = 14; for (auto num : nums) { if (num == 0) continue; ma = max(ma, num);

原题链接：https://leetcode-cn.com/problems/nge-tou-zi-de-dian-shu-lcof/vector<double> twoSum(int n) { vector<vector<int>> dp(15, vector<int>(70, 0)); for (int i = 1; i <= 6; i++) { dp[1][i] = 1; } for (int i =

原题链接：https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/滑动窗口：vector<int> maxSlidingWindow(vector<int>& nums, int k) { int n = nums.size(); if (n == 0 || k == 0) return {}; deque<int> dq; vector&

原题链接：https://leetcode-cn.com/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/string reverseLeftWords(string s, int n) { return s.substr(n) + s.substr(0, n) ;}

原题链接：https://leetcode-cn.com/problems/fan-zhuan-dan-ci-shun-xu-lcof/string reverseWords(string s) { stringstream ss(s); string str, ans; stack<string> sk; while (ss >> str){ sk.push(str); } while (!sk.empty()) { ans += sk.top()

原题链接：https://leetcode-cn.com/problems/he-wei-sde-lian-xu-zheng-shu-xu-lie-lcof/滑动窗口vector<vector<int>> findContinuousSequence(int target) { int i = 1;//滑动窗口的左边界 int j = 1;//滑动窗口的右边界 int sum = 0;//滑动窗口中数字的和 vector<vector<

原题链接：https://leetcode-cn.com/problems/he-wei-sde-liang-ge-shu-zi-lcof/双指针vector<int> twoSum(vector<int>& nums, int target) { int n = nums.size(); int p = 0, q = n - 1; vector<int> ans; while (p < q) {

原题链接：https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof/1、后序遍历 + 剪枝bool isBalanced(TreeNode* root) { return dfs(root) != -1;}int dfs(TreeNode* root) { if (root == NULL) return 0; int depthLeft = dfs(root->left); if (depthLef

原题链接：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof/dfsint maxDepth(TreeNode* root) { if (root == NULL) return 0; return max(maxDepth(root->left),maxDepth(root->right)) + 1;}

原题链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/int kthLargest(TreeNode* root, int k) { vector<int> vr; postOrder(root, vr); return vr[k - 1];}void postOrder(TreeNode* root, vector<int>& vr)

原题链接：https://leetcode-cn.com/problems/que-shi-de-shu-zi-lcof/int missingNumber(vector<int>& nums) { int ans = 0; for (auto x : nums) { if (x == ans) ans++; else break; } return ans; }

原题链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/int search(vector<int>& nums, int target) { int ans = 0; for (auto x : nums) { if (x == target) ans++; } return ans;}

原题链接：https://leetcode-cn.com/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof/char firstUniqChar(string s) { vector<char> keys; unordered_map<char, int> ump; int n = s.size(); for (auto x : s){ if (!ump.count(x)) keys

原题链接：https://leetcode-cn.com/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/int maxSubArray(vector<int>& nums) { int n = nums.size(); int res = nums[0]; for (int i = 1; i < n; i++) { nums[i] += max(nums[i - 1], 0); r

零拷贝这三个字，一直是服务器网络编程的关键字，任何性能优化都离不开。在 Java 程序员的世界，常用的零拷贝有 mmap 和 sendFile。那么，他们在 OS 里，到底是怎么样的一个的设计？本文将简单聊聊 mmap 和 sendFile 这两个零拷贝。一、传统IO的劣势初学 Java 时，我们在学习 IO 和 网络编程时，会使用以下代码：File file = new File("index.html");RandomAccessFile raf = new RandomAccessFile(f

防火墙相关概念此处先描述一些相关概念。从逻辑上讲。防火墙可以大体分为主机防火墙和网络防火墙。主机防火墙：针对于单个主机进行防护。网络防火墙：往往处于网络入口或边缘，针对于网络入口进行防护，服务于防火墙背后的本地局域网。网络防火墙和主机防火墙并不冲突，可以理解为，网络防火墙主外（集体）， 主机防火墙主内（个人）。从物理上讲，防火墙可以分为硬件防火墙和软件防火墙。硬件防火墙：在硬件级别实现部分防火墙功能，另一部分功能基于软件实现，性能高，成本高。软件防火墙：应用软件处理逻辑运行于通用硬件平

访问控制和继承一个派生类继承了所有的基类方法，但下列情况除外：基类的构造函数、析构函数和拷贝构造函数。基类的重载运算符。基类的友元函数。继承类型当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：公有继承（public）：

原题链接：vector<int> getLeastNumbers(vector<int>& arr, int k) { vector<int> ans; sort(arr.begin(), arr.end()); for (int i = 0; i < k; i++) { ans.push_back(arr[i]); } return ans;}

原题链接：https://leetcode-cn.com/problems/shu-zu-zhong-chu-xian-ci-shu-chao-guo-yi-ban-de-shu-zi-lcof/int majorityElement(vector<int>& nums) { sort(nums.begin(), nums.end()); return nums[nums.size() / 2];}

原题链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/vector<vector<int>> levelOrder(TreeNode* root) { queue<TreeNode*> qe; vector<vector<int>> res; if (root != NULL) qe.push(root);

原题链接：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof/class MinStack {public: stack<int> A, B;//A为正常栈，B为 /** initialize your data structure here. */ MinStack() { } void push(int x) { A.push(x);

输入数组，数组中为树先序遍历结果，空节点值为-1Node* createTree(vector<int> nums, int &pos) { int n = nums.size(); if (pos >= n || nums[pos] == -1) return NULL; Node *root = (Node *)malloc(sizeof(Node)); root->val = nums[pos]; if (pos < n)

原题链接：https://leetcode-cn.com/problems/recover-a-tree-from-preorder-traversal/迭代 + 栈TreeNode* recoverFromPreorder(string S) { // 存储当前节点的路径 stack<TreeNode*> path; // 存储字符串中的位置 int pos = 0; while (pos < S.size()) {

原题链接：https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { if (root == NULL || root == p || root == q) return root;//当越过叶节点，则直接返回null，当root等于p,q,则直接返回ro

docker run -i -t ubuntu /bin/bash输入上面这行命令，启动一个ubuntu容器时，到底发生了什么？大致过程可以用下图描述：首先系统要有一个docker daemon的后台进程在运行，当刚才这行命令敲下时，docker client(即：docker终端命令行)会调用docker daemon请求启动一个容器，docker daemon会向host os(即：linux)请求创建容器linux会创建一个空的容器（可以简单理解为：一个未安装操作系统的裸机

原题链接：https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/vector<int> spiralOrder(vector<vector<int>>& matrix) { int n = matrix.size(); if (n == 0) return {}; int m = matrix[0].size(); vector<int> a

原题链接：https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof/bool isSymmetric(TreeNode* root) { if(root == NULL) return true; return isSymmetric(root->left, root->right);}bool isSymmetric(TreeNode* leftNode, TreeNode* rightNode) {

原题链接：https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof/TreeNode* mirrorTree(TreeNode* root) { if (root == NULL) return NULL; mirrorTree(root->left); mirrorTree(root->right); swap(root->left, root->right); retur

原题链接：https://leetcode-cn.com/problems/shu-de-zi-jie-gou-lcof/bool isSubStructure(TreeNode *A, TreeNode* B) {//先序遍历根节点的子树 return (A && B) && (recur(A, B) || isSubStructure(A->left, B) || isSubStructure(A->right, B));}bool recur

原题链接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode *p1 = l1, *p2 = l2; ListNode *dum = new ListNode(0), *cur = dum; while (p1 && p2) {

原题链接：https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/双指针ListNode* getKthFromEnd(ListNode* head, int k) { ListNode *p = head, *q = head; while (q && k) {//q比p先走k步 q = q->next; k--; }