【问题标题】:rxjava delay: How to get variable delay on each item emitted from a list?rxjava 延迟:如何获得从列表发出的每个项目的可变延迟?
【发布时间】:2016-08-18 07:55:46
【问题描述】:

我希望在从可观察列表发出的每个项目之间有自定义延迟,作为项目本身的函数。 假设我们有一个列表(项目,延迟):

[("item1", 2),("item2", 1),("item3", 2),("item4", 3),("item5", 2),("item6", 3)]

我希望输出类似于:

0 seconds: 
1 seconds: 
item1
2 seconds: 
item2
3 seconds: 
4 seconds: 
item3
5 seconds: 
6 seconds: 
7 seconds: 
item4
8 seconds: 
9 seconds: 
item5
10 seconds: 
11 seconds: 
12 seconds: 
item6
Completed!
13 seconds: 

我不确定如何使用延迟/计时器运算符最好地完成此任务。浏览了延迟文档,但找不到直接的方法。任何指针都会有所帮助。谢谢!

【问题讨论】:

    标签: java rx-java


    【解决方案1】:

    不需要任何花哨的东西。只需使用 concatMap 和 delay 运算符

    jla.concatMap(s -> Observable.just(s).delay(s.delay, TimeUnit.SECONDS))           
      .subscribe(s1 -> System.out.println(s1.name + " just came..."), 
                 e -> {}, 
                 () -> System.out.println("Everybody came!")); 
    

    【讨论】:

    • 我有一种感觉,它必须如此简单,但这个解决方案让我望而却步......非常感谢!
    • @JohnWowUs 你能详细说明你的答案吗.. 我有一个格式为 的自定义振动模式。所以我想调用振动功能然后等待“on_time”秒;然后调用停止振动()并等待“off_time”秒;然后再次重复相同的操作。请注意,“on_time”和“off_time”值是可变的。示例:
    【解决方案2】:

    您可以尝试使用 .delay() 的覆盖 http://reactivex.io/RxJava/javadoc/rx/Observable.html#delay(rx.functions.Func1)

    这似乎正是你所需要的

    代码类似于:

    yourObservable.delay((item) -> Observable.timer(item.getDelay(), TimeUnit.SECONDS))
    

    【讨论】:

    • 这行得通..在每次发射之间添加了一个 n 延迟 :)
    【解决方案3】:

    我可能有如下可能的解决方案。虽然我觉得可以有更好的方法来实现它,但这目前有效。如果您发现可以改进的方法,请提出替代方案/改进建议:

    import java.util.concurrent.TimeUnit;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    import rx.Observable;
    import rx.functions.Action0;
    import rx.functions.Action1;
    import rx.functions.Func1;
    
    public class Watchtower {
        public static void main(String[] arg) throws Exception {
    
            // Boilerplate for setup
            System.out.println("Welcome to Watchtower");
    
            class SuperHero {
                public String name;
                public long delay;
    
                public SuperHero(String name, int delay) {
                    this.name = name;
                    this.delay = (long) delay;
                }
            }
    
            Observable<Long> clock = Observable.interval(1, TimeUnit.SECONDS).take(14);
    
            clock.subscribe(tick -> System.out.println(tick + " seconds: "));
    
            List<SuperHero> jla = new ArrayList<>(Arrays.asList(
                new SuperHero("Bruce", 2),
                new SuperHero("Barry", 1),
                new SuperHero("Clark", 2),
                new SuperHero("Hal", 3),
                new SuperHero("Arthur", 2),
                new SuperHero("Diana", 3)
                )
            );
    
            // Rxjava stuff starts form here:
    
            Observable<SuperHero> jl = Observable.from(jla);
    
            final long[] cumDelay = {0};
    
            Observable<SuperHero> delays = jl
                .doOnNext(s -> cumDelay[0] += s.delay)
                .delay(s -> Observable.timer(cumDelay[0], TimeUnit.SECONDS));
    
            Observable.zip(jl, delays, (s, d) -> s)
                .doOnNext(s -> System.out.println(s.name + " just came..."))
                .doOnCompleted(() -> System.out.println("Everybody came!"))
                .subscribe();
    
            // Just to have program remain alive and run on normal command line
            Thread.sleep(15000);
        }
    }
    

    它产生的输出:

    Welcome to Watchtower
    0 seconds: 
    1 seconds: 
    Bruce just came...
    2 seconds: 
    Barry just came...
    3 seconds: 
    4 seconds: 
    Clark just came...
    5 seconds: 
    6 seconds: 
    7 seconds: 
    Hal just came...
    8 seconds: 
    9 seconds: 
    Arthur just came...
    10 seconds: 
    11 seconds: 
    12 seconds: 
    Diana just came...
    Everybody came!
    13 seconds: 
    

    【讨论】:

      【解决方案4】:

      为了延迟特定步骤,您可以使用 zip 并将您的第一个 Observable.from 中发出的每个项目与 X 时间间隔结合起来。

      /**
       * If we want to delay the every single item emitted in the pipeline we will need a hack,
       * one possible hack is use zip operator and combine every item emitted with an interval so every item emitted has to wait until interval emit the item.
         */
         @Test
         public void delay() {
             long start = System.currentTimeMillis();
             Subscription subscription = Observable.zip(Observable.from(Arrays.asList(1, 2, 3)), Observable.interval(200, TimeUnit.MILLISECONDS), (i, t) -> i)
                                            .subscribe(n ->System.out.println("time:" + (System.currentTimeMillis() - start)));
                 new TestSubscriber((Observer) subscription).awaitTerminalEvent(3000, TimeUnit.MILLISECONDS);
             }
      

      这将打印出来

                time:537
                time:738
                time:936
      

      更多实践示例在这里https://github.com/politrons/reactive

      【讨论】:

      • 这将在发射的项目之间提供 200 毫秒的恒定延迟。我想要的是发射项目之间的自定义延迟,可能是最后发射项目的函数。
      【解决方案5】:

      您也可以使用Timer 运算符 看看这个

      Integer[] arr = {1, 2, 3, 4, 5, 6, 7};
      Observable.fromArray(arr)
              // timer returns a 0 value, note the nested map operator usage
              // in order to preserve original integers
              .flatMap(x -> Observable.timer(50 * x, TimeUnit.MILLISECONDS)
                          .map(y -> x))
              .timestamp()
              .subscribe(timedIntegers ->
                      Log.i(TAG, "Timed String: "
                              + timedIntegers.value()
                              + " "
                              + timedIntegers.time()));
      

      【讨论】:

        猜你喜欢
        • 1970-01-01
        • 2015-03-26
        • 2016-10-26
        • 1970-01-01
        • 1970-01-01
        • 2017-02-07
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        相关资源
        最近更新 更多