Question

我创建了一个固定的线程池来处理每300毫秒的事件发射，并假设该过程需要1000毫秒。假设多线程可以工作但只重用一个线程。

如果我将sleepTime设置为小于300毫秒，则处理线程会改变，但这是无用的。

问题：如何让它并发？为什么程序重用该线程？

提前谢谢

html, body, #canvas {
  margin: 0;
  padding: 0;
  width: 100%;
  height: 100%;
  overflow: hidden;
}

日志

<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r73/three.min.js"></script>
<canvas id="canvas"></canvas>
<script id="vertex-shader" type="x-shader/x-vertex">
  varying vec2 vUv;

  void main() {
    vUv = uv;
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
  }
</script>
<script id="fragment-shader" type="x-shader/x-fragment">
  #define M_TAU 6.2831853071795864769252867665590

  varying vec2 vUv;

  void main() {
    float w = sin(500.0 * M_TAU * vUv.x) / 2.0 + 0.5;
    vec3 color = vec3(w, 0.0, 0.0);
    gl_FragColor = vec4(color, 1.0);
  }
</script>

Answer 1

根据我在您的代码中所理解的，生产者的生产速度比订阅者更快。但是Observable<Long> interval(long interval, TimeUnit unit)实际上不支持Backpressure。文档说明了

此操作员因使用时间而不支持背压。如果下游需要更慢，它应该减慢计时器或使用一些东西比如{@link #onBackpressureDrop}。

如果您的处理速度真的比生产者慢，那么您在订阅者代码中可以做的就是这样

.subscribe(new Action1<Long>() {

    @Override
    public void call(Long pT) {
        e.submit(new Runnable() {
            System.out.println("i am " + pT + "in thread:" + Thread.currentThread().getName());

        }
    }
});

Answer 2

相反

 .subscribeOn(Schedulers.computation())

尝试

 .observeOn(Schedulers.computation())

我之前用Rx实现并发性的这个例子非常好用作例子

   public class ObservableZip {

private Scheduler scheduler;
private Scheduler scheduler1;
private Scheduler scheduler2;

@Test
public void testAsyncZip() {
    scheduler = Schedulers.newThread();
    scheduler1 = Schedulers.newThread();
    scheduler2 = Schedulers.newThread();
    long start = System.currentTimeMillis();
    Observable.zip(obAsyncString(), obAsyncString1(), obAsyncString2(), (s, s2, s3) -> s.concat(s2)
                                                                                        .concat(s3))
              .subscribe(result -> showResult("Async:", start, result));
}




public void showResult(String transactionType, long start, String result) {
    System.out.println(result + " " +
                               transactionType + String.valueOf(System.currentTimeMillis() - start));
}


public Observable<String> obAsyncString() {
    return Observable.just("")
                     .observeOn(scheduler)
                     .doOnNext(val -> {
                         System.out.println("Thread " + Thread.currentThread()
                                                              .getName());
                     })
                     .map(val -> "Hello");
}

public Observable<String> obAsyncString1() {
    return Observable.just("")
                     .observeOn(scheduler1)
                     .doOnNext(val -> {
                         System.out.println("Thread " + Thread.currentThread()
                                                              .getName());
                     })
                     .map(val -> " World");
}

public Observable<String> obAsyncString2() {
    return Observable.just("")
                     .observeOn(scheduler2)
                     .doOnNext(val -> {
                         System.out.println("Thread " +  Thread.currentThread()
                                                               .getName());
                     })
                     .map(val -> "!");
  }

 }

Answer 3

我在GitHub找到了答案！

内部observable确实在多线程上发出，但接下来的做法不是。如果我想要它是并行的，我应该在内部可观察量中进行。

RxJava - 为什么执行程序只使用一个线程

3 个答案: