RPC框架之——thrift的深入理解（二）

最新推荐文章于 2024-01-25 18:09:41 发布
最新推荐文章于 2024-01-25 18:09:41 发布
阅读量530 收藏 6
点赞数
文章标签： rpc apache java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mucheng_/article/details/129473073
版权

一、网络服务模型详解

简介：Thrift提供的网络服务模型：单线程、多线程、事件驱动，从另一个角度划分为：阻塞服务模型、非阻塞服务模型。

阻塞服务模型：TSimpleServer、TThreadPoolServer。

非阻塞服务模型：TNonblockingServer、THsHaServer和TThreadedSelectorServer

图片.png

1、TServer

TServer定义了静态内部类Args，Args继承自抽象类AbstractServerArgs。AbstractServerArgs采用了建造者模式，向TServer提供各种工厂。

图片.png

2、TSimpleServer

TSimpleServer的工作模式采用最简单的阻塞IO，实现方法简洁明了，便于理解，但是一次只能接收和处理一个socket连接，效率比较低。它主要用于演示Thrift的工作过程，在实际开发过程中很少用到它。

图片.png

服务端代码：

package com.yogurt;

import com.yogurt.Service.Impl.UserServiceImpl;
import com.yogurt.Service.UserService;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TSimpleServer;
import org.apache.thrift.transport.TServerSocket;

/**
 * @author yogurt
 * @Date 2023/2/26 - 18:27 - 2023
 */
public class SimpleService {

    public static void main(String[] args) {
        try{
            TServerSocket socket = new TServerSocket(9000);
            // 获取process
            UserService.Processor processor = new UserService.Processor(new UserServiceImpl());
            // 指定TBinaryProtocol
            TBinaryProtocol.Factory factory = new TBinaryProtocol.Factory();

            TServer.Args args1 = new TSimpleServer.Args(socket);
            args1.processor(processor);
            args1.protocolFactory(factory);

            TSimpleServer tSimpleServer = new TSimpleServer(args1);

            tSimpleServer.serve();
        }catch (Exception e){
            System.out.println(e);
        }
    }
}

客户端代码：

package com.yogurt;

import com.yogurt.Service.User;
import com.yogurt.Service.UserService;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.transport.TSocket;

/**
 * @author yogurt
 * @Date 2023/2/26 - 18:36 - 2023
 */
public class client {

    public static void main(String[] args) {

        try{
            TSocket socket = new TSocket("localhost", 9000);
            // 指定二进制编码
            TBinaryProtocol protocol = new TBinaryProtocol(socket);
            UserService.Client client = new UserService.Client(protocol);
            socket.open();

            // RPC 调用
            User byId = client.getById(9000);
            System.out.println("byId = " + byId);
        }catch (Exception e){
            System.out.println(e);
        }
    }
}

3、TThreadPoolServer

TThreadPoolServer模式采用阻塞socket方式工作，主线程负责阻塞式监听是否有新socket到来，具体的业务处理交由一个线程池来处理。

图片.png

服务端代码：

package com.yogurt;

import com.yogurt.Service.Impl.UserServiceImpl;
import com.yogurt.Service.UserService;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TThreadPoolServer;
import org.apache.thrift.server.TThreadedSelectorServer;
import org.apache.thrift.transport.TServerSocket;
import org.apache.thrift.transport.TTransportException;

/**
 * @author yogurt
 * @Date 2023/3/4 - 22:35 - 2023
 */
public class ThreadPoolServer {

    public static void main(String[] args) throws TTransportException {
        TServerSocket socket = new TServerSocket(9000);
        UserService.Processor processor = new UserService.Processor(new UserServiceImpl());
        TBinaryProtocol.Factory factory = new TBinaryProtocol.Factory();
        TThreadPoolServer.Args args1 = new TThreadPoolServer.Args(socket);
        args1.processor(processor);
        args1.protocolFactory(factory);

        TThreadPoolServer server = new TThreadPoolServer(args1);
        server.serve();
    }
}

ThreadPoolServer解决了TSimpleServer不支持并发和多连接的问题，引入了线程池。实现的模型是One Thread Per Connection。

优缺点：

TThreadPoolServer模式的优点

拆分了监听线程(Accept Thread)和处理客户端连接的工作线程(Worker Thread)，数据读取和业务处理都交给线程池处理。因此在并发量较大时新连接也能够被及时接受。线程池模式比较适合服务器端能预知最多有多少个客户端并发的情况，这时每个请求都能被业务线程池及时处理，性能也非常高。

TThreadPoolServer模式的缺点

线程池模式的处理能力受限于线程池的工作能力，当并发请求数大于线程池中的线程数时，新请求也只能排队等待。
默认线程池允许创建的最大线程数量为Integer.MAX_VALUE，可能会创建出大量线程，导致OOM(内存溢出)

4、TNonblockingServer

TNonblockingServer模式也是单线程工作，但是采用NIO的模式，利用io多路复用模型处理socket就绪事件,对于有数据到来的socket进行数据读取操作，对于有数据发送的socket则进行数据发送操作，对于监听socket则产生一个新业务socket并将其注册到selector上（注：TNonblockingServer要求底层的传输通道必须使用TFramedTransport）

图片.png

服务端代码：

package com.yogurt;

import com.yogurt.Service.Impl.UserServiceImpl;
import com.yogurt.Service.UserService;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.transport.TNonblockingServerSocket;
import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.transport.layered.TFramedTransport;

/**
 * @author yogurt
 * @Date 2023/3/4 - 23:39 - 2023
 */
public class TNonblockingServer {
    public static void main(String[] args) throws Exception {
        TNonblockingServerSocket socket = new TNonblockingServerSocket(9000);
        UserService.Processor processor = new UserService.Processor(new UserServiceImpl());
        TCompactProtocol.Factory factory = new TCompactProtocol.Factory();
        TFramedTransport.Factory factory1 = new TFramedTransport.Factory();
        org.apache.thrift.server.TNonblockingServer.Args args1 = new org.apache.thrift.server.TNonblockingServer.Args(socket);
        args1.processor(processor);
        args1.protocolFactory(factory);
        args1.transportFactory(factory1);

        org.apache.thrift.server.TNonblockingServer server = new org.apache.thrift.server.TNonblockingServer(args1);
        server.serve();
    }
}

客户端代码：

package com.yogurt;

import com.yogurt.Service.User;
import com.yogurt.Service.UserService;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.transport.layered.TFramedTransport;

/**
 * @author yogurt
 * @Date 2023/3/5 - 0:27 - 2023
 */
public class NonblockingClient {
    public static void main(String[] args) throws Exception {
        TFramedTransport transport = new TFramedTransport(new TSocket("localhost",9000));
        TCompactProtocol protocol = new TCompactProtocol(transport);
        UserService.Client client = new UserService.Client(protocol);
        transport.open();

        User byId = client.getById(900);
        System.out.println("byId = " + byId);
    }
}

优缺点

TNonblockingServer模式优点

相比于TSimpleServer效率提升主要体现在IO多路复用上，TNonblockingServer采用非阻塞IO，对accept/read/write等IO事件进行监控和处理，同时监控多个socket的状态变化。

TNonblockingServer模式缺点

TNonblockingServer模式在业务处理上还是采用单线程顺序来完成。在业务处理比较复杂、耗时的时候，例如某些接口函数需要读取数据库执行时间较长，会导致整个服务被阻塞住，此时该模式效率也不高，因为多个调用请求任务依然是顺序一个接一个执行

5、THsHaServer

鉴于TNonblockingServer的缺点，THsHaServer继承于TNonblockingServer，引入了线程池提高了任务处理的并发能力（注：THsHaServer和TNonblockingServer一样，要求底层的传输通道必须使用TFramedTransport）

图片.png

服务端代码：

package com.yogurt;

import com.yogurt.Service.Impl.UserServiceImpl;
import com.yogurt.Service.UserService;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.TNonblockingServer;
import org.apache.thrift.transport.TNonblockingServerSocket;
import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.transport.layered.TFramedTransport;

/**
 * @author yogurt
 * @Date 2023/3/5 - 10:48 - 2023
 */
public class HsHaServer {

    public static void main(String[] args) throws TTransportException {
        TNonblockingServerSocket socket = new TNonblockingServerSocket(9000);
        UserService.Processor processor = new UserService.Processor(new UserServiceImpl());
        TCompactProtocol.Factory factory = new TCompactProtocol.Factory();
        TFramedTransport.Factory factory1 = new TFramedTransport.Factory();

        TNonblockingServer.Args args1 = new TNonblockingServer.Args(socket);
        args1.processor(processor);
        args1.protocolFactory(factory);
        args1.transportFactory(factory1);

        TNonblockingServer server = new TNonblockingServer(args1);

        server.serve();
    }
}

优缺点

THsHaServer的优点

THsHaServer与TNonblockingServer模式相比，THsHaServer在完成数据读取之后，将业务处理过程交由一个线程池来完成，主线程直接返回进行下一次循环操作，效率大大提升。

THsHaServer的缺点

主线程仍然需要完成所有socket的监听接收、数据读取和数据写入操作。当并发请求数较大时，且发送数据量较多时，监听socket上新连接请求不能被及时接受

6、TThreadedSelectorServer

TThreadedSelectorServer是对THsHaServer的一种扩充，它将selector中的读写IO事件(read/write)从主线程中分离出来。同时引入worker工作线程池。TThreadedSelectorServer模式是目前Thrift提供的最高级的线程服务模型，它内部有如果几个部分构成：

  1. 一个AcceptThread专门用于处理监听socket上的新连接。

  2. 若干个SelectorThread专门用于处理业务socket的网络I/O读写操作，所有网络数据的读写均是有这些线程来完成。

  3. 一个负载均衡器SelectorThreadLoadBalancer对象，主要用于AcceptThread线程接收到一个新socket连接请求时，决定将这个新连接请求分配给哪个SelectorThread线程。

  4. 一个ExecutorService类型的工作线程池，在SelectorThread线程中，监听到有业务socket中有调用请求过来，则将请求数据读取之后，交给ExecutorService线程池中的线程完成此次调用的具体执行。主要用于处理每个rpc请求的handler回调处理。

图片.png

服务端代码：

package com.yogurt;

import com.yogurt.Service.Impl.UserServiceImpl;
import com.yogurt.Service.UserService;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.TThreadedSelectorServer;
import org.apache.thrift.transport.TNonblockingServerSocket;
import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.transport.layered.TFramedTransport;

/**
 * @author yogurt
 * @Date 2023/3/5 - 11:07 - 2023
 */
public class ThreadedSelectorServer {

    public static void main(String[] args) throws TTransportException {
        TNonblockingServerSocket socket = new TNonblockingServerSocket(9000);
        UserService.Processor<UserServiceImpl> processor = new UserService.Processor<>(new UserServiceImpl());
        TCompactProtocol.Factory factory = new TCompactProtocol.Factory();
        TFramedTransport.Factory factory1 = new TFramedTransport.Factory();

        TThreadedSelectorServer.Args args1 = new TThreadedSelectorServer.Args(socket);
        args1.processor(processor);
        args1.protocolFactory(factory);
        args1.transportFactory(factory1);
        TThreadedSelectorServer server = new TThreadedSelectorServer(args1);

        server.serve();
    }
}

客户端代码：

package com.yogurt;

import com.yogurt.Service.User;
import com.yogurt.Service.UserService;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.transport.layered.TFramedTransport;

/**
 * @author yogurt
 * @Date 2023/3/5 - 11:13 - 2023
 */
public class ThreadedSelectorClient {

    public static void main(String[] args) {

        for (int i = 0; i < 5; i++) {

            new Thread(() ->{
                try {
                    handle();
                } catch (TTransportException e) {
                    e.printStackTrace();
                } catch (TException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

    public static void handle() throws TException {
        TFramedTransport transport = new TFramedTransport(new TSocket("localhost", 9000));

        TCompactProtocol protocol = new TCompactProtocol(transport);
        UserService.Client client = new UserService.Client(protocol);
        transport.open();
        User byId = client.getById(9000);
        System.out.println("byId = " + byId);
    }
}
来源项目
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RPC学习-RPC远程调用（Thrift）
qq_48772498的博客
05-06 1439
一.Thrift RPC 调用过程 对于客户端而言，Thrift RPC 框架提供接口代理类，调用 RPC 接口，同调用本地方法一样，不需要感知如何通过网络 IO 调用其他服务器上实现的方法并拿到结果。 对于服务端而言，实现 RPC 接口同实现本地定义的 interface 一样，只需要编写具体业务实现逻辑，不需要关注这个方法如何能够被其他服务器所使用。 二.Thrift RPC 框架介绍 Thrift 是 Facebook 于 2007 年开发的跨语言的 RPC 框架，支持 Java、Node.
Thrift 框架
qq_51861704的博客
05-09 5471
目录 Thrift 框架总体概述 Thrift 基础架构详解 Thrift 框架实现原理 以方法调用String getStr(String str1,Strin str2)为例描述Thrift 框架实现原理 Thrift支持的数据传输格式、数据传输方式和服务模型以及Thrift可定义的数据类 Thrift 框架总体概述 Thrift实际上是实现了C/S（客户/服务器模式）模式，通过代码生成工具将接口定义文件生成服务器端和客户端代码（可以为不同语言），从而实现服务端和客户端跨语言的支持
RPC框架之——thrift的深入理解（一）
mucheng_的博客
02-26 3134
Thrift是一个轻量级、跨语言的RPC框架，主要用于各个服务之间的RPC通信，最初由Facebook于2007年开发，2008年进入Apache开源项目。它通过自身的IDL中间语言, 并借助代码生成引擎生成各种主流语言的RPC服务端/客户端模板代码。
一文学习Thrift RPC
qq_45774645的博客
01-25 1839
1. thrift-client 代表的是服务的调用者2. thrift-server 代表的是服务的提供者3. thrift-common RPC编程共有的内容 1，实体类型 2，服务接口。
0202年，您真的需要Thrift这样一个RPC微服务框架来拯救一下传统HTTP接口(api)了
刘悦的技术博客
05-04 704
但毋庸置疑，HTTP接口由于受限于HTTP协议，需要带HTTP请求头，导致传输起来效率或者说安全性不如RPC，目前市面上流行的rpc框架有dubbo/hessian Thrift，阿里开源的dubbo固然还不错，但是本人更倾向于facebook开源的Thrift框架，这款框架在github上好评如潮，这一次我们使用的就是基于Thrift的thriftpy2框架。第三个来说就是安全性。服务端首先读取通信文件，然后建立起一个服务，监听6000端口，等待客户端请求，实际上服务端的方法也是主要业务逻辑编写的地方。
java写非常不错的RPC框架，基于Thrift
06-28
HARPC（High Availability RPC）是基于Thrift的跨语言、高可用的RPC框架。具备高性能、高可用、轻量级等特点 * 跨语言通信 * 方便的使Java、Python、C++三种程序可以相互通信 * 负载均衡和容灾处理 * 方便的实现...
cocolian-rpc:使用Apache Thrift作为容器，Google Protobuf作为协议的一个RPC框架
05-15
一、功能cocolian-rpc是一个RPC...二、cocolian-rpc-server使用Apache Thrift 作为RPC Server， Protobuf Message作为输入输出参数。 Apache Thrift作为Server，我们以这个Servce作为基础服务：service BaseService
Thrift RPC客户端的服务化框架代码
07-31
Thrift RPC客户端的服务化框架代码,
C++Workflow的RPC框架源码.zip
05-19
C++ Workflow的RPC框架，支持百度bRPC、腾讯tRPC以及thrift协议。C++ Workflow的RPC框架，支持百度bRPC、腾讯tRPC以及thrift协议。C++ Workflow的RPC框架，支持百度bRPC、腾讯tRPC以及thrift协议。C++ Workflow的RPC...
基于thrift的rpc框架，在thrift基础上增加负载均衡，连接池，性能监控.zip
最新发布
03-23
基于thrift的rpc框架，在thrift基础上增加负载均衡，连接池，性能监控.zip
thrift多线程服务端
热门推荐
xiaoshe的专栏
06-22 1万+
接上一篇 thrift一个例子 作为服务端，应该能够同时接收多个客户端传来的数据，所以服务端应该实现多线程机制。按以下3个步骤改写服务端（Serv_server.skeleton.cpp）即可实现多线程。（1）采用线程池的main函数的代码如下：int main(int argc, char **argv) { // thread pool shared_ptrServHandle
Thrift中Tserverclinet的异步调用问题
KaffeeVenus
04-18 1813
project.gradle.buildFinished { /*生成的SvcBaseOriginal.java 需要将TServerClient修改为自己的，不然多线程有问题/ def clientFile = new File(‘src/main/gen/kl/hsm/server/svc/base/SvcBaseOriginal.java’) def list = [] if(clientF...
Thrift+Haproxy负载均衡
一个菜鸟
06-21 7428
应用需求项目时间使用中，后台存在4个使用thrift创建的A、B、C、D四个相同的Rpc服务，另外两个相同的服务E、F需要请求Rpc服务获取服务结果，在实际应用中E、F两个服务的请求需要随机的发送到四台Rpc服务，实现负载均衡。由于thrift使用的是tcp传输协议，也就是说我们需要使用第四层负责均衡技术来实现thrift Rpc服务的负载均衡。常用的负责均衡软件有Nginx、Haproxy等，但是
【基础】利用thrift实现一个非阻塞带有回调机制的客户端
weixin_30340819的博客
12-23 206
假设读者对thrift有一定了解。 　　客户端有时需要非阻塞的去发送请求，给定服务端一个请求，要求其返回一个计算结果。但是客户端不想等待服务端处理完，而是想发送完这个指令后自己去做其他事情，当结果返回时自动的去处理。 　　比如举个形象点的例子：饭店的Boss让小弟A把本周店里的欠条收集起来放到自己桌子上，然后又告诉自己的小秘书坐在自己办公室等着小弟A把欠条拿过来，然后统计一下一共有多少，...
什么是 Thrift（RPC）？一种接口描述语言和二进制通讯协议，用来定义和创建跨语言的服务
RToax
10-04 1513
Thrift是一种接口描述语言和二进制通讯协议，它被用来定义和创建跨语言的服务。它被当作一个远程过程调用（RPC）框架来使用，是由Facebook为“大规模跨语言服务开发”而开发的。它通过一个代码生成引擎联合了一个软件栈，来创建不同程度的、无缝的跨平台高效服务，可以使用C#、C++（基于POSIX兼容系统）、Cappuccino、Cocoa、Delphi、Erlang、Go、Haskell、Java、Node.js、OCaml、Perl、PHP、Python、Ruby和Smalltalk。
spring整合thrift实现不同java项目回调
newayue的博客
04-03 504
1：https://www.cnblogs.com/chenny7/p/4224720.htmlthrift原理和使用 2：生成java的thrift文件： （1）先创建一个服务Hello.thrift： namespace java com.ayue.thrift.protocol service Hello{ string helloString(1:string par...
跨语言RPC框架Thrift详解
zw19910924的专栏
10-08 1万+
一、 概念Apache的Thrift软件框架，是用来进行可伸缩的、跨语言的服务开发，它通过一个代码生成引擎来构建高效、无缝的服务，这些服务能够实现跨语言调度，目前支持的语言有： C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, OCaml and Delphi
Thrift使用入门-RPC服务
cjf_wei的博客
12-18 2229
Thrift是一个跨语言的服务部署框架，除了提供性能优异的序列化/反序列化功能，还提供了RPC服务，相对于Protocol buffers，它支持的语言更加广泛。本文介绍使用Thrift的RPC实现client和server间的通信。对于Thrift的介绍和语法说明可以参见文献[1-2]。
跨语言rpc框架thrift实战
07-28
跨语言 RPC 框架 Thrift 是一个开源的高效通信协议和序列化框架，可以用于构建跨语言的客户端和服务器端应用程序。 下面是一个简单的 Thrift 实战示例： 1. 定义 Thrift 文件：首先，我们需要创建一个 .thrift 文件来定义我们的 RPC 接口和数据结构。例如，我们可以创建一个名为 "calculator.thrift" 的文件，其中包含以下内容： ``` namespace java com.example.calculator namespace py calculator service CalculatorService { i32 add(1: i32 num1, 2: i32 num2), i32 subtract(1: i32 num1, 2: i32 num2), i32 multiply(1: i32 num1, 2: i32 num2), double divide(1: double num1, 2: double num2) } ``` 2. 生成代码：使用 Thrift 编译器将 .thrift 文件生成相应语言的代码。例如，我们可以使用以下命令生成 Java 和 Python 的代码： ``` thrift --gen java calculator.thrift thrift --gen py calculator.thrift ``` 这将生成相应语言的客户端和服务器端代码。 3. 实现服务器端：在服务器端，我们需要实现 Thrift 定义的接口。对于 Java，我们可以编写一个实现 CalculatorService 接口的类，并在该类中实现具体的业务逻辑。对于 Python，我们可以编写一个类似的实现。 4. 启动服务器：在服务器上启动 Thrift 服务器，以便接受客户端的请求。不同语言的服务器实现方式可能有所不同，但通常都需要提供一个监听指定端口的入口。 5. 实现客户端：在客户端，我们可以使用生成的客户端代码来调用服务器端的接口。对于 Java，我们可以创建一个 Thrift 客户端，并使用生成的代码来调用服务器端提供的方法。对于 Python，我们可以编写相应的客户端代码。 6. 运行客户端：运行客户端代码，通过网络连接到服务器，并发送请求调用服务器端的方法。 以上是一个简单的 Thrift 实战示例。请注意，具体的实现方式和步骤可能因语言和框架而异，但基本原理是相似的。Thrift 还支持更多高级特性，如异步调用、连接池等，可以根据具体需求进行扩展和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值