精华内容
下载资源
问答
  • 2018-05-05 11:35:23

    作为一个Java后端开发,我们写出的大部分代码都决定着用户的使用体验。如果我们的后端代码性能不好,那么用户在访问我们的网站时就要浪费一些时间等待服务器的响应,造成极差的用户体验,这就可能导致用户投诉甚至用户的流失。

    性能优化是一个很大的话题。《Java程序性能优化》说性能优化包含五个层次:设计调优、代码调优、JVM调优、数据库调优、操作系统调优等。而每一个层次又包含很多方法论和最佳实践。本文只举几个常用的Java代码优化方案,可以真正应用到项目中的方案。

    1、使用单例

    对于IO处理、数据库连接、配置文件解析加载等一些非常耗费系统资源的操作,我们必须对这些实例的创建进行限制,或者是始终使用一个公用的实例,以节约系统开销,这种情况下就需要用到单例模式。

    2、使用Future模式
    假设一个任务执行起来需要花费一些时间,为了省去不必要的等待时间,可以先获取一个“提货单”,即Future,然后继续处理别的任务,直到“货物”到达,即任务执行完得到结果,此时便可以用“提货单”进行提货,即通过Future对象得到返回值。

    public class RealData implements Callable<String> {  
        protected String data;  
    
        public RealData(String data) {  
            this.data = data;  
        }  
    
        @Override  
        public String call() throws Exception {  
            //利用sleep方法来表示真是业务是非常缓慢的  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            return data;  
        }  
    }  
    
    public class Application {  
        public static void main(String[] args) throws Exception {  
            FutureTask<String> futureTask =   
                    new FutureTask<String>(new RealData("name"));  
            ExecutorService executor =   
                    Executors.newFixedThreadPool(1); //使用线程池  
            //执行FutureTask,相当于上例中的client.request("name")发送请求  
            executor.submit(futureTask);  
            //这里可以用一个sleep代替对其他业务逻辑的处理  
            //在处理这些业务逻辑过程中,RealData也正在创建,从而充分了利用等待时间  
            Thread.sleep(2000);  
            //使用真实数据  
            //如果call()没有执行完成依然会等待  
            System.out.println("数据=" + futureTask.get());  
        }  
    }

    3、使用线程池

    合理利用线程池能够带来三个好处。第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二:提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行。第三:提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
    在 Java 5 之后,并发编程引入了一堆新的启动、调度和管理线程的API。Executor 框架便是 Java 5 中引入的,其内部使用了线程池机制,它在 java.util.cocurrent 包下,通过该框架来控制线程的启动、执行和关闭,可以简化并发编程的操作。

    public class MultiThreadTest {
        public static void main(String[] args) {
            ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("thread-%d").build();
            ExecutorService executor = new ThreadPoolExecutor(2, 5, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), threadFactory);
            executor.execute(new Runnable() {
                @Override
                public void run() {
                   System.out.println("hello world !");
                }
            });
            System.out.println(" ===> main Thread! " );
        }
    }

    4、使用NIO

    JDK自1.4起开始提供全新的I/O编程类库,简称NIO,其不但引入了全新高效的Buffer和Channel,同时,还引入了基于Selector的非阻塞 I/O机制,将多个异步的I/O操作集中到一个或几个线程当中进行处理,使用NIO代替阻塞I/O能提高程序的并发吞吐能力,降低系统的开销。
    对于每一个请求,如果单独开一个线程进行相应的逻辑处理,当客户端的数据传递并不是一直进行,而是断断续续的,则相应的线程需要 I/O等待,并进行上下文切换。而使用NIO引入的Selector机制后,可以提升程序的并发效率,改善这一状况。

    public class NioTest {  
        static public void main( String args[] ) throws Exception {  
            FileInputStream fin = new FileInputStream("c:\\test.txt");  
            // 获取通道  
            FileChannel fc = fin.getChannel();  
            // 创建缓冲区  
            ByteBuffer buffer = ByteBuffer.allocate(1024);  
            // 读取数据到缓冲区  
            fc.read(buffer);  
            buffer.flip();  
            while (buffer.remaining()>0) {  
                byte b = buffer.get();  
                System.out.print(((char)b));  
            }  
            fin.close();  
        }  
    }  

    5、锁优化

    在并发场景中,我们的代码中经常会用到锁。存在锁,就必然存在锁的竞争,存在锁的竞争,就会消耗很多资源。那么,如何优化我们Java代码中的锁呢?主要可以从以下几个方面考虑:

    • 减少锁持有时间
      可以使用同步代码块来代替同步方法。这样可以减少锁持有的时间。
    • 减少锁粒度
      要在并发场景中使用Map的时候,记得使用ConcurrentHashMap来代替HashTable和HashMap。
    • 锁分离
      普通锁(如syncronized)会导致读阻塞写、写也会阻塞读,同时读读与写写之间也会进行阻塞,可以想办法将读操作和写操作分离开。
    • 锁粗化
      有些情况下我们希望把很多次锁的请求合并成一个请求,以降低短时间内大量锁请求、同步、释放带来的性能损耗。
    • 锁消除
      锁消除是Java虚拟机在JIT编译是,通过对运行上下文的扫描,去除不可能存在共享资源竞争的锁,通过锁消除,可以节省毫无意义的请求锁时间。

    6、压缩传输

    在进行数据传输之前,可以先将数据进行压缩,以减少网络传输的字节数,提升数据传输的速度,接收端可以将数据进行解压,以还原出传递的数据,并且,经过压缩的数据还可以节约所耗费的存储介质(磁盘或内存)的空间以及网络带宽,降低成本。当然,压缩也并不是没有开销的,数据压缩需要大量的CPU计算,并且,根据压缩算法的不同,计算的复杂度以及数据的压缩比也存在较大差异。一般情况下,需要根据不同的业务场景,选择不同的压缩算法。

    7、缓存结果

    对于相同的用户请求,如果每次都重复的查询数据库,重复的进行计算,将浪费很多的时间和资源。将计算后的结果缓存到本地内存,或者是通过分布式缓存来进行结果的缓存,可以节约宝贵的CPU计算资源,减少重复的数据库查询或者是磁盘I/O,将原本磁头的物理转动变成内存的电子运动,提高响应速度,并且线程的迅速释放也使得应用的吞吐能力得到提升。

    以上内容参考自作者Hollis的人人都能掌握的Java服务端性能优化方案

    更多相关内容
  • 前言这个服务端优化的想法是我在一篇文章看到...对于部分页面数据较多的页面,请求接口以及渲染页面的时间过长,影响用户体验,所以研究了缓存优化方案,去优化部分页面性能。缓存使用到的算法在这里我用的是LRU库,...

    前言

    这个服务端优化的想法是我在一篇文章看到的,可惜不记得文章的链接了,如果有印象的读者可以评论一下文章来源,谢谢。

    背景

    用Nuxt.js开发的网站,因为依赖于服务端的功能,无法使用nuxt generate去生成静态文件,用Nginx托管站点。

    对于部分页面数据较多的页面,请求接口以及渲染页面的时间过长,影响用户体验,所以研究了缓存优化方案,去优化部分页面性能。

    缓存使用到的算法

    在这里我用的是LRU库,LRU缓存的核心在于能够把最不常使用的数据移除,让给最新读取的数据。如果有想要详细了解该算法的可以参考该文章:

    LRU算法

    实现思路

    在server端判断用户所访问的路径,若该路径是所需要缓存的页面,则在server端渲染完成后,将得到的html代码缓存到内存中。

    在用户访问网站时,判断访问的页面是否有缓存,如果有缓存的话,则直接返回html代码,减少服务端渲染这一步骤的时间。

    当被缓存的页面的数据需要更新时,应当把该页面的缓存给清空,等到获取到新的数据后,再重新缓存。

    代码实现

    创建缓存对象并导出该对象,使得后续的新增缓存和清空缓存操作的是同一个缓存对象。// globalCache.js

    const LRU = require('lru-cache')

    const cachePage = new LRU({

    // 最大缓存数量

    max: 10,

    // 缓存过期时间(ms)

    maxAge: 1000 * 60 * 10

    })

    module.exports = cachePage

    复制代码

    执行缓存操作// pageCache.js

    const cachePage = require('./globalCache')

    export default function (req, res, next) {

    const pathname = req.path

    // 选择所需要缓存的路径,以首页为例

    if (pathname === '/') {

    const existHtml = cachePage.get('index')

    if (existHtml) {

    return res.end(existHtml, 'utf-8')

    } else {

    // 重写res.end

    res.original_end = res.end

    res.end = function (data) {

    // 在发送页面数据的同时设置缓存

    if (res.statusCode === 200) {

    cachePage.set('index', data)

    }

    res.original_end(data, 'utf-8')

    }

    }

    }

    next()

    }

    // nuxt.config.js

    // 将设置的缓存逻辑应用到服务端渲染中间件中

    module.exports = {

    ...

    serverMiddleware: [

    './pageCache'

    ],

    ...

    }

    复制代码

    更新缓存// server/index.js

    // 省略部分代码

    const express = require('express')

    const app = express()

    const cachePage = require('../globalCache')

    async function start() {

    // 简略的做个刷新首页缓存的示例,将首页缓存置空

    // 在服务端创建一个接口,在后端更新数据的同时,访问该接口刷新缓存

    app.get('/refreshCache', (req, res, next) => {

    cachePage.set('index', null)

    res.sendStatus(200)

    })

    ...

    }

    复制代码

    优化效果

    本地测试效果

    缓存前的document下载的时间

    713c3de8da0faf6d334e10cc484dfb37.png

    缓存后的document下载时间

    f48e12ffff3f0c1ff147829d65d58ad0.png

    源码

    存在的问题

    该缓存方案只适用于与用户信息无关的页面,例如纯展示数据的页面等等。

    缓存只生效于首屏页面,例如现在设置了second页面进行缓存,那么从首页跳转过去时,该缓存是无效的,只有直接打开second页面才有缓存的效果。具体原因可以看ssr的原理。

    该缓存方案还可以应用在接口缓存与组件缓存当中,具体实现方案可以自己研究一下~

    b739ec46bb5c46d9c0aa4ce35ba1ea56.png

    关于找一找教程网

    本站文章仅代表作者观点,不代表本站立场,所有文章非营利性免费分享。

    本站提供了软件编程、网站开发技术、服务器运维、人工智能等等IT技术文章,希望广大程序员努力学习,让我们用科技改变世界。

    [基于Nuxt.js的服务端缓存优化]http://www.zyiz.net/tech/detail-114445.html

    展开全文
  • 一、缓存 浏览器与服务器之间通过http header传递缓存信息,通过设置http header配置缓存机制。 cache-control cache-control可以在http request header中存在 也可以在http response header中存在 其作用就是让...

    一、缓存
    浏览器与服务器之间通过http header传递缓存信息,通过设置http header配置缓存机制。

    cache-control

    1. cache-control可以在http request header中存在
    2. 也可以在http response header中存在
    3. 其作用就是让浏览器与服务器相互知道各自那边的缓存策略情况。

    cache-control的属性

    1. max-age:指定缓存的最大有效时间。在这段时间之内有效,浏览器不用再向服务器请求,直接从缓存中读。status:200(from memory cache)。expires是过期时间配置(http1.0),优先级没有max-age高。
    2. s-maxage:如果既设置了max-age又设置了s-maxage。返回状态是304(去CDN拿的)。s-maxage只能指定public的缓存时间,比如CDN、代理服务器。
      private缓存设备:只适用于当前用户访问并且读取信息。
      public缓存设备:能被很多用户访问并且读取信息的。
      s-maxage优先级高于max-age.
      s-maxage对于public缓存设备来说才是有效的。
      所以,s-maxage是对于CDN这样公共的public缓存设备来说的资源过期时间,浏览器从CDN取得资源,返回状态码304。
    3. no-cache:不会直接去浏览器缓存中读,会发请求到服务器,通过服务器的一些信息(比如:last-modified)来判断浏览器端的缓存是否过期,从而知道缓存策略。
    4. no-store:对资源不使用任何缓存策略。

    Expires

    Expire:缓存过期时间,用来指定资源的到期时间,是服务器端的具体时间点,告诉浏览器在过期时间前,浏览器可以直接从浏览器缓存取数据,而无需再次请求。

    max-age也是这个意思,但max-age优先级高于expires,当没有设置max-age时,expires就生效。

    expires和max-age都是浏览器端的缓存策略,在过期时间之前,都直接从浏览器缓存中读取数据。

    但当服务器文件资源发生变化后,浏览器端并不会更新资源,这就引出了Last-Modified和If-Modified-Since这两字段。

    Last-Modified、If-Modified-Since

    • 基于客户端和服务端协商的缓存机制,可以取得最新的资源
    • Last-Modified——response header
    • If-Modified-Since——request header
    • 需与cache-control共同使用

    返回304,服务端资源没更新,客户端直接从缓存中读取资源。
    返回200,服务端资源更新了,并发给客户端一份更新过的文件。

    也就是说,当cache-control配了max-age,且max-age没有过期,会优先走max-age,从浏览器中读相关的文件,当max-age过期后,浏览器和服务器才会通过Last-Modified / If-Modified-Since进行协商,由服务端控制合理的缓存方式。

    但Last-Modified有缺点。

    Last-Modified的缺点

    1. 某些服务端不能获取精确的修改时间,也就不能准确返回。
    2. 文件修改时间改了,但文件内容却没有变

    Etag的出现解决了该问题。

    Etag / If-None-Match

    1. 文件内容的hash值,能唯一标识文件,当文件内容改变,hash值会跟着变化。
    2. Etag——response header
    3. If-None-Match——request header
    4. 需要与cache-control共同使用

    实际上就是——分级缓存策略

    通过对服务端的配置实现缓存策略。
    在这里插入图片描述
    二、缓存流程图
    在这里插入图片描述
    在这里插入图片描述

    二、服务端性能优化

    Vue渲染面临的问题是什么?为什么要用vue-ssr
    在这里插入图片描述
    多层次的优化方案

    1. 构建层模板编译
      在webpack构建的时候将模板语法template编译成浏览器可以直接执行的html代码。
    2. 数据无关的prerender的方式
      将每个用户看起来都一样的页面在webpack构建层直接编译成html代码,用户直接访问html,这样在浏览器端不会执行vue相关的代码。
    3. 服务端渲染
      将浏览器端要做的运算移到服务端,是运算能力的平衡。
      在服务端获取数据渲染页面,返回给浏览器html,能直接渲染出页面。
      (vue-ssr:将首屏相关的一些数据在服务端直接生成html返回给客户端,客户端将html渲染出来,而不是在客户端执行相应的JS从而渲染出页面。所以,vue-ssr解决首屏渲染的问题)
    展开全文
  • 前端性能优化,解决并发请求,promise缓存,小程序接口缓存,提高首页启动速度,减少http请求

    功能概述:

    1. 前端项目中有同一接口重复触发的并发现象
    2. 一些公共数据接口,如用户信息,配置信息等接口需要多次获取
    3. 首页有大量重复请求影响启动时间

    适用条件:

    1. 基本的公共数据和用户信息
    2. get类获取数据接口
    3. 基本原则就是缓存不更新或者更新周期较长的数据

    大体思路:

    1. 初次请求时将接口promise缓存到map对象中,map中的key名使用api名+参数拼接;下一次请求到同一key名的接口直接返回缓存中的promise;如果没有此key的promise使用正常的接口请求;

    需求功能:

    1. 同一个接口,需要区分参数进行存储接口名+参数,生成唯一字符串
    2. 支持异步接口请求
    3. 支持promise
    4. 考虑并发的情况,同一接口同时触发的情况
    5. 默认关闭缓存,通过接口参数设置单独开启缓存
    6. 支持设置有效期,过期主动清除,取代惰性删除可能引起的内存溢出

    实现代码:

    /****************** promise方案封装 **********************/
    class ItemCache {
      constructor(promise, timeout) {
          // data可存返回数据,也可存promise
          this.promise = promise
          // 设定超时时间,设定为多少秒
          this.timeout = timeout
          // 创建对象时候的时间,大约设定为数据获得的时间
          this.cacheTime = (new Date()).getTime()
      }
    }
    class ExpriesCache {
      // 定义静态数据map来作为缓存池
      static cacheMap =  new Map()
      // 数据是否超时
      static isOverTime(name) {
          const promise = ExpriesCache.cacheMap.get(name)
          // 没有数据 判定超时
          if (!promise) return true
          // 获取系统当前时间戳
          const currentTime = (new Date()).getTime()        
          // 获取当前时间与存储时间的过去的秒数
          const overTime = (currentTime - promise.cacheTime) / 1000
          // 如果过去的秒数大于当前的超时时间,也返回null让其去服务端取数据
          if (Math.abs(overTime) > promise.timeout) {
              // 惰性清除过期数据
              ExpriesCache.cacheMap.delete(name)
              return true
          }
          // 不超时
          return false
      }
      // 当前data在 cache 中是否超时
      static has(name) {
          return !ExpriesCache.isOverTime(name)
      }
      // 删除 cache 中的 data
      static delete(name) {
          return ExpriesCache.cacheMap.delete(name) 
      }
      // 获取缓存
      static get(name) {
          const isDataOverTiem = ExpriesCache.isOverTime(name)
          console.log(isDataOverTiem)
          //如果 数据超时,返回null,但是没有超时,返回promise
          return isDataOverTiem ? null : ExpriesCache.cacheMap.get(name).promise
      }
      // 设置存储,默认过期时间600秒
      static set(name, promise, timeout = 600) {
          // 设置 itemCache
          const itemCache = new ItemCache(promise, timeout)
          // 缓存
          ExpriesCache.cacheMap.set(name, itemCache)
          // 定时器主动清除过期数据
          setTimeout(()=>{
            console.log('删除过期数据',name)
            ExpriesCache.delete(name)
          }, timeout*1000)
          console.log(ExpriesCache.cacheMap)
      }
      // 声明key接口名 name+参数拼接
      static getName(name,params) {
        const paramsUrl = tool.paramsUrl(params)
        const key = name + paramsUrl
        return key
      }
    }
    
    /****************** 缓存使用 **********************/
    actions.forEach(item => {
      let name = item.name || item.action;
      api[name] = async params => {
        params = params || {}
        for (let i in params) {
          params[i] = params[i] != 0 ? params[i] || '' : params[i];
        }
        let result = await api.getopenid();
        let opendata = {
          openid: result["openid"],
          sign: result["sign"]
        }
        if (item.action === 'get_union_id' || item.action === 'wx_decode_data') {
          opendata["session_key"] = result['session_key'];
        }
    
        // 是否开启缓存,获取属性后删除该参数
        let isCache = params && params.isCache
        params && params.isCache && delete params.isCache
    
        // 生成key
        let key = ExpriesCache.getName(name,params);
        // 获得数据
        let promise = ExpriesCache.get(key)
        if(isCache && promise){
          // 返回缓存数据******
          console.log(key)
          return promise
        }else{
          // 正常请求接口流程
          const promise = new Promise((resolve, reject) => {
            http.request({
              url: item.url,
              data: {
                action: item.action,
                t: Date.now(),
                ...opendata,
                ...params,
              }
            }).then(res => {
              return resolve(res)
            }).catch(err => {
              hideLoading()
              return reject(err)
            })
          })
          // 设置promise缓存
          isCache && ExpriesCache.set(key, promise, 10,) 
          return promise
        }
      }
    })
    

    注:该方案借鉴了其他技术大佬的方案,因大家发的都一样,不知道原作者是谁,故无备注参考文章地址

    展开全文
  • 缓存使用及优化方案

    千次阅读 2018-04-24 01:55:00
    缓存使用及优化方案 关于缓存 在计算机技术里,大家对于缓存一词肯定不陌生,CPU有缓存、数据库有缓存、静态资源缓存CDN、Redis等等; 在这里我们谈的主要是服务器缓存技术,服务端性能优化,最常用的手段就是...
  • 文章目录Pre概影响性能的因素响应时间 与 QPS线程数 与 QPS如何发现瓶颈工具 JProfiler 和 Yourkit如何简单的判断 CPU 是不是瓶颈如何优化系统减少编码减少序列化Java 极致优化并发读优化总结 Pre 小工匠聊架构-...
  • 优化页面访问速度(三) ——服务端优化优化访问速度优化页面访问速度(三)——服务端优化一、概述服务端优化,主要可以通过消息队列、减少数据库请求(缓存)、并发处理、页面静态化等方式处理。二、消息队列1、解决...
  • 对于常规项目,服务端的压力通常来自以下几个方面: 数据处理 1.1 接收请求 1.2 处理请求(响应时间) 数据存储 2.1物理介质存储容量上限 2.2大量数据的存储,影响数据处理速度 物联网项目特点 ...
  • 服务端 缓存使用总结

    千次阅读 2016-09-12 18:28:53
    服务端缓存使用总结缓存类型 localcache memcache redis 区别对比 缓存类型 使用场景 使用示例 优点 缺点 localcache 少量数据,对应用程序只读或读多写少 后台配置,分区信息 无需网络开心,访问速度最快 ...
  • Java秒杀系统方案优化 高性能高并发实战 以“秒杀”这一Java高性能高并发的试金石场景为例,带你通过一系列系统级优化,学会应对高并发。 多种缓存 / 分布式session / RabbitMQ 异步下单 / 图形验证码 / 限流防刷
  • 自动化缓存策略-处理大规模缓存方案 http-Header(协议头部):基于http-Request(请求头部)和http-Response(响应头)来实现的缓存策略 缓存策略(一)cache-control 属性: max-age:指定缓存的有效时间 s-max...
  • 浅谈一下我对查询缓存优化的一些理解,给出几个优化方法和这个方法可以优化的原因1.查询过程中尽量避免使用SELECT *原因: MySQL客户端和服务端的通信协议是半双工的,如果使用select*,会使服务端想应该客户端的数据...
  • 6.3 HTTP:如何减少 HTTP 请求6.4 Cookie—— 减少 Cookie 大小的策略和益处6.5 服务器——缓存配置和优化方案6.5 服务器——如何开启 Gzip 压缩6.6 HTTPS—— 如何开启全站 HTTPS6.7 HTTP2 —— 升级 HTTP2 的好处...
  • geoserver矢量瓦片发服务前端展示偏移问题解决 切图效果失真问题 独立部署GeoWebCache 结语 特别鸣谢大佬李晓晖,通过对他的博文(利用GeoWebCache实现WebGIS地形图展示的缓存优化 - 李晓晖 - 博客园)学习后对...
  • Android性能优化方案

    千次阅读 2022-04-20 20:33:00
    尽可能地减少本地资源的使用,可从技术方案上考虑从服务端拉取图片、lottie、so库等资源。 利用lottie替换帧动画的使用,减少帧动画图片资源的使用。 利用混淆删除无用代码,减少dex文件大小。 响应时间优化 对用户...
  • webpack 缓存问题处理解决方案 导读 在该篇博文中,我们将逐步实现文件hash后缀的输出,修改某个文件,才会对应输出修改该文件的hash后缀,同时满足性能优化,客服端服务端代码同步更新 项目地址:...
  • 服务端渲染(SSR) 通用技术解决方案

    千次阅读 2022-02-24 00:23:00
    项目背景服务端渲染(SSR) 通用技术解决方案的诞生来源于对 360搜索百科移动端项目的一次重构实践。而当时决定重构该项目的主要原因有以下几点:1. 技术栈陈旧,熟悉、开发以及维护成本都...
  • 关于前端缓存优化

    千次阅读 2019-07-04 16:59:08
    关于缓存,大概可以分为以下几种: ① CDN缓存 ② DNS缓存 ③ 客户端缓存(无需请求的memory cache,disk cache;需要发请求验证的Etag/Last-Modified304) ④ Service Worker与缓存及离线缓存 ⑤ PageCache与...
  • Android开发——WebView轻量缓存优化

    千次阅读 2017-11-28 12:56:20
    建议优化流量的消耗,可以对加载画质进行选择。想比淘宝 APP,消耗流量可是大多了。[2017-06-01 21:43:36] 怎么没用有流量节约模式,一会用了我 200M。[2017-06-12 08:32:25] 严选 app 太费流量了。于是乎
  • 前端 api 请求缓存方案

    千次阅读 2019-04-27 10:45:56
    在开发 web 应用程序时,性能都是必不可少的话题。对于webpack打包的单页面应用程序而言,我们可以采用很多方式来对性能进行优化,比方说 tree-shaking...而事实上,缓存一定是提升web应用程序有效方法之一,尤其是...
  • Redis 性能调优——缓存设计优化

    千次阅读 2019-07-31 19:51:18
    Redis 是一个开源的高性能的 Key-Value 服务器。本篇主要介绍一下缓存的设计与优化
  • 一、多级缓存(lua + openresty+redis+mysql ) 思路: 1. 先从openresty的缓存中的数据 如果能获取直接返回。 2. 如果获取不到openresty的数据,再从redis中获取数据,如果能获取,将redis的数据存储到...
  • 前端性能优化的几种方案

    千次阅读 2021-11-27 20:20:52
    前端进行性能优化方案很多,这里只列举部分。在实际应用中不要贪多,想着都用上,要对网站的主要用户群体进行针对性优化。 1、降低请求量 ​ ① 合并资源,减少http请求数量。 ​ ② lazyLoad,如图片懒加载。...
  • Server层负责接收和管理客户端连接、管理缓存、解析SQL、优化SQL、调用存储引擎执行SQL;存储引擎层主要负责存储、查询数据。 一条查询SQL的执行过程 1、连接管理 连接器负责跟客户端建立连接、获取权限、维持和...
  • 分布式缓存详解

    千次阅读 2021-08-25 21:23:54
    常用的两种缓存技术的服务端特点1. Memcache服务端2. Redis服务端二. 缓存结构化选型三. Redis构造大索引回源问题四. 一致性问题1. 并发读写导致的一致性问题2. 主从同步延时导致的一致性问题3. 缓存污染导致的一致...
  • 服务端渲染

    千次阅读 多人点赞 2021-03-18 10:36:12
    SSR (server side render)服务端渲染,是指由服务侧(server side)完成页面的DOM结构拼接,然后发送到浏览器,为其绑定状态与事件,成为完全可交互页面的过程。 CSR(client side render)客户端渲染,是指由...
  • 为了提升用户在Web访问过程的体验,降低网络带宽成本和减轻服务端负载,文章从Web访问过程中本地浏览器端、CDN缓存、服务器端等3个层面来...通过对Web访问过程的缓存优化,大大降低了用户访问时延,提升服务端性能。
  • 数据库优化方案整理

    万次阅读 多人点赞 2018-08-29 16:05:16
    一:优化说明 A:有数据表明,用户可以承受的最大等待时间为8秒。数据库优化策略有很多,设计初期,建立好的数据结构对于后期性能优化至关重要。因为数据库结构是系统的基石,基础打不好,使用各种优化策略,也不能...
  • 本文主要根据现代 WEB服务器的体系架构并结合作者多年网站建设实践经验分别从服务端、客户端、服务器配置和数据通讯压缩等多种不同角度提出了改进网站访问速度, 安全性, 可靠性和稳定性等性能的方法, 并对各方案进行...
  • 瑞吉外卖项目优化-Day01 课程内容 环境搭建 缓存短信验证码 缓存菜品信息 SpringCache 缓存套餐数据 前言 1). 当前系统存在的问题 之前我们已经实现了移动端菜品展示、点餐、购物车、下单等功能,但是由于移动端...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 50,265
精华内容 20,106
关键字:

服务端缓存优化方案