std::sync::Weak::strong_count

[SoniEx2]

I'd like to test if a Weak is done for without potentially incrementing an atomic refcount, because doing so is slow.

I want a faster alternative to Weak.upgrade().is_some().

also currently have this in my code: https://play.rust-lang.org/?gist=339c2c518a2d42aee7e5a585133427eb&version=stable

// since Weaks are completely useless...
// this checks if the arc and weak point to the same value without attempting to upgrade the weak.
// this is "safer" than trying to get the strong count
fn compare_arc_weak<T>(arc: &Arc<T>, weak: &Weak<T>) -> bool {
    unsafe {
        // we assume arc and weak have same size and alignment as usize
        let arcusize: usize = mem::transmute_copy(arc);
        let weakusize: usize = mem::transmute_copy(weak);
        arcusize == weakusize
    }
}

[ishitatsuyuki]

Relying on such count is racy. You have to upgrade to ensure thread safety.

[SoniEx2]

You absolutely do not.

If the strong count is 0(?), then the weak is done for, and upgrade is always gonna be None.

(Altho tbh after some more tweaking I ended up not needing the strong count. Still needed that compare_arc_weak function tho.)

[ishitatsuyuki]

The race is well known, and what you proposed should never be a part of public API.

Identity equality is another thing. We currently doesn't expose those which need discussion on how to add them.

[SoniEx2]

You can't get the strong count back up once it reaches 0. That's the whole point of Arc/Weak! Because once it's 0, it's dropped.

Unless you're saying there's a race condition in which you can turn a Weak into an uninitialized/dropped Arc!?

[ishitatsuyuki]

Well, that particular thing is correct.

However, with regards to this issue,

1. Obtaining the count directly encourage racy behaviour
2. The motivation is not clear.

[oli-obk]

Do you have an example of using the comparison? I'm curious about the use case

[Lymia]

rust/src/liballoc/rc.rs

Lines 1228 to 1236 in e028687

	#[stable(feature = "rc_weak", since = "1.4.0")]
	pub fn upgrade(&self) -> Option<Rc<T>> {
	if self.strong() == 0 {
	None
	} else {
	self.inc_strong();
	Some(Rc { ptr: self.ptr, phantom: PhantomData })
	}
	}

This function is factually unnecessary for this use case, as Weak::upgrade already performs this check.

[SoniEx2]

You're looking at the wrong Weak. Check the arc Weak, it's more expensive.

[RalfJung]

The question still stands: When do you ever think it is useful to know that, at some point in the past, the Weak was (not) valid? This is the best you can get.
It is true that once the Weak is invalid, it will stay invalid, but how is that useful information?

[SoniEx2]

I have no idea what exactly I was using it for, but I just want to be able to use "stupid" optimizations like compare Arc and Weak (which doesn't need to be an atomic operation) to avoid an atomic operation/refcount/optimize for inequality.

I think the usual use-case would involve checking if they're (not) the same and upgrading/cloning as needed.

(I feel like this might have something to do with an eventbus thing I was working on but idk)