精华内容
下载资源
问答
  • [面试][架构] 集群有哪几种?

    千次阅读 2017-03-02 00:51:37
    前言:我们在做项目的时候经常会用到集群, 在面试的时候也... 部署方式有以下    主从方式:主机工作,备机监控。此方式不能有效的利用服务器资源 互为主从:两服务器同时在线,一台服务器故障可切

    前言:我们在做项目的时候经常会用到集群, 在面试的时候也经常会问到你们有没有用集群, 怎么部署的。 无论你是 web容器集群还是db集群,按照所要解决的问题可以分为如下几种:

    一:高可用集群,提升可用性,(容灾、故障转移), 部署方式有以下三种         

    1. 主从方式:主机工作,备机监控。此方式不能有效的利用服务器资源
    2. 互为主从:两服务器同时在线,一台服务器故障可切换到另一台上。此 方式有效的利用服务器资源,但当服务器故障时候,将导致一台服务器上运行多个业务。
    3. 多台服务器主从:大部分服务器在线使用,小部分监控;若有部分服务器故障,可切换到指定的小部分服务器上。此方式为前两种方式的综合。然后多台服务器群集,也增加了管理的复杂度。

    高可用集群的另外一个特点是共享资源,多个节点服务器共享一个存储资源,该存储可在不同节点之间转移。相关知识: Raid与DAN、SAN、NAS基础

    二:负载均衡集群,LoadBalance, 提升吞吐量

    1. 不同节点之间相互独立,不共享任何资源(硬件,网络, 但应用的会话保持需要一定的策略)。
    2. 通过一定算法将客户端的访问请求分配到群集的各个节点上,充分利用每个节点的资源。
    3. 负载均衡扩展了网络设备和服务器带宽,增加吞吐量,加强网络数据处理能。
    4. 每个节点的性能和配置可能不同,根据算法,可以分配不同的权重到不同节点上,以实现不同节点的资源利用。

    二:并行计算群集,Performance, 减少应答时间

    1. 并行计算或称平行计算是相对于串行计算来说的
    2. 并行计算的能力的目的是提高计算速度。

    并行计算分为时间计算和空间计算:

    1. 时间计算既是流水线技术,一个处理器分为多个单元,每个单元负责不同任务,这些单元可并行计算。
    2. 空间计算利用多个处理器并发的执行计算。目前PC机的计算能力越来越强,将大量低廉的PC机互联起来,组成一个"大型计算机"以解决复杂的计算任务。Beowulf computers为最典型的空间并行计算。




    展开全文
  • 一般来说,实现Apache与Tomcat6的负载均衡种方式,一是使用mod_jk,另一是使用mod_proxy模块。... 无论使用哪种方式,一般都要经过以下个步骤(同一台机器): 修改startup.bat...
    转自:http://blog.csdn.net/jubincn/archive/2009/11/13/4807549.aspx 有待修改

    一般来说,实现Apache与Tomcat6的负载均衡有两种方式,一种是使用mod_jk,另一种是使用mod_proxy模块。本文只讨论mod_jk方式。

    无论使用哪种方式,一般都要经过以下这几个步骤(同一台机器):

    修改startup.bat中的CATALINA_HOME变量的值。因为每个Tomcat实体的CATALINA_HOME都是不一样的,如果设置为系统的环境变量,那么在启动这几个Tomcat时就会出问题。
    设置不同的Tomcat服务器(启动)端口
    对不同的Tomcat实体设置不同的AJP connector
    停止Coyote HTTP/1.1 连接器(Http请求交给Apache Http Server处理)
    在Standalone Engine中设置jvmRoute
    注释掉Catalina Engine
    在worker.properties中配置Tomcat worker
    下面来详细说下详细的配置步骤

    在Tomcat startup.bat中修改CATALINA_HOME的值
    注:这一步跟负载均衡没关系,没有负载均衡也要进行这一步

    首先下载Tomcat6.*.*.zip,解压后进行重命名,复制三个,分别是Tomcat6A,Tomcat6B,Tomcat6C

    startup.bat只是在.zip格式的Tomcat压缩包里才有,使用安装包安装的好像没有。找到这个文件,打开后修改

    对与Tomcat6A:

    set CATALINA_HOME=%CURRENT_DIR%为set CATALINA_HOME=C:\Program Files\Apache Software Foundation\Tomcat6A、

    对于Tomcat6B:

    set CATALINA_HOME=%CURRENT_DIR%为set CATALINA_HOME=C:\Program Files\Apache Software Foundation\Tomcat6B、
    对于Tomcat6C:
    set CATALINA_HOME=%CURRENT_DIR%为set CATALINA_HOME=C:\Program Files\Apache Software Foundation\Tomcat6C、
    设置不同的服务器端口
    注:这一步与负载均衡没有直接关系,是为了处理多个Tomcat的问题,如果这些Tomcat分布在 不同的机器上,应该不会有这个问题
    打开conf/server.xml,找到下面这个标签:
    <Server port="8005" shutdown="SHUTDOWN" debug="0">
    在本例中, Tomcat6A使用8005端口
    Tomcat6B使用8006端口
    Tomcat6C使用8007端口
    设置Tomcat中的AJP连接器接口
    注:这是第一步跟负载均衡直接相关的步骤
    打开conf/server.xml,找到这样一个xml标签:
    <!--Define an AJP1.3 connector on port 8009-->
    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443">
    在本例中, Tomcat6A使用8009端口
    Tomcat6B使用8010端口
    Tomcat6C使用8011端口
    停止监听默认的Http/1.1连接器
    注:这步也是和负载均衡直接相关,但不是负载均衡中的关键,只是个副产品(byproduct)

    为了防止人们直接访问某个Tomcat(因为这样会使负载均衡器失去意义),所以我们要关掉它的HTTP连接器,使得这些Tomcat只能通过AJP协议接收Apache转发过来的请求,因此需要停止HTTP/1.1连接器

    打开conf/server.xml,像下面的代码这样注释掉HTTP/1.1连接器的监听
    <!--Define
    <Connector port="8080" protocol="HTTP/1.1"
    maxThreads="150" connectionTimeout="20000"
    redirectPort="8443 />"
    -->
    在Standalone Engine中设置jvmRoute属性
    注:这是实现负载均衡的关键一步,这一步做了两件事,一是配置了Standalone Engine,二是赋予这个Engine一个id:jvmRoute

    每个Tomcat worker的server.xml中都有有关Engine的配置(语句)。这个Engine是一个和Catalina Engine一样级别最高的Engine,代表整个Catalina Servlet Engine。这条配置语句在server.xml中,jvmRoute的值必须是唯一的,在本例中,各个Tomcat实例的配置如下

    Tomcat6A:

    <!--You should set jvmRoute to support load-balancing via AJP-->

    <Engine name="Standalone" defaultHost="localhost" jvmRoute="Tomcat6A">

    Tomcat6B:

    <!--You should set jvmRoute to support load-balancing via AJP-->

    <Engine name="Standalone" defaultHost="localhost" jvmRoute="Tomcat6A">

    Tomcat6C:

    <!--You should set jvmRoute to support load-balancing via AJP-->

    <Engine name="Standalone" defaultHost="localhost" jvmRoute="Tomcat6A">

    注释掉Catalina Engine
    注:这一步其实可以和上一步合并

    因为我们配置了Standalone Engine,因此需要注释掉Catalina Engine。具体做法是:在server.xml中找到相应代码进行注释,结果如下:、

    <!--

    <Engine name=-"Catalina" defaultHost="localhost">

    -->

    在httpd.conf中配置Tomcat与Apache
    注:粗体字为与负载均衡有直接关系的配置语句

    在Apache Http Server下的conf文件夹中打开httpd.conf,添加下面的语句到其末尾

    LoadModule jk_module modules/mod_jk.so

    JkWorkersFile conf/workers.properties

    JkLogLevel error

    JkLogFile "C:\Program Files\Apache Software Foundation\Apache2.2\logs\mod_jk.Log"

    JkMount /examples/jsp/* bal1
    JkMount /jkstatus/ stat1
    配置workers.proterties
    配置每一个Tomcat实例
    在workers.proterties中每一个Tomcat实例一般有这几个属性需要配置,分别是:

    type(类型): 一般有ajp13(代表Tomcat的worker),lb负载

    host(主机): Tomcat所在机器的ip地址

    port(端口): worker所监听的端口号

    lbfactor(负载权重): 影响负载均衡器在分发请求时所分配的请求数,相对大小更重要

    在本例中,具体配置如下:

    Tomcat6A:

    worker.Tomcat6A.type = ajp13

    worker.Tomcat6A.host = 192.168.9.182

    worker.Tomcat6A.port = 8009

    worker.Tomcat6A.lbfactor=10

    Tomcat6B:

    worker.Tomcat6B.type = ajp13

    worker.Tomcat6B.host = 192.168.9.182

    worker.Tomcat6B.port = 8010

    worker.Tomcat6B.lbfactor = 10

    Tomcat6C:

    worker.Tomcat6C.type = ajp13

    worker.Tomcat6C.host = 192.168.9.182

    worker.Tomcat6C.port = 8011

    worker.Tomcat6C.lbfactor = 10

    (这里的host值就是自己机器的ip地址,需要查看自己的机器的ip地址来替代这个地址)

    在worker.properties中配置负载均衡器
    在worker.properties文件中添加这两条配置语句

    worker.bal1.type = lb

    worker.bal1.sticky_session = 1

    worker.bal1.balance = Tomcat6A, Tomcat6B, Tomcat6C

    sticky_session属性设为1,这样负载均衡器lb就会尽量保持一个session,也就是使用户在一次会话中跟同一个Tomcat进行交互。(我猜如果不能保持跟同一个Tomcat进行交互,也就不能保持一个session)。

    balance属性可以告诉mod_jk模块那些worker由lb负载均衡器控制

    在worker.properties中配置Status Worker
    利用这个Worker,我们可以获得负载的实时统计信息

    在worker.properties中添加

    worker.staat1.type = status

    给mod_jk配置workes.list
    到现在为止,我们已经配置好了三个ajp13 worker,一个lb worker,一个status worker。接下来需要做的就是告诉mod_jk这些worker的信息,在worker.properties中添加这条配置语句就可以做到:

    worker.list = bal1, stat1

    一个配置好的worker.properties实例
    worker.list = bal1, stat1

    worker.Tomcat6A.type = ajp13

    worker.Tomcat6A.host = 192.168.9.182

    worker.Tomcat6A.port = 8009

    worker.Tomcat6A.lbfactor = 10

    worker.Tomcat6B.type = ajp13

    worker.Tomcat6B.host = 192.168.9.182

    worker.Tomcat6B.port = 8010

    worker.Tomcat6B.lbfactor = 10

    worker.Tomcat6C.type = ajp13

    worker.Tomcat6C.host = 192.168.9.182

    worker.Tomcat6C.port = 8011

    worker.Tomcat6C.lbfactor = 10

    worker.bal1.type = lb

    worker.bal1.stick_session = 1

    worker.bal1.balance_workers = Tomcat6A, Tomcat6B, Tomcat6C

    worker.stat1.type = status

    测试配置是否成功
    在Tomcat的目录下找到webapps/examples/jsp/目录下创建一个index.jsp文件,内容如下:

    view plaincopy to clipboardprint?
    <%@page language="java"%>
    <html>
    <body>
    <h1>Index Page Of Tomcat6A</h1>
    </body>
    </html>


    其他两个Tomcat所做的操作类似,只是index.jsp中的内容变了一下,分别是:

    view plaincopy to clipboardprint?
    <%@page language="java"%>
    <html>
    <body>
    <h1>Index Page Of Tomcat6A</h1>
    </body>
    </html>


    view plaincopy to clipboardprint?
    <%@page language="java"%>
    <html>
    <body>
    <h1>Index Page Of Tomcat6A</h1>
    </body>
    </html>


    配好后,重启Tomcat和Apache Http Server,顺序为 关闭Apache->关闭Tomcat->启动Tomcat->启动Apache

    在浏览器中输入http://localhost/examples/jsp/index.jsp,然后运行多个浏览器实例(同一个浏览器的标签式浏览不行,因为很多标签式浏览被设置为共享session),如果出现不同的页面,就说明负载均衡配置成功了。
    展开全文
  • 通过阅读本文你可以学到以下知识: 怎样获取多线程 的结果 获取多线程结果的方式有哪几种? 哪种方式最优雅 Dubbo 的集群容错模式:Forking Cluster 可以怎么实现? ...

    通过阅读本文你可以学到以下知识:

    1. 怎样获取多线程 的结果
    2. 获取多线程结果的方式有哪几种?
    3. 哪种方式最优雅
    4. Dubbo 的集群容错模式:Forking Cluster 可以怎么实现?

    背景

    二胖上次写完参数校验(《二胖写参数校验的坎坷之路》)之后,领导一直不给他安排其他开发任务,就一直让他看看代码熟悉业务。二胖每天上班除了偶尔跟坐在隔壁的前端小姐姐聊聊天,就是看看这些枯燥无味的业务代码,无聊的一匹。虽然二胖已是久经职场的老油条了,但是看到同事们的周报都写的满满的,而自己的周报,就一两行,熟悉了什么功能。心里还是慌得一匹,毕竟公司不养闲人啊。于是乎二胖终于鼓起勇气为了向领导表明自己的上进心,主动向领导要开发任务。领导一看这小伙子这么有上进心,于是就到任务看板里面挑了一个业务逻辑比较简单的任务分配给了二胖。二胖拿到这个任务屁颠屁颠的回到座位。任务比较简单,就是通过爬虫去爬取某些卖机票(某猪、某携、某团等)的网站的一些机票,然后保存到数据库。

    同步入库

    二胖拿到任务,三下五除二就把任务完成了。

     public static void main(String[] args) throws InterruptedException {        String mouZhuFlightPrice = getMouZhuFlightPrice();        String mouXieFlightPrice = getMouXieFlightPrice();        String mouTuanFlightPrice = getMouTuanFlightPrice();        saveDb(mouZhuFlightPrice);        saveDb(mouXieFlightPrice);        saveDb(mouTuanFlightPrice);    }    /**     * 模拟请求某猪网站 爬取机票信息     *     *     * @return     * @throws InterruptedException     */    public static String getMouZhuFlightPrice() throws InterruptedException {        // 模拟请求某猪网站 爬取机票信息        Thread.sleep(10000);        return "获取到某猪网站的机票信息了";    }    /**     * 模拟请求某携网站 爬取机票信息     *     * @return     * @throws InterruptedException     */    public static String getMouXieFlightPrice() throws InterruptedException {        // 模拟请求某携网站 爬取机票信息        Thread.sleep(5000);        return "获取到某携网站的机票信息了";    }    /**     * 模拟请求团网站 爬取机票信息     *     * @return     * @throws InterruptedException     */    public static String getMouTuanFlightPrice() throws InterruptedException {        // 模拟请求某团网站 爬取机票信息        Thread.sleep(3000);        return "获取到某团网站的机票信息了";    }    /**     * 保存 DB     *     * @param flightPriceList     */    public static void saveDb(String flightPriceList) {            // 解析字符串 进行异步入库    }

    这次二胖学乖了,任务完成了先去找下坐他对面的技术大拿(看他那发际线就知道了)同事“二狗”让二狗大拿帮忙指点一二,看看代码是否还能有优化的地方。毕竟领导对代码的性能、以及代码的优雅是有要求的。领导多次在部门的周会上提到让我们多看看“二狗”写的代码,学习下人家写代码的优雅、抽象、封装等等。二狗大概的瞄了下二胖写的代码,提出了个小小的建议“这个代码可以采用多线程来优化下哦,你看某猪这个网站耗时是拿到结果需要 10s,其他的耗时都比它短,先有结果的我们可以先处理的,不需要等到大家都返回了再来处理的”。

    轮循 futureList 获取结果

    幸好二胖对多线程了解一点点,于是乎采用future的方式来实现。二胖使用一个List来保存每个任务返回的Future,然后去轮询这些Future,直到每个Future都已完成。由于需要先完成的任务需要先执行,且不希望出现因为排在前面的任务阻塞导致后面先完成的任务的结果没有及时获取的情况,所以在调用get方式时,需要将超时时间设置为0

      public static void main(String[] args) {        int taskSize = 3;        Future<String> mouZhuFlightPriceFuture = executor.submit(() -> getMouZhuFlightPrice());        Future<String> mouXieFlightPriceFuture = executor.submit(() -> getMouXieFlightPrice());        Future<String> mouTuanFlightPriceFuture = executor.submit(() -> getMouTuanFlightPrice());        List<Future<String>> futureList = new ArrayList<>();        futureList.add(mouZhuFlightPriceFuture);        futureList.add(mouXieFlightPriceFuture);        futureList.add(mouTuanFlightPriceFuture);        // 轮询,获取完成任务的返回结果        while (taskSize > 0) {            for (Future<String> future : futureList) {                String result = null;                try {                    result = future.get(0, TimeUnit.SECONDS);                } catch (InterruptedException e) {                    taskSize--;                    e.printStackTrace();                } catch (ExecutionException e) {                    taskSize--;                    e.printStackTrace();                } catch (TimeoutException e) {                    // 超时异常需要忽略,因为我们设置了等待时间为 0,只要任务没有完成,就会报该异常                }                // 任务已经完成                if (result != null) {                    System.out.println("result=" + result);                    // 从 future 列表中删除已经完成的任务                    futureList.remove(future);                    taskSize--;                    // 此处必须 break,否则会抛出并发修改异常。(也可以通过将 futureList 声明为 CopyOnWriteArrayList 类型解决)                    break; // 进行下一次 while 循环                }            }        }    }

    上述代码有两个小细节需要注意下:

    • 如采用ArrayList的话futureList删除之后需要break进行下一次while循环,否则会产生我们意想不到的ConcurrentModificationException异常。具体原因可看下《ArrayList 的删除姿势你都掌握了吗》这个文章,里面有详细的介绍。

    • 在捕获了InterruptedExceptionExecutionException异常后记得 taskSize--否则就会发生死循环。如果生产发生了死循环你懂的,cpu被你打满,程序假死等。你离被开除也不远了。

    • 上面轮询future列表非常的复杂,而且还有很多异常需要处理,还有很多细节需要考虑,还有被开除的风险。所以这种方案也被pass了。

    自定义 BlockingQueue 实现

    • 上述方案被pass之后,二胖就在思考可以借用哪种数据来实现下先进先出的功能,貌似队列可以实现下这个功能。所以二胖又写了一版采用队列来实现的功能。
      final static ExecutorService executor = new ThreadPoolExecutor(6, 6,            0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());    public static void main(String[] args) throws InterruptedException, ExecutionException {        Future<String> mouZhuFlightPriceFuture = executor.submit(() -> getMouZhuFlightPrice());        Future<String> mouXieFlightPriceFuture = executor.submit(() -> getMouXieFlightPrice());        Future<String> mouTuanFlightPriceFuture = executor.submit(() -> getMouTuanFlightPrice());        // 创建阻塞队列        BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(3);        executor.execute(() -> run(mouZhuFlightPriceFuture, blockingQueue));        executor.execute(() -> run(mouXieFlightPriceFuture, blockingQueue));        executor.execute(() -> run(mouTuanFlightPriceFuture, blockingQueue));        // 异步保存所有机票价格        for (int i = 0; i < 3; i++) {            String result = blockingQueue.take();            System.out.println(result);            saveDb(result);        }    }    private static void run(Future<String> flightPriceFuture, BlockingQueue<String> blockingQueue) {        try {            blockingQueue.put(flightPriceFuture.get());        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }    }
    • 这次比上个版本好多了,代码也简洁多了。不过按理说这种需求应该是大家经常遇到的,应该不需要自己来实现把,JAVA这么贴心的语言应该会有api可以直接拿来用吧。

    CompletionService 实现

    • 二胖现在毕竟也是对代码的简洁性有追求的人了。于是乎二胖去翻翻自己躺在书柜里吃灰的并发相关的书籍,看看是否有解决方案。在这里插入图片描述终于皇天不负有心人在二胖快要放弃的时候突然发现了新大陆。《Java 并发编程实战》一书6.3.5CompletionService:ExecutorBlockingQueue,有这样一段话:

    如果向 Executor 提交了一组计算任务,并且希望在计算完成后获得结果,那么可以保留与每个任务关联的 Future,然后反复使用 get 方法,同时将参数 timeout 指定为 0,从而通过轮询来判断任务是否完成。这种方法虽然可行,但却有些繁琐。幸运的是,还有一种更好的方法:完成服务 CompletionService。

      final static ExecutorService executor = new ThreadPoolExecutor(6, 6,            0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());    public static void main(String[] args) throws ExecutionException, InterruptedException {        CompletionService completionService = new ExecutorCompletionService(executor);        completionService.submit(() -> getMouZhuFlightPrice());        completionService.submit(() -> getMouXieFlightPrice());        completionService.submit(() -> getMouTuanFlightPrice());        for (int i = 0; i < 3; i++) {            String result = (String)completionService.take().get();            System.out.println(result);            saveDb(result);        }    }

    当我们使用了CompletionService不用遍历future列表,也不需要去自定义队列了,代码变得简洁了。下面我们就来分析下CompletionService实现的原理吧。

    CompletionService 介绍

    • 我们可以先看下JDK源码中CompletionServicejavadoc说明吧
    /** * A service that decouples the production of new asynchronous tasks * from the consumption of the results of completed tasks.  Producers * {@code submit} tasks for execution. Consumers {@code take} * completed tasks and process their results in the order they * complete.

    大概意思是CompletionService实现了生产者提交任务和消费者获取结果的解耦,生产者和消费者都不用关心任务的完成顺序,由CompletionService来保证,消费者一定是按照任务完成的先后顺序来获取执行结果。

    成员变量

    public class ExecutorCompletionService<V> implements CompletionService<V> {    // 执行 task 的线程池,创建 CompletionService 必须指定;    private final Executor executor;    //主要用于创建待执行 task;    private final AbstractExecutorService aes;    //存储已完成状态的 task,默认是基于链表结构的阻塞队列 LinkedBlockingQueue。            private final BlockingQueue<Future<V>> completionQueue;

    任务提交

    ExecutorCompletionService任务的提交和执行都是委托给Executor来完成。当提交某个任务时,该任务首先将被包装为一个QueueingFuture

    public Future<V> submit(Callable<V> task) {        if (task == null) throw new NullPointerException();        RunnableFuture<V> f = newTaskFor(task);        executor.execute(new QueueingFuture(f));        return f;    }

    任务完成后何时进入队列

    在这里插入图片描述从源码可以看出,QueueingFutureFutureTask的子类,实现了done方法,在task执行完成之后将当前task添加到completionQueue,将返回结果加入到阻塞队列中,加入的顺序就是任务完成的先后顺序。done方法的具体调用在FutureTaskfinishCompletion方法。

    获取已完成任务

     public Future<V> take() throws InterruptedException {        return completionQueue.take();    }    public Future<V> poll() {        return completionQueue.poll();    }    public Future<V> poll(long timeout, TimeUnit unit)            throws InterruptedException {        return completionQueue.poll(timeout, unit);    }

    takepoll都是调用BlockingQueue提供的方法。

    • take() 获取任务阻塞,直到可以拿到任务为止。
    • poll() 获取任务不阻塞,如果没有获取到任务直接返回null
    • poll(long timeout, TimeUnit unit) 带超时时间等待的获取任务方法(一般推荐使用这种

    总结

    • CompletionService 把线程池 Executor 和阻塞队列 BlockingQueue融合在一起,能够让批异步任务的管理更简单,将生产者提交任务和消费者获取结果的解耦。
    • CompletionService 能够让异步任务的执行结果有序化,先执行完的先进入阻塞队列,利用这个特性,我们可以轻松实现后续处理的有序性,避免无谓的等待。

    结束

    • 由于自己才疏学浅,难免会有纰漏,假如你发现了错误的地方,还望留言给我指出来,我会对其加以修正。
    • 如果你觉得文章还不错,你的转发、分享、赞赏、点赞、留言就是对我最大的鼓励。
    • 感谢您的阅读,十分欢迎并感谢您的关注。

    阅读全文: http://gitbook.cn/gitchat/activity/5f05f223bdff462974330354

    您还可以下载 CSDN 旗下精品原创内容社区 GitChat App ,阅读更多 GitChat 专享技术内容哦。

    FtooAtPSkEJwnW-9xkCLqSTRpBKX

    展开全文
  • kafka个面试题

    2020-10-07 16:16:35
    1.Kafka 的设计时什么样的呢? Kafka将消息以topic为单位进行归纳 将向Kafka topic发布消息的程序成为producers. ...数据传输的事务定义通常有以下级别: (1) 最多一次:消息不会被重复发送,最多被传输一次,..

    1.Kafka 的设计时什么样的呢?

    Kafka将消息以topic为单位进行归纳

    将向Kafka topic发布消息的程序成为producers.

    将预订topics并消费消息的程序成为consumer.

    Kafka以集群的方式运行,可以由一一个或多个服务组成,每个服务叫做一个broker.producers通过网络将消息发送到Kafka集群,集群向消费者提供消息

    2数据传输的事物定义有哪三种?

    数据传输的事务定义通常有以下三种级别:

    (1) 最多一次:消息不会被重复发送,最多被传输一次,但也有可能一-次不传输(2)最少一一次: 消息不会被漏发送,最少被传输一次,但也有可能被重复传输

    (3)精确的一次(Exactly once) :不会漏传输也不会重复传输,每个消息都传输被一次而且仅仅被传输一次,这是大家所期望的

    3.Kafka判断一个节点是否还活着有那两个条件?

    (1)节点必须可以维护和ZooKeeper的连接,Zookeeper 通过心跳机制检查每个节点的连

    (2)如果节点是个fllower,他必须能及时的同步leader的写操作,延时不能太久

    4 producer是否直接将数据发送到broker的leader(主节点)?

    producer直接将数据发送到broker的leader(主节点),不需要在多个节点进行分发,为了帮助producer做到这点,所有的Kafka节点都可以及时的告知:那些节点是活动的,日标topic目标分区的leader在哪,这样producer就可以直授将消息发送到目的地了

    5、 Kafa consumer是否可以消费指定分区消息?

    Kafa consumer 消费消息时,向broker发出"fetch"请求去消费特定分区的消息,consumer指定消息在日志中的偏移量(offset), 就可以消费从这个位置开始的消息,customer 拥有了offset的控制权,可以向后回滚去重新消费之前的消息,这是很有意义的

    需要的点赞+关注,私信我获取,还有更多好货等你来取

    展开全文
  • Redis有哪几种持久化方式?优缺点是什么? Redis 哪些架构模式?讲讲各自的特点 Redis主从是怎么选取的redis插槽的分配? Redis主节点宕机了怎么办,还有没有同步的数据怎么办? Redis集群的话数据分片怎么分...
  • Redis有哪几种持久化方式?优缺点是什么? Redis 哪些架构模式?讲讲各自的特点 Redis主从是怎么选取的redis插槽的分配? Redis主节点宕机了怎么办,还有没有同步的数据怎么办? Redis集群的话数据分片怎么分...
  • 详细的内容放在附件中,以下列出大纲,以后会陆续有新的章节放出   第一章脚本部分写作大纲,包含...2. 说明集群启动和停止的方式有哪几种:start-all.sh/sop-all.sh和start-dfs.sh/stop-dfs.sh等 3. 以start...
  • 我的了解分布式架构主要有以下几种 1::tomcat+nginx+memcached+mysql集群 案例:1个nginx服务器 3个tomcat服务器 1个memcached 类似这种搭建起来的也属于一种分布式架构 对吗 各位?? 2:然后现在炒的...
  • Redis有哪几种持久化方式?优缺点是什么? Redis 哪些架构模式?讲讲各自的特点 Redis主从是怎么选取的redis插槽的分配? Redis主节点宕机了怎么办,还有没有同步的数据怎么办? Redis集群的话数据分片怎么分,...
  • 107.spring boot 配置文件有哪几种类型?它们什么区别? 108.spring boot 哪些方式可以实现热部署? 109.jpa 和 hibernate 什么区别? 110.什么是 spring cloud? 111.spring cloud 断路器的作用是什么? 112....
  • 4.4.6 你知道哪几种垃圾收集器,各自的优缺点,重点讲下cms和G1,包括原理,流程,优缺点。 4.4.7 垃圾回收算法的实现原理。 4.4.8 当出现了内存溢出,你怎么排错。 4.4.9 JVM内存模型的相关知识了解多少,比如重...
  • Redis 的持久化有哪几种方式?不同的持久化机制都什么优缺点?持久化机制具体底层是如何实现的? Redis 集群模式的工作原理能说一下么?在集群模式下,Redis 的 key 是如何寻址的?分布式寻址都哪些算法?了解...
  • 无论哪种新增,完成后都需要查询购物车列表: 判断是否登录 否:直接查询localstorage中数据并展示 是:已登录,则需要先看本地是否数据, :需要提交到后台添加到redis,合并数据,而后查询 否:直接去后台...
  • FailStore目前提供几种实现:leveldb,rocksdb,berkeleydb,mapdb,ltsdb,用于可以自由选择使用种,用户也可以采用SPI扩展使用自己的实现。 流程图 下图是一个标准的实时任务执行流程。 LTS-Admin新版界面预览 ...
  • php高级开发教程说明

    2008-11-27 11:39:22
    哪种方式更好?每一个程序 员会说他(她)的方法最好,但只有那些熟悉两概念—o o p和过程化编程—的人能够作出 判断。 前面提到的每一语言代表一解决问题的特定方法,这些问题多属于具有特殊要求的某 一特殊...
  • CruiseYoung提供的带详细书签的电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 Oracle Database 11g数据库管理艺术(涵盖DBA必知必会的所有数据库管理知识) 基本信息 原书名: Expert Oracle ...
  • 通过微信观察其个人发布的朋友圈乱七八糟的又是否像一个正常个人,如果是,那么从各方面推断其大体是哪种类型的人(职业、文化、性格);若其微信存在绝大部分全都是租房信息可以断定为中介(公寓管理员)。 言不...
  • 支持前端作为mysq通用代理,后端JDBC方式支持Oracle、DB2、SQL Server 、 mongodb 、巨杉。 支持密码加密 支持服务降级 支持IP白名单 支持SQL黑名单、sql注入攻击拦截 支持分表(1.6) 集群基于ZooKeeper管理,在线...
  • 近20年使用Oracle技术产品以及Oracle数据库管理员/Oracle数据库应用管理员的经验,是真正应用集群、性能调优以及数据库内部属性方面的专家。同时是一位演讲家及Oracle ACE。  JARED STILL 从1994年就开始使用...
  • 近20年使用Oracle技术产品以及Oracle数据库管理员/Oracle数据库应用管理员的经验,是真正应用集群、性能调优以及数据库内部属性方面的专家。同时是一位演讲家及Oracle ACE。  JARED STILL 从1994年就开始使用...
  • 说明: 指定 Oracle 使用哪种日历系统作为日期格式。例如, 如果 NLS_CALENDAR 设置为 'Japanese Imperial', 那么日期格式为 'E YY-MM-DD'。即: 如果日期是 1997 年 5 月 15 日, 那么 SYSDATE 显示为 'H 09-05-15'。 ...
  • Redis有哪几种持久化方式?优缺点是什么? Redis 哪些架构模式?讲讲各自的特点 Redis主从是怎么选取的redis插槽的分配? Redis主节点宕机了怎么办,还有没有同步的数据怎么办? Redis集群的话数据分片怎么分...

空空如也

空空如也

1 2
收藏数 24
精华内容 9
关键字:

集群方式有以下哪几种