2. 程式人生 > >redis系列之數據庫與緩存數據一致性解決方案

redis系列之數據庫與緩存數據一致性解決方案

阿新 • • 發佈：2018-03-07
查詢緩存 src dev 信息 一次 ram ren red getc

redis系列之數據庫與緩存數據一致性解決方案

數據庫與緩存讀寫模式策略

寫完數據庫後是否需要馬上更新緩存還是直接刪除緩存？ （1）、如果寫數據庫的值與更新到緩存值是一樣的，不需要經過任何的計算，可以馬上更新緩存，但是如果對於那種寫數據頻繁而讀數據少的場景並不合適這種解決方案，因為也許還沒有查詢就被刪除或修改了，這樣會浪費時間和資源 （2）、如果寫數據庫的值與更新緩存的值不一致，寫入緩存中的數據需要經過幾個表的關聯計算後得到的結果插入緩存中，那就沒有必要馬上更新緩存，只有刪除緩存即可，等到查詢的時候在去把計算後得到的結果插入到緩存中即可。 所以一般的策略是當更新數據時，先刪除緩存數據，然後更新數據庫，而不是更新緩存，等要查詢的時候才把最新的數據更新到緩存

數據庫與緩存雙寫情況下導致數據不一致問題

場景一

當更新數據時，如更新某商品的庫存，當前商品的庫存是100，現在要更新為99，先更新數據庫更改成99，然後刪除緩存，發現刪除緩存失敗了，這意味著數據庫存的是99，而緩存是100，這導致數據庫和緩存不一致。

場景一解決方案

這種情況應該是先刪除緩存，然後在更新數據庫，如果刪除緩存失敗，那就不要更新數據庫，如果說刪除緩存成功，而更新數據庫失敗，那查詢的時候只是從數據庫裏查了舊的數據而已，這樣就能保持數據庫與緩存的一致性。

場景二

在高並發的情況下，如果當刪除完緩存的時候，這時去更新數據庫，但還沒有更新完，另外一個請求來查詢數據，發現緩存裏沒有，就去數據庫裏查，還是以上面商品庫存為例，如果數據庫中產品的庫存是100，那麽查詢到的庫存是100，然後插入緩存，插入完緩存後，原來那個更新數據庫的線程把數據庫更新為了99，導致數據庫與緩存不一致的情況

場景二解決方案

遇到這種情況，可以用隊列的去解決這個問，創建幾個隊列，如20個，根據商品的ID去做hash值，然後對隊列個數取摸，當有數據更新請求時，先把它丟到隊列裏去，當更新完後在從隊列裏去除，如果在更新的過程中，遇到以上場景，先去緩存裏看下有沒有數據，如果沒有，可以先去隊列裏看是否有相同商品ID在做更新，如果有也把查詢的請求發送到隊列裏去，然後同步等待緩存更新完成。
這裏有一個優化點，如果發現隊列裏有一個查詢請求了，那麽就不要放新的查詢操作進去了，用一個while（true）循環去查詢緩存，循環個200MS左右，如果緩存裏還沒有則直接取數據庫的舊數據，一般情況下是可以取到的。 在高並發下解決場景二要註意的問題
（1）讀請求時長阻塞
由於讀請求進行了非常輕度的異步化，所以一定要註意讀超時的問題，每個讀請求必須在超時間內返回，該解決方案最大的風險在於可能數據更新很頻繁，導致隊列中擠壓了大量的更新操作在裏面，然後讀請求會發生大量的超時，最後導致大量的請求直接走數據庫，像遇到這種情況，一般要做好足夠的壓力測試，如果壓力過大，需要根據實際情況添加機器。
（2）請求並發量過高
這裏還是要做好壓力測試，多模擬真實場景，並發量在最高的時候QPS多少，扛不住就要多加機器，還有就是做好讀寫比例是多少
（3）多服務實例部署的請求路由
可能這個服務部署了多個實例，那麽必須保證說，執行數據更新操作，以及執行緩存更新操作的請求，都通過nginx服務器路由到相同的服務實例上
（4）熱點商品的路由問題，導致請求的傾斜
某些商品的讀請求特別高，全部打到了相同的機器的相同丟列裏了，可能造成某臺服務器壓力過大，因為只有在商品數據更新的時候才會清空緩存，然後才會導致讀寫並發，所以更新頻率不是太高的話，這個問題的影響並不是很大，但是確實有可能某些服務器的負載會高一些。

數據庫與緩存數據一致性解決方案流程圖

技術分享圖片

數據庫與緩存數據一致性解決方案對應代碼

商品庫存實體

[java] view plain copy
  1. package com.shux.inventory.entity;
  2. /**
  3. **********************************************
  4. * 描述：
  5. * Simba.Hua
  6. * 2017年8月30日
  7. **********************************************
  8. **/
  9. public class InventoryProduct {
  10. private Integer productId;
  11. private Long InventoryCnt;
  13. public Integer getProductId() {
  14. return productId;
  15. }
  16. public void setProductId(Integer productId) {
  17. this.productId = productId;
  18. }
  19. public Long getInventoryCnt() {
  20. return InventoryCnt;
  21. }
  22. public void setInventoryCnt(Long inventoryCnt) {
  23. InventoryCnt = inventoryCnt;
  24. }
  26. }

請求接口

[java] view plain copy
  1. /**
  2. **********************************************
  3. * 描述：
  4. * Simba.Hua
  5. * 2017年8月27日
  6. **********************************************
  7. **/
  8. public interface Request {
  9. public void process();
  10. public Integer getProductId();
  11. public boolean isForceFefresh();
  12. }

數據更新請求

[java] view plain copy
  1. package com.shux.inventory.request;
  3. import org.springframework.transaction.annotation.Transactional;
  5. import com.shux.inventory.biz.InventoryProductBiz;
  6. import com.shux.inventory.entity.InventoryProduct;
  8. /**
  9. **********************************************
  10. * 描述：更新庫存信息
  11. * 1、先刪除緩存中的數據
  12. * 2、更新數據庫中的數據
  13. * Simba.Hua
  14. * 2017年8月30日
  15. **********************************************
  16. **/
  17. public class InventoryUpdateDBRequest implements Request{
  18. private InventoryProductBiz inventoryProductBiz;
  19. private InventoryProduct inventoryProduct;
  21. public InventoryUpdateDBRequest(InventoryProduct inventoryProduct,InventoryProductBiz inventoryProductBiz){
  22. this.inventoryProduct = inventoryProduct;
  23. this.inventoryProductBiz = inventoryProductBiz;
  24. }
  25. @Override
  26. @Transactional
  27. public void process() {
  28. inventoryProductBiz.removeInventoryProductCache(inventoryProduct.getProductId());
  29. inventoryProductBiz.updateInventoryProduct(inventoryProduct);
  30. }
  31. @Override
  32. public Integer getProductId() {
  33. // TODO Auto-generated method stub
  34. return inventoryProduct.getProductId();
  35. }
  36. @Override
  37. public boolean isForceFefresh() {
  38. // TODO Auto-generated method stub
  39. return false;
  40. }
  42. }

查詢請求

[java] view plain copy
  1. package com.shux.inventory.request;
  3. import com.shux.inventory.biz.InventoryProductBiz;
  4. import com.shux.inventory.entity.InventoryProduct;
  6. /**
  7. **********************************************
  8. * 描述：查詢緩存數據
  9. * 1、從數據庫中查詢
  10. * 2、從數據庫中查詢後插入到緩存中
  11. * Simba.Hua
  12. * 2017年8月30日
  13. **********************************************
  14. **/
  15. public class InventoryQueryCacheRequest implements Request {
  16. private InventoryProductBiz inventoryProductBiz;
  17. private Integer productId;
  18. private boolean isForceFefresh;
  20. public InventoryQueryCacheRequest(Integer productId,InventoryProductBiz inventoryProductBiz,boolean isForceFefresh) {
  21. this.productId = productId;
  22. this.inventoryProductBiz = inventoryProductBiz;
  23. this.isForceFefresh = isForceFefresh;
  24. }
  25. @Override
  26. public void process() {
  27. InventoryProduct inventoryProduct = inventoryProductBiz.loadInventoryProductByProductId(productId);
  28. inventoryProductBiz.setInventoryProductCache(inventoryProduct);
  29. }
  30. @Override
  31. public Integer getProductId() {
  32. // TODO Auto-generated method stub
  33. return productId;
  34. }
  35. public boolean isForceFefresh() {
  36. return isForceFefresh;
  37. }
  38. public void setForceFefresh(boolean isForceFefresh) {
  39. this.isForceFefresh = isForceFefresh;
  40. }
  43. }

spring啟動時初始化隊列線程池

[java] view plain copy
  1. package com.shux.inventory.thread;
  3. import java.util.concurrent.ArrayBlockingQueue;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  7. import com.shux.inventory.request.Request;
  8. import com.shux.inventory.request.RequestQueue;
  9. import com.shux.utils.other.SysConfigUtil;
  11. /**
  12. **********************************************
  13. * 描述：請求處理線程池，初始化隊列數及每個隊列最多能處理的數量
  14. * Simba.Hua
  15. * 2017年8月27日
  16. **********************************************
  17. **/
  18. public class RequestProcessorThreadPool {
  19. private static final int blockingQueueNum = SysConfigUtil.get("request.blockingqueue.number")==null?10:Integer.valueOf(SysConfigUtil.get("request.blockingqueue.number").toString());
  20. private static final int queueDataNum = SysConfigUtil.get("request.everyqueue.data.length")==null?100:Integer.valueOf(SysConfigUtil.get("request.everyqueue.data.length").toString());
  21. private ExecutorService threadPool = Executors.newFixedThreadPool(blockingQueueNum);
  22. private RequestProcessorThreadPool(){
  23. for(int i=0;i<blockingQueueNum;i++){//初始化隊列
  24. ArrayBlockingQueue<Request> queue = new ArrayBlockingQueue<Request>(queueDataNum);//每個隊列中放100條數據
  25. RequestQueue.getInstance().addQueue(queue);
  26. threadPool.submit(new RequestProcessorThread(queue));//把每個queue交個線程去處理，線程會處理每個queue中的數據
  27. }
  28. }
  29. public static class Singleton{
  30. private static RequestProcessorThreadPool instance;
  31. static{
  32. instance = new RequestProcessorThreadPool();
  33. }
  34. public static RequestProcessorThreadPool getInstance(){
  35. return instance;
  36. }
  37. }
  38. public static RequestProcessorThreadPool getInstance(){
  39. return Singleton.getInstance();
  40. }
  41. /**
  42. * 初始化線程池
  43. */
  44. public static void init(){
  45. getInstance();
  46. }
  47. }

請求處理線程

[java] view plain copy
  1. package com.shux.inventory.thread;
  3. import java.util.Map;
  4. import java.util.concurrent.ArrayBlockingQueue;
  5. import java.util.concurrent.Callable;
  7. import com.shux.inventory.request.InventoryUpdateDBRequest;
  8. import com.shux.inventory.request.Request;
  9. import com.shux.inventory.request.RequestQueue;
  11. /**
  12. **********************************************
  13. * 描述：請求處理線程
  14. * Simba.Hua
  15. * 2017年8月27日
  16. **********************************************
  17. **/
  18. public class RequestProcessorThread implements Callable<Boolean>{
  19. private ArrayBlockingQueue<Request> queue;
  20. public RequestProcessorThread(ArrayBlockingQueue<Request> queue){
  21. this.queue = queue;
  22. }
  23. @Override
  24. public Boolean call() throws Exception {
  25. Request request = queue.take();
  26. Map<Integer,Boolean> flagMap = RequestQueue.getInstance().getFlagMap();
  27. //不需要強制刷新的時候，查詢請求去重處理
  28. if (!request.isForceFefresh()){
  29. if (request instanceof InventoryUpdateDBRequest) {//如果是更新請求，那就置為false
  30. flagMap.put(request.getProductId(), true);
  31. } else {
  32. Boolean flag = flagMap.get(request.getProductId());
  33. /**
  34. * 標誌位為空，有三種情況
  35. * 1、沒有過更新請求
  36. * 2、沒有查詢請求
  37. * 3、數據庫中根本沒有數據
  38. * 在最初情況，一旦庫存了插入了數據，那就好會在緩存中也會放一份數據，
  39. * 但這種情況下有可能由於redis中內存滿了，redis通過LRU算法把這個商品給清除了，導致緩存中沒有數據
  40. * 所以當標誌位為空的時候，需要從數據庫重查詢一次，並且把標誌位置為false，以便後面的請求能夠從緩存中取
  41. */
  42. if ( flag == null) {
  43. flagMap.put(request.getProductId(), false);
  44. }
  45. /**
  46. * 如果不為空，並且flag為true，說明之前有一次更新請求，說明緩存中沒有數據了（更新緩存會先刪除緩存），
  47. * 這個時候就要去刷新緩存，即從數據庫中查詢一次，並把標誌位設置為false
  48. */
  49. if ( flag != null && flag) {
  50. flagMap.put(request.getProductId(), false);
  51. }
  52. /**
  53. * 這種情況說明之前有一個查詢請求，並且把數據刷新到了緩存中，所以這時候就不用去刷新緩存了，直接返回就可以了
  54. */
  55. if (flag != null && !flag) {
  56. flagMap.put(request.getProductId(), false);
  57. return true;
  58. }
  59. }
  60. }
  61. request.process();
  62. return true;
  63. }
  65. }

請求隊列

[java] view plain copy
  1. package com.shux.inventory.request;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.concurrent.ArrayBlockingQueue;
  7. import java.util.concurrent.ConcurrentHashMap;
  9. /**
  10. **********************************************
  11. * 描述：請求隊列
  12. * Simba.Hua
  13. * 2017年8月27日
  14. **********************************************
  15. **/
  16. public class RequestQueue {
  17. private List<ArrayBlockingQueue<Request>> queues = new ArrayList<>();
  19. private Map<Integer,Boolean> flagMap = new ConcurrentHashMap<>();
  20. private RequestQueue(){
  22. }
  23. private static class Singleton{
  24. private static RequestQueue queue;
  25. static{
  26. queue = new RequestQueue();
  27. }
  28. public static RequestQueue getInstance() {
  29. return queue;
  30. }
  31. }
  33. public static RequestQueue getInstance(){
  34. return Singleton.getInstance();
  35. }
  36. public void addQueue(ArrayBlockingQueue<Request> queue) {
  37. queues.add(queue);
  38. }
  40. public int getQueueSize(){
  41. return queues.size();
  42. }
  43. public ArrayBlockingQueue<Request> getQueueByIndex(int index) {
  44. return queues.get(index);
  45. }
  47. public Map<Integer,Boolean> getFlagMap() {
  48. return this.flagMap;
  49. }
  50. }


spring 啟動初始化線程池類

[java] view plain copy
  1. package com.shux.inventory.listener;
  3. import org.springframework.context.ApplicationListener;
  4. import org.springframework.context.event.ContextRefreshedEvent;
  6. import com.shux.inventory.thread.RequestProcessorThreadPool;
  8. /**
  9. **********************************************
  10. * 描述：spring 啟動初始化線程池類
  11. * Simba.Hua
  12. * 2017年8月27日
  13. **********************************************
  14. **/
  15. public class InitListener implements ApplicationListener<ContextRefreshedEvent>{
  17. @Override
  18. public void onApplicationEvent(ContextRefreshedEvent event) {
  19. // TODO Auto-generated method stub
  20. if(event.getApplicationContext().getParent() != null){
  21. return;
  22. }
  23. RequestProcessorThreadPool.init();
  24. }
  25. }

異步處理請求接口

[java] view plain copy
  1. package com.shux.inventory.biz;
  3. import com.shux.inventory.request.Request;
  5. /**
  6. **********************************************
  7. * 描述：請求異步處理接口，用於路由隊列並把請求加入到隊列中
  8. * Simba.Hua
  9. * 2017年8月30日
  10. **********************************************
  11. **/
  12. public interface IRequestAsyncProcessBiz {
  13. void process(Request request);
  14. }

異步處理請求接口實現

[java] view plain copy
  1. package com.shux.inventory.biz.impl;
  3. import java.util.concurrent.ArrayBlockingQueue;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.stereotype.Service;
  9. import com.shux.inventory.biz.IRequestAsyncProcessBiz;
  10. import com.shux.inventory.request.Request;
  11. import com.shux.inventory.request.RequestQueue;
  14. /**
  15. **********************************************
  16. * 描述：異步處理請求,用於路由隊列並把請求加入到隊列中
  17. * Simba.Hua
  18. * 2017年8月30日
  19. **********************************************
  20. **/
  21. @Service("requestAsyncProcessService")
  22. public class RequestAsyncProcessBizImpl implements IRequestAsyncProcessBiz {
  23. private Logger logger = LoggerFactory.getLogger(getClass());
  24. @Override
  25. public void process(Request request) {
  26. // 做請求的路由，根據productId路由到對應的隊列
  27. ArrayBlockingQueue<Request> queue = getQueueByProductId(request.getProductId());
  28. try {
  29. queue.put(request);
  30. } catch (InterruptedException e) {
  31. logger.error("產品ID{}加入隊列失敗",request.getProductId(),e);
  32. }
  33. }
  35. private ArrayBlockingQueue<Request> getQueueByProductId(Integer productId) {
  36. RequestQueue requestQueue = RequestQueue.getInstance();
  37. String key = String.valueOf(productId);
  38. int hashcode;
  39. int hash = (key == null) ? 0 : (hashcode = key.hashCode())^(hashcode >>> 16);
  40. //對hashcode取摸
  41. int index = (requestQueue.getQueueSize()-1) & hash;
  42. return requestQueue.getQueueByIndex(index);
  43. }
  47. }


數據更新請求controller

[java] view plain copy
  1. package com.shux.inventory.controller;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.ResponseBody;
  8. import com.shux.inventory.biz.IRequestAsyncProcessBiz;
  9. import com.shux.inventory.biz.InventoryProductBiz;
  10. import com.shux.inventory.entity.InventoryProduct;
  11. import com.shux.inventory.request.InventoryUpdateDBRequest;
  12. import com.shux.inventory.request.Request;
  13. import com.shux.utils.other.Response;
  15. /**
  16. **********************************************
  17. * 描述：提交更新請求
  18. * Simba.Hua
  19. * 2017年9月1日
  20. **********************************************
  21. **/
  22. @Controller("/inventory")
  23. public class InventoryUpdateDBController {
  24. private @Autowired InventoryProductBiz inventoryProductBiz;
  25. private @Autowired IRequestAsyncProcessBiz requestAsyncProcessBiz;
  26. @RequestMapping("/updateDBInventoryProduct")
  27. @ResponseBody
  28. public Response updateDBInventoryProduct(InventoryProduct inventoryProduct){
  29. Request request = new InventoryUpdateDBRequest(inventoryProduct,inventoryProductBiz);
  30. requestAsyncProcessBiz.process(request);
  31. return new Response(Response.SUCCESS,"更新成功");
  32. }
  33. }

數據查詢請求controller

[java] view plain copy
  1. package com.shux.inventory.controller;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  7. import com.shux.inventory.biz.IRequestAsyncProcessBiz;
  8. import com.shux.inventory.biz.InventoryProductBiz;
  9. import com.shux.inventory.entity.InventoryProduct;
  10. import com.shux.inventory.request.InventoryQueryCacheRequest;
  11. import com.shux.inventory.request.Request;
  13. /**
  14. **********************************************
  15. * 描述：提交查詢請求
  16. * 1、先從緩存中取數據
  17. * 2、如果能從緩存中取到數據，則返回
  18. * 3、如果不能從緩存取到數據，則等待20毫秒，然後再次去數據，直到200毫秒，如果超過200毫秒還不能取到數據，則從數據庫中取，並強制刷新緩存數據
  19. * Simba.Hua
  20. * 2017年9月1日
  21. **********************************************
  22. **/
  23. @Controller("/inventory")
  24. public class InventoryQueryCacheController {
  25. private @Autowired InventoryProductBiz inventoryProductBiz;
  26. private @Autowired IRequestAsyncProcessBiz requestAsyncProcessBiz;
  27. @RequestMapping("/queryInventoryProduct")
  28. public InventoryProduct queryInventoryProduct(Integer productId) {
  29. Request request = new InventoryQueryCacheRequest(productId,inventoryProductBiz,false);
  30. requestAsyncProcessBiz.process(request);//加入到隊列中
  31. long startTime = System.currentTimeMillis();
  32. long allTime = 0L;
  33. long endTime = 0L;
  34. InventoryProduct inventoryProduct = null;
  35. while (true) {
  36. if (allTime > 200){//如果超過了200ms,那就直接退出，然後從數據庫中查詢
  37. break;
  38. }
  39. try {
  40. inventoryProduct = inventoryProductBiz.loadInventoryProductCache(productId);
  41. if (inventoryProduct != null) {
  42. return inventoryProduct;
  43. } else {
  44. Thread.sleep(20);//如果查詢不到就等20毫秒
  45. }
  46. endTime = System.currentTimeMillis();
  47. allTime = endTime - startTime;
  48. } catch (Exception e) {
  49. }
  50. }
  51. /**
  52. * 代碼執行到這來，只有以下三種情況
  53. * 1、緩存中本來有數據，由於redis內存滿了，redis通過LRU算法清除了緩存，導致數據沒有了
  54. * 2、由於之前數據庫查詢比較慢或者內存太小處理不過來隊列中的數據，導致隊列裏擠壓了很多的數據，所以一直沒有從數據庫中獲取數據然後插入到緩存中
  55. * 3、數據庫中根本沒有這樣的數據，這種情況叫數據穿透，一旦別人知道這個商品沒有，如果一直執行查詢，就會一直查詢數據庫，如果過多，那麽有可能會導致數據庫癱瘓
  56. */
  57. inventoryProduct = inventoryProductBiz.loadInventoryProductByProductId(productId);
  58. if (inventoryProduct != null) {
  59. Request forcRrequest = new InventoryQueryCacheRequest(productId,inventoryProductBiz,true);
  60. requestAsyncProcessBiz.process(forcRrequest);//這個時候需要強制刷新數據庫，使緩存中有數據
  61. return inventoryProduct;
  62. }
  63. return null;
  65. }
  66. }

redis系列之數據庫與緩存數據一致性解決方案

相關推薦

redis系列之數據庫與緩存數據一致性解決方案

查詢緩存 src dev 信息 一次 ram ren red getc redis系列之數據庫與緩存數據一致性解決方案 數據庫與緩存讀寫模式策略 寫完數據庫後是否需要馬上更新緩存還是直接刪除緩存？ （1）、如果寫數據庫的值與更新到緩存值是一樣的，不需要經過任何的計算，可以馬

hbase非結構化數據庫與結構化數據庫比較

數據可靠性 插入 聯網 定位 海量數據 倍增 關系型 字符類型 文件 目的：了解hbase與支持海量數據查詢的特性以及實現方式 傳統關系型數據庫特點及局限 傳統數據庫事務性特別強，要求數據完整性及安全性，造成系統可用性以及伸縮性大打折扣。對於高並發的訪問量，數據庫性

iOS數據庫離線緩存思路和網絡層封裝

integer 離線 super mat mode dict 數據緩存 req center 一直想總結一下關於iOS的離線數據緩存的方面的問題，然後近期也簡單的對AFN進行了再次封裝。全部想把這兩個結合起來寫一下。數據展示型的頁面做離線緩存能夠有更好的用戶體驗

圖數據庫與關系數據庫的實驗對比——意大利商會 InfoCamere 案例

一個 問題 data 一次 支持 圖表 相關 invest 限制 摘要: InfoCamere是附屬於意大利商會的IT公司，主要設計和開發最新和創新的IT解決方案和服務，它通過一個公眾也可以訪問的網絡連接商會及其數據庫。借助InfoCamere，意大利和國外的企業，公共機

論 業務系統 架構 的 簡化 （二） 用 關系數據庫 作 緩存

分鐘 ase cap .net red lan 分布 https 未來 通常， 分布式緩存 是 NoSql 數據庫， 比如 Redis 。 但 實際上 我們 可以用 關系數據庫 來 作 緩存 。 比如 常用的 商品列表 等， 可以用 關系數據庫 來作 緩存， 查詢

四、redis系列之主從復制與哨兵機制

添加 連接 管理 block 也有 daemonize toc 導出 拓撲 1. 緒言 　　在現實應用環境中，出於數據容量、容災、性能等因素的考慮，往往不會只使用一臺服務器，而是使用集群的方式。Redis 中也有類似的維持一主多從的方式提高 Redis 集群的高可用性的方案

oracle初始參數設置錯誤導致數據庫無法啟動報ORA-00821的解決方案

rod type app 執行sql sta file nbsp set star 今天為了修改數據庫配置,將sga_max_size設置為了20G,但是sga_target沒改,仍然為10G 結果改完後重啟數據庫就啟動不了了,報ORA-00821錯誤 ORA-00821:

idea操作mysql數據庫添加漢字時出現亂碼解決方案

http nco har 一個 技術分享 格式 出現 clas 操作mysql 首先 然後 最後 在連接數據庫後面加一個指定編碼格式 編碼格式： characterEncoding=UTF-8 　　 idea操作mysql數據庫添加漢字時出現亂碼解決方案

MySQL數據庫遠程連接的個人解決方案

遠程 roo 簡單配置 地址 mysql數據庫 本機 set 個人 訪問 首先，目的是使用本機可視化工具SQLyog通過IP地址遠程訪問另一臺機器上的MySQL數據庫。 本人實踐的MySQL版本是MySQL 5.7.23，數據庫部署的主機系統是Windows。這些簡單

Redis緩存穿透問題及解決方案

時間 mon 位數 exp 速度 boolean value 通過 tin 上周在工作中遇到了一個問題場景，即查詢商品的配件信息時（商品：配件為1：N的關系），如若商品並未配置配件信息，則查數據庫為空，且不會加入緩存，這就會導致，下次在查詢同樣商品的配件時，由於緩存未命中，

緩存三大問題及解決方案

com 能夠 特定 應對 image 只為 分布 雙11 第一個 1. 緩存來由 隨著互聯網系統發展的逐步完善，提高系統的qps，目前的絕大部分系統都增加了緩存機制從而避免請求過多的直接與數據庫操作從而造成系統瓶頸，極大的提升了用戶體驗和系統穩定性。 2. 緩存問題 雖然

緩存穿透、緩存擊穿、緩存雪崩概念及解決方案

失效 當前 過期 直接 集中 設置 查詢 過濾 導致 緩存穿透 概念 訪問一個不存在的key，緩存不起作用，請求會穿透到DB，流量大時DB會掛掉。 解決方案 采用布隆過濾器，使用一個足夠大的bitmap，用於存儲可能訪問的key，不存在的key直接被過濾； 訪問key未在

Redis緩存數據庫的安裝與配置(1)

cte quest ready 計算 測試工具 報錯信息 數據庫的安裝 參數說明 div 1.安裝 tarxf redis-3.2.5.tar.gz cd redis-3.2.5 make mkdir -p /usr/local/redis/bin src目錄下這些文件作

緩存數據庫-redis數據類型和操作

memcached tco view 技術 hid 指定 創建 div one Redis支持五種數據類型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合) 一：String（字符串） string是

緩存數據庫-redis數據類型和操作（sorted set)

兩個 ring can 哈希 不同 規則 end card 通過 一：Redis 有序集合(sorted set) 　　Redis 有序集合和集合一樣也是string類型元素的集合,且不允許重復的成員。 　　不同的是每個元素都會關聯一個double類型的分數。redis正是

緩存數據庫-redis(訂閱發布)

之間 height obj 緩存 urn response span self 頻道 一：Redis 發布訂閱 Redis 發布訂閱(pub/sub)是一種消息通信模式：發送者(pub)發送消息，訂閱者(sub)接收消息。 Redis 客戶端可以訂閱任意數量的頻道。 下圖展

初識Redis系列之三：Redis支持的數據類型及使用

ted print 數據類型 eight 排序 sorted ring hang 無序 支持的數據類型有五種： string（字符串）、hash（哈希）、list（列表）、set（集合）及zset(sorted set：有序集合)； 下面分別對這幾種類型進行簡單的Redis

Django基礎之數據庫與ORM

page 寫入 src postgres def 由於 ont 方法 cut 一.數據庫配置 1.django默認支持sqlite，mysql, oracle,postgresql數據庫。 django默認使用sqlite的數據庫，默認自帶sqlite的數據庫驅動

Redis緩存數據庫服務器

位置 word -- 新的 當前 limit run 永不 日誌級別 Redis緩存數據庫服務器Redis是一個開源的科技與內存也可持久化的日誌型、Key-Value數據庫Redis的存儲分為內存存儲、磁盤存儲和Log文件三部分，配置文件中有三個參數對其進行配置。 優勢：和

Redis 緩存數據庫

redisRedis 緩存數據庫第1章 Redis簡介:redis是使用C語言編寫的開源的,支持網絡,基於內存,可持久性的鍵值對存儲數據庫,2013年5月之前,Redis是最流行的鍵值對存儲數據庫Redis采用內存數據集,支持多種數據類型官方網站：https://redis.io官方各版本下載地址：http: