Atomic increment if non-negative and atomic decrement if non-positive

I have two groups of threads A and B. Threads in A execute function funA, and threads in B execute function funB. It is OK for threads in each group to execute their functions concurrently, but funA and funB must not be executed concurrently. How do we achieve this? Is this problem have a name, so I can read about it online?

One possible solution is the following:

std::atomic<std::int64_t> counter{};
void funA() {
  std::int64_t curr = 0;
  while( 
    (curr=counter.load(std::memory_order_relaxed)) < 0 ||
    !counter.compare_exchange_weak(curr,curr+1,std::memory_order_relaxed));
  // implementation of funA goes here
  counter.fetch_sub(1); // better to happen using RAII
}
void funB() {
  std::int64_t curr = 0;
  while( 
    (curr=counter.load(std::memory_order_relaxed)) > 0 ||
    !counter.compare_exchange_weak(curr,curr-1,std::memory_order_relaxed));
  // implementation of funB goes here
  counter.fetch_add(1); // better to happen using RAII
}

Is this correct? Is it the best we can do? What I don't like about it is that threads in same group compete against each other on those while loops.