erlang的“缺点”

erlang的优点

1、并发简单

2、热更新

3、易于学习

为什么要学erlang？

erlang底层实现是C

所有简单来说，如果一个很精通C的程序员（20年+）肯定是比一个常规的erlang程序员写出的代码效率更高。

其实这个对于底层基于C的大部分语言（JAVA等）都是一个道理，

可是为什么要学erlang呢，因为成本，一个精通C的程序员培养的成本太大（这也是为什么JAVA程序员很多^_^）

什么时候用erlang解决问题？

erlang擅长的是大计算，小消息

简单的说，如果一个逻辑比较复杂的功能，而且结果是成本较低（相比逻辑实现来说），就可以用erlang

如果逻辑比较简单或者结果和逻辑差不多，就不适合了

下面我们举个例子来证明这种“缺点”

比如现在我要求一个整数里面所有的质数（只能被1和自己整除的数，假设1和2都是不是质数）

首先我们用C实现，为了方便比较我们用erlang nif调用C（理论只用C更快）

代码如下

#include <stdbool.h>  
#include <math.h>  
#include "erl_nif.h"  
  
static bool isPrime(int i)  
{  
        int j;  
        int t = sqrt(i) + 1;  
        for(j = 2; j <= t; ++j)  
        {  
                if(i % j == 0)  
                        return false;  
        }  
        return true;  
}  
  
static ERL_NIF_TERM findPrime(ErlNifEnv *env, int argc, ERL_NIF_TERM argv[])  
{  
        int n;  
        if(!enif_get_int(env, argv[0], &n))  
                return enif_make_badarg(env);  
        else  
        {  
                int i;  
                ERL_NIF_TERM res = enif_make_list(env, 0);  
                for(i = 2; i < n; ++i)  
                {  
                        if(isPrime(i))  
                                res = enif_make_list_cell(env, enif_make_int(env, i), res);  
                }  
                return res;  
        }  
}  
  
static ErlNifFunc nif_funcs[] = {  
        {"findPrime", 1, findPrime}  
};  

ERL_NIF_INIT(etest001, nif_funcs, NULL, NULL, NULL, NULL)

　　其中erlang的调用如下，C编译完成的叫etest001_nif.so

load() ->  
        erlang:load_nif("./etest001_nif", 0).  
  
findPrime(_N) ->  
        io:format("this function is not defined!~n").

　　我们来统计一下运行时间

11> timer:tc(etest001, findPrime, [100000]).
{8994,
 [99991,99989,99971,99961,99929,99923,99907,99901,99881,
  99877,99871,99859,99839,99833,99829,99823,99817,99809,99793,
  99787,99767,99761,99733,99721,99719,99713,99709|...]}

我们用erlang实现

myprime(N) ->
    myprime(N+1,3,[]).

myprime(N, N, L) ->
    L;
myprime(N, X, L) ->
    case isprime(X) of
        false ->
            myprime(N,X+1,L);
        true ->
            myprime(N,X+1,[X|L])
    end.

isprime(1) ->
    false;
isprime(2) ->
    false;
isprime(N) ->
    M = erlang:trunc(math:sqrt(N)) + 1,
    isprime(M,2,N).

isprime(M, M, _) ->
    true;
isprime(M, X, N) ->
    if  N rem X == 0 ->
            false;
        true ->
           isprime(M, X+1, N)
    end.

　　我们来统计一下运行时间

12> timer:tc(etest001, myprime, [100000]).  
{65929,
 [99991,99989,99971,99961,99929,99923,99907,99901,99881,
  99877,99871,99859,99839,99833,99829,99823,99817,99809,99793,
  99787,99767,99761,99733,99721,99719,99713,99709|...]}

好，现在可以看出erlang使用的时间差不多是使用nif（C语言）的8倍，而且随着这个数的增加，这个倍数应该是越来越大

有人可能会说，erlang擅长的是并发，你这个没有用并发阿，当然不快，好我们用并发，因为要用并发，而且结果要显示一个，所以肯定要用消息，

我们下面用并发的试试

代码如下

myprime2(N) ->
    Pid = self(),
    _ = [spawn(fun() -> isprime2(Pid, X) end) ||  X <- lists:seq(1,N)],
    myprime_work(N, []).

myprime_work(0, L) ->
    L;
myprime_work(N, L) ->
    receive
        false ->
            myprime_work(N-1, L);
        X ->
            myprime_work(N-1, [X|L])
    end.

isprime2(Pid, 1) ->
    Pid ! false;
isprime2(Pid, 2) ->
    Pid ! false;
isprime2(Pid, N) ->
    M = erlang:trunc(math:sqrt(N)) + 1,
    isprime2(Pid, M, 2, N).

isprime2(Pid, M, M, N) ->
    Pid ! N;
isprime2(Pid, M, X, N) ->
    if  N rem X == 0 ->
            Pid ! false;
        true ->
           isprime2(Pid,M, X+1, N)
    end.

　我们还是看看结果

13> timer:tc(etest001, myprime2, [100000]).
{456058,
 [99991,99989,99971,99961,99929,99923,99907,99901,99881,
  99877,99871,99859,99839,99833,99829,99823,99817,99809,99793,
  99787,99767,99761,99733,99721,99719,99713,99709|...]}

　

这个实现的居然比先前的还慢，是先前单进程的（erlang的）6倍左右，是nif（C语言）的48倍左右

8994 μs（nif，C） ，65929 μs（erlang，单进程），456058 μs（erlang，多进程）

主要原因消息的成本（消息比较多，一个进程一个消息，还有创建进程的成本）是比计算还高很多～～～

大家可以在自己的环境试试，erlang的程序也还能优化，可是结果应该不会有大的变化（因为相差太多）～～～