diff --git a/src/Common/ProfileEvents.cpp b/src/Common/ProfileEvents.cpp
index 87fcf220ff0a..052c059a72db 100644
--- a/src/Common/ProfileEvents.cpp
+++ b/src/Common/ProfileEvents.cpp
@@ -475,6 +475,7 @@ The server successfully detected this situation and will download merged part fr
     M(FileSegmentUseMicroseconds, "File segment use() time") \
     M(FileSegmentRemoveMicroseconds, "File segment remove() time") \
     M(FileSegmentHolderCompleteMicroseconds, "File segments holder complete() time") \
+    M(FileSegmentFailToIncreasePriority, "Number of times the priority was not increased due to a high contention on the cache lock") \
     M(FilesystemCacheHoldFileSegments, "Filesystem cache file segments count, which were hold") \
     M(FilesystemCacheUnusedHoldFileSegments, "Filesystem cache file segments count, which were hold, but not used (because of seek or LIMIT n, etc)") \
     \
diff --git a/src/Interpreters/Cache/FileCache.cpp b/src/Interpreters/Cache/FileCache.cpp
index d242544f787b..9c705ddc27c4 100644
--- a/src/Interpreters/Cache/FileCache.cpp
+++ b/src/Interpreters/Cache/FileCache.cpp
@@ -188,6 +188,11 @@ CacheGuard::Lock FileCache::lockCache() const
     return cache_guard.lock();
 }
 
+CacheGuard::Lock FileCache::tryLockCache() const
+{
+    return cache_guard.tryLock();
+}
+
 FileSegments FileCache::getImpl(const LockedKey & locked_key, const FileSegment::Range & range, size_t file_segments_limit) const
 {
     /// Given range = [left, right] and non-overlapping ordered set of file segments,
diff --git a/src/Interpreters/Cache/FileCache.h b/src/Interpreters/Cache/FileCache.h
index 2de2f347999e..5b665ad0271a 100644
--- a/src/Interpreters/Cache/FileCache.h
+++ b/src/Interpreters/Cache/FileCache.h
@@ -173,6 +173,7 @@ class FileCache : private boost::noncopyable
     void deactivateBackgroundOperations();
 
     CacheGuard::Lock lockCache() const;
+    CacheGuard::Lock tryLockCache() const;
 
     std::vector<FileSegment::Info> sync();
 
diff --git a/src/Interpreters/Cache/FileSegment.cpp b/src/Interpreters/Cache/FileSegment.cpp
index 8bd894659173..e58402dac033 100644
--- a/src/Interpreters/Cache/FileSegment.cpp
+++ b/src/Interpreters/Cache/FileSegment.cpp
@@ -23,6 +23,7 @@ namespace ProfileEvents
     extern const Event FileSegmentWriteMicroseconds;
     extern const Event FileSegmentUseMicroseconds;
     extern const Event FileSegmentHolderCompleteMicroseconds;
+    extern const Event FileSegmentFailToIncreasePriority;
     extern const Event FilesystemCacheHoldFileSegments;
     extern const Event FilesystemCacheUnusedHoldFileSegments;
 }
@@ -965,8 +966,10 @@ void FileSegment::increasePriority()
     auto it = getQueueIterator();
     if (it)
     {
-        auto cache_lock = cache->lockCache();
-        hits_count = it->increasePriority(cache_lock);
+        if (auto cache_lock = cache->tryLockCache())
+            hits_count = it->increasePriority(cache_lock);
+        else
+            ProfileEvents::increment(ProfileEvents::FileSegmentFailToIncreasePriority);
     }
 }
 
diff --git a/src/Interpreters/Cache/Guards.h b/src/Interpreters/Cache/Guards.h
index 09586b55c612..5729620d82f0 100644
--- a/src/Interpreters/Cache/Guards.h
+++ b/src/Interpreters/Cache/Guards.h
@@ -65,10 +65,12 @@ struct CacheGuard : private boost::noncopyable
     /// so, we wouldn't be able to pass CacheGuard::Lock to a function which accepts KeyGuard::Lock, for example
     struct Lock : public std::unique_lock<std::mutex>
     {
-        explicit Lock(std::mutex & mutex_) : std::unique_lock<std::mutex>(mutex_) {}
+        using Base = std::unique_lock<std::mutex>;
+        using Base::Base;
     };
 
     Lock lock() { return Lock(mutex); }
+    Lock tryLock() { return Lock(mutex, std::try_to_lock); }
     std::mutex mutex;
 };