erlang 并发编程-并发01

迈不过友情╰ 2021-12-03 03:45 302阅读 0赞

### 并发编程 ###

erlang纯消息传递式语言

特点：

*  创建和销毁进程是非常快速的； 
 *  在进程间发送消息是非常快速的； 
 *  进程在所有操作系统上都具有相同的行为方式； 
 *  可以拥有大量进程； 
 *  进程不共享任何内存，是完全独立的； 
 *  进程唯一的交互方式就是消息传递。

创建新进程

%% 通过pid给次线程发消息，Mod模块，Func方法，Args传入参数
    Pid = spawn(Mod,Func,Args).

%% 新起一个并发进程执行Fun,Fun的属性是当前值
    Pid = spawn(Fun).

发送消息

Pid ! Message

接受消息

receive 
        Pattern1 [when Guard1] ->
            Expressions1;
        Pattern2 [when Guard2] ->
            Expressions2;
        ...
    end
    
    
    %% 例子
    loop() -> 
        receive     
            {rectangle,Width,Ht} ->
                io:format([Width * Ht]),
                loop();
            {square,Side} ->
                io:format{[Side * Side]},
                loop()
    end.

自己给自己发送消息，每次收到消息打印一次数据

-module(area_server1).
    -export([loop/0,rpc/2]).
    
    %% 发送消息，并监听返回值
    rpc(Pid,Request) ->
        Pid ! {self(),Request},
        recrive
            Response ->
                Response
        end.
    
    %% 开启指定数据的 消息监听
    loop() -> 
        receive
            {From, {Rectangle,Width,Ht}} ->
                From ! Width * Ht,
                loop();
            {From,{circle,R}} ->
                From ! 3.14159 * R * R,
                loop();
            {From,Other} ->
                From ! {error,Other},
                loop()
        end.

Pid = spawn(area_server1,loop,[]).
    
    area_server1:rpc(Pid,{rectangle,6.8}).
    
    area_server1:rpc(Pid,{circle,6}).
    
    area_server1:rpc(Pid,socks).

可以接收指定的Pid消息

rpc(Pid,Request) ->
        Pid ! {self(), Request},
        receive
            {Pid,Response} ->   %% 这里指定接受和  发送Pid一样的消息
                Response
        end.

上限：电脑会默认设置进程上限，不能无限的添加会消耗完电脑物理内存。

%% 查询当前电脑设置的进程上限
    erlang:system_info(process_limit).
    
    %% +p 添加进程上限，超出预定值
    erl +p 3000000

带超时时间的接收数据

延迟执行定时器

-module(stimer).
    -export([start/2,cancel/1]).
    
    start(Time,Fun) -> spawn(fun() -> timer(Time,Fun) end).
    cancel(Pid) -> Pid ! cancel.
    timer(Time,Fun) ->
        receive
            cancel -> 
                void
        after Time ->
                Fun()
        end.

周期性定时器

注册进程，erlang注册进程，之后使用进程名进行消息发送和接受

%% 注册，名称必须是原子。如果名称已存在则会注册失败
    register(AnAtom,Pid).
    
    %% 移除注册
    unregister(AnAtom).
    
    %% 查看该名称是否已被注册,成功返回Pid,失败返回undefined
    whereis(AnAtom).
    
    %% 查询所有注册信息
    registered().

例子：(使用直接使用注册的原子即可)

Pid = spawn(area_server,loop,[]).
    
    register(area,Pid).
    
    area ! {rectangle,4,5}.

### 并发程序的错误 ###

防御式编程

让进程崩溃，然后在其他进程里纠正错误。

优点：

*  不必思考应对措施，而是选择直接崩溃，别人会来修复这个错误。
 *  不会使错误恶化，因为无需在知道出错后进行额外的计算。
 *  如果在错误发生后第一时间举旗示意，就能得到非常好的错误诊断。在错误发生后继续运行经常会导致更多错误发生，让调试变得更加困难。
 *  编写错误恢复代码时不用担心崩溃的原因，只需要把注意力放在事后清理上。
 *  它简化了系统架构，这样我们就能把应用程序和错误恢复当成两个独立的问题来思考，而不是一个交叉的问题。

术语含义：

1.  进程（分普通进程和系统进程）：spawn创建的是普通进程，通过process\_flag(trap\_exit,true)变成系统进程。
2.  连接：2个进程连接后，一个崩溃了会告诉另一个崩溃原因。他们是相互的。收到崩溃消息也就是一个退出消息，所有连接的进程都会关闭（除非是系统进程）。
3.  连接组：多个进程在一个组内，一个崩溃，其他进程都会收到它的崩溃原因。
4.  监视：A进程监视B，B崩溃了A就会知道。（不能是A崩溃B知道）A收到的是宕机消息，A不会关闭本进程。
5.  消息和错误信号：正常通信是消息，崩溃前喊出的是错误信号
6.  错误信号：格式是｛‘EXIT’,Pid,Why｝收到这个新号的进程退出原因不是normal也会终止。可以通过代码终止（exit(Why).终止自己。exit(Pid,Why)终止别人，当前进程不停止 ）。系统进程收到（kill signal）会终止进程，是通过exit(Pid,kill)生成的。它不会告诉连接的其他进程 崩溃原因。

创建连接link()

P1 调用link(P2)  P1就会和P2建立一个连接(相互连接的进程一个崩溃了，连接的进程也会崩溃除非是系统进程（可以捕捉退出信号）。)

创建方式

%% 类似于spawn(Fun)和spawn(Mod,Func,Args)的创建方式
    
    %% 连接
    %% 创建进程的同时创建连接
    -spec spawn_link(Fun) -> Pid
    -spec spawn_link(Mod,Fnc,Args) ->Pid
    
    %% 创建一个与指定进程的连接
    -spec link(Pid) -> true
    %% 移除与当前线程绑定的指定连接
    -spec unlink(Pid) -> true
    
    %% 创建进程的同时创建监视
    -spec spawn_monitor(Fun) -> {Pid,Ref}
    -spec spawn_monitor(Mod,Fnc,Args) -> {Pid,Ref}
    
    %% 创建一个与当前进程连接的监视
    -spec erlang:monitor(process,ltem) -> Ref
    %% 移除一个与当前进程连接的监视
    -spec demonitor(Ref) -> true
    
    %% 当前进程转换成系统进程
    -spec process_flag(trap_exit,true)
    
    %% 停止当前进程，并广播崩溃原因
    -spec exit(Why) -> none()
    
    %% 停止指定进程，并广播关闭它的原因
    -sepc exot(Pid,Why) -> true

监听进程崩溃后的返回的错误消息

on_exit(Pid,Fun) ->
        spawn(fun() ->
               Ref = monitor(process,Pid),
               receive
                   {'DOWN',Ref,process,Pid,Why} ->
                   Fun(Why)
               end
            end).

## ##