《Erlang 程序设计》练习答案 -- 第十三章 并发程序中的错误

最新推荐文章于 2023-03-13 12:08:31 发布
最新推荐文章于 2023-03-13 12:08:31 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： Erlang 文章标签： erlang 并发 设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwh578867817/article/details/49897785
版权 
% (1).编写一个 my_spawn(Mod, Func, Args) 函数。它的行为类似 spawn(Mod, Func, Args)，
% 但有一点区别。如果分裂出的进程挂了，就应打印出一个消息，说明进程挂掉的原因以及
% 在此之前存货了多长时间。

-module(myspawn).
-export([my_spawn/3]).

-spec my_spawn(Mod, Func, Args) -> pid() when
    Mod  :: atom(),
    Func :: atom(),
    Args :: [T],
    T    :: term().


my_spawn(Mod, Func, Args) ->
    {Hour1, Minute1, Second1} = time(),
    Pid = spawn(Mod, Func, Args),
    spawn(fun() ->
            Ref = monitor(process, Pid),
            receive 
                {'DOWN', Ref, process, Pid, Why} ->
                    {Hour2, Minute2, Second2} = time(),
                    io:format("error:~p, time:~pS~n", [Why, (Hour2-Hour1)*60*60+(Minute2-Minute1)*60+(Second2-Second1)])
            end
    end),
    Pid.
% (2).用本章前面展示的 on_exit 函数来完成上一个练习。

-module(myspawn).
-export([my_spawn/3]).

my_spawn(Mod, Func, Args) ->
    {Hour1, Minute1, Second1} = time(),
    on_exit(spawn(Mod, Func, Args), fun() -> io:format("error......~n") end),
    {Hour2, Minute2, Second2} = time(),
    io:format("time:~p~n", [(Hour2-Hour1)*60*60 + (Minute2-Minute1)*60 + (Second2-Second1)]).


on_exit(Pid, Fun) ->
    spawn(fun() -> 
          Ref = monitor(process, Pid),
          receive
              {'DOWN', Ref, process, Pid, Why} ->
                  Fun(Why)
          end  
    end).
% (3).编写一个 my_spawn(Mod, Func, Args, Time) 函数。它的行为类似spawn(Mod, Func, Args)，
% 但有一点区别。如果分裂出的进程存活超过了Time秒，就应当被摧毁。

-module(myspawn).
-export([my_spawn/4, start/0, func/1]).

% 类型声明
-spec my_spawn(Mod, Func, Args, Time) -> pid() when
      Mod   :: atom(),
      Func  :: atom(),
      Args  :: [T],
      T     :: term(),
      Time  :: term().

% 启动函数
start() ->
    my_spawn(myspawn, func, [], 5000).

% 创建一个进程和一个监视进程
my_spawn(Mod, Fun, Args, Time) ->
    Pid = spawn(Mod, Fun, [Time]),
    io:format("Pid:~p~n", [Pid]),
    spawn(fun() -> 
            Ref = monitor(process, Pid),
            receive 
                {'DOWN', Ref, process, Pid, Why} ->
                    io:format("Pid:~p process quit~n", Pid),
                    io:format("Why Quit:~p~n", [Why])
            end  
        end),
    Pid.

% 创建的进程执行函数，当超时Time后，退出并发送一个退出信号给监视进程，监视进程接受后打印该进程的 Pid 和退出的原因 Why。
func(Time) ->
    io:format("Time:~p~n", [Time]),
    receive 
        {ok, Message} ->
            io:format("Message:~p~n", Message)
    after Time ->
            exit("timeout")
    end.

5秒后打印 =ERROR REPORT===

% (4).编写一个函数，让它创建一个每隔5秒就打印一次“我还在运行”的注册进程。
% 编写一个函数来监视这个进程，如果进程挂了就重启它。启动公共进程和监视进程。
% 然后摧毁公共进程，检查它是否会被监视进程重启。

-module(myspawn).
-export([start/0, my_spawn/3, func/0]).


start() ->
    my_spawn(myspawn, func, []).

my_spawn(Mod, Func, Args) ->
    Pid = spawn(Mod, Func, Args),
    spawn(fun() -> 
            Ref = monitor(process, Pid),
            receive 
                {'DOWN', Ref, process, Pid, Why} ->
                    io:format("接受到消息:~p，正在重启进程~n", [Why]),
                    spawn(Mod, Func, Args),
                    io:format("重启完毕...~n"),
                    monitor(process, Pid)
            end
          end),
    Pid.

func() ->
    receive
        {ok, Message} ->
              exit(Message)
    after 5000 ->
              io:format("我还在运行~n"),
              func()
    end.

注意，即使函数不在模块外面使用，也必须export导出，否则运行失败。

我这里有两个版本，一个正确，一个错误
版本1 正确运行

% (5).编写一个函数来启动和监视多个进程。
% 如果任何一个工作进程非正常中止，就重启它

-module(myspawn).
-export([my_spawn/4, start/1, for/3, spawn_func/0, list_func/3]).


start(N) ->
    my_spawn(myspawn, spawn_func, [], N).

my_spawn(Mod, Func, Args, N) ->
    % 创建 N 个进程。 
    % 创建监视进程
    Monitor = spawn(fun() ->
                        Fs = list_func(N, [], spawn_func),
                        % spawn_link 注意如果一参版本，只能用`fun()-> ... end`匿名函数作为参数，如果是三参版本，Func参数可以是普通函数
                        Id = [spawn_link(myspawn, F, []) || F <- Fs],
                        receive
                            {'DOWN', _, process, Pid, Why} ->
                                io:format("Pid:~p quit, Reason:~p~n", [Pid, Why]),
                                io:format("正在重启进程~n"),
                                spawn_link(Func),
                                io:format("重启完毕~n")
                        end
                    end),
    io:format("Monitor:~p~n", [Monitor]).

spawn_func() ->
    io:format("hello world:~p~n", [self()]),
    receive 
        {ok, Message} -> 
            exit(Message);
        other ->
            spawn_func()
    end.

list_func(N, H, F) when N =/= 1 ->
    list_func(N-1, [F|H], F);
list_func(N, H, F) when N =:= 1 ->
    H.

版本2 参数错误

% (5).编写一个函数来启动和监视多个进程。
% 如果任何一个工作进程非正常中止，就重启它

-module(myspawn).
-export([my_spawn/4, start/1, for/3, spawn_func/0, list_func/3]).


start(N) ->
    my_spawn(myspawn, spawn_func, [], N).

my_spawn(Mod, Func, Args, N) ->
    % 创建 N 个进程。 
    % 创建监视进程
    Monitor = spawn(fun() ->
                        % 为何不能 for 循环创建spawn_link？我猜想可能是在Monitor进程外部调用函数，获得不到Monitor信息，所以不能和Monitor连接起来？问题先放这里，感兴趣小伙伴可以留言一起讨论
                        for(1, N, spawn_link),
                        receive
                            {'DOWN', _, process, Pid, Why} ->
                                io:format("Pid:~p quit, Reason:~p~n", [Pid, Why]),
                                io:format("正在重启进程~n"),
                                spawn_link(Func),
                                io:format("重启完毕~n")
                        end
                    end),
    io:format("Monitor:~p~n", [Monitor]).

spawn_func() ->
    io:format("hello world:~p~n", [self()]),
    receive 
        {ok, Message} -> 
            exit(Message);
        other ->
            spawn_func()
    end.

for(Max, Max, Func) -> [Func(myspawn, spawn_func, [])];
for(I, Max, Func)   -> [Func(myspawn, spawn_func, []) | for(I+1, Max, Func)].
% (6).编写一个函数来启动和监视多个工作进程，如果任何一个进程非正常终止，
% 就摧毁所有进程，然后重启它们。

-module(myspawn).
-export([my_spawn/4, start/1, spawn_func/0, list_func/3]).


start(N) ->
    my_spawn(myspawn, spawn_func, [], N).

my_spawn(_, _, _, N) ->
    Monitor = spawn(fun() ->
                        % 创建 N 个进程
                        Fs = list_func(N, [], spawn_func),
                        Id = [spawn_link(myspawn, F, []) || F <- Fs],
                        io:format("Id:~p~n", [Id]),
                        receive
                            {'DOWN', _, process, Pid, normal} ->
                                Pid;
                            {'DOWN', _, process, Pid, Why} ->
                                io:format("Pid:~p quit, Reason:~p~n", [Pid, Why]),
                                % 杀死所有工作进程
                                [exit(Cpid, normal) || Cpid <- Id],
                                io:format("正在重启所有进程~n"),
                                % 新建所有工作进程
                                [spawn_link(myspawn, F, []) || F <- Fs],
                                io:format("重启完毕~n")
                        end
                    end),
    io:format("Monitor:~p~n", [Monitor]).

spawn_func() ->
    io:format("hello world:~p~n", [self()]),
    receive 
        {ok, Message} -> 
            exit(Message);
        other ->
            spawn_func()
    end.

list_func(N, H, F) when N =/= 1 ->
    list_func(N-1, [F|H], F);
list_func(N, H, _) when N =:= 1 ->
    H.
夏天的技术博客
关注
专栏目录
Erlang开源20周年：这门编程语言见证了互联网的技术成长
SummerGao
12-19 266
Erlang于1998年12月...
Java环境搭建-基础语法
weixin_47669974的博客
06-12 519
Java环境搭建-基础语法
erlang程序设计8.11的习题
05-31 140
第二题: -module(for). -export([for/3,empty_proc/0,post_msg/1]). for(N,N,F)->[F()]; for(I,N,F)->[F() | for(I+1,N,F)]. empty_fun()-> receive _Any-> io:format("~w is exi...
《Erlang程序设计》第八章习题
wlkdarling的博客
05-14 143
8.11.1.编写一个函数start(AnAtom, Fun)来把spawn(Fun)的结果注册为AnAtom。当两个并行的进程同时执行到start/2函数时，要确保代码能够正常工作。也就是说，这两个进程其中一个成功执行，而另一个必须执行失败。 -module(section_8). -compile(export_all). start(AnAtom, Fun) -> case whereis(AnAtom) of undefined -> r
erlang程序设计8.27练习（2）
Wesley大胃王
02-06 310
erlang程序设计第二版学习笔记-码云 题目不写了，能搜到说明缘分。 环境Eshell V9.2 -module(module_statistics). -export([done/0]). %% 当前函数不考虑效率，将三个问题分开解答 done() -> L = [{L1,L2}||{L1,L2} code:all_loaded() , filelib:is_file(L2
Programming Erlang 13.9 练习：编写一个 my_spawn 函数
潘广宇的博客
04-09 284
一、题目 编写一个my_spawn(Mod, Func, Args)函数。它的行为类似spawn(Mod, Func, Args)，但有一点区别。如果分裂出的进程挂了，就应打印一个消息，说明进程挂掉的原因以及在此之前存活了多长时间 二、编写 myspawn 模块 -module(myspawn). -export([my_spawn/3]). my_spawn(Mod, Func, ...
练习13
thmfire的专栏
10-26 379
  /*****************************************************************************13. 有N个硬币（N为偶数）正面朝上排成一排，每次将 N-1 个硬币翻过来放在原位 置， 不断地重复上述过程，直到最后全部硬币翻成反面朝上为止。编程让计算机把 翻币的最简过程及翻币次数打印出来（用＊代表正面，O 代
JAVA经典面试题附答案(持续更新版)
热门推荐
hjseo_seg的博客
06-23 1万+
前言: 少年易老学难成，一寸光阴不可轻。未觉池塘春草梦，阶前梧叶已秋声 。—朱熹《劝学诗》 勤奋才是改变你命运的唯一捷径。 整理不易,各位看官点赞再看更舒适，养成好习惯(●′｀●)1.JAVA中的几种基本类型，各占用多少字节？ 下图单位是bit,非字节 1B=8bit 2.String能被继承吗？为什么？ 不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。平常我们定义的String str=”abc”(直接赋一个字面量);其实和String str=
RabbitMQ
最新发布
weixin_38380811的博客
03-13 2403
RabbitMQ
Go 菜鸟学习笔记-快速入门（上）
山前
05-31 1703
1.简介和hello world go语言编程思想 接受了函数式编程的一些想法，支持匿名函数与闭包 接受了以Erlang语言为代表的面向消息编程思想，支持goroutine和通道 推荐使用消息而不是共享内存来进行并发编程 有丰富的内置类型，支持函数多返回值，类型和接口，反射 自动垃圾回收，错误处理 优点和用途 并行、内存管理、数组安全、编译迅速 用于高性能分布式系统领域，被设计成一门应用于搭载 Web 服务器的系统编程语言。 helloworld package mian import "fmt
《Erlang 程序设计》练习答案 -- 第十二章 并发编程
IT小小鸟～～
11-17 2546
% (1).编写一个start(AnAtom, Fun)函数来把spawn(Fun)注册为AnAtom。 % 确保当两个并行的进程同时执行start/2时你的程序也能正确工作。 % 在这种情况下，必须保证其中一个进程会成功执行而另一个会失败。 -module(execstart). -export([create/2]).start(AnAtom, Fun) -> case whereis(
《Erlang程序设计》第8章习题第一…
镜子蓝玉的专栏
08-29 763
（1）编写一个函数start(AnAtom,Fun)来把spawn(Fun)的结果注册为AnAtom。当两个并行的进行同时执行到start/2函数时，要确保代码能够正常工作。也就是说，这两个进程其中一个成功执行，而另一个必须执行失败。 -module(p150_1_process_conflict). -export([main/0]). %Not to concern about what
第十三章
qq_36074180的博客
09-14 218
public class CustomerBiz { String[] names=new String[5]; public void addName(String name){ for(int i=0;i<names.length;i++){ if(names[i]==null){ names[i]=name; break; } } } public void s
Erlang 的 spawn() 使用时，值得注意的一点
wanghaicheng0421的专栏
03-19 847
spawn() 在使用的过程中遇到一个有趣的事儿，描述如下： A：    spawn(fun() -> io:format("hello world~n", []) end), B：    spawn(out_put()). 以上两种方式的处理方式不同。 区别在于： A 直接返回 进程ID    而B 知道 out_put()结束才返回进程ID。 实例： 情况A： -modu
Chapter8课后习题 函数（第四周Ⅱ）
weixin_40368681的博客
04-01 231
8-1：8-2：8-3：8-4：8-5：8-6：8-7：8-8：8-10：8-11：8-12：8-13：8-14：8-16：8-17：
《Windows核心编程》&《windows程序设计》Start
野猫网络
10-27 1219
恶补基础啊……第一章看完，第二章以前看过跳过，第三章看到3.3.22004.11.1《windows程序设计》第一章、第二章、第三章、第六章
第7章 用函数实现模版化程序设计
qq_44592759的博客
02-22 123
第7章 用函数实现模版化程序设计标题例7.1 想输出以下的结果，用函数调用实现。标题例7.2 输入两个整数，要求输出其中值较大者。要求用函数来找到大者。标题例7.3 将例7.2稍作改动，将在max函数中定义的变量z改为float型。标题例7.4 输入两个实数，用一个函数求出他们的和。 标题例7.1 想输出以下的结果，用函数调用实现。 #include&lt;stdio.h&gt; int...
《Erlang程序设计》 第七章 并发
weixin_30896825的博客
05-30 65
第七章 并发 Table of Contents 并发 第七章 并发 这里作者再次强调了其对并发编程的理解, 即并发是一种本能, 而不是像共享内存的并发编程方式那样, 为了防止同时修改, 需要加锁, 而这种机制的复杂程度及带来的一系列的问题, 都使得并发编程成为了一种看似高级的技能, 而并不是像作者所理解的那样:即使你不会开车, 看到...
并发编程利器：Erlang程序设计
"Erlang程序设计 - 一本关于并发世界的软件开发指南，由Joe Armstrong撰写，是Erlang开发的重要参考资料。" Erlang是一种面向并发的、函数式编程语言，最初由爱立信开发，用于构建高可用性、容错性强的分布式系统。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夏天的技术博客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值