diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e7ef5b50d..f30103801a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@
 
 ### Features
 
+- Implemented instance isolation so that multiple instances of the Sentry SDK can be instantiated inside the same process when using the Caching Transport ([#4498](https://github.com/getsentry/sentry-dotnet/pull/4498))
 - The SDK now makes use of the new SessionEndStatus `Unhandled` when capturing an unhandled but non-terminal exception, i.e. through the UnobservedTaskExceptionIntegration ([#4633](https://github.com/getsentry/sentry-dotnet/pull/4633), [#4653](https://github.com/getsentry/sentry-dotnet/pull/4653))
 - The SDK now provides a `IsSessionActive` to allow checking the session state ([#4662](https://github.com/getsentry/sentry-dotnet/pull/4662))
 - The SDK now makes use of the new SessionEndStatus `Unhandled` when capturing an unhandled but non-terminal exception, i.e. through the UnobservedTaskExceptionIntegration ([#4633](https://github.com/getsentry/sentry-dotnet/pull/4633))
diff --git a/src/Sentry/GlobalSessionManager.cs b/src/Sentry/GlobalSessionManager.cs
index 8fb6cb8413..cfa27fe89b 100644
--- a/src/Sentry/GlobalSessionManager.cs
+++ b/src/Sentry/GlobalSessionManager.cs
@@ -33,10 +33,7 @@ public GlobalSessionManager(
         _clock = clock ?? SystemClock.Clock;
         _persistedSessionProvider = persistedSessionProvider
                                     ?? (filePath => Json.Load(_options.FileSystem, filePath, PersistedSessionUpdate.FromJson));
-
-        // TODO: session file should really be process-isolated, but we
-        // don't have a proper mechanism for that right now.
-        _persistenceDirectoryPath = options.TryGetDsnSpecificCacheDirectoryPath();
+        _persistenceDirectoryPath = options.GetIsolatedCacheDirectoryPath();
     }
 
     // Take pause timestamp directly instead of referencing _lastPauseTimestamp to avoid
diff --git a/src/Sentry/Internal/CacheDirectoryCoordinator.cs b/src/Sentry/Internal/CacheDirectoryCoordinator.cs
new file mode 100644
index 0000000000..3f8cb09cfd
--- /dev/null
+++ b/src/Sentry/Internal/CacheDirectoryCoordinator.cs
@@ -0,0 +1,146 @@
+using Sentry.Extensibility;
+using Sentry.Internal.Extensions;
+
+namespace Sentry.Internal;
+
+internal class CacheDirectoryCoordinator : IDisposable
+{
+    private readonly IDiagnosticLogger? _logger;
+    private readonly IFileSystem _fileSystem;
+    private readonly Lock _lock = new();
+
+    private Stream? _lockStream;
+    private readonly string _lockFilePath;
+
+    private volatile bool _acquired;
+    private volatile bool _disposed;
+
+    public CacheDirectoryCoordinator(string cacheDir, IDiagnosticLogger? logger, IFileSystem fileSystem)
+    {
+        _logger = logger;
+        _fileSystem = fileSystem;
+        // Note this creates a lock file in the cache directory's parent directory... not in the cache directory itself
+        _lockFilePath = $"{cacheDir}.lock";
+    }
+
+    public bool TryAcquire()
+    {
+        if (_acquired)
+        {
+            return true;
+        }
+
+        lock (_lock)
+        {
+            if (_acquired)
+            {
+                return true;
+            }
+
+            if (_disposed)
+            {
+                return false;
+            }
+
+            try
+            {
+                var baseDir = Path.GetDirectoryName(_lockFilePath);
+                if (!string.IsNullOrWhiteSpace(baseDir))
+                {
+                    _fileSystem.CreateDirectory(baseDir);
+                }
+                _acquired = _fileSystem.TryCreateLockFile(_lockFilePath, out _lockStream);
+                return _acquired;
+            }
+            catch (Exception ex)
+            {
+                _logger?.LogDebug("Unable to acquire cache directory lock", ex);
+            }
+            finally
+            {
+                if (!_acquired && _lockStream is not null)
+                {
+                    try
+                    { _lockStream.Dispose(); }
+                    catch
+                    {
+                        // Ignore
+                    }
+                    _lockStream = null;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        lock (_lock)
+        {
+            _disposed = true;
+
+            if (_acquired)
+            {
+                try
+                {
+                    _lockStream?.Close();
+                }
+                catch (Exception ex)
+                {
+                    _logger?.LogError("Error releasing the cache directory file lock.", ex);
+                }
+            }
+
+            try
+            {
+                _lockStream?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                _logger?.LogError("Error disposing cache lock stream.", ex);
+            }
+            _lockStream = null;
+        }
+    }
+}
+
+internal static class CacheDirectoryHelper
+{
+    public const string IsolatedCacheDirectoryPrefix = "isolated_";
+
+    internal static string? GetBaseCacheDirectoryPath(this SentryOptions options) =>
+        string.IsNullOrWhiteSpace(options.CacheDirectoryPath)
+            ? null
+            : Path.Combine(options.CacheDirectoryPath, "Sentry");
+
+    internal static string? GetIsolatedFolderName(this SentryOptions options)
+    {
+        var stringBuilder = new StringBuilder(IsolatedCacheDirectoryPrefix);
+#if IOS || ANDROID
+        // On iOS or Android the app is already sandboxed, so there's no risk of sending data to another Sentry's DSN.
+        // However, users may still initiate the SDK multiple times within the process, so we need an InitCounter
+        stringBuilder.Append(options.InitCounter.Count);
+#else
+        if (string.IsNullOrWhiteSpace(options.Dsn))
+        {
+            return null;
+        }
+        var processId = options.ProcessIdResolver.Invoke() ?? 0;
+        stringBuilder.AppendJoin('_', options.Dsn.GetHashString(), processId.ToString(),
+            options.InitCounter.Count.ToString());
+#endif
+        return stringBuilder.ToString();
+    }
+
+    internal static string? GetIsolatedCacheDirectoryPath(this SentryOptions options) =>
+        GetBaseCacheDirectoryPath(options) is not { } baseCacheDir
+        || GetIsolatedFolderName(options) is not { } isolatedFolderName
+            ? null
+            : Path.Combine(baseCacheDir, isolatedFolderName);
+}
diff --git a/src/Sentry/Internal/FileSystemBase.cs b/src/Sentry/Internal/FileSystemBase.cs
index 60b474a668..9e377d9836 100644
--- a/src/Sentry/Internal/FileSystemBase.cs
+++ b/src/Sentry/Internal/FileSystemBase.cs
@@ -2,6 +2,9 @@ namespace Sentry.Internal;
 
 internal abstract class FileSystemBase : IFileSystem
 {
+    public IEnumerable<string> EnumerateDirectories(string path, string searchPattern) =>
+        Directory.EnumerateDirectories(path, searchPattern);
+
     public IEnumerable<string> EnumerateFiles(string path) => Directory.EnumerateFiles(path);
 
     public IEnumerable<string> EnumerateFiles(string path, string searchPattern) =>
@@ -23,6 +26,7 @@ public IEnumerable<string> EnumerateFiles(string path, string searchPattern, Sea
     public abstract bool CreateDirectory(string path);
     public abstract bool DeleteDirectory(string path, bool recursive = false);
     public abstract bool CreateFileForWriting(string path, out Stream fileStream);
+    public abstract bool TryCreateLockFile(string path, out Stream fileStream);
     public abstract bool WriteAllTextToFile(string path, string contents);
     public abstract bool MoveFile(string sourceFileName, string destFileName, bool overwrite = false);
     public abstract bool DeleteFile(string path);
diff --git a/src/Sentry/Internal/Http/CachingTransport.cs b/src/Sentry/Internal/Http/CachingTransport.cs
index f2117f60b2..ebb4c9dab4 100644
--- a/src/Sentry/Internal/Http/CachingTransport.cs
+++ b/src/Sentry/Internal/Http/CachingTransport.cs
@@ -5,26 +5,35 @@
 namespace Sentry.Internal.Http;
 
 /// <summary>
-/// A transport that caches envelopes to disk and sends them in the background.
+/// Transport that caches envelopes to disk and sends them in the background.
 /// </summary>
 /// <remarks>
+/// <para>
 /// Note although this class has a <see cref="CachingTransport.DisposeAsync"/>
 /// method, it doesn't implement <see cref="IAsyncDisposable"/> as this caused
 /// a dependency issue with Log4Net in some situations.
-///
-/// See https://github.com/getsentry/sentry-dotnet/issues/3178
+/// </para>
+/// <para>See https://github.com/getsentry/sentry-dotnet/issues/3178</para>
 /// </remarks>
 internal class CachingTransport : ITransport, IDisposable
 {
+    internal const int ResultMigrationOk = 0;
+    internal const int ResultMigrationNoBaseCacheDir = 1;
+    internal const int ResultMigrationAlreadyMigrated = 2;
+    internal const int ResultMigrationLockNotAcquired = 3;
+    internal const int ResultMigrationCancelled = 4;
+
     private const string EnvelopeFileExt = "envelope";
     private const string ProcessingFolder = "__processing";
 
     private readonly ITransport _innerTransport;
     private readonly SentryOptions _options;
     private readonly bool _failStorage;
-    private readonly string _isolatedCacheDirectoryPath;
     private readonly int _keepCount;
 
+    private readonly CacheDirectoryCoordinator _cacheCoordinator;
+    private readonly string _isolatedCacheDirectoryPath;
+
     // When a file is getting processed, it's moved to a child directory
     // to avoid getting picked up by other threads.
     private readonly string _processingDirectoryPath;
@@ -45,6 +54,7 @@ internal class CachingTransport : ITransport, IDisposable
 
     private readonly CancellationTokenSource _workerCts = new();
     private Task _worker = null!;
+    private Task? _recycler = null;
 
     private ManualResetEventSlim? _initCacheResetEvent = new();
     private ManualResetEventSlim? _preInitCacheResetEvent = new();
@@ -75,8 +85,13 @@ private CachingTransport(ITransport innerTransport, SentryOptions options, bool
             : 0; // just in case MaxCacheItems is set to an invalid value somehow (shouldn't happen)
 
         _isolatedCacheDirectoryPath =
-            options.TryGetProcessSpecificCacheDirectoryPath() ??
+            options.GetIsolatedCacheDirectoryPath() ??
             throw new InvalidOperationException("Cache directory or DSN is not set.");
+        _cacheCoordinator = new CacheDirectoryCoordinator(_isolatedCacheDirectoryPath, options.DiagnosticLogger, options.FileSystem);
+        if (!_cacheCoordinator.TryAcquire())
+        {
+            throw new InvalidOperationException("Cache directory already locked.");
+        }
 
         // Sanity check: This should never happen in the first place.
         // We check for `DisableFileWrite` before creating the CachingTransport.
@@ -90,15 +105,19 @@ private void Initialize(bool startWorker)
         // Restore any abandoned files from a previous session
         MoveUnprocessedFilesBackToCache();
 
-        // Ensure directories exist
-        _fileSystem.CreateDirectory(_isolatedCacheDirectoryPath);
         _fileSystem.CreateDirectory(_processingDirectoryPath);
 
-        // Start a worker, if one is needed
         if (startWorker)
         {
             _options.LogDebug("Starting CachingTransport worker.");
             _worker = Task.Run(CachedTransportBackgroundTaskAsync);
+
+            // Start a recycler in the background so as not to block initialisation
+            _recycler = Task.Run(() =>
+            {
+                SalvageAbandonedCacheSessions(_workerCts.Token);
+                MigrateVersion5Cache(_workerCts.Token);
+            }, _workerCts.Token);
         }
         else
         {
@@ -178,6 +197,48 @@ private async Task CachedTransportBackgroundTaskAsync()
         _options.LogDebug("CachingTransport worker stopped.");
     }
 
+    internal void SalvageAbandonedCacheSessions(CancellationToken cancellationToken)
+    {
+        if (_options.GetBaseCacheDirectoryPath() is not { } baseCacheDir)
+        {
+            return;
+        }
+
+        const string searchPattern = $"{CacheDirectoryHelper.IsolatedCacheDirectoryPrefix}*";
+        foreach (var dir in _fileSystem.EnumerateDirectories(baseCacheDir, searchPattern))
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return; // graceful exit on cancellation
+            }
+
+            if (string.Equals(dir, _isolatedCacheDirectoryPath, StringComparison.OrdinalIgnoreCase))
+            {
+                continue; // Ignore the current cache directory
+            }
+
+            _options.LogDebug("Found abandoned cache: {0}", dir);
+            using var coordinator = new CacheDirectoryCoordinator(dir, _options.DiagnosticLogger, _options.FileSystem);
+            if (!coordinator.TryAcquire())
+            {
+                continue;
+            }
+
+            _options.LogDebug("Salvaging abandoned cache: {0}", dir);
+            foreach (var filePath in _fileSystem.EnumerateFiles(dir, "*.envelope", SearchOption.AllDirectories))
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return; // graceful exit on cancellation
+                }
+
+                var destinationPath = Path.Combine(_isolatedCacheDirectoryPath, Path.GetFileName(filePath));
+                _options.LogDebug("Moving abandoned file back to cache: {0} to {1}.", filePath, destinationPath);
+                MoveFileWithRetries(filePath, destinationPath, "abandoned");
+            }
+        }
+    }
+
     private void MoveUnprocessedFilesBackToCache()
     {
         // Processing directory may already contain some files left from previous session
@@ -194,42 +255,106 @@ private void MoveUnprocessedFilesBackToCache()
         {
             var destinationPath = Path.Combine(_isolatedCacheDirectoryPath, Path.GetFileName(filePath));
             _options.LogDebug("Moving unprocessed file back to cache: {0} to {1}.", filePath, destinationPath);
+            MoveFileWithRetries(filePath, destinationPath, "unprocessed");
+        }
+    }
+
+    /// <summary>
+    /// When migrating from version 5 to version 6, the cache directory structure changed.
+    /// In version 5, there were no isolated subdirectories.
+    /// </summary>
+    /// <param name="cancellationToken"></param>
+    /// <returns>An integer return code to facilitate testing.</returns>
+    internal int MigrateVersion5Cache(CancellationToken cancellationToken)
+    {
+        if (_options.GetBaseCacheDirectoryPath() is not { } baseCacheDir)
+        {
+            return ResultMigrationNoBaseCacheDir;
+        }
 
-            const int maxAttempts = 3;
-            for (var attempt = 1; attempt <= maxAttempts; attempt++)
+        // This code needs to execute only once during the first initialization of version 6.
+        var markerFile = Path.Combine(baseCacheDir, ".migrated");
+        if (_fileSystem.FileExists(markerFile))
+        {
+            return ResultMigrationAlreadyMigrated;
+        }
+
+        var migrationLock = Path.Combine(baseCacheDir, "migration");
+        using var coordinator = new CacheDirectoryCoordinator(migrationLock, _options.DiagnosticLogger, _options.FileSystem);
+        if (!coordinator.TryAcquire())
+        {
+            return ResultMigrationLockNotAcquired;
+        }
+
+        const string searchPattern = $"*.{EnvelopeFileExt}";
+        var processingDirectoryPath = Path.Combine(baseCacheDir, ProcessingFolder);
+        foreach (var cacheDir in new[] { baseCacheDir, processingDirectoryPath })
+        {
+            if (cancellationToken.IsCancellationRequested)
             {
-                try
+                return ResultMigrationCancelled; // graceful exit on cancellation
+            }
+
+            if (!_fileSystem.DirectoryExists(cacheDir))
+            {
+                continue;
+            }
+
+            foreach (var filePath in _fileSystem.EnumerateFiles(cacheDir, searchPattern, SearchOption.TopDirectoryOnly))
+            {
+                if (cancellationToken.IsCancellationRequested)
                 {
-                    _fileSystem.MoveFile(filePath, destinationPath);
-                    break;
+                    return ResultMigrationCancelled; // graceful exit on cancellation
                 }
-                catch (Exception ex)
-                {
-                    if (!_fileSystem.FileExists(filePath))
-                    {
-                        _options.LogDebug(
-                            "Failed to move unprocessed file back to cache (attempt {0}), " +
-                            "but the file no longer exists so it must have been handled by another process: {1}",
-                            attempt, filePath);
-                        break;
-                    }
 
-                    if (attempt < maxAttempts)
-                    {
-                        _options.LogDebug(
-                            "Failed to move unprocessed file back to cache (attempt {0}, retrying.): {1}",
-                            attempt, filePath);
+                var destinationPath = Path.Combine(_isolatedCacheDirectoryPath, Path.GetFileName(filePath));
+                _options.LogDebug("Migrating version 5 cache file: {0} to {1}.", filePath, destinationPath);
+                MoveFileWithRetries(filePath, destinationPath, "version 5");
+            }
+        }
 
-                        Thread.Sleep(200); // give a small bit of time before retry
-                    }
-                    else
-                    {
-                        _options.LogError(ex,
-                            "Failed to move unprocessed file back to cache (attempt {0}, done.): {1}", attempt, filePath);
-                    }
+        // Leave a marker file so we don't try to migrate again
+        _fileSystem.WriteAllTextToFile(markerFile, "6.0.0");
+        return ResultMigrationOk;
+    }
+
+    private void MoveFileWithRetries(string filePath, string destinationPath, string moveType)
+    {
+        const int maxAttempts = 3;
+        for (var attempt = 1; attempt <= maxAttempts; attempt++)
+        {
+            try
+            {
+                _fileSystem.MoveFile(filePath, destinationPath);
+
+                break;
+            }
+            catch (Exception ex)
+            {
+                if (!_fileSystem.FileExists(filePath))
+                {
+                    _options.LogDebug(
+                        "Failed to move {2} file back to cache (attempt {0}), " +
+                        "but the file no longer exists so it must have been handled by another process: {1}",
+                        attempt, filePath, moveType);
+                    break;
+                }
+
+                if (attempt < maxAttempts)
+                {
+                    _options.LogDebug(
+                        "Failed to move {2} file back to cache (attempt {0}, retrying.): {1}",
+                        attempt, filePath, moveType);
 
-                    // note: we do *not* want to re-throw the exception
+                    Thread.Sleep(200); // give a small bit of time before retry
+                }
+                else
+                {
+                    _options.LogError(ex,
+                        "Failed to move {2} file back to cache (attempt {0}, done.): {1}", attempt, filePath, moveType);
                 }
+
+                // note: we do *not* want to re-throw the exception
             }
         }
     }
@@ -278,7 +403,7 @@ private async Task ProcessCacheAsync(CancellationToken cancellation)
 
             // Make sure no files got stuck in the processing directory
             // See https://github.com/getsentry/sentry-dotnet/pull/3438#discussion_r1672524426
-            if (_options.NetworkStatusListener is { Online: false } listener)
+            if (_options.NetworkStatusListener is { Online: false })
             {
                 MoveUnprocessedFilesBackToCache();
             }
@@ -539,6 +664,19 @@ public Task StopWorkerAsync()
         return _worker;
     }
 
+    private Task StopRecyclerAsync()
+    {
+        if (_recycler?.IsCompleted != false)
+        {
+            // already stopped
+            return Task.CompletedTask;
+        }
+
+        _options.LogDebug("Stopping CachingTransport worker.");
+        _workerCts.Cancel();
+        return _recycler;
+    }
+
     public Task FlushAsync(CancellationToken cancellationToken = default)
     {
         _options.LogDebug("CachingTransport received request to flush the cache.");
@@ -557,10 +695,21 @@ public async ValueTask DisposeAsync()
             _options.LogError(ex, "Error stopping worker during dispose.");
         }
 
+        try
+        {
+            await StopRecyclerAsync().ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _options.LogError(ex, "Error in recycler during dispose.");
+        }
+
         _workerSignal.Dispose();
         _workerCts.Dispose();
         _worker.Dispose();
+        _recycler?.Dispose();
         _cacheDirectoryLock.Dispose();
+        _cacheCoordinator.Dispose();
         _preInitCacheResetEvent?.Dispose();
         _initCacheResetEvent?.Dispose();
 
diff --git a/src/Sentry/Internal/IFileSystem.cs b/src/Sentry/Internal/IFileSystem.cs
index 366bf70583..dd44d67b84 100644
--- a/src/Sentry/Internal/IFileSystem.cs
+++ b/src/Sentry/Internal/IFileSystem.cs
@@ -10,6 +10,7 @@ internal interface IFileSystem
     // Note: This is not comprehensive.  If you need other filesystem methods, add to this interface,
     // then implement in both Sentry.Internal.FileSystem and Sentry.Testing.FakeFileSystem.
 
+    public IEnumerable<string> EnumerateDirectories(string path, string searchPattern);
     public IEnumerable<string> EnumerateFiles(string path);
     public IEnumerable<string> EnumerateFiles(string path, string searchPattern);
     public IEnumerable<string> EnumerateFiles(string path, string searchPattern, SearchOption searchOption);
@@ -22,6 +23,7 @@ internal interface IFileSystem
     public bool CreateDirectory(string path);
     public bool DeleteDirectory(string path, bool recursive = false);
     public bool CreateFileForWriting(string path, out Stream fileStream);
+    public bool TryCreateLockFile(string path, out Stream fileStream);
     public bool WriteAllTextToFile(string path, string contents);
     public bool MoveFile(string sourceFileName, string destFileName, bool overwrite = false);
     public bool DeleteFile(string path);
diff --git a/src/Sentry/Internal/InitCounter.cs b/src/Sentry/Internal/InitCounter.cs
new file mode 100644
index 0000000000..57155a9dc8
--- /dev/null
+++ b/src/Sentry/Internal/InitCounter.cs
@@ -0,0 +1,23 @@
+namespace Sentry.Internal;
+
+/// <summary>
+/// This is used internally to track the number of times the SDK has been initialised so that different
+/// Hub instances get a different cache directory path, even if they're running in the same process.
+/// </summary>
+internal interface IInitCounter
+{
+    public int Count { get; }
+    public void Increment();
+}
+
+/// <inheritdoc cref="IInitCounter"/>
+internal class InitCounter : IInitCounter
+{
+    internal static InitCounter Instance { get; } = new();
+
+    private int _count;
+
+    public int Count => Volatile.Read(ref _count);
+
+    public void Increment() => Interlocked.Increment(ref _count);
+}
diff --git a/src/Sentry/Internal/Polyfills.cs b/src/Sentry/Internal/Polyfills.cs
index 2113687f8d..4666a1f568 100644
--- a/src/Sentry/Internal/Polyfills.cs
+++ b/src/Sentry/Internal/Polyfills.cs
@@ -1,5 +1,9 @@
 // Polyfills to bridge the missing APIs in older targets.
 
+#if !NET9_0_OR_GREATER
+global using Lock = object;
+#endif
+
 #if NETFRAMEWORK || NETSTANDARD2_0
 namespace System
 {
@@ -9,6 +13,32 @@ internal static class HashCode
         public static int Combine<T1, T2, T3>(T1 value1, T2 value2, T3 value3) => (value1, value2, value3).GetHashCode();
     }
 }
+
+internal static partial class PolyfillExtensions
+{
+    public static StringBuilder AppendJoin(this StringBuilder builder, char separator, params object?[] values)
+    {
+        if (values.Length == 0)
+        {
+            return builder;
+        }
+
+        if (values[0] is {} value)
+        {
+            builder.Append(value);
+        }
+
+        for (var i = 1; i < values.Length; i++)
+        {
+            builder.Append(separator);
+            if (values[i] is {} nextValue)
+            {
+                builder.Append(nextValue);
+            }
+        }
+        return builder;
+    }
+}
 #endif
 
 #if NETFRAMEWORK
diff --git a/src/Sentry/Internal/ReadOnlyFilesystem.cs b/src/Sentry/Internal/ReadOnlyFilesystem.cs
index a5972b58f3..c71792b569 100644
--- a/src/Sentry/Internal/ReadOnlyFilesystem.cs
+++ b/src/Sentry/Internal/ReadOnlyFilesystem.cs
@@ -17,6 +17,12 @@ public override bool CreateFileForWriting(string path, out Stream fileStream)
         return false;
     }
 
+    public override bool TryCreateLockFile(string path, out Stream fileStream)
+    {
+        fileStream = Stream.Null;
+        return false;
+    }
+
     public override bool WriteAllTextToFile(string path, string contents) => false;
 
     public override bool MoveFile(string sourceFileName, string destFileName, bool overwrite = false) => false;
diff --git a/src/Sentry/Internal/ReadWriteFileSystem.cs b/src/Sentry/Internal/ReadWriteFileSystem.cs
index 6a9a08c2a3..ed4b58f496 100644
--- a/src/Sentry/Internal/ReadWriteFileSystem.cs
+++ b/src/Sentry/Internal/ReadWriteFileSystem.cs
@@ -25,6 +25,26 @@ public override bool CreateFileForWriting(string path, out Stream fileStream)
         return true;
     }
 
+    /// <summary>
+    /// Tries to create or open a file for exclusive access.
+    /// </summary>
+    /// <remarks>
+    /// This method can throw all of the same exceptions that the <see cref="FileStream"/> constructor can throw. The
+    /// caller is responsible for handling those exceptions.
+    /// </remarks>
+    public override bool TryCreateLockFile(string path, out Stream fileStream)
+    {
+        // Note that FileShare.None is implemented via advisory locks only on macOS/Linux... so it will stop
+        // other .NET processes from accessing the file but not other non-.NET processes. This should be fine
+        // in our case - we just want to avoid multiple instances of the SDK concurrently accessing the cache
+        fileStream = new FileStream(
+            path,
+            FileMode.OpenOrCreate,
+            FileAccess.ReadWrite,
+            FileShare.None);
+        return true;
+    }
+
     public override bool WriteAllTextToFile(string path, string contents)
     {
         File.WriteAllText(path, contents);
diff --git a/src/Sentry/Sentry.csproj b/src/Sentry/Sentry.csproj
index ed8451dbfa..dfcc6310f5 100644
--- a/src/Sentry/Sentry.csproj
+++ b/src/Sentry/Sentry.csproj
@@ -83,7 +83,7 @@
 
   <!-- Ensure at least version 6 of System.Text.Json so we have JsonSerializationContext available -->
   <ItemGroup Condition="$(TargetFramework.StartsWith('net4')) or $(TargetFramework.StartsWith('netstandard'))">
-    <PackageReference Include="System.Text.Json" Version="6.0.10" >
+    <PackageReference Include="System.Text.Json" Version="8.0.5" >
       <!--
         Ignoring the vulnerability warning: https://github.com/advisories/GHSA-hh2w-p6rv-4g7w
         The app can/should pin to the latest version. We will bump once a patch on v6 (still LTS until Nov 24) is out
diff --git a/src/Sentry/SentryOptions.cs b/src/Sentry/SentryOptions.cs
index f3ad6710a1..00ab2f1cba 100644
--- a/src/Sentry/SentryOptions.cs
+++ b/src/Sentry/SentryOptions.cs
@@ -814,6 +814,24 @@ public IDiagnosticLogger? DiagnosticLogger
     /// </summary>
     public string? CacheDirectoryPath { get; set; }
 
+    internal Func<int?> ProcessIdResolver
+    {
+        set => _processIdResolver = value;
+        get
+        {
+            return _processIdResolver ?? DefaultResolver;
+            int? DefaultResolver() => ProcessInfo.Instance?.GetId(this);
+        }
+    }
+    private Func<int?>? _processIdResolver;
+
+    internal IInitCounter InitCounter
+    {
+        get => _initCounter ?? Sentry.Internal.InitCounter.Instance;
+        set => _initCounter = value;
+    }
+    private IInitCounter? _initCounter;
+
     /// <summary>
     /// <para>The SDK will only capture HTTP Client errors if it is enabled.</para>
     /// <para><see cref="FailedRequestStatusCodes"/> can be used to configure which requests will be treated as failed.</para>
@@ -1834,31 +1852,6 @@ internal void SetupLogging()
         }
     }
 
-    internal string? TryGetDsnSpecificCacheDirectoryPath()
-    {
-        if (string.IsNullOrWhiteSpace(CacheDirectoryPath))
-        {
-            return null;
-        }
-
-        // DSN must be set to use caching
-        if (string.IsNullOrWhiteSpace(Dsn))
-        {
-            return null;
-        }
-#if IOS || ANDROID // on iOS or Android the app is already sandboxed so there's no risk of sending data from 1 app to another Sentry's DSN
-        return Path.Combine(CacheDirectoryPath, "Sentry");
-#else
-        return Path.Combine(CacheDirectoryPath, "Sentry", Dsn.GetHashString());
-#endif
-    }
-
-    internal string? TryGetProcessSpecificCacheDirectoryPath()
-    {
-        // In the future, this will most likely contain process ID
-        return TryGetDsnSpecificCacheDirectoryPath();
-    }
-
     internal static List<StringOrRegex> GetDefaultInAppExclude() =>
     [
         "System",
diff --git a/src/Sentry/SentrySdk.cs b/src/Sentry/SentrySdk.cs
index 10b5678d87..ee64c719de 100644
--- a/src/Sentry/SentrySdk.cs
+++ b/src/Sentry/SentrySdk.cs
@@ -30,6 +30,8 @@ static partial class SentrySdk
 
     internal static IHub InitHub(SentryOptions options)
     {
+        options.InitCounter.Increment();
+
         options.SetupLogging();
 
         ProcessInfo.Instance ??= new ProcessInfo(options);
diff --git a/test/Sentry.Maui.Tests/SentryMauiAppBuilderExtensionsTests.cs b/test/Sentry.Maui.Tests/SentryMauiAppBuilderExtensionsTests.cs
index c3fac5e100..c464b2ec53 100644
--- a/test/Sentry.Maui.Tests/SentryMauiAppBuilderExtensionsTests.cs
+++ b/test/Sentry.Maui.Tests/SentryMauiAppBuilderExtensionsTests.cs
@@ -267,6 +267,10 @@ public void UseSentry_WithCaching_CanChangeCacheDirectoryPath()
 
         // Assert
         Assert.Equal(cachePath, options.CacheDirectoryPath);
+        if (options.Transport is CachingTransport cachingTransport)
+        {
+            cachingTransport.Dispose(); // Release cache lock so that the cacheDirectory can be removed
+        }
     }
 
     [Fact]
diff --git a/test/Sentry.Testing/FakeFileSystem.cs b/test/Sentry.Testing/FakeFileSystem.cs
index 0b6c3ad94a..cfc98796e3 100644
--- a/test/Sentry.Testing/FakeFileSystem.cs
+++ b/test/Sentry.Testing/FakeFileSystem.cs
@@ -6,6 +6,9 @@ internal class FakeFileSystem : IFileSystem
 {
     private readonly MockFileSystem _fileSystem = new();
 
+    public IEnumerable<string> EnumerateDirectories(string path, string searchPattern) =>
+        _fileSystem.Directory.EnumerateDirectories(path, searchPattern);
+
     public IEnumerable<string> EnumerateFiles(string path) => _fileSystem.Directory.EnumerateFiles(path);
 
     public IEnumerable<string> EnumerateFiles(string path, string searchPattern) =>
@@ -30,6 +33,16 @@ public bool CreateDirectory(string path)
         return _fileSystem.Directory.Exists(path);
     }
 
+    public bool TryCreateLockFile(string path, out Stream fileStream)
+    {
+        fileStream = _fileSystem.FileStream.New(
+            path,
+            FileMode.OpenOrCreate,
+            FileAccess.ReadWrite,
+            FileShare.None);
+        return true;
+    }
+
     public bool DeleteDirectory(string path, bool recursive = false)
     {
         _fileSystem.Directory.Delete(path, recursive);
diff --git a/test/Sentry.Tests/HubTests.cs b/test/Sentry.Tests/HubTests.cs
index 17c3474705..86edf944ab 100644
--- a/test/Sentry.Tests/HubTests.cs
+++ b/test/Sentry.Tests/HubTests.cs
@@ -2,6 +2,7 @@
 using Sentry.Internal.Http;
 using Sentry.Protocol;
 using Sentry.Tests.Internals;
+using Sentry.Tests.Internals.Http;
 
 namespace Sentry.Tests;
 
@@ -2400,6 +2401,10 @@ public async Task FlushOnDispose_SendsEnvelope(bool cachingEnabled)
         await transport.Received(1)
             .SendEnvelopeAsync(Arg.Is<Envelope>(env => (string)env.Header["event_id"] == id.ToString()),
                 Arg.Any<CancellationToken>());
+        if (options.Transport is CachingTransport cachingTransport)
+        {
+            await cachingTransport.DisposeAsync(); // Release cache lock so that the cacheDirectory can be removed
+        }
     }
 
     private static Scope GetCurrentScope(Hub hub) => hub.ScopeManager.GetCurrent().Key;
diff --git a/test/Sentry.Tests/Internals/CacheDirectoryCoordinatorTests.cs b/test/Sentry.Tests/Internals/CacheDirectoryCoordinatorTests.cs
new file mode 100644
index 0000000000..3d40483b4c
--- /dev/null
+++ b/test/Sentry.Tests/Internals/CacheDirectoryCoordinatorTests.cs
@@ -0,0 +1,99 @@
+namespace Sentry.Tests.Internals;
+
+public class CacheDirectoryCoordinatorTests : IDisposable
+{
+    private readonly Fixture _fixture = new();
+
+    public void Dispose()
+    {
+        _fixture.CacheRoot.Dispose();
+    }
+
+    private class Fixture
+    {
+        public readonly TempDirectory CacheRoot = new();
+        public ReadWriteFileSystem FileSystem { get; } = new();
+
+        public string CacheDirectoryPath { get; private set; }
+        private readonly string _isolatedDirectory = Guid.NewGuid().ToString("N");
+
+        public CacheDirectoryCoordinator GetSut()
+        {
+            CacheDirectoryPath = Path.Combine(CacheRoot.Path, _isolatedDirectory);
+            return new(CacheDirectoryPath, null, FileSystem);
+        }
+    }
+
+    [Fact]
+    public void TryAcquire_FirstTime_ReturnsTrueAndCreatesLockFile()
+    {
+        // Arrange
+        using var coordinator = _fixture.GetSut();
+
+        // Act
+        var acquired = coordinator.TryAcquire();
+
+        // Assert
+        Assert.True(acquired);
+        Assert.True(_fixture.FileSystem.FileExists(_fixture.CacheDirectoryPath + ".lock"));
+    }
+
+    [Fact]
+    public void TryAcquire_TwiceOnSameCoordinator_IdempotentTrue()
+    {
+        // Arrange
+        using var coordinator = _fixture.GetSut();
+
+        // Act
+        Assert.True(coordinator.TryAcquire());
+        Assert.True(coordinator.TryAcquire());
+    }
+
+    [Fact]
+    public void TryAcquire_Locked_Fails()
+    {
+        // Arrange
+        using var c1 = _fixture.GetSut();
+        using var c2 = _fixture.GetSut();
+        Assert.True(c1.TryAcquire());
+
+        // Act & Assert
+        Assert.False(c2.TryAcquire());
+    }
+
+    [Fact]
+    public void TryAcquire_AfterReleasedSut_Succeeds()
+    {
+        // Arrange
+        var c1 = _fixture.GetSut();
+        Assert.True(c1.TryAcquire());
+        c1.Dispose();
+
+        // Act & Assert
+        using var c3 = _fixture.GetSut();
+        Assert.True(c3.TryAcquire());
+    }
+
+    [Fact]
+    public void TryAcquire_AfterDispose_ReturnsFalse()
+    {
+        // Arrange
+        var coordinator = _fixture.GetSut();
+        coordinator.Dispose();
+
+        // Act & Assert
+        Assert.False(coordinator.TryAcquire());
+    }
+
+    [Fact]
+    public void Dispose_CanBeCalledMultipleTimes_NoThrow()
+    {
+        // Arrange
+        var coordinator = _fixture.GetSut();
+        coordinator.TryAcquire();
+
+        // Act & Assert
+        coordinator.Dispose();
+        coordinator.Dispose();
+    }
+}
diff --git a/test/Sentry.Tests/Internals/Http/CachingTransportTests.cs b/test/Sentry.Tests/Internals/Http/CachingTransportTests.cs
index 4eb29f4290..dc5922fb84 100644
--- a/test/Sentry.Tests/Internals/Http/CachingTransportTests.cs
+++ b/test/Sentry.Tests/Internals/Http/CachingTransportTests.cs
@@ -1,4 +1,3 @@
-using System.IO.Abstractions.TestingHelpers;
 using Sentry.Internal.Http;
 
 namespace Sentry.Tests.Internals.Http;
@@ -223,6 +222,7 @@ public async Task AwareOfExistingFiles()
 
         // Move them all to processing and leave them there (due to FakeFailingTransport)
         await initialTransport.FlushAsync();
+        await initialTransport.DisposeAsync();
 
         // Act
 
@@ -242,7 +242,7 @@ public async Task Handle_Malformed_Envelopes_Gracefully()
     {
         // Arrange
         var cacheDirectoryPath =
-            _options.TryGetProcessSpecificCacheDirectoryPath() ??
+            _options.GetIsolatedCacheDirectoryPath() ??
             throw new InvalidOperationException("Cache directory or DSN is not set.");
         var processingDirectoryPath = Path.Combine(cacheDirectoryPath, "__processing");
         var fileName = $"{Guid.NewGuid()}.envelope";
@@ -623,11 +623,235 @@ public async Task DoesntWriteSentAtHeaderToCacheFile()
         await transport.SendEnvelopeAsync(envelope);
 
         // Assert
+        var isolatedCacheDir = _options.GetIsolatedCacheDirectoryPath();
         var filePath = _options.FileSystem
-            .EnumerateFiles(_options.CacheDirectoryPath!, "*", SearchOption.AllDirectories)
+            .EnumerateFiles(isolatedCacheDir!, "*", SearchOption.AllDirectories)
             .Single();
 
         var contents = _options.FileSystem.ReadAllTextFromFile(filePath);
         Assert.DoesNotContain("sent_at", contents);
     }
+
+    [Fact]
+    public async Task SalvageAbandonedCacheSessions_MovesEnvelopesFromOtherIsolatedDirectories()
+    {
+        // Arrange
+        using var innerTransport = new FakeTransport();
+        await using var transport = CachingTransport.Create(innerTransport, _options, startWorker: false);
+
+        var currentIsolated = _options.GetIsolatedCacheDirectoryPath()!; // already validated during creation
+        var baseCacheDir = Directory.GetParent(currentIsolated)!.FullName;
+
+        // Create two abandoned isolated cache directories with envelope files (including in nested folder)
+        void CreateAbandonedDir(int index)
+        {
+            var abandoned = Path.Combine(baseCacheDir, $"isolated_abandoned_{index}");
+            _options.FileSystem.CreateDirectory(abandoned);
+            var nested = Path.Combine(abandoned, "nested");
+            _options.FileSystem.CreateDirectory(nested);
+
+            // root file
+            var rootFile = Path.Combine(abandoned, $"root_{index}.envelope");
+            _options.FileSystem.WriteAllTextToFile(rootFile, "dummy content");
+            // nested file
+            var nestedFile = Path.Combine(nested, $"nested_{index}.envelope");
+            _options.FileSystem.WriteAllTextToFile(nestedFile, "dummy content");
+        }
+
+        CreateAbandonedDir(1);
+        CreateAbandonedDir(2);
+
+        // Act
+        transport.SalvageAbandonedCacheSessions(CancellationToken.None);
+
+        // Assert: All *.envelope files from abandoned dirs should now reside in the current isolated cache directory root
+        var movedFiles = _options.FileSystem
+            .EnumerateFiles(currentIsolated, "*.envelope", SearchOption.TopDirectoryOnly)
+            .Select(Path.GetFileName)
+            .ToArray();
+
+        movedFiles.Should().Contain(new[] { "root_1.envelope", "nested_1.envelope", "root_2.envelope", "nested_2.envelope" });
+
+        // Ensure abandoned directories no longer contain those files
+        var abandonedResidual = _options.FileSystem
+            .EnumerateFiles(baseCacheDir, "*.envelope", SearchOption.AllDirectories)
+            .Where(p => !p.StartsWith(currentIsolated, StringComparison.OrdinalIgnoreCase))
+            .ToArray();
+        abandonedResidual.Should().BeEmpty();
+    }
+
+    [Fact]
+    public async Task SalvageAbandonedCacheSessions_CurrentDirectory_Skipped()
+    {
+        // Arrange
+        using var innerTransport = new FakeTransport();
+        await using var transport = CachingTransport.Create(innerTransport, _options, startWorker: false);
+        var currentIsolated = _options.GetIsolatedCacheDirectoryPath()!;
+
+        var currentFile = Path.Combine(currentIsolated, "current.envelope");
+        _options.FileSystem.WriteAllTextToFile(currentFile, "dummy content");
+
+        // Act
+        transport.SalvageAbandonedCacheSessions(CancellationToken.None);
+
+        // Assert: File created in current directory should remain untouched
+        _options.FileSystem.FileExists(currentFile).Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task SalvageAbandonedCacheSessions_ActiveLock_Skipped()
+    {
+        // Arrange
+        using var innerTransport = new FakeTransport();
+        await using var transport = CachingTransport.Create(innerTransport, _options, startWorker: false);
+
+        var currentIsolated = _options.GetIsolatedCacheDirectoryPath()!;
+        var baseCacheDir = Directory.GetParent(currentIsolated)!.FullName;
+
+        // Create an abandoned directory that matches the search pattern and acquire its lock
+        var lockedDir = Path.Combine(baseCacheDir, "isolated_locked");
+        _options.FileSystem.CreateDirectory(lockedDir);
+        var lockedEnvelope = Path.Combine(lockedDir, "locked.envelope");
+        _options.FileSystem.WriteAllTextToFile(lockedEnvelope, "dummy content");
+
+        // Acquire the lock so salvage can't take it
+        using (var coordinator = new CacheDirectoryCoordinator(lockedDir, _options.DiagnosticLogger, _options.FileSystem))
+        {
+            var acquired = coordinator.TryAcquire();
+            acquired.Should().BeTrue("test must hold the lock to validate skip behavior");
+
+            // Act
+            transport.SalvageAbandonedCacheSessions(CancellationToken.None);
+
+            // Assert: File should still be in locked abandoned directory and not in current directory
+            _options.FileSystem.FileExists(lockedEnvelope).Should().BeTrue();
+            var moved = _options.FileSystem
+                .EnumerateFiles(currentIsolated, "locked.envelope", SearchOption.TopDirectoryOnly)
+                .Any();
+            moved.Should().BeFalse();
+        }
+    }
+
+    [Fact]
+    public async Task MigrateVersion5Cache_MovesEnvelopesFromBaseAndProcessing()
+    {
+        // Arrange
+        using var innerTransport = new FakeTransport();
+        await using var transport = CachingTransport.Create(innerTransport, _options, startWorker: false);
+
+        var isolatedCacheDir = _options.GetIsolatedCacheDirectoryPath()!;
+
+        var baseCacheDir = _options.GetBaseCacheDirectoryPath()!;
+        var rootFile = Path.Combine(baseCacheDir, "v5_root.envelope");
+        _options.FileSystem.CreateDirectory(baseCacheDir);
+        _options.FileSystem.WriteAllTextToFile(rootFile, "dummy content");
+
+        var processingDir = Path.Combine(baseCacheDir, "__processing");
+        var procFile = Path.Combine(processingDir, "v5_proc.envelope");
+        _options.FileSystem.CreateDirectory(processingDir);
+        _options.FileSystem.WriteAllTextToFile(procFile, "dummy content");
+
+        // Act
+        var result = transport.MigrateVersion5Cache(CancellationToken.None);
+
+        // Assert
+        result.Should().Be(CachingTransport.ResultMigrationOk);
+
+        var markerFile = Path.Combine(baseCacheDir, ".migrated");
+        _options.FileSystem.FileExists(markerFile).Should().BeTrue();
+        _options.FileSystem.FileExists(rootFile).Should().BeFalse();
+        _options.FileSystem.FileExists(procFile).Should().BeFalse();
+
+        var movedRoot = Path.Combine(isolatedCacheDir, "v5_root.envelope");
+        var movedProc = Path.Combine(isolatedCacheDir, "v5_proc.envelope");
+        _options.FileSystem.FileExists(movedRoot).Should().BeTrue();
+        _options.FileSystem.FileExists(movedProc).Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task MigrateVersion5Cache_AlreadyMigrated_Skipped()
+    {
+        // Arrange
+        using var innerTransport = new FakeTransport();
+        await using var transport = CachingTransport.Create(innerTransport, _options, startWorker: false);
+
+        var baseCacheDir = _options.GetBaseCacheDirectoryPath()!;
+        var rootFile = Path.Combine(baseCacheDir, "v5_root.envelope");
+        _options.FileSystem.CreateDirectory(baseCacheDir);
+        _options.FileSystem.WriteAllTextToFile(rootFile, "dummy content");
+
+        var processingDir = Path.Combine(baseCacheDir, "__processing");
+        var procFile = Path.Combine(processingDir, "v5_proc.envelope");
+        _options.FileSystem.CreateDirectory(processingDir);
+        _options.FileSystem.WriteAllTextToFile(procFile, "dummy content");
+
+        var marker = Path.Combine(baseCacheDir, ".migrated");
+        _options.FileSystem.WriteAllTextToFile(marker, "6.0.0");
+
+        // Act
+        var result = transport.MigrateVersion5Cache(CancellationToken.None);
+
+        // Assert
+        result.Should().Be(CachingTransport.ResultMigrationAlreadyMigrated);
+        _options.FileSystem.FileExists(rootFile).Should().BeTrue();
+        _options.FileSystem.FileExists(procFile).Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task MigrateVersion5Cache_MigrationLockHeld_Skipped()
+    {
+        // Arrange
+        using var innerTransport = new FakeTransport();
+        await using var transport = CachingTransport.Create(innerTransport, _options, startWorker: false);
+
+        var baseCacheDir = _options.GetBaseCacheDirectoryPath()!;
+        var rootFile = Path.Combine(baseCacheDir, "v5_root.envelope");
+        _options.FileSystem.CreateDirectory(baseCacheDir);
+        _options.FileSystem.WriteAllTextToFile(rootFile, "dummy content");
+
+        var processingDir = Path.Combine(baseCacheDir, "__processing");
+        var procFile = Path.Combine(processingDir, "v5_proc.envelope");
+        _options.FileSystem.CreateDirectory(processingDir);
+        _options.FileSystem.WriteAllTextToFile(procFile, "dummy content");
+
+        var migrationLockPath = Path.Combine(baseCacheDir, "migration");
+        using var coordinator = new CacheDirectoryCoordinator(migrationLockPath, _options.DiagnosticLogger, _options.FileSystem);
+        coordinator.TryAcquire().Should().BeTrue("test must hold the migration lock");
+
+        // Act
+        var result = transport.MigrateVersion5Cache(CancellationToken.None);
+
+        // Assert
+        result.Should().Be(CachingTransport.ResultMigrationLockNotAcquired);
+        _options.FileSystem.FileExists(rootFile).Should().BeTrue();
+        _options.FileSystem.FileExists(procFile).Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task MigrateVersion5Cache_Cancelled_Skipped()
+    {
+        // Arrange
+        using var innerTransport = new FakeTransport();
+        await using var transport = CachingTransport.Create(innerTransport, _options, startWorker: false);
+
+        var baseCacheDir = _options.GetBaseCacheDirectoryPath()!;
+        var rootFile = Path.Combine(baseCacheDir, "v5_root.envelope");
+        _options.FileSystem.CreateDirectory(baseCacheDir);
+        _options.FileSystem.WriteAllTextToFile(rootFile, "dummy content");
+
+        var processingDir = Path.Combine(baseCacheDir, "__processing");
+        var procFile = Path.Combine(processingDir, "v5_proc.envelope");
+        _options.FileSystem.CreateDirectory(processingDir);
+        _options.FileSystem.WriteAllTextToFile(procFile, "dummy content");
+
+        // Act
+        using var cts = new CancellationTokenSource();
+        await cts.CancelAsync();
+        var result = transport.MigrateVersion5Cache(cts.Token);
+
+        // Assert
+        result.Should().Be(CachingTransport.ResultMigrationCancelled);
+        _options.FileSystem.FileExists(rootFile).Should().BeTrue();
+        _options.FileSystem.FileExists(procFile).Should().BeTrue();
+    }
 }
diff --git a/test/Sentry.Tests/Internals/InitCounterTests.cs b/test/Sentry.Tests/Internals/InitCounterTests.cs
new file mode 100644
index 0000000000..cc3f70a5f3
--- /dev/null
+++ b/test/Sentry.Tests/Internals/InitCounterTests.cs
@@ -0,0 +1,55 @@
+namespace Sentry.Tests.Internals;
+
+public class InitCounterTests
+{
+    [Fact]
+    public void Count_StartsAtZero()
+    {
+        // Arrange
+        var intCounter = new InitCounter();
+
+        // Act & Assert
+        Assert.Equal(0, intCounter.Count);
+    }
+
+    [Fact]
+    public void Increment_IncreasesByOne()
+    {
+        // Arrange
+        var intCounter = new InitCounter();
+
+        // Act
+        intCounter.Increment();
+
+        // Assert
+        intCounter.Count.Should().Be(1);
+    }
+
+    [Fact]
+    public async Task Increment_IsThreadsSafe()
+    {
+        // Arrange
+        const int incrementsPerTask = 1000;
+        const int numberOfTasks = 10;
+        var intCounter = new InitCounter();
+
+        // Act
+        // Spawn multiple threads to increment the counter then wait for all the threads to complete and verify the expected number of increments has been made
+        var tasks = new List<Task>();
+        for (var i = 0; i < numberOfTasks; i++)
+        {
+            tasks.Add(Task.Run(() =>
+            {
+                for (int j = 0; j < incrementsPerTask; j++)
+                {
+                    intCounter.Increment();
+                }
+            }));
+        }
+
+        await Task.WhenAll(tasks);
+
+        // Assert
+        Assert.Equal(incrementsPerTask * numberOfTasks, intCounter.Count);
+    }
+}
diff --git a/test/Sentry.Tests/SentryClientTests.cs b/test/Sentry.Tests/SentryClientTests.cs
index 0bf106fe3f..c8beac09a9 100644
--- a/test/Sentry.Tests/SentryClientTests.cs
+++ b/test/Sentry.Tests/SentryClientTests.cs
@@ -1619,15 +1619,20 @@ public void Ctor_KeepsCustomTransportOnOptions()
     [Fact]
     public void Ctor_WrapsCustomTransportWhenCachePathOnOptions()
     {
+        // Arrange
         _fixture.SentryOptions.Dsn = ValidDsn;
         _fixture.SentryOptions.Transport = new FakeTransport();
         using var cacheDirectory = new TempDirectory();
         _fixture.SentryOptions.CacheDirectoryPath = cacheDirectory.Path;
 
+        // Act
         using var sut = new SentryClient(_fixture.SentryOptions);
 
+        // Assert
         var cachingTransport = Assert.IsType<CachingTransport>(_fixture.SentryOptions.Transport);
         _ = Assert.IsType<FakeTransport>(cachingTransport.InnerTransport);
+
+        cachingTransport.Dispose(); // Release cache lock so that the cacheDirectory can be removed
     }
 
     [Fact]
diff --git a/test/Sentry.Tests/SentryOptionsTests.cs b/test/Sentry.Tests/SentryOptionsTests.cs
index df934ad69a..f30a2af8a1 100644
--- a/test/Sentry.Tests/SentryOptionsTests.cs
+++ b/test/Sentry.Tests/SentryOptionsTests.cs
@@ -682,4 +682,57 @@ public void CachesInstallationId()
         installationId2.Should().Be(installationId1);
         logger.Received(0).Log(SentryLevel.Debug, "Resolved installation ID '{0}'.", null, Arg.Any<string>());
     }
+
+    [Fact]
+    public void TryGetIsolatedCacheDirectoryPath_NullCacheDirectory_ReturnsNull()
+    {
+        var o = new SentryOptions { CacheDirectoryPath = null, Dsn = ValidDsn };
+        Assert.Null(o.GetIsolatedCacheDirectoryPath());
+    }
+
+#if IOS || ANDROID
+    [Fact]
+    public void GetIsolatedFolderName_MissingDsn_UniqueForInitcount()
+    {
+        var o = new SentryOptions { CacheDirectoryPath = "c:\\cache", Dsn = null };
+        var folder = o.GetIsolatedFolderName();
+        Assert.Equal($"{CacheDirectoryHelper.IsolatedCacheDirectoryPrefix}{o.InitCounter.Count}", folder);
+    }
+#else
+    [Fact]
+    public void GetIsolatedFolderName_MissingDsn__ReturnsNull()
+    {
+        var o = new SentryOptions { CacheDirectoryPath = "c:\\cache", Dsn = null };
+        var folder = o.GetIsolatedFolderName();
+        Assert.Null(folder);
+    }
+#endif
+
+    [Theory]
+    [InlineData(5, null)]
+    [InlineData(5, 7)]
+    public void GetIsolatedFolderName_UniqueForDsnInitCountAndProcessId(int initCount, int? processId)
+    {
+        // Arrange
+        var initCounter = Substitute.For<IInitCounter>();
+        initCounter.Count.Returns(initCount);
+        var o = new SentryOptions
+        {
+            CacheDirectoryPath = "c:\\cache",
+            Dsn = ValidDsn,
+            InitCounter = initCounter,
+            ProcessIdResolver = () => processId
+        };
+
+        // Act
+        var path = o.GetIsolatedFolderName();
+
+        // Assert
+#if IOS || ANDROID
+        var expectedFolder = $"{CacheDirectoryHelper.IsolatedCacheDirectoryPrefix}{initCount}";
+#else
+        var expectedFolder = $"{CacheDirectoryHelper.IsolatedCacheDirectoryPrefix}{ValidDsn.GetHashString()}_{processId ?? 0}_{initCount}";
+#endif
+        path.Should().Be(expectedFolder);
+    }
 }
diff --git a/test/Sentry.Tests/SentrySdkTests.cs b/test/Sentry.Tests/SentrySdkTests.cs
index 9c5fe1eca0..cceb134d57 100644
--- a/test/Sentry.Tests/SentrySdkTests.cs
+++ b/test/Sentry.Tests/SentrySdkTests.cs
@@ -188,6 +188,26 @@ public void Init_EmptyDsnDisabledDiagnostics_DoesNotLogWarning()
         }
     }
 
+    [Fact]
+    public void Init_IncrementsInitCount()
+    {
+        // Arrange
+        var initCount = new InitCounter();
+
+        // Act
+        using var first = SentrySdk.Init(o =>
+        {
+            o.Dsn = ValidDsn;
+            o.AutoSessionTracking = false;
+            o.BackgroundWorker = Substitute.For<IBackgroundWorker>();
+            o.InitNativeSdks = false;
+            o.InitCounter = initCount;
+        });
+
+        // Assert
+        initCount.Count.Should().Be(1);
+    }
+
     [Fact]
     public void Init_MultipleCalls_ReplacesHubWithLatest()
     {
@@ -246,6 +266,11 @@ public async Task Init_WithCache_BlocksUntilExistingCacheIsFlushed(bool? testDel
         using var cacheDirectory = new TempDirectory();
         var cachePath = cacheDirectory.Path;
 
+        // Force all instances to use the same cache path
+        var initCounter = Substitute.For<IInitCounter>();
+        initCounter.Count.Returns(1);
+        Func<int?> processIdResolver = () => 42;
+
         // Pre-populate cache
         var initialInnerTransport = Substitute.For<ITransport>();
         var initialTransport = CachingTransport.Create(
@@ -258,6 +283,8 @@ public async Task Init_WithCache_BlocksUntilExistingCacheIsFlushed(bool? testDel
                 CacheDirectoryPath = cachePath,
                 AutoSessionTracking = false,
                 InitNativeSdks = false,
+                InitCounter = initCounter,
+                ProcessIdResolver = processIdResolver
             },
             startWorker: false);
         await using (initialTransport)
@@ -308,6 +335,8 @@ public async Task Init_WithCache_BlocksUntilExistingCacheIsFlushed(bool? testDel
                 o.Debug = true;
                 o.DiagnosticLogger = _logger;
                 o.CacheDirectoryPath = cachePath;
+                o.InitCounter = initCounter;
+                o.ProcessIdResolver = processIdResolver;
                 o.InitCacheFlushTimeout = initFlushTimeout;
                 o.Transport = transport;
                 o.AutoSessionTracking = false;
@@ -340,8 +369,10 @@ public async Task Init_WithCache_BlocksUntilExistingCacheIsFlushed(bool? testDel
         finally
         {
             // cleanup to avoid disposing/deleting the temp directory while the cache worker is still running
-            var cachingTransport = (CachingTransport)options!.Transport;
-            await cachingTransport!.StopWorkerAsync();
+            if (options!.Transport is CachingTransport cachingTransport)
+            {
+                await cachingTransport!.StopWorkerAsync();
+            }
         }
     }
 #endif