public class MyArrayList<AnyType> implements Iterable<AnyType>
{
	private static final int DEFAULT_CAPACITY = 10;
	
	private int theSize;
	private AnyType[] theItems;
	
	public int size()
	{
		return theSize;
	}
	
	public boolean isEmpty()
	{
		return size() == 0;
	}
	
	//调整容量符合大小
	public void trimToSize()
	{
		ensureCapacity(size());
	}
	//确保数组大小足够大
	public void ensureCapacity(int newCapacity)
	{
		if(newCapacity < theSize)
			return;
		
		//复制数据到新数组中
		AnyType[] old = theItems;
		theItems = (AnyType[]) new Object[newCapacity];
		for(int i = 0; i <size(); i++)
		{
			theItems[i] = old[i];
		}
	}
	public AnyType get(int index)
	{
		if(index < 0 || index >= size())
		{
			throw new ArrayIndexOutOfBoundsException();
		}
		return theItems[index];
	}
	
	public AnyType set(int index, AnyType newVal)
	{
		if(index < 0 || index >= size())
		{
			throw new ArrayIndexOutOfBoundsException();
		}
		AnyType old = theItems[index];
		theItems[index] = newVal;
		return old;
	}
	
	public void add(int index, AnyType x)
	{
		//数组不够大，则扩大数组
		if(theItems.length == size())
		{
			ensureCapacity(size()*2 + 1);
		}
		//从index开始，元素往后移动一位
		for(int i = theSize; i > index; i--)
		{
			theItems[i] = theItems[i - 1];
		}
		//index位置赋值x
		theItems[index] = x;
		theSize++;
	}
	
	public AanyType remove(int index)
	{
		AnyType removedItem = theItems[index];
		for(int i = index; i < size(); i++)
		{
			//从index位置开始，所有元素都往前移动一位
			theItems[i] = theItems[i + 1];
		}
		theSize--;
		return removedItem;
	}
	
	public java.util.Iterator<AnyType> iterator()
	{
		return new ArrayListIterator<AnyType>();
	}
	
	private static class ArrayListIterator<AnyType> implements java.util.Iterator<AnyType>
	{
		private int current = 0;
		
		public boolean hasNext()
		{
			return current < MyArrayList.this.size();
		}
		
		public AnyType next()
		{
			return MyArrayList.this.theItems[current++];
		}
		
		public void remove()
		{
			//防止迭代器的remove与MyArrayList的remove冲突
			MyArrayList.this.remove(--current);
		}
	}
};

public class MyLinkedList<AnyType> implements Iterable<AnyType>
{
	private static class Node<AnyType>
	{
		public AnyType data;
		public Node<AnyType> prev;
		public Node<AnyType> next;
		public Node(AnyType d, Node<AnyType> p, Node<AnyType> n)
		{
			data = d;
			prev = p;
			next = n;
		}
	}
	
	private int theSize;
	//自从链表构造以来对链表所做的改变次数
	//与迭代器里的modCount进行比较
	private int modCount = 0;
	//头节点
	private Node<AnyType> beginMarker;
	//尾节点
	private Node<AnyType> endMarker;
	
	public boolean add(AnyType x)
	{
		add(size(), x);
		return true;
	}
	
	public void add(int index, AnyType x)
	{
		//根据index获取节点，在该节点前添加x
		addBefore(getNode(index, x));
	}
	
	public void addBefore(Node<AnyType> p, AnyTyoe x)
	{
		//在p和p之前插入新节点
		Node<AnyType> newNode = new Node<AnyType>(x, p.prev, p);
		//更新新节点前一节点的后一节点链接
		newNode.prev.next = newNode;
		//更新p的前一节点链接
		p.prev = newNode;
		theSize++;
		modCount++;
	}
	public AnyType get(int index)
	{
		return getNode(index).data;
	}
	
	public AnyType set(int index, AnyType newVal)
	{
		Node<AnyType> p = getNode(index);
		AnyType oldVal = p.data;
		p.data = newVal;
		return oldVal;
	}
	
	public AnyType remove(int index)
	{
		return remove(getNode(index));
	}
	
	private AnyType remove(Node<AnyType> p)
	{
		p.next.prev = p.prev;
		p.prev.next = p.next;
		theSize--;
		modCount++;
		
		return p.data;
	}
	
	private Node<AnyType> getNode(int index)
	{
		Node<AnyType> p;
		
		if(index < 0 || index > size())
		{
			throw new IndexOutOfBoundsException();
		}
		
		//从头节点或者尾节点开始查找
		if(index < size() / 2)
		{
			p = beginMarker.next;
			for(int i = 0; i < index; i++)
			{
				p = p.next;
			}
		}
		else
		{
			p = endMarker;
			for(int i = size(); i > index; i--)
			{
				p = p.prev;
			}
		}
		
		return p;
	}
	
	private class LinkedListIterator implements java.util.Iterator<AnyType>
	{
		private Node<AnyType> current = beginMarker.next;
		private int expectedModCount = modCount;
		private boolean okToRemove = false;
		
		public boolean hasNext()
		{
			return current != endMarker;
		}
		
		public AnyType next()
		{
			if(modCount != expectedModCount)
			{
				throw new java.util.ConcurrentModificationException();
			}
			if(!hasNext())
			{
				throw new java.util.NoSuchElementException();
			}
			
			AnyType nextItem = current.data;
			current = current.next;
			okToRemove = true;
			return nextItem;
		}
		
		public void remove()
		{
			if(modCount != expectedModCount)
			{
				throw new java.util.ConcurrentModificationException();
			}
			if(!okToRemove)
			{
				throw new IllegalStateException();
			}
			
			MyLinkedList.this.remove(current.prev);
			okToRemove = false;
			expectedModCount++;
		}
	}
}

docker run -d -p 5000:5000 -v /data/registry:/var/lib/registry --restart=always --name registry registry:2
# 配置非安全访问的仓库IP:端口号
/etc/docker/daemon.json 
"insecure-registries":["10.0.2.15:5000"]

docker push 192.168.1.62:5000/xpanda/busybox
docker pull 192.168.1.62:5000/xpanda/busybox

docker search
docker ps
docker images
#删除镜像
docker rmi
#删除容器实例
docker rm
#下载镜像
docker pull quay.io/coreos/etcd:v3.2.16
#构建镜像
docker build -t xpanda/nginx:1.12.2 .
#后台运行
docker run -d -p 8080:8080 -p 443:443 --ip 10.20.0.1 -v /data/configs/nginx/conf.d:/etc/nginx/conf.d -v /data/configs/nginx/certs:/etc/nginx/certs xpanda/nginx:1.12.2
#进入容器
docker exec -it 5c61a04b14fc /bin/bash
#日志查看
docker logs -f --tail=100 6aa2172c8742
journalctl -u docker.service -n

释放页：```free_pages

struct super_block {
  unsigned long long s_maxbytes;//文件大小上限
  struct file_system_type s_type;//文件系统类型
}

struct inode {
  unsigned long i_ino;//节点号
  atomic_t i_count;//引用计数
  loff_t i_size;//以字节为单位的文件大小
  struct address_space *i_mapping;//相关的地址映射
  struct address_space i_data;//设备地址映射
  struct dquot *i_dquot[MAXQUOTAS];//索引节点的磁盘限额
}

// <linux/dcache.h>

struct dentry {
  struct dentry *d_parent;//父目录的目录项对象
  struct qstr d_name;//目录项名称
  struct inode *d_inode;//相关联的索引节点
}

struct file {
  struct path f_path;//包含目录项
}