最近写了一个简单的客户端，用来模拟服务化框架的客户端调用，功能如下:
- 随机调用服务
- 打印服务结果
- 10%的几率较少访问量(假设1个并发)，10%几率高访问量(假设100个并发)，80%几率正常访问量(假设10个并发)
- 打印各个访问量情况下的服务调用总时间
分别尝试了Java和Clojure实现，在实现过程中，两者的思路完全不同！
面向对象/面向过程语言思路
逻辑很简单，基本不涉及面向对象概念，主要还是面向过程语言的思路！
如果使用Java来实现，那么大致的思路是这样的:
- 首先需要一个随机数生成器，基于这个随机数生成器来构建随机调用逻辑
- 随机调用服务就是判断随机数大小，例如:0~1的随机数范围，大于0.5访问服务A,否则访问服务B
- 并发量判定则可以依据0~10的随机数范围，小于等于1时并发为1，大于等于9时并发为100，否则并发为10
- 在每个服务调用完成后，统计执行时间，然后汇总就可以了
下面是Java实现的代码:
public class RandomCall {
private static ExecutorService executorService = Executors.newFixedThreadPool(4);
public static void main(String[] args) throws Exception {
while (true) {
int rand = (int)(Math.random() * 10);
if (rand >= 9) {
call(100);
} else if (rand <= 1) {
call(1);
} else {
call(10);
}
Thread.sleep(1000L);
}
}
private static void call(int n) throws Exception {
final AtomicLong total = new AtomicLong(0);
final CountDownLatch latch = new CountDownLatch(n);
for (int i = 0; i < n; i++) {
executorService.execute(new Runnable() {
public void run() {
long start = System.currentTimeMillis();
if ((int)(Math.random() * 2) > 1) {
System.out.println(callServiceA());
} else {
System.out.println(callServiceB());
}
total.addAndGet(System.currentTimeMillis() - start);
latch.countDown();
}
});
}
latch.await();
System.out.println("Invoke " + n + ":" + total + " ms");
}
}
代码没什么好说的，对ExecutorService,Executors以及CountDownLatch不熟悉的请自行Google。
函数式语言思路
函数式语言的思路和上面的思路差异很大！
函数式语言通过提供大量的函数来操作少量的数据结构来完成逻辑。
所以其大致思路就是构建相应的数据结构，然后使用提供的操作函数来对其进行操作。
对于“随机调用服务”这个需求，我们可以把它看成是有一个序列，随机排列着需要调用的服务！
;定义一个包含了所调用服务的Vector
(def fns [call-serviceA call-serviceB])
;依据上面的Vector构建一个随机排列的服务序列
(def rand-infinite-fns (repeatedly #(get fns (->> fns count rand int))))
简单解释下最后一行代码:
;;->>是个宏，是为了方便代码阅读
(->> fns count rand int)
;;等价于
(int (rand (count fns)))
;;从最里面那个括号往外读：
;;1 获取fns这个Vector的长度
;;2 以这个长度为随机数范围(0,length)产生随机数
;;3 并取整
#(get fns ...)
;#(...)表示匿名函数，是个语法糖，等价于
(fn [] (get fns ...))
(get fns ...)
;就是依据上面的随机数，从fns这个Vector中获取元素
(repeatedly ...)
;就是字面意思，不停的重复，结果构建成一个LazySeq
;LazySeq就是在需要时才执行
理解了上面的代码，我们是不是可以以同样的逻辑，构建一个随机1、10、100的LazySeq来实现随机并发的逻辑呢？
(defn arr [1 10 100])
(def rand-infinite-arr (repeatedly #(get arr (->> arr count rand int))))
很简单吧？那么问题来了：
- 目前这个LazySeq是平均概率的分布着1、10、100，和需求不符合
- 第二行代码和前面的逻辑一模一样，是不是可以重构成函数
第一个问题有思路吗？可以先想想。
其实很简单
(def arr [1 10 10 10 10 10 10 10 10 100])
(def rand-infinite-arr (repeatedly #(get arr (->> arr count rand int))))
这样是不是就符合要求了？
再进一步对第二行代码重构为函数:
(defn rand-infinite [vec]
(repeatedly #(get vec (->> vec count rand int))))
(def fns [call-serviceA call-serviceB])
(def arr [1 10 10 10 10 10 10 10 10 100])
(def rand-infinite-fns (rand-infinite fns))
(def rand-infinite-arr (rand-infinite arr))
- rand-infinite-fns中是随机调用的函数
- rand-infinite-arr中是随机的并发数
现在我们只要从rand-infinite-arr中依次取出元素，然后根据元素的值来构建相同数量的线程来进行调用就可以了！由于是无限序列，所以间接实现了死循环！
举个例子:
;;假设现在rand-infinite-fns中元素如下
[call-serviceA call-serviceA call-serviceB call-serviceA ...]
;;rand-infinite-arr中元素如下
[10 1 10 100 10 10 1 ...]
;;rand-infinite-arr的第一个元素是10,
;;则从rand-infinite-fns中取10个元素，构建10个线程去调用
;;rand-infinite-arr的第二个元素是1,
;;则从rand-infinite-fns的第11个函数开始，去一个函数去调用
;;以此类推
第一印象是递归,Clojure代码实现如下:
(loop [rand-fns (rand-infinite fns)
nums (rand-infinite arr)]
...
(recur (drop (first nums) rand-fns)
(drop 1 nums)))
最后就是构建线程进行函数调用
(time (println (pmap #(%) (take (first nums) rand-fns)))
;;pmap就是将#(% obj)这个函数依次应用到后面的序列上，并且是并发的
;;time函数打印出执行所需要的时间
;;(take (first nums) rand-fns)就是依据nums元素的大小，获取相应数量的rand-fns的元素
;;rand-fns中的元素是函数，直接放在括号里的第一个元素就可以执行了，这里是替换了那个%
实际上可以更进一步，上面的流程，相当于遍历下面这个链表:
[[call-serviceA] [call-serviceA call-serviceB ...] [call-serviceB] [call-serviceB call-serviceA ...] ...]
所以只需要构建类似上面的链表结构就可以了，Clojure里很简单:
(let [rand-fns (rand-infinite fns)
rand-arr (rand-infinite arr)
group-rand-fns (map #(take % rand-fns) rand-arr)]
...))
;;group-rand-fns就是我们需要的链表结构
最后只要遍历这个链表就可以了:
(defn invoke [fns]
(Thread/sleep 1000)
(time (println (pmap #(%) fns))))
(defn -main [& args]
(let [rand-fns (rand-infinite fns)
rand-arr (rand-infinite arr)
group-rand-fns (map #(take % rand-fns) rand-arr)]
(doall (map invoke group-rand-fns))))
;;doall表示立即执行，因为map出来的链表是lazySeq,这里的map相当于外层循环，对每个内部链表应用invoke函数
;;invoke内部是内层循环，每隔1秒就并发调用链表中的函数
完整代码如下:
(defn rand-infinite [vec]
(repeatedly #(get vec (->> vec count rand int))))
(def fns [call-serviceA call-serviceB])
(def arr [1 10 10 10 10 10 10 10 10 100])
(defn invoke [fns]
(Thread/sleep 1000)
(time (println (pmap #(%) fns))))
(defn -main [& args]
(let [rand-fns (rand-infinite fns)
rand-arr (rand-infinite arr)
group-rand-fns (map #(take % rand-fns) rand-arr)]
(doall (map invoke group-rand-fns))))
Java8实现
Java8提供了lambda表达式等功能，支持函数式编程，下面使用Java8实现，直接贴代码：
public class RandomCall {
public static void main(String[] args) throws Exception {
Function<Supplier<String>,Long> func = sup -> {
long start = System.currentTimeMillis();
sup.get();
return System.currentTimeMillis() - start;
};
Supplier<String> serviceASup = () -> callServiceA();
Supplier<String> serviceBSup = () -> callServiceB();
List<Supplier<String>> fns = Arrays.asList(serviceASup,serviceBSup);
List<Integer> arr = Arrays.asList(1,10,10,10,10,10,10,10,10,100);
Stream.generate(() -> (int) (Math.random() * 10)).map(arr::get)
.forEach(n -> {
Thread.sleep(1000L);
System.out.println(Stream.generate(() -> (int) (Math.random() * 2)).map(fns::get).limit(n)
.parallel().mapToLong(func::apply).sum());
});
}
}
总结
- 最终代码，Clojure明显少于Java、略少于Java8。在代码表现力上Clojure > Java8 > Java
- 函数式思路和过程式思路差异很大
- 在编写Clojure代码时，明显是偏脑力的劳动。而在编写Java的时候，明显是偏体力的劳动
- 编写Clojure代码，如果不多思考，则写出来的代码将比Java要难读得多
- Java8代码比Clojure代码可读性上感觉更差(可能自己对Java8的函数式思路还不太了解)
