通过gpfdist unload 与load java 代码设计和实现

最新推荐文章于 2023-09-19 09:40:26 发布
最新推荐文章于 2023-09-19 09:40:26 发布
阅读量781 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happyzxs/article/details/78733648
版权

原理 通过外部表将数据文件写入客户端所在的服务器（中转）再通过外部表引入文件到目标库。每次操作一张或多张表
设计思想：java 的面向对象思想
1将 gpfdist 看成一个对象 创建Gpfdist 类，因其作用有2个 就是启动和停止
即shell执行的两条命令
2每个gpfdist 进程的参数是不一样的 所以再创建一个GpfdistBean 用于存储每个gpfdist 实例的参数，通过GpfdistBean 的实例创建不同的启动和关闭命令
3创建可写外部表然后将数据存入外部文件是一个对象，所以定义WritAbleExternalTable类有两个方法 创建外部表和写数据
4每次写的外部表的具体参数不一样 所以创建WritAbleExternalTableBean 类用来存储每次WritAbleExternalTable实例的参数
5可读外部表同可写外部表
6创建一个线程调用1-5实现数据卸载和装在的过程
具体实现

GpfdistBean 

public class GpfdistBean {
    private String clientFilePath;//gpfdist 安装位置
    private String startPort;//起始端口号
    private String endPort;//终止端口号
    private String logFilePath;//日志文件路径
    private String pid;//gpfdist 进程pid
    public String getClientFilePath() {
        return clientFilePath;
    }
    public void setClientFilePath(String clientFilePath) {
        this.clientFilePath = clientFilePath;
    }
    public String getStartPort() {
        return startPort;
    }
    public void setStartPort(String startPort) {
        this.startPort = startPort;
    }
    public String getEndPort() {
        return endPort;
    }
    public void setEndPort(String endPort) {
        this.endPort = endPort;
    }
    public String getLogFilePath() {
        return logFilePath;
    }
    public void setLogFilePath(String logFilePath) {
        this.logFilePath = logFilePath;
    }
    public String getPid() {
        return pid;
    }
    public void setPid(String pid) {
        this.pid = pid;
    }

}

Gpfdist 

public class Gpfdist {

    //Starting gpfdist
    public String getGpfdistStartingCommand(GpfdistBean gpfdistBean) {
        String clientFilePath =gpfdistBean.getClientFilePath() ;//gpfdist 安装位置
        String startPort = gpfdistBean.getStartPort();//起始端口号
        String endPort =gpfdistBean.getEndPort();//终止端口号
        String logFilePath = gpfdistBean.getLogFilePath();//日志文件路径
        StringBuilder  command =new StringBuilder("gpfdist -d");
        command.append(clientFilePath);
        command.append(" -p ");
        command.append(startPort);
        command.append(" -P ");
        command.append(endPort);
        if(null==logFilePath?false:true) {
            command.append(" -l ");
            command.append(logFilePath);
        }
        return command.toString();
    }

    //Stopping gpfdist
    public String getGpfdistStoppingCommand(GpfdistBean gpfdistBean) {
        StringBuilder  command =new StringBuilder("kill -9 ");
        String pid = gpfdistBean.getPid();
        command.append(pid);
        return command.toString();
    }
}

WritableExternalTableBean 

public class WritableExternalTableBean {
    private String tableName;//原表名称
    private String externalTableName;//外部表名称
    private String protocol;//通讯协议
    private String etlhost;//etl  ip
    private String etlPort;//etl  端口
    private String expenses;//数据文件绝对路径
    private String fileFormat;//数据文件格式
    private String delimiter;//数据文件字段分割符
    private String distributed;//数据分发原则
    public String getEtlhost() {
        return etlhost;
    }
    public void setEtlhost(String etlhost) {
        this.etlhost = etlhost;
    }
    public String getEtlPort() {
        return etlPort;
    }
    public void setEtlPort(String etlPort) {
        this.etlPort = etlPort;
    }
    public String getExpenses() {
        return expenses;
    }
    public void setExpenses(String expenses) {
        this.expenses = expenses;
    }

    public String getTableName() {
        return tableName;
    }
    public void setTableName(String tableName) {
        this.tableName = tableName;
    }
    public String getExternalTableName() {
        return externalTableName;
    }
    public void setExternalTableName(String externalTableName) {
        this.externalTableName = externalTableName;
    }
    public String getProtocol() {
        return protocol;
    }
    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }
    public String getFileFormat() {
        return fileFormat;
    }
    public void setFileFormat(String fileFormat) {
        this.fileFormat = fileFormat;
    }
    public String getDelimiter() {
        return delimiter;
    }
    public void setDelimiter(String delimiter) {
        this.delimiter = delimiter;
    }
    public String getDistributed() {
        return distributed;
    }
    public void setDistributed(String distributed) {
        this.distributed = distributed;
    }

}

WritableExternalTable 

/**
 * regular table--external table --external file 
 * @author 26110
 *
 */
public class WritableExternalTable {


    //create WritableExternalTable

    //1 Defining a Command-Based Writable External Web Table 废弃


    //2 Defining a File-Based Writable External Table 
    /**
     * file relation table
     * @return
     */
    public String getCreateWriteExtTableSql(WritableExternalTableBean writeTable) {
        StringBuilder sql = null;
        String tableName =writeTable.getTableName();//原表名称
        String externalTableName =writeTable.getExternalTableName();//外部表名称
        String protocol =writeTable.getProtocol();//通讯协议
        String etlhost =writeTable.getEtlhost();//etl  ip
        String etlPort =writeTable.getEtlPort();//etl  端口
        String expenses =writeTable.getExpenses();//数据文件绝对路径
        String fileFormat =writeTable.getFileFormat();//数据文件格式
        String delimiter =writeTable.getDelimiter();//数据文件字段分割符
        String distributed =writeTable.getDistributed();//数据分发原则
        sql=new StringBuilder("CREATE WRITABLE EXTERNAL TABLE  ");
        sql.append(externalTableName);
        sql.append(" ( LIKE ");
        sql.append(tableName);
        sql.append(" ) LOCATION (");
        sql.append("'");
        sql.append(protocol);
        sql.append("://");
        sql.append(etlhost);
        sql.append(":");
        sql.append(etlPort);
        sql.append("/");
        sql.append(expenses);
        sql.append("')");
        sql.append(" FORMAT '");
        sql.append(fileFormat);
        sql.append("' (DELIMITER '");
        sql.append(delimiter);
        sql.append("')");
        if(distributed==null?false:true) {
            sql.append(" DISTRIBUTED BY (");
            sql.append(distributed);
            sql.append(")");
        }
        return sql.toString();
    }

    //3 Unloading Data Using a Writable External Table 
    /**
     * pass writable external table write data to file
     * @return
     */
    public String getUnloadingSql(WritableExternalTableBean writeTable) {
        String external = writeTable.getExternalTableName();
        String tableName = writeTable.getTableName();
        String sql = null;
        sql="INSERT INTO writable_ext_table SELECT * FROM regular_table";
        sql.replace("writable_ext_table", external);
        sql.replace("regular_table", tableName);
        return sql;
    }

    //4 Unloading Data Using COPY 废弃

}

ReadableExternalTableBean 

public class ReadableExternalTableBean {

    private String tableName;//原表名称
    private String externalTableName;//外部表名称
    private String protocol;//通讯协议
    private String etlhost;//etl  ip
    private String etlPort;//etl  端口
    private String expenses;//数据文件绝对路径
    private String fileFormat;//数据文件格式
    private String delimiter;//数据文件字段分割符
    private String distributed;//数据分发原则
    private String[] columnAndType;//字段名和字段类型
    public String getEtlhost() {
        return etlhost;
    }
    public void setEtlhost(String etlhost) {
        this.etlhost = etlhost;
    }
    public String getEtlPort() {
        return etlPort;
    }
    public void setEtlPort(String etlPort) {
        this.etlPort = etlPort;
    }
    public String getExpenses() {
        return expenses;
    }
    public void setExpenses(String expenses) {
        this.expenses = expenses;
    }

    public String getTableName() {
        return tableName;
    }
    public void setTableName(String tableName) {
        this.tableName = tableName;
    }
    public String getExternalTableName() {
        return externalTableName;
    }
    public void setExternalTableName(String externalTableName) {
        this.externalTableName = externalTableName;
    }
    public String getProtocol() {
        return protocol;
    }
    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }
    public String getFileFormat() {
        return fileFormat;
    }
    public void setFileFormat(String fileFormat) {
        this.fileFormat = fileFormat;
    }
    public String getDelimiter() {
        return delimiter;
    }
    public void setDelimiter(String delimiter) {
        this.delimiter = delimiter;
    }
    public String getDistributed() {
        return distributed;
    }
    public void setDistributed(String distributed) {
        this.distributed = distributed;
    }
    public String[] getColumnAndType() {
        return columnAndType;
    }
    public void setColumnAndType(String[] columnAndType) {
        this.columnAndType = columnAndType;
    }



}

ReadableExternalTable 


/**
 * external file --external table --regular table
 * @author 26110
 *
 */
public class ReadableExternalTable {

    /*
     * 
     CREATE EXTERNAL TABLE load_zxs_test2 (
    e_id INTEGER,
    e_name CHARACTER VARYING(30),
    e_date DATE,
    e_address CHARACTER VARYING(100),
    e_tel CHARACTER VARYING(11),
    e_id_1 INTEGER,
    e_name_1 CHARACTER VARYING(30),
    e_date_1 DATE,
    e_address_1 CHARACTER VARYING(100),
    e_tel_1 CHARACTER VARYING(11)
    )  
     LOCATION ('gpfdist://192.168.12.94:8899/zxs_test2.txt')   FORMAT 'TEXT' ( DELIMITER '|' NULL ' ')  

      LOG ERRORS SEGMENT REJECT LIMIT 5;


    INSERT INTO zxs_test0 SELECT * FROM load_zxs_test2

     */
    /**
     * pass Readable external file table write data to database
     * @return
     */

    public String getCreateReadExtTableSql(ReadableExternalTableBean readTable) {
        StringBuilder sql = null;
        String externalTableName =readTable.getExternalTableName();//外部表名称
        String protocol =readTable.getProtocol();//通讯协议
        String etlhost =readTable.getEtlhost();//etl  ip
        String etlPort =readTable.getEtlPort();//etl  端口
        String expenses =readTable.getExpenses();//数据文件绝对路径
        String fileFormat =readTable.getFileFormat();//数据文件格式
        String delimiter =readTable.getDelimiter();//数据文件字段分割符
        String[] columnAndType = readTable.getColumnAndType();//字段名和字段类型
        sql=new StringBuilder("CREATE  EXTERNAL TABLE  ");
        sql.append(externalTableName);
        sql.append(" (  ");
        sql.append(columnAndType.toString());
        sql.append(" ) LOCATION (");
        sql.append("'");
        sql.append(protocol);
        sql.append("://");
        sql.append(etlhost);
        sql.append(":");
        sql.append(etlPort);
        sql.append("/");
        sql.append(expenses);
        sql.append("')");
        sql.append(" FORMAT '");
        sql.append(fileFormat);
        sql.append("' (DELIMITER '");
        sql.append(delimiter);
        sql.append("')");
        sql.append("  LOG ERRORS SEGMENT REJECT LIMIT 5;");
        return sql.toString();
    }
    //3 loading Data Using a Readable External Table 
        /**
         * pass Readable external file relation date to external table 
         * @return
         */
        public String getLoadingSql(ReadableExternalTableBean readTable) {
            String external = readTable.getExternalTableName();
            String tableName =readTable.getTableName();
            String sql = null;
            sql="INSERT INTO regular_table SELECT * FROM readable_ext_table ";
            sql.replace("readable_ext_table", external);
            sql.replace("regular_table", tableName);
            return sql;
        }
}

UnloadAndLoadThread 


import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * one table one thread
 * contains unload and mask and load step
 * @author 26110
 *
 */
public class UnloadAndLoadThread implements Runnable {
    private WritableExternalTableBean wb;
    private ReadableExternalTableBean rb;
    private GpfdistBean gpfdistBean;

    public UnloadAndLoadThread(WritableExternalTableBean wb, ReadableExternalTableBean rb, GpfdistBean gpfdistBean) {
        this.wb = wb;
        this.rb = rb;
        this.gpfdistBean = gpfdistBean;
    }

    @Override
    public void run() {
        // 一 unload
        // 1 run gpfdist
        Gpfdist unloadGpfdist = new Gpfdist();
        String unloadCommand = unloadGpfdist.getGpfdistStartingCommand(this.gpfdistBean);
        Runtime unloadRunTime = Runtime.getRuntime();
        try {
            unloadRunTime.exec(unloadCommand);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        WritableExternalTable wet = new WritableExternalTable();
        // 2 get writable external table sql
        String createWriteExtTabsql = wet.getCreateWriteExtTableSql(wb);
        // 3 get write data to file sql
        String insert2WriteFileSql = wet.getUnloadingSql(wb);
        // 4 make connection and execute sql
        String unloadurl = "";
        String unloaduser = "";
        String unloadpassword = "";
        Connection unloadConn = null;
        try {
            unloadConn = GreenplumConnection.getConnection(unloadurl, unloaduser, unloadpassword);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Statement unloadst = null;
        try {
            unloadst = unloadConn.createStatement();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            unloadst.execute(createWriteExtTabsql);
            unloadst.execute(insert2WriteFileSql);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 5 释放资源，关闭连接，关闭gpfdist
        try {
            unloadst.close();
            GreenplumConnection.closeConnection(unloadConn);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        unloadGpfdist.getGpfdistStoppingCommand(this.gpfdistBean);

        // 三 load
        // 1 run gpfdist
        Gpfdist loadGpfdist = new Gpfdist();
        String loadCommand = loadGpfdist.getGpfdistStartingCommand(this.gpfdistBean);
        Runtime loadRunTime = Runtime.getRuntime();
        try {
            loadRunTime.exec(loadCommand);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        ReadableExternalTable ret = new ReadableExternalTable();
        // 2 get readable external table sql
        String createReadExtTabsql = ret.getCreateReadExtTableSql(rb);
        // 3 get write file to database sql
        String insert2DatabaseSql = ret.getLoadingSql(rb);
        // 4 make connection and execute sql
        String loadurl = "";
        String loaduser = "";
        String loadpassword = "";
        Connection loadconn = null;
        try {
            loadconn = GreenplumConnection.getConnection(loadurl, loaduser, loadpassword);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Statement loadst = null;
        try {
            loadst = loadconn.createStatement();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            loadst.execute(createReadExtTabsql);
            loadst.execute(insert2DatabaseSql);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 5 释放资源，关闭连接，关闭gpfdist
        try {
            loadst.close();
            GreenplumConnection.closeConnection(loadconn);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        loadGpfdist.getGpfdistStoppingCommand(this.gpfdistBean);
    }

}

GreenplumConnection 


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class GreenplumConnection {
    public static Connection getConnection(String url,String user,String password) throws SQLException {
        Connection conn = null;
        DriverManager.getConnection(url, user, password);
        return conn;
    }
    public static void closeConnection(Connection conn) throws SQLException {
        conn.close();
    }
}
happyzxs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
GPLOAD-Java-Wrapper
06-18
GPLOAD-Java-Wrapper 用于运行 GPload 以将数据批量加载到 HAWQ 和 Greenplum 的 Java 包装类 args = --input=resources/inputfile.csv --table=demo300.SXDTable --url=myclusterip:8080/dbname --user=gpadmin --delimiter=,\n" + 可选参数 --truncate {true|false} (truncates destination table before loading) --reuse {true|false} (reuse existing external tables if they exists, minimized catalo
gpfdist
06-16 1811
Greenplum数据加载方式（1） – insert 和 copy 1,844total views, 1views today greenplum数据加载主要包括insert、copy、外部表、gpload、web external table等五种方式。 其中insert和copy是串行；外部表gpfdist和gpload工具是并行方式。 1、insert 这种加载方式和其他数据库SQL语法一样，但是效率最差，只适合加载极少数数据。需要通过master节点操作。 <1>直接...
greenplum gpfdist 命令使用
知识的力量
05-17 2802
目录 12.4 gpfdist 命令使用 12.4.1 查看原始表的信息 12.4.2 开启gpfdist服务 12.4.3 把数据库的表下载到磁盘 12.4 gpfdist 命令使用 12.4.1 查看原始表的信息 查看表的行数 select count(*) from ods.test1; -- 182683056 查看表的大小 select pg_size_pre...
greenplum--gpfdist
weixin_37044203的博客
03-12 1090
文章目录命令格式实例 gpfdist是Greenplum中并行文件分发程序。使用它创建可读外部表时，来自gp的数据段都是并行的。 命令格式 gpfdist [-d <directory>] [-p <http_port>] [-l <log_file>] [-t <timeout>] [-S] [-w <time>] [-v | -V]...
gpfdist服务安装
刀锋
11-16 1698
gpfdist简介 gpfdist是Greenplum数据库并行文件分发程序。可读外部表和gpload使用它为所有Greenplum数据库的segment并行地提供外部表文件。 可写外部表使用它并行地接受来自Greenplum数据库的segement的输出流，并将它们写到文件中。使用gpfdist的好处是，在读写外部表时，可以保证最大的并行性，从而提供最佳的性能以及更容易管理外部表。更多官方原文描述请进入gpfdist。 gpfdist涉及软件下载 要使用gpfdist服务，需要安装greenplum
JAVA各种OOM代码示例与解决方法
08-18
本文主要介绍了关于JAVA各种OOM代码示例与解决方法的相关资料，通过示例代码以及图文介绍的非常详细，对大家学习或者使用java具有一定的参考学习价值。 JAVA堆溢出（java.lang.OutOfMemoryError: Java heap space）...
教育应用程序接口设计及代码编写.ppt
11-23
教育应用程序的API设计与代码编写要求开发者具备良好的用户体验设计能力，熟悉编程语言和框架，了解数据结构和算法，以及掌握网络通信协议等基础知识。通过本次讲座，开发者将学习到如何构建高效、易用的教育应用。
教育应用程序接口设计及代码编写.pptx
11-12
教育应用程序接口设计及代码编写涉及到的是构建教育软件的核心技术，主要包括用户界面设计和程序逻辑实现。在设计教育应用时，良好的用户界面和高效的操作流程是提升用户体验的关键。 一、简单的计算器应用程序任务...
多模块程序设计与调试优质文档.ppt
11-13
窗体模块包含界面和相关代码，标准模块用于存储共享代码和全局变量，类模块则用于创建自定义对象。 7. **程序的中止**：在多模块程序中，程序的执行流程可能会涉及到多个模块的交互。当所有需要执行的过程结束，...
学生档案管理系统的设计与实现.pdf
02-27
代码实现上，例如在菜单的Click事件中，系统通过Load和Unload方法动态加载或卸载窗体，实现了在不同功能模块之间的切换。同时，每个功能模块如“成绩维护”窗体（Frmcjwh）的点击事件，会关闭其他窗体，确保每次只有...
java system.load分析_Java System类load()方法及示例
weixin_30005929的博客
02-13 2092
系统类load()方法load()方法在java.lang包中可用。load()方法用于从本地文件系统中加载名为fn(filename)的给定参数的Java文件。load()方法是静态方法，也可以使用类名进行访问。load()方法在文件加载时可能会引发异常：SecurityException：在这种情况下，checkLink()当安全管理器存在时，其方法不允许加载在方法中传递的指定文件。Unsat...
greenplum gpfdist工具
Serendipity_Shy
04-07 1965
gpfdist 是 Greenplum 数据库并行文件分发程序。它可以被外部表和 gpload 用来并行地将外部表文件分发给 Greenplum 数据库 Segment节点<greenplum架构介绍它也可以被可写外部表使用，将Segment节点上的数据写入目标文件中。gpfdist 可以看成是一个http服务，因其是单进程模式，所以为实现服务端的并行，需要启动多个 gpfdist 服务。
Greenplum外部表数据加载——gpfdist
Focus on PostgreSQL
04-22 3207
Greenplum在数据加载方面有一个明显的优势，就是支持数据的并发加载，gpfdist就是并发加载的工具，在数据库中对应的就是外部表。 外部表就是指表的数据存放在数据库之外的数据文件中。外部表是直接在segment上导入数据，相比与其它的ETL工具，因为需要经过GP的单点master(效率较低)，这种方式速度会很快。 创建外部表语法： CREATE EXTERNAL TABLE Defines...
Greenplum实用工具-gpfdist
最新发布
数据源的港湾
09-19 632
注：本文翻译自向Greenplum数据库段提供数据文件或从数据库段写入数据文件。
GreenPlum--gpfdist,gpfdists,file和gphdfs
唐僧洗头爱飘柔
04-22 1124
三种用来访问外部表数据源的协议：gpfdist，gpfdists和gphdfs gpfdist 在外部表指定文件的所有主机上运行GP文件分发程序（gpfdist）。 该程序指向一个给定的目录，并行的为所有segment实例提供外部数据文件服务。 如果文件使用了gzip或者bzip2压缩，gpfdist会自动解压 可以使用多个gpfdist来提升外部表的扫描性能 可以使用通配符或者C风格的模式匹配多...
GreenPlum导入导出数据(二)gpfdist
qq_36135235的博客
03-19 2277
1.在linux下启动gpfdist服务 gpfdist是Greenplum自带的工具,无需安装其他依赖或服务 $ gpfdist -d /u01 -p 5555 -l /tmp/gpfdist.log & 参数解释： -d 数据文件所放的目录 -p 设置访问gpfdist端口，这个可以根据实际情况写。 -l 设置日志文件所放的目录，这个参数也可以不用填写。 & 必...
GreenPlum 集群 gpfdist 实战
热门推荐
csdn's blog
08-01 1万+
并行文件服务gpfdist组件模块，能够实现最大并行度、加载带宽，默认greenplum集群已经有了已经安装了gpfdist，但是如果在单独的服务器上，还是需要再次安装的单独的组件，需要下载一个loaders的组件安装包进行安装。 1，下载 下载地址：https://network.pivotal.io/products/pivotal-gpdb#/releases/4540...
gpfdist性能优化介绍
MyySophia的博客
12-09 1408
gpfdist外部表，是Greenplum数据库最重要的数据批量加载技术，有着极高的性能。 先讲个故事，我们经历过很多的POC测试，虽然gpfdist外部表的加载性能一直领先友商，但是，在文件服务器带宽有限的情况下，我们往往很难取得碾压性的优势，尤其是文件服务器只有一根光纤的时候，测试的结果，往往是大家的性能几乎相同，所以，我在很长一段时间，都在考虑，如何可以突破性能的上限，大概一年前，我就跟我们的技术大牛同事聊这些思考，得到了一个大牛的共鸣，后来我就做了他的产品经理，他开始着手写一个可以在一定程度上代替
gpfdist不落盘导入数据
weixin_42788640的博客
01-25 376
Linux中一切皆可以看作是文件，通过把gpfdist外部表中的文件替换成管道，可以实现不落盘导入数据。 创建管道 通过mkfifo命令创建命名管道，作为写入和读取的文件，下图示例中第一个字符p表示该文件是管道文件。 开启gpfdist服务 建立外部表 外部表中需要指定文件的location，把location中的文件写成刚才创建的管道。 开启生产者与消费者线程 往该管道中写数据可以看作是生产者、数据库中读取数据可以看作是消费者。在实际代码实现中可以考虑使用双线程/进程来实现，二者在对方线程未触发前会
教育应用API设计与代码实现
教育应用程序接口设计及代码编写是构建教育类软件的重要环节，涉及到如何将不同组件、服务或系统有效地连接在一起，以实现功能丰富的教育应用。本资源主要讲解了从简单计算器应用程序的设计到更复杂的可视化界面和多...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值