-       // Create a new connection, and then in a go routine have it start a
-       // transaction, update a row, sleep for a time, and then complete the
-       // transaction. With original connection attempt to update the same row
-       // being updated concurrently in the separate go routine, this will be
-       // blocked until the original transaction completes.
-       var wgTxnStarted sync.WaitGroup
-       wgTxnStarted.Add(1)
-
-       // Lock to wait for the txn to complete to avoid the test finishing
-       // before the txn is committed.
-       var wgTxnDone sync.WaitGroup
-       wgTxnDone.Add(1)
+       // contentionStartCh is used to communicate to the main goroutine when the
+       // INSERT has been performed by the worker goroutine, meaning that the
+       // contention can now start.
+       contentionStartCh := make(chan time.Time, 1)
+       // wg ensures that the function blocks until the concurrent goroutine exits.
+       var wg sync.WaitGroup
+       wg.Add(1)
+       defer wg.Wait()
 
        go func() {
-               defer wgTxnDone.Done()
+               defer wg.Done()
                tx, errTxn := conn.BeginTx(ctx, &gosql.TxOptions{})
                require.NoError(t, errTxn)
                _, errTxn = tx.ExecContext(ctx,
                        fmt.Sprintf("INSERT INTO %s (id, s) VALUES ('test', $1);", table),
                        insertValue)
                require.NoError(t, errTxn)
-               wgTxnStarted.Done()
+               contentionStartCh <- timeutil.Now()
                _, errTxn = tx.ExecContext(ctx, "select pg_sleep(.5);")
                require.NoError(t, errTxn)
                errTxn = tx.Commit()
                require.NoError(t, errTxn)
        }()
 
-       start := timeutil.Now()
-
-       // Need to wait for the txn to start to ensure lock contention.
-       wgTxnStarted.Wait()
+       // Need to wait for the INSERT to be performed to ensure lock contention.
+       start := <-contentionStartCh
        // This will be blocked until the updateRowWithDelay finishes.
        _, errUpdate := conn.ExecContext(
                ctx, fmt.Sprintf("UPDATE %s SET s = $1 where id = 'test';", table), updateValue)
        require.NoError(t, errUpdate)
        end := timeutil.Now()
-       require.GreaterOrEqual(t, end.Sub(start), 499*time.Millisecond)
-
-       wgTxnDone.Wait()
+       require.GreaterOrEqual(t, end.Sub(start), 500*time.Millisecond)
 }