Issues with deadlocks when using the TryPublish in multiple threads simultaneously

Hey, I ran into the similar kind of issue and spent a good chunk of time tracing through the stack before I understood what was actually happening.

What's actually going on

The deadlock isn't in your code. It's happening deep inside XbyK's publish pipeline. 
When TryPublish runs, it first deletes the existing draft ContentItemCommonData record. 
Before the actual delete happens, ObjectDependenciesRemover.GetDependencyData fires a SELECT query inside an open transaction to figure out what related objects need cleaning up. When two threads hit that same step at the same time, even for completely different content items, they end up waiting on each other's transaction locks and SQL Server kills one of them as the deadlock.

My scenario — scheduled task with nested linked content items

I ran into a variant of this in a scheduled task that imports/updates content hub items where each parent item has several nested linked content items. The task was kicking off updates for everything in parallel, which meant TryPublish was being called simultaneously for the parent item and all its linked children.

This is actually worse than publishing unrelated items concurrently, because the parent and its linked items share overlapping dependency rows.

The method I was using for each update follows the documented XbyK pattern — TryCreateDraft → TryUpdateDraft → TryPublish — which is correct. The problem was purely in how the scheduled task was calling it.

What actually fixed it for me

Two things together:

First, publish in the right order nested linked items first, then the parent. XbyK doesn't cascade automatically via the API the way the UI does, so you need to sequence this yourself. Processing deepest children first means by the time you publish the parent, there are fewer unresolved dependency relationships in play.

Second, go fully sequential. No parallel foreach.

Just a plain foreach with await on each item:

Example what I used

**// nested/linked items first**
foreach (var linkedItemId in linkedItemIds)
    await UpdateContentItemByIdAsync(linkedItemId, ...);

**// parent last**
await UpdateContentItemByIdAsync(parentItemId, ...);

/// Example reference code block
public async Task UpdateContentItemByIdAsync(
    int contentItemId,
    string contentType,
    Dictionary<string, object> updatedFieldData,
    string languageName,
    CancellationToken cancellationToken)
{
    try
    {
        var user = userInfoProvider.Get("administrator");
        var contentItemManager = contentItemManagerFactory.Create(user.UserID);
        var updatedData = new ContentItemData(updatedFieldData);

        // Add detailed logging before attempting update
        logger.LogInformation(
            new EventId(0, "UPDATE_ATTEMPT"),
            "Attempting to update content item ID {ItemId} of type '{ContentType}' in language '{Language}'",
            contentItemId, contentType, languageName);

        // Try to create draft first (in case no draft exists)
        logger.LogDebug(
            new EventId(0, "CREATE_DRAFT_ATTEMPT"),
            "Creating draft for content item ID {ItemId}",
            contentItemId);

        await contentItemManager.TryCreateDraft(contentItemId, languageName, cancellationToken);

        // Check the result of TryUpdateDraft
        bool updateResult = await contentItemManager.TryUpdateDraft(
            contentItemId,
            languageName,
            updatedData,
            cancellationToken);

        if (!updateResult)
        {
            // Log detailed error when update fails
            logger.LogError(
                new EventId(0, "UPDATE_DRAFT_FAILED"),
                "TryUpdateDraft returned FALSE for content item ID {ItemId}, language '{Language}', type '{ContentType}'. " +
                "Possible causes: no draft exists, language variant missing, or invalid content item ID.",
                contentItemId, languageName, contentType);
            return; // Exit early - don't try to publish if update failed
        }

        logger.LogInformation(
            new EventId(0, "UPDATE_DRAFT_SUCCESS"),
            "Successfully updated draft for content item ID {ItemId}",
            contentItemId);

        // Check the result of TryPublish
        bool publishResult = await contentItemManager.TryPublish(
            contentItemId,
            languageName,
            cancellationToken);

        if (!publishResult)
        {
            //  Log detailed error when publish fails
            logger.LogError(
                new EventId(0, "PUBLISH_FAILED"),
                "TryPublish returned FALSE for content item ID {ItemId}, language '{Language}'. " +
                "Draft was updated but not published.",
                contentItemId, languageName);
            return; // Exit early
        }

        //  Enhanced success logging
        logger.LogInformation(
            new EventId(0, "UPDATE_SUCCESS"),
            "Successfully updated and published content item ID {ItemId} of type '{ContentType}'",
            contentItemId, contentType);

        // Invalidate cache for this content item
        CacheHelper.TouchKey($"contentitem|{contentItemId}");
        CacheHelper.TouchKey($"contenttype|{contentType}");
        
        // Also invalidate any cached items by GUID if we can retrieve it
        // This ensures the cache keys used in MappedContentItemRepository are invalidated
        try
        {
            var queryBuilder = new ContentItemQueryBuilder()
                .ForContentType(contentType, parameters =>
                {
                    parameters.TopN(1)
                        .Where(w => w.WhereEquals("ContentItemID", contentItemId))
                        .Columns(nameof(IContentItemFieldsSource.SystemFields.ContentItemGUID));
                });

            var guids = await contentQueryExecutor.GetResult(
                queryBuilder,
                rowData => rowData.ContentItemGUID,
                new ContentQueryExecutionOptions { ForPreview = false },
                cancellationToken);

            var guid = guids.FirstOrDefault();
            if (guid != Guid.Empty)
            {
                // Invalidate cache keys used in MappedContentItemRepository
                // Format: "getcontentitem|{ContentItemGuid}|{lang}"
                // We'll touch the content item cache key which should invalidate dependent caches
                CacheHelper.TouchKey($"contentitem|{contentItemId}");
            }
        }
        catch (Exception cacheEx)
        {
            // Log but don't fail the update if cache invalidation fails
            logger.LogWarning(
                new EventId(0, "CACHE_INVALIDATION_WARNING"),
                cacheEx,
                "Failed to invalidate cache for content item ID {ItemId}, but update was successful",
                contentItemId);
        }
    }
    catch (Exception ex)
    {
        logger.LogError(
            new EventId(0, "UPDATE_ERROR"),
            ex,
            "Exception while updating content item ID {ItemId} of type '{ContentType}'",
            contentItemId, contentType);
        throw;
    }
}

Thanks
Nikhila