Параллельная программа, скомпилированная с clang, работает нормально, но зависает с gcc

Вы сталкиваетесь с неопределенным поведением, поскольку фактически повторно блокируете уже полученную блокировку. С MSVC я получил полезный стек вызовов, чтобы отличить это. Вот рабочий фиксированный пример (я полагаю, теперь работает для меня, см. изменения в методе заимствования(), которые могут быть дополнительно переработаны, поскольку блокировка внутри деструктора может быть поставлена ​​под сомнение):

#include <iostream>
#include <vector>
#include <stdexcept>
#include <mutex>
#include <condition_variable>

template <typename T>
class Pool {
  ///////////////////////////
  class Borrowed {
    friend class Pool<T>;
    Pool<T>& pool;
    const size_t id;
    T * val;

  public:
    Borrowed(Pool & p, size_t i, T& v) : pool(p), id(i), val(&v) {}
    ~Borrowed() { release(); }

    T& get() const {
      if (!val) throw std::runtime_error("Borrowed::get() this resource was collected back by the pool");
      return *val;
    }

    void release() { pool.collect(*this); }
  };
  ///////////////////////////    
  struct Resource {
    T val;
    bool available = true;
    Resource(T v) : val(std::move(v)) {}
  };
  ///////////////////////////

  std::vector<Resource> vres;
  size_t hint = 0;

  std::condition_variable cv;
  std::mutex mtx;
  size_t available_cnt;

public:

  Pool(std::initializer_list<T> l) : available_cnt(l.size()) {
    vres.reserve(l.size());
    for (T t : l) {
      vres.emplace_back(std::move(t));
    }
    std::cout << "Pool has size " << vres.size() << std::endl;
  }

  ~Pool() {
    for (auto & res : vres) {
      if (!res.available) {
        std::cerr << "WARNING Pool::~Pool resources are still in use\n";
      }
    }
  }

  Borrowed borrow() {
    
    std::unique_lock<std::mutex> lk(mtx);
    while (available_cnt == 0) cv.wait(lk);

    if (vres[hint].available) {
      // quick path, if hint points to an available resource
      std::cout << "hint good" << std::endl;
      vres[hint].available = false;
      --available_cnt;
      Borrowed b(*this, hint, vres[hint].val);
      if (hint + 1 < vres.size()) ++hint;
      lk.unlock();
      return b; // <--- gcc seems to hang here
    }
    else {
      // full scan to find the available resource
      std::cout << "hint bad" << std::endl;
      for (hint = 0; hint < vres.size(); ++hint) {
        if (vres[hint].available) {
          vres[hint].available = false;
          --available_cnt;
          lk.unlock();
          return Borrowed(*this, hint, vres[hint].val);
        }
      }
    }
    throw std::runtime_error("Pool::borrow() no resource is available - internal logic error");
  }

  void collect(Borrowed & b) {
    if (&(b.pool) != this)
      throw std::runtime_error("Pool::collect() trying to collect resource owned by another pool!");
    if (b.val) {
      b.val = nullptr;
      {
        std::scoped_lock<std::mutex> lk(mtx);
        hint = b.id;
        vres[hint].available = true;
        ++available_cnt;
        cv.notify_one();
      }
    }
  }
};

///////////////////////////////////////////////////////////////////

#include <thread>
#include <chrono>



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
  try
  {
    Pool<std::string> pool{ "hello","world" };

    std::vector<std::thread> vt;
    for (int i = 10; i > 0; --i) {
      vt.emplace_back([&pool, i]()
        {
          auto res = pool.borrow();
          std::this_thread::sleep_for(std::chrono::milliseconds(i * 300));
          std::cout << res.get() << std::endl;
        }
      );
    }

    for (auto & t : vt) t.join();

    return 0;
  }
  catch(const std::exception& e)
  {
    std::cout << "exception occurred: " << e.what();
  }
  return 0;
}

Деструктор блокировки в сочетании с пропущенным NRVO вызвал проблему (спасибо Secundi за указание на это в комментариях).

Если компилятор пропускает NRVO, несколько строк ниже if вызовут деструктор b. Деструктор пытается захватить мьютекс до того, как он будет освобожден unique_lock, что приводит к тупиковой ситуации.

Borrowed b(*this, hint, vres[hint].val);
if ( hint + 1 < vres.size() ) ++hint;
return b; // <--- gcc seems to hang here

Здесь крайне важно не разрушить b. На самом деле, даже если ручное освобождение unique_lock перед возвратом позволит избежать взаимоблокировки, деструктор b пометит объединенный ресурс как доступный, в то время как он просто заимствован, что делает код неправильным.

Возможное исправление заключается в замене приведенных выше строк на:

const auto tmp = hint;
if ( hint + 1 < vres.size() ) ++hint;
return Borrowed(*this, tmp, vres[tmp].val);

Другая возможность (которая не исключает первую) состоит в том, чтобы удалить (злой) копирующий элемент Borrowed и предоставить только движущийся элемент:

Borrowed(const Borrowed &) = delete;
Borrowed(Borrowed && b): pool(b.pool), id(b.id), val(b.val) { b.val = nullptr; }