0

我正在尝试同时使用代理回调。不幸的是，无论我做什么，它似乎总是顺序运行而不是并行运行。（没有代理它没有）

主类（应用）：

class
    APPLICATION

inherit
    ARGUMENTS

create
    make

feature {NONE} -- Initialization

    make
            -- Run application.
        local
            a1 : separate PROCEDURE
            a2 : separate PROCEDURE
        do
            create my_counter.make (1, 100_000_000)
            create my_counter2.make (2, 100_000_000)

            launch_counter(my_counter)
            launch_counter(my_counter2)

        end

feature -- Launch

    launch_counter(c: separate COUNTER)
        do
            c.run (5, agent print_hello)
        end

    print_hello
        do
            print("Hello!%N")
        end

feature -- Access

    my_counter : separate COUNTER
    my_counter2 : separate COUNTER

end

计数器类：

class
    COUNTER

inherit
    EXECUTION_ENVIRONMENT


create
    make

feature -- Initilzation
    make (i: INTEGER; delay: INTEGER)
        do
            id := i
            delay_time := delay
        end

feature -- Stuff

    run (times: INTEGER; p: separate PROCEDURE)
    local
        c : INTEGER
    do
        from
            c := times
        until
            c = 0
        loop
            print("COUNTER: " + id.out)
            p.call
            sleep(delay_time)
            c := c - 1

        end

    end

feature {NONE} -- Access

    delay_time : INTEGER
    id: INTEGER

end

预期输出：

COUNTER: 1Hello!
COUNTER: 2Hello!
COUNTER: 1Hello!
etc.

实际输出：

COUNTER: 1Hello!
COUNTER: 1Hello!
COUNTER: 1Hello!
COUNTER: 1Hello!
COUNTER: 1Hello!
COUNTER: 2Hello!
COUNTER: 2Hello!
COUNTER: 2Hello!
COUNTER: 2Hello!
COUNTER: 2Hello!

我必须改变什么才能使其按预期运行？

4

1 回答 1

1

代理对象保留对目标的引用，在您的示例中是对 type 的根对象的引用APPLICAITON，因此所有调用都需要print_hello同步。为避免这种情况，调用代理的对象应记录在COUNTER对象中并从那里使用。

这可以通过向action类添加属性COUNTER并更新其创建过程来实现

make (i: INTEGER; delay: INTEGER; a: separate PROCEDURE)
    do
        id := i
        delay_time := delay
        action := a
    end
...
action: separate PROCEDURE

然后将使用以下代码代替（p.call该功能不再有参数）：COUNTER.runrunp

        separate action as p do
            p.call
        end

现在p没有锁定进入该功能run，因此回调可以由不同的处理器交替执行。

于 2017-07-07T15:00:43.817 回答