精华内容
下载资源
问答
  • RTU模式Master端编程.rar

    2021-05-14 16:50:26
    RTU模式Master端编程程序示例
  • mysql模式 master/slave

    2019-04-20 13:40:57
    mysql模式 master/slave
                    author:skate
    time:2012/03/08


    MySQL高可用解决方案
    1.主备模式:master/slave
    2.级联主备模式:A->B->C
    3.mysql双主MMM模式
    4.hearbeat/san,hearbeat/BRBD模式
    5.NDB cluster模式

     

    参考:http://ourmysql.com/archives/758

     

    这里只讲配置,具体的适合应用场景稍后在详述

    1.主备模式:master/slave

    A.master可以停机配置slave
    B.master不允许停机配置slave
    C.添加/删除slave
    D.常用的维护与诊断手册


    A.master可以停机(停止更新)配置slave
    通过"load data from master"语句把master主服务器的数据copy到slave从服务器上,但是这个语句使用是有前提条件的;
    一个是只对myisam表起作用,第二是该语句将会获得全局的读锁,禁止master主库的任何更新,当然热备份就不会有全局
    读锁了。


    mysql的复制基本原理是master对数据库的更新存入master的二进制日志文件里,slave通过读master的二进制日志来完成master和slave的主从同步的。整个同步过程需要三个线程来完成

    master有一个io线程:负责将master的二进制日志发送到slave
    slave有一个io线程和一个sql线程:slave的I/O线程读取master的Binlog Dump线程发送的内容并将该数据拷贝到slave的
    数据目录中的本地文件中,即中继日志。slave的sql线程用于读取中继日志并执行日志中包含的更新。

     

    在复制的环境中用到的文件
    master的文件:
    1.二进制文件
    二进制文件最好放在单独的目录下,这不但对方便优化、更方便维护。重新命名二进制日志很简单,只需要修改[mysqld]里的
    log_bin选项,这里有一点需要注意,如下例子:

    log_bin=/home/mysql/binlog/binlog.log

    [root@localhost ~]# ll /home/mysql/binlog
    total 8
    -rw-rw---- 1 mysql mysql 98 Mar  7 17:24 binlog.000001
    -rw-rw---- 1 mysql mysql 33 Mar  7 17:24 binlog.index
    [root@localhost ~]#

    从上面的例子可以看到,我要重新调整logbin的路径为“/home/mysql/binlog”,但我log_bin的设置却有些不同


    这里需要注意两点
    1).目录的文件夹命名不能有空格
    2).指定目录时候一定要以*.log结尾,即不能仅仅指定到文件夹的级别,否则在重启mysql时会报错。

    2.错误日志
    错误日志对于诊断问题非常重要,第一个要看的就应该是这个文件,类似oracle的alertlog文件。
    它的默认路径是“log-error=/var/log/mysqld.log”。

     

    slave文件
    1.中继日志文件(包括中继日志索引文件)
    中继日志文件和master的二进制文件格式一样,也应该单独维护它,把它单独放在一个目录下,可以通过如下两个参数修改
    --relay-log=file_name
    --relay-log-index=file_name

    和中继日志有关的几个参数
    --max-relay-logs-size=size
    定义中继日志的大小

    --relay-log-info-file=file_name
    从服务器用于记录中继日志相关信息的文件名。默认名为数据目录中的relay-log.info。

    --relay-log-purge={0|1}
    是否自动清空不再需要中继日志时。默认值为1(启用)。这是一个全局变量,可以用SET GLOBAL Relay_log_purge动态更改。

    3.master.info和relay-log.info两个状态文件
    这两个文件都是保存在硬盘上的,服务器异常不会丢失的
    master.info:
    在slave重启时,读取这个文件以确定它已经从主服务器读取了多少二进制日志,默认名字是数据目录下master.info,若要修改其文件名,通过参数 “--master-info-file=file_name”

    relay-log.info:
    在slave重启时,读取这个文件以确定它已经处理了多少二进制日志,默认名字是数据目录下relay-log.info,若要修改其文件名,通过参数“--relay-log-info-file=file_name”

    4.错误日志
    这个和master一样,参考上面,这里就不说了

    5.二进制日志
    当做级联复制时,二进制文件也会启用,和master类似。

     

    停机master复制配置的步骤
    1)确定主从服务器的版本,最好版本一样
    2)在master服务器上建立一个复制用户并授权,用户slave服务器连接取log用。
    3)配置主master,并为slave服务器准备master的备份数据
    4)配置slave服务器
    5)严重配置是否正确

     

    1)确定主从服务器的版本,最好版本一样
    在主从库上运行如下语句,检查版本是否一致
    mysql> select version();

    2)在master服务器上建立一个复制用户并授权,用户slave服务器连接取log用。

    创建复制用户:
    mysql> grant replication slave on *.* to

    展开全文
  • 笔记记录一下 生产环境中,solr难免会部署双机,这个时候就会用到主从模式,而solr的主从模式配置也很简单,详细配置可以参见Solr的主从模式Master-Slave ...

    笔记记录一下

    生产环境中,solr难免会部署双机,这个时候就会用到主从模式,而solr的主从模式配置也很简单,详细配置可以参见Solr的主从模式Master-Slave

    展开全文
  • 并发模式Master-Worker模式核心思想:系统由两类进程协同工作,即Master进程和Worker进程,Master负责接收和分配任务,Wroker负责处理子任务。当各个Worker进程将子任务处理完成后,将结果返回给Master进程,由Master...

    并发模式Master-Worker模式核心思想:系统由两类进程协同工作,即Master进程和Worker进程,Master负责接收和分配任务,Wroker负责处理子任务。当各个Worker进程将子任务处理完成后,将结果返回给Master进程,由Master进程进行汇总,从而得到最终的结果.Master接收到了一个任务,对任务进行拆分,并且分配给各个Worker,让各个Worker之间各自运行各自的子任务,最后Worker们的返回结果交给Master进行汇总并且最后返回给任务的发起方

    主要参与者

    Worker:用于实际处理一个任务;

    Master:任务的分配和最终结果的合成;

    Main:启动程序,调度开启Master。

    package com.neo.study001.radio17;
    
    import java.util.Random;
    
    /**
     * @author liyy
     * @date 2020/5/6 22:41
     */
    public class TestMain {
    
        public static void main(String[] args) {
            Master master = new Master(new Worker(), 10);
            Random random = new Random();
            for (int i = 0; i <= 100; i++) {
                Task task = new Task();
                task.setId(i);
                task.setName("任务" + i);
                task.setPrice(random.nextDouble());
                master.submit(task);
            }
            master.excute();
            long start = System.currentTimeMillis();
            while (true) {
                if (master.isComplete()) {
                    long time= System.currentTimeMillis()-start;
                    double result = master.getResult();
                    System.out.println("最终结果:" + result+",最终耗时:"+time);
                    break;
                }
            }
        }
    
    
    }
    

     

    package com.neo.study001.radio17;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentLinkedQueue;
    
    /**
     * @author liyy
     * @date 2020/5/6 22:15
     */
    public class Master {
        //1.承装任务的集合
        private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<Task>();
    
        //2.承装所有的Worker对象
        private HashMap<String, Thread> workers = new HashMap<String, Thread>();
    
        //3.承装结果集
        private ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<String, Object>();
    
        public Master(Worker worker, int workerCount) {
            worker.setWorkQueue(this.workQueue);
            worker.setResultMap(this.resultMap);
            for (int i = 0; i < workerCount; i++) {
                workers.put("子节点" + i, new Thread(worker));
            }
        }
    
        //提交方法
        public void submit(Task task) {
            this.workQueue.add(task);
        }
    
        public void excute() {
            for (Map.Entry<String, Thread> me : workers.entrySet()) {
                me.getValue().start();
            }
        }
    
        public boolean isComplete() {
            for (Map.Entry<String, Thread> me : workers.entrySet()) {
                if (me.getValue().getState() != Thread.State.TERMINATED) {
                    return false;
                }
            }
            return true;
        }
    
        public double getResult() {
            double sum=0D;
            for (Map.Entry<String, Object> e :
                    resultMap.entrySet()) {
                sum+=(double)e.getValue();
            }
            return sum;
        }
    }
    

     

    package com.neo.study001.radio17;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentLinkedQueue;
    
    /**
     * @author liyy
     * @date 2020/5/6 22:26
     */
    public class Worker implements Runnable {
    
        private ConcurrentLinkedQueue<Task> workQueue;
        private ConcurrentHashMap<String, Object> resultMap;
    
        public void setWorkQueue(ConcurrentLinkedQueue<Task> workQueue) {
            this.workQueue = workQueue;
        }
    
        public void setResultMap(ConcurrentHashMap<String, Object> resultMap) {
            this.resultMap = resultMap;
        }
    
        @Override
        public void run() {
            while (true){
                Task input = this.workQueue.poll();
                if(input==null){
                    break;
                }
                //处理业务逻辑
                Object obj=handle(input);
                this.resultMap.put(Integer.toString(input.getId()),obj);
            }
        }
    
        private Object handle(Task input) {
            Object result=null;
            try {
                Thread.sleep(500);
                result = input.getPrice();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return result;
        }
    
    
    }
    

     

    package com.neo.study001.radio17;
    
    /**
     * @author liyy
     * @date 2020/5/6 22:17
     */
    public class Task {
        private int id;
        private String name;
        private double price;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    }
    
    展开全文
  • 并发模式Master-Worker模式核心思想:系统由两类进程协同工作,即Master进程和Worker进程,Master负责接收和分配任务,Wroker负责处理子任务。当各个Worker进程将子任务处理完成后,将结果返回给Master进程,由Master...

    并发模式Master-Worker模式核心思想:系统由两类进程协同工作,即Master进程和Worker进程,Master负责接收和分配任务,Wroker负责处理子任务。当各个Worker进程将子任务处理完成后,将结果返回给Master进程,由Master进程进行汇总,从而得到最终的结果.Master接收到了一个任务,对任务进行拆分,并且分配给各个Worker,让各个Worker之间各自运行各自的子任务,最后Worker们的返回结果交给Master进行汇总并且最后返回给任务的发起方

    主要参与者

    Worker:用于实际处理一个任务;

    Master:任务的分配和最终结果的合成;

    Main:启动程序,调度开启Master。

    package com.neo.study001.redio17;
    
    import java.util.Random;
    
    /**
     * @author liyy
     * @date 2020/5/6 22:41
     */
    public class TestMain {
    
        public static void main(String[] args) {
            Master master = new Master(new Worker(), 10);
            Random random = new Random();
            for (int i = 0; i <= 100; i++) {
                Task task = new Task();
                task.setId(i);
                task.setName("任务" + i);
                task.setPrice(random.nextDouble());
                master.submit(task);
            }
            master.excute();
            long start = System.currentTimeMillis();
            while (true) {
                if (master.isComplete()) {
                    long time= System.currentTimeMillis()-start;
                    double result = master.getResult();
                    System.out.println("最终结果:" + result+",最终耗时:"+time);
                    break;
                }
            }
        }
    
    
    }
    

     

    package com.neo.study001.redio17;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentLinkedQueue;
    
    /**
     * @author liyy
     * @date 2020/5/6 22:15
     */
    public class Master {
        //1.承装任务的集合
        private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<Task>();
    
        //2.承装所有的Worker对象
        private HashMap<String, Thread> workers = new HashMap<String, Thread>();
    
        //3.承装结果集
        private ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<String, Object>();
    
        public Master(Worker worker, int workerCount) {
            worker.setWorkQueue(this.workQueue);
            worker.setResultMap(this.resultMap);
            for (int i = 0; i < workerCount; i++) {
                workers.put("子节点" + i, new Thread(worker));
            }
        }
    
        //提交方法
        public void submit(Task task) {
            this.workQueue.add(task);
        }
    
        public void excute() {
            for (Map.Entry<String, Thread> me : workers.entrySet()) {
                me.getValue().start();
            }
        }
    
        public boolean isComplete() {
            for (Map.Entry<String, Thread> me : workers.entrySet()) {
                if (me.getValue().getState() != Thread.State.TERMINATED) {
                    return false;
                }
            }
            return true;
        }
    
        public double getResult() {
            double sum=0D;
            for (Map.Entry<String, Object> e :
                    resultMap.entrySet()) {
                sum+=(double)e.getValue();
            }
            return sum;
        }
    }
    

     

    package com.neo.study001.redio17;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentLinkedQueue;
    
    /**
     * @author liyy
     * @date 2020/5/6 22:26
     */
    public class Worker implements Runnable {
    
        private ConcurrentLinkedQueue<Task> workQueue;
        private ConcurrentHashMap<String, Object> resultMap;
    
        public void setWorkQueue(ConcurrentLinkedQueue<Task> workQueue) {
            this.workQueue = workQueue;
        }
    
        public void setResultMap(ConcurrentHashMap<String, Object> resultMap) {
            this.resultMap = resultMap;
        }
    
        @Override
        public void run() {
            while (true){
                Task input = this.workQueue.poll();
                if(input==null){
                    break;
                }
                //处理业务逻辑
                Object obj=handle(input);
                this.resultMap.put(Integer.toString(input.getId()),obj);
            }
        }
    
        private Object handle(Task input) {
            Object result=null;
            try {
                Thread.sleep(500);
                result = input.getPrice();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return result;
        }
    
    
    }
    

     

    package com.neo.study001.redio17;
    
    /**
     * @author liyy
     * @date 2020/5/6 22:17
     */
    public class Task {
        private int id;
        private String name;
        private double price;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    }
    

     

    展开全文
  • 主从模式master-slive

    2020-01-01 09:59:25
    最近看到很多的一些开源组件都在用主从模式,这里记录下主从模式学到的一些东西。 todo
  • Master And Works 模式是一种并发设计模式,主要用于分发相应,用以提高吞吐量 我觉得在模式上,Master可以粗略的类比为Spring前端控制器Dispatcher Servlet,它用于分发请求,具体操作是留给具体(Workers)handler去...
  • 为了避免Slave 线程占用过多的资源,我们主要采取了两个措施。一个是,Master 类所创建的Slave 线程数量为JVM 所在主机的CPU 个数(通过Runtime.getRuntime().availableProcessor()获取);...Master-Slave 模式的应用
  • Master-Worker模式是常用的并行设计模式,可以将大任务划分为小任务,是一种分而治之的设计理念。 系统由两个角色组成,Master和Worker,Master负责接收和分配任务,Worker负责处理任务。子进程处理完成以后,会...
  • 这里面有两个重要角色:Master 、 Worker Master 负责接收和分配任务 ; Worker 负责处理从master分配过来的子任务。 如图:多个客户端发送请求,master处理器接收请求并分组处理,分发给多个worker线程去执行...
  • 环境: spark version :1.5.2 运行模式:standalone 过程分析: 集群上跑着大量任务,但发现集群每运行两天就会挂掉一次。挂掉后集群所有work进程和master进程都会死掉。于是查看w...
  • @ Mongodb主备模式Master/Slave

    千次阅读 2014-07-14 15:43:30
    测试环境: ...192.168.3.24上的MongoDB作为Master,192.168.3.25作为Slave。 分别对应的用户名为 dominic4.com  和dominic5.com 一: Master 启动配置( 这里可以使用一个配置文件) [root@domin
  • 摘要: 如今,为了提高Solr的搜索速度,使其具有很好的容灾能力,往往会配置SolrCloud,但在Solr4之前,还有一种很流行的方式,Master-Slave模式,为什么要提及这种方式,因为我们公司目前用的就是这种方式。...
  • 最近在学习Go语言,在了解Go语言操作数据库的相关知识点时,涉及到了Mysql数据库主从模式搭建相关的只是,因此简单记录一下Linux下Mysql数据库主从模式的搭建流程,以及搭建中遇到的一些问题 1.创建数据库 我用的是...
  • Flink集群standalone模式 Master节点StandaloneSessionClusterEntrypoint启动后,Slave节点TaskManagerRunner无法启动的解决办法 bigdata1是Master节点,bigdata2、bigdata3是Slave节点,在bigdata1执行Flink集群...
  • Master-Worker模式

    2019-09-14 06:25:13
    Master-Worker模式 Master-Worker模式是一种并行计算模式。核心思想是由两个类协同工作:Master负责接收和分配任务,Worker负责处理子任务。当所有的Worker处理完后,由Master归纳总结。好处是可以将一个大任务...
  • 并行设计模式属于设计优化的一部分,它是对一些常用...并行程序设计模式主要有 Future模式Master-Worker模式、Guarded Suspeionsion模式、不变模式和生产者-消费者模式,本文主要讲解 Master-Worker模式 Master
  • 16 Master-Worker模式

    2018-07-01 13:09:55
    6.3 Master-Worker模式Master-Worker模式是常用的并行计算模式,它的核心思想是系统由两类进程协作工作:Master进程和Worker进程。Master负责接收和分配任务,Woker负责处理子任务。当各个Worker子进程处理完后,会...
  • --Master Slave实验 --创建数据目录 $ mkdir /data/1 $ mkdir /data/2 $ mkdir /data/3 --启动mongodb库 $ /data/mongodb-linux-i686-1.6.0/bin/mongod --port 27020 --dbpath /data/1 --master & $ /data/...
  • master/worker工作模式

    2020-01-07 17:48:10
    master/worker模式 master: 读取并验证配置信息。 创建,绑定及关闭套接字。 启动、终止worker进程以及维护worker进程的个数。 平滑重启升级:无须终止服务而重新配置工作。 控制非中断式程序升级,启用新的二进制...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,538
精华内容 5,015
关键字:

模式master