截教教主
截教教主

分布式系统理论

说到分布式系统，不得不说集中式系统。传统集中式系统中整个项目所有的东西都在一个应用里面。
一个网站就是一个应用，当系统压力较大时，只能横向扩展，增加多个服务器或者多个容器去做负载均衡，避免单点故障而影响到整个系统。

集中式最明显的优点就是开发，测试，运维会比较方便，不用考虑复杂的分布式环境。

弊端也很明显，系统大而复杂、不易扩展、难于维护，每次更新都必须更新所有的应用。
分布式系统理论_第1张图片

                      集中式系统拓扑图

鉴于集中式系统的种种弊端，促成了分布式系统的形成，分布式系统背后是由一系列的计算机组成，但用户感知不到背后的逻辑，就像访问单个计算机一样，天然的避免了单机故障的问题。

应用可以按业务类型拆分成多个应用或服务，再按结构分成接口层、服务层。

我们也可以按访问入口分，如移动端、PC 端等定义不同的接口应用。数据库可以按业务类型拆分成多个实例，还可以对单表进行分库分表。同时增加分布式缓存、消息队列、非关系型数据库、搜索等中间件。

分布式系统虽好，但是增加了系统的复杂性，如分布式事务、分布式锁、分布式 Session、数据一致性等都是现在分布式系统中需要解决的难题。

分布式系统也增加了开发测试运维的成本，工作量增加，其管理不好反而会变成一种负担。
分布式系统理论_第2张图片

                           分布式系统拓扑图

分布式系统最为核心的要属分布式服务框架，有了分布式服务框架，我们只需关注各自的业务，而无需去关注那些复杂的服务之间调用的过程。

分布式服务框架

目前业界比较流行的分布式服务框架有：阿里的 Dubbo、Spring Cloud。

这里不对这些分布式服务框架做对比，简单的说说他们都做了些什么，能使我们用远程服务就像调用本地服务那么简单高效。

服务

服务是对使用用户有功能输出的模块，以技术框架作为基础，能实现用户的需求。

比如日志记录服务、权限管理服务、后台服务、配置服务、缓存服务、存储服务、消息服务等，这些服务可以灵活的组合在一起，也可以独立运行。

服务需要有接口，与系统进行对接。面向服务的开发，应该是把服务拆分开发，把服务组合运行。

更加直接的例子如：历史详情、留言板、评论、评级服务等。他们之间能独立运行，也要能组合在一起作为一个整体。

注册中心

注册中心对整个分布式系统起着最为核心的整合作用，支持对等集群，需要提供 CRUD 接口，支持订阅发布机制且可靠性要求非常之高，一般拿 Zookeeper 集群来做为注册中心。

分布式环境中服务提供方的服务会在多台服务器上部署，每台服务器会向注册中心提供服务方标识、服务列表、地址、对应端口、序列化协议等信息。

注册中心记录下服务和服务地址的映射关系，一般一个服务会对应多个地址，这个过程我们称之为服务发布或服务注册。

服务调用方会根据服务方标识、服务列表从注册中心获取所需服务的信息（地址端口信息、序列化协议等），这些信息会缓存至本地。

当服务需要调用其他服务时，直接在这里找到服务的地址，进行调用，这个过程我们称之为服务发现。
分布式系统理论_第3张图片

注册中心

下面是以 Zookeeper 作为注册中心的简单实现：

/**
     * 创建node节点
     * @param node
     * @param data
     */
    public boolean createNode(String node, String data) {
        try {
            byte[] bytes = data.getBytes();
            //同步创建临时顺序节点
            String path = zk.create(ZkConstant.ZK_RPC_DATA_PATH+"/"+node+"-", bytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            log.info("create zookeeper node ({} => {})", path, data);
        }catch (KeeperException e) {
            log.error("", e);
            return false;
        }catch (InterruptedException ex){
            log.error("", ex);
            return false;
        }
        return true;
    }

分布式系统理论_第4张图片

子节点 1
分布式系统理论_第5张图片

子节点 2

如下面 Zookeeper 中写入的临时顺序节点信息：
com.black.blackrpc.test.HelloWord：发布服务时对外的名称。
00000000010，00000000011：ZK 顺序节点 ID。
127.0.0.1:8888，127.0.0.1:8889：服务地址端口。
Protostuff：序列化方式。
1.0：权值，负载均衡策略使用。

这里使用的是 Zookeeper 的临时顺序节点，为什么使用临时顺序节点，主要是考虑以下两点：
当服务提供者异常下线时，与 Zookeeper 的连接会中断，Zookeeper 服务器会主动删除临时节点，同步给服务消费者。
这样就能避免服务消费者去请求异常的服务器。校稿注： 一般消费方也会在实际发起请求前，对当前获取到的服务提供方节点进行心跳，避免请求连接有问题的节点。
Zookeeper 下面是不允许创建 2 个名称相同的 ZK 子节点的，通过顺序节点就能避免创建相同的名称。
当然也可以不用顺序节点的方式，直接以 com.black.blackrpc.test.HelloWord 创建节点，在该节点下创建数据节点。

下面是 ZK 的数据同步过程：

/**
     * 同步节点 （通知模式）
     * syncNodes会通过级联方式，在每次watcher被触发后，就会再挂上新的watcher。完成了类似链式触发的功能
     */
    public boolean syncNodes() {
        try {
            List nodeList = zk.getChildren(ZkConstant.ZK_RPC_DATA_PATH, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeChildrenChanged) {
                        syncNodes();
                    }
                }
            });
            Map> map =new HashMap>();
            for (String node : nodeList) {
                byte[] bytes = zk.getData(ZkConstant.ZK_RPC_DATA_PATH + "/" + node, false, null);
                String key =node.substring(0, node.lastIndexOf(ZkConstant.DELIMITED_MARKER));
                String value=new String(bytes);
                Object object =map.get(key);
                if(object!=null){
                    ((List)object).add(value);
                }else {
                    List dataList = new ArrayList();
                    dataList.add(value);
                    map.put(key,dataList);
                }
                log.info("node: [{}] data: [{}]",node,new String(bytes));
            }
            /**修改连接的地址缓存*/
            if(MapUtil.isNotEmpty(map)){
                log.debug("invoking service cache updateing....");
                InvokingServiceCache.updataInvokingServiceMap(map);
            }
            return true;
        } catch (KeeperException | InterruptedException e) {
            log.error(e.toString());
            return false;
        }
    }

当数据同步到本地时，一般会写入到本地文件中，防止因 Zookeeper 集群异常下线而无法获取服务提供者信息。

通讯与协议

服务消费者无论是与注册中心还是与服务提供者，都需要存在网络连接传输数据，而这就涉及到通讯。

笔者之前也做过这方面的工作，当时使用的是 java BIO 简单的写了一个通讯包，使用场景没有多大的并发，阻塞式的 BIO 也未暴露太多问题。

java BIO 因其建立连接之后会阻塞线程等待数据，这种方式必须以一连接一线程的方式，即客户端有连接请求时服务器端就需要启动一个线程进行处理。当连接数过大时，会建立相当多的线程，性能直线下降。

Java NIO：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 I/O 请求时才启动一个线程进行处理。

Java AIO：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的 I/O 请求都是由 OS 先完成了再通知服务器应用去启动线程进行处理。

BIO、NIO、AIO 适用场景分析:
BIO：用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，但程序直观简单易理解。
NIO：适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂。
目前主流的通讯框架 Netty、Apache Mina、Grizzl、NIO Framework 都是基于其实现的。
AIO：用于连接数目多且连接比较长（重操作）的架构，比如图片服务器，文件传输等，充分调用 OS 参与并发操作，编程比较复杂。

作为基石的通讯，其实要考虑很多东西。如：丢包粘包的情况，心跳机制，断连重连，消息缓存重发，资源的优雅释放，长连接还是短连接等。

下面是 Netty 建立服务端，客户端的简单实现：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.bytes.ByteArrayDecoder;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/***
 * netty tcp 服务端
 * @author cds
 *
 */
public class NettyTcpService {
    private static final Logger log = LoggerFactory.getLogger(NettyTcpService.class);
    private String host;
    private int port;

    public NettyTcpService(String address) throws Exception{
        String str[] = address.split(":");
        this.host=str[0];
        this.port=Integer.valueOf(str[1]);
    }

    public NettyTcpService(String host,int port) throws Exception{
        this.host=host;
        this.port=port;
    }
    /**用于分配处理业务线程的线程组个数 */  
    private static final int BIZGROUPSIZE = Runtime.getRuntime().availableProcessors()*2; //默认  
    /** 业务出现线程大小*/  
    private static final int BIZTHREADSIZE = 4;  
    /* 
     * NioEventLoopGroup实际上就是个线程,
     * NioEventLoopGroup在后台启动了n个NioEventLoop来处理Channel事件, 
     * 每一个NioEventLoop负责处理m个Channel, 
     * NioEventLoopGroup从NioEventLoop数组里挨个取出NioEventLoop来处理Channel
     */  
    private static final EventLoopGroup bossGroup = new NioEventLoopGroup(BIZGROUPSIZE);  
    private static final EventLoopGroup workerGroup = new NioEventLoopGroup(BIZTHREADSIZE);  

    public void start() throws Exception {
        log.info("Netty Tcp Service Run...");
        ServerBootstrap b = new ServerBootstrap();  
        b.group(bossGroup, workerGroup);  
        b.channel(NioServerSocketChannel.class);  
        b.childHandler(new ChannelInitializer() {  
            @Override  
            public void initChannel(SocketChannel ch) throws Exception {  
                ChannelPipeline pipeline = ch.pipeline();  
                pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));  
                pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));  
                pipeline.addLast("decoder", new ByteArrayDecoder());  
                pipeline.addLast("encoder", new ByteArrayEncoder());  
              //  pipeline.addLast(new Encoder());
              //  pipeline.addLast(new Decoder());
                pipeline.addLast(new TcpServerHandler());
            }  
        });  
        b.bind(host, port).sync();  
        log.info("Netty Tcp Service Success!");
    }  
    /**
     * 停止服务并释放资源
     */
    public void shutdown() {  
        workerGroup.shutdownGracefully();  
        bossGroup.shutdownGracefully();  
    }
} 

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
/**
 * 服务端处理器
 */
public class TcpServerHandler extends SimpleChannelInboundHandler{
    private static final Logger log = LoggerFactory.getLogger(TcpServerHandler.class);

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        byte[] data=(byte[])msg;
        }
}
 
  
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.bytes.ByteArrayDecoder;
import io.netty.handler.codec.bytes.ByteArrayEncoder;
import io.netty.util.concurrent.Future;
/**
 * netty tcp 客户端
 * @author cds
 *
 */
public class NettyTcpClient {
    private static final Logger log = LoggerFactory.getLogger(NettyTcpClient.class);
    private String host;  
    private int port;  
    private Bootstrap bootstrap;  
    private Channel channel;
    private EventLoopGroup group;

    public NettyTcpClient(String host,int port){
        bootstrap=getBootstrap();
        channel= getChannel(host,port);
        this.host=host;
        this.port=port;
    }

    public String getHost() {
        return host;
    }

    public int getPort() {
        return port;
    }

    /** 
     * 初始化Bootstrap 
     * @return 
     */  
    public final Bootstrap getBootstrap(){  
        group = new NioEventLoopGroup();  
        Bootstrap b = new Bootstrap();  
        b.group(group).channel(NioSocketChannel.class);  
        b.handler(new ChannelInitializer() {  
            @Override  
            protected void initChannel(Channel ch) throws Exception {  
                ChannelPipeline pipeline = ch.pipeline();  
                 // pipeline.addLast(new Encoder());
                 // pipeline.addLast(new Decoder());
                pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));  
                pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));  
                pipeline.addLast("decoder", new ByteArrayDecoder());  
                pipeline.addLast("encoder", new ByteArrayEncoder());  

                pipeline.addLast("handler", new TcpClientHandler());
            }  
        });  
        b.option(ChannelOption.SO_KEEPALIVE, true);  
        return b;  
    }  

    /**
     * 连接，获取Channel
     * @param host
     * @param port
     * @return
     */
    public final Channel getChannel(String host,int port){  
        Channel channel = null;  
        try {  
            channel = bootstrap.connect(host, port).sync().channel();  
            return channel;
        } catch (Exception e) {  
            log.info(String.format("connect Server(IP[%s],PORT[%s]) fail!", host,port));  
            return null;  
        }
    }  

    /**
     * 发送消息
     * @param msg
     * @throws Exception
     */
    public boolean sendMsg(Object msg) throws Exception {  
        if(channel!=null){
            channel.writeAndFlush(msg).sync();  
            log.debug("msg flush success");
            return true;
        }else{  
            log.debug("msg flush fail,connect is null");
            return false;
        }  
    }

    /**
     * 连接断开
     * 并且释放资源
     * @return
     */
    public boolean disconnectConnect(){
        //channel.close().awaitUninterruptibly();
        Future future =group.shutdownGracefully();//shutdownGracefully释放所有资源，并且关闭所有当前正在使用的channel
        future.syncUninterruptibly();
        return true;
    }
}

 
  
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
/**
 * 客户端处理器
 */
public class TcpClientHandler extends SimpleChannelInboundHandler{
    private static final Logger log = LoggerFactory.getLogger(TcpClientHandler.class);
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        byte[] data=(byte[])msg;
    }
}
 
  
说到通讯就不能不说协议，通信时所遵守的规则，访问什么，传输的格式等都属于协议。
 
  
作为一个开发人员，应该都了解 TCP/IP 协议，它是一个网络通信模型，以及一整套网络传输协议家族，是互联网的基础通信架构。
 
  
也都应该用过 Http（超文本传输协议），Web 服务器传输超文本到本地浏览器的传送协议，该协议建立在 TCP/IP 协议之上。分布式服务框架服务间的调用也会规定协议。
 
  
为了支持不同场景，分布式服务框架会存在多种协议，如 Dubbo 就支持 7 种协议：Dubbo 协议(默认)，RMI 协议，Hessian协议，HTTP 协议，WebService 协议，Thrift 协议，Memcached 协议，Redis 协议每种协议应对的场景不尽相同，具体场景具体对待。
 
  
服务路由
 
  
分布式服务上线时都是集群组网部署，集群中会存在某个服务的多实例，消费者如何从服务列表中选择合适的服务提供者进行调用，这就涉及到服务路由。分布式服务框架需要能够满足用户灵活的路由需求。
 
  
透明化路由
 
  
很多开源的 RPC 框架调用者需要配置服务提供者的地址信息，尽管可以通过读取数据库的服务地址列表等方式避免硬编码地址信息，但是消费者依然要感知服务提供者的地址信息，这违反了透明化路由原则。
 
  
基于服务注册中心的服务订阅发布，消费者通过主动查询和被动通知的方式获取服务提供者的地址信息，而不再需要通过硬编码方式得到提供者的地址信息。
 
  
只需要知道当前系统发布了那些服务，而不需要知道服务具体存在于什么位置，这就是透明化路由。
 
  
负载均衡
 
  
负载均衡策略是服务的重要属性，分布式服务框架通常会提供多种负载均衡策略，同时支持用户扩展负载均衡策略。
 
  
随机
 
  
通常在对等集群组网中，采用随机算法进行负载均衡，随机路由算法消息分发还是比较均匀的，采用 JDK 提供的 java.util.Random 或者 java.security.SecureRandom 在指定服务提供者列表中生成随机地址。
 
  
消费者基于随机生成的服务提供者地址进行远程调用：
 
  
/**
 * 随机
 */
public class RandomStrategy implements ClusterStrategy {
    @Override
    public RemoteServiceBase select(List list) {
        int MAX_LEN = list.size();
        int index = RandomUtil.nextInt(MAX_LEN);
        return list.get(index);
    }
}

 
  
随机还是存在缺点的，可能出现部分节点的碰撞的概率较高，另外硬件配置差异较大时，会导致各节点负载不均匀。
 
  
为避免这些问题，需要对服务列表加权，性能好的机器接收的请求的概率应该高于一般机器：
 
  
/**
 * 加权随机
 */
public class WeightingRandomStrategy implements ClusterStrategy {
    @Override
    public RemoteServiceBase select(List list) {
         //存放加权后的服务提供者列表
        List weightingList = new ArrayList();
        for (RemoteServiceBase remoteServiceBase : list) {
            //扩大10倍
            int weight = (int) (remoteServiceBase.getWeight()*10);
            for (int i = 0; i < weight; i++) {
                weightingList.add(remoteServiceBase);
            }
        }
        int MAX_LEN = weightingList.size();
        int index = RandomUtil.nextInt(MAX_LEN);
        return weightingList.get(index);
    }
}

 
  
轮询
 
  
逐个请求服务地址，到达边界之后，继续绕接。主要缺点：慢的提供者会累积请求。
 
  
例如第二台机器很慢，但没挂。当请求第二台机器时被卡在那。久而久之，所有请求都卡在第二台机器上。
 
  
轮询策略实现非常简单，顺序循环遍历服务提供者列表，达到边界之后重新归零开始，继续顺序循环：
 
  
/**
 * 轮询
 */
public class PollingStrategy implements ClusterStrategy {
    //计数器
    private int index = 0;
    private Lock lock = new ReentrantLock();
    @Override
    public RemoteServiceBase select(List list) {
        RemoteServiceBase service = null;
            try {
                lock.tryLock(10, TimeUnit.MILLISECONDS);
                //若计数大于服务提供者个数,将计数器归0
                if (index >= list.size()) {
                    index = 0;
                }
                service = list.get(index);
                index++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
          //兜底,保证程序健壮性,若未取到服务,则直接取第一个
            if (service == null) {
                service = list.get(0);
            }       
        return service;
    }
}

 
  
加权轮询的话，需要给服务地址添加权重：
 
  
/**
 * 加权轮询
 */
public class WeightingPollingStrategy implements ClusterStrategy {
    //计数器
    private int index = 0;
    //计数器锁
    private Lock lock = new ReentrantLock();
    @Override
    public RemoteServiceBase select(List list) {
        RemoteServiceBase service = null;
        try {
            lock.tryLock(10, TimeUnit.MILLISECONDS);
            //存放加权后的服务提供者列表
            List weightingList = new ArrayList();
            for (RemoteServiceBase remoteServiceBase : list) {
                //扩大10倍
                int weight = (int) (remoteServiceBase.getWeight()*10);
                for (int i = 0; i < weight; i++) {
                    weightingList.add(remoteServiceBase);
                }
            }
            //若计数大于服务提供者个数,将计数器归0
            if (index >= weightingList.size()) {
                index = 0;
            }
            service = weightingList.get(index);
            index++;
            return service;

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        //兜底,保证程序健壮性,若未取到服务,则直接取第一个
        return list.get(0);
    }
}

 
  
服务调用时延
 
  
消费者缓存所有服务提供者的调用时延，周期性的计算服务调用平均时延。
 
  
然后计算每个服务提供者服务调用时延与平均时延的差值，根据差值大小动态调整权重，保证服务时延大的服务提供者接收更少的消息，防止消息堆积。
 
  
该策略的特点：保证处理能力强的服务接受更多的消息，通过动态的权重分配消除服务调用时延的震荡范围，使所有服务的调用时延接近平均值，实现负载均衡。
 
  
一致性哈希
 
  
相同参数的请求总是发送到统一服务提供者，当某一台服务提供者宕机时，原本发往根提供者的请求，基于虚拟节点，平摊到其他提供者，不会引起剧烈变动，平台提供默认的虚拟节点数，可以通过配置文件修改虚拟节点个数。
 
  
一致性 Hash 环工作原理如下图所示：
 分布式系统理论_第6张图片
 
  
一致性哈希
 
  
路由规则
 
  
负载均衡只能保证服务提供者压力的平衡，但是在一些业务场景中需要设置一些过滤规则，比较常用的是基本表达式的条件路由。
 
  
通过 IP 条件表达式配置黑白名单访问控制：consumerIP != 192.168.1.1。
 
  
只暴露部分服务提供者，防止这个集群服务都被冲垮，导致其他服务也不可用。
 例如providerIP = 192.168.3*。
 读写分离：method=find*,list*,get*,query*=>providerIP=192.168.1.。
 前后台分离：app=web=>providerIP=192.168.1.,app=java=>providerIP=192.168.2.。
 灰度升级：将WEB前台应用理由到新的服务版本上：app=web=>provicerIP=192.168.1.*。
 
  
序列化与反序列化
 
  
把对象转换为字节序列的过程称为序列化，把字节序列恢复为对象的过程称为反序列化。
 
  
运程调用的时候，我们需要先将 Java 对象进行序列化，然后通过网络，IO 进行传输，当到达目的地之后，再进行反序列化获取到我们想要的结果对象。
 
  
分布式系统中，传输的对象会很多，这就要求序列化速度快，产生字节序列小的序列化技术。
 
  
序列化技术
 
  
：Serializable，XML，Jackson，MessagePack，FastJson，Protocol Buffer，Thrift，Gson，Avro，Hessian 等。
 
  
Serializable 是 Java 自带的序列化技术，无法跨平台，序列化和反序列化的速度相对较慢。
 
  
XML 技术多平台支持好，常用于与银行交互的报文，但是其字节序列产生较大，不太适合用作分布式通讯框架。
 
  
FastJson 是 Java 语言编写的高性能的 JSON 处理器，由阿里巴巴公司开发，字节序列为 json 串，可读性好，序列化也速度非常的快。
 
  
Protocol Buffer 序列化速度非常快，字节序列较小，但是可读性较差。
 
  
一般分布式服务框架会内置多种序列化协议可供选择，如 Dubbo 支持的 7 种协议用到的序列化技术就不完全相同。
 
  
服务调用
 
  
本地环境下，使用某个接口很简单，直接调用就行。分布式环境下就不是那么简单了，消费者方只会存在接口的定义，没有具体的实现。
 
  
想要像本地环境下直接调用远程接口那就得耗费一些功夫了，需要用到远程代理。
 
  
下面是我盗的图：
 分布式系统理论_第7张图片
 
  
远程代理
 
  
通信时序如下：
 分布式系统理论_第8张图片
 
  
通信时序
 
  
消费者端没有具体的实现，需要调用接口时动态的去创建一个代理类。与 Spirng 集成的情况，那直接在 Bean 构建的时候注入代理类。
 
  
下面是构建代理类：
 
  
import java.lang.reflect.Proxy;
public class JdkProxy {
    public static Object getInstance(Class cls){       
        JdkMethodProxy invocationHandler = new JdkMethodProxy();
        Object newProxyInstance = Proxy.newProxyInstance(  
                cls.getClassLoader(),  
                new Class[] { cls }, 
                invocationHandler); 
        return (Object)newProxyInstance;
    }
}

 
  
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JdkMethodProxy implements InvocationHandler {

    @Override
    public Object invoke(Object proxy, Method method, Object[] parameters)  throws Throwable {        
        //如果传进来是一个已实现的具体类
        if (Object.class.equals(method.getDeclaringClass())) {  
            try {  
                return method.invoke(this, parameters);  
            } catch (Throwable t) {  
                t.printStackTrace();  
            }  
        //如果传进来的是一个接口
        } else {  
            //实现接口的核心方法 
            //return RemoteInvoking.invoking(serviceName, serializationType, //timeOut,loadBalanceStrategy,method, parameters);
        }  
        return null;
    }
}

 
  
代理会做很多事情，对请求服务的名称及参数信息的序列化、通过路由选择最为合适服务提供者、建立通讯连接发送请求信息（或者直接发起 Http 请求）、最后返回获取到的结果。
 
  
当然这里面需要考虑很多问题，如调用超时，请求异常，通讯连接的缓存，同步服务调用还是异步服务调用等等。
 
  
同步服务调用：
 
  
客户端发起远程服务调用请求，用户线程完成消息序列化之后，将消息投递到通信框架，然后同步阻塞，等待通信线程发送请求并接收到应答之后，唤醒同步等待的用户线程，用户线程获取到应答之后返回。
 
  
异步服务调用：
 
  
基于 Java 的 Future 机制，客户端发起远程服务调用请求，该请求会被标上 RequestId，同时建立一个与 RequestId 对应的 Future，客户端通过 Future 的 Get 方法获取结果时会被阻塞。
 
  
服务端收到请求应达会回传 RequestId，通过 RequestId 去解除对应 Future 的阻塞，同时 Set 对应结果，最后客户端获取到结果。
 
  
构建 Future，以 RequestId 为 Key，Put 到线程安全的 Map 中。Get 结果时需要写入 Time Out 超时时间，防止由于结果的未返回而导致的长时间的阻塞。
 
  
SyncFuture syncFuture =new SyncFuture();
SyncFutureCatch.syncFutureMap.put(rpcRequest.getRequestId(), syncFuture);
try {
    RpcResponse rpcResponse= syncFuture.get(timeOut,TimeUnit.MILLISECONDS);     return rpcResponse.getResult();
}catch (Exception e){
    throw e;
}finally {
    SyncFutureCatch.syncFutureMap.remove(rpcRequest.getRequestId());
}

 
  
结果返回时通过回传的 RequestId 获取对应 Future 写入 Response，Future 线程解除阻塞：
 
  
log.debug("Tcp Client receive head："+headAnalysis+"Tcp Client receive data：" +rpcResponse);
SyncFuture syncFuture= SyncFutureCatch.syncFutureMap.get(rpcResponse.getRequestId());
if(syncFuture!=null){
        syncFuture.setResponse(rpcResponse);
}

 
  
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class SyncFuture implements Future {
    // 因为请求和响应是一一对应的，因此初始化CountDownLatch值为1。
    private CountDownLatch latch = new CountDownLatch(1);
    // 需要响应线程设置的响应结果
    private T response;
    // Futrue的请求时间，用于计算Future是否超时
    private long beginTime = System.currentTimeMillis();
    public SyncFuture() {
    }
    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
        return false;
    }
    @Override
    public boolean isCancelled() {
        return false;
    }
    @Override
    public boolean isDone() {
        if (response != null) {
            return true;
        }
        return false;
    }
    // 获取响应结果，直到有结果才返回。
    @Override
    public T get() throws InterruptedException {
        latch.await();
        return this.response;
    }
    // 获取响应结果，直到有结果或者超过指定时间就返回。
    @Override
    public T get(long timeOut, TimeUnit unit) throws InterruptedException {
        if (latch.await(timeOut, unit)) {
            return this.response;
        }
        return null;
    }
    // 用于设置响应结果，并且做countDown操作，通知请求线程
    public void setResponse(T response) {
        this.response = response;
        latch.countDown();
    }
    public long getBeginTime() {
        return beginTime;
    }
}

SyncFuture syncFuture =new SyncFuture();
SyncFutureCatch.syncFutureMap.put(rpcRequest.getRequestId(), syncFuture);
RpcResponse rpcResponse= syncFuture.get(timeOut,TimeUnit.MILLISECONDS);
SyncFutureCatch.syncFutureMap.remove(rpcRequest.getRequestId());

 
  
除了同步服务调用，异步服务调用，还有并行服务调用，泛化调用等调用形式。
 
  
高可用
 
  
简单的介绍了下分布式服务框架，下面来说下分布式系统的高可用。一个系统设计开发出来，三天两晚就出个大问题，导致无法使用，那这个系统也不是什么好系统。
 
  
业界流传一句话：“我们系统支持 X 个 9 的可靠性”。这个 X 是代表一个数字，X 个 9 表示在系统 1 年时间的使用过程中，系统可以正常使用时间与总时间（1 年）之比。
 
  
3 个 9：(1-99.9%)36524=8.76 小时，表示该系统在连续运行 1 年时间里最多可能的业务中断时间是 8.76 小时，4 个 9 即 52.6 分钟，5 个 9 即 5.26 分钟。要做到如此高的可靠性，是非常大的挑战。
 
  
一个大型分布式项目可能是由几十上百个项目构成，涉及到的服务成千上万，主链上的一个流程就需要流转多个团队维护的项目。
 
  
拿 4 个 9 的可靠性来说，平摊到每个团队的时间可能不到 10 分钟。这 10 分钟内需要顶住压力，以最快的时间找到并解决问题，恢复系统的可用。
 
  
下面说说为了提高系统的可靠性都有哪些方案：
 
  
服务检测：某台服务器与注册中心的连接中断，其提供的服务也无响应时，系统应该能主动去重启该服务，使其能正常对外提供。
 
  
故障隔离：集群环境下，某台服务器能对外提供服务，但是因为其他原因，请求结果始终异常。
 
  
这时就需要主动将该节点从集群环境中剔除，避免继续对后面的请求造成影响，非高峰时期再尝试修复该问题。至于机房故障的情况，只能去屏蔽整个机房了。
 
  
目前饿了么做的是异地多活，即便单边机房挂了，流量也可以全量切换至另外一边机房，保证系统的可用。
 
  
监控：包含业务监控、服务异常监控、DB 中间件性能的监控等，系统出现异常的时候能及时的通知到开发人员。等到线下报上来的时候，可能影响已经很大了。
 
  
压测：产线主链路的压测是必不可少的，单靠集成测试，有些高并发的场景是无法覆盖到的，压测能暴露平常情况无法出现的问题，也能直观的提现系统的吞吐能力。当业务激增时，可以考虑直接做系统扩容。
 
  
SOP 方案与演练：产线上随时都可能会发生问题，抱着出现问题时再想办法解决的态度是肯定不行的，时间根本来不及。
 
  
提前做好对应问题的 SOP 方案，能节省大量时间，尽快的恢复系统的正常。当然平常的演练也是不可少的，一旦产线故障可以做到从容不迫的去应对和处理。
 
  
除了上述方案外，还可以考虑服务策略的使用：
 
  
降级策略：业务高峰期，为了保证核心服务，需要停掉一些不太重要的业务。
 
  
如双十一期间不允许发起退款、只允许查看 3 个月之内的历史订单等业务的降级，调用服务接口时，直接返回的空结果或异常等服务的降级，都属于分布式系统的降级策略。
 
  
服务降级是可逆操作，当系统压力恢复到一定值不需要降级服务时，需要去除降级，将服务状态恢复正常。
 
  
服务降级主要包括屏蔽降级和容错降级：
 屏蔽降级：分布式服务框架直接屏蔽对远程接口的请求，不发起对远程服务的调用，直接返回空结果、抛出指定异常、执行本地模拟接口实现等方式。
 容错降级：非核心服务不可调用时，可以对故障服务做业务放通，保证主流程不受影响。如请求超时、消息解码异常、系统拥塞保护异常， 服务提供方系统异常等情况。
 
  
笔者之前就碰到过因双方没有做容错降级导致的系统故障的情况。午高峰时期，对方调用我们的一个非核心查询接口，我们系统因为 Bug 问题一直异常，导致对方调用这个接口的页面异常而无法跳转到主流程页面，影响了产线的生产。当时对方紧急发版才使系统恢复正常。
 
  
限流策略：说到限流，最先想到的就是秒杀活动了，一场秒杀活动的流量可能是正常流量的几百至几千倍，如此高的流量系统根本无法处理，只能通过限流来避免系统的崩溃。
 
  
服务的限流本质和秒杀活动的限流是一样的，都是限制请求的流入，防止服务提供方因大量的请求而崩溃。
 
  
限流算法：令牌桶、漏桶、计数器算法。上述算法适合单机的限流，但涉及到整个集群的限流时，得考虑使用缓存中间件了。
 
  
例如：某个服务 1 分钟内只允许请求 2 次，或者一天只允许使用 1000 次。
 
  
由于负载均衡存在，可能集群内每台机器都会收到请求，这种时候就需要缓存来记录调用方某段时间内的请求次数，再做限流处理。Redis 就很适合做此事。
 
  
熔断策略：熔断本质上是一种过载保护机制，这一概念来源于电子工程中的断路器，当电流过大时，保险丝会熔断，从而保护整个电路。
 
  
同样在分布式系统中，当被调用的远程服务无法使用时，如果没有过载保护，就会导致请求的资源阻塞在远程服务器上耗尽资源。
 
  
很多时候，刚开始可能只是出现了局部小规模的故障，然而由于种种原因，故障影响范围越来越大，最终导致全局性的后果。
 
  
当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护自己以及系统整体的可用性，可以暂时切断对下游服务的调用。
 
  
熔断器的设计思路：
 Closed：初始状态，熔断器关闭，正常提供服务。
 Open: 失败次数，失败百分比达到一定的阈值之后，熔断器打开，停止访问服务。
 Half-Open：熔断一定时间之后，小流量尝试调用服务，如果成功则恢复，熔断器变为 Closed 状态。
 
  
数据一致性
 
  
一个系统设计开发出来，必须保证其运行的数据准确和一致性。拿支付系统来说：用户银行卡已经扣款成功，系统里却显示失败，没有给用户的虚拟帐户充值上，这会引起客诉。
 
  
说的再严重点，用户发起提现，资金已经转到其银行账户，系统却没扣除对应虚拟帐号的余额，直接导致资金损失了。如果这时候用户一直发起提现，那就酸爽了。
 
  
CAP 原则
 
  
说到数据一致性，就不得不说到 CAP 原则。CAP 原则中指出任何一个分布式系统中，Consistency（一致性 C）、 Availability（可用性 A）、Partition tolerance（分区容错性 P），三者不可兼得。
 
  
传统单机数据库基于 ACID 特性（原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）） ，放弃了分区容错性，能做到可用性和一致性。
 
  
对于一个分布式系统而言，分区容错性是一个最基本的要求。既然是一个分布式系统，那么分布式系统中的组件必然需要被部署到不同的节点，会出现节点与节点之间的网络通讯。
 
  
而网络问题又是一定会出现的异常情况，分区容错性也就成为了一个分布式系统必然需要面对和解决的问题。
 
  
系统架构师往往需要把精力花在如何根据业务特点在一致性和可用性之间寻求平衡。
 
  
集中式系统，通过数据库事务的控制，能做到数据的强一致性。但是分布式系统中，涉及多服务间的调用，通过分布式事务的方案：
 两阶段提交（2PC）
 三阶段提交（3PC）
 补偿事务（TCC）
 …
 
  
虽然能实现数据的强一致，但是都是通过牺牲可用性来实现。
 
  
BASE 理论
 
  
BASE 理论是对 CAP 原则中一致性和可用性权衡的结果：Basically Available（基本可用）、Soft state（软状态）和 Eventually consistent（最终一致性）。
 
  
BASE 理论，其来源于对大规模互联网系统分布式实践的总结，是基于 CAP 原则逐步演化而来的。
 
  
其最核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。
 
  
基本可用：是指分布式系统在出现不可预知故障的时候，允许损失部分可用性，这不等价于系统不可用。
 
  
软状态：指允许系统中的数据存在中间状态，并认为该中间状态的存在不会影响系统的整体可用性，即允许系统在不同节点的数据副本之间进行数据同步的过程存在延时。
 
  
最终一致性：强调的是所有的数据副本，在经过一段时间的同步之后，最终都能够达到一致的状态。
 
  
因此，最终一致性的本质是需要系统保证最终数据能够达到一致，而不需要实时保证系统数据的强一致性。
 
  
总的来说，BASE 理论面向的是大型高可用可扩展的分布式系统，和传统的事物 ACID 特性是相反的。
 
  
它完全不同于 ACID 的强一致性模型，而是通过牺牲强一致性来获得可用性，并允许数据在一段时间内是不一致的，但最终达到一致状态。
 
  
同时，在实际的分布式场景中，不同业务单元和组件对数据一致性的要求是不同的，因此在具体的分布式系统架构设计过程中，ACID 特性和 BASE 理论往往又会结合在一起。
 
  
结语
 
  
分布式系统涉及到的东西还有很多，如：分布式锁、定时调度、数据分片、性能问题、各种中间件的使用等，笔者分享只是了解到的那一小部分的知识而已。
 
  
之前本着学习的目的也写过一个非常简单的分布式服务框架 blackRpc，通过它了解了分布式服务框架内部的一些活动。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(架构设计)

        

            

                
    
                    
  • 深入解析：FIR滤波器在FPGA上的设计与实现全流程
                        king-agic
FPGAfpga开发经验分享
                        
    在FPGA中实现FIR（FiniteImpulseResponse）滤波器涉及多个步骤，包括滤波器设计、系数量化、硬件架构设计、HDL（HardwareDescriptionLanguage）编码、综合、布局布线以及验证。1.滤波器设计使用软件工具如MATLAB、Octave或者Python中的SciPy库来设计FIR滤波器。定义滤波器的规格，例如采样频率、截止频率、通带和阻带衰减等。生成滤波器的
    
                    
    • 
                    
  • 【构建企业级Spring Boot应用：从基础到高级的全面指南】
                        小怪兽9699
springboot后端java
                        
    摘要本文旨在为开发者提供一份详尽的指南，帮助大家深入理解并掌握如何使用SpringBoot框架来快速开发企业级应用程序。通过实际案例分析、代码示例以及架构设计思路分享，读者不仅能够学习到理论知识，还能获得宝贵的实践经验。本文将涵盖从环境搭建、项目创建、配置管理、数据访问层、Web服务开发、安全机制实现、日志记录、单元测试与集成测试，到最终的部署上线等各个方面。目录摘要目录引言SpringBoot简
    
                    
    • 
                    
  • 从零开始：Spring Boot核心概念与架构解析
                        小筱在线
springbootspringboot架构后端
                        
    引言在当今的Java开发领域，SpringBoot已经成为构建企业级应用的首选框架之一。它以其简洁、高效、易于上手的特点，极大地简化了Spring应用的开发过程。本文将从SpringBoot的核心概念入手，深入解析其架构设计和运行原理，帮助读者从零开始全面理解SpringBoot。一、SpringBoot简介1.1什么是SpringBoot？SpringBoot是由Pivotal团队提供的基于Sp
    
                    
    • 
                    
  • tidb和mysql性能优化有哪些区别
                        大0马浓
tidbmysql
                        
    TiDB和MySQL在性能优化上的区别主要体现在架构设计、扩展方式、优化手段和适用场景等方面。以下是主要区别的总结：1.架构设计差异MySQL：单机架构（或主从复制架构），存储和计算耦合。-依赖本地磁盘或集中式存储（如SAN/NAS）。-优化集中在单机资源（CPU、内存、磁盘I/O）的合理利用。TiDB：-分布式架构，存储（TiKV）、计算（TiDBServer）、调度（PD）分离。-数据自动分片
    
                    
    • 
                    
  • 系统质量属性与架构评估
                        zhousenshan
软考-系统架构师架构
                        
    架构评估的重要概念系统架构风险：指架构设计中潜在的、存在问题的架构决策所带来的隐患。敏感点：指为了实现某种特定的质量属性，一个或多个构件所具有的特性。权衡点：指影响多个质量属性的特性，是多个质量属性的敏感点。风险点：可能引起风险的因素，可能导致一些问题。非风险点：如果某件事是可行的、可接受的，则为非风险点。系统架构风险如果业务逻辑的描述尚未达成共识，可能导致部分业务功能模块规则的矛盾，影响系统的可
    
                    
    • 
                    
  • 2024年前端提效项目盘点之：低代码拖拽生成页面（架构设计篇）
                        前端77
前端低代码
                        
    前言因为之前公司内部业务及提效的需要，做了一系列低代码的项目：分别有vscode插件、figma设计稿转代码插件、脚手架，拖拽生成h5营销页面和问卷等。现在把这一些系列实践的经验自我总结一下，形成一个低代码专栏。每个项目都分为思路架构设计和实践各两篇文章。当前是整个专栏的其中一个项目：拖拽生成h5页面（架构设计篇）1.起因为了满足公司运营及提效需要，搭建了一套供运营人员的使用的低代码平台。2.低代
    
                    
    • 
                    
  • 【软考速通笔记】系统架构设计师⑧——系统质量属性与架构评估
                        小康师兄
系统架构设计师笔记系统架构架构架构评估质量属性质量属性场景ATAM
                        
    文章目录一、前言二、软件系统质量属性2.1开发期质量属性2.2运行期质量属性三、质量属性场景描述四、系统架构评估方法4.1方法分类4.2软件架构分析方法4.3架构权衡分析法4.4成本效益分析法五、其他一、前言笔记目录大纲请查阅：【软考速通笔记】系统架构设计师——导读关注【小康师兄】微信公众号，回复【系统架构设计师】即可获取PDF和详细教程。二、软件系统质量属性2.1开发期质量属性易理解性：指软件系
    
                    
    • 
                    
  • 谷粒商城08:PowerDesigner数据库设计极速入门
                        ssk521125
科技数据库
                        
    在谷粒商城的开发过程中，数据库设计是至关重要的一环。PowerDesigner作为一款强大的数据库设计工具，能够帮助开发者高效地创建、管理和维护数据库模型。接下来，让我们快速入门，了解如何使用PowerDesigner进行谷粒商城的数据库设计。一、认识PowerDesigner（一）功能概述PowerDesigner是一款功能全面的建模工具，涵盖了数据库设计、业务流程建模、应用程序架构设计等多个领
    
                    
    • 
                    
  • 面试题-秒杀系统的设计
                        java路飞
面试复习java面试秒杀系统
                        
    文章目录什么是秒杀经典秒杀问题1.如何防止超卖？2.如何防止恶意请求？3.如何提高系统的并发能力？4.如何保证数据的一致性？你如何设计一个秒杀系统1.系统架构设计2.数据库设计3.秒杀流程设计4.安全性设计总结什么是秒杀秒杀是一种特殊的电商营销活动，通常指在一个短暂时间内，以极低的价格售卖限量商品的一种销售模式。秒杀活动通常会吸引大量用户参与，因此需要系统具备高并发、高可用和高性能等特点。在秒杀活
    
                    
    • 
                    
  • 聊一聊 IM 要如何实现运维与监控？
                        
后端java
                        
    IM系列imdoc实时通讯文档仓库聊一聊IM是什么？聊一聊IM即时通讯系统聊一聊IM要如何设计？聊一聊IM要如何设计功能模块？聊一聊IM要如何进行架构设计？聊一聊IM要如何进行技术选型？聊一聊IM要如何保证安全性？聊一聊IM要如何保证扩展性？聊一聊IM要如何实现运维与监控？聊一聊IM要如何提升用户体验？聊一聊IM要如何进行测试与部署？聊一聊IM要如何编写文档+技术支持？聊一聊IM要如何打造差异化？
    
                    
    • 
                    
  • 破解高并发难题：百万到亿级系统架构实战指南
                        繁华之中悟静
架构数据结构软件需求软件工程微服务软件构建
                        
    参考书籍《架构真意-企业级应用架构设计方法论与实践》作者范刚孙玄机械工业出版社本书通过架构设计方法论、分布式架构设计与实践和大数据架构设计三部分内容，系统阐述了在软件开发的时候，如何设计软件架构，并且对1000万级、5000万级、亿级等不同量级流量的系统平台给出了不同的技术架构方案。书籍对于想快速熟悉软件架构构建思想和理念的从业者，有较大的帮助。第一部分架构设计方法论架构设计按照“5视图法”分为逻
    
                    
    • 
                    
  • 聊一聊 IM 要如何提升用户体验？
                        
后端java
                        
    IM系列imdoc实时通讯文档仓库聊一聊IM是什么？聊一聊IM即时通讯系统聊一聊IM要如何设计？聊一聊IM要如何设计功能模块？聊一聊IM要如何进行架构设计？聊一聊IM要如何进行技术选型？聊一聊IM要如何保证安全性？聊一聊IM要如何保证扩展性？聊一聊IM要如何实现运维与监控？聊一聊IM要如何提升用户体验？聊一聊IM要如何进行测试与部署？聊一聊IM要如何编写文档+技术支持？聊一聊IM要如何打造差异化？
    
                    
    • 
                    
  • 聊一聊 IM 要如何提升用户体验？
                        
后端java
                        
    IM系列imdoc实时通讯文档仓库聊一聊IM是什么？聊一聊IM即时通讯系统聊一聊IM要如何设计？聊一聊IM要如何设计功能模块？聊一聊IM要如何进行架构设计？聊一聊IM要如何进行技术选型？聊一聊IM要如何保证安全性？聊一聊IM要如何保证扩展性？聊一聊IM要如何实现运维与监控？聊一聊IM要如何提升用户体验？聊一聊IM要如何进行测试与部署？聊一聊IM要如何编写文档+技术支持？聊一聊IM要如何打造差异化？
    
                    
    • 
                    
  • 教育培训APP开发全攻略：从网校系统源码搭建到功能优化的技术方案
                        万岳科技程序员小金
APP开发教学教育平台开发教育小程序软件开发APP开发在线教育系统源码教育APP开发教育平台搭建
                        
    本篇文章，笔者将从网校系统源码搭建到功能优化的角度，全面解析教育培训APP的开发技术方案，帮助企业和开发者更好地理解如何提升在线教育平台的性能与用户体验。一、教育培训APP开发的核心架构教育培训APP的架构设计是其能否顺利运行和扩展的基础。在设计过程中，需要考虑到用户数量、数据存储、信息安全、系统响应速度等多个因素。因此，架构的选择至关重要。1、前端架构：用户体验为核心教育培训APP的前端设计直接
    
                    
    • 
                    
  • 因果推断在智能广告中的实践
                        AI天才研究院
计算AI大模型应用入门实战与进阶大数据人工智能语言模型AILLMJavaPython架构设计AgentRPA计算AI大模型应用
                        
    非常感谢您提出这个有趣的话题。让我们一步步设计一个关于"因果推断在智能广告中的实践"的系统架构。这个项目将涉及复杂的数据分析、机器学习和广告投放系统，我们需要仔细考虑各个方面以确保系统的有效性和可扩展性。文章目录因果推断在智能广告中的实践-系统架构设计1.需求分析1.1功能需求1.2非功能性需求2.系统概述2.1高层次系统描述2.2主要组件及关系2.3系统核心流程3.详细架构设计3.1数据收集模块
    
                    
    • 
                    
  • Llama 2架构深度解析：Meta开源的70B参数大模型设计哲学
                        AI时代已来！
llama架构
                        
    一、架构设计理念Llama2作为Meta开源的商用级大语言模型，其架构设计体现了三大核心原则：效率优先：在7B/13B/70B参数规模下保持线性计算复杂度扩展性强化：通过改进注意力机制支持4k上下文长度安全性内嵌：在预训练阶段融入5%安全语料，降低有害输出概率（较前代下降34%）二、核心模块创新1.改进型Transformer架构标准化方案：采用RMSNorm替代LayerNorm，计算效率提升1
    
                    
    • 
                    
  • 《阿里游戏高可用架构设计实践》读后感
                        weixin_34343689
数据库后端运维
                        
    《阿里游戏高可用架构设计实践》读后感在文章当中我印象最深刻的一句话是“高可用的系统是设计出来的，不是靠运维保障出来的！”游戏出现故障会有很多原因，并不是说除了程序Bug以外，可能其他都是运维背黑锅了。其实，这些问题背后真正的原因是系统设计方案有问题，也就是说，技术上是比较弱的。1、高可用目标-传统方法高可用其实都是指几个9，5个9的话可能就是电信级或者金融级的，互联网大部分是3个9到4个9。2、高
    
                    
    • 
                    
  • 前端架构设计
                        weixin_34266504
前端测试javascriptViewUI
                        
    最近在拜读一本《前端架构设计》的书，该书讲到前端架构师的用户是开发人员。所选择的工具、编写的代码、创建的流程，都是为了让开发人员能够构建出最高效的、不出错的、可扩展的和可持续优化的系统。一、HTML1）标签规范化div乱炖是指嵌套多层div元素。为了保持简洁，语义化的标签是首选，应用样式所依靠的是HTML5元素名称和它们的层级关系，在标记中没有类名，往往写出层级的后代选择器。2）模块化方法前端开发
    
                    
    • 
                    
  • 华为数通Datacom认证体系详解：从HCIA到HCIE的进阶路径
                        武汉誉天
誉天资讯华为
                        
    华为数通Datacom（DataCommunication）课程是华为认证体系中的核心方向之一，聚焦企业网络通信与数据通信技术，适合从事网络规划、部署和运维的人员。一、数通Datacom课程体系华为数通Datacom认证分为三个级别，逐级递进，覆盖从网络基础到架构设计的全技能栈：HCIA-Datacom:华为认证数通工程师（初级）掌握基础网络搭建与运维能力HCIP-Datacom:华为认证数通高级
    
                    
    • 
                    
  • 基于架构的软件设计（Architecture-Based Software Design, ABSD）
                        丰年稻香
软件架构设计架构
                        
    1.引言在现代软件开发中，软件架构不仅决定了系统的可扩展性、可维护性和性能，还直接影响开发效率和成本。基于架构的软件设计（ABSD）采用系统化的方法，通过架构驱动整个软件开发生命周期，以确保系统的稳定性、可扩展性和适应性。本篇博客将介绍基于架构的软件设计的基础、主要活动及其输入输出，帮助软件架构师更好地理解和应用架构设计。2.基于架构的软件设计的基础ABSD方法的核心在于如何从系统需求出发，建立合
    
                    
    • 
                    
  • 从零到一：利用DeepSeek构建高精度图像分类模型实战解析
                        一碗黄焖鸡三碗米饭
人工智能前沿与实践分类数据挖掘人工智能
                        
    引言：为什么选择DeepSeek进行图像分类？在计算机视觉领域，图像分类作为基础任务，其技术演进经历了从传统特征工程到深度学习的革命性转变。DeepSeek作为国产自研的深度学习框架，凭借其高效计算优化和灵活架构设计，在ImageNet等基准测试中展现出与PyTorch、TensorFlow等主流框架相媲美的性能。本文将手把手带您实现从零搭建工业级图像分类模型的全过程。一、DeepSeek技术架构
    
                    
    • 
                    
  • 在线教育平台架构设计
                        AI天才研究院
编程实践Python实战自然语言处理人工智能语言模型编程实践开发语言架构设计
                        
    作者：禅与计算机程序设计艺术1.简介随着互联网的飞速发展，电子商务蓬勃发展，在线教育也成为火热话题。在线教育公司在做教育培训方面已经占据了大量的市场份额，他们通过各种方式让学习者在网上获得知识、技能和工具，提升个人能力。近年来，在线教育平台产品数量越来越多，复杂度也在不断增加，平台需要具备高可用、可扩展性、安全性、成本效益等优秀特性。因此，如何设计一个合适的在线教育平台，成为一个重要的课题。本文将
    
                    
    • 
                    
  • 软件架构设计：架构风格
                        Chief395
软考：架构师架构
                        
    一、架构风格概述定义架构风格是对软件系统整体结构和组织方式的抽象描述，提供了一套通用的设计原则和模式。作用提高系统的可维护性、可扩展性和可复用性。帮助开发团队在设计和实现过程中保持一致性和规范性。常见架构风格分层架构、MVC架构、微服务架构、事件驱动架构、管道-过滤器架构等。二、常见架构风格详解1.分层架构（LayeredArchitecture）特点：将系统划分为多个层次，每层只与相邻层交互。典
    
                    
    • 
                    
  • 《Kafka 理解： Broker、Topic 和 Partition》
                        频繁输入，积极输出
kafka分布式
                        
    Kafka核心架构解析：从概念到实践Kafka是一个分布式流处理平台，广泛应用于日志收集、实时数据分析和事件驱动架构。本文将从Kafka的核心组件、工作原理、实际应用场景等方面进行详细解析，帮助读者深入理解Kafka的架构设计及其在大数据领域的重要性。1.Kafka的背景与应用场景1.1Kafka的背景Kafka最初由LinkedIn开发，用于解决其大规模数据处理的挑战。2011年，Kafka开源
    
                    
    • 
                    
  • 基于 Elasticsearch 和 Milvus 的 RAG 运维知识库的架构设计和部署落地实现指南
                        ViniJack
AImilvus运维rag落地方案知识库
                        
    最近在整理一些业务场景的架构设计和部署落地实现指南先放一个【基于RAG的运维知识库(ElasticSearch+Milvus)的详细实现指南】，其中包含了详尽的技术实现细节、可运行的示例代码、原理分析、优缺点分析和应用场景分析。架构描述：基于RAG的运维知识库(ElasticSearch+Milvus)部署指南1.极其详细的部署步骤(包含详尽的技术实现细节和分步骤、可运行的示例代码-也只能给示例代
    
                    
    • 
                    
  • SQL 大厂面试题目（由浅入深）
                        egekm_sefg
面试学习路线阿里巴巴sql面试数据库
                        
    今天给大家带来一份大厂SQL面试覆盖：基础语法→复杂查询→性能优化→架构设计，大家需深入理解执行原理并熟悉实际业务场景的解决方案。1.基础查询与过滤题目：查询employees表中所有薪资（salary）大于10000且部门编号（dept_id）为5的员工姓名（name）和入职日期（hire_date）。SELECTname,hire_date?FROMemployees?WHEREsalary>
    
                    
    • 
                    
  • Redis 架构与设计
                        yuguo.im
redis架构数据库
                        
    Redis是一种开源的高性能内存键值数据库，其架构设计围绕简单、快速和高效展开。1.Redis的核心架构Redis是一个基于C语言编写的单线程内存数据库，但通过多路复用实现了高效的并发处理。它的架构主要由以下几个模块组成：a.客户端与服务器Redis采用客户端-服务器架构：客户端发送命令请求。服务器处理请求并返回结果。通信使用RESP（RedisSerializationProtocol）协议。b
    
                    
    • 
                    
  • 大模型时代的软件架构设计
                        AI天才研究院
计算DeepSeekR1&大数据AI人工智能大模型AI大模型企业级应用开发实战javapythonjavascriptkotlingolang架构人工智能大厂程序员硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLM系统架构设计软件哲学Agent程序员实现财富自由
                        
    引言当今世界，人工智能（AI）技术正以惊人的速度发展，其中大模型（LargeModels）的崛起尤为引人注目。大模型，也被称为深度学习模型，因其庞大的参数规模和强大的数据处理能力，成为推动AI技术前进的重要力量。随着大模型的广泛应用，软件架构设计面临着前所未有的挑战和机遇。大模型时代的软件架构设计，不仅需要解决传统软件架构所面对的问题，如性能、可靠性和可扩展性等，还需要应对大模型带来的新挑战，如计
    
                    
    • 
                    
  • 游戏任务系统模块架构设计分析
                        你一身傲骨怎能输
射击游戏项目游戏
                        
    1.引言在现代商业化射击游戏中，任务系统是一个至关重要的模块。它不仅能增加游戏的深度和趣味性，还能通过任务奖励机制提高玩家的参与度和留存率。本文将详细介绍一个高扩展、高性能、高可配置的C#语言任务系统模块的架构设计和实现。2.需求分析2.1功能需求任务创建与管理：支持创建、更新、删除任务。任务分配：支持将任务分配给玩家。任务进度跟踪：实时跟踪玩家的任务进度。任务完成与奖励：处理任务完成后的奖励发放
    
                    
    • 
                    
  • 玩转Java微服务：架构设计与实战进阶终极指南
                        Light60
低代码实战篇技能篇Java微服务SpringCloud分布式架构容器化部署服务治理
                        
    摘要本文深入解析Java微服务核心原理与落地实践，涵盖SpringCloudAlibaba生态体系实战技巧。通过全链路代码示例演示服务注册发现、分布式配置、熔断限流等关键模块实现，结合电商案例阐述DDD领域驱动设计在微服务拆分的应用。提供可落地的性能优化方案与云原生演进路线，助您构建高可用、易扩展的现代化分布式系统。关键词：Java微服务、SpringCloud、分布式架构、容器化部署、服务治理一
    
                    
    • 
                                
  • 数据采集高并发的架构应用
                                    3golden
.net
                                    
    问题的出发点： 
 
         最近公司为了发展需要，要扩大对用户的信息采集，每个用户的采集量估计约2W。如果用户量增加的话，将会大量照成采集量成3W倍的增长，但是又要满足日常业务需要，特别是指令要及时得到响应的频率次数远大于预期。 
      &n
    
                                
    • 
                                
  • 不停止 MySQL 服务增加从库的两种方式
                                    brotherlamp
linuxlinux视频linux资料linux教程linux自学
                                    
    现在生产环境MySQL数据库是一主一从，由于业务量访问不断增大，故再增加一台从库。前提是不能影响线上业务使用，也就是说不能重启MySQL服务，为了避免出现其他情况，选择在网站访问量低峰期时间段操作。 
 一般在线增加从库有两种方式，一种是通过mysqldump备份主库，恢复到从库，mysqldump是逻辑备份，数据量大时，备份速度会很慢，锁表的时间也会很长。另一种是通过xtrabacku
    
                                
    • 
                                
  • Quartz——SimpleTrigger触发器
                                    eksliang
SimpleTriggerTriggerUtilsquartz
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2208166 一.概述 
SimpleTrigger触发器，当且仅需触发一次或者以固定时间间隔周期触发执行； 
  二.SimpleTrigger的构造函数 
 
 SimpleTrigger(String name, String group)：通过该构造函数指定Trigger所属组和名称； 
 Simpl
    
                                
    • 
                                
  • Informatica应用（1）
                                    18289753290
sqlworkflowlookup组件Informatica
                                    
    1.如果要在workflow中调用shell脚本有一个command组件，在里面设置shell的路径；调度wf可以右键出现schedule，现在用的是HP的tidal调度wf的执行。 
2.designer里面的router类似于SSIS中的broadcast（多播组件）;Reset_Workflow_Var：参数重置 （比如说我这个参数初始是1在workflow跑得过程中变成了3我要在结束时还要
    
                                
    • 
                                
  • python 获取图片验证码中文字
                                    酷的飞上天空
python
                                    
    根据现成的开源项目 http://code.google.com/p/pytesser/改写 
在window上用easy_install安装不上  看了下源码发现代码很少  于是就想自己改写一下 
  
添加支持网络图片的直接解析 
  
  
#coding:utf-8 
#import sys 
#reload(sys) 
#sys.s
    
                                
    • 
                                
  • AJAX
                                    永夜-极光
Ajax
                                    
    1.AJAX功能:动态更新页面,减少流量消耗,减轻服务器负担 
  
2.代码结构: 
   
<html>

<head>
<script type="text/javascript">
function loadXMLDoc()
{
.... AJAX script goes here ...

    
                                
    • 
                                
  • 创业OR读研
                                    随便小屋
创业
                                    
            现在研一，有种想创业的想法，不知道该不该去实施。因为对于的我情况这两者是矛盾的，可能就是鱼与熊掌不能兼得。 
       
        研一的生活刚刚过去两个月，我们学校主要的是
    
                                
    • 
                                
  • 需求做得好与坏直接关系着程序员生活质量
                                    aijuans
IT 生活
                                    
      
        这个故事还得从去年换工作的事情说起，由于自己不太喜欢第一家公司的环境我选择了换一份工作。去年九月份我入职现在的这家公司，专门从事金融业内软件的开发。十一月份我们整个项目组前往北京做现场开发，从此苦逼的日子开始了。 
       系统背景：五月份就有同事前往甲方了解需求一直到6月份，后续几个月也完
    
                                
    • 
                                
  • 如何定义和区分高级软件开发工程师
                                    aoyouzi

                                    
    在软件开发领域，高级开发工程师通常是指那些编写代码超过 3 年的人。这些人可能会被放到领导的位置，但经常会产生非常糟糕的结果。Matt Briggs 是一名高级开发工程师兼 Scrum 管理员。他认为，单纯使用年限来划分开发人员存在问题，两个同样具有 10 年开发经验的开发人员可能大不相同。近日，他发表了一篇博文，根据开发者所能发挥的作用划分软件开发工程师的成长阶段。 
　　初
    
                                
    • 
                                
  • Servlet的请求与响应
                                    百合不是茶
servletget提交java处理post提交
                                    
      
Servlet是tomcat中的一个重要组成,也是负责客户端和服务端的中介 
  
  
1,Http的请求方式(get  ,post); 
  客户端的请求一般都会都是Servlet来接受的,在接收之前怎么来确定是那种方式提交的,以及如何反馈,Servlet中有相应的方法,  http的get方式 servlet就是都doGet(
    
                                
    • 
                                
  • web.xml配置详解之listener
                                    bijian1013
javaweb.xmllistener
                                    
    一.定义 
<listener>  
	<listen-class>com.myapp.MyListener</listen-class>  
</listener> 
  
二.作用        该元素用来注册一个监听器类。可以收到事件什么时候发生以及用什么作为响
    
                                
    • 
                                
  • Web页面性能优化（yahoo技术）
                                    Bill_chen
JavaScriptAjaxWebcssYahoo
                                    
    1.尽可能的减少HTTP请求数 content 
2.使用CDN server 
3.添加Expires头(或者 Cache-control) server 
4.Gzip 组件 server 
5.把CSS样式放在页面的上方。 css 
6.将脚本放在底部(包括内联的) javascript 
7.避免在CSS中使用Expressions css 
8.将javascript和css独立成外部文
    
                                
    • 
                                
  • 【MongoDB学习笔记八】MongoDB游标、分页查询、查询结果排序
                                    bit1129
mongodb
                                    
    游标 
  
游标，简单的说就是一个查询结果的指针。游标作为数据库的一个对象，使用它是包括 
 
 声明 
 打开 
 循环抓去一定数目的文档直到结果集中的所有文档已经抓取完 
 关闭游标 
 
  
游标的基本用法，类似于JDBC的ResultSet(hasNext判断是否抓去完,next移动游标到下一条文档)，在获取一个文档集时，可以提供一个类似JDBC的FetchSize
    
                                
    • 
                                
  • ORA-12514 TNS 监听程序当前无法识别连接描述符中请求服务 的解决方法
                                    白糖_
ORA-12514
                                    
     今天通过Oracle SQL*Plus连接远端服务器的时候提示“监听程序当前无法识别连接描述符中请求服务”，遂在网上找到了解决方案： 
 ①打开Oracle服务器安装目录\NETWORK\ADMIN\listener.ora文件，你会看到如下信息： 
  
# listener.ora Network Configuration File: D:\database\Oracle\net
    
                                
    • 
                                
  • Eclipse 问题 A resource exists with a different case
                                    bozch
eclipse
                                    
    在使用Eclipse进行开发的时候，出现了如下的问题： 
Description Resource Path Location TypeThe project was not built due to "A resource exists with a different case: '/SeenTaoImp_zhV2/bin/seentao'.&
    
                                
    • 
                                
  • 编程之美-小飞的电梯调度算法
                                    bylijinnan
编程之美
                                    
    

public class AptElevator {

	/**
	 * 编程之美 小飞 电梯调度算法
	 * 在繁忙的时间，每次电梯从一层往上走时，我们只允许电梯停在其中的某一层。
	 * 所有乘客都从一楼上电梯，到达某层楼后，电梯听下来，所有乘客再从这里爬楼梯到自己的目的层。
	 * 在一楼时，每个乘客选择自己的目的层，电梯则自动计算出应停的楼层。
	 * 问：电梯停在哪
    
                                
    • 
                                
  • SQL注入相关概念
                                    chenbowen00
sqlWeb安全
                                    
    SQL Injection：就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。 
 
具体来说，它是利用现有应用程序，将（恶意）的SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。 
 
首先让我们了解什么时候可能发生SQ
    
                                
    • 
                                
  • [光与电]光子信号战防御原理
                                    comsci
原理
                                    
     
 
      无论是在战场上,还是在后方,敌人都有可能用光子信号对人体进行控制和攻击,那么采取什么样的防御方法,最简单,最有效呢? 
 
      我们这里有几个山寨的办法,可能有些作用,大家如果有兴趣可以去实验一下 
 
      根据光
    
                                
    • 
                                
  • oracle 11g新特性:Pending Statistics
                                    daizj
oracledbms_stats
                                    
    oracle 11g新特性:Pending Statistics 转 
 
从11g开始，表与索引的统计信息收集完毕后，可以选择收集的统信息立即发布，也可以选择使新收集的统计信息处于pending状态，待确定处于pending状态的统计信息是安全的，再使处于pending状态的统计信息发布，这样就会避免一些因为收集统计信息立即发布而导致SQL执行计划走错的灾难。 
 
在 11g 之前的版本中，D
    
                                
    • 
                                
  • 快速理解RequireJs
                                    dengkane
jqueryrequirejs
                                    
    RequireJs已经流行很久了，我们在项目中也打算使用它。它提供了以下功能： 
 
 声明不同js文件之间的依赖 
 可以按需、并行、延时载入js库 
 可以让我们的代码以模块化的方式组织 
 
初看起来并不复杂。 在html中引入requirejs 
在HTML中，添加这样的 <script> 标签： 
<script src="/path/to
    
                                
    • 
                                
  • C语言学习四流程控制if条件选择、for循环和强制类型转换
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int i, j;

	scanf("%d %d", &i, &j);

	if (i > j)
		printf("i大于j\n");
	else
		printf("i小于j\n");

	retu
    
                                
    • 
                                
  • dictionary的使用要注意
                                    dcj3sjt126com
IO
                                    
    NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:
                          user.user_id , @"id",
                          user.username , @"username",
         
    
                                
    • 
                                
  • Android 中的资源访问(Resource)
                                    finally_m
xmlandroidStringdrawablecolor
                                    
     
简单的说，Android中的资源是指非代码部分。例如，在我们的Android程序中要使用一些图片来设置界面，要使用一些音频文件来设置铃声，要使用一些动画来显示特效，要使用一些字符串来显示提示信息。那么，这些图片、音频、动画和字符串等叫做Android中的资源文件。 
在Eclipse创建的工程中，我们可以看到res和assets两个文件夹，是用来保存资源文件的，在assets中保存的一般是原生
    
                                
    • 
                                
  • Spring使用Cache、整合Ehcache
                                    234390216
springcacheehcache@Cacheable
                                    
    Spring使用Cache 
  
  
       从3.1开始，Spring引入了对Cache的支持。其使用方法和原理都类似于Spring对事务管理的支持。Spring Cache是作用在方法上的，其核心思想是这样的：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的
    
                                
    • 
                                
  • 当druid遇上oracle blob(clob)
                                    jackyrong
oracle
                                    
    http://blog.csdn.net/renfufei/article/details/44887371 
 
众所周知，Oracle有很多坑, 所以才有了去IOE。 
 
在使用Druid做数据库连接池后，其实偶尔也会碰到小坑，这就是使用开源项目所必须去填平的。【如果使用不开源的产品，那就不是坑，而是陷阱了，你都不知道怎么去填坑】 
 
用Druid连接池，通过JDBC往Oracle数据库的
    
                                
    • 
                                
  • easyui datagrid pagination获得分页页码、总页数等信息
                                    ldzyz007

                                    
    var grid = $('#datagrid');  
var options = grid.datagrid('getPager').data("pagination").options;  
var curr = options.pageNumber;  
var total = options.total;  
var max =
    
                                
    • 
                                
  • 浅析awk里的数组
                                    nigelzeng
二维数组array数组awk
                                    
    awk绝对是文本处理中的神器，它本身也是一门编程语言，还有许多功能本人没有使用到。这篇文章就单单针对awk里的数组来进行讨论，如何利用数组来帮助完成文本分析。 
  
有这么一组数据： 
   abcd,91#31#2012-12-31 11:24:00 
case_a,136#19#2012-12-31 11:24:00 
case_a,136#23#2012-12-31 1
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(6) - TigerVNC
                                    rensanning
centos
                                    
    安装GNOME桌面环境 
 
# yum groupinstall "X Window System" "Desktop" 
 
 
安装TigerVNC 
 
# yum -y install tigervnc-server tigervnc 
 
 
启动VNC服务 
 
# /etc/init.d/vncserver restart
# vncser
    
                                
    • 
                                
  • Spring 数据库连接整理
                                    tomcat_oracle
springbeanjdbc
                                    
    1、数据库连接jdbc.properties配置详解  　　jdbc.url=jdbc:hsqldb:hsql://localhost/xdb   　　jdbc.username=sa   　　jdbc.password=   　　jdbc.driver=不同的数据库厂商驱动，此处不一一列举   　　接下来，详细配置代码如下：   　　 
Spring连接池      
    
                                
    • 
                                
  • Dom4J解析使用xpath java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常
                                    xp9802

                                    
    用Dom4J解析xml,以前没注意,今天使用dom4j包解析xml时在xpath使用处报错 
     异常栈：java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常  
     导入包 jaxen-1.1-beta-6.jar 解决; 
&nb
    
                                
    •