private static readonly Synchronizer<int> Sync = new Synchronizer<int>();

...

public async Task SomeWork(SomeModel model, CancellationToken cancellationToken)
{
    // блокируем, чтобы метод выполнялся монопольно для каждого model.Id
    using(await Sync.Lock(model.Id, cancellationToken)
    {
        ...
    }
}

    public class Synchronizer<T>
    {
        private readonly object _lock = new object();
        private readonly Dictionary<T, SyncLock<T>> _syncLocks = new Dictionary<T, SyncLock<T>>();

        public async Task<IDisposable> LockAsync(T value, CancellationToken cancellationToken)
        {
            SyncLock<T> syncLock;
            lock (_lock)
            {
                if (!_syncLocks.TryGetValue(value, out syncLock))
                {
                    syncLock = new SyncLock<T>(this, value);
                    _syncLocks.Add(value, syncLock);
                }
                syncLock.Capture();
            }
            await syncLock.WaitAsync(cancellationToken).ConfigureAwait(false);
            return syncLock;
        }

        internal void Unlock(SyncLock<T> syncLock)
        {
            lock (_lock)
            {
                var capturedCount = syncLock.Release();
                if (capturedCount == 0) _syncLocks.Remove(syncLock.Value);
            }
        }
    }

    internal class SyncLock<T> : IDisposable
    {
        private readonly Synchronizer<T> _synchronizer;
        private readonly T _value;
        private readonly SemaphoreSlim _semaphore;
        private int _captureCount;


        #region Internal routines

        internal SyncLock([NotNull] Synchronizer<T> synchronizer, T value)
        {
            _synchronizer = synchronizer;
            _value = value;
            _semaphore = new SemaphoreSlim(1, 1);
        }

        internal Task WaitAsync(CancellationToken cancellationToken)
        {
            return _semaphore.WaitAsync(cancellationToken);
        }

        internal int Capture()
        {
            return ++_captureCount;
        }

        internal int Release()
        {
            _captureCount--;
            _semaphore.Release();
            return _captureCount;
        }

        #endregion


        #region Properties

        public T Value => _value;

        #endregion


        #region IDisposable

        /// <inheritdoc />
        public void Dispose()
        {
            _synchronizer.Unlock(this);
        }

        #endregion
    }

[StructLayout(LayoutKind.Explicit)]
public struct struct1
{
    [FieldOffset(0)]
    public int x; 
    [FieldOffset(64)]
    public int y; 
}

private static readonly Synchronizer<int> Sync = new Synchronizer<int>();

...

public async Task SomeWork(SomeModel model, CancellationToken cancellationToken)
{
    // получаем объект блокировки для монопольных операций по model.Id
    using(var syncLock = await Sync.GetLock(model.Id))
    {
        // блокируем
        await syncLock.WaitAsync(cancellationToken);
        // делаем свои дела
        ...
    }
}

    public class Synchronizer<T>
    {
        private readonly object _lock = new object();
        private readonly Dictionary<T, SyncLock<T>> _syncLocks = new Dictionary<T, SyncLock<T>>();

        public SyncLock<T> GetLock(T value)
        {
            lock (_lock)
            {
                if (!_syncLocks.TryGetValue(value, out var syncLock))
                {
                    syncLock = new SyncLock<T>(this, value);
                    _syncLocks.Add(value, syncLock);
                }
                syncLock.Capture();
                return syncLock;
            }
        }

        internal void Unlock(SyncLock<T> syncLock)
        {
            lock (_lock)
            {
                var capturedCount = syncLock.Release();
                if (capturedCount == 0) _syncLocks.Remove(syncLock.Value);
            }
        }
    }

    public class SyncLock<T> : IDisposable
    {
        private readonly Synchronizer<T> _synchronizer;
        private readonly T _value;
        private readonly SemaphoreSlim _semaphore;
        private int _captureCount;


        #region Internal routines

        internal SyncLock([NotNull] Synchronizer<T> synchronizer, T value)
        {
            _synchronizer = synchronizer;
            _value = value;
            _semaphore = new SemaphoreSlim(1, 1);
        }

        internal int Capture()
        {
            return ++_captureCount;
        }

        internal int Release()
        {
            _captureCount--;
            _semaphore.Release();
            return _captureCount;
        }

        #endregion


        #region Public methods

        public T Value => _value;

        public async Task WaitAsync(CancellationToken cancellationToken)
        {
            await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
            cancellationToken.ThrowIfCancellationRequested();
        }

        #endregion


        #region IDisposable

        /// <inheritdoc />
        public void Dispose()
        {
            _synchronizer.Unlock(this);
        }

        #endregion
    }