You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1756 lines
250 KiB
1756 lines
250 KiB
<!DOCTYPE html>
|
|
<html lang="zh-Hans">
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=2">
|
|
<meta name="theme-color" content="#222">
|
|
<meta name="generator" content="Hexo 4.2.0">
|
|
<link rel="apple-touch-icon" sizes="180x180" href="/images/apple-touch-icon-next.png">
|
|
<link rel="icon" type="image/png" sizes="32x32" href="/images/favicon-32x32-next.png">
|
|
<link rel="icon" type="image/png" sizes="16x16" href="/images/favicon-16x16-next.png">
|
|
<link rel="mask-icon" href="/images/logo.svg" color="#222">
|
|
<meta name="google-site-verification" content="2X6S9P7CAjXjVvw8YyQR8pCu-B0oEu7O9quLgxXuWyA">
|
|
<meta name="baidu-site-verification" content="dV8JGNzi0c">
|
|
<meta name="chinaz-site-verification" content="500A176AA29CFB31">
|
|
|
|
<script data-ad-client="ca-pub-7480618470784058" async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
|
|
|
|
<link rel="stylesheet" href="/css/main.css">
|
|
|
|
<link rel="stylesheet" href="//fonts.loli.net/css?family=Lato:300,300italic,400,400italic,700,700italic|M+ 2p:300,300italic,400,400italic,700,700italic&display=swap&subset=latin,latin-ext">
|
|
<link rel="stylesheet" href="/lib/font-awesome/css/all.min.css">
|
|
<link rel="stylesheet" href="//cdn.jsdelivr.net/gh/fancyapps/fancybox@3/dist/jquery.fancybox.min.css">
|
|
|
|
<script id="hexo-configurations">
|
|
var NexT = window.NexT || {};
|
|
var CONFIG = {"hostname":"nicksxs.me","root":"/","scheme":"Pisces","version":"7.8.0","exturl":false,"sidebar":{"position":"left","display":"post","padding":18,"offset":12,"onmobile":false},"copycode":{"enable":true,"show_result":false,"style":null},"back2top":{"enable":true,"sidebar":false,"scrollpercent":false},"bookmark":{"enable":false,"color":"#222","save":"auto"},"fancybox":true,"mediumzoom":false,"lazyload":true,"pangu":false,"comments":{"style":"tabs","active":null,"storage":true,"lazyload":false,"nav":null},"algolia":{"hits":{"per_page":10},"labels":{"input_placeholder":"Search for Posts","hits_empty":"We didn't find any results for the search: ${query}","hits_stats":"${hits} results found in ${time} ms"}},"localsearch":{"enable":false,"trigger":"auto","top_n_per_article":1,"unescape":false,"preload":false},"motion":{"enable":true,"async":false,"transition":{"post_block":"fadeIn","post_header":"slideDownIn","post_body":"slideDownIn","coll_header":"slideLeftIn","sidebar":"slideUpIn"}}};
|
|
</script>
|
|
|
|
<meta name="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
<meta property="og:type" content="website">
|
|
<meta property="og:title" content="Nicksxs's Blog">
|
|
<meta property="og:url" content="https://nicksxs.me/index.html">
|
|
<meta property="og:site_name" content="Nicksxs's Blog">
|
|
<meta property="og:description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
<meta property="article:author" content="Nicksxs">
|
|
<meta property="article:tag" content="Nicksxs">
|
|
<meta property="article:tag" content="史学森">
|
|
<meta property="article:tag" content="米方方">
|
|
<meta property="article:tag" content="米方方的男朋友">
|
|
<meta property="article:tag" content="森哥">
|
|
<meta name="twitter:card" content="summary">
|
|
|
|
<link rel="canonical" href="https://nicksxs.me/">
|
|
|
|
|
|
<script id="page-configurations">
|
|
// https://hexo.io/docs/variables.html
|
|
CONFIG.page = {
|
|
sidebar: "",
|
|
isHome : true,
|
|
isPost : false,
|
|
lang : 'zh-Hans'
|
|
};
|
|
</script>
|
|
|
|
<title>Nicksxs's Blog</title>
|
|
|
|
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-61358619-1"></script>
|
|
<script>
|
|
if (CONFIG.hostname === location.hostname) {
|
|
window.dataLayer = window.dataLayer || [];
|
|
function gtag(){dataLayer.push(arguments);}
|
|
gtag('js', new Date());
|
|
gtag('config', 'UA-61358619-1');
|
|
}
|
|
</script>
|
|
|
|
|
|
<script>
|
|
var _hmt = _hmt || [];
|
|
(function() {
|
|
var hm = document.createElement("script");
|
|
hm.src = "https://hm.baidu.com/hm.js?20f33b3c0c0eff9b1522999c0015646d";
|
|
var s = document.getElementsByTagName("script")[0];
|
|
s.parentNode.insertBefore(hm, s);
|
|
})();
|
|
</script>
|
|
|
|
|
|
|
|
|
|
<noscript>
|
|
<style>
|
|
.use-motion .brand,
|
|
.use-motion .menu-item,
|
|
.sidebar-inner,
|
|
.use-motion .post-block,
|
|
.use-motion .pagination,
|
|
.use-motion .comments,
|
|
.use-motion .post-header,
|
|
.use-motion .post-body,
|
|
.use-motion .collection-header { opacity: initial; }
|
|
|
|
.use-motion .site-title,
|
|
.use-motion .site-subtitle {
|
|
opacity: initial;
|
|
top: initial;
|
|
}
|
|
|
|
.use-motion .logo-line-before i { left: initial; }
|
|
.use-motion .logo-line-after i { right: initial; }
|
|
</style>
|
|
</noscript>
|
|
|
|
<link rel="alternate" href="/atom.xml" title="Nicksxs's Blog" type="application/atom+xml">
|
|
</head>
|
|
|
|
<body itemscope itemtype="http://schema.org/WebPage">
|
|
<div class="container use-motion">
|
|
<div class="headband"></div>
|
|
|
|
<header class="header" itemscope itemtype="http://schema.org/WPHeader">
|
|
<div class="header-inner"><div class="site-brand-container">
|
|
<div class="site-nav-toggle">
|
|
<div class="toggle" aria-label="Toggle navigation bar">
|
|
<span class="toggle-line toggle-line-first"></span>
|
|
<span class="toggle-line toggle-line-middle"></span>
|
|
<span class="toggle-line toggle-line-last"></span>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="site-meta">
|
|
|
|
<a href="/" class="brand" rel="start">
|
|
<span class="logo-line-before"><i></i></span>
|
|
<h1 class="site-title">Nicksxs's Blog</h1>
|
|
<span class="logo-line-after"><i></i></span>
|
|
</a>
|
|
<p class="site-subtitle" itemprop="description">What hurts more, the pain of hard work or the pain of regret?</p>
|
|
</div>
|
|
|
|
<div class="site-nav-right">
|
|
<div class="toggle popup-trigger">
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
|
|
|
|
|
|
<nav class="site-nav">
|
|
<ul id="menu" class="main-menu menu">
|
|
<li class="menu-item menu-item-home">
|
|
|
|
<a href="/" rel="section"><i class="home fa-fw"></i>Home</a>
|
|
|
|
</li>
|
|
<li class="menu-item menu-item-about">
|
|
|
|
<a href="/about/" rel="section"><i class="about fa-fw"></i>About</a>
|
|
|
|
</li>
|
|
<li class="menu-item menu-item-tags">
|
|
|
|
<a href="/tags/" rel="section"><i class="tags fa-fw"></i>Tags</a>
|
|
|
|
</li>
|
|
<li class="menu-item menu-item-categories">
|
|
|
|
<a href="/categories/" rel="section"><i class="categories fa-fw"></i>Categories</a>
|
|
|
|
</li>
|
|
<li class="menu-item menu-item-archives">
|
|
|
|
<a href="/archives/" rel="section"><i class="archives fa-fw"></i>Archives</a>
|
|
|
|
</li>
|
|
<li class="menu-item menu-item-sitemap">
|
|
|
|
<a href="/sitemap.xml" rel="section"><i class="sitemap fa-fw"></i>Sitemap</a>
|
|
|
|
</li>
|
|
<li class="menu-item menu-item-commonweal">
|
|
|
|
<a href="/404/" rel="section"><i class="heartbeat fa-fw"></i>Commonweal 404</a>
|
|
|
|
</li>
|
|
</ul>
|
|
</nav>
|
|
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
<div class="back-to-top">
|
|
<i class="fa fa-arrow-up"></i>
|
|
<span>0%</span>
|
|
</div>
|
|
|
|
<a href="https://github.com/nicksxs" class="github-corner" title="Follow me on GitHub" aria-label="Follow me on GitHub" rel="noopener" target="_blank"><svg width="80" height="80" viewBox="0 0 250 250" aria-hidden="true"><path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path><path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path><path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a>
|
|
|
|
|
|
<main class="main">
|
|
<div class="main-inner">
|
|
<div class="content-wrap">
|
|
|
|
|
|
<div class="content index posts-expand">
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/05/22/%E8%81%8A%E8%81%8A%E6%88%91%E5%88%9A%E5%AD%A6%E4%BC%9A%E7%9A%84%E5%BA%94%E7%94%A8%E8%AF%8A%E6%96%AD%E6%96%B9%E6%B3%95/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/05/22/%E8%81%8A%E8%81%8A%E6%88%91%E5%88%9A%E5%AD%A6%E4%BC%9A%E7%9A%84%E5%BA%94%E7%94%A8%E8%AF%8A%E6%96%AD%E6%96%B9%E6%B3%95/" class="post-title-link" itemprop="url">聊聊我刚学会的应用诊断方法</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
<time title="Created: 2020-05-22 23:26:50" itemprop="dateCreated datePublished" datetime="2020-05-22T23:26:50+08:00">2020-05-22</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar-check"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Edited on</span>
|
|
<time title="Modified: 2020-05-24 21:51:43" itemprop="dateModified" datetime="2020-05-24T21:51:43+08:00">2020-05-24</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Java/" itemprop="url" rel="index"><span itemprop="name">Java</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Thread-dump/" itemprop="url" rel="index"><span itemprop="name">Thread dump</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/%E9%97%AE%E9%A2%98%E6%8E%92%E6%9F%A5/" itemprop="url" rel="index"><span itemprop="name">问题排查</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/%E5%B7%A5%E5%85%B7/" itemprop="url" rel="index"><span itemprop="name">工具</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/05/22/%E8%81%8A%E8%81%8A%E6%88%91%E5%88%9A%E5%AD%A6%E4%BC%9A%E7%9A%84%E5%BA%94%E7%94%A8%E8%AF%8A%E6%96%AD%E6%96%B9%E6%B3%95/" class="post-meta-item leancloud_visitors" data-flag-title="聊聊我刚学会的应用诊断方法" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/05/22/%E8%81%8A%E8%81%8A%E6%88%91%E5%88%9A%E5%AD%A6%E4%BC%9A%E7%9A%84%E5%BA%94%E7%94%A8%E8%AF%8A%E6%96%AD%E6%96%B9%E6%B3%95/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/05/22/聊聊我刚学会的应用诊断方法/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<p>因为传说中的出身问题，我以前写的是PHP，在使用 swoole 之前，基本的应用调试手段就是简单粗暴的 var_dump，exit，对于单进程模型的 PHP 也是简单有效，技术栈换成 Java 之后，就变得没那么容易，一方面是需要编译，另一方面是一般都是基于 spring 的项目，如果问题定位比较模糊，那框架层的是很难靠简单的 System.out.println 或者打 log 解决，(PS：我觉得可能我写的东西比较适合从 PHP 这种弱类型语言转到 Java 的小白同学)这个时候一方面因为是 Java，有了非常好用的 idea IDE 的支持，可以各种花式调试，条件断点尤其牛叉，但是又因为有 Spring+Java 的双重原因，有些情况下单步调试可以把手按废掉，这也是我之前一直比较困惑苦逼的点，后来随着慢慢精（jiang）进（you）之后，比如对于一个 oom 的情况，我们可以通过启动参数加上-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=xx/xx 来配置溢出时的堆dump 日志，获取到这个文件后，我们可以通过像 Memory Analyzer (MAT)[<a href="https://www.eclipse.org/mat/]" target="_blank" rel="noopener">https://www.eclipse.org/mat/]</a> (The Eclipse Memory Analyzer is a fast and feature-rich Java heap analyzer that helps you find memory leaks and reduce memory consumption.)来查看诊断问题所在，之前用到的时候是因为有个死循环一直往链表里塞数据，属于比较简单的，后来一次是由于运维进行应用迁移时按默认的统一配置了堆内存大小，导致内存的确不够用，所以溢出了，<br>今天想说的其实主要是我们的 thread dump，这也是我最近才真正用的一个方法，可能真的很小白了，用过 ide 的单步调试其实都知道会有一个一层层的玩意，比如函数从 A，调用了 B，再从 B 调用了 C，一直往下(因为是 Java，所以还有很多🤦♂️)，这个其实也是大部分语言的调用模型，利用了栈这个数据结构，通过这个结构我们可以知道代码的调用链路，由于对于一个 spring 应用，在本身框架代码量非常庞大的情况下，外加如果应用代码也是非常多的时候，有时候通过单步调试真的很难短时间定位到问题，需要非常大的耐心和仔细观察，当然不是说完全不行，举个例子当我的应用经常启动需要非常长的时间，因为本身应用有非常多个 bean，比较难说究竟是 bean 的加载的确很慢还是有什么异常原因，这种时候就可以使用 thread dump 了，具体怎么操作呢<br><img data-src="https://mystore-1255223546.cos.ap-chengdu.myqcloud.com/uPic/GPYHjd.png" alt=""><br>如果在idea 中运行或者调试时，可以直接点击这个照相机一样的按钮，右边就会出现了左边会显示所有的线程，右边会显示线程栈，</p>
|
|
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">"main@1" prio=5 tid=0x1 nid=NA runnable</span><br><span class="line"> java.lang.Thread.State: RUNNABLE</span><br><span class="line"> at TreeDistance.treeDist(TreeDistance.java:64)</span><br><span class="line"> at TreeDistance.treeDist(TreeDistance.java:65)</span><br><span class="line"> at TreeDistance.treeDist(TreeDistance.java:65)</span><br><span class="line"> at TreeDistance.treeDist(TreeDistance.java:65)</span><br><span class="line"> at TreeDistance.main(TreeDistance.java:45)</span><br></pre></td></tr></table></figure>
|
|
<p>这就是我们主线程的堆栈信息了，main 表示这个线程名，prio表示优先级，默认是 5，tid 表示线程 id，nid 表示对应的系统线程，后面的runnable 表示目前线程状态，因为是被我打了断点，所以是就许状态，然后下面就是对应的线程栈内容了，在<code>TreeDistance</code>类的 <code>treeDist</code>方法中，对应的文件行数是 64 行。<br>这里使用 thread dump一般也不会是上面我截图代码里的这种代码量很少的，一般是大型项目，有时候跑着跑着没反应，又不知道跑到哪了，特别是一些刚接触的大项目或者需要定位一个大项目的一个疑难问题，一时没思路时，可以使用这个方法，个人觉得非常有帮助。</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/05/17/%E8%81%8A%E8%81%8A%E6%88%91%E7%90%86%E8%A7%A3%E7%9A%84%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/05/17/%E8%81%8A%E8%81%8A%E6%88%91%E7%90%86%E8%A7%A3%E7%9A%84%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1/" class="post-title-link" itemprop="url">聊聊我理解的分布式事务</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
<time title="Created: 2020-05-17 23:56:01" itemprop="dateCreated datePublished" datetime="2020-05-17T23:56:01+08:00">2020-05-17</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar-check"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Edited on</span>
|
|
<time title="Modified: 2020-05-24 22:18:43" itemprop="dateModified" datetime="2020-05-24T22:18:43+08:00">2020-05-24</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1/" itemprop="url" rel="index"><span itemprop="name">分布式事务</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1/%E4%B8%A4%E9%98%B6%E6%AE%B5%E6%8F%90%E4%BA%A4/" itemprop="url" rel="index"><span itemprop="name">两阶段提交</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1/%E4%B8%89%E9%98%B6%E6%AE%B5%E6%8F%90%E4%BA%A4/" itemprop="url" rel="index"><span itemprop="name">三阶段提交</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/05/17/%E8%81%8A%E8%81%8A%E6%88%91%E7%90%86%E8%A7%A3%E7%9A%84%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1/" class="post-meta-item leancloud_visitors" data-flag-title="聊聊我理解的分布式事务" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/05/17/%E8%81%8A%E8%81%8A%E6%88%91%E7%90%86%E8%A7%A3%E7%9A%84%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/05/17/聊聊我理解的分布式事务/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<p>前面说了mysql数据库的事务相关的，那事务是用来干嘛的，这里得补一下ACID，</p>
|
|
<blockquote>
|
|
<p><a href="https://zh.wikipedia.org/wiki/ACID" target="_blank" rel="noopener"><strong>ACID</strong></a>，是指<a href="https://zh.wikipedia.org/wiki/数据库管理系统" target="_blank" rel="noopener">数据库管理系统</a>（<a href="https://zh.wikipedia.org/wiki/DBMS" target="_blank" rel="noopener">DBMS</a>）在写入或更新资料的过程中，为保证<a href="https://zh.wikipedia.org/wiki/数据库事务" target="_blank" rel="noopener">事务</a>（transaction）是正确可靠的，所必须具备的四个特性：<a href="https://zh.wikipedia.org/w/index.php?title=原子性&action=edit&redlink=1" target="_blank" rel="noopener">原子性</a>（atomicity，或称不可分割性）、<a href="https://zh.wikipedia.org/w/index.php?title=一致性_(数据库系统)&action=edit&redlink=1" target="_blank" rel="noopener">一致性</a>（consistency）、<a href="https://zh.wikipedia.org/wiki/隔離性" target="_blank" rel="noopener">隔离性</a>（isolation，又称独立性）、<a href="https://zh.wikipedia.org/w/index.php?title=持久性&action=edit&redlink=1" target="_blank" rel="noopener">持久性</a>（durability）。</p>
|
|
</blockquote>
|
|
<ul>
|
|
<li><p>Atomicity（原子性）：一个事务（transaction）中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被<a href="https://zh.wikipedia.org/wiki/回滚_(数据管理)" target="_blank" rel="noopener">回滚</a>（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。即，事务不可分割、不可约简。<a href="https://zh.wikipedia.org/wiki/ACID#cite_note-acid-1" target="_blank" rel="noopener">[1]</a></p>
|
|
</li>
|
|
<li><p>Consistency（一致性）：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设<a href="https://zh.wikipedia.org/wiki/数据完整性" target="_blank" rel="noopener">约束</a>、<a href="https://zh.wikipedia.org/wiki/触发器_(数据库)" target="_blank" rel="noopener">触发器</a>、<a href="https://zh.wikipedia.org/wiki/级联回滚" target="_blank" rel="noopener">级联回滚</a>等。<a href="https://zh.wikipedia.org/wiki/ACID#cite_note-acid-1" target="_blank" rel="noopener">[1]</a></p>
|
|
</li>
|
|
<li><p>Isolation（隔离性）：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括未提交读（Read uncommitted）、提交读（read committed）、可重复读（repeatable read）和串行化（Serializable）。<a href="https://zh.wikipedia.org/wiki/ACID#cite_note-acid-1" target="_blank" rel="noopener">[1]</a></p>
|
|
</li>
|
|
<li><p>Durability（持久性）：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。<a href="https://zh.wikipedia.org/wiki/ACID#cite_note-acid-1" target="_blank" rel="noopener">[1]</a></p>
|
|
</li>
|
|
</ul>
|
|
<p>在mysql中，借助于MVCC，各种级别的锁，日志等特性来实现了事务的ACID，但是这个我们通常是对于一个数据库服务的定义，常见的情况下我们的数据库随着业务发展也会从单实例变成多实例，组成主从Master-Slave架构，这个时候其实会有一些问题随之出现，比如说主从同步延迟，假如在业务代码中做了读写分离，对于一些敏感度较低的数据其实问题不是很大，只要主从延迟不到特别夸张的地步一般都是可以忍受的，但是对于一些核心的业务数据，比如订单之类的，不能忍受数据不一致，下了单了，付了款了，一刷订单列表，发现这个订单还没支付，甚至订单都没在，这对于用户来讲是恨不能容忍的错误，那么这里就需要一些措施，要不就不读写分离，要不就在 redis 这类缓存下订单，或者支付后加个延时等，这些都是一些补偿措施，并且这也是一个不太切当的例子，比较合适的例子也可以用这个下单来说，一般在电商平台下单会有挺多要做的事情，比如像下面这个图</p>
|
|
<p><img data-src="https://mystore-1255223546.cos.ap-chengdu.myqcloud.com/uPic/WX20200517-2127322x.png" alt=""></p>
|
|
<p>下单的是后要冻结核销优惠券，如果账户里有钱要冻结扣除账户里的钱，如果使用了J 豆也一样，可能还有 E 卡，忽略我借用的平台，因为目前一般后台服务化之后，可能每一项都是对应的一个后台服务，我们期望的执行过程是要不全成功，要不就全保持执行前状态，不能是部分扣减核销成功了，部分还不行，所以我们处理这种情况会引入一些通用的方案，第一种叫<a href="https://zh.wikipedia.org/wiki/%E4%BA%8C%E9%98%B6%E6%AE%B5%E6%8F%90%E4%BA%A4" target="_blank" rel="noopener">二阶段提交</a>,</p>
|
|
<blockquote>
|
|
<p><strong>二阶段提交</strong>（英语：Two-phase Commit）是指在<a href="https://zh.wikipedia.org/wiki/计算机网络" target="_blank" rel="noopener">计算机网络</a>以及<a href="https://zh.wikipedia.org/wiki/数据库" target="_blank" rel="noopener">数据库</a>领域内，为了使基于<a href="https://zh.wikipedia.org/wiki/分布式系统" target="_blank" rel="noopener">分布式系统</a>架构下的所有节点在进行<a href="https://zh.wikipedia.org/wiki/数据库事务" target="_blank" rel="noopener">事务</a>提交时保持一致性而设计的一种<a href="https://zh.wikipedia.org/wiki/演算法" target="_blank" rel="noopener">算法</a>。通常，<strong>二阶段提交</strong>也被称为是一种<strong>协议</strong>（Protocol）。在分布式系统中，每个节点虽然可以知晓自己的操作时成功或者失败，却无法知道其他节点的操作的成功或失败。当一个事务跨越多个节点时，为了保持事务的<a href="https://zh.wikipedia.org/wiki/ACID" target="_blank" rel="noopener">ACID</a>特性，需要引入一个作为<strong>协调者</strong>的组件来统一掌控所有节点（称作<strong>参与者</strong>）的操作结果并最终指示这些节点是否要把操作结果进行真正的提交（比如将更新后的数据写入磁盘等等）。因此，二阶段提交的算法思路可以概括为： 参与者将操作成败通知协调者，再由协调者根据所有参与者的反馈情报决定各参与者是否要提交操作还是中止操作。</p>
|
|
</blockquote>
|
|
<p>对于上面的例子，我们将整个过程分成两个阶段，首先是提交请求阶段，这个阶段大概需要做的是确定资源存在，锁定资源，可能还要做好失败后回滚的准备，如果这些都 ok 了那么就响应成功，这里其实用到了一个叫事务的协调者的角色，类似于裁判员，每个节点都反馈第一阶段成功后，开始执行第二阶段，也就是实际执行操作，这里也是需要所有节点都反馈成功后才是执行成功，要不就是失败回滚。其实常用的分布式事务的解决方案主要也是基于此方案的改进，比如后面介绍的<a href="https://zh.wikipedia.org/wiki/%E4%B8%89%E9%98%B6%E6%AE%B5%E6%8F%90%E4%BA%A4" target="_blank" rel="noopener">三阶段提交</a>，有三阶段提交就是因为二阶段提交比较尴尬的几个点，</p>
|
|
<ul>
|
|
<li>第一是对于两阶段提交，其中默认只有协调者有超时时间，当一个参与者进入卡死状态时只能依赖协调者的超时来结束任务，这中间的时间参与者都是锁定着资源</li>
|
|
<li>第二是协调者的单点问题，万一挂了，参与者就会在那傻等着</li>
|
|
</ul>
|
|
<p>所以三阶段提交引入了各节点的超时机制和一个准备阶段，首先是一个<code>can commit</code>阶段，询问下各个节点有没有资源，能不能进行操作，这个阶段不阻塞，只是提前做个摸底，这个阶段其实人畜无害，但是能提高成功率，在这个阶段如果就有节点反馈是不接受的，那就不用执行下去了，也没有锁资源，然后第二阶段是 <code>pre commit</code> ，这个阶段做的事情跟原来的 第一阶段比较类似，然后是第三阶段<code>do commit</code>，其实三阶段提交我个人觉得只是加了个超时，和准备阶段，好像木有根本性的解决的两阶段提交的问题，后续可以再看看一些论文来思考讨论下。</p>
|
|
<p>2020年05月24日22:11 更新<br>这里跟朋友讨论了下，好像想通了最核心的一点，对于前面说的那个场景，如果是两阶段提交，如果各个节点中有一个没回应，并且协调者也挂了，这个时候会有什么情况呢，再加一个假设，其实比如这个一阶段其实是检验就失败的，理论上应该大家都释放资源，那么对于这种异常情况，其他的参与者就不知所措了，就傻傻地锁着资源阻塞着，那么三阶段提交的意义就出现了，把第一阶段拆开，那么即使在这个阶段出现上述的异常，即也不会锁定资源，同时参与者也有超时机制，在第二阶段锁定资源出现异常是，其他参与者节点等超时后就自动释放资源了，也就没啥问题了，不过对于那种异常恢复后的一些情况还是没有很好地解决，需要借助 zk 等，后面有空可以讲讲 paxos 跟 raft 等</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/05/10/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC-%E7%BB%AD%E7%BB%AD%E7%AF%87%E4%B9%8B%E5%8A%A0%E9%94%81%E5%88%86%E6%9E%90/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/05/10/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC-%E7%BB%AD%E7%BB%AD%E7%AF%87%E4%B9%8B%E5%8A%A0%E9%94%81%E5%88%86%E6%9E%90/" class="post-title-link" itemprop="url">聊聊 mysql 的 MVCC 续续篇之锁分析</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
|
|
<time title="Created: 2020-05-10 09:55:10 / Modified: 22:26:13" itemprop="dateCreated datePublished" datetime="2020-05-10T09:55:10+08:00">2020-05-10</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/" itemprop="url" rel="index"><span itemprop="name">Mysql</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/" itemprop="url" rel="index"><span itemprop="name">C</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/" itemprop="url" rel="index"><span itemprop="name">数据结构</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/%E6%BA%90%E7%A0%81/" itemprop="url" rel="index"><span itemprop="name">源码</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/Mysql/" itemprop="url" rel="index"><span itemprop="name">Mysql</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/05/10/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC-%E7%BB%AD%E7%BB%AD%E7%AF%87%E4%B9%8B%E5%8A%A0%E9%94%81%E5%88%86%E6%9E%90/" class="post-meta-item leancloud_visitors" data-flag-title="聊聊 mysql 的 MVCC 续续篇之锁分析" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/05/10/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC-%E7%BB%AD%E7%BB%AD%E7%AF%87%E4%B9%8B%E5%8A%A0%E9%94%81%E5%88%86%E6%9E%90/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/05/10/聊聊-mysql-的-MVCC-续续篇之加锁分析/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<p>看完前面两篇水文之后，感觉不得不来分析下 mysql 的锁了，其实前面说到幻读的时候是有个前提没提到的，比如一个<code>select * from table1 where id = 1</code>这种查询语句其实是不会加传说中的锁的，当然这里是指在 RR 或者 RC 隔离级别下，<br>看一段 mysql官方文档</p>
|
|
<blockquote>
|
|
<p><code>SELECT ... FROM</code> is a consistent read, reading a snapshot of the database and setting no locks unless the transaction isolation level is set to SERIALIZABLE. For SERIALIZABLE level, the search sets shared next-key locks on the index records it encounters. However, only an index record lock is required for statements that lock rows using a unique index to search for a unique row. </p>
|
|
</blockquote>
|
|
<p>纯粹的这种一致性读，实际读取的是快照，也就是基于 read view 的读取方式，除非当前隔离级别是SERIALIZABLE<br>但是对于以下几类</p>
|
|
<ul>
|
|
<li><code>select * from table where ? lock in share mode;</code></li>
|
|
<li><code>select * from table where ? for update;</code></li>
|
|
<li><code>insert into table values (...);</code></li>
|
|
<li><code>update table set ? where ?;</code></li>
|
|
<li><code>delete from table where ?;</code> </li>
|
|
</ul>
|
|
<p>除了第一条是 S 锁之外，其他都是 X 排他锁，这边在顺带下，S 锁表示共享锁， X 表示独占锁，同为 S 锁之间不冲突，S 与 X，X 与 S，X 与 X 之间都冲突，也就是加了前者，后者就加不上了<br>我们知道对于 RC 级别会出现幻读现象，对于 RR 级别不会出现，主要的区别是 RR 级别下对于以上的加锁读取都根据情况加上了 gap 锁，那么是不是 RR 级别下以上所有的都是要加 gap 锁呢，当然不是<br>举个例子，RR 事务隔离级别下，table1 有个主键id 字段<br><code>select * from table1 where id = 10 for update</code><br>这条语句要加 gap 锁吗？<br>答案是不需要，这里其实算是我看了这么久的一点自己的理解，啥时候要加 gap 锁，判断的条件是根据我查询的数据是否会因为不加 gap 锁而出现数量的不一致，我上面这条查询语句，在什么情况下会出现查询结果数量不一致呢，只要在这条记录被更新或者删除的时候，有没有可能我第一次查出来一条，第二次变成两条了呢，不可能，因为是主键索引。<br>再变更下这个题的条件，当 id 不是主键，但是是唯一索引，这样需要怎么加锁，注意问题是怎么加锁，不是需不需要加 gap 锁，这里呢就是稍微延伸一下，把聚簇索引（主键索引）和二级索引带一下，当 id 不是主键，说明是个二级索引，但是它是唯一索引，体会下，首先对于 id = 10这个二级索引肯定要加锁，要不要锁 gap 呢，不用，因为是唯一索引，id = 10 只可能有这一条记录，然后呢，这样是不是就好了，还不行，因为啥，因为它是二级索引，对应的主键索引的记录才是真正的数据，万一被更新掉了咋办，所以在 id = 10 对应的主键索引上也需要加上锁（默认都是 record lock行锁），那主键索引上要不要加 gap 呢，也不用，也是精确定位到这一条记录<br>最后呢，当 id 不是主键，也不是唯一索引，只是个普通的索引，这里就需要大名鼎鼎的 gap 锁了，<br>是时候画个图了<br><img data-src="https://mystore-1255223546.cos.ap-chengdu.myqcloud.com/uPic/WX20200510-1126082x.png" alt=""><br>其实核心的目的还是不让这个 id=10 的记录不会出现幻读，那么就需要在 id 这个索引上加上三个 gap 锁，主键索引上就不用了，在 id 索引上已经控制住了id = 10 不会出现幻读，主键索引上这两条对应的记录已经锁了，所以就这样 OK 了</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/05/02/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC-%E7%BB%AD%E7%AF%87/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/05/02/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC-%E7%BB%AD%E7%AF%87/" class="post-title-link" itemprop="url">聊聊 mysql 的 MVCC 续篇</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
<time title="Created: 2020-05-02 14:46:35" itemprop="dateCreated datePublished" datetime="2020-05-02T14:46:35+08:00">2020-05-02</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar-check"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Edited on</span>
|
|
<time title="Modified: 2020-05-03 22:26:29" itemprop="dateModified" datetime="2020-05-03T22:26:29+08:00">2020-05-03</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/" itemprop="url" rel="index"><span itemprop="name">Mysql</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/" itemprop="url" rel="index"><span itemprop="name">C</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/" itemprop="url" rel="index"><span itemprop="name">数据结构</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/%E6%BA%90%E7%A0%81/" itemprop="url" rel="index"><span itemprop="name">源码</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/Mysql/" itemprop="url" rel="index"><span itemprop="name">Mysql</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/05/02/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC-%E7%BB%AD%E7%AF%87/" class="post-meta-item leancloud_visitors" data-flag-title="聊聊 mysql 的 MVCC 续篇" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/05/02/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC-%E7%BB%AD%E7%AF%87/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/05/02/聊聊-mysql-的-MVCC-续篇/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<p>上一篇聊了mysql 的 innodb 引擎基于 read view 实现的 mvcc 和事务隔离级别，可能有些细心的小伙伴会发现一些问题，第一个是在 RC 级别下的事务提交后的可见性，这里涉及到了三个参数，m_low_limit_id，m_up_limit_id，m_ids，之前看到知乎的一篇写的非常不错的文章，但是就在这一点上似乎有点疑惑，这里基于源码和注释来解释下这个问题</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/**</span></span><br><span class="line"><span class="comment">Opens a read view where exactly the transactions serialized before this</span></span><br><span class="line"><span class="comment">point in time are seen in the view.</span></span><br><span class="line"><span class="comment">@param id Creator transaction id */</span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">ReadView::prepare</span><span class="params">(<span class="keyword">trx_id_t</span> id)</span> </span>{</span><br><span class="line"> ut_ad(mutex_own(&trx_sys->mutex));</span><br><span class="line"></span><br><span class="line"> m_creator_trx_id = id;</span><br><span class="line"></span><br><span class="line"> m_low_limit_no = m_low_limit_id = m_up_limit_id = trx_sys->max_trx_id;</span><br></pre></td></tr></table></figure>
|
|
<p>m_low_limit_id赋的值是trx_sys->max_trx_id，代表的是当前系统最小的未分配的事务 id，所以呢，举个例子，当前有三个活跃事务，事务 id 分别是 100，200，300，而 m_up_limit_id = 100, m_low_limit_id = 301，当事务 id 是 200 的提交之后，它的更新就是可以被 100 和 300 看到，而不是说 m_ids 里没了 200，并且 200 比 100 大就应该不可见了</p>
|
|
<h2 id="幻读"><a href="#幻读" class="headerlink" title="幻读"></a>幻读</h2><p>还有一个问题是幻读的问题，这貌似也是个高频面试题，啥意思呢，或者说跟它最常拿来比较的脏读，脏读是指读到了别的事务未提交的数据，因为未提交，严格意义上来讲，不一定是会被最后落到库里，可能会回滚，也就是在 read uncommitted 级别下会出现的问题，但是幻读不太一样，幻读是指两次查询的结果数量不一样，比如我查了第一次是 <code>select * from table1 where id < 10 for update</code>,查出来了一条结果 id 是 5，然后再查一下发现出来了一条 id 是 5，一条 id 是 7，那是不是有点尴尬了，其实呢这个点我觉得脏读跟幻读也比较是从原理层面来命名，如果第一次接触的同学发觉有点不理解也比较正常，因为从逻辑上讲总之都是数据不符合预期，但是基于源码层面其实是不同的情况，幻读是在原先的 read view 无法完全解决的，怎么解决呢，简单的来说就是锁咯，我们知道innodb 是基于 record lock 行锁的，但是貌似没有办法解决这种问题，那么 innodb 就引入了 gap lock 间隙锁，比如上面说的情况下，id 小于 10 的情况下，是都应该锁住的，gap lock 其实是基于索引结构来锁的，因为索引树除了树形结构之外，还有一个next record 的指针，gap lock 也是基于这个来锁的<br>看一下 mysql 的文档</p>
|
|
<blockquote>
|
|
<p>SELECT … FOR UPDATE sets an exclusive next-key lock on every record the search encounters. However, only an index record lock is required for statements that lock rows using a unique index to search for a unique row. </p>
|
|
</blockquote>
|
|
<p>对于一个 for update 查询，在 RR 级别下，会设置一个 next-key lock在每一条被查询到的记录上，next-lock 又是啥呢，其实就是 gap 锁和 record 锁的结合体，比如我在数据库里有 id 是 1，3，5，7，10，对于上面那条查询，查出来的结果就是 1，3，5，7，那么按照文档里描述的，对于这几条记录都会加上next-key lock，也就是(-∞, 1], (1, 3], (3, 5], (5, 7], (7, 10) 这些区间和记录会被锁起来，不让插入，再唠叨一下呢，就是其实如果是只读的事务，光 read view 一致性读就够了，如果是有写操作的呢，就需要锁了。</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/04/26/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/04/26/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC/" class="post-title-link" itemprop="url">聊聊 mysql 的 MVCC</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
<time title="Created: 2020-04-26 22:14:01" itemprop="dateCreated datePublished" datetime="2020-04-26T22:14:01+08:00">2020-04-26</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar-check"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Edited on</span>
|
|
<time title="Modified: 2020-05-02 19:46:21" itemprop="dateModified" datetime="2020-05-02T19:46:21+08:00">2020-05-02</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/" itemprop="url" rel="index"><span itemprop="name">Mysql</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/" itemprop="url" rel="index"><span itemprop="name">C</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/" itemprop="url" rel="index"><span itemprop="name">数据结构</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Mysql/%E6%BA%90%E7%A0%81/" itemprop="url" rel="index"><span itemprop="name">源码</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/Mysql/" itemprop="url" rel="index"><span itemprop="name">Mysql</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/04/26/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC/" class="post-meta-item leancloud_visitors" data-flag-title="聊聊 mysql 的 MVCC" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/04/26/%E8%81%8A%E8%81%8A-mysql-%E7%9A%84-MVCC/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/04/26/聊聊-mysql-的-MVCC/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<p>很久以前，有位面试官问到，你知道 mysql 的事务隔离级别吗，“额 O__O …，不太清楚”，完了之后我就去网上找相关的文章，找到了这篇<a href="https://www.cnblogs.com/zhoujinyi/p/3437475.html" target="_blank" rel="noopener">MySQL 四种事务隔离级的说明</a>, 文章写得特别好，看了这个就懂了各个事务隔离级别都是啥，不过看了这个之后多思考一下的话还是会发现问题，这么神奇的事务隔离级别是怎么实现的呢</p>
|
|
<p>其中 innodb 的事务隔离用到了标题里说到的 mvcc，<a href="https://en.wikipedia.org/wiki/Multiversion_concurrency_control" target="_blank" rel="noopener"><strong>Multiversion concurrency control</strong></a>, 直译过来就是多版本并发控制，先不讲这个究竟是个啥，考虑下如果纯猜测，这个事务隔离级别应该会是怎么样实现呢，愚钝的我想了下，可以在事务开始的时候拷贝一个表，这个可以支持 RR 级别，RC 级别就不支持了，而且要是个非常大的表，想想就不可行</p>
|
|
<p>腆着脸说虽然这个不可行，但是思路是对的，具体实行起来需要做一系列（肥肠多）的改动，首先根据我的理解，其实这个拷贝一个表是变成拷贝一条记录，但是如果有多个事务，那就得拷贝多次，这个问题其实可以借助版本管理系统来解释，在用版本管理系统，git 之类的之前，很原始的可能是开发完一个功能后，就打个压缩包用时间等信息命名，然后如果后面要找回这个就直接用这个压缩包的就行了，后来有了 svn，git 中心式和分布式的版本管理系统，它的一个特点是粒度可以控制到文件和代码行级别，对应的我们的 mysql 事务是不是也可以从一开始预想的表级别细化到行的级别，可能之前很多人都了解过，数据库的一行记录除了我们用户自定义的字段，还有一些额外的字段，去源码<a href="https://github.com/mysql/mysql-server/blob/8.0/storage/innobase/include/data0type.h#L170" target="_blank" rel="noopener">data0type.h</a>里捞一下</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Precise data types for system columns and the length of those columns;</span></span><br><span class="line"><span class="comment"><span class="doctag">NOTE:</span> the values must run from 0 up in the order given! All codes must</span></span><br><span class="line"><span class="comment">be less than 256 */</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> DATA_ROW_ID 0 <span class="comment">/* row id: a 48-bit integer */</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> DATA_ROW_ID_LEN 6 <span class="comment">/* stored length for row id */</span></span></span><br><span class="line"></span><br><span class="line"><span class="comment">/** Transaction id: 6 bytes */</span></span><br><span class="line"><span class="keyword">constexpr</span> <span class="keyword">size_t</span> DATA_TRX_ID = <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line"><span class="comment">/** Transaction ID type size in bytes. */</span></span><br><span class="line"><span class="keyword">constexpr</span> <span class="keyword">size_t</span> DATA_TRX_ID_LEN = <span class="number">6</span>;</span><br><span class="line"></span><br><span class="line"><span class="comment">/** Rollback data pointer: 7 bytes */</span></span><br><span class="line"><span class="keyword">constexpr</span> <span class="keyword">size_t</span> DATA_ROLL_PTR = <span class="number">2</span>;</span><br><span class="line"></span><br><span class="line"><span class="comment">/** Rollback data pointer type size in bytes. */</span></span><br><span class="line"><span class="keyword">constexpr</span> <span class="keyword">size_t</span> DATA_ROLL_PTR_LEN = <span class="number">7</span>;</span><br></pre></td></tr></table></figure>
|
|
|
|
<p>一个是 <code>DATA_ROW_ID</code>，这个是在数据没指定主键的时候会生成一个隐藏的，如果用户有指定主键就是主键了</p>
|
|
<p>一个是 <code>DATA_TRX_ID</code>，这个表示这条记录的事务 ID</p>
|
|
<p>还有一个是 <code>DATA_ROLL_PTR</code> 指向回滚段的指针</p>
|
|
<p>指向的回滚段其实就是我们常说的 undo log，这里面的具体结构就是个链表，在 mvcc 里会使用到这个，还有就是这个 <code>DATA_TRX_ID</code>，每条记录都记录了这个事务 ID，表示的是这条记录的当前值是被哪个事务修改的，下面就扯回事务了，我们知道 <code>Read Uncommitted</code>， 其实用不到隔离，直接读取当前值就好了，到了 <code>Read Committed</code> 级别，我们要让事务读取到提交过的值，mysql 使用了一个叫 <code>read view</code> 的玩意，它里面有这些值是我们需要注意的，</p>
|
|
<p><code>m_low_limit_id</code>, 这个是 read view 创建时最大的活跃事务 id</p>
|
|
<p><code>m_up_limit_id</code>, 这个是 read view 创建时最小的活跃事务 id</p>
|
|
<p><code>m_ids</code>, 这个是 read view 创建时所有的活跃事务 id 数组</p>
|
|
<p><code>m_creator_trx_id 这个是当前记录的创建事务 id</code></p>
|
|
<p>判断事务的可见性主要的逻辑是这样，</p>
|
|
<ol>
|
|
<li>当记录的事务 <code>id</code> 小于最小活跃事务 id，说明是可见的，</li>
|
|
<li>如果记录的事务 <code>id</code> 等于当前事务 id，说明是自己的更改，可见</li>
|
|
<li>如果记录的事务 <code>id</code> 大于最大的活跃事务 <code>id</code>, 不可见</li>
|
|
<li>如果记录的事务 <code>id</code> 介于 <code>m_low_limit_id</code> 和 <code>m_up_limit_id</code> 之间，则要判断它是否在 <code>m_ids</code> 中，如果在，不可见，如果不在，表示已提交，可见<br>具体的<a href="https://github.com/mysql/mysql-server/blob/8.0/storage/innobase/include/read0types.h#L160" target="_blank" rel="noopener">代码</a>捞一下看看<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/** Check whether the changes by id are visible.</span></span><br><span class="line"><span class="comment"> @param[in] id transaction id to check against the view</span></span><br><span class="line"><span class="comment"> @param[in] name table name</span></span><br><span class="line"><span class="comment"> @return whether the view sees the modifications of id. */</span></span><br><span class="line"> <span class="function"><span class="keyword">bool</span> <span class="title">changes_visible</span><span class="params">(<span class="keyword">trx_id_t</span> id, <span class="keyword">const</span> <span class="keyword">table_name_t</span> &name)</span> <span class="keyword">const</span></span></span><br><span class="line"><span class="function"> <span class="title">MY_ATTRIBUTE</span><span class="params">((warn_unused_result))</span> </span>{</span><br><span class="line"> ut_ad(id > <span class="number">0</span>);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (id < m_up_limit_id || id == m_creator_trx_id) {</span><br><span class="line"> <span class="keyword">return</span> (<span class="literal">true</span>);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> check_trx_id_sanity(id, name);</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (id >= m_low_limit_id) {</span><br><span class="line"> <span class="keyword">return</span> (<span class="literal">false</span>);</span><br><span class="line"></span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (m_ids.empty()) {</span><br><span class="line"> <span class="keyword">return</span> (<span class="literal">true</span>);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="keyword">const</span> <span class="keyword">ids_t</span>::value_type *p = m_ids.data();</span><br><span class="line"></span><br><span class="line"> <span class="keyword">return</span> (!<span class="built_in">std</span>::binary_search(p, p + m_ids.<span class="built_in">size</span>(), id));</span><br><span class="line"> }</span><br></pre></td></tr></table></figure>
|
|
剩下来一点是啥呢，就是 <code>Read Committed</code> 和 <code>Repeated Read</code> 也不一样，那前面说的 <code>read view</code> 都能支持吗，又是怎么支持呢，假如这个 <code>read view</code> 是在事务一开始就创建，那好像能支持的只是 RR 事务隔离级别，其实呢，这是通过创建 <code>read view</code>的时机，对于 RR 级别，就是在事务的第一个 <code>select</code> 语句是创建，对于 RC 级别，是在每个 <code>select</code> 语句执行前都是创建一次，那样就可以保证能读到所有已提交的数据</li>
|
|
</ol>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/04/18/redis%E7%B3%BB%E5%88%97%E4%BB%8B%E7%BB%8D%E5%85%AB/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/04/18/redis%E7%B3%BB%E5%88%97%E4%BB%8B%E7%BB%8D%E5%85%AB/" class="post-title-link" itemprop="url">redis系列介绍八-淘汰策略</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
<time title="Created: 2020-04-18 23:23:41" itemprop="dateCreated datePublished" datetime="2020-04-18T23:23:41+08:00">2020-04-18</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar-check"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Edited on</span>
|
|
<time title="Modified: 2020-04-19 17:28:42" itemprop="dateModified" datetime="2020-04-19T17:28:42+08:00">2020-04-19</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Redis/" itemprop="url" rel="index"><span itemprop="name">Redis</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Redis/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/" itemprop="url" rel="index"><span itemprop="name">数据结构</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Redis/%E6%BA%90%E7%A0%81/" itemprop="url" rel="index"><span itemprop="name">源码</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/" itemprop="url" rel="index"><span itemprop="name">C</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/Redis/" itemprop="url" rel="index"><span itemprop="name">Redis</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/04/18/redis%E7%B3%BB%E5%88%97%E4%BB%8B%E7%BB%8D%E5%85%AB/" class="post-meta-item leancloud_visitors" data-flag-title="redis系列介绍八-淘汰策略" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/04/18/redis%E7%B3%BB%E5%88%97%E4%BB%8B%E7%BB%8D%E5%85%AB/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/04/18/redis系列介绍八/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<h3 id="LRU"><a href="#LRU" class="headerlink" title="LRU"></a>LRU</h3><p>说完了过期策略再说下淘汰策略，redis 使用的策略是近似的 lru 策略，为什么是近似的呢，先来看下什么是 lru，看下 wiki 的介绍<br><img data-src="https://i.loli.net/2020/04/14/wWyhc2dQfb4BYsK.png" alt="">，图中一共有四个槽的存储空间，依次访问顺序是 A B C D E D F，<br>当第一次访问 D 时刚好占满了坑，并且值是 4，这个值越小代表越先被淘汰，当 E 进来时，看了下已经存在的四个里 A 是最小的，代表是最早存在并且最早被访问的，那就先淘汰它了，E 占领了 A 的位置，并设置值为 4，然后又访问 D 了，D 已经存在了，不过又被访问到了，得更新值为 5，然后是 F 进来了，这时 B 是最老的且最近未被访问，所以就淘汰它了。以上是一个 lru 的简要说明，但是 redis 没有严格按照这个去执行，理由跟前面过期策略一致，最严格的过期策略应该是每个 key 都有对应的定时器，当超时时马上就能清除，但是问题是这样的cpu 消耗太大，所换来的内存效率不太值得，淘汰策略也是这样，类似于上图，要维护所有 key 的一个有序 lru 值，并且遍历将最小的淘汰，redis 采用的是抽样的形式，最初的实现方式是随机从 dict 抽取 5 个 key，淘汰一个 lru 最小的，这样子勉强能达到淘汰的目的，但是效果不是特别好，后面在 redis 3.0开始，将随机抽取改成了维护一个 pool，pool 的大小默认是 16，每次放入的都是按lru 值有序排列好，每一次放入的必须是 lru小于 pool 中最小的 lru 才允许放入，直到放满，后面再有新的就会将大的踢出。<br>redis 针对这个策略的改进做了一个实验，这里借用下图<br><img data-src="https://i.loli.net/2020/04/18/QwcROpB345ezEkX.png" alt=""><br>首先背景是这图中的所有点都对应一个 redis 的 key，灰色部分加入后被顺序访问过一遍，然后又加入了绿色部分，那么按照理论的 lru 算法，应该是图左上中，浅灰色部分全都被淘汰，那么对比来看看图右上，左下和右下，左下表示 2.8 版本就是随机抽样 5 个 key，淘汰其中 lru 最小的一个，发现是灰色和浅灰色的都有被淘汰的，右下的 3.0 版本抽样数量不变的情况下，稍好一些，当 3.0 版本的抽样数量调整成 10 后，已经较为接近理论上的 lru 策略了，通过代码来简要分析下</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span> <span class="title">redisObject</span> {</span></span><br><span class="line"> <span class="keyword">unsigned</span> type:<span class="number">4</span>;</span><br><span class="line"> <span class="keyword">unsigned</span> encoding:<span class="number">4</span>;</span><br><span class="line"> <span class="keyword">unsigned</span> lru:LRU_BITS; <span class="comment">/* LRU time (relative to global lru_clock) or</span></span><br><span class="line"><span class="comment"> * LFU data (least significant 8 bits frequency</span></span><br><span class="line"><span class="comment"> * and most significant 16 bits access time). */</span></span><br><span class="line"> <span class="keyword">int</span> refcount;</span><br><span class="line"> <span class="keyword">void</span> *ptr;</span><br><span class="line">} robj;</span><br></pre></td></tr></table></figure>
|
|
<p>对于 lru 策略来说，lru 字段记录的就是<a href="https://github.com/antirez/redis/blob/unstable/src/server.h#L603" target="_blank" rel="noopener"><code>redisObj</code></a> 的LRU time，<br>redis 在访问数据时，都会调用<a href="https://github.com/antirez/redis/blob/unstable/src/db.c#L55" target="_blank" rel="noopener"><code>lookupKey</code></a>方法</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Low level key lookup API, not actually called directly from commands</span></span><br><span class="line"><span class="comment"> * implementations that should instead rely on lookupKeyRead(),</span></span><br><span class="line"><span class="comment"> * lookupKeyWrite() and lookupKeyReadWithFlags(). */</span></span><br><span class="line"><span class="function">robj *<span class="title">lookupKey</span><span class="params">(redisDb *db, robj *key, <span class="keyword">int</span> flags)</span> </span>{</span><br><span class="line"> dictEntry *de = dictFind(db->dict,key->ptr);</span><br><span class="line"> <span class="keyword">if</span> (de) {</span><br><span class="line"> robj *val = dictGetVal(de);</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Update the access time for the ageing algorithm.</span></span><br><span class="line"><span class="comment"> * Don't do it if we have a saving child, as this will trigger</span></span><br><span class="line"><span class="comment"> * a copy on write madness. */</span></span><br><span class="line"> <span class="keyword">if</span> (!hasActiveChildProcess() && !(flags & LOOKUP_NOTOUCH)){</span><br><span class="line"> <span class="keyword">if</span> (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {</span><br><span class="line"> <span class="comment">// 这个是后面一节的内容</span></span><br><span class="line"> updateLFU(val);</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="comment">// 对于这个分支，访问时就会去更新 lru 值</span></span><br><span class="line"> val->lru = LRU_CLOCK();</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> val;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">return</span> <span class="literal">NULL</span>;</span><br><span class="line"> }</span><br><span class="line">}</span><br><span class="line"><span class="comment">/* This function is used to obtain the current LRU clock.</span></span><br><span class="line"><span class="comment"> * If the current resolution is lower than the frequency we refresh the</span></span><br><span class="line"><span class="comment"> * LRU clock (as it should be in production servers) we return the</span></span><br><span class="line"><span class="comment"> * precomputed value, otherwise we need to resort to a system call. */</span></span><br><span class="line"><span class="function"><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="title">LRU_CLOCK</span><span class="params">(<span class="keyword">void</span>)</span> </span>{</span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">int</span> lruclock;</span><br><span class="line"> <span class="keyword">if</span> (<span class="number">1000</span>/server.hz <= LRU_CLOCK_RESOLUTION) {</span><br><span class="line"> <span class="comment">// 如果服务器的频率server.hz大于 1 时就是用系统预设的 lruclock</span></span><br><span class="line"> lruclock = server.lruclock;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> lruclock = getLRUClock();</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> lruclock;</span><br><span class="line">}</span><br><span class="line"><span class="comment">/* Return the LRU clock, based on the clock resolution. This is a time</span></span><br><span class="line"><span class="comment"> * in a reduced-bits format that can be used to set and check the</span></span><br><span class="line"><span class="comment"> * object->lru field of redisObject structures. */</span></span><br><span class="line"><span class="function"><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="title">getLRUClock</span><span class="params">(<span class="keyword">void</span>)</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> (mstime()/LRU_CLOCK_RESOLUTION) & LRU_CLOCK_MAX;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>redis 处理命令是在这里<a href="https://github.com/antirez/redis/blob/unstable/src/server.c#L3355" target="_blank" rel="noopener"><code>processCommand</code></a></p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* If this function gets called we already read a whole</span></span><br><span class="line"><span class="comment"> * command, arguments are in the client argv/argc fields.</span></span><br><span class="line"><span class="comment"> * processCommand() execute the command or prepare the</span></span><br><span class="line"><span class="comment"> * server for a bulk read from the client.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * If C_OK is returned the client is still alive and valid and</span></span><br><span class="line"><span class="comment"> * other operations can be performed by the caller. Otherwise</span></span><br><span class="line"><span class="comment"> * if C_ERR is returned the client was destroyed (i.e. after QUIT). */</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">processCommand</span><span class="params">(client *c)</span> </span>{</span><br><span class="line"> moduleCallCommandFilters(c);</span><br><span class="line"></span><br><span class="line"> </span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Handle the maxmemory directive.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * Note that we do not want to reclaim memory if we are here re-entering</span></span><br><span class="line"><span class="comment"> * the event loop since there is a busy Lua script running in timeout</span></span><br><span class="line"><span class="comment"> * condition, to avoid mixing the propagation of scripts with the</span></span><br><span class="line"><span class="comment"> * propagation of DELs due to eviction. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.maxmemory && !server.lua_timedout) {</span><br><span class="line"> <span class="keyword">int</span> out_of_memory = freeMemoryIfNeededAndSafe() == C_ERR;</span><br><span class="line"> <span class="comment">/* freeMemoryIfNeeded may flush slave output buffers. This may result</span></span><br><span class="line"><span class="comment"> * into a slave, that may be the active client, to be freed. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.current_client == <span class="literal">NULL</span>) <span class="keyword">return</span> C_ERR;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* It was impossible to free enough memory, and the command the client</span></span><br><span class="line"><span class="comment"> * is trying to execute is denied during OOM conditions or the client</span></span><br><span class="line"><span class="comment"> * is in MULTI/EXEC context? Error. */</span></span><br><span class="line"> <span class="keyword">if</span> (out_of_memory &&</span><br><span class="line"> (c->cmd->flags & CMD_DENYOOM ||</span><br><span class="line"> (c->flags & CLIENT_MULTI &&</span><br><span class="line"> c->cmd->proc != execCommand &&</span><br><span class="line"> c->cmd->proc != discardCommand)))</span><br><span class="line"> {</span><br><span class="line"> flagTransaction(c);</span><br><span class="line"> addReply(c, shared.oomerr);</span><br><span class="line"> <span class="keyword">return</span> C_OK;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>这里只摘了部分，当需要清理内存时就会调用, 然后调用了<a href="https://github.com/antirez/redis/blob/unstable/src/evict.c#L631" target="_blank" rel="noopener"><code>freeMemoryIfNeededAndSafe</code></a></p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br><span class="line">89</span><br><span class="line">90</span><br><span class="line">91</span><br><span class="line">92</span><br><span class="line">93</span><br><span class="line">94</span><br><span class="line">95</span><br><span class="line">96</span><br><span class="line">97</span><br><span class="line">98</span><br><span class="line">99</span><br><span class="line">100</span><br><span class="line">101</span><br><span class="line">102</span><br><span class="line">103</span><br><span class="line">104</span><br><span class="line">105</span><br><span class="line">106</span><br><span class="line">107</span><br><span class="line">108</span><br><span class="line">109</span><br><span class="line">110</span><br><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* This is a wrapper for freeMemoryIfNeeded() that only really calls the</span></span><br><span class="line"><span class="comment"> * function if right now there are the conditions to do so safely:</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * - There must be no script in timeout condition.</span></span><br><span class="line"><span class="comment"> * - Nor we are loading data right now.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> */</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">freeMemoryIfNeededAndSafe</span><span class="params">(<span class="keyword">void</span>)</span> </span>{</span><br><span class="line"> <span class="keyword">if</span> (server.lua_timedout || server.loading) <span class="keyword">return</span> C_OK;</span><br><span class="line"> <span class="keyword">return</span> freeMemoryIfNeeded();</span><br><span class="line">}</span><br><span class="line"><span class="comment">/* This function is periodically called to see if there is memory to free</span></span><br><span class="line"><span class="comment"> * according to the current "maxmemory" settings. In case we are over the</span></span><br><span class="line"><span class="comment"> * memory limit, the function will try to free some memory to return back</span></span><br><span class="line"><span class="comment"> * under the limit.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * The function returns C_OK if we are under the memory limit or if we</span></span><br><span class="line"><span class="comment"> * were over the limit, but the attempt to free memory was successful.</span></span><br><span class="line"><span class="comment"> * Otehrwise if we are over the memory limit, but not enough memory</span></span><br><span class="line"><span class="comment"> * was freed to return back under the limit, the function returns C_ERR. */</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">freeMemoryIfNeeded</span><span class="params">(<span class="keyword">void</span>)</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> keys_freed = <span class="number">0</span>;</span><br><span class="line"> <span class="comment">/* By default replicas should ignore maxmemory</span></span><br><span class="line"><span class="comment"> * and just be masters exact copies. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.masterhost && server.repl_slave_ignore_maxmemory) <span class="keyword">return</span> C_OK;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">size_t</span> mem_reported, mem_tofree, mem_freed;</span><br><span class="line"> <span class="keyword">mstime_t</span> latency, eviction_latency;</span><br><span class="line"> <span class="keyword">long</span> <span class="keyword">long</span> delta;</span><br><span class="line"> <span class="keyword">int</span> slaves = listLength(server.slaves);</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* When clients are paused the dataset should be static not just from the</span></span><br><span class="line"><span class="comment"> * POV of clients not being able to write, but also from the POV of</span></span><br><span class="line"><span class="comment"> * expires and evictions of keys not being performed. */</span></span><br><span class="line"> <span class="keyword">if</span> (clientsArePaused()) <span class="keyword">return</span> C_OK;</span><br><span class="line"> <span class="keyword">if</span> (getMaxmemoryState(&mem_reported,<span class="literal">NULL</span>,&mem_tofree,<span class="literal">NULL</span>) == C_OK)</span><br><span class="line"> <span class="keyword">return</span> C_OK;</span><br><span class="line"></span><br><span class="line"> mem_freed = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (server.maxmemory_policy == MAXMEMORY_NO_EVICTION)</span><br><span class="line"> <span class="keyword">goto</span> cant_free; <span class="comment">/* We need to free memory, but policy forbids. */</span></span><br><span class="line"></span><br><span class="line"> latencyStartMonitor(latency);</span><br><span class="line"> <span class="keyword">while</span> (mem_freed < mem_tofree) {</span><br><span class="line"> <span class="keyword">int</span> j, k, i;</span><br><span class="line"> <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> next_db = <span class="number">0</span>;</span><br><span class="line"> sds bestkey = <span class="literal">NULL</span>;</span><br><span class="line"> <span class="keyword">int</span> bestdbid;</span><br><span class="line"> redisDb *db;</span><br><span class="line"> dict *dict;</span><br><span class="line"> dictEntry *de;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (server.maxmemory_policy & (MAXMEMORY_FLAG_LRU|MAXMEMORY_FLAG_LFU) ||</span><br><span class="line"> server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL)</span><br><span class="line"> {</span><br><span class="line"> <span class="class"><span class="keyword">struct</span> <span class="title">evictionPoolEntry</span> *<span class="title">pool</span> = <span class="title">EvictionPoolLRU</span>;</span></span><br><span class="line"></span><br><span class="line"> <span class="keyword">while</span>(bestkey == <span class="literal">NULL</span>) {</span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> total_keys = <span class="number">0</span>, keys;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* We don't want to make local-db choices when expiring keys,</span></span><br><span class="line"><span class="comment"> * so to start populate the eviction pool sampling keys from</span></span><br><span class="line"><span class="comment"> * every DB. */</span></span><br><span class="line"> <span class="keyword">for</span> (i = <span class="number">0</span>; i < server.dbnum; i++) {</span><br><span class="line"> db = server.db+i;</span><br><span class="line"> dict = (server.maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS) ?</span><br><span class="line"> db->dict : db->expires;</span><br><span class="line"> <span class="keyword">if</span> ((keys = dictSize(dict)) != <span class="number">0</span>) {</span><br><span class="line"> evictionPoolPopulate(i, dict, db->dict, pool);</span><br><span class="line"> total_keys += keys;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span> (!total_keys) <span class="keyword">break</span>; <span class="comment">/* No keys to evict. */</span></span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Go backward from best to worst element to evict. */</span></span><br><span class="line"> <span class="keyword">for</span> (k = EVPOOL_SIZE<span class="number">-1</span>; k >= <span class="number">0</span>; k--) {</span><br><span class="line"> <span class="keyword">if</span> (pool[k].key == <span class="literal">NULL</span>) <span class="keyword">continue</span>;</span><br><span class="line"> bestdbid = pool[k].dbid;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (server.maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS) {</span><br><span class="line"> de = dictFind(server.db[pool[k].dbid].dict,</span><br><span class="line"> pool[k].key);</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> de = dictFind(server.db[pool[k].dbid].expires,</span><br><span class="line"> pool[k].key);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Remove the entry from the pool. */</span></span><br><span class="line"> <span class="keyword">if</span> (pool[k].key != pool[k].cached)</span><br><span class="line"> sdsfree(pool[k].key);</span><br><span class="line"> pool[k].key = <span class="literal">NULL</span>;</span><br><span class="line"> pool[k].idle = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* If the key exists, is our pick. Otherwise it is</span></span><br><span class="line"><span class="comment"> * a ghost and we need to try the next element. */</span></span><br><span class="line"> <span class="keyword">if</span> (de) {</span><br><span class="line"> bestkey = dictGetKey(de);</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="comment">/* Ghost... Iterate again. */</span></span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* volatile-random and allkeys-random policy */</span></span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (server.maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM ||</span><br><span class="line"> server.maxmemory_policy == MAXMEMORY_VOLATILE_RANDOM)</span><br><span class="line"> {</span><br><span class="line"> <span class="comment">/* When evicting a random key, we try to evict a key for</span></span><br><span class="line"><span class="comment"> * each DB, so we use the static 'next_db' variable to</span></span><br><span class="line"><span class="comment"> * incrementally visit all DBs. */</span></span><br><span class="line"> <span class="keyword">for</span> (i = <span class="number">0</span>; i < server.dbnum; i++) {</span><br><span class="line"> j = (++next_db) % server.dbnum;</span><br><span class="line"> db = server.db+j;</span><br><span class="line"> dict = (server.maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM) ?</span><br><span class="line"> db->dict : db->expires;</span><br><span class="line"> <span class="keyword">if</span> (dictSize(dict) != <span class="number">0</span>) {</span><br><span class="line"> de = dictGetRandomKey(dict);</span><br><span class="line"> bestkey = dictGetKey(de);</span><br><span class="line"> bestdbid = j;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Finally remove the selected key. */</span></span><br><span class="line"> <span class="keyword">if</span> (bestkey) {</span><br><span class="line"> db = server.db+bestdbid;</span><br><span class="line"> robj *keyobj = createStringObject(bestkey,sdslen(bestkey));</span><br><span class="line"> propagateExpire(db,keyobj,server.lazyfree_lazy_eviction);</span><br><span class="line"> <span class="comment">/* We compute the amount of memory freed by db*Delete() alone.</span></span><br><span class="line"><span class="comment"> * It is possible that actually the memory needed to propagate</span></span><br><span class="line"><span class="comment"> * the DEL in AOF and replication link is greater than the one</span></span><br><span class="line"><span class="comment"> * we are freeing removing the key, but we can't account for</span></span><br><span class="line"><span class="comment"> * that otherwise we would never exit the loop.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * AOF and Output buffer memory will be freed eventually so</span></span><br><span class="line"><span class="comment"> * we only care about memory used by the key space. */</span></span><br><span class="line"> delta = (<span class="keyword">long</span> <span class="keyword">long</span>) zmalloc_used_memory();</span><br><span class="line"> latencyStartMonitor(eviction_latency);</span><br><span class="line"> <span class="keyword">if</span> (server.lazyfree_lazy_eviction)</span><br><span class="line"> dbAsyncDelete(db,keyobj);</span><br><span class="line"> <span class="keyword">else</span></span><br><span class="line"> dbSyncDelete(db,keyobj);</span><br><span class="line"> latencyEndMonitor(eviction_latency);</span><br><span class="line"> latencyAddSampleIfNeeded(<span class="string">"eviction-del"</span>,eviction_latency);</span><br><span class="line"> latencyRemoveNestedEvent(latency,eviction_latency);</span><br><span class="line"> delta -= (<span class="keyword">long</span> <span class="keyword">long</span>) zmalloc_used_memory();</span><br><span class="line"> mem_freed += delta;</span><br><span class="line"> server.stat_evictedkeys++;</span><br><span class="line"> notifyKeyspaceEvent(NOTIFY_EVICTED, <span class="string">"evicted"</span>,</span><br><span class="line"> keyobj, db->id);</span><br><span class="line"> decrRefCount(keyobj);</span><br><span class="line"> keys_freed++;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* When the memory to free starts to be big enough, we may</span></span><br><span class="line"><span class="comment"> * start spending so much time here that is impossible to</span></span><br><span class="line"><span class="comment"> * deliver data to the slaves fast enough, so we force the</span></span><br><span class="line"><span class="comment"> * transmission here inside the loop. */</span></span><br><span class="line"> <span class="keyword">if</span> (slaves) flushSlavesOutputBuffers();</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Normally our stop condition is the ability to release</span></span><br><span class="line"><span class="comment"> * a fixed, pre-computed amount of memory. However when we</span></span><br><span class="line"><span class="comment"> * are deleting objects in another thread, it's better to</span></span><br><span class="line"><span class="comment"> * check, from time to time, if we already reached our target</span></span><br><span class="line"><span class="comment"> * memory, since the "mem_freed" amount is computed only</span></span><br><span class="line"><span class="comment"> * across the dbAsyncDelete() call, while the thread can</span></span><br><span class="line"><span class="comment"> * release the memory all the time. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.lazyfree_lazy_eviction && !(keys_freed % <span class="number">16</span>)) {</span><br><span class="line"> <span class="keyword">if</span> (getMaxmemoryState(<span class="literal">NULL</span>,<span class="literal">NULL</span>,<span class="literal">NULL</span>,<span class="literal">NULL</span>) == C_OK) {</span><br><span class="line"> <span class="comment">/* Let's satisfy our stop condition. */</span></span><br><span class="line"> mem_freed = mem_tofree;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> latencyEndMonitor(latency);</span><br><span class="line"> latencyAddSampleIfNeeded(<span class="string">"eviction-cycle"</span>,latency);</span><br><span class="line"> <span class="keyword">goto</span> cant_free; <span class="comment">/* nothing to free... */</span></span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> latencyEndMonitor(latency);</span><br><span class="line"> latencyAddSampleIfNeeded(<span class="string">"eviction-cycle"</span>,latency);</span><br><span class="line"> <span class="keyword">return</span> C_OK;</span><br><span class="line"></span><br><span class="line">cant_free:</span><br><span class="line"> <span class="comment">/* We are here if we are not able to reclaim memory. There is only one</span></span><br><span class="line"><span class="comment"> * last thing we can try: check if the lazyfree thread has jobs in queue</span></span><br><span class="line"><span class="comment"> * and wait... */</span></span><br><span class="line"> <span class="keyword">while</span>(bioPendingJobsOfType(BIO_LAZY_FREE)) {</span><br><span class="line"> <span class="keyword">if</span> (((mem_reported - zmalloc_used_memory()) + mem_freed) >= mem_tofree)</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> usleep(<span class="number">1000</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> C_ERR;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>这里就是根据具体策略去淘汰 key，首先是要往 pool 更新 key，更新key 的方法是<a href="https://github.com/antirez/redis/blob/unstable/src/evict.c#L162" target="_blank" rel="noopener"><code>evictionPoolPopulate</code></a></p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br><span class="line">89</span><br><span class="line">90</span><br><span class="line">91</span><br><span class="line">92</span><br><span class="line">93</span><br><span class="line">94</span><br><span class="line">95</span><br><span class="line">96</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">evictionPoolPopulate</span><span class="params">(<span class="keyword">int</span> dbid, dict *sampledict, dict *keydict, struct evictionPoolEntry *pool)</span> </span>{</span><br><span class="line"> <span class="keyword">int</span> j, k, count;</span><br><span class="line"> dictEntry *samples[server.maxmemory_samples];</span><br><span class="line"></span><br><span class="line"> count = dictGetSomeKeys(sampledict,samples,server.maxmemory_samples);</span><br><span class="line"> <span class="keyword">for</span> (j = <span class="number">0</span>; j < count; j++) {</span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> idle;</span><br><span class="line"> sds key;</span><br><span class="line"> robj *o;</span><br><span class="line"> dictEntry *de;</span><br><span class="line"></span><br><span class="line"> de = samples[j];</span><br><span class="line"> key = dictGetKey(de);</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* If the dictionary we are sampling from is not the main</span></span><br><span class="line"><span class="comment"> * dictionary (but the expires one) we need to lookup the key</span></span><br><span class="line"><span class="comment"> * again in the key dictionary to obtain the value object. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.maxmemory_policy != MAXMEMORY_VOLATILE_TTL) {</span><br><span class="line"> <span class="keyword">if</span> (sampledict != keydict) de = dictFind(keydict, key);</span><br><span class="line"> o = dictGetVal(de);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Calculate the idle time according to the policy. This is called</span></span><br><span class="line"><span class="comment"> * idle just because the code initially handled LRU, but is in fact</span></span><br><span class="line"><span class="comment"> * just a score where an higher score means better candidate. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {</span><br><span class="line"> idle = estimateObjectIdleTime(o);</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {</span><br><span class="line"> <span class="comment">/* When we use an LRU policy, we sort the keys by idle time</span></span><br><span class="line"><span class="comment"> * so that we expire keys starting from greater idle time.</span></span><br><span class="line"><span class="comment"> * However when the policy is an LFU one, we have a frequency</span></span><br><span class="line"><span class="comment"> * estimation, and we want to evict keys with lower frequency</span></span><br><span class="line"><span class="comment"> * first. So inside the pool we put objects using the inverted</span></span><br><span class="line"><span class="comment"> * frequency subtracting the actual frequency to the maximum</span></span><br><span class="line"><span class="comment"> * frequency of 255. */</span></span><br><span class="line"> idle = <span class="number">255</span>-LFUDecrAndReturn(o);</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL) {</span><br><span class="line"> <span class="comment">/* In this case the sooner the expire the better. */</span></span><br><span class="line"> idle = ULLONG_MAX - (<span class="keyword">long</span>)dictGetVal(de);</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> serverPanic(<span class="string">"Unknown eviction policy in evictionPoolPopulate()"</span>);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Insert the element inside the pool.</span></span><br><span class="line"><span class="comment"> * First, find the first empty bucket or the first populated</span></span><br><span class="line"><span class="comment"> * bucket that has an idle time smaller than our idle time. */</span></span><br><span class="line"> k = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">while</span> (k < EVPOOL_SIZE &&</span><br><span class="line"> pool[k].key &&</span><br><span class="line"> pool[k].idle < idle) k++;</span><br><span class="line"> <span class="keyword">if</span> (k == <span class="number">0</span> && pool[EVPOOL_SIZE<span class="number">-1</span>].key != <span class="literal">NULL</span>) {</span><br><span class="line"> <span class="comment">/* Can't insert if the element is < the worst element we have</span></span><br><span class="line"><span class="comment"> * and there are no empty buckets. */</span></span><br><span class="line"> <span class="keyword">continue</span>;</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (k < EVPOOL_SIZE && pool[k].key == <span class="literal">NULL</span>) {</span><br><span class="line"> <span class="comment">/* Inserting into empty position. No setup needed before insert. */</span></span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="comment">/* Inserting in the middle. Now k points to the first element</span></span><br><span class="line"><span class="comment"> * greater than the element to insert. */</span></span><br><span class="line"> <span class="keyword">if</span> (pool[EVPOOL_SIZE<span class="number">-1</span>].key == <span class="literal">NULL</span>) {</span><br><span class="line"> <span class="comment">/* Free space on the right? Insert at k shifting</span></span><br><span class="line"><span class="comment"> * all the elements from k to end to the right. */</span></span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Save SDS before overwriting. */</span></span><br><span class="line"> sds cached = pool[EVPOOL_SIZE<span class="number">-1</span>].cached;</span><br><span class="line"> memmove(pool+k+<span class="number">1</span>,pool+k,</span><br><span class="line"> <span class="keyword">sizeof</span>(pool[<span class="number">0</span>])*(EVPOOL_SIZE-k<span class="number">-1</span>));</span><br><span class="line"> pool[k].cached = cached;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="comment">/* No free space on right? Insert at k-1 */</span></span><br><span class="line"> k--;</span><br><span class="line"> <span class="comment">/* Shift all elements on the left of k (included) to the</span></span><br><span class="line"><span class="comment"> * left, so we discard the element with smaller idle time. */</span></span><br><span class="line"> sds cached = pool[<span class="number">0</span>].cached; <span class="comment">/* Save SDS before overwriting. */</span></span><br><span class="line"> <span class="keyword">if</span> (pool[<span class="number">0</span>].key != pool[<span class="number">0</span>].cached) sdsfree(pool[<span class="number">0</span>].key);</span><br><span class="line"> memmove(pool,pool+<span class="number">1</span>,<span class="keyword">sizeof</span>(pool[<span class="number">0</span>])*k);</span><br><span class="line"> pool[k].cached = cached;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Try to reuse the cached SDS string allocated in the pool entry,</span></span><br><span class="line"><span class="comment"> * because allocating and deallocating this object is costly</span></span><br><span class="line"><span class="comment"> * (according to the profiler, not my fantasy. Remember:</span></span><br><span class="line"><span class="comment"> * premature optimizbla bla bla bla. */</span></span><br><span class="line"> <span class="keyword">int</span> klen = sdslen(key);</span><br><span class="line"> <span class="keyword">if</span> (klen > EVPOOL_CACHED_SDS_SIZE) {</span><br><span class="line"> pool[k].key = sdsdup(key);</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="built_in">memcpy</span>(pool[k].cached,key,klen+<span class="number">1</span>);</span><br><span class="line"> sdssetlen(pool[k].cached,klen);</span><br><span class="line"> pool[k].key = pool[k].cached;</span><br><span class="line"> }</span><br><span class="line"> pool[k].idle = idle;</span><br><span class="line"> pool[k].dbid = dbid;</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p><code>Redis</code>随机选择<code>maxmemory_samples</code>数量的key，然后计算这些<code>key</code>的空闲时间<code>idle time</code>，当满足条件时(比pool中的某些键的空闲时间还大)就可以进<code>pool</code>。<code>pool</code>更新之后，就淘汰<code>pool</code>中空闲时间最大的键。</p>
|
|
<p><a href="https://github.com/antirez/redis/blob/unstable/src/evict.c#L90" target="_blank" rel="noopener"><code>estimateObjectIdleTime</code></a>用来计算Redis对象的空闲时间：</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Given an object returns the min number of milliseconds the object was never</span></span><br><span class="line"><span class="comment"> * requested, using an approximated LRU algorithm. */</span></span><br><span class="line"><span class="function"><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> <span class="title">estimateObjectIdleTime</span><span class="params">(robj *o)</span> </span>{</span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> lruclock = LRU_CLOCK();</span><br><span class="line"> <span class="keyword">if</span> (lruclock >= o->lru) {</span><br><span class="line"> <span class="keyword">return</span> (lruclock - o->lru) * LRU_CLOCK_RESOLUTION;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">return</span> (lruclock + (LRU_CLOCK_MAX - o->lru)) *</span><br><span class="line"> LRU_CLOCK_RESOLUTION;</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>空闲时间第一种是 lurclock 大于对象的 lru，那么就是减一下乘以精度，因为 lruclock 有可能是已经预生成的，所以会可能走下面这个</p>
|
|
<h3 id="LFU"><a href="#LFU" class="headerlink" title="LFU"></a>LFU</h3><p>上面介绍了LRU 的算法，但是考虑一种场景</p>
|
|
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">~~~~~A~~~~~A~~~~~A~~~~A~~~~~A~~~~~A~~|</span><br><span class="line">~~B~~B~~B~~B~~B~~B~~B~~B~~B~~B~~B~~B~|</span><br><span class="line">~~~~~~~~~~C~~~~~~~~~C~~~~~~~~~C~~~~~~|</span><br><span class="line">~~~~~D~~~~~~~~~~D~~~~~~~~~D~~~~~~~~~D|</span><br></pre></td></tr></table></figure>
|
|
<p>可以发现，当采用 lru 的淘汰策略的时候，D 是最新的，会被认为是最值得保留的，但是事实上还不如 A 跟 B，然后 antirez 大神就想到了LFU (Least Frequently Used) 这个算法, 显然对于上面的四个 key 的访问频率，保留优先级应该是 B > A > C = D<br>那要怎么来实现这个 LFU 算法呢，其实像LRU，理想的情况就是维护个链表，把最新访问的放到头上去，但是这个会影响访问速度，注意到前面代码的应该可以看到，redisObject 的 lru 字段其实是两用的，当策略是 LFU 时，这个字段就另作他用了，它的 24 位长度被分成两部分</p>
|
|
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"> 16 bits 8 bits</span><br><span class="line">+----------------+--------+</span><br><span class="line">+ Last decr time | LOG_C |</span><br><span class="line">+----------------+--------+</span><br></pre></td></tr></table></figure>
|
|
<p>前16位字段是最后一次递减时间，因此Redis知道 上一次计数器递减，后8位是 计数器 counter。<br>LFU 的主体策略就是当这个 key 被访问的次数越多频率越高他就越容易被保留下来，并且是最近被访问的频率越高。这其实有两个事情要做，一个是在访问的时候增加计数值，在一定长时间不访问时进行衰减，所以这里用了两个值，前 16 位记录上一次衰减的时间，后 8 位记录具体的计数值。<br>Redis4.0之后为maxmemory_policy淘汰策略添加了两个LFU模式：</p>
|
|
<p><code>volatile-lfu</code>：对有过期时间的key采用LFU淘汰策略<br><code>allkeys-lfu</code>：对全部key采用LFU淘汰策略<br>还有2个配置可以调整LFU算法： </p>
|
|
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br></pre></td><td class="code"><pre><span class="line">lfu-log-factor 10</span><br><span class="line">lfu-decay-time 1</span><br><span class="line">``` </span><br><span class="line">`lfu-log-factor` 可以调整计数器counter的增长速度，lfu-log-factor越大，counter增长的越慢。</span><br><span class="line"></span><br><span class="line">`lfu-decay-time`是一个以分钟为单位的数值，可以调整counter的减少速度</span><br><span class="line">这里有个问题是 8 位大小够计么，访问一次加 1 的话的确不够，不过大神就是大神，才不会这么简单的加一。往下看代码</span><br><span class="line">```C</span><br><span class="line">/* Low level key lookup API, not actually called directly from commands</span><br><span class="line"> * implementations that should instead rely on lookupKeyRead(),</span><br><span class="line"> * lookupKeyWrite() and lookupKeyReadWithFlags(). */</span><br><span class="line">robj *lookupKey(redisDb *db, robj *key, int flags) {</span><br><span class="line"> dictEntry *de = dictFind(db->dict,key->ptr);</span><br><span class="line"> if (de) {</span><br><span class="line"> robj *val = dictGetVal(de);</span><br><span class="line"></span><br><span class="line"> /* Update the access time for the ageing algorithm.</span><br><span class="line"> * Don't do it if we have a saving child, as this will trigger</span><br><span class="line"> * a copy on write madness. */</span><br><span class="line"> if (!hasActiveChildProcess() && !(flags & LOOKUP_NOTOUCH)){</span><br><span class="line"> if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {</span><br><span class="line"> // 当淘汰策略是 LFU 时，就会调用这个updateLFU</span><br><span class="line"> updateLFU(val);</span><br><span class="line"> } else {</span><br><span class="line"> val->lru = LRU_CLOCK();</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> return val;</span><br><span class="line"> } else {</span><br><span class="line"> return NULL;</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p><a href="https://github.com/antirez/redis/blob/unstable/src/db.c#L46" target="_blank" rel="noopener"><code>updateLFU</code></a> 这个其实个入口，调用了两个重要的方法</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Update LFU when an object is accessed.</span></span><br><span class="line"><span class="comment"> * Firstly, decrement the counter if the decrement time is reached.</span></span><br><span class="line"><span class="comment"> * Then logarithmically increment the counter, and update the access time. */</span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">updateLFU</span><span class="params">(robj *val)</span> </span>{</span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> counter = LFUDecrAndReturn(val);</span><br><span class="line"> counter = LFULogIncr(counter);</span><br><span class="line"> val->lru = (LFUGetTimeInMinutes()<<<span class="number">8</span>) | counter;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>首先来看看<a href="https://github.com/antirez/redis/blob/unstable/src/evict.c#L335" target="_blank" rel="noopener"><code>LFUDecrAndReturn</code></a>，这个方法的作用是根据上一次衰减时间和系统配置的 <code>lfu-decay-time</code> 参数来确定需要将 counter 减去多少</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* If the object decrement time is reached decrement the LFU counter but</span></span><br><span class="line"><span class="comment"> * do not update LFU fields of the object, we update the access time</span></span><br><span class="line"><span class="comment"> * and counter in an explicit way when the object is really accessed.</span></span><br><span class="line"><span class="comment"> * And we will times halve the counter according to the times of</span></span><br><span class="line"><span class="comment"> * elapsed time than server.lfu_decay_time.</span></span><br><span class="line"><span class="comment"> * Return the object frequency counter.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * This function is used in order to scan the dataset for the best object</span></span><br><span class="line"><span class="comment"> * to fit: as we check for the candidate, we incrementally decrement the</span></span><br><span class="line"><span class="comment"> * counter of the scanned objects if needed. */</span></span><br><span class="line"><span class="function"><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="title">LFUDecrAndReturn</span><span class="params">(robj *o)</span> </span>{</span><br><span class="line"> <span class="comment">// 右移 8 位，拿到上次衰减时间</span></span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> ldt = o->lru >> <span class="number">8</span>;</span><br><span class="line"> <span class="comment">// 对 255 做与操作，拿到 counter 值</span></span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> counter = o->lru & <span class="number">255</span>;</span><br><span class="line"> <span class="comment">// 根据lfu_decay_time来算出过了多少个衰减周期</span></span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> num_periods = server.lfu_decay_time ? LFUTimeElapsed(ldt) / server.lfu_decay_time : <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">if</span> (num_periods)</span><br><span class="line"> counter = (num_periods > counter) ? <span class="number">0</span> : counter - num_periods;</span><br><span class="line"> <span class="keyword">return</span> counter;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>然后是加，调用了<a href="https://github.com/antirez/redis/blob/unstable/src/evict.c#L315" target="_blank" rel="noopener"><code>LFULogIncr</code></a></p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* Logarithmically increment a counter. The greater is the current counter value</span></span><br><span class="line"><span class="comment"> * the less likely is that it gets really implemented. Saturate it at 255. */</span></span><br><span class="line"><span class="function"><span class="keyword">uint8_t</span> <span class="title">LFULogIncr</span><span class="params">(<span class="keyword">uint8_t</span> counter)</span> </span>{</span><br><span class="line"> <span class="comment">// 最大值就是 255，到顶了就不加了</span></span><br><span class="line"> <span class="keyword">if</span> (counter == <span class="number">255</span>) <span class="keyword">return</span> <span class="number">255</span>;</span><br><span class="line"> <span class="comment">// 生成个随机小数</span></span><br><span class="line"> <span class="keyword">double</span> r = (<span class="keyword">double</span>)rand()/RAND_MAX;</span><br><span class="line"> <span class="comment">// 减去个基础值，LFU_INIT_VAL = 5，防止刚进来就被逐出</span></span><br><span class="line"> <span class="keyword">double</span> baseval = counter - LFU_INIT_VAL;</span><br><span class="line"> <span class="comment">// 如果是小于 0，</span></span><br><span class="line"> <span class="keyword">if</span> (baseval < <span class="number">0</span>) baseval = <span class="number">0</span>;</span><br><span class="line"> <span class="comment">// 如果 baseval 是 0，那么 p 就是 1了，后面 counter 直接加一，如果不是的话，得看系统参数lfu_log_factor，这个越大，除出来的 p 越小，那么 counter++的可能性也越小，这样子就把前面的疑问给解决了，不是直接+1 的</span></span><br><span class="line"> <span class="keyword">double</span> p = <span class="number">1.0</span>/(baseval*server.lfu_log_factor+<span class="number">1</span>);</span><br><span class="line"> <span class="keyword">if</span> (r < p) counter++;</span><br><span class="line"> <span class="keyword">return</span> counter;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>大概的变化速度可以参考</p>
|
|
<figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line">+--------+------------+------------+------------+------------+------------+</span><br><span class="line">| factor | 100 hits | 1000 hits | 100K hits | 1M hits | 10M hits |</span><br><span class="line">+--------+------------+------------+------------+------------+------------+</span><br><span class="line">| 0 | 104 | 255 | 255 | 255 | 255 |</span><br><span class="line">+--------+------------+------------+------------+------------+------------+</span><br><span class="line">| 1 | 18 | 49 | 255 | 255 | 255 |</span><br><span class="line">+--------+------------+------------+------------+------------+------------+</span><br><span class="line">| 10 | 10 | 18 | 142 | 255 | 255 |</span><br><span class="line">+--------+------------+------------+------------+------------+------------+</span><br><span class="line">| 100 | 8 | 11 | 49 | 143 | 255 |</span><br><span class="line">+--------+------------+------------+------------+------------+------------+</span><br></pre></td></tr></table></figure>
|
|
<p>简而言之就是 lfu_log_factor 越大变化的越慢</p>
|
|
<h3 id="总结"><a href="#总结" class="headerlink" title="总结"></a>总结</h3><p>总结一下，redis 实现了近似的 lru 淘汰策略，通过增加了淘汰 key 的池子(pool)，并且增大每次抽样的 key 的数量来将淘汰效果更进一步地接近于 lru，这是 lru 策略，但是对于前面举的一个例子，其实 lru 并不能保证 key 的淘汰就如我们预期，所以在后期又引入了 lfu 的策略，lfu的策略比较巧妙，复用了 redis 对象的 lru 字段，并且使用了factor 参数来控制计数器递增的速度，防止 8 位的计数器太早溢出。</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/04/12/redis%E7%B3%BB%E5%88%97%E4%BB%8B%E7%BB%8D%E4%B8%83/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/04/12/redis%E7%B3%BB%E5%88%97%E4%BB%8B%E7%BB%8D%E4%B8%83/" class="post-title-link" itemprop="url">redis系列介绍七-过期策略</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
|
|
<time title="Created: 2020-04-12 21:22:00 / Modified: 22:57:42" itemprop="dateCreated datePublished" datetime="2020-04-12T21:22:00+08:00">2020-04-12</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Redis/" itemprop="url" rel="index"><span itemprop="name">Redis</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Redis/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/" itemprop="url" rel="index"><span itemprop="name">数据结构</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Redis/%E6%BA%90%E7%A0%81/" itemprop="url" rel="index"><span itemprop="name">源码</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/" itemprop="url" rel="index"><span itemprop="name">C</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/C/Redis/" itemprop="url" rel="index"><span itemprop="name">Redis</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/04/12/redis%E7%B3%BB%E5%88%97%E4%BB%8B%E7%BB%8D%E4%B8%83/" class="post-meta-item leancloud_visitors" data-flag-title="redis系列介绍七-过期策略" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/04/12/redis%E7%B3%BB%E5%88%97%E4%BB%8B%E7%BB%8D%E4%B8%83/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/04/12/redis系列介绍七/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<p>这一篇不再是数据结构介绍了，大致的数据结构基本都介绍了，这一篇主要是查漏补缺，或者说讲一些重要且基本的概念，也可能是经常被忽略的，很多讲 redis 的系列文章可能都会忽略，学习 redis 的时候也会，因为觉得源码学习就是讲主要的数据结构和“算法”学习了就好了。<br>redis 的主要应用就是拿来作为高性能的缓存，那么缓存一般有些啥需要注意的，首先是访问速度，如果取得跟数据库一样快，那就没什么存在的意义，第二个是缓存的字面意思，我只是为了让数据读取快一些，通常大部分的场景这个是需要更新过期的，这里就把我要讲的第一点引出来了（真累，</p>
|
|
<h2 id="redis过期策略"><a href="#redis过期策略" class="headerlink" title="redis过期策略"></a>redis过期策略</h2><p>redis 是如何过期缓存的，可以猜测下，最无脑的就是每个设置了过期时间的 key 都设个定时器，过期了就删除，这种显然消耗太大，清理地最及时，还有的就是 redis 正在采用的懒汉清理策略和定期清理<br>懒汉策略就是在使用的时候去检查缓存是否过期，比如 get 操作时，先判断下这个 key 是否已经过期了，如果过期了就删掉，并且返回空，如果没过期则正常返回<br>主要代码是</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br><span class="line">89</span><br><span class="line">90</span><br><span class="line">91</span><br><span class="line">92</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* This function is called when we are going to perform some operation</span></span><br><span class="line"><span class="comment"> * in a given key, but such key may be already logically expired even if</span></span><br><span class="line"><span class="comment"> * it still exists in the database. The main way this function is called</span></span><br><span class="line"><span class="comment"> * is via lookupKey*() family of functions.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * The behavior of the function depends on the replication role of the</span></span><br><span class="line"><span class="comment"> * instance, because slave instances do not expire keys, they wait</span></span><br><span class="line"><span class="comment"> * for DELs from the master for consistency matters. However even</span></span><br><span class="line"><span class="comment"> * slaves will try to have a coherent return value for the function,</span></span><br><span class="line"><span class="comment"> * so that read commands executed in the slave side will be able to</span></span><br><span class="line"><span class="comment"> * behave like if the key is expired even if still present (because the</span></span><br><span class="line"><span class="comment"> * master has yet to propagate the DEL).</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * In masters as a side effect of finding a key which is expired, such</span></span><br><span class="line"><span class="comment"> * key will be evicted from the database. Also this may trigger the</span></span><br><span class="line"><span class="comment"> * propagation of a DEL/UNLINK command in AOF / replication stream.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * The return value of the function is 0 if the key is still valid,</span></span><br><span class="line"><span class="comment"> * otherwise the function returns 1 if the key is expired. */</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">expireIfNeeded</span><span class="params">(redisDb *db, robj *key)</span> </span>{</span><br><span class="line"> <span class="keyword">if</span> (!keyIsExpired(db,key)) <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* If we are running in the context of a slave, instead of</span></span><br><span class="line"><span class="comment"> * evicting the expired key from the database, we return ASAP:</span></span><br><span class="line"><span class="comment"> * the slave key expiration is controlled by the master that will</span></span><br><span class="line"><span class="comment"> * send us synthesized DEL operations for expired keys.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * Still we try to return the right information to the caller,</span></span><br><span class="line"><span class="comment"> * that is, 0 if we think the key should be still valid, 1 if</span></span><br><span class="line"><span class="comment"> * we think the key is expired at this time. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.masterhost != <span class="literal">NULL</span>) <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Delete the key */</span></span><br><span class="line"> server.stat_expiredkeys++;</span><br><span class="line"> propagateExpire(db,key,server.lazyfree_lazy_expire);</span><br><span class="line"> notifyKeyspaceEvent(NOTIFY_EXPIRED,</span><br><span class="line"> <span class="string">"expired"</span>,key,db->id);</span><br><span class="line"> <span class="keyword">return</span> server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) :</span><br><span class="line"> dbSyncDelete(db,key);</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="comment">/* Check if the key is expired. */</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">keyIsExpired</span><span class="params">(redisDb *db, robj *key)</span> </span>{</span><br><span class="line"> <span class="keyword">mstime_t</span> when = getExpire(db,key);</span><br><span class="line"> <span class="keyword">mstime_t</span> now;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (when < <span class="number">0</span>) <span class="keyword">return</span> <span class="number">0</span>; <span class="comment">/* No expire for this key */</span></span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Don't expire anything while loading. It will be done later. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.loading) <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* If we are in the context of a Lua script, we pretend that time is</span></span><br><span class="line"><span class="comment"> * blocked to when the Lua script started. This way a key can expire</span></span><br><span class="line"><span class="comment"> * only the first time it is accessed and not in the middle of the</span></span><br><span class="line"><span class="comment"> * script execution, making propagation to slaves / AOF consistent.</span></span><br><span class="line"><span class="comment"> * See issue #1525 on Github for more information. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.lua_caller) {</span><br><span class="line"> now = server.lua_time_start;</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">/* If we are in the middle of a command execution, we still want to use</span></span><br><span class="line"><span class="comment"> * a reference time that does not change: in that case we just use the</span></span><br><span class="line"><span class="comment"> * cached time, that we update before each call in the call() function.</span></span><br><span class="line"><span class="comment"> * This way we avoid that commands such as RPOPLPUSH or similar, that</span></span><br><span class="line"><span class="comment"> * may re-open the same key multiple times, can invalidate an already</span></span><br><span class="line"><span class="comment"> * open object in a next call, if the next call will see the key expired,</span></span><br><span class="line"><span class="comment"> * while the first did not. */</span></span><br><span class="line"> <span class="keyword">else</span> <span class="keyword">if</span> (server.fixed_time_expire > <span class="number">0</span>) {</span><br><span class="line"> now = server.mstime;</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">/* For the other cases, we want to use the most fresh time we have. */</span></span><br><span class="line"> <span class="keyword">else</span> {</span><br><span class="line"> now = mstime();</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* The key expired if the current (virtual or real) time is greater</span></span><br><span class="line"><span class="comment"> * than the expire time of the key. */</span></span><br><span class="line"> <span class="keyword">return</span> now > when;</span><br><span class="line">}</span><br><span class="line"><span class="comment">/* Return the expire time of the specified key, or -1 if no expire</span></span><br><span class="line"><span class="comment"> * is associated with this key (i.e. the key is non volatile) */</span></span><br><span class="line"><span class="function"><span class="keyword">long</span> <span class="keyword">long</span> <span class="title">getExpire</span><span class="params">(redisDb *db, robj *key)</span> </span>{</span><br><span class="line"> dictEntry *de;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* No expire? return ASAP */</span></span><br><span class="line"> <span class="keyword">if</span> (dictSize(db->expires) == <span class="number">0</span> ||</span><br><span class="line"> (de = dictFind(db->expires,key->ptr)) == <span class="literal">NULL</span>) <span class="keyword">return</span> <span class="number">-1</span>;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* The entry was found in the expire dict, this means it should also</span></span><br><span class="line"><span class="comment"> * be present in the main dict (safety check). */</span></span><br><span class="line"> serverAssertWithInfo(<span class="literal">NULL</span>,key,dictFind(db->dict,key->ptr) != <span class="literal">NULL</span>);</span><br><span class="line"> <span class="keyword">return</span> dictGetSignedIntegerVal(de);</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>这里有几点要注意的，第一是当惰性删除时会根据lazyfree_lazy_expire这个参数去判断是执行同步删除还是异步删除，另外一点是对于 slave，是不需要执行的，因为会在 master 过期时向 slave 发送 del 指令。<br>光采用这个策略会有什么问题呢，假如一些key 一直未被访问，那这些 key 就不会过期了，导致一直被占用着内存，所以 redis 采取了懒汉式过期加定期过期策略，定期策略是怎么执行的呢</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br><span class="line">89</span><br><span class="line">90</span><br><span class="line">91</span><br><span class="line">92</span><br><span class="line">93</span><br><span class="line">94</span><br><span class="line">95</span><br><span class="line">96</span><br><span class="line">97</span><br><span class="line">98</span><br><span class="line">99</span><br><span class="line">100</span><br><span class="line">101</span><br><span class="line">102</span><br><span class="line">103</span><br><span class="line">104</span><br><span class="line">105</span><br><span class="line">106</span><br><span class="line">107</span><br><span class="line">108</span><br><span class="line">109</span><br><span class="line">110</span><br><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br><span class="line">117</span><br><span class="line">118</span><br><span class="line">119</span><br><span class="line">120</span><br><span class="line">121</span><br><span class="line">122</span><br><span class="line">123</span><br><span class="line">124</span><br><span class="line">125</span><br><span class="line">126</span><br><span class="line">127</span><br><span class="line">128</span><br><span class="line">129</span><br><span class="line">130</span><br><span class="line">131</span><br><span class="line">132</span><br><span class="line">133</span><br><span class="line">134</span><br><span class="line">135</span><br><span class="line">136</span><br><span class="line">137</span><br><span class="line">138</span><br><span class="line">139</span><br><span class="line">140</span><br><span class="line">141</span><br><span class="line">142</span><br><span class="line">143</span><br><span class="line">144</span><br><span class="line">145</span><br><span class="line">146</span><br><span class="line">147</span><br><span class="line">148</span><br><span class="line">149</span><br><span class="line">150</span><br><span class="line">151</span><br><span class="line">152</span><br><span class="line">153</span><br><span class="line">154</span><br><span class="line">155</span><br><span class="line">156</span><br><span class="line">157</span><br><span class="line">158</span><br><span class="line">159</span><br><span class="line">160</span><br><span class="line">161</span><br><span class="line">162</span><br><span class="line">163</span><br><span class="line">164</span><br><span class="line">165</span><br><span class="line">166</span><br><span class="line">167</span><br><span class="line">168</span><br><span class="line">169</span><br><span class="line">170</span><br><span class="line">171</span><br><span class="line">172</span><br><span class="line">173</span><br><span class="line">174</span><br><span class="line">175</span><br><span class="line">176</span><br><span class="line">177</span><br><span class="line">178</span><br><span class="line">179</span><br><span class="line">180</span><br><span class="line">181</span><br><span class="line">182</span><br><span class="line">183</span><br><span class="line">184</span><br><span class="line">185</span><br><span class="line">186</span><br><span class="line">187</span><br><span class="line">188</span><br><span class="line">189</span><br><span class="line">190</span><br><span class="line">191</span><br><span class="line">192</span><br><span class="line">193</span><br><span class="line">194</span><br><span class="line">195</span><br><span class="line">196</span><br><span class="line">197</span><br><span class="line">198</span><br><span class="line">199</span><br><span class="line">200</span><br><span class="line">201</span><br><span class="line">202</span><br><span class="line">203</span><br><span class="line">204</span><br><span class="line">205</span><br><span class="line">206</span><br><span class="line">207</span><br><span class="line">208</span><br><span class="line">209</span><br><span class="line">210</span><br><span class="line">211</span><br><span class="line">212</span><br><span class="line">213</span><br><span class="line">214</span><br><span class="line">215</span><br><span class="line">216</span><br><span class="line">217</span><br><span class="line">218</span><br><span class="line">219</span><br><span class="line">220</span><br><span class="line">221</span><br><span class="line">222</span><br><span class="line">223</span><br><span class="line">224</span><br><span class="line">225</span><br><span class="line">226</span><br><span class="line">227</span><br><span class="line">228</span><br><span class="line">229</span><br><span class="line">230</span><br><span class="line">231</span><br><span class="line">232</span><br><span class="line">233</span><br><span class="line">234</span><br><span class="line">235</span><br><span class="line">236</span><br><span class="line">237</span><br><span class="line">238</span><br><span class="line">239</span><br><span class="line">240</span><br><span class="line">241</span><br><span class="line">242</span><br><span class="line">243</span><br><span class="line">244</span><br><span class="line">245</span><br><span class="line">246</span><br><span class="line">247</span><br><span class="line">248</span><br><span class="line">249</span><br><span class="line">250</span><br><span class="line">251</span><br><span class="line">252</span><br><span class="line">253</span><br><span class="line">254</span><br><span class="line">255</span><br><span class="line">256</span><br><span class="line">257</span><br><span class="line">258</span><br><span class="line">259</span><br><span class="line">260</span><br><span class="line">261</span><br><span class="line">262</span><br><span class="line">263</span><br><span class="line">264</span><br><span class="line">265</span><br><span class="line">266</span><br><span class="line">267</span><br><span class="line">268</span><br><span class="line">269</span><br><span class="line">270</span><br><span class="line">271</span><br><span class="line">272</span><br><span class="line">273</span><br><span class="line">274</span><br><span class="line">275</span><br><span class="line">276</span><br><span class="line">277</span><br><span class="line">278</span><br><span class="line">279</span><br><span class="line">280</span><br><span class="line">281</span><br><span class="line">282</span><br><span class="line">283</span><br><span class="line">284</span><br><span class="line">285</span><br><span class="line">286</span><br><span class="line">287</span><br><span class="line">288</span><br><span class="line">289</span><br><span class="line">290</span><br><span class="line">291</span><br><span class="line">292</span><br><span class="line">293</span><br><span class="line">294</span><br><span class="line">295</span><br><span class="line">296</span><br><span class="line">297</span><br><span class="line">298</span><br><span class="line">299</span><br><span class="line">300</span><br><span class="line">301</span><br><span class="line">302</span><br><span class="line">303</span><br><span class="line">304</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/* This function handles 'background' operations we are required to do</span></span><br><span class="line"><span class="comment"> * incrementally in Redis databases, such as active key expiring, resizing,</span></span><br><span class="line"><span class="comment"> * rehashing. */</span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">databasesCron</span><span class="params">(<span class="keyword">void</span>)</span> </span>{</span><br><span class="line"> <span class="comment">/* Expire keys by random sampling. Not required for slaves</span></span><br><span class="line"><span class="comment"> * as master will synthesize DELs for us. */</span></span><br><span class="line"> <span class="keyword">if</span> (server.active_expire_enabled) {</span><br><span class="line"> <span class="keyword">if</span> (server.masterhost == <span class="literal">NULL</span>) {</span><br><span class="line"> activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> expireSlaveKeys();</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Defrag keys gradually. */</span></span><br><span class="line"> activeDefragCycle();</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Perform hash tables rehashing if needed, but only if there are no</span></span><br><span class="line"><span class="comment"> * other processes saving the DB on disk. Otherwise rehashing is bad</span></span><br><span class="line"><span class="comment"> * as will cause a lot of copy-on-write of memory pages. */</span></span><br><span class="line"> <span class="keyword">if</span> (!hasActiveChildProcess()) {</span><br><span class="line"> <span class="comment">/* We use global counters so if we stop the computation at a given</span></span><br><span class="line"><span class="comment"> * DB we'll be able to start from the successive in the next</span></span><br><span class="line"><span class="comment"> * cron loop iteration. */</span></span><br><span class="line"> <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> resize_db = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> rehash_db = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">int</span> dbs_per_call = CRON_DBS_PER_CALL;</span><br><span class="line"> <span class="keyword">int</span> j;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Don't test more DBs than we have. */</span></span><br><span class="line"> <span class="keyword">if</span> (dbs_per_call > server.dbnum) dbs_per_call = server.dbnum;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Resize */</span></span><br><span class="line"> <span class="keyword">for</span> (j = <span class="number">0</span>; j < dbs_per_call; j++) {</span><br><span class="line"> tryResizeHashTables(resize_db % server.dbnum);</span><br><span class="line"> resize_db++;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Rehash */</span></span><br><span class="line"> <span class="keyword">if</span> (server.activerehashing) {</span><br><span class="line"> <span class="keyword">for</span> (j = <span class="number">0</span>; j < dbs_per_call; j++) {</span><br><span class="line"> <span class="keyword">int</span> work_done = incrementallyRehash(rehash_db);</span><br><span class="line"> <span class="keyword">if</span> (work_done) {</span><br><span class="line"> <span class="comment">/* If the function did some work, stop here, we'll do</span></span><br><span class="line"><span class="comment"> * more at the next cron loop. */</span></span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="comment">/* If this db didn't need rehash, we'll try the next one. */</span></span><br><span class="line"> rehash_db++;</span><br><span class="line"> rehash_db %= server.dbnum;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br><span class="line"><span class="comment">/* Try to expire a few timed out keys. The algorithm used is adaptive and</span></span><br><span class="line"><span class="comment"> * will use few CPU cycles if there are few expiring keys, otherwise</span></span><br><span class="line"><span class="comment"> * it will get more aggressive to avoid that too much memory is used by</span></span><br><span class="line"><span class="comment"> * keys that can be removed from the keyspace.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * Every expire cycle tests multiple databases: the next call will start</span></span><br><span class="line"><span class="comment"> * again from the next db, with the exception of exists for time limit: in that</span></span><br><span class="line"><span class="comment"> * case we restart again from the last database we were processing. Anyway</span></span><br><span class="line"><span class="comment"> * no more than CRON_DBS_PER_CALL databases are tested at every iteration.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * The function can perform more or less work, depending on the "type"</span></span><br><span class="line"><span class="comment"> * argument. It can execute a "fast cycle" or a "slow cycle". The slow</span></span><br><span class="line"><span class="comment"> * cycle is the main way we collect expired cycles: this happens with</span></span><br><span class="line"><span class="comment"> * the "server.hz" frequency (usually 10 hertz).</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * However the slow cycle can exit for timeout, since it used too much time.</span></span><br><span class="line"><span class="comment"> * For this reason the function is also invoked to perform a fast cycle</span></span><br><span class="line"><span class="comment"> * at every event loop cycle, in the beforeSleep() function. The fast cycle</span></span><br><span class="line"><span class="comment"> * will try to perform less work, but will do it much more often.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * The following are the details of the two expire cycles and their stop</span></span><br><span class="line"><span class="comment"> * conditions:</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * If type is ACTIVE_EXPIRE_CYCLE_FAST the function will try to run a</span></span><br><span class="line"><span class="comment"> * "fast" expire cycle that takes no longer than EXPIRE_FAST_CYCLE_DURATION</span></span><br><span class="line"><span class="comment"> * microseconds, and is not repeated again before the same amount of time.</span></span><br><span class="line"><span class="comment"> * The cycle will also refuse to run at all if the latest slow cycle did not</span></span><br><span class="line"><span class="comment"> * terminate because of a time limit condition.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * If type is ACTIVE_EXPIRE_CYCLE_SLOW, that normal expire cycle is</span></span><br><span class="line"><span class="comment"> * executed, where the time limit is a percentage of the REDIS_HZ period</span></span><br><span class="line"><span class="comment"> * as specified by the ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC define. In the</span></span><br><span class="line"><span class="comment"> * fast cycle, the check of every database is interrupted once the number</span></span><br><span class="line"><span class="comment"> * of already expired keys in the database is estimated to be lower than</span></span><br><span class="line"><span class="comment"> * a given percentage, in order to avoid doing too much work to gain too</span></span><br><span class="line"><span class="comment"> * little memory.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * The configured expire "effort" will modify the baseline parameters in</span></span><br><span class="line"><span class="comment"> * order to do more work in both the fast and slow expire cycles.</span></span><br><span class="line"><span class="comment"> */</span></span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP 20 <span class="comment">/* Keys for each DB loop. */</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ACTIVE_EXPIRE_CYCLE_FAST_DURATION 1000 <span class="comment">/* Microseconds. */</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 <span class="comment">/* Max % of CPU to use. */</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE 10 <span class="comment">/* % of stale keys after which</span></span></span><br><span class="line"><span class="meta"><span class="comment"> we do extra efforts. */</span></span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">activeExpireCycle</span><span class="params">(<span class="keyword">int</span> type)</span> </span>{</span><br><span class="line"> <span class="comment">/* Adjust the running parameters according to the configured expire</span></span><br><span class="line"><span class="comment"> * effort. The default effort is 1, and the maximum configurable effort</span></span><br><span class="line"><span class="comment"> * is 10. */</span></span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span></span><br><span class="line"> effort = server.active_expire_effort<span class="number">-1</span>, <span class="comment">/* Rescale from 0 to 9. */</span></span><br><span class="line"> config_keys_per_loop = ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP +</span><br><span class="line"> ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP/<span class="number">4</span>*effort,</span><br><span class="line"> config_cycle_fast_duration = ACTIVE_EXPIRE_CYCLE_FAST_DURATION +</span><br><span class="line"> ACTIVE_EXPIRE_CYCLE_FAST_DURATION/<span class="number">4</span>*effort,</span><br><span class="line"> config_cycle_slow_time_perc = ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC +</span><br><span class="line"> <span class="number">2</span>*effort,</span><br><span class="line"> config_cycle_acceptable_stale = ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE-</span><br><span class="line"> effort;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* This function has some global state in order to continue the work</span></span><br><span class="line"><span class="comment"> * incrementally across calls. */</span></span><br><span class="line"> <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> current_db = <span class="number">0</span>; <span class="comment">/* Last DB tested. */</span></span><br><span class="line"> <span class="keyword">static</span> <span class="keyword">int</span> timelimit_exit = <span class="number">0</span>; <span class="comment">/* Time limit hit in previous call? */</span></span><br><span class="line"> <span class="keyword">static</span> <span class="keyword">long</span> <span class="keyword">long</span> last_fast_cycle = <span class="number">0</span>; <span class="comment">/* When last fast cycle ran. */</span></span><br><span class="line"></span><br><span class="line"> <span class="keyword">int</span> j, iteration = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">int</span> dbs_per_call = CRON_DBS_PER_CALL;</span><br><span class="line"> <span class="keyword">long</span> <span class="keyword">long</span> start = ustime(), timelimit, elapsed;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* When clients are paused the dataset should be static not just from the</span></span><br><span class="line"><span class="comment"> * POV of clients not being able to write, but also from the POV of</span></span><br><span class="line"><span class="comment"> * expires and evictions of keys not being performed. */</span></span><br><span class="line"> <span class="keyword">if</span> (clientsArePaused()) <span class="keyword">return</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (type == ACTIVE_EXPIRE_CYCLE_FAST) {</span><br><span class="line"> <span class="comment">/* Don't start a fast cycle if the previous cycle did not exit</span></span><br><span class="line"><span class="comment"> * for time limit, unless the percentage of estimated stale keys is</span></span><br><span class="line"><span class="comment"> * too high. Also never repeat a fast cycle for the same period</span></span><br><span class="line"><span class="comment"> * as the fast cycle total duration itself. */</span></span><br><span class="line"> <span class="keyword">if</span> (!timelimit_exit &&</span><br><span class="line"> server.stat_expired_stale_perc < config_cycle_acceptable_stale)</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (start < last_fast_cycle + (<span class="keyword">long</span> <span class="keyword">long</span>)config_cycle_fast_duration*<span class="number">2</span>)</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line"></span><br><span class="line"> last_fast_cycle = start;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* We usually should test CRON_DBS_PER_CALL per iteration, with</span></span><br><span class="line"><span class="comment"> * two exceptions:</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * 1) Don't test more DBs than we have.</span></span><br><span class="line"><span class="comment"> * 2) If last time we hit the time limit, we want to scan all DBs</span></span><br><span class="line"><span class="comment"> * in this iteration, as there is work to do in some DB and we don't want</span></span><br><span class="line"><span class="comment"> * expired keys to use memory for too much time. */</span></span><br><span class="line"> <span class="keyword">if</span> (dbs_per_call > server.dbnum || timelimit_exit)</span><br><span class="line"> dbs_per_call = server.dbnum;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* We can use at max 'config_cycle_slow_time_perc' percentage of CPU</span></span><br><span class="line"><span class="comment"> * time per iteration. Since this function gets called with a frequency of</span></span><br><span class="line"><span class="comment"> * server.hz times per second, the following is the max amount of</span></span><br><span class="line"><span class="comment"> * microseconds we can spend in this function. */</span></span><br><span class="line"> timelimit = config_cycle_slow_time_perc*<span class="number">1000000</span>/server.hz/<span class="number">100</span>;</span><br><span class="line"> timelimit_exit = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">if</span> (timelimit <= <span class="number">0</span>) timelimit = <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (type == ACTIVE_EXPIRE_CYCLE_FAST)</span><br><span class="line"> timelimit = config_cycle_fast_duration; <span class="comment">/* in microseconds. */</span></span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Accumulate some global stats as we expire keys, to have some idea</span></span><br><span class="line"><span class="comment"> * about the number of keys that are already logically expired, but still</span></span><br><span class="line"><span class="comment"> * existing inside the database. */</span></span><br><span class="line"> <span class="keyword">long</span> total_sampled = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">long</span> total_expired = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">for</span> (j = <span class="number">0</span>; j < dbs_per_call && timelimit_exit == <span class="number">0</span>; j++) {</span><br><span class="line"> <span class="comment">/* Expired and checked in a single loop. */</span></span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> expired, sampled;</span><br><span class="line"></span><br><span class="line"> redisDb *db = server.db+(current_db % server.dbnum);</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Increment the DB now so we are sure if we run out of time</span></span><br><span class="line"><span class="comment"> * in the current DB we'll restart from the next. This allows to</span></span><br><span class="line"><span class="comment"> * distribute the time evenly across DBs. */</span></span><br><span class="line"> current_db++;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Continue to expire if at the end of the cycle more than 25%</span></span><br><span class="line"><span class="comment"> * of the keys were expired. */</span></span><br><span class="line"> <span class="keyword">do</span> {</span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> num, slots;</span><br><span class="line"> <span class="keyword">long</span> <span class="keyword">long</span> now, ttl_sum;</span><br><span class="line"> <span class="keyword">int</span> ttl_samples;</span><br><span class="line"> iteration++;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* If there is nothing to expire try next DB ASAP. */</span></span><br><span class="line"> <span class="keyword">if</span> ((num = dictSize(db->expires)) == <span class="number">0</span>) {</span><br><span class="line"> db->avg_ttl = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> slots = dictSlots(db->expires);</span><br><span class="line"> now = mstime();</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* When there are less than 1% filled slots, sampling the key</span></span><br><span class="line"><span class="comment"> * space is expensive, so stop here waiting for better times...</span></span><br><span class="line"><span class="comment"> * The dictionary will be resized asap. */</span></span><br><span class="line"> <span class="keyword">if</span> (num && slots > DICT_HT_INITIAL_SIZE &&</span><br><span class="line"> (num*<span class="number">100</span>/slots < <span class="number">1</span>)) <span class="keyword">break</span>;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* The main collection cycle. Sample random keys among keys</span></span><br><span class="line"><span class="comment"> * with an expire set, checking for expired ones. */</span></span><br><span class="line"> expired = <span class="number">0</span>;</span><br><span class="line"> sampled = <span class="number">0</span>;</span><br><span class="line"> ttl_sum = <span class="number">0</span>;</span><br><span class="line"> ttl_samples = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">if</span> (num > config_keys_per_loop)</span><br><span class="line"> num = config_keys_per_loop;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Here we access the low level representation of the hash table</span></span><br><span class="line"><span class="comment"> * for speed concerns: this makes this code coupled with dict.c,</span></span><br><span class="line"><span class="comment"> * but it hardly changed in ten years.</span></span><br><span class="line"><span class="comment"> *</span></span><br><span class="line"><span class="comment"> * Note that certain places of the hash table may be empty,</span></span><br><span class="line"><span class="comment"> * so we want also a stop condition about the number of</span></span><br><span class="line"><span class="comment"> * buckets that we scanned. However scanning for free buckets</span></span><br><span class="line"><span class="comment"> * is very fast: we are in the cache line scanning a sequential</span></span><br><span class="line"><span class="comment"> * array of NULL pointers, so we can scan a lot more buckets</span></span><br><span class="line"><span class="comment"> * than keys in the same time. */</span></span><br><span class="line"> <span class="keyword">long</span> max_buckets = num*<span class="number">20</span>;</span><br><span class="line"> <span class="keyword">long</span> checked_buckets = <span class="number">0</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">while</span> (sampled < num && checked_buckets < max_buckets) {</span><br><span class="line"> <span class="keyword">for</span> (<span class="keyword">int</span> table = <span class="number">0</span>; table < <span class="number">2</span>; table++) {</span><br><span class="line"> <span class="keyword">if</span> (table == <span class="number">1</span> && !dictIsRehashing(db->expires)) <span class="keyword">break</span>;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">unsigned</span> <span class="keyword">long</span> idx = db->expires_cursor;</span><br><span class="line"> idx &= db->expires->ht[table].sizemask;</span><br><span class="line"> dictEntry *de = db->expires->ht[table].table[idx];</span><br><span class="line"> <span class="keyword">long</span> <span class="keyword">long</span> ttl;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Scan the current bucket of the current table. */</span></span><br><span class="line"> checked_buckets++;</span><br><span class="line"> <span class="keyword">while</span>(de) {</span><br><span class="line"> <span class="comment">/* Get the next entry now since this entry may get</span></span><br><span class="line"><span class="comment"> * deleted. */</span></span><br><span class="line"> dictEntry *e = de;</span><br><span class="line"> de = de->next;</span><br><span class="line"></span><br><span class="line"> ttl = dictGetSignedIntegerVal(e)-now;</span><br><span class="line"> <span class="keyword">if</span> (activeExpireCycleTryExpire(db,e,now)) expired++;</span><br><span class="line"> <span class="keyword">if</span> (ttl > <span class="number">0</span>) {</span><br><span class="line"> <span class="comment">/* We want the average TTL of keys yet</span></span><br><span class="line"><span class="comment"> * not expired. */</span></span><br><span class="line"> ttl_sum += ttl;</span><br><span class="line"> ttl_samples++;</span><br><span class="line"> }</span><br><span class="line"> sampled++;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> db->expires_cursor++;</span><br><span class="line"> }</span><br><span class="line"> total_expired += expired;</span><br><span class="line"> total_sampled += sampled;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Update the average TTL stats for this database. */</span></span><br><span class="line"> <span class="keyword">if</span> (ttl_samples) {</span><br><span class="line"> <span class="keyword">long</span> <span class="keyword">long</span> avg_ttl = ttl_sum/ttl_samples;</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Do a simple running average with a few samples.</span></span><br><span class="line"><span class="comment"> * We just use the current estimate with a weight of 2%</span></span><br><span class="line"><span class="comment"> * and the previous estimate with a weight of 98%. */</span></span><br><span class="line"> <span class="keyword">if</span> (db->avg_ttl == <span class="number">0</span>) db->avg_ttl = avg_ttl;</span><br><span class="line"> db->avg_ttl = (db->avg_ttl/<span class="number">50</span>)*<span class="number">49</span> + (avg_ttl/<span class="number">50</span>);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* We can't block forever here even if there are many keys to</span></span><br><span class="line"><span class="comment"> * expire. So after a given amount of milliseconds return to the</span></span><br><span class="line"><span class="comment"> * caller waiting for the other active expire cycle. */</span></span><br><span class="line"> <span class="keyword">if</span> ((iteration & <span class="number">0xf</span>) == <span class="number">0</span>) { <span class="comment">/* check once every 16 iterations. */</span></span><br><span class="line"> elapsed = ustime()-start;</span><br><span class="line"> <span class="keyword">if</span> (elapsed > timelimit) {</span><br><span class="line"> timelimit_exit = <span class="number">1</span>;</span><br><span class="line"> server.stat_expired_time_cap_reached_count++;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">/* We don't repeat the cycle for the current database if there are</span></span><br><span class="line"><span class="comment"> * an acceptable amount of stale keys (logically expired but yet</span></span><br><span class="line"><span class="comment"> * not reclained). */</span></span><br><span class="line"> } <span class="keyword">while</span> ((expired*<span class="number">100</span>/sampled) > config_cycle_acceptable_stale);</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> elapsed = ustime()-start;</span><br><span class="line"> server.stat_expire_cycle_time_used += elapsed;</span><br><span class="line"> latencyAddSampleIfNeeded(<span class="string">"expire-cycle"</span>,elapsed/<span class="number">1000</span>);</span><br><span class="line"></span><br><span class="line"> <span class="comment">/* Update our estimate of keys existing but yet to be expired.</span></span><br><span class="line"><span class="comment"> * Running average with this sample accounting for 5%. */</span></span><br><span class="line"> <span class="keyword">double</span> current_perc;</span><br><span class="line"> <span class="keyword">if</span> (total_sampled) {</span><br><span class="line"> current_perc = (<span class="keyword">double</span>)total_expired/total_sampled;</span><br><span class="line"> } <span class="keyword">else</span></span><br><span class="line"> current_perc = <span class="number">0</span>;</span><br><span class="line"> server.stat_expired_stale_perc = (current_perc*<span class="number">0.05</span>)+</span><br><span class="line"> (server.stat_expired_stale_perc*<span class="number">0.95</span>);</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
<p>执行定期清除分成两种类型，快和慢，分别由<code>beforeSleep</code>和<code>databasesCron</code>调用，快版有两个限制，一个是执行时长由ACTIVE_EXPIRE_CYCLE_FAST_DURATION限制，另一个是执行间隔是 2 倍的ACTIVE_EXPIRE_CYCLE_FAST_DURATION，另外这还可以由配置的server.active_expire_effort参数来控制，默认是 1，最大是 10</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">onfig_cycle_fast_duration = ACTIVE_EXPIRE_CYCLE_FAST_DURATION +</span><br><span class="line"> ACTIVE_EXPIRE_CYCLE_FAST_DURATION/<span class="number">4</span>*effort</span><br></pre></td></tr></table></figure>
|
|
<p>然后会从一定数量的 db 中找出一定数量的带过期时间的 key（保存在 expires中），这里的数量是由</p>
|
|
<figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">config_keys_per_loop = ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP +</span><br><span class="line"> ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP/<span class="number">4</span>*effort</span><br><span class="line">``` </span><br><span class="line">控制，慢速的执行时长是</span><br><span class="line">```C</span><br><span class="line">config_cycle_slow_time_perc = ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC +</span><br><span class="line"> <span class="number">2</span>*effort</span><br><span class="line">timelimit = config_cycle_slow_time_perc*<span class="number">1000000</span>/server.hz/<span class="number">100</span>;</span><br></pre></td></tr></table></figure>
|
|
<p>这里还有一个额外的退出条件，如果当前数据库的抽样结果已经达到我们所允许的过期 key 百分比，则下次不再处理当前 db，继续处理下个 db</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/04/05/Comparator%E4%BD%BF%E7%94%A8%E5%B0%8F%E8%AE%B0/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/04/05/Comparator%E4%BD%BF%E7%94%A8%E5%B0%8F%E8%AE%B0/" class="post-title-link" itemprop="url">Comparator使用小记</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
|
|
<time title="Created: 2020-04-05 21:41:41 / Modified: 21:42:20" itemprop="dateCreated datePublished" datetime="2020-04-05T21:41:41+08:00">2020-04-05</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Java/" itemprop="url" rel="index"><span itemprop="name">Java</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Java/%E9%9B%86%E5%90%88/" itemprop="url" rel="index"><span itemprop="name">集合</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/04/05/Comparator%E4%BD%BF%E7%94%A8%E5%B0%8F%E8%AE%B0/" class="post-meta-item leancloud_visitors" data-flag-title="Comparator使用小记" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/04/05/Comparator%E4%BD%BF%E7%94%A8%E5%B0%8F%E8%AE%B0/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/04/05/Comparator使用小记/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<p>在Java8的stream之前，将对象进行排序的时候，可能需要对象实现Comparable接口，或者自己实现一个Comparator，</p>
|
|
<p>比如这样子</p>
|
|
<p>我的对象是Entity</p>
|
|
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">public</span> <span class="class"><span class="keyword">class</span> <span class="title">Entity</span> </span>{</span><br><span class="line"></span><br><span class="line"> <span class="keyword">private</span> Long id;</span><br><span class="line"></span><br><span class="line"> <span class="keyword">private</span> Long sortValue;</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">public</span> Long <span class="title">getId</span><span class="params">()</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> id;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title">setId</span><span class="params">(Long id)</span> </span>{</span><br><span class="line"> <span class="keyword">this</span>.id = id;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">public</span> Long <span class="title">getSortValue</span><span class="params">()</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> sortValue;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">public</span> <span class="keyword">void</span> <span class="title">setSortValue</span><span class="params">(Long sortValue)</span> </span>{</span><br><span class="line"> <span class="keyword">this</span>.sortValue = sortValue;</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
|
|
<p>Comparator</p>
|
|
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">public</span> <span class="class"><span class="keyword">class</span> <span class="title">MyComparator</span> <span class="keyword">implements</span> <span class="title">Comparator</span> </span>{</span><br><span class="line"> <span class="meta">@Override</span></span><br><span class="line"> <span class="function"><span class="keyword">public</span> <span class="keyword">int</span> <span class="title">compare</span><span class="params">(Object o1, Object o2)</span> </span>{</span><br><span class="line"> Entity e1 = (Entity) o1;</span><br><span class="line"> Entity e2 = (Entity) o2;</span><br><span class="line"> <span class="keyword">if</span> (e1.getSortValue() < e2.getSortValue()) {</span><br><span class="line"> <span class="keyword">return</span> -<span class="number">1</span>;</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (e1.getSortValue().equals(e2.getSortValue())) {</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
|
|
|
|
<p>比较代码</p>
|
|
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">private</span> <span class="keyword">static</span> MyComparator myComparator = <span class="keyword">new</span> MyComparator();</span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="keyword">public</span> <span class="keyword">static</span> <span class="keyword">void</span> <span class="title">main</span><span class="params">(String[] args)</span> </span>{</span><br><span class="line"> List<Entity> list = <span class="keyword">new</span> ArrayList<Entity>();</span><br><span class="line"> Entity e1 = <span class="keyword">new</span> Entity();</span><br><span class="line"> e1.setId(<span class="number">1L</span>);</span><br><span class="line"> e1.setSortValue(<span class="number">1L</span>);</span><br><span class="line"> list.add(e1);</span><br><span class="line"> Entity e2 = <span class="keyword">new</span> Entity();</span><br><span class="line"> e2.setId(<span class="number">2L</span>);</span><br><span class="line"> e2.setSortValue(<span class="keyword">null</span>);</span><br><span class="line"> list.add(e2);</span><br><span class="line"> Collections.sort(list, myComparator);</span><br></pre></td></tr></table></figure>
|
|
|
|
<p>看到这里的e2的排序值是null，在Comparator中如果要正常运行的话，就得判空之类的，这里有两点需要，一个是不想写这个MyComparator，然后也没那么好排除掉list里排序值，那么有什么办法能解决这种问题呢，应该说java的这方面真的是很强大</p>
|
|
<p><img data-src="https://i.loli.net/2020/04/05/8VfjeOSmcvx4dyk.png" alt=""></p>
|
|
<p>看一下nullsFirst的实现</p>
|
|
<figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">final</span> <span class="keyword">static</span> <span class="class"><span class="keyword">class</span> <span class="title">NullComparator</span><<span class="title">T</span>> <span class="keyword">implements</span> <span class="title">Comparator</span><<span class="title">T</span>>, <span class="title">Serializable</span> </span>{</span><br><span class="line"> <span class="keyword">private</span> <span class="keyword">static</span> <span class="keyword">final</span> <span class="keyword">long</span> serialVersionUID = -<span class="number">7569533591570686392L</span>;</span><br><span class="line"> <span class="keyword">private</span> <span class="keyword">final</span> <span class="keyword">boolean</span> nullFirst;</span><br><span class="line"> <span class="comment">// if null, non-null Ts are considered equal</span></span><br><span class="line"> <span class="keyword">private</span> <span class="keyword">final</span> Comparator<T> real;</span><br><span class="line"></span><br><span class="line"> <span class="meta">@SuppressWarnings</span>(<span class="string">"unchecked"</span>)</span><br><span class="line"> NullComparator(<span class="keyword">boolean</span> nullFirst, Comparator<? <span class="keyword">super</span> T> real) {</span><br><span class="line"> <span class="keyword">this</span>.nullFirst = nullFirst;</span><br><span class="line"> <span class="keyword">this</span>.real = (Comparator<T>) real;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="meta">@Override</span></span><br><span class="line"> <span class="function"><span class="keyword">public</span> <span class="keyword">int</span> <span class="title">compare</span><span class="params">(T a, T b)</span> </span>{</span><br><span class="line"> <span class="keyword">if</span> (a == <span class="keyword">null</span>) {</span><br><span class="line"> <span class="keyword">return</span> (b == <span class="keyword">null</span>) ? <span class="number">0</span> : (nullFirst ? -<span class="number">1</span> : <span class="number">1</span>);</span><br><span class="line"> } <span class="keyword">else</span> <span class="keyword">if</span> (b == <span class="keyword">null</span>) {</span><br><span class="line"> <span class="keyword">return</span> nullFirst ? <span class="number">1</span>: -<span class="number">1</span>;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> <span class="keyword">return</span> (real == <span class="keyword">null</span>) ? <span class="number">0</span> : real.compare(a, b);</span><br><span class="line"> }</span><br><span class="line"> }</span><br></pre></td></tr></table></figure>
|
|
|
|
<p>核心代码就是下面这段，其实就是帮我们把前面要做的事情做掉了，是不是挺方便的，小记一下哈</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/03/29/echo%E5%91%BD%E4%BB%A4%E7%9A%84%E4%B8%80%E4%B8%AA%E5%B0%8F%E6%8A%80%E5%B7%A7/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/03/29/echo%E5%91%BD%E4%BB%A4%E7%9A%84%E4%B8%80%E4%B8%AA%E5%B0%8F%E6%8A%80%E5%B7%A7/" class="post-title-link" itemprop="url">docker使用中发现的echo命令的一个小技巧及其他</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
<time title="Created: 2020-03-29 21:48:50" itemprop="dateCreated datePublished" datetime="2020-03-29T21:48:50+08:00">2020-03-29</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Docker/" itemprop="url" rel="index"><span itemprop="name">Docker</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Linux/" itemprop="url" rel="index"><span itemprop="name">Linux</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Linux/%E5%91%BD%E4%BB%A4/" itemprop="url" rel="index"><span itemprop="name">命令</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Linux/%E5%91%BD%E4%BB%A4/echo/" itemprop="url" rel="index"><span itemprop="name">echo</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Docker/%E5%8F%91%E8%A1%8C%E7%89%88%E6%9C%AC/" itemprop="url" rel="index"><span itemprop="name">发行版本</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/03/29/echo%E5%91%BD%E4%BB%A4%E7%9A%84%E4%B8%80%E4%B8%AA%E5%B0%8F%E6%8A%80%E5%B7%A7/" class="post-meta-item leancloud_visitors" data-flag-title="docker使用中发现的echo命令的一个小技巧及其他" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/03/29/echo%E5%91%BD%E4%BB%A4%E7%9A%84%E4%B8%80%E4%B8%AA%E5%B0%8F%E6%8A%80%E5%B7%A7/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/03/29/echo命令的一个小技巧/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<p>最近做 docker 系列，会经常进到 docker 内部，如上一篇介绍的，这些镜像一般都有用 ubuntu 或者alpine 这样的 Linux 系统作为底包，如果构建镜像的时候没有替换源的话，因为你懂的原因，在内部想编辑下东西要安装 vim 就会很慢很慢，thousand years later~<br>而且如果在容器内部想改源配置的话也要编辑器，就陷入了一个鸡生蛋，跟蛋生鸡的问题中，对于 linux 大神来说应该有一万种方法解决这个问题，对于我这个渣渣来说可能只想到了这个土方法，先 cp backup 一下 sources.list, 再 echo “xxx” > sources.list, 这里就碰到了一个问题，这个 sources.list 一般不止一行，直接 echo 的话就解析不了了，不过 echo 可以支持”\n”转义，就是加-e<br>看一下解释和示例<br><img data-src="https://i.loli.net/2020/03/23/4vlxSOuR2DdF5kp.png" alt=""><br>还有一点也是在这个时候要安装 vim 之类的，得知道是什么镜像底包，如果是用 uname 指令，其实看到的是宿主机的系统，得用<code>cat /etc/issue</code><br><img data-src="https://i.loli.net/2020/03/29/mh5YxdDnX3VSkg8.png" alt=""><br>这里稍稍记一下</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-Hans">
|
|
<link itemprop="mainEntityOfPage" href="https://nicksxs.me/2020/03/21/docker%E6%AF%94%E4%B8%80%E8%88%AC%E5%A4%9A%E4%B8%80%E7%82%B9%E7%9A%84%E5%88%9D%E5%AD%A6%E8%80%85%E4%BB%8B%E7%BB%8D%E4%B8%89/">
|
|
|
|
<span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<meta itemprop="image" content="/uploads/avatar.jpg">
|
|
<meta itemprop="name" content="Nicksxs">
|
|
<meta itemprop="description" content="learn from zero,技术博客，Nicksxs，史学森">
|
|
</span>
|
|
|
|
<span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
|
|
<meta itemprop="name" content="Nicksxs's Blog">
|
|
</span>
|
|
<header class="post-header">
|
|
<h2 class="post-title" itemprop="name headline">
|
|
|
|
<a href="/2020/03/21/docker%E6%AF%94%E4%B8%80%E8%88%AC%E5%A4%9A%E4%B8%80%E7%82%B9%E7%9A%84%E5%88%9D%E5%AD%A6%E8%80%85%E4%BB%8B%E7%BB%8D%E4%B8%89/" class="post-title-link" itemprop="url">docker比一般多一点的初学者介绍三</a>
|
|
</h2>
|
|
|
|
<div class="post-meta">
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-calendar"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Posted on</span>
|
|
|
|
|
|
<time title="Created: 2020-03-21 14:43:39 / Modified: 16:19:01" itemprop="dateCreated datePublished" datetime="2020-03-21T14:43:39+08:00">2020-03-21</time>
|
|
</span>
|
|
<span class="post-meta-item">
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-folder"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">In</span>
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Docker/" itemprop="url" rel="index"><span itemprop="name">Docker</span></a>
|
|
</span>
|
|
,
|
|
<span itemprop="about" itemscope itemtype="http://schema.org/Thing">
|
|
<a href="/categories/Docker/%E4%BB%8B%E7%BB%8D/" itemprop="url" rel="index"><span itemprop="name">介绍</span></a>
|
|
</span>
|
|
</span>
|
|
|
|
|
|
<span id="/2020/03/21/docker%E6%AF%94%E4%B8%80%E8%88%AC%E5%A4%9A%E4%B8%80%E7%82%B9%E7%9A%84%E5%88%9D%E5%AD%A6%E8%80%85%E4%BB%8B%E7%BB%8D%E4%B8%89/" class="post-meta-item leancloud_visitors" data-flag-title="docker比一般多一点的初学者介绍三" title="Views">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Views: </span>
|
|
<span class="leancloud-visitors-count"></span>
|
|
</span>
|
|
|
|
<span class="post-meta-item">
|
|
|
|
<span class="post-meta-item-icon">
|
|
<i class="far fa-comment"></i>
|
|
</span>
|
|
<span class="post-meta-item-text">Disqus: </span>
|
|
|
|
<a title="disqus" href="/2020/03/21/docker%E6%AF%94%E4%B8%80%E8%88%AC%E5%A4%9A%E4%B8%80%E7%82%B9%E7%9A%84%E5%88%9D%E5%AD%A6%E8%80%85%E4%BB%8B%E7%BB%8D%E4%B8%89/#disqus_thread" itemprop="discussionUrl">
|
|
<span class="post-comments-count disqus-comment-count" data-disqus-identifier="2020/03/21/docker比一般多一点的初学者介绍三/" itemprop="commentCount"></span>
|
|
</a>
|
|
</span>
|
|
|
|
|
|
|
|
</div>
|
|
</header>
|
|
|
|
|
|
|
|
|
|
<div class="post-body" itemprop="articleBody">
|
|
|
|
|
|
<h2 id="运行第一个-Dockerfile"><a href="#运行第一个-Dockerfile" class="headerlink" title="运行第一个 Dockerfile"></a>运行第一个 Dockerfile</h2><p>上一篇的 Dockerfile 我们停留在构建阶段，现在来把它跑起来</p>
|
|
<figure class="highlight shell"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">docker run -d -p 80 --name static_web nicksxs/static_web \</span><br><span class="line">nginx -g "daemon off;"</span><br></pre></td></tr></table></figure>
|
|
<p>这里的<code>-d</code>表示以分离模型运行docker (detached),然后-p 是表示将容器的 80 端口开放给宿主机，然后容器名就叫 static_web,使用了我们上次构建的 static_web 镜像，后面的是让 nginx 在前台运行<br><img data-src="https://i.loli.net/2020/03/21/VCEuf5BTopXNkcA.png" alt=""><br>可以看到返回了个容器 id，但是具体情况没出现，也没连上去，那我们想看看怎么访问在 Dockerfile 里写的静态页面，我们来看下docker 进程<br><img data-src="https://i.loli.net/2020/03/21/Cx1JYGBrHRqojpz.png" alt=""><br>发现为我们随机分配了一个宿主机的端口，32768，去服务器的防火墙把这个外网端口开一下，看看是不是符合我们的预期呢<br><img data-src="https://i.loli.net/2020/03/21/xhAcQlX5iP9KnYB.png" alt=""><br>好像不太对额，应该是 ubuntu 安装的 nginx 的默认工作目录不对，我们来进容器看看，再熟悉下命令<code>docker exec -it 4792455ca2ed /bin/bash</code><br>记得容器 id 换成自己的，进入容器后得找找 nginx 的配置文件，通常在<code>/etc/nginx</code>,<code>/usr/local/etc</code>等目录下，然后找到我们的目录是在这<br><img data-src="https://i.loli.net/2020/03/21/wE8TfkbC2d9pNuv.png" alt=""><br>所以把刚才的内容复制过去再试试<br><img data-src="https://i.loli.net/2020/03/21/qNkpHn3GW8aiwIr.png" alt=""><br>目标达成，give me five✌️</p>
|
|
<h2 id="第二个-Dockerfile"><a href="#第二个-Dockerfile" class="headerlink" title="第二个 Dockerfile"></a>第二个 Dockerfile</h2><p>然后就想来动态一点的，毕竟写过 PHP，就来试试 PHP<br>再建一个目录叫 dynamic_web，里面创建 src 目录，放一个 index.php<br>内容是</p>
|
|
<figure class="highlight php"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta"><?php</span></span><br><span class="line"><span class="keyword">echo</span> <span class="string">"Hello World!"</span>;</span><br></pre></td></tr></table></figure>
|
|
<p>然后在 dynamic_web 目录下创建 Dockerfile，</p>
|
|
<figure class="highlight dockerfile"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">FROM</span> trafex/alpine-nginx-php7:latest</span><br><span class="line"><span class="keyword">COPY</span><span class="bash"> src/ /var/www/html</span></span><br><span class="line"><span class="keyword">EXPOSE</span> <span class="number">80</span></span><br></pre></td></tr></table></figure>
|
|
<p>Dockerfile 虽然只有三行，不过要着重说明下，这个底包其实不是docker 官方的，有两点考虑，一点是官方的基本都是 php apache 的镜像，还有就是 alpine这个，截取一段中文介绍</p>
|
|
<blockquote>
|
|
<p>Alpine 操作系统是一个面向安全的轻型 Linux 发行版。它不同于通常 Linux 发行版，Alpine 采用了 musl libc 和 busybox 以减小系统的体积和运行时资源消耗，但功能上比 busybox 又完善的多，因此得到开源社区越来越多的青睐。在保持瘦身的同时，Alpine 还提供了自己的包管理工具 apk，可以通过 <a href="https://pkgs.alpinelinux.org/packages" target="_blank" rel="noopener">https://pkgs.alpinelinux.org/packages</a> 网站上查询包信息，也可以直接通过 apk 命令直接查询和安装各种软件。<br>Alpine 由非商业组织维护的，支持广泛场景的 Linux发行版，它特别为资深/重度Linux用户而优化，关注安全，性能和资源效能。Alpine 镜像可以适用于更多常用场景，并且是一个优秀的可以适用于生产的基础系统/环境。</p>
|
|
</blockquote>
|
|
<blockquote>
|
|
<p>Alpine Docker 镜像也继承了 Alpine Linux 发行版的这些优势。相比于其他 Docker 镜像，它的容量非常小，仅仅只有 5 MB 左右（对比 Ubuntu 系列镜像接近 200 MB），且拥有非常友好的包管理机制。官方镜像来自 docker-alpine 项目。</p>
|
|
</blockquote>
|
|
<blockquote>
|
|
<p>目前 Docker 官方已开始推荐使用 Alpine 替代之前的 Ubuntu 做为基础镜像环境。这样会带来多个好处。包括镜像下载速度加快，镜像安全性提高，主机之间的切换更方便，占用更少磁盘空间等。 </p>
|
|
</blockquote>
|
|
<p>一方面在没有镜像的情况下，拉取 docker 镜像还是比较费力的，第二个就是也能节省硬盘空间，所以目前有大部分的 docker 镜像都将 alpine 作为基础镜像了<br>然后再来构建下<br><img data-src="https://i.loli.net/2020/03/21/56cuKf1ObvkBSG3.png" alt=""><br>这里还有个点，就是上面的那个镜像我们也是 EXPOSE 80端口，然后外部宿主机会随机映射一个端口，为了偷个懒，我们就直接指定外部端口了<br><code>docker run -d -p 80:80 dynamic_web</code>打开浏览器发现访问不了，咋回事呢<br>因为我们没看<code>trafex/alpine-nginx-php7:latest</code>这个镜像<a href="https://hub.docker.com/r/trafex/alpine-nginx-php7" target="_blank" rel="noopener">说明</a>,它内部的服务是 8080 端口的，所以我们映射的暴露端口应该是 8080，再用<code>docker run -d -p 80:8080 dynamic_web</code>这个启动，<br><img data-src="https://i.loli.net/2020/03/21/qDd2LVhz1Po4McX.png" alt=""></p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<footer class="post-footer">
|
|
<div class="post-eof"></div>
|
|
</footer>
|
|
</article>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<nav class="pagination">
|
|
<span class="page-number current">1</span><a class="page-number" href="/page/2/">2</a><span class="space">…</span><a class="page-number" href="/page/6/">6</a><a class="extend next" rel="next" href="/page/2/"><i class="fa fa-angle-right" aria-label="Next page"></i></a>
|
|
</nav>
|
|
|
|
|
|
|
|
</div>
|
|
|
|
|
|
<script>
|
|
window.addEventListener('tabs:register', () => {
|
|
let { activeClass } = CONFIG.comments;
|
|
if (CONFIG.comments.storage) {
|
|
activeClass = localStorage.getItem('comments_active') || activeClass;
|
|
}
|
|
if (activeClass) {
|
|
let activeTab = document.querySelector(`a[href="#comment-${activeClass}"]`);
|
|
if (activeTab) {
|
|
activeTab.click();
|
|
}
|
|
}
|
|
});
|
|
if (CONFIG.comments.storage) {
|
|
window.addEventListener('tabs:click', event => {
|
|
if (!event.target.matches('.tabs-comment .tab-content .tab-pane')) return;
|
|
let commentClass = event.target.classList[1];
|
|
localStorage.setItem('comments_active', commentClass);
|
|
});
|
|
}
|
|
</script>
|
|
|
|
</div>
|
|
|
|
|
|
<div class="toggle sidebar-toggle">
|
|
<span class="toggle-line toggle-line-first"></span>
|
|
<span class="toggle-line toggle-line-middle"></span>
|
|
<span class="toggle-line toggle-line-last"></span>
|
|
</div>
|
|
|
|
<aside class="sidebar">
|
|
<div class="sidebar-inner">
|
|
|
|
<ul class="sidebar-nav motion-element">
|
|
<li class="sidebar-nav-toc">
|
|
Table of Contents
|
|
</li>
|
|
<li class="sidebar-nav-overview">
|
|
Overview
|
|
</li>
|
|
</ul>
|
|
|
|
<!--noindex-->
|
|
<div class="post-toc-wrap sidebar-panel">
|
|
</div>
|
|
<!--/noindex-->
|
|
|
|
<div class="site-overview-wrap sidebar-panel">
|
|
<div class="site-author motion-element" itemprop="author" itemscope itemtype="http://schema.org/Person">
|
|
<img class="site-author-image" itemprop="image" alt="Nicksxs"
|
|
src="/uploads/avatar.jpg">
|
|
<p class="site-author-name" itemprop="name">Nicksxs</p>
|
|
<div class="site-description" itemprop="description">learn from zero,技术博客，Nicksxs，史学森</div>
|
|
</div>
|
|
<div class="site-state-wrap motion-element">
|
|
<nav class="site-state">
|
|
<div class="site-state-item site-state-posts">
|
|
<a href="/archives/">
|
|
|
|
<span class="site-state-item-count">51</span>
|
|
<span class="site-state-item-name">posts</span>
|
|
</a>
|
|
</div>
|
|
<div class="site-state-item site-state-categories">
|
|
<a href="/categories/">
|
|
|
|
<span class="site-state-item-count">44</span>
|
|
<span class="site-state-item-name">categories</span></a>
|
|
</div>
|
|
<div class="site-state-item site-state-tags">
|
|
<a href="/tags/">
|
|
|
|
<span class="site-state-item-count">69</span>
|
|
<span class="site-state-item-name">tags</span></a>
|
|
</div>
|
|
</nav>
|
|
</div>
|
|
<div class="links-of-author motion-element">
|
|
<span class="links-of-author-item">
|
|
<a href="https://github.com/nicksxs" title="GitHub → https://github.com/nicksxs" rel="noopener" target="_blank"><i class="github fa-fw"></i>GitHub</a>
|
|
</span>
|
|
<span class="links-of-author-item">
|
|
<a href="mailto:nicksxs1202@gmail.com" title="E-Mail → mailto:nicksxs1202@gmail.com" rel="noopener" target="_blank"><i class="envelope fa-fw"></i>E-Mail</a>
|
|
</span>
|
|
<span class="links-of-author-item">
|
|
<a href="/atom.xml" title="RSS → /atom.xml"><i class="rss fa-fw"></i>RSS</a>
|
|
</span>
|
|
</div>
|
|
<div class="cc-license motion-element" itemprop="license">
|
|
<a href="https://creativecommons.org/licenses/by-nc-sa/4.0/" class="cc-opacity" rel="noopener" target="_blank"><img src="/images/cc-by-nc-sa.svg" alt="Creative Commons"></a>
|
|
</div>
|
|
|
|
<script type="text/javascript" charset="utf-8" src="/js/tagcloud.js"></script>
|
|
<script type="text/javascript" charset="utf-8" src="/js/tagcanvas.js"></script>
|
|
<div class="widget-wrap">
|
|
<div id="myCanvasContainer" class="widget tagcloud">
|
|
<canvas width="250" height="250" id="resCanvas" style="width=100%">
|
|
<ul class="tag-list" itemprop="keywords"><li class="tag-list-item"><a class="tag-list-link" href="/tags/2019/" rel="tag">2019</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/2PC/" rel="tag">2PC</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/3PC/" rel="tag">3PC</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/C/" rel="tag">C</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/C/" rel="tag">C++</a><span class="tag-list-count">3</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Comparator/" rel="tag">Comparator</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Design-Patterns/" rel="tag">Design Patterns</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Distributed-Lock/" rel="tag">Distributed Lock</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Docker/" rel="tag">Docker</a><span class="tag-list-count">4</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Dockerfile/" rel="tag">Dockerfile</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/G1/" rel="tag">G1</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/GC/" rel="tag">GC</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Garbage-First-Collector/" rel="tag">Garbage-First Collector</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Gogs/" rel="tag">Gogs</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/JVM/" rel="tag">JVM</a><span class="tag-list-count">2</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Java/" rel="tag">Java</a><span class="tag-list-count">5</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Maven/" rel="tag">Maven</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Redis/" rel="tag">Redis</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Singleton/" rel="tag">Singleton</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Stream/" rel="tag">Stream</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Thread-dump/" rel="tag">Thread dump</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/Webhook/" rel="tag">Webhook</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/aqs/" rel="tag">aqs</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/c/" rel="tag">c++</a><span class="tag-list-count">14</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/cgroup/" rel="tag">cgroup</a><span class="tag-list-count">2</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/cluster/" rel="tag">cluster</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/docker/" rel="tag">docker</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/echo/" rel="tag">echo</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/gap-lock/" rel="tag">gap lock</a><span class="tag-list-count">2</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/hadoop/" rel="tag">hadoop</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/im/" rel="tag">im</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/java/" rel="tag">java</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/leetcode/" rel="tag">leetcode</a><span class="tag-list-count">13</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/linux/" rel="tag">linux</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/mfc/" rel="tag">mfc</a><span class="tag-list-count">2</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/mq/" rel="tag">mq</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/mvcc/" rel="tag">mvcc</a><span class="tag-list-count">3</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/mysql/" rel="tag">mysql</a><span class="tag-list-count">4</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/namespace/" rel="tag">namespace</a><span class="tag-list-count">3</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/next-key-lock/" rel="tag">next-key lock</a><span class="tag-list-count">2</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/nginx/" rel="tag">nginx</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/nullsfirst/" rel="tag">nullsfirst</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/openresty/" rel="tag">openresty</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/php/" rel="tag">php</a><span class="tag-list-count">2</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/python/" rel="tag">python</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/read-view/" rel="tag">read view</a><span class="tag-list-count">3</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/redis/" rel="tag">redis</a><span class="tag-list-count">8</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/sort/" rel="tag">sort</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/spark/" rel="tag">spark</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/swoole/" rel="tag">swoole</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/uname/" rel="tag">uname</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/websocket/" rel="tag">websocket</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E4%B8%89%E9%98%B6%E6%AE%B5%E6%8F%90%E4%BA%A4/" rel="tag">三阶段提交</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E4%B8%A4%E9%98%B6%E6%AE%B5%E6%8F%90%E4%BA%A4/" rel="tag">两阶段提交</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1/" rel="tag">分布式事务</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81/" rel="tag">分布式锁</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%8D%95%E4%BE%8B/" rel="tag">单例</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%8D%9A%E5%AE%A2%EF%BC%8C%E6%96%87%E7%AB%A0/" rel="tag">博客，文章</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%8F%91%E8%A1%8C%E7%89%88/" rel="tag">发行版</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%AF%84%E7%94%9F%E8%99%AB/" rel="tag">寄生虫</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%B9%B4%E7%BB%88%E6%80%BB%E7%BB%93/" rel="tag">年终总结</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%B9%BB%E8%AF%BB/" rel="tag">幻读</a><span class="tag-list-count">2</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E5%BD%B1%E8%AF%84/" rel="tag">影评</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E6%8E%92%E5%BA%8F/" rel="tag">排序</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/" rel="tag">数据结构</a><span class="tag-list-count">11</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E6%BA%90%E7%A0%81/" rel="tag">源码</a><span class="tag-list-count">11</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E7%94%9F%E6%B4%BB/" rel="tag">生活</a><span class="tag-list-count">2</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/" rel="tag">设计模式</a><span class="tag-list-count">1</span></li><li class="tag-list-item"><a class="tag-list-link" href="/tags/%E8%AF%BB%E5%90%8E%E6%84%9F/" rel="tag">读后感</a><span class="tag-list-count">1</span></li></ul>
|
|
</canvas>
|
|
</div>
|
|
</div>
|
|
|
|
|
|
|
|
<div class="links-of-blogroll motion-element">
|
|
<div class="links-of-blogroll-title"><i class="fa fa-link fa-fw"></i>
|
|
Links
|
|
</div>
|
|
<ul class="links-of-blogroll-list">
|
|
<li class="links-of-blogroll-item">
|
|
<a href="http://www.zipperary.com/" title="http://www.zipperary.com/" rel="noopener" target="_blank">Zippera's blog</a>
|
|
</li>
|
|
<li class="links-of-blogroll-item">
|
|
<a href="http://x20a.xyz/" title="http://x20a.xyz/" rel="noopener" target="_blank">Freedom</a>
|
|
</li>
|
|
<li class="links-of-blogroll-item">
|
|
<a href="http://samuel.group/" title="http://samuel.group/" rel="noopener" target="_blank">sfwtt</a>
|
|
</li>
|
|
<li class="links-of-blogroll-item">
|
|
<a href="http://blog.leanote.com/buru" title="http://blog.leanote.com/buru" rel="noopener" target="_blank">bruce</a>
|
|
</li>
|
|
<li class="links-of-blogroll-item">
|
|
<a href="http://m2shad0w.com/" title="http://m2shad0w.com/" rel="noopener" target="_blank">m2shad0w</a>
|
|
</li>
|
|
<li class="links-of-blogroll-item">
|
|
<a href="http://www.programcat.com/" title="http://www.programcat.com" rel="noopener" target="_blank">程序喵的厨房</a>
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
|
|
</div>
|
|
|
|
</div>
|
|
</aside>
|
|
<div id="sidebar-dimmer"></div>
|
|
|
|
|
|
</div>
|
|
</main>
|
|
|
|
<footer class="footer">
|
|
<div class="footer-inner">
|
|
|
|
|
|
|
|
|
|
<div class="copyright">
|
|
|
|
©
|
|
<span itemprop="copyrightYear">2020</span>
|
|
<span class="with-love">
|
|
<i class="fa fa-heart"></i>
|
|
</span>
|
|
<span class="author" itemprop="copyrightHolder">Nicksxs</span>
|
|
</div>
|
|
<div class="powered-by">Powered by <a href="https://hexo.io/" class="theme-link" rel="noopener" target="_blank">Hexo</a> & <a href="https://pisces.theme-next.org/" class="theme-link" rel="noopener" target="_blank">NexT.Pisces</a>
|
|
</div>
|
|
|
|
|
|
<div class="busuanzi-count">
|
|
<script async src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script>
|
|
<span class="post-meta-item" id="busuanzi_container_site_uv" style="display: none;">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-user"></i>
|
|
</span>
|
|
<span class="site-uv" title="Total Visitors">
|
|
<span id="busuanzi_value_site_uv"></span>
|
|
</span>
|
|
</span>
|
|
<span class="post-meta-divider">|</span>
|
|
<span class="post-meta-item" id="busuanzi_container_site_pv" style="display: none;">
|
|
<span class="post-meta-item-icon">
|
|
<i class="fa fa-eye"></i>
|
|
</span>
|
|
<span class="site-pv" title="Total Views">
|
|
<span id="busuanzi_value_site_pv"></span>
|
|
</span>
|
|
</span>
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<script>
|
|
(function() {
|
|
function leancloudSelector(url) {
|
|
url = encodeURI(url);
|
|
return document.getElementById(url).querySelector('.leancloud-visitors-count');
|
|
}
|
|
|
|
function addCount(Counter) {
|
|
var visitors = document.querySelector('.leancloud_visitors');
|
|
var url = decodeURI(visitors.id);
|
|
var title = visitors.dataset.flagTitle;
|
|
|
|
Counter('get', '/classes/Counter?where=' + encodeURIComponent(JSON.stringify({ url })))
|
|
.then(response => response.json())
|
|
.then(({ results }) => {
|
|
if (results.length > 0) {
|
|
var counter = results[0];
|
|
leancloudSelector(url).innerText = counter.time + 1;
|
|
Counter('put', '/classes/Counter/' + counter.objectId, { time: { '__op': 'Increment', 'amount': 1 } })
|
|
.catch(error => {
|
|
console.error('Failed to save visitor count', error);
|
|
});
|
|
} else {
|
|
leancloudSelector(url).innerText = 'Counter not initialized! More info at console err msg.';
|
|
console.error('ATTENTION! LeanCloud counter has security bug, see how to solve it here: https://github.com/theme-next/hexo-leancloud-counter-security. \n However, you can still use LeanCloud without security, by setting `security` option to `false`.');
|
|
|
|
}
|
|
})
|
|
.catch(error => {
|
|
console.error('LeanCloud Counter Error', error);
|
|
});
|
|
}
|
|
|
|
function showTime(Counter) {
|
|
var visitors = document.querySelectorAll('.leancloud_visitors');
|
|
var entries = [...visitors].map(element => {
|
|
return decodeURI(element.id);
|
|
});
|
|
|
|
Counter('get', '/classes/Counter?where=' + encodeURIComponent(JSON.stringify({ url: { '$in': entries } })))
|
|
.then(response => response.json())
|
|
.then(({ results }) => {
|
|
for (let url of entries) {
|
|
let target = results.find(item => item.url === url);
|
|
leancloudSelector(url).innerText = target ? target.time : 0;
|
|
}
|
|
})
|
|
.catch(error => {
|
|
console.error('LeanCloud Counter Error', error);
|
|
});
|
|
}
|
|
|
|
let { app_id, app_key, server_url } = {"enable":true,"app_id":"ysza182Vghlqjdt7QiwGLLJy-gzGzoHsz","app_key":"s9GDqbn7gnGGkusf66YRVccw","server_url":"https://leancloud.cn","security":true};
|
|
function fetchData(api_server) {
|
|
var Counter = (method, url, data) => {
|
|
return fetch(`${api_server}/1.1${url}`, {
|
|
method,
|
|
headers: {
|
|
'X-LC-Id' : app_id,
|
|
'X-LC-Key' : app_key,
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: JSON.stringify(data)
|
|
});
|
|
};
|
|
if (CONFIG.page.isPost) {
|
|
if (CONFIG.hostname !== location.hostname) return;
|
|
addCount(Counter);
|
|
} else if (document.querySelectorAll('.post-title-link').length >= 1) {
|
|
showTime(Counter);
|
|
}
|
|
}
|
|
|
|
let api_server = app_id.slice(-9) !== '-MdYXbMMI' ? server_url : `https://${app_id.slice(0, 8).toLowerCase()}.api.lncldglobal.com`;
|
|
|
|
if (api_server) {
|
|
fetchData(api_server);
|
|
} else {
|
|
fetch('https://app-router.leancloud.cn/2/route?appId=' + app_id)
|
|
.then(response => response.json())
|
|
.then(({ api_server }) => {
|
|
fetchData('https://' + api_server);
|
|
});
|
|
}
|
|
})();
|
|
</script>
|
|
|
|
|
|
</div>
|
|
</footer>
|
|
</div>
|
|
|
|
|
|
<script src="/lib/anime.min.js"></script>
|
|
<script src="//cdn.jsdelivr.net/npm/jquery@3/dist/jquery.min.js"></script>
|
|
<script src="//cdn.jsdelivr.net/gh/fancyapps/fancybox@3/dist/jquery.fancybox.min.js"></script>
|
|
<script src="//cdn.jsdelivr.net/npm/lozad@1/dist/lozad.min.js"></script>
|
|
<script src="/lib/velocity/velocity.min.js"></script>
|
|
<script src="/lib/velocity/velocity.ui.min.js"></script>
|
|
|
|
<script src="/js/utils.js"></script>
|
|
|
|
<script src="/js/motion.js"></script>
|
|
|
|
|
|
<script src="/js/schemes/pisces.js"></script>
|
|
|
|
|
|
<script src="/js/next-boot.js"></script>
|
|
|
|
|
|
|
|
|
|
|
|
<script>
|
|
(function(){
|
|
var bp = document.createElement('script');
|
|
var curProtocol = window.location.protocol.split(':')[0];
|
|
bp.src = (curProtocol === 'https') ? 'https://zz.bdstatic.com/linksubmit/push.js' : 'http://push.zhanzhang.baidu.com/push.js';
|
|
var s = document.getElementsByTagName("script")[0];
|
|
s.parentNode.insertBefore(bp, s);
|
|
})();
|
|
</script>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<script>
|
|
function loadCount() {
|
|
var d = document, s = d.createElement('script');
|
|
s.src = 'https://nicksxs.disqus.com/count.js';
|
|
s.id = 'dsq-count-scr';
|
|
(d.head || d.body).appendChild(s);
|
|
}
|
|
// defer loading until the whole page loading is completed
|
|
window.addEventListener('load', loadCount, false);
|
|
</script>
|
|
|
|
</body>
|
|
</html>
|