I might be missing something but I think we can go for a simpler solution here:

let step = if self.reversed { -1 } else { 1 };
let curr_pos = self.position.fetch_add(step);
if curr_pos >= 0 {
...

then use the same code as before.

This will answer what we expect from an iterator. Each time next is called we will receive a unique item from the iterable. Once the iterator is exhausted all consecutive calls will get stop iteration.

Ah, that probably would work since it's an isize and it wouldn't matter if it went below 0, it wouldn't underflow.

Again lets use fetch_add here. In this solution we can have 2 thread getting the same value.

Please see comment in objiter

I made a comment on your last set of reviews; if it's a reverse iterator and reaches the end, then fetch_sub would underflow and if next(it) is called again the index would be usize::MAX_VALUE. What would you suggest for that?

Maybe a separate done flag?

I do prefer to keep this simple as the current implementation is a little complex. I think we an go in a few directions here:

1. Change the position to isize.
2. Start the position at len(iterator) instead of len(iterator) - 1 and go until 0.
3. Check if we are at 0 before doing the fetch_sub.

Oh, right, it'd be fine if we do a load and then a fetch_sub after we check that we're still in bounds, since it's still atomic. Okay, thanks for your feedback.

Looking at this again I am not sure 2 or 3 will be simple at all. I think changing to isize will be the simplest. You can't actually do load and then fetch_sub as it will not be atomic.

Okay, I updated it to just use the fetch_* operations. I didn't really want to do that, but I think I was just being silly, because yes, if someone does this:

it = iter([1,2])
try:
    next(it)
except:
    pass

Then it's eventually going to wrap around and start yielding elements again, but that's a very small edge case that doesn't really matter in the grand scheme of things.