精华内容
下载资源
问答
  • 什么是分布式? 分布式软件系统(Distributed Software Systems)是支持分布式处理的软件系统,是在由通信网络互联的多...分布式缓存系统是为了解决数据库服务器和web服务器之间的瓶颈。 如果一个网站的流量很大,这个...
    什么是分布式?
    分布式软件系统(Distributed Software Systems)是支持分布式处理的软件系统,是在由通信网络互联的多处理机体系结构上执行任务的系统。
    它包括分布式操作系统、分布式程序设计语言及其编译(解释)系统、分布式文件系统和分布式数据库系统等。

    什么是分布式缓存?
    分布式缓存系统是为了解决数据库服务器和web服务器之间的瓶颈。
    如果一个网站的流量很大,这个瓶颈将会非常明显,每次数据库查询耗费的时间将会非常可观。
    对于更新速度不是很快的网站,我们可以用静态化来避免过多的数据库查询。
    对于更新速度以秒计的网站,静态化也不会太理想,可以用缓存系统来构建。
    如果只是单台服务器用作缓存,问题不会太复杂,如果有多台服务器用作缓存,就要考虑缓存服务器的负载均衡。

    什么是分布式事务?
    分布式事务处理(Distributed Transaction Processing,DTP)
    分布式事务处理是指一个事务可能涉及多个数据库操作,分布式事务处理的关键是必须有一种方法可以知道事务在任何地方所做的所有动作,
    提交或回滚事务的决定必须产生统一的结果(全部提交或全部回滚)。
    或 跨越多个服务器的事务称为分布式事务,sql server 可以由DTc microsoft distributed transaction coordinator
    来支持处理分布式事务,可以使用 BEgin distributed transaction 命令启动一个分布式事务处理


    什么是分布式事务??
    就是管理不在同一台服务器上的N条操作的事务。。


    如果在一个事务中,操作的资源只有一个,那这个事务就是本地事务。如果操作的资源不止一个,那们就可以称为分布式事务。这里的资源指数据库的连接,JMS的连接或者其他的一些连接。
    请各位大侠说说自己的看法。

    什么是事务?

    我们将事务 定义为对应用程序状态的相关操作的集合
    事务具有原子性、一致性、隔离性 以及持久性 这几个属性。这些属性统称为 ACID 属性。
    展开全文
  • 1.本地缓存分布式缓存的概念 根据缓存是否与应用进程属于同一进程,缓存可分为本地缓存分布式缓存本地缓存是在同一个进程内的内存空间中缓存数据,数据读写都是在同一个进程内完成。 分布式缓存一般都是独立...

    1.本地缓存与分布式缓存的概念
    根据缓存是否与应用进程属于同一进程,缓存可分为本地缓存与分布式缓存。
    本地缓存是在同一个进程内的内存空间中缓存数据,数据读写都是在同一个进程内完成。
    分布式缓存一般都是独立部署的一个进程,并且与应用进程部署在不同的机器上,故需要通过网络来完成分布式缓存数据读写操作的传输。
    2.本地缓存
    (1)本地缓存的优缺点
    <1>访问速度快,但无法进行大数据缓存。(数据不需要网络传输,但需要占用应用进程的内存空间)
    <2>本地缓存只支持被应用进程访问,一般无法被其他应用进程访问。
    <3>数据随应用进程的重启而丢失。
    (2)应用场景
    本地缓存一般适用于缓存只读数据,如统计类数据。如果数据需要在不同节点部署需要共享和保持一致,则使用分布式缓存。
    (3)本地缓存的实现
    缓存一般使用key-value键值对结构,在java编程中,常用字典包括hashMap和ConcurrentHashMap、谷歌的guava工具包的Cache、ehcache、CaffeineCache
    guava的使用详细地址:https://blog.csdn.net/weixin_37335761/article/details/102643320?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.control

    3.分布式缓存
    (1)分布式缓存的优缺点
    <1>支持大数据量存储,不受应用进程重启的的影响;
    <2>数据集中存储,保证数据一致性。
    <3>数据读写分离,高性能、高可用。
    <4>数据开网络传输。性能低于本地缓存。
    (2)分布式缓存的实现
    MemCached和redis
    具体参考:https://blog.csdn.net/u010013573/article/details/102530682?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.control

    展开全文
  • 本地缓存+分布式缓存1新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一...

    笔记:05、缓存&分布式锁.pdf

    一.缓存使用

    为了系统性能的提升,我们一般都会将部分数据放入缓存中,加速访问。而 db 承担数据落
    盘工作。
    哪些数据适合放入缓存?
     即时性、数据一致性要求不高的
     访问量大且更新频率不高的数据(读多,写少)
    举例:电商类应用,商品分类,商品列表等适合缓存并加一个失效时间(根据数据更新频率
    来定),后台如果发布一个商品,买家需要 5 分钟才能看到新的商品一般还是可以接受的。
    在这里插入图片描述

    1.代码示例

    在这里插入图片描述

    二、缓存分类

    在这里插入图片描述
    问题:
    1).由于本地缓存保存在项目中。当分布式访问时,每次访问的不一定同一个缓存,会产生问题
    2).修改某个应用,无法保证所有应用的数据一致

    在这里插入图片描述
    分布式项目使用本地缓存不合适,可以使用分布式缓存

    2.分布式缓存

    在这里插入图片描述
    redis可以集群,数据库也可以分库、分表

    展开全文
  • 分布式缓存4.1. 前言4.2.使用 一 .前言 二 .广播变量使用 2.1.前言 Flink支持广播。可以将数据广播到TaskManager上,数据存储到内存中。 数据存储在内存中,这样可以减缓大量的shuffle操作;比如在数据join阶段,不...

    一 .前言

    二 .广播变量使用

    2.1.前言

    Flink支持广播。可以将数据广播到TaskManager上,数据存储到内存中。

    数据存储在内存中,这样可以减缓大量的shuffle操作;比如在数据join阶段,不可避免的就是大量的shuffle操作,我们可以把其中一个dataStream广播出去,一直加载到taskManager的内存中,可以直接在内存中拿数据,避免了大量的shuffle,导致集群性能下降;

    广播变量创建后,它可以运行在集群中的任何function上,而不需要多次传递给集群节点。
    另外需要记住,不应该修改广播变量,这样才能确保每个节点获取到的值都是一致的。

    在这里插入图片描述

    • 可以理解广播就是一个公共的共享变量
    • 将一个数据集广播后,不同的Task都可以在节点上获取到
    • 每个节点只存一份
    • 如果不使用广播,每一个Task都会拷贝一份数据集,造成内存资源浪费

    2.2. 使用

    • 在需要使用广播的操作后,使用withBroadcastSet创建广播
    • 在操作中,使用getRuntimeContext.getBroadcastVariable[广播数据类型](广播名)获取广播变量
    package com.boyi.broadcast
    
    
    import org.apache.flink.api.common.functions.RichMapFunction
    import org.apache.flink.api.scala._
    import org.apache.flink.configuration.Configuration
    
    object BroadCastDemo {
    
    
      def main(args: Array[String]): Unit = {
        // 1. 获取`ExecutionEnvironment`运行环境
        val env = ExecutionEnvironment.getExecutionEnvironment
    
        // 1. 分别创建两个数据集
        val studentDataSet: DataSet[(Int, String)] = env.fromCollection(List((1, "张三"), (2, "李四"), (3, "王五")))
        val scoreDataSet: DataSet[(Int, String, Int)] = env.fromCollection(List((1, "语文", 50), (2, "数学", 70), (3, "英文", 86)))
    
        // 1. 使用`RichMapFunction`对`成绩`数据集进行map转换
        // 将成绩数据(学生ID,学科,成绩) -> (学生姓名,学科,成绩)
        val resultDataSet: DataSet[(String, String, Int)] = scoreDataSet.map(new RichMapFunction[(Int, String, Int), (String, String, Int)] {
    
          var bc_studentList: List[(Int, String)] = null
    
          // - 重写`open`方法中,获取广播数据
          override def open(parameters: Configuration): Unit = {
            import scala.collection.JavaConverters._
            bc_studentList = getRuntimeContext.getBroadcastVariable[(Int, String)]("bc_student").asScala.toList
          }
    
          //   - 在`map`方法中使用广播进行转换
          override def map(value: (Int, String, Int)): (String, String, Int) = {
            // 获取学生ID
            val studentId: Int = value._1
            // 过滤出和学生ID相同的内容
            val tuples: List[(Int, String)] = bc_studentList.filter((x: (Int, String)) => x._1 == studentId)
            // 构建元组
            (tuples(0)._2,value._2,value._3)
          }
        }).withBroadcastSet(studentDataSet, "bc_student")
    
        // 3. 打印测试
        resultDataSet.print()
      }
    
    }
    

    三 .累加器

    3.1. 前言

    Accumulator 即累加器,与 MapReduce counter 的应用场景差不多,都能很好地观察task在运行期间的数据变化
    可以在Flink job任务中的算子函数中操作累加器,但是只能在任务执行结束之后才能获得累加器的最终结果。

    Flink现在有以下内置累加器。每个累加器都实现了Accumulator接口。

    • IntCounter
    • LongCounter
    • DoubleCounter

    3.2. 使用

    遍历下列数据, 打印出单词的总数

    "a","b","c","d"
    

    开发步骤:

    1. 获取批处理环境
    2. 加载本地集合
    3. map转换
      1. 定义累加器
      2. 注册累加器
      3. 累加数据
    4. 数据写入到文件中
    5. 执行任务,获取任务执行结果对象(JobExecutionResult)
    6. 获取累加器数值
    7. 打印数值
    package com.boyi.broadcast
    
    import org.apache.flink.api.common.accumulators.IntCounter
    import org.apache.flink.api.common.functions.RichMapFunction
    import org.apache.flink.api.scala.ExecutionEnvironment
    import org.apache.flink.configuration.Configuration
    
    /**
     * counter 累加器
     */
    object BatchDemoCounter {
      def main(args: Array[String]): Unit = {
        //获取执行环境
        val env = ExecutionEnvironment.getExecutionEnvironment
    
        import org.apache.flink.api.scala._
    
        val data = env.fromElements("a","b","c","d")
    
        val res = data.map(new RichMapFunction[String,String] {
          //1:定义累加器
          val numLines = new IntCounter
    
          override def open(parameters: Configuration): Unit = {
            super.open(parameters)
            //2:注册累加器
            getRuntimeContext.addAccumulator("num-lines",this.numLines)
          }
    
          var sum = 0;
          override def map(value: String) = {
            //如果并行度为1,使用普通的累加求和即可,但是设置多个并行度,则普通的累加求和结果就不准了
            sum += 1;
            System.out.println("sum:"+sum);
            this.numLines.add(1)
            value
          }
    
        }).setParallelism(1)
    
       res.writeAsText("/opt/a/tmp/BatchDemoCounter")
        val jobResult = env.execute("BatchDemoCounterScala")
        //    //3:获取累加器
        val num = jobResult.getAccumulatorResult[Int]("num-lines")
    
        println("num:"+num)
    
      }
    }
    
    

    四 .分布式缓存

    4.1. 前言

    Flink提供了一个类似于Hadoop的分布式缓存,让并行运行实例的函数可以在本地访问。
    这个功能可以被使用来分享外部静态的数据.

    缓存的使用流程:

    使用ExecutionEnvironment实例对本地的或者远程的文件(例如:HDFS上的文件),为缓存文件指定一个名字注册该缓存文件。当程序执行时候,Flink会自动将复制文件或者目录到所有worker节点的本地文件系统中,函数可以根据名字去该节点的本地文件系统中检索该文件!

    注意:广播是将变量分发到各个worker节点的内存上,分布式缓存是将文件缓存到各个worker节点上

    4.2.使用

    遍历下列数据, 并在open方法中获取缓存的文件

    a,b,c,d
    
    
    import org.apache.commons.io.FileUtils
    import org.apache.flink.api.common.functions.RichMapFunction
    import org.apache.flink.api.scala.ExecutionEnvironment
    import org.apache.flink.configuration.Configuration
    
    /**
     * 分布式缓存
     */
    object BatchDemoDisCache {
      def main(args: Array[String]): Unit = {
        //获取执行环境
        val env = ExecutionEnvironment.getExecutionEnvironment
    
        //隐式转换
        import org.apache.flink.api.scala._
    
        //1:注册文件
        env.registerCachedFile("/opt/a/tmp/BatchDemoDisCache.txt","BatchDemoDisCache.txt")
    
        //读取数据
        val data = env.fromElements("a","b","c","d")
        val result = data.map(new RichMapFunction[String,String] {
    
          override def open(parameters: Configuration): Unit = {
            super.open(parameters)
            //访问数据
            val myFile = getRuntimeContext.getDistributedCache.getFile("BatchDemoDisCache.txt")
            val lines = FileUtils.readLines(myFile)
            val it = lines.iterator()
            while (it.hasNext){
              val line = it.next();
              println("line:"+line)
            }
          }
          override def map(value: String) = {
            value
          }
        })
        result.print()
      }
    }
    
    

    地址: https://github.com/BoYiZhang/flink-demo

    展开全文
  • 1:本地缓存分布式缓存 性能提升大神器:缓存,我们合理利用缓存就可以对系统性能有一个大提升,当然使用缓存也会有很多的问题,我们就一起提升解决 通过以前的性能优化,我们可以优化它的业务逻辑来增加它的...
  • 2.本地缓存分布式缓存 本地缓存适用于单机应用,比如map做本地缓存,就是 如果是分布式情况下 分布式本地缓存带来的问题 1)缓存不共享 在这种情况下,每个服务都有一个缓存,但是这个缓存并不
  • 如何实现本地缓存分布式缓存1)本地缓存分布式缓存1.1)本地缓存1.1)分布式缓存2)知识扩展2.1)EhCache 和 Guava 的使用及特点分析2.2)LRU 和 LFU 的区别3)EhCache 基础使用4)手动实现一个缓存系统5)小结 ...
  • 本地缓存分布式缓存的比较: 分布式缓存一致性更好一点,本地缓存 每个实例都有自己的缓存,可能会存在不一致的情况。 本地缓存会占用堆内存,影响垃圾回收、影响系统性能。分布式缓存两大开销会导致其慢于本地...
  • 缓存既然如此重要,那本课时我们就来重点看一下,应该如何实现本地缓存分布式缓存? 典型回答 本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地缓存的操
  • 一,缓存的使用 1,那些数据适合放入缓存? 及时性,数据一致性要求不高的数据;访问量大且更新频率不高的数据(读多写少) 2,本地缓存(Map): ...3,分布式缓存-缓存中间件(这里采用Red...
  • 缓存既然如此重要,那本课时我们就来重点看一下,应该如何实现本地缓存分布式缓存? 典型回答 本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地
  • 缓存是什么,有什么作用? ...程序级别的缓存组件,特点是本地缓存和应用程序会在运行同一个进程中,本地缓存的操作特别快,在同一个进程中不会有网络上的延迟和开销。 本地缓存适用于单节点非集群
  • SpringBoot:第四篇 集成Guava(本地缓存+分布式缓存) 本地缓存+分布式缓存(redis)构建二级缓存 (1)解决redis 热key (2)redis缓存io读写,毫秒级响应,本地缓存响应时间更短,亚秒级;对于响应要求更高的服务 ...
  • 一、缓存的概念 在服务端编程当中,缓存主要是指将数据库的数据加载到内存中,之后对该数据的访问都在...根据缓存是否与应用进程属于同一进程,可以将内存分为本地缓存分布式缓存本地缓存是在同一个进程内的...
  • 本地缓存:指的是在应用中的缓存组件,是应用和cache是在同一个进程内部,单应用不需要集群支持或者集群情况下各节点无需互相通知的场景下使用本地缓存较合适; 分布式缓存:应用分离的缓存组件或服务,是自身就是...
  • 本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地缓存的操作会非常快,因为在同一个进程内也意味着不会有网络上的延迟和开销。 本地缓存适用于单节
  • 1、首先对于本地内存缓存,就是把数据缓存在本机的内存中,如下图1所示: ...当我们在应用中使用跨进程的缓存机制,例如分布式缓存memcached或者微软的AppFabric,此时数据被缓存在应用...
  • 其实这个阶段拿出分布式缓存,有些早,前期主要用的是本地缓存,我使用到的技术主要是ehcahe,这个内存基本就存在你应用运行的服务器上面,这个有个很大的问题就是,不适合长久存储,如果长久存储,数据量很大的时候...
  • 151、缓存-缓存使用-本地缓存分布式缓存 152、缓存-缓存使用-整合redis测试 153、缓存-缓存使用-改造三级分类业务 154、缓存-缓存使用-压力测试出的内存泄露及解决 155、缓存-缓存使用-缓存击穿、穿透、雪崩 156、...
  • 在现在的系统架构中,缓存的地位可以说是非常高的。因为在互联网的时代,请求的并发量可能会非常高,但是关系型数据库对于高并发的处理能力并不是非常强,而缓存由于是在内存中处理,并不需要磁盘的IO,所以非常适合...
  • title: 学习笔记:cache 和spring cache 技术—本地缓存-分布式缓存,缓存穿透,雪崩,和热点key的问题 author: Eric liu tags: [] categories: hexo JVM缓存(本地缓存)将数据缓存在JVM中,使用Map或者Guava的...
  • 如图1所示,缓存的使用可以出现在1~4的各个环节中,每个环节的缓存方案与使用各有特点。 1 缓存特征 缓存是一个数据模型对象,有它的一些特征 1.1 命中率 命中率=返回正确结果数/请求缓存次数 命中率问题是缓存中的...
  • 分布式事务来由 分布式事务难点分析 分布式事务分类 强事务之Seata两阶段提交AT模式 强事务之Seata-XA协议 强事务之Seata-TCC方式 弱事务之Seata-Saga模式 弱事务之本地消息表 分布式事务总结 分布式配置和链路追踪 ...
  • 01 介绍本地缓存分布式缓存 分布式缓存 与应用分离的缓存组件或服务,与本地应用隔离一个独 立的应用,多个应用可直接的共享缓存 常⻅的分布式缓存 Redis、Memcached等 本地缓存 和业务程序一起的缓存...
  • RMI方式缓存集群/配置分布式缓存

    千次阅读 2016-10-25 18:05:34
    RMI方式缓存集群/配置分布式缓存 RMI 是 Java 的一种远程方法调用技术,是一种点对点的基于 Java 对象的通讯方式。EhCache 从 1.2 版本开始就支持 RMI 方式的缓存集群。在集群环境中 EhCache 所有缓存对象的键和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 131,060
精华内容 52,424
关键字:

本地缓存/分布式缓存