基础知识储备已达到一定阶段，所以开始投入生产研发，所以就对fabric进行了性能压测；

　　项目使用的是fabric-sdk-java，所以这里的压测也只java版本的结果；

　　部署情况：

　10.0.200.111机器：
　　    |-orderer1.lychee.com
　　    |-ca0.org1.lychee.com
　　10.0.200.113机器：
　　    |-orderer2.lychee.com
　　    |-peer0.org1.lychee.com
　　    |-z1   (zookeeper)
　　    |-k1   (kafka)
　　    |-couchdb0.org1.lychee.com
　　10.0.200.114机器：
　　    |-orderer3.lychee.com
　　    |-peer1.org1.lychee.com
　　    |-z2
　　    |-k2
　　    |-couchdb1.org1.lychee.com
　　10.0.200.115机器：
　　    |-peer0.org2.lychee.com
　　    |-z3
　　    |-k3
　　    |-couchdb0.org2.lychee.com
　　10.0.200.116机器：
　　    |-peer1.org2.lychee.com
　　    |-k4
　　    |-ca0.org2.lychee.com
　　    |-couchdb1.org2.lychee.com
   
　　机器配置如下：
　　2核4G内存200G硬盘
　　sdk虚拟处的channel只加入了2个peer，具体结果如下：
　　1、网络搭建过程，即channel创建过程
　　      10s左右
　　2、查询耗时
　　      同步使用10个线程，每个线程进行10个查询，总耗时在2s左右
　　      平均每个查询耗时在60～400毫秒之间
　　3、invoke相关，本案例测试的智能合约包含了getstate和putstate操作
　　      同步使用10个线程，每个线程进行10个查询，总耗时在6s左右
　　      平均每个查询耗时在60～400毫秒之间
   
　　总结：
　　1、client使用单例模式
　　2、查询接口在50TPS
　　3、数据处理接口在16TPS
   
　　附java性能测试类：
　　package com.lychee.fabric.sdk.demo;
　　import java.util.concurrent.CountDownLatch;
　　public class TestHarness {
　　       public static void main(String[] args) throws InterruptedException {  
　　            TestHarness testHarness = new TestHarness();  
　　            long timeTasks = testHarness.timeTasks(10, new Runnable() {  
　　                @Override  
　　                public void run() {  
　　                    try {  
　　                        Thread.sleep(1000);  
　　                    } catch (InterruptedException e) {  
　　                        e.printStackTrace();  
　　                    }  
　　                }  
　　            });  
　　            System.out.println(timeTasks);  
　　        }  
　　        public long timeTasks(int nThreads, final Runnable task) throws InterruptedException {  
　　//          //预热，编译  
　　//          for (int i = 0; i < 10000; i++) {  
　　//              task.run();  
　　//          }          
　　            // 真正的测试  
　　            // 使用同步工具类，保证多个线程同时（近似同时）执行
　　            final CountDownLatch startGate = new CountDownLatch(1);  
　　            // 使用同步工具类，用于等待所有线程都运行结束时，再统计耗时
　　            final CountDownLatch endGate = new CountDownLatch(nThreads);  
　　            for (int i = 0; i < nThreads; i++) {  
　　                final int j = i;
　　                Thread t = new Thread() {  
　　                    @Override  
　　                    public void run() {  
　　                        try {  
　　                            startGate.await();  
　　                            try {  
　　                                
　　                                task.run();  
　　                            } finally {  
　　                                endGate.countDown();  
　　                            }  
　　                        } catch (InterruptedException e) {  
　　                            e.printStackTrace();  
　　                        }  
　　                    }  
　　                };  
　　                t.start();  
　　            }  
　　            long start = System.currentTimeMillis();  
　　            startGate.countDown();  
　　            endGate.await();  
　　            long end = System.currentTimeMillis();  
　　            return end - start;  
　　        } 
　　}

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标常用软件之Maya频道！