pub fn increment_shutdown_count(&self) {
        let previous = self.shutdown_count.fetch_add(1, Ordering::AcqRel);
        debug_assert!(previous != 0, "registry ref count incremented from zero");
        assert!(
            previous != std::usize::MAX,
            "overflow in registry ref count"
        );
    }
/// Increments the terminate counter. This increment should be
/// balanced by a call to `terminate`, which will decrement. This
/// is used when spawning asynchronous work, which needs to
/// prevent the registry from terminating so long as it is active.
///
/// Note that blocking functions such as `join` and `scope` do not
/// need to concern themselves with this fn; their context is
/// responsible for ensuring the current thread-pool will not
/// terminate until they return.
///
/// The global thread-pool always has an outstanding reference
/// (the initial one). Custom thread-pools have one outstanding
/// reference that is dropped when the `ThreadPool` is dropped:
/// since installing the thread-pool blocks until any joins/scopes
/// complete, this ensures that joins/scopes are covered.
///
/// The exception is `::spawn()`, which can create a job outside
/// of any blocking scope. In that case, the job itself holds a
/// terminate count and is responsible for invoking `terminate()`
/// when finished.
Increments the terminate counter. This increment should be
balanced by a call to `terminate`, which will decrement. This
is used when spawning asynchronous work, which needs to
prevent the registry from terminating so long as it is active.

Note that blocking functions such as `join` and `scope` do not
need to concern themselves with this fn; their context is
responsible for ensuring the current thread-pool will not
terminate until they return.

The global thread-pool always has an outstanding reference
(the initial one). Custom thread-pools have one outstanding
reference that is dropped when the `ThreadPool` is dropped:
since installing the thread-pool blocks until any joins/scopes
complete, this ensures that joins/scopes are covered.

The exception is `::spawn()`, which can create a job outside
of any blocking scope. In that case, the job itself holds a
terminate count and is responsible for invoking `terminate()`
when finished.
Increments the terminate counter . This increment should be balanced by a call to ` terminate ` which will decrement . This is used when spawning asynchronous work which needs to prevent the registry from terminating so long as it is active . Note that blocking functions such as ` join ` and ` scope ` do not need to concern themselves with this fn ; their context is responsible for ensuring the current thread - pool will not terminate until they return . The global thread - pool always has an outstanding reference ( the initial one ) . Custom thread - pools have one outstanding reference that is dropped when the ` ThreadPool ` is dropped : since installing the thread - pool blocks until any joins / scopes complete this ensures that joins / scopes are covered . The exception is ` :: spawn () ` which can create a job outside of any blocking scope . In that case the job itself holds a terminate count and is responsible for invoking ` terminate () ` when finished .
pub fn increment_shutdown_count(&self) {
        let previous = self.shutdown_count.fetch_add(1, Ordering::AcqRel);
        debug_assert!(previous != 0, "registry ref count incremented from zero");
        assert!(
            previous != std::usize::MAX,
            "overflow in registry ref count"
        );
    }
pub fn increment_shutdown_count ( & self ) { let previous = self . shutdown_count . fetch_add ( 1 , Ordering :: AcqRel ) ; debug_assert ! ( previous 0 " " ) ; assert ! ( previous std usize MAX " " ) ; }
Increments the terminate counter.
Increments the terminate counter .
&self
&self