精华内容
下载资源
问答
  • 日志DLL(高并发)

    2011-03-02 13:34:11
    适用于普通程序、高并发程序、服务程序的日志记录。 1.采用多线程技术进行对日志的记录。 2.在日志过程中还可以正常使用正在记录的日志文件。 3.在产生日志的同时将一些重要的日志直接在DebugView中显示。(只要...
  • 读写分离的由来(高可用、高并发、高吞吐)2.读写分离的目的3.什么时候进行读写分离4.读写分离的优点二、读写分离具体在django项目中的应用第一步:settings中配置数据库第二步:模型同步第三步:配置读写分离① 在...

    一、读写分离


    1.读写分离的由来(高可用、高并发、高吞吐)


    在实际生产中,由单台mysql作为独立的数据库是完全不能满足实际需求的,无论在安全性,高可用性高并发性以及高吞吐高可用、高并发)等各个方面。因此,一般来说都是通过主从复制(Master-Slave)的方式来同步数据,再通过读写分离来提升数据库的并发负载能力 这样的方案来进行部署与实施的。
    读写分离 基本的原理是让主数据库处理增删改操作(INSERT、DELETE、UPDATE),而从数据库处理SELECT查询操作。


    2.读写分离的目的


    数据库的写操作是比较耗时的(写10000条数据到oracle可能要3分钟)。但数据库的读操作速度较快(从oracle读10000条数据可能只要5秒钟)。
    所以读写分离解决的是,数据库的写入,影响查询的效率。


    3.什么时候进行读写分离


    数据库不一定要读写分离,如果程序使用数据库较多,更新少,查询多的时候情况下会考虑使用,利用数据库主从同步。


    4.读写分离的优点


    可以减少数据库的压力,提高性能。
    主从复制以及读写分离在实际应用中,对于 都在同一个数据库服务器中,是不能满足实际需求的。无论是在安全性、高可用性还是高并发性等各个方面都是不能完全满足实际需求的。因此,通过主从复制的方式来同步数据、再通过读写分离来提升数据库的并发负载能力。


    二、读写分离具体在django项目中的应用


    第一步:settings中配置数据库


    在这里插入图片描述
    在这里插入图片描述
    涉及到 django服务如何选择使用数据库:

    写:master —》 default

    读: slave库 ——》 slave


    第二步:模型同步


    如果使用mysql数据库首先应该建库 ,使用sqllit3 不需要创建库

    进行数据的迁移,同步表结构,但只需要同步到slave数据库中

    在这里插入图片描述


    第三步:配置读写分离


    将读写分别使用不同的数据库
    自动模式

    重写方法:

    • 重写的是 数据库路由提供的方法
    • db_for_read() 读数据库的配置 slave
    • db_for_write() 写数据库的配置 master -》 default

    ① 在项目的主目录中创建一个脚本文件,自定义数据库路由


    在这里插入图片描述


    ② 在settings中配置


    配置指定的数据库路由
    在这里插入图片描述


    ③使用


    注册后,不能用注册的账号登录

    发现
    在主数据库中有注册的用户
    在这里插入图片描述
    而在从数据库中却没有该用户的信息
    在这里插入图片描述
    按照配置,将数据写在了master库,没有写在slave库中

    原因: 数据库之间进行数据同步,需要在数据库中进行配置


    三、 配置一主多从


    1. 一主多从概念


    在这里插入图片描述
    问题: 如何选择slave,数据库集群关于选择slave加一个权重,负载均衡


    2. 随机选择slave库处理


    第一步:在settings中配置多个从库


    在这里插入图片描述


    第二步: 在py文件中加上random函数,随机选择从库


    在这里插入图片描述


    四、如果是使用mysql数据库,那么只需改动数据库配置


    在这里插入图片描述


    五、一主多从方案(随机和分库分表)


    https://blog.csdn.net/oLingTing/article/details/92649272
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    一主多从方案

    在这里插入图片描述


    展开全文
  • 我们可以简单的认为 AOF 就是日志文件,此文件只会记录“变更操作”(例如:set/del 等),如果 server 中持续的大量变更操作,将会导致 AOF 文件非常的庞大,意味着 server 失效后,数据恢复的过程将会很长;...
  • 14.3.1 XML文件 14.3.2 读取XML文件 14.4 内存中的XML处理 14.4.1 XmlDocument 14.4.2 XPathNavigator 14.4.3 XDocument 14.5 搜索XML内容 14.5.1 搜索XmlDocument 14.5.2 使用XPath搜索Xml...
  • 14.3.1 XML文件 14.3.2 读取XML文件 14.4 内存中的XML处理 14.4.1 XmlDocument 14.4.2 XPathNavigator 14.4.3 XDocument 14.5 搜索XML内容 14.5.1 搜索XmlDocument 14.5.2 使用XPath搜索Xml...
  • 郝林第二版 Go并发编程书籍PDF版,带高清目录 第1章 初识Go语言 1 1.1 语言特性 1 1.2 安装和设置 2 1.3 工程结构 3 1.3.1 工作区 3 1.3.2 GOPATH 4 1.3.3 源码文件 5 1.3.4 代码包...
  • 发送供客户端下载的文件、读取并保存客户端的上传文件、动态生成图像并发送给客户端、读取客户端的cookie以及向客户端Cookie、访问Servlet容器为Web应用提供的工作目录、在一个Web应用内,通过请求转发、包含和...

    本章将会进一步介绍Servlet的一些高级用法:发送供客户端下载的文件、读取并保存客户端的上传文件、动态生成图像并发送给客户端、读取客户端的cookie以及向客户端写Cookie、访问Servlet容器为Web应用提供的工作目录、在同一个Web应用内,通过请求转发、包含和重定向等关系来进行Web组件之间的合作;访问Servlet容器内的其他Web应用、处理由多个客户端同时访问Web应用中的相同资源导致的并发问题。

    1.    下载文件

    下载文件是指把服务器端的文件发送到客户端,Servlet能够向客户端发送任意格式的文件数据。下面例程的DownloadServlet类线获得请求参数filename,该参数代表客户端请求下载的文件的名字。DownloadServlet类接下来通过ServletContext()的getResourceAsStream方法,得到一个用于读取/store目录下的响应文件的输入流,再调用response.getOutputStream方法,得到一个用于输出响应正文的输出流。DownloadServlet然后通过输入流读取文件中的数据,并通过输出流把文件中的数据发送到客户端。
    DownloadServle.java

    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    
    public class DownloadServlet extends HttpServlet {
        @Override
        public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            OutputStream out;
            InputStream in ;
            String filename = req.getParameter("filename");
    
            if (filename == null){
                out = resp.getOutputStream();
                out.write("Please input filename.".getBytes());
                out.close();
                return;
            }
            in = getServletContext().getResourceAsStream("/store/"+filename) ;
            int length = in.available();
            resp.setContentType("application/force-download");
            resp.setHeader("Content-Length",String.valueOf(length));
            resp.setHeader("Content-Disposition","attachment;filename=\""+filename+"\"");
    
            /**把本地文件中的数据发送给客户**/
            out = resp.getOutputStream();
            int bytesRead = 0;
            byte[] buffer = new byte[512];
            while ((bytesRead = in.read(buffer)) != -1){
                out.write(buffer,0,bytesRead);
            }
        }
    }
    
    程序演示:创建一个web/store文件夹,将一个Example.rar文件放在该文件夹下。在web.xml中配置路由为/download,运行应用后在浏览器访问: localhost:8080/download?filename=Example.rar,就会自动弹出下载页面,可以下载该文件到客户端。下面,如果尝试输入一个不存在的文件名,比如localhost:8080/download?filename=NotExist,会返回一个异常页面:

    2.    上传文件

    上传文件是指把客户端的文件发送到服务器端。当客户端向服务器上传文件时,客户端发送的HTTP请求正文采用“multipart/form-data”数据类型,它表示复杂的包括多个子部分的符合表单。下面例程的 upload..html定义了一个用于上传文件的复合表单,它有一个名字为“username”的输入框,还有两个用于指定上传文件的文件域。

    upload.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Upload</title>
    </head>
    <body>
        <form name="uploadForm" method="post"
              enctype="multipart/form-data"
              action="upload">
            <table>
                <tr>
                    <td><div align="right">User Name:</div></td>
                    <td><input type="text" name="username" size="30"/> </td>
                </tr>
                <tr>
                    <td><div align="right">Upload File1:</div> </td>
                    <td><input type="file" name="file1" size="30"/> </td>
                </tr>
                <tr>
                    <td><div align="right">Upload File2:</div> </td>
                    <td><input type="file" name="file2" size="30"/> </td>
                </tr>
                <tr>
                    <td><input type="submit" name="submit" value="sunmit"></td>
                    <td><input type="reset" name="reset" value="reset"></td>
                </tr>
            </table>
        </form>
    </body>
    </html>
    不管HTTP请求正文为何种数据类型,Servlet容器都会把HTTP请求包装成一个HttpServletRequest对象。当请求正文为“multipart/form-data”数据类型时,Servlet直接从HttpServletRequest对象中解析出复合表单的每个子部分仍然是一项复杂的工作。为了简化对“multipart/form-data”类型数据的处理过程,可以利用Apache开源软件组织提供的两个软件包来实现文件上传。
    • fileupload软件包(commons-fileupload-版本号.jar):负责上传文件的软件包,百度一下就能找到。
    • io软件包(commons-io-版本号.jar):负责输入输出的软件包。

    将这两个软件包的jar文件都放在/WEB-INF/lib目录下(使用IDEA进行开发,不要忘记将两个jar包add到工程中)。Servlet主要利用fileupload包中的接口和类来实现文件上传,而fileupload软件包本身依赖io软件包。

    对于一个正文部分为“multipart/form-data”类型的HTTP请求,uploadfile软件包把请求正文包含的复合表单的每个子部分看作是一个FileItem对象。FileItem对象分为两种类型:

    • formFiled:普通表单域类型,表单中的文本框和提交按钮等都是这种类型。
    • 非formField:上传文件类型,表单中的文件域就是这种类型,它包含了文件数据。

    FileItemFactory是创建FileItem对象的工厂,DiskFileItemFactory类和DiskFileItem类分别实现了FileItemFactory和FileItem接口。DiskFileItem类表示基于硬盘的FileItem,DiskFileItem类能够把客户端上传的文件数据保存到硬盘上,DiskFileItemFactory则是创建DiskFileItem的工厂。

    以下程序代码创建了一个DiskFileItemFactory对象,然后设置了在向硬盘写数据时所用的缓冲区的大小,以及所使用的临时目录。在fileupload软件包自身的实现中,为了提高向硬盘写数据的效率,尤其是写大容量数据的效率,fileupload软件包在写数据时会使用缓存,以及向临时目录存放一些临时数据。

            //创建一个基于硬盘的FileItem工厂
            DiskFileItemFactory factory = new DiskFileItemFactory();
            //设置想硬盘写数据时所用的缓冲区的大小,此处为4k
            factory.setSizeThreshold(4*1024);
            //设置临时目录
            factory.setRepository(new File(tempItemPath));
    ServletFileUpload类为文件上传处理器,它与FileItemFactory关联。以下程序代码创建了一个该对象,它与一个DiskFileItemFactory对象关联。ServletFileUpload类的setSizeMax()方法用来设置允许上传的文件的最大尺寸。
            //创建一个文件上传处理器
            ServletFileUpload servletFileUpload = new ServletFileUpload(factory);
            //设置允许上传的文件的最大尺寸,此处为4M
            servletFileUpload.setSizeMax(4*1024*1024);
    ServletFileUpload类的parseRequest(HttpServletRequest req)方法能够解析HttpServletRequest对象中的复合表单数据,返回包含一组FileItem对象的List集合:
    List items = upload.parseRequest(req);
    在得到了包含FileItem对象的List集合后,就可以遍历这个集合,判断每个FileItem对象的类型然后作出相应的处理。
            while (iter.hasNext()){
                FileItem item = (FileItem)iter.next();
                if (item.isFormField()){
                    //处理普通的表单域
                    //...
                }else{
                    //处理上传文件
                    //...
                }
            }

    例程UploadServlet类利用fileupload包来处理用户在upload.html中上传的文件。

    UploadServlet.java

    import org.apache.commons.fileupload.FileItem;
    import org.apache.commons.fileupload.disk.DiskFileItemFactory;
    import org.apache.commons.fileupload.servlet.ServletFileUpload;
    
    import javax.servlet.ServletConfig;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.File;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.Iterator;
    import java.util.List;
    
    public class UploadServlet extends HttpServlet{
        private String filePath;
        private String tempFilePath;
    
        @Override
        public void init(ServletConfig config) throws ServletException {
            super.init(config);
            filePath = config.getInitParameter("filePath");
            System.out.println("config.getInitParameter(filePath):"+filePath);
            tempFilePath = config.getInitParameter("tempFilePath");
            filePath = getServletContext().getRealPath(filePath);
            System.out.println("RealPath:"+filePath);
            tempFilePath = getServletContext().getRealPath(tempFilePath);
        }
    
        @Override
        public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.setContentType("text/plain");
            PrintWriter outNet = resp.getWriter();
            try {
                DiskFileItemFactory factory = new DiskFileItemFactory();
                factory.setSizeThreshold(4*1024);
                factory.setRepository(new File(tempFilePath));
                ServletFileUpload upload = new ServletFileUpload(factory);
                upload.setSizeMax(4*1024*1024);
    
                List items = upload.parseRequest(req);
    
                Iterator iter = items.iterator();
                while (iter.hasNext()){
                    FileItem item = (FileItem)iter.next();
                    if (item.isFormField()){
                        processFormField(item,outNet);
                    }else {
                        processUploadedFile(item,outNet);
                    }
                }
                outNet.close();
            }catch (Exception e){throw new ServletException(e);}
        }
        private void processFormField(FileItem item,PrintWriter outNet){
            String name = item.getFieldName();
            String value = item.getString();
            outNet.println(name+":"+value+"\r\n");
        }
        private void processUploadedFile(FileItem item,PrintWriter outNet) throws Exception{
            String filename = item.getName();
            int index = filename.lastIndexOf("\\");
            filename = filename.substring(index+1,filename.length());
            long fileSize = item.getSize();
    
            if (filename.equals("") && fileSize == 0) return;
    
            File UploadFile = new File(filePath+"/"+filename);
            item.write(UploadFile);
            outNet.println(filename+" is saved.");
            outNet.println("The size of "+filename+" is "+ fileSize+"\r\n");
        }
    }
    
    然后配置web.xml
        <servlet>
            <servlet-name>UploadServlet</servlet-name>
            <servlet-class>UploadServlet</servlet-class>
            <init-param>
                <param-name>filePath</param-name>
                <param-value>store</param-value>
            </init-param>
            <init-param>
                <param-name>tempFilePath</param-name>
                <param-value>temp</param-value>
            </init-param>
        </servlet>
        <servlet-mapping>
            <servlet-name>UploadServlet</servlet-name>
            <url-pattern>/upload</url-pattern>
        </servlet-mapping>

    配置完成后,运行应用,访问localhost:8080/upload.html,选择两个小于4MB的文件,上传就会看到页面跳转到/upload,显示了成功保存的对应信息。注意,如果选择了大小大于4MB的文件,就会点击提交后就会报错,在tomcat的日志中也会看到对应的错误信息。

    注意UploadServlet的init()方法中对于路径的处理,对控制台打印出来的相对路径和真实路径进行分析,要分得清相对路径和真实路径分别是从哪里获取的。

    展开全文
  • MySQL主从复制与读写分离

    千次阅读 多人点赞 2021-02-23 19:03:53
    无论是在安全性、高可用性还是高并发等各个方面都是完全不能满足实际需求的。因此,通过主从复制的方式来同步数据,再通过读写分离来提升数据库的并发负载能力。有点类似于rsync,但是不同的是rsync是对磁盘文件做...


    前言
    在实际的生产环境中,对数据库的读和写都在同一个数据库服务器中,是不能满足实际需求的。无论是在安全性、高可用性还是高并发等各个方面都是完全不能满足实际需求的。因此,通过主从复制的方式来同步数据,再通过读写分离来提升数据库的并发负载能力。有点类似于rsync,但是不同的是rsync是对磁盘文件做备份,而mysql主从复制是对数据库中的数据、语句做备份。

    一、MySQL 主从复制原理

    1、MySQL 支持的复制类型

    基于语句的复制(STATEMENT):在主服务器上执行的 SQL 语句,在从服务器上执行同样的语句。MySQL 默认采用基于语句的复制,效率比较高。
    基于行的复制(ROW):把改变的内容复制过去,而不是把命令在从服务器上执行一遍。
    混合类型的复制(MIXED):默认采用基于语句的复制,一旦发现基于语句无法精确复制时,就会采用基于行的复制。

    2、MySQL主从复制的工作过程

    主MySQL服务器:Master
    从MySQL服务器:Slave
    在这里插入图片描述
    1)Master 服务器保存记录到二进制日志
    在每个事务更新数据完成之前,Master 服务器在二进制日志(Binary log)记录这些改变。写入二进制日志完成后,Master 服务器通知存储引擎提交事务。
    2)Slave 服务器复制 Master 服务器的日志
    Slave 服务器将 Master 服务器的二进制日志复制到其中继日志(Relay log)。
    首先 Slave 服务器开始一个工作线程(I/O),I/O线程在 Master 服务器上打开一个普通的连接,然后开始 Binlog dump process。
    Binlog dump process 从 Master 服务器的二进制日志中读取事件,如果 Slave 服务器已经跟上 Master 服务器,它会睡眠并等待 Master 服务器产生新的事件,I/O线程将这些事件写入中继日志。
    3)Slave 服务器重放复制过来的日志
    SQL slave thread(SQL从线程)处理该过程的最后一步,SQL线程从中继日志读取事件,并重放其中的事件而更新 Slave 服务器的数据,使其与 Master 服务器中的数据一致,只要该线程与 I/O 线程保持一致,中继日志通常会位于 OS 缓存中,所以中继日志的开销很小。

    二、MySQL读写分离

    1、读写分离的概念

    读写分离基本的原理是让主数据库处理事务性增、改、删操作(INSERT、UPDATE、DELETE),而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。

    2、读写分离存在意义

    因为数据库的“写”(写10000条数据可能要3分钟)操作是比较耗时的。
    但是数据库的“读”(读10000条数据可能只要5秒钟)。
    所以读写分离,解决的是,数据库的写入,影响了查询的效率

    3、什么时候要读写分离

    数据库不一定要读写分离,如果程序使用数据库较多时,而更新少,查询多的情况下会考虑使用。利用数据库主从同步,再通过读写分离可以分担数据库压力,提高性能。

    4、MySQL 读写分离原理

    读写分离就是只在主服务器上写,只在从服务器上读。
    基本的原理是让主数据库处理事务性查询,而从数据库处理 select 查询。
    数据库复制被用来把主数据库上事务性查询导致的变更同步到集群中的从数据库。

    5、常见的 MySQL 读写分离

    1)基于程序代码内部实现
    在代码中根据 select、insert 进行路由分类,这类方法也是目前生产环境应用最广泛的。
    优缺点:
    优点是性能较好,因为在程序代码中实现,不需要增加额外的设备为硬件开支;
    缺点是需要开发人员来实现,运维人员无从下手。
    并不是所有的应用都适合在程序代码中实现读写分离,像一些大型复杂的Java应用,如果在程序代码中实现读写分离对代码改动就较大。
    2)基于中间代理层实现
    代理一般位于客户端和服务器之间,代理服务器接到客户端请求后通过判断后转发到后端数据库,有以下代表性程序:
    MySQL-Proxy:MySQL-Proxy 为 MySQL 开源项目,通过其自带的 lua 脚本进行SQL 判断。
    Atlas:是由奇虎360的Web平台部基础架构团队开发维护的一个基于MySQL协议的数据中间层项目。它是在mysql-proxy 0.8.2版本的基础上,对其进行了优化,增加了一些新的功能特性。360内部使用Atlas运行的mysql业务,每天承载的读写请求数达几十亿条。支持事物以及存储过程。
    Amoeba:由陈思儒开发,作者曾就职于阿里巴巴。该程序由Java语言进行开发,阿里巴巴将其用于生产环境。但是它不支持事务和存储过程。
    由于使用MySQL Proxy需要写大量的Lua脚本,这些Lua脚本不是现成的,而需要自己编写,这对于并不熟悉MySQL Proxy内置变量和MySQL Protocol的人来说是非常困难的。
    Amoeba是一个非常容易使用,可移植性非常强的软件,因此它在生产环境中被广泛用于数据库的代理层。

    三、MySQL主从复制和读写分离实验部署

    在这里插入图片描述

    主机 操作系统 IP地址 所需工具/软件/安装包
    Amoeba CentOS7 192.168.109.3 jdk-6u14-linux-x64.bin、amoeba-mysql-binary-2.2.0.tar.gz
    Master CentOS7 192.168.109.12 ntp 、 mysql-boost-5.7.20.tar.gz
    Slave1 CentOS7 192.168.109.22 ntp 、ntpdate 、 mysql-boost-5.7.20.tar.gz
    Slave2 CentOS7 192.168.109.33 ntp 、ntpdate 、mysql-boost-5.7.20.tar.gz
    客户端 CentOS7 192.168.109.5

    实验思路
    第一步:客户端client访问代理服务器amoeba
    第二步:代理服务器读写判断
    写操作:写入到主服务器
    第三步:主服务器将增删改写入自己二进制日志
    第四步:从服务器将主服务器的二进制日志同步至自己中继日志
    第五步:从服务器重放中继日志到数据库中
    读操作:直接访问从服务器
    最终结果:降低负载,起到负载均衡作用

    # 将所有主机的防火墙和安全机制关闭
    
    systemctl stop firewalld
    systemctl disable firewalld
    setenforce 0
    

    在这里插入图片描述

    1、搭建 MySQL 主从复制

    1)Mysql主从服务器时间同步

    Master服务器:192.168.109.12

    yum -y install ntp
    
    vim /etc/ntp.conf
    ##---------末尾添加---------
    server 127.127.109.0          #设置本地是时钟源,注意修改网段
    fudge 127.127.109.0 stratum 8 #设置时间层级为8(限制在15内)
    
    service ntpd start
    

    加粗样式
    在这里插入图片描述
    在这里插入图片描述

    Slave1服务器:192.168.109.22
    Slave2服务器:192.168.109.33

    yum -y install ntp ntpdate
    
    service ntpd start
    
    /usr/sbin/ntpdate 192.168.109.12  #进行时间同步,指向Master服务器IP
    
    crontab -e
    */30 * * * * /usr/sbin/ntpdate 192.168.109.12
    

    在这里插入图片描述
    在这里插入图片描述

    2)主服务器的mysql配置

    Master服务器:192.168.109.12

    vim /etc/my.cnf
    server-id = 1
    log-bin=master-bin      #添加,主服务器开启二进制日志
    log-slave-updates=true  #添加,允许从服务器更新二进制日志
    
    systemctl restart mysqld
    

    在这里插入图片描述
    在这里插入图片描述

    mysql -u root -p
    #给从服务器授权
    grant replication slave on *.* to 'myslave'@'192.168.109.%' identified by '123123';
    flush privileges;
    
    show master status;
    #File 列显示日志名,Fosition 列显示偏移量
    

    在这里插入图片描述

    3)从服务器的mysql配置

    Slave1服务器:192.168.109.22
    Slave2服务器:192.168.109.33

    vim /etc/my.cnf
    #修改,注意id与Master的不同,两个Slave的id也要不同
    server-id = 2
    #添加,开启中继日志,从主服务器上同步日志文件记录到本地
    relay-log=relay-log-bin
    #添加,定义中继日志文件的位置和名称
    relay-log-index=slave-relay-bin.index
    
    systemctl restart mysqld
    

    在这里插入图片描述
    在这里插入图片描述

    mysql -u root -p
    #配置同步,注意 master_log_file 和 master_log_pos 的值要与Master查询的一致,
    change master to master_host='192.168.109.12' , master_user='myslave',master_password='123123',master_log_file='master-bin.000001',master_log_pos=604;
    
    start slave;					#启动同步,如有报错执行 reset slave;
    show slave status\G				#查看 Slave 状态
    //确保 IO 和 SQL 线程都是 Yes,代表同步正常。
    Slave_IO_Running: Yes			#负责与主机的io通信
    Slave_SQL_Running: Yes			#负责自己的slave mysql进程
    

    在这里插入图片描述
    在这里插入图片描述
    一般 Slave_IO_Running: No 的可能性:

    • 网络不通
    • my.cnf配置有问题
    • 密码、file文件名、pos偏移量不对
    • 防火墙没有关闭

    4)验证主从复制效果

    create database test;
    show databases;
    

    在这里插入图片描述

    2、搭建 MySQL 读写分离

    Amoeba服务器:192.168.109.3

    安装 Java 环境

    • 因为 Amoeba 基于是 jdk1.5 开发的,所以官方推荐使用 jdk1.5 或 1.6 版本,高版本不建议使用。
    • 将jdk-6u14-linux-x64.bin 和 amoeba-mysql-binary-2.2.0.tar.gz.0 上传到/opt目录下。
    cd /opt/
    cp jdk-6u14-linux-x64.bin /usr/local/
    
    cd /usr/local/
    chmod +x jdk-6u14-linux-x64.bin
    ./jdk-6u14-linux-x64.bin
    按空格到最后一行
    按yes,按enter
    
    mv jdk1.6.0_14/ /usr/local/jdk1.6
    
    vim /etc/profile
    export JAVA_HOME=/usr/local/jdk1.6
    export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
    export PATH=$JAVA_HOME/lib:$JAVA_HOME/jre/bin/:$PATH:$HOME/bin
    export AMOEBA_HOME=/usr/local/amoeba
    export PATH=$PATH:$AMOEBA_HOME/bin
    
    source /etc/profile
    java -version
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    安装 Amoeba软件

    mkdir /usr/local/amoeba
    tar zxvf /opt/amoeba-mysql-binary-2.2.0.tar.gz -C /usr/local/amoeba/
    chmod -R 755 /usr/local/amoeba/
    /usr/local/amoeba/bin/amoeba
    //如显示amoeba start|stop 说明安装成功
    

    在这里插入图片描述
    在这里插入图片描述

    在主从服务器的mysql上授权

    Master服务器:192.168.109.12
    Slave1服务器:192.168.109.22
    Slave2服务器:192.168.109.33

    # 先在Master、Slave1、Slave2 的mysql上开放权限给 Amoeba 访问
    
    grant all on *.* to 'test'@'192.168.109.%' identified by '123123';
    

    在这里插入图片描述

    配置 Amoeba读写分离,两个 Slave 读负载均衡

    Amoeba服务器:192.168.109.3

    (1)修改amoeba配置文件

    cd /usr/local/amoeba/conf/
    
    cp amoeba.xml amoeba.xml.bak
    vim amoeba.xml           #修改amoeba配置文件
    #---------30修改------------------------------
    <property name="user">amoeba</property>
    #---------32修改------------------------------
    <property name="password">123456</property>
    #---------115修改-----------------------------
    <property name="defaultPool">master</property>
    #---------117去掉注释–------------------------
    <property name="writePool">master</property>
    <property name="readPool">slaves</property>
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    (2)修改数据库配置文件

    cp dbServers.xml dbServers.xml.bak
    
    vim dbServers.xml
    #---------23注释掉--------------------------------------
    作用:默认进入test库 以防mysql中没有test库时,会报错
    <!-- mysql schema
    <property name="schema">test</property>
    -->
    #---------26修改-----------------------------------------
    <!-- mysql user -->
    <property name="user">test</property>
    #---------28-30去掉注释----------------------------------
    <property name="password">123123</property>
    #---------45修改,设置主服务器的名Master------------------
    <dbServer name="master"  parent="abstractServer">
    #---------48修改,设置主服务器的地址----------------------
    <property name="ipAddress">192.168.109.12</property>
    #---------52修改,设置从服务器的名slave1-----------------
    <dbServer name="slave1"  parent="abstractServer">
    #---------55修改,设置从服务器1的地址---------------------
    <property name="ipAddress">192.168.109.22</property>
    #---------58复制上面6行粘贴,设置从服务器2的名slave2和地址---
    <dbServer name="slave2"  parent="abstractServer">
    <property name="ipAddress">192.168.109.33</property>
    #---------修改后的65或66修改-------------------------------------
    <dbServer name="slaves" virtual="true">
    #---------71修改----------------------------------------
    <property name="poolNames">slave1,slave2</property>
    
    /usr/local/amoeba/bin/amoeba start&	 #启动Amoeba软件,按ctrl+c 返回
    netstat -anpt | grep java		   	 #查看8066端口是否开启,默认端口为TCP 8066
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    测试读写分离

    客户端:客户端:192.168.109.5

    # 使用yum快速安装MySQL虚拟客户端
    yum install -y mysql mysql-server
    
    mysql -u amoeba -p123456 -h 192.168.109.3 -P8066
    

    在这里插入图片描述
    通过amoeba服务器代理访问mysql ,在通过客户端连接mysql后写入的数据只有主服务会记录,然后同步给从服务器
    在主服务器上

    use test;
    create table test (id int(10),name varchar(10),address varchar(20));
    

    在这里插入图片描述

    两台从服务器上

    stop slave;			#关闭同步
    use test;
    

    在这里插入图片描述
    在这里插入图片描述
    从服务器slave1:192.168.109.22

    # 添加数据
    
    insert into test values('1','slave1','this_is_slave1');
    

    从数据库slave2:192.168.109.33

    insert into test values('2','slave2','this_is_slave2');
    

    在主服务器上

    insert into test values('3','wangwu','this_is_master');
    

    在客户端服务器上

    use db_test;
    select * from test;		//客户端会分别向slave1和slave2读取数据,显示的只有在两个从服务器上添加的数据,没有在主服务器上添加的数据
    
    insert into test values('4','qianqi','this_is_client');		//只有主服务器上有此数据
    
    展开全文
  • 数据库保存图片和文件保存图片

    千次阅读 2012-10-22 20:04:25
    小图片的话 ...1.存储要散列,一个目录下不能放太多文件 2.在数据库中要记录图片散列地址 3.好处是可以直接把整个图片目录同步到静态服或CDN。且可以打包下载 4.可以分布式存放 5.请求服务器压力小

    小图片的话
    数据库存储:
    1.读、写方便些
    2.不方便把图片批量导出
    3.请求量大的话,并发是个问题,数据库压力,WEB太力都会大,因为是实时查库,实时header图片

    文件存储:
    1.存储要散列,一个目录下不能放太多文件
    2.在数据库中要记录图片散列地址
    3.好处是可以直接把整个图片目录同步到静态服或CDN。且可以打包下载
    4.可以分布式存放
    5.高请求服务器压力小

    WEB应用我觉得一般情况下都不建议使用数据库存储。
    客户端独立应用的话我觉得为了安全可以存在本地数据库里。

    展开全文
  • UNIX环境高级编程

    2013-04-19 09:29:57
    1.4 文件目录 3 1.5 输入和输出 6 1.6 程序和进程 8 1.7 出错处理 10 1.8 用户标识 12 1.9 信号 14 1.10 时间值 15 1.11 系统调用和库函数 16 1.12 小结 17 习题 18 第2章 UNIX标准化及实现 ...
  • 8.2.1 文件目录 8.2.2 文件属性 8.2.3 文件描述符 8.2.4 文件1/O 8.2.5 分散-聚集I/O(Scatter-Garther I/O) 8.2.6 文件加锁 8.3 文件系统 8.3.1 逻辑磁盘 8.4 特殊文件 8.4.1 符号链接 8.4.2 管道和FIFO 8.5 文件...
  • 1.4 文件目录  1.5 输入和输出  1.6 程序和进程  1.7 出错处理  1.8 用户标识  1.9 信号  1.10 时间值  1.11 系统调用和库函数  1.12 小结  习题  第2章 UNIX标准化及实现  2.1 引言  2.2...
  • 1.4 文件目录3 1.5 输入和输出6 1.6 程序和进程8 1.7 出错处理10 1.8 用户标识12 1.9 信号14 1.10 时间值15 1.11 系统调用和库函数16 1.12 小结17 习题18 第2章UNIX标准化及实现19 2.1 引言19 2.2 UNIX标准化19 ...
  • 书中除了介绍UNIX文件目录、标准I/O库、系统数据文件和信息、进程环境、进程控制、进程关系、信号、线程、线程控制、守护进程、各种I/O、进程间通信、网络IPC、伪终端等方面的内容,还在此基础上介绍了多个应用...
  • 本书是专为在UNIX平台下用C语言编制程序的人的。是以POSIX为标准,主要以C语言为基础,详细介绍了UNIX平台下编写各种应用程序的范例和方法。全书分四个部分,共十五章。本书范例丰富,且具有代表性,如Socket编程...
  • 1.4 文件目录 3 1.5 输入和输出 6 1.6 程序和进程 8 1.7 出错处理 10 1.8 用户标识 12 1.9 信号 14 1.10 时间值 15 1.11 系统调用和库函数 16 1.12 小结 17 习题 18 第2章 UNIX标准化及实现 ...
  • 1.4 文件目录 3 1.5 输入和输出 6 1.6 程序和进程 8 1.7 出错处理 10 1.8 用户标识 12 1.9 信号 14 1.10 时间值 15 1.11 系统调用和库函数 16 1.12 小结 17 习题 18 第2章 UNIX标准...
  • 书中除了介绍UNIX文件目录、标准I/O库、系统数据文件和信息、进程环境、进程控制、进程关系、信号、线程、线程控制、守护进程、各种I/O、进程间通信、网络IPC、伪终端等方面的内容,还在此基础上介绍了多个应用...
  •  1.1.2 文件结构和目录结构  1.2 文件系统的相关编程  1.3 进程系统  1.3.1 进程的概念  1.3.2 Linux中描述进程的核心数据结构。  1.3.3 和进程相关的系统调用  本章小结 第二章 进程间通信...
  • 书中除了介绍UNIX文件目录、标准I/O库、系统数据文件和信息、进程环境、进程控制、进程关系、信号、线程、线程控制、守护进程、各种I/O、进程间通信、网络IPC、伪终端等方面的内容,还在此基础上介绍了多个应用...
  • # log和pid文件目录,如果不设置默认打到当前路径的logs目录。 log.dir = # log file name. # log文件名。 log.file = collector.log # log flush enable. If set false, logs may not be print ...
  • 5.1.1数据读一致性与一致性 5.1.2多版本数据块 5.1.3 ANSIISO事务隔离级别 5.1.4 Oracle事务隔离级别 5.1.5锁管理器 5.2 RAC资源的协调和管理 5.2.1 Cache Fusion的结构 5.2.2 Cache Fusion工作原理 5.2.3...
  • 书中除了介绍UNIX文件目录、标准I/O库、系统数据文件和信息、进程环境、进程控制、进程  关系、信号、线程、线程控制、守护进程、各种I/O、进程间通信、网络IPC、伪终端等方面的内容,还在  此基础上介绍了多...
  • 书中除了介绍UNIX文件目录、标准I/O库、系统数据文件和信息、进程环境、进程控制、进程  关系、信号、线程、线程控制、守护进程、各种I/O、进程间通信、网络IPC、伪终端等方面的内容,还在  此基础上介绍了多...
  • 14.3.1 XML文件 476 14.3.2 读取XML文件 478 14.4 内存中的XML处理 481 14.4.1 XmlDocument 482 14.4.2 XPathNavigator 485 14.4.3 XDocument 486 14.5 搜索XML内容 491 14.5.1 搜索XmlDocument ...
  • 目录 推荐序 前言 第1章MySQL架构与历史1 1.1MySQL逻辑架构1 1.1.1连接管理与安全性2 1.1.2优化与执行3 1.2并发控制3 1.2.1读写锁4 1.2.2锁粒度4 1.3事务6 1.3.1隔离级别8 1.3.2死锁9 1.3.3事务日志10...
  • 文章目录概述docker安装Kafka版本演进Kafka架构架构Kafka支持高并发读写核心技术页缓存技术 + 磁盘顺序零拷贝技术(zero-copy)性能测试元数据文件存储日志的清除及压缩策略日志清除策略日志压缩策略分区和副本分区...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 177
精华内容 70
关键字:

同目录高并发写文件