Java MissingBackpressureException类代码示例

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
protected void queueScalar(InnerSubscriber<T> subscriber, T value) {
    RxRingBuffer q = subscriber.queue;
    if (q == null) {
        q = RxRingBuffer.getSpscInstance();
        subscriber.add(q);
        subscriber.queue = q;
    }
    try {
        q.onNext(this.nl.next(value));
        emit();
    } catch (MissingBackpressureException ex) {
        subscriber.unsubscribe();
        subscriber.onError(ex);
    } catch (IllegalStateException ex2) {
        if (!subscriber.isUnsubscribed()) {
            subscriber.unsubscribe();
            subscriber.onError(ex2);
        }
    }
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
private boolean assertCapacity() {
    if (this.capacity == null) {
        return true;
    }
    long currCapacity;
    do {
        currCapacity = this.capacity.get();
        if (currCapacity <= 0) {
            if (this.saturated.compareAndSet(false, true)) {
                unsubscribe();
                this.child.onError(new MissingBackpressureException("Overflowed buffer of " + this.baseCapacity));
                if (this.onOverflow != null) {
                    this.onOverflow.call();
                }
            }
            return false;
        }
    } while (!this.capacity.compareAndSet(currCapacity, currCapacity - 1));
    return true;
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
public boolean onNext(int index, T t) {
    synchronized (this) {
        if (!this.haveValues.get(index)) {
            this.haveValues.set(index);
            this.haveValuesCount++;
        }
        this.collectedValues[index] = t;
        if (this.haveValuesCount != this.collectedValues.length) {
            return false;
        }
        try {
            this.buffer.onNext(this.combinator.call(this.collectedValues));
        } catch (MissingBackpressureException e) {
            onError(e);
        } catch (Throwable e2) {
            Exceptions.throwOrReport(e2, this.child);
        }
        tick();
        return true;
    }
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
public void onNext(Object o) throws MissingBackpressureException {
    boolean iae = false;
    boolean mbe = false;
    synchronized (this) {
        Queue<Object> q = this.queue;
        if (q != null) {
            mbe = !q.offer(on.next(o));
        } else {
            iae = true;
        }
    }
    if (iae) {
        throw new IllegalStateException("This instance has been unsubscribed and the queue is no longer usable.");
    } else if (mbe) {
        throw new MissingBackpressureException();
    }
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
private boolean assertCapacity() {
    if (capacity == null) {
        return true;
    }

    long currCapacity;
    do {
        currCapacity = capacity.get();
        if (currCapacity <= 0) {
            if (saturated.compareAndSet(false, true)) {
                unsubscribe();
                child.onError(new MissingBackpressureException(
                        "Overflowed buffer of "
                                + baseCapacity));
                if (onOverflow != null) {
                    onOverflow.call();
                }
            }
            return false;
        }
        // ensure no other thread stole our slot, or retry
    } while (!capacity.compareAndSet(currCapacity, currCapacity - 1));
    return true;
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
/**
 * Make sure we get a MissingBackpressureException propagated through when we have a fast temporal (hot) producer.
 */
@Test
public void testHotOperatorBackpressure() {
    TestSubscriber<String> ts = new TestSubscriber<String>();
    Observable.timer(0, 1, TimeUnit.MICROSECONDS)
            .observeOn(Schedulers.computation())
            .map(new Function<Long, String>() {

                @Override
                public String call(Long t1) {
                    System.out.println(t1);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                    }
                    return t1 + " slow value";
                }

            }).subscribe(ts);

    ts.awaitTerminalEvent();
    System.out.println("Errors: " + ts.getOnErrorEvents());
    assertEquals(1, ts.getOnErrorEvents().size());
    assertEquals(MissingBackpressureException.class, ts.getOnErrorEvents().get(0).getClass());
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
@Test
public void missingBackpressureException() throws MissingBackpressureException {
    RxRingBuffer b = createRingBuffer();
    TestSubscriber<Object> s = new TestSubscriber<Object>();
    s.requestMore(Flow.defaultBufferSize());
    for (int i = 0; i < Flow.defaultBufferSize(); i++) {
        b.onNext("one");
    }
    try {
        b.onNext("o");
        fail("expected failure adding beyond size");
    } catch (Exception e) {
        // expecting failure
        assertTrue(e instanceof MissingBackpressureException);
    }
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
@Test
public void roomForError() throws MissingBackpressureException {
    RxRingBuffer b = createRingBuffer();
    TestSubscriber<Object> s = new TestSubscriber<Object>();
    s.requestMore(Flow.defaultBufferSize());
    for (int i = 0; i < Flow.defaultBufferSize(); i++) {
        b.onNext("one");
    }
    // should act full now
    try {
        b.onNext("should-fail");
        fail("expected error");
    } catch (Exception e) {
        // we want this
        b.onError(new MissingBackpressureException());
    }
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
@Test
public void multipleTerminalEventsOnComplete() throws MissingBackpressureException {
    RxRingBuffer b = createRingBuffer();
    TestSubscriber<Object> s = new TestSubscriber<Object>();
    s.requestMore(Flow.defaultBufferSize());
    for (int i = 0; i < Flow.defaultBufferSize(); i++) {
        b.onNext("one");
    }
    // queue is now full
    b.onError(new RuntimeException("an error"));
    try {
        b.onComplete();
        // we ignore duplicate terminal events
    } catch (IllegalStateException e) {
        fail("we will ignore duplicate terminal events");
    }
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
@Test
public void multipleTerminalEventsOnError() throws MissingBackpressureException {
    RxRingBuffer b = createRingBuffer();
    TestSubscriber<Object> s = new TestSubscriber<Object>();
    s.requestMore(Flow.defaultBufferSize());
    for (int i = 0; i < Flow.defaultBufferSize(); i++) {
        b.onNext("one");
    }
    // queue is now full
    b.onComplete();
    try {
        b.onError(new RuntimeException("an error"));
        // we ignore duplicate terminal events
    } catch (IllegalStateException e) {
        fail("we will ignore duplicate terminal events");
    }
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
@Test(timeout = 500)
public void testPollingTerminalState() throws MissingBackpressureException {
    RxRingBuffer b = createRingBuffer();
    b.onNext(1);
    b.onComplete();
    TestSubscriber<Object> s = new TestSubscriber<Object>();
    Object o = null;
    while ((o = b.poll()) != null) {
        if (b.isCompleted(o)) {
            s.onComplete();
        } else {
            s.onNext(o);
        }
    }

    s.awaitTerminalEvent();
    s.assertReceivedOnNext(Arrays.<Object> asList(1));
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
@Override
public void onNext(T t) {
    if (done) {
        return;
    }
    try {
        queue.onNext(NotificationLite.next(t));
    } catch (MissingBackpressureException mbe) {
        try {
            onError(mbe);
        } finally {
            unsubscribe();
        }
        return;
    } catch (IllegalStateException ex) {
        if (!isUnsubscribed()) {
            try {
                onError(ex);
            } finally {
                unsubscribe();
            }
        }
        return;
    }
    parent.emit();
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
@Override
public void onNext(T t) {
    try {
        queue.onNext(NotificationLite.next(t));
    } catch (MissingBackpressureException mbe) {
        try {
            onError(mbe);
        } finally {
            unsubscribe();
        }
        return;
    } catch (IllegalStateException ex) {
        if (!isUnsubscribed()) {
            try {
                onError(ex);
            } finally {
                unsubscribe();
            }
        }
        return;
    }
    parent.emit();
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
private void handleScalarSynchronousObservableWithoutRequestLimits(ScalarSynchronousObservable<? extends T> t) {
    T value = t.get();
    if (getEmitLock()) {
        try {
            actual.onNext(value);
            return;
        } finally {
            if (releaseEmitLock()) {
                drainQueuesIfNeeded();
            }
            request(1);
        }
    } else {
        initScalarValueQueueIfNeeded();
        try {
            scalarValueQueue.onNext(value);
        } catch (MissingBackpressureException e) {
            onError(e);
        }
        return;
    }
}
 

import rx.exceptions.MissingBackpressureException; //导入依赖的package包/类
@Override
public void onNext(T t) {
    long r = get();
    if (r != Long.MIN_VALUE) {
        long p = produced;
        if (r != p) {
            produced = p + 1;
            actual.onNext(t);
        } else {
            unsubscribe();
            actual.onError(new MissingBackpressureException("PublishSubject: could not emit value due to lack of requests"));
        }
    }
}