Exemple #1
0
        //15 超时接收
        static async Task Worker15()
        {
            chan <int> chan = chan <int> .make(1);//缓存1个

            generator.children children = new generator.children();
            children.go(async delegate()
            {
                for (int i = 0; i < 3; i++)
                {
                    await chan.send(i);
                    await generator.sleep(1000);
                }
            });
            children.go(async delegate()
            {
                while (true)
                {
                    chan_recv_wrap <int> res = await chan.timed_receive(2000);
                    if (res.state == chan_state.overtime)
                    {
                        Log($"recv 超时");
                        break;
                    }
                    Log($"recv {res.msg}");
                }
            });
            await children.wait_all();
        }
Exemple #2
0
        //16 超时发送
        static async Task Worker16()
        {
            chan <int> chan = chan <int> .make(0);//无缓存

            generator.children children = new generator.children();
            children.go(async delegate()
            {
                for (int i = 0; ; i++)
                {
                    chan_send_wrap res = await chan.timed_send(2000, i);
                    if (res.state == chan_state.overtime)
                    {
                        Log($"send 超时");
                        break;
                    }
                    await generator.sleep(1000);
                }
            });
            children.go(async delegate()
            {
                for (int i = 0; i < 3; i++)
                {
                    chan_recv_wrap <int> res = await chan.receive();
                    Log($"recv0 {res.msg}");
                }
            });
            await children.wait_all();
        }
Exemple #3
0
        //19 一轮选择一个发送
        static async Task Worker19()
        {
            chan <int> chan1 = chan <int> .make(0);

            chan <int> chan2 = chan <int> .make(0);

            generator.children children = new generator.children();
            children.go(async delegate()
            {
                for (int i = 0; i < 3; i++)
                {
                    await generator.select(true).case_send(chan1, i, async delegate()
                    {
                        Log($"send1 {i}");
                        await generator.sleep(1000);
                    }).case_send(chan2, i, async delegate()
                    {
                        Log($"send2 {i}");
                        await generator.sleep(1000);
                    }).end();
                }
                chan1.close();
                chan2.close();
            });
            children.go(async delegate()
            {
                while (true)
                {
                    chan_recv_wrap <int> res = await chan1.receive();
                    if (res.state == chan_state.closed)
                    {
                        Log($"chan1 已关闭");
                        break;
                    }
                    Log($"recv1 {res.msg}");
                }
            });
            children.go(async delegate()
            {
                while (true)
                {
                    chan_recv_wrap <int> res = await chan2.receive();
                    if (res.state == chan_state.closed)
                    {
                        Log($"chan2 已关闭");
                        break;
                    }
                    Log($"recv2 {res.msg}");
                }
            });
            await children.wait_all();
        }
Exemple #4
0
        //14 生产者->消费者
        static async Task Worker14()
        {
            chan <int> chan = chan <int> .make(-1);//无限缓存,使用默认strand

            generator.children children = new generator.children();
            children.go(async delegate()
            {
                for (int i = 0; i < 3; i++)
                {
                    await chan.send(i);
                    await generator.sleep(1000);
                }
                chan.close();
            });
            children.go(async delegate()
            {
                for (int i = 10; i < 13; i++)
                {
                    await chan.send(i);
                    await generator.sleep(1000);
                }
                chan.close();
            });
            children.go(async delegate()
            {
                while (true)
                {
                    chan_recv_wrap <int> res = await chan.receive();
                    if (res.state == chan_state.closed)
                    {
                        Log($"chan 已关闭");
                        break;
                    }
                    Log($"recv0 {res.msg}");
                }
            });
            children.go(async delegate()
            {
                while (true)
                {
                    chan_recv_wrap <int> res = await chan.receive();
                    if (res.state == chan_state.closed)
                    {
                        Log($"chan 已关闭");
                        break;
                    }
                    Log($"recv1 {res.msg}");
                }
            });
            await children.wait_all();
        }