io.reactivex.internal.util.BackpressureHelper#add ( )源码实例Demo

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        // modify request to upstream to account for inserted values
        // use a CAS loop because request can be called from any thread
        while (true) {
            long ins = inserted.get();
            long d = Math.min(ins, n);
            if (inserted.compareAndSet(ins, ins - d)) {
                if (n - d > 0) {
                    upstream.request(n - d);
                }
                break;
            }
        }
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        if (BackpressureHelper.add(this, n) == 0) {
            long requested = n;
            long emitted = 0;
            do {
                emitted = requested;
                while (requested-- > 0 && !cancelled && (count == -1 || counter-- > 0)) {
                    child.onNext(value);
                }
            } while ((requested = this.addAndGet(-emitted)) > 0);
            if (count >= 0 && !cancelled) {
                child.onComplete();
            }
        }
    }
}
 

@Override
public void request(long n) {
    debug(this + " request " + n);
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        while (true) {
            Subscription p = parent.get();
            long d = deferredRequests.get();
            if (d == -1) {
                // parent exists so can request of it
                debug(this + " requesting from parent " + n);
                p.request(n);
                break;
            } else {
                long d2 = d + n;
                if (d2 < 0) {
                    d2 = Long.MAX_VALUE;
                }
                if (deferredRequests.compareAndSet(d, d2)) {
                    break;
                }
            }
        }
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        // modify request to upstream to account for inserted values
        // use a CAS loop because request can be called from any thread
        while (true) {
            long ins = inserted.get();
            long d = Math.min(ins, n);
            if (inserted.compareAndSet(ins, ins - d)) {
                if (n - d > 0) {
                    upstream.request(n - d);
                }
                break;
            }
        }
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(this, n);
        if (once.compareAndSet(false, true)) {
            if (n == Long.MAX_VALUE) {
                parent.request(Long.MAX_VALUE);
                unbounded = true;
            } else {
                parent.request(1);
            }
        }
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        requestMore();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        parent.request(n);
        scheduleDrain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        scheduleDrain();
    }
}
 

@Override
public void request(long n) {
    debug(this + " request " + n);
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        while (true) {
            Requests<T> r = requests.get();
            Requests<T> r2;
            if (r.parent == null) {
                long d = r.deferred + n;
                if (d < 0) {
                    d = Long.MAX_VALUE;
                }
                r2 = new Requests<T>(r.parent, r.unreconciled, d, r.child);
                if (requests.compareAndSet(r, r2)) {
                    break;
                }
            } else {
                long x = n + r.deferred - r.unreconciled;
                long u = Math.max(0, -x);
                r2 = new Requests<T>(r.parent, u, 0, r.child);
                if (requests.compareAndSet(r, r2)) {
                    if (x > 0) {
                        r.parent.request(x);
                    }
                    break;
                }
            }
        }
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        if (once.compareAndSet(false, true)) {
            sources.subscribe(this);
            subscription.request(maxConcurrent);
        }
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        parent.request(n);
        drain();
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        drain();
    }
}
 

@Override
public void cancel() {
    if (!cancelled) {
        cancelled = true;

        if (BackpressureHelper.add(this, 1) == 0) {
            releaseRest(items, release);
        }
    }
}
 

@Override
public void cancel() {
    if (!cancelled) {
        cancelled = true;

        if (BackpressureHelper.add(this, 1) == 0) {
            T[] a = items;
            int n = a.length;
            Consumer<? super T> r = release;
            for (int i = index; i < n; i++) {
                releaseItem(a[i], r);
            }
        }
    }
}
 

@Override
public void request(long n) {
    if (SubscriptionHelper.validate(n)) {
        BackpressureHelper.add(requested, n);
        schedule();
    }
}
 

@Override
public void request(long n) {
    BackpressureHelper.add(requested, n);
    drain();
}
 

@Override
public void request(long n) {
    BackpressureHelper.add(requested, n);
    schedule();
}