一、安装和运行

memcache 安装

1
2

sudo apt install libevent libevent-dev
sudo apt install memcached

memcache 帮助

1
2
3
4
5
6
7
8
9
10

memcached -h
-d 启动一个守护进程
-m 分配给 memcache 使用的内存数量，单位是 MB
-u 运行 memcache 的用户
-l 监听的服务器 IP 地址，可以有多个地址
-p 设置 memcache 监听的端口
-c 最大运行的并发连接数，默认是 1024
-P 设置保存 memcache 的 pid 文件
-v 打印错误/警告日志
-vv 或 -vvv 打印更加详细的日志

文件映射相当于将一个磁盘文件映射到内存中，通过 mmap 的方式，后面我们读写此文件的时候，就可以通过读写内存来操作此文件。本文我们测试一下通过 mmap 映射磁盘文件到内存中，docker 对其的支持情况。

一、提出问题

• 容器重启后，映射的文件是否可以保留
• 不同容器之间，容器与宿主机之间。文件是否可见

我们在物理机时代，对于进程间通信，我们会经常想到使用共享内存，因为可以做到一块共享内存可以做到被映射到多个进程的虚拟地址空间，从而实现进程间通信比较快速。并且进程退出后，共享内存还在，并不会归还给操作系统。这样在一定程序上做到了数据的持久性。

进入 docker 时代，程序的部署、发布一般都采用 k8s、docker 等这种云上技术，本文探讨一下 docker 容器对于共享内存的支持。

一、提出问题

1. 不同的容器之间，“共享内存” 是否隔离？
2. 容器中创建的 “共享内存”，在宿主机中是否可见？

本文使用的内核版本为：v2.6.12

我们一般称键值对数组为映射，也称为哈希。一般查找的时间复杂度可以低至常数级别。在高频次的查询场景中，有较为优异的性能。关于映射的性质，我们不过多讨论，本文主要看看 Linux 中映射的实现，本文以 Linux 2.6.12 版本为例。

Linux 实现的映射，并不是一个通用的映射。他的目标是：映射一个唯一数（UID）到一个指针。

一、实现结构

Linux 提供了结构体 idr 用来完成这一目标。如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

struct idr_layer {
	unsigned long		 bitmap;
	struct idr_layer	*ary[1<<IDR_BITS];  // 64 位机器 IDR_BITS 为 6
	int			 count;
};

struct idr {
	struct idr_layer *top;
	struct idr_layer *id_free;
	int		  layers;
	int		  id_free_cnt;
	spinlock_t	  lock;
};

队列是一种定义了 FIFO 先进先出的结构。Linux 内核的队列实现在 kfifo.c 中。本文以 Linux 2.6.12 版本来进行讨论。

我们还是老样子，从底层实现看起，然后再来总结规律、适用场景。

一、创建队列

创建队列的实现如下：

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

struct kfifo *kfifo_init(unsigned char *buffer, unsigned int size,
			 unsigned int __nocast gfp_mask, spinlock_t *lock)
{
	struct kfifo *fifo;

	/* size must be a power of 2 */
	BUG_ON(size & (size - 1));

	fifo = kmalloc(sizeof(struct kfifo), gfp_mask);
	if (!fifo)
		return ERR_PTR(-ENOMEM);

	fifo->buffer = buffer;
	fifo->size = size;
	fifo->in = fifo->out = 0;
	fifo->lock = lock;

	return fifo;
}

struct kfifo *kfifo_alloc(unsigned int size, unsigned int __nocast gfp_mask, spinlock_t *lock)
{
	unsigned char *buffer;
	struct kfifo *ret;

	/*
	 * round up to the next power of 2, since our 'let the indices
	 * wrap' tachnique works only in this case.
	 */
	if (size & (size - 1)) {
		BUG_ON(size > 0x80000000);
		size = roundup_pow_of_two(size);
	}

	buffer = kmalloc(size, gfp_mask);
	if (!buffer)
		return ERR_PTR(-ENOMEM);

	ret = kfifo_init(buffer, size, gfp_mask, lock);

	if (IS_ERR(ret))
		kfree(buffer);

	return ret;
}

链表是一种存放和操作可变数量元素（常称为节点）的数据结构。他们在内存中无须占有连续内存块，内存块之间通过指针连接。本文探讨一下 Linux 中链表的实现。

一、链表的定义

Linux 内核中，不是将数据结构塞入链表，而是将链表节点塞入数据结构。

比如我们之前定义链表，一般是有了结构体，然后在此结构体中增加 “前向指针” 或者“ 后向指针”，以达到链表将节点串联起来的目的。而 Linux 内核中，是将链表节点塞入数据结构体中，以达到同样的效果。

链表代码在头文件：<linux/include/linux/list.h> 中声明，数据结构如下：

1
2
3

struct list_head {
	struct list_head *next, *prev;
};

我们都知道使用原始的JDBC在操作数据库是比较麻烦的，所以Spring为了提高开发的效率，顺带着就把JDBC封装、改造了一番，而JdbcTemplate就是Spring对原始JDBC封装之后提供的一个操作数据库的工具类。

我们可以借助JdbcTemplate来完成所有数据库操作，比如：增删改查等。

JdbcTemplate主要提供以下三种类型的方法：

• executeXxx() : 执行任何SQL语句，对数据库、表进行新建、修改、删除操作

• 返回上一级 [项目]
• 链接与装载
  • 1.预处理、编译、汇编、链接过程
  • 2.二进制的装载与执行

• 返回上一级 [项目]
• 锁竞争分析工具
  • image
  • 原理