package io.reactivex.internal.queue;

import io.reactivex.internal.fuseable.SimplePlainQueue;
import java.util.concurrent.atomic.AtomicReference;

/* loaded from: classes2.dex */
public final class MpscLinkedQueue<T> implements SimplePlainQueue<T> {
    private final AtomicReference<LinkedQueueNode<T>> a = new AtomicReference<>();
    private final AtomicReference<LinkedQueueNode<T>> b = new AtomicReference<>();

    static final class LinkedQueueNode<E> extends AtomicReference<LinkedQueueNode<E>> {
        private E a;

        LinkedQueueNode() {
        }

        public E a() {
            E b = b();
            a((LinkedQueueNode<E>) null);
            return b;
        }

        public E b() {
            return this.a;
        }

        public LinkedQueueNode<E> c() {
            return get();
        }

        LinkedQueueNode(E e) {
            a((LinkedQueueNode<E>) e);
        }

        public void a(E e) {
            this.a = e;
        }

        public void a(LinkedQueueNode<E> linkedQueueNode) {
            lazySet(linkedQueueNode);
        }
    }

    public MpscLinkedQueue() {
        LinkedQueueNode<T> linkedQueueNode = new LinkedQueueNode<>();
        a(linkedQueueNode);
        b(linkedQueueNode);
    }

    LinkedQueueNode<T> a() {
        return this.b.get();
    }

    LinkedQueueNode<T> b(LinkedQueueNode<T> linkedQueueNode) {
        return this.a.getAndSet(linkedQueueNode);
    }

    LinkedQueueNode<T> c() {
        return this.a.get();
    }

    @Override // io.reactivex.internal.fuseable.SimpleQueue
    public void clear() {
        while (poll() != null && !isEmpty()) {
        }
    }

    @Override // io.reactivex.internal.fuseable.SimpleQueue
    public boolean isEmpty() {
        return b() == c();
    }

    @Override // io.reactivex.internal.fuseable.SimpleQueue
    public boolean offer(T t) {
        if (t == null) {
            throw new NullPointerException("Null is not a valid element");
        }
        LinkedQueueNode<T> linkedQueueNode = new LinkedQueueNode<>(t);
        b(linkedQueueNode).a(linkedQueueNode);
        return true;
    }

    @Override // io.reactivex.internal.fuseable.SimplePlainQueue, io.reactivex.internal.fuseable.SimpleQueue
    public T poll() {
        LinkedQueueNode<T> c;
        LinkedQueueNode<T> a = a();
        LinkedQueueNode<T> c2 = a.c();
        if (c2 != null) {
            T a2 = c2.a();
            a(c2);
            return a2;
        }
        if (a == c()) {
            return null;
        }
        do {
            c = a.c();
        } while (c == null);
        T a3 = c.a();
        a(c);
        return a3;
    }

    void a(LinkedQueueNode<T> linkedQueueNode) {
        this.b.lazySet(linkedQueueNode);
    }

    LinkedQueueNode<T> b() {
        return this.b.get();
    }
}