Microsoft.Data.Sqlite: the pool can hand one connection to two openers while it grows (race between Activate and ReclaimLeakedConnections) #39253

SqliteConnectionInternal obj = pool == null ? new SqliteConnectionInternal(...) : pool.GetConnection();
obj.Activate(outerConnection);   // outside the pool's lock

_active = true;
_outerConnection.SetTarget(outerConnection);

public void Activate(SqliteConnection outerConnection)
{
    _outerConnection.SetTarget(outerConnection);
    _active = true;
}

using System.Collections.Concurrent;
using Microsoft.Data.Sqlite;

// Opens a pooled connection string from many threads at once, against a pool that has to grow, and checks
// whether two SqliteConnection objects that are open AT THE SAME TIME share one sqlite3 handle.
var path = Path.Combine(Path.GetTempPath(), $"poolrace-{Guid.NewGuid():N}.db");
var connectionString = new SqliteConnectionStringBuilder { DataSource = path, Pooling = true }.ToString();
var threads = args.Length > 1 ? int.Parse(args[1]) : 32;
var rounds = args.Length > 0 ? int.Parse(args[0]) : 500;
int shared = 0, errors = 0;
var gate = args.Length > 2 && args[2] == "serialised" ? new SemaphoreSlim(1, 1) : null;

for (var round = 0; round < rounds; round++)
{
    SqliteConnection.ClearAllPools();
    var held = new ConcurrentDictionary<nint, int>();
    using var barrier = new Barrier(threads);
    var workers = Enumerable.Range(0, threads).Select(_ => Task.Factory.StartNew(() =>
    {
        barrier.SignalAndWait();
        try
        {
            using var connection = new SqliteConnection(connectionString);
            gate?.Wait();
            try { connection.Open(); } finally { gate?.Release(); }
            // A function is registered on open, as EF Core does for its own functions.
            connection.CreateFunction("probe", (long x) => x);
            var handle = connection.Handle!.DangerousGetHandle();
            if (held.AddOrUpdate(handle, 1, (_, n) => n + 1) > 1)
            {
                Interlocked.Increment(ref shared);
            }
            try
            {
                using var command = connection.CreateCommand();
                command.CommandText = "SELECT probe(1)";
                command.ExecuteScalar();
            }
            finally
            {
                // Released before the connection goes back to the pool, so a later legitimate reuse never counts.
                held.AddOrUpdate(handle, 0, (_, n) => n - 1);
            }
        }
        catch (SqliteException e)
        {
            Interlocked.Increment(ref errors);
            if (errors <= 3) Console.WriteLine($"round {round}: {e.Message}");
        }
    }, TaskCreationOptions.LongRunning)).ToArray();
    Task.WaitAll(workers);
}

Console.WriteLine($"{(gate is null ? "opens in parallel" : "opens serialised")}: {rounds} rounds x {threads} threads: {shared} times two open connections shared one handle, {errors} SQLite errors");
SqliteConnection.ClearAllPools();
File.Delete(path);
return shared > 0 ? 1 : 0;