引子

角色

先来看看这三种刷新中的两个角色…

• 存储单元：存数据的小弟，一行为一个单位（假设存储器有256行，每行有256列），这里有256行存储单元，这些孩子编号为0~255行————一次操作一行的存储单元~
• cpu：老大哥。从存储单元里面操作数据啦，一次取一行或者写一行的数据。

那么他们要做什么呢?自然是老大哥(cpu)想让小弟们(一行一行的存储单元)存或者写数据啦~

访问和刷新时…

但是，存储单元有一个特性：每隔一段时间得充电，也就是刷新，不然就会由于没电导致数据丢失（假设4ms内必须充电一次，这个4ms，也叫做最大刷新周期）。

那么，当cpu读取或者写入数据的时候，就会出现下面两种情况：

1. 正常情况：【cpu】：我来读/写数据啦！【某行小弟】：好的老大，我现在有电！这就把数据给您…（时间过了一个存储周期）老大再见！！！常来玩！（当某一行不在充电/刷新时，正常读写）
2. 死区：【cpu】：我来读/写数据啦！【某行小弟】：老大不好了！我可能快要没电了！，根据刷新规则！我得先充个电！等我先充个电去保护一下数据！！！老大过会再来呗！（当根据刷新规则，某一行进行刷新的这段时间，该行无法进行数据读写。此段用来刷新的时间称作死区）

一些特性

这里还得补充一点点：

1. cpu读/写数据是需要时间的，读/写一次所耗费的时间叫做存取周期（存储周期），同时我们假设存取周期为0.5us。
2. 某一行充一次电/刷新一次的时间，也等于一个存取周期（存储周期）。
3. 刷新间隔：所有存储单元都刷新一遍所需要的时间，也是两次所有存储单元开始刷新之间间隔的时间。

回过头来那么，上文的刷新规则是什么呢？

其实就是标题所指的三种刷新方式：集中式刷新、分散式刷新、异步式刷新。

集中式刷新

在一个刷新周期（4ms）内，所有的小弟们（存储单元行）约好了一起去刷新，由于一次只能刷新一行，一行刷新花费0.5us，故所有行一共花费256x0.5us的时间集中在一起去刷新（充电）

大概是这种感觉：
每4ms（4000us=8000个周期）中：
前7744个周期（3872us）cpu：正常的要求读写，存储单元们：正常的读写
后256个周期（0.5us*256=128us=256个周期）cpu：人呢？存储单元们：排队充电呢！（一行一行的排队，一行为一个单位）

前7744个周期就是正常的读/写或者维持周期，对应着上面“正常”的情况，后256个周期就是刷新周期，也就是死区，对应着上文“死区”的情况。

分散式刷新

每读取一次，某一行就刷新一次

每次cpu去读写某一行的时候，读完了，还没完事，还得等这一行刷新完成之后，才算完整的完成了一次存取周期。

这样悄悄的把刷新的时间融入到存取周期中，也就不存在单独用来刷新的时间了。

因为刷新时间就是死区，那么没有刷新时间就没有死区，所以分散式刷新不存在死区。

代价就是，由于把刷新时间融入到了存取周期中，导致存取T周期变长：Tc(新的存取周期)=Tm(原来的存取周期)+Tr(每一个周期完成一次存取之后立刻刷新)=0.5us+0.5ms=1us。所以整体的存取周期变长了，实际存取的效率也就下降了，虽然没有了死区。

打个比方，假如刷新就是摸鱼。
原来是：集中摸鱼，摸鱼这段时间不跟cpu工作（死区）。
现在是：看似不摸鱼了，所有时间都可以跟cpu工作（无死区），但是原来0.5us能干完的读写操作现在非得花1us才做完，这1us中实际上悄悄的摸鱼了0.5us（1us中有0.5ms用于刷新）

如此一来，倘若每次cpu都读写不同的行，则每隔256个1us的存取周期（256*（0.5+0.5））所有的行都可刷新一次，则任意一行的刷新间隔为256个存取周期，整体的刷新间隔（所有行都被刷新一次）的刷新间隔也为256个存取周期。

有的同学会问，这里分散刷新是只有读写操作的时候才刷新，如果某一行一直没有被cpu读写，或者cpu一直读写某一行？那是不是就会造成数据的丢失？

先说确定的结论：大家大可不必担心这个问题，因为“无关紧要”，只需要了解分散式刷新的原理以及“每次都应该会读写不同的行，存取周期加倍，刷新间隔是行数个周期”即可。

再说笔者的瞎掰愚见：提出这个问题的童鞋一定是非常善于思考的。这个问题的实质在我看来就和：为什么牛顿经典力学在微观中不适用但是在宏观中适用？原子内部有间隔甚至按照某些理论是按照概率在空间中出现，那么我是由很多原子构成的，是不是一直持续用力的撞墙也有概率“穿墙”？

这种问题有一些相同的特点：我们用微观的思考方式去考虑宏观的问题。为了大家理解“分散刷新”，所有的资料书或者教材都用微观且理想的一块存储器来举例子，并且告诉大家在微观当中发生了什么。但是在宏观中，如同“会不会一直读取某一行”或者“会不会一直不读某一行”这种在微观中有可能发生的事情发生的情况，就如同“在微观中原子确实有概率穿墙但在宏观中我们一直在撞墙”的情况一样，虽然确实在微观的角度下会发生，但是在一个实际的分散刷新的存储器中，以宏观视角来看，这样的事件也同理几乎不会发生。再用概率的视角来看，每一行被读/写的概率几乎相同，若把时间扩展到足够长，读取次数足够多（即从宏观的视角），每一行被读取的次数几乎是相同的，那么平均来看，从微观来看，我们也可以近似的看成cpu每一次都读/写了不同行。

当然有兴趣我觉得最好还是实际找一块真真实实的分散式刷新的存储芯片，实际看一看到底真实情况下分散刷新如何工作的，可能可以更好的回答这个问题。

异步式刷新

每一行只要在最大刷新周期（不刷新/充电就丢失数据的极限时间）内，找个每一行它自己觉得方便的时候刷新即可。

但是每次存储单元只能刷新一行，那么最多多久时间就必须刷新一行？从而保证每一行能在最大刷新周期内被刷新？

假设最大刷新周期为4ms，有256行且每一行必须在4ms内被刷新。

那么每隔4(ms)/256(行)=15.6(us/行)的时间就必须刷新一行（这个时间内任选0.5us来刷新），才能保证在一个最大刷新周期内，每一行都被刷新。

可能有些数感不太好的同学（比如笔者），在这里会有点晕。我们来验证一下，如果某一行在某一轮被刷新了，那么在给接下来的255轮刷新时（每一轮刷新一行），它都不会刷新（每一轮在刷新别的行呢！），它下一次刷新是在15.6us/行*255行之后，它要等256轮才会失去信息，所以就保证了数据的不丢失。

请看图：

可能有的同学还有点晕，不知道这个15.6us是什么东西。15.6us是刷新一行最多允许间隔的时间，换个说法，就是每隔15.6us必须刷新一行， 更容易混淆的说法叫做(存储器)每次刷新周期（间隔） 。因为从前面的计算不难看出，只有至少每15.6u刷新一行，才能保证在4ms这个极限刷新时间内，所有的行都被刷新，才能保证在每次刷新不同行的时候，每两行之间间隔的时间小于4ms。

在这个15.6的最小必须刷新一行的时间里，只有0.5us用于刷新某一行，剩下的15.1us（实际是15.0us，因为在这个例子中时间必须为0.5us的倍数）用于进行跟cpu的玩耍通信 。

所以说，异步式刷新所说的某行在Xms内至少刷新一次=每（Xms/行数）至少刷新一行。在上述的例子中，就是每4ms内至少刷新一次 = 每(4ms/256=15.6ms)至少刷新一行。

那么在这个例子中死区是多少呢？死区是0.5us，就是当cpu正好访问的那一行在这一轮刷新时正好就是它在刷新且正好在刷新，导致出现了无法访问的情况，就是死区了。同图片所述，将刷新安排在译码阶段，就可以避免死区~

简单的问题啰啰嗦嗦写了一大堆，还希望大家能够多加指点。

为什么DRAM需要刷新

DRAM(Dynamic Random Access Memory)即动态RAM,是我们熟知的内存,用在手机,电脑等设备当中用于存储数据与指令.通常所讲的RAM即指DRAM.DRAM由晶体管和小容电容存储单元组成。每个存储单元都有一小的蚀刻晶体管，这个晶体管通过小电容的电荷保持存储状态，即开和关。电容类似于小型充电电池。它可以用电压充电以代表1，放电后代表0，但是被充电的电容会因放电而丢掉电荷，所以它们必须由一新电荷持续地"刷新"。
接下来的例子我们以一个16K*1位的芯片来进行讲解.
16K->2¹⁴=(2⁷)²=(128×128)B,故该芯片有128*128根行线与列选择线.
而对DRAM刷新的方法是一次刷新完整的一行,即我们一共需要刷新128次共128行.
DRAM最大刷新周期：2ms，8ms，16ms等（DRAM在这些时间内会丢失电容，所以必须刷新).
我们假设最大刷新周期为2ms,即在间隔2ms的时间内,这128行必须全部刷新完毕,并设定存储周期为0.5us(即这0.5us将进行数据的读/写或一行的刷新)

集中刷新

集中刷新顾名思义,即在某一个时间段集中对这写行进行刷新.
首先我们计算出对128行刷新所需要的时间:
128*0.5us=64us(集中刷新时间)
2ms-64us=1936us(正常进行读写或维持电容内数据有效的时间)
故由于有着64us的时间需要对电容进行刷新,因此这一段时间称为"死区",即这段时间内CPU无法对DRAM进行访问.
优点:结构简单,实现简单
缺点:由于死区时间的导致,CPU在这段时间内无法进行大部分的工作,这是由于CPU所需要的部分指令是需要从内存中取得的

分散刷新

分散刷新的含义即对每一行进行独立的刷新,其实现方法为:
对于该行,前0.5us进行数据正常的存取,后0.5us进行该行的刷新,因此由于这一特性,使得DRAM的存储周期变为了1us(0.5+0.5),即128行将会在128us内完成全部的刷新,在2ms的时间内这128行将会被刷新2000/128=15.6次.
优点:无死区,不会导致CPU的空转
缺点:存储周期翻倍,CPU效率降低,且由于刷新时间间隔内会多次的对电容进行刷新,造成硬件磨损

异步刷新

异步刷新是前两种刷新的折中考虑.
对于这128行,在2ms的刷新间隔内,我们可以轻易的算出只需要每
2000/128=15.6us刷新一行即可完成2ms内对所有行的刷新,因此异步刷新也正是使用这思路.
即在这15.6us中,只会剩余0.5us用于最后对行的刷新,其余时间用于对存储单元进行数据访问.
如果将DRAM的刷新安排在CPU对指令的译码阶段，由于这个阶段CPU不访问存储器，所以这种方案既克服了分散刷新需独占0.5μs用于刷新，使存取周期加长且降低系统速度的缺点，又不会出现集中刷新的访存“死区”问题，从根本上上提高了整机的工作效率。
目前大部分使用的刷新方法都是这种
优点:不会过度刷新且没有死区

例题讲解

vue页面刷新

首先我们都知道vue属于单页面应用，默认境况下是不会触发刷新页面操作的，所以这个时候就需要我们通过事件来触发reload()来达到刷新操作

接下来我就为大家介绍三种刷新页面的方法

1.

wiindow.location.reload([bForceGet])

该方法强迫浏览器刷新当前页面

bForceGet 可选参数，默认为false,从客户端缓存里取当前

true,则以get方式，从服务器端获取最新的页面，相当于页面f5刷新

wiindow.location.replace(URL)

该URL参数未你所要跳转的地址，如果想实现当前页面刷新，你可以这样做

wiindow.location.replace(location.href)

2.

this.$router.go(0)

经常使用vue的小伙伴看到这个应该很熟悉吧，我们经常用它来实现前进后退，但别忘了它还可以实现自身页面刷新

3.

对于以上两种方法，虽然都可以实现页面刷新，但页面会刷的白一下，给用户的体验非常不好

3.

利用provide/inject组合方式是我目前觉得最好用的方法，下面我们就来详细介绍其用法

首先在我们的app.vue页面中设置

<template>
  <div id="app">
    <router-view v-if="isRouterAlive"></router-view>    
  </div>
</template>

<script>

export default {
  provide(){
    return{
      reload:this.reload //提供数据
    }
  },
  data() {
    return {
      isRouterAlive:true,
    }
  },
  methods: {
    reload(){
      this.isRouterAlive=false
      this.$nextTick(()=>{
        this.isRouterAlive=true
        console.log("确实刷新了")
      })
    }
  },
};

</script>

这里我来说明一下，我们的主体思路，我想可以通过视图的显隐来达到我们想要的刷新，所以我们就在这里声明了一个方法，先让视图消失随后又出现，这种方法有什么好处呢，你可以刷新局部页面，也可以刷新全部页面，这完全由你自己来控制

接下来，找到我们想要刷新的页面

<template>
  <div>
      <el-button @click="click_close">刷新</el-button>
  </div>
</template>

<script>
  export default {
    inject:['reload'],
      methods: {
       click_close(){       
        this.reload()
      }
      
    },
    mounted () {
       
    },
  }
</script>

如果我们这样来写的话确实通过点击按钮可以触发刷新操作

可以看到，当我们点击刷新的时候我们的页面就会触发一次事件，刷新一次，可这并不是我们想要的，我们想要的是当一进入页面，就要触发一次刷新，那干脆我们执行这个事件的函数放在mounted里面好了，话不多说直接开始

<template>
  <div>
      <el-button @click="click_close">刷新</el-button>
  </div>
</template>

<script>
  export default {
    inject:['reload'],
      methods: {
       click_close(){             
      }
      
    },
    mounted () {
       this.reload()
    },
  }
</script>

如果你这么写，你打开页面后你会惊奇的发现，刷新次数无限飙升，还没有两秒，刷新次数已经达到了上万次，你试的想一下，如果你有后台，不断地刷新，向后台发送请求，就这每秒请求的频率，不把你服务器搞崩才怪，那为什么会陷入死循环呢，很简单，你刚加载页面的时候他触发一次刷新，刷新之后是不是又会重新加载一下页面呢，然后再触发，在加载…无穷无尽 那就没有办法解决嘛，有，既然我们找到了原因，那解决的办法也是有的

解决思路：通过判断来处理第一次刷新后，后续将不再执行，也就是我们第一次执行的时候为true，其余的全为false

在vue-router里找到我们当前页的路由信息，加入meta元标签

import Vue from 'vue'
import VueRouter from 'vue-router'
import Home from '../views/Home.vue'

Vue.use(VueRouter)

const routes = [
  {
    path: '/',
    name: 'Home',
    component: Home
  },
    {
      path: '/table',
      // name: 'routeName',
      component: () => import('../views/Table.vue'),
      meta:{
        reload:''
      }
    },
   
]

const router = new VueRouter({
  mode: 'hash',
  base: process.env.BASE_URL,
  routes
})

export default router

然后在我们需要刷新的页面这样来写

<template>
  <div>
      <el-button @click="click_close">刷新</el-button>
  </div>
</template>

<script>
  export default {
    inject:['reload'],
      methods: {
       click_close(){    
         if(this.$route.meta.reload.indexOf('one')==-1){
          this.$route.meta.reload='one'
          this.reload()
      }      
      }     
    },
    mounted () {
       this.click_close()
    }
  }
</script>

ok 这样我们就完美解决了当已进入该页面就会默认刷新一次的需求