diff --git a/mailbox-core/src/main/java/org/briarproject/mailbox/core/db/JdbcDatabase.kt b/mailbox-core/src/main/java/org/briarproject/mailbox/core/db/JdbcDatabase.kt
index df83c51c11720be4610958d3941ae53cdfd6028f..b9039cd2ac6f2ee492ec71c19396a2bc4d76d030 100644
--- a/mailbox-core/src/main/java/org/briarproject/mailbox/core/db/JdbcDatabase.kt
+++ b/mailbox-core/src/main/java/org/briarproject/mailbox/core/db/JdbcDatabase.kt
@@ -102,12 +102,9 @@ abstract class JdbcDatabase(private val dbTypes: DatabaseTypes, private val cloc
         }
         // Open the database and create the tables and indexes if necessary
         // First: mark the database as not closed and not wiped
-        connectionsLock.lock()
-        try {
+        connectionsLock.withLock {
             closed = false
             wiped = false
-        } finally {
-            connectionsLock.unlock()
         }
         // Check if we have the settings table to determine if we're reopening an existing database
         LOG.info { "checking for settings table" }
@@ -139,11 +136,8 @@ abstract class JdbcDatabase(private val dbTypes: DatabaseTypes, private val cloc
             compactAndClose()
             logDuration(LOG, { "Compacting database" }, start)
             // Allow the next transaction to reopen the DB
-            connectionsLock.lock()
-            try {
+            connectionsLock.withLock {
                 closed = false
-            } finally {
-                connectionsLock.unlock()
             }
             write { txn ->
                 storeLastCompacted(txn.unbox())
@@ -247,25 +241,17 @@ abstract class JdbcDatabase(private val dbTypes: DatabaseTypes, private val cloc
 
     private fun startTransaction(): Connection {
         LOG.trace { "startTransaction()" }
-        var connection: Connection?
-        connectionsLock.lock()
-        LOG.trace { "connections lock acquired" }
-        connection = try {
+        var connection = connectionsLock.withLock {
             if (closed || wiped) throw DbClosedException()
             connections.poll()
-        } finally {
-            connectionsLock.unlock()
         }
         try {
             if (connection == null) {
                 // Open a new connection
                 connection = createConnection()
                 connection.autoCommit = false
-                connectionsLock.lock()
-                try {
+                connectionsLock.withLock {
                     openConnections++
-                } finally {
-                    connectionsLock.unlock()
                 }
             }
         } catch (e: SQLException) {
@@ -277,24 +263,18 @@ abstract class JdbcDatabase(private val dbTypes: DatabaseTypes, private val cloc
     private fun abortTransaction(connection: Connection) {
         try {
             connection.rollback()
-            connectionsLock.lock()
-            try {
+            connectionsLock.withLock {
                 connections.add(connection)
                 connectionsChanged.signalAll()
-            } finally {
-                connectionsLock.unlock()
             }
         } catch (e: SQLException) {
             // Try to close the connection
             logException(LOG, e)
             tryToClose(connection, LOG)
             // Whatever happens, allow the database to close
-            connectionsLock.lock()
-            try {
+            connectionsLock.withLock {
                 openConnections--
                 connectionsChanged.signalAll()
-            } finally {
-                connectionsLock.unlock()
             }
         }
     }
@@ -305,12 +285,9 @@ abstract class JdbcDatabase(private val dbTypes: DatabaseTypes, private val cloc
         } catch (e: SQLException) {
             throw DbException(e)
         }
-        connectionsLock.lock()
-        try {
+        connectionsLock.withLock {
             connections.add(connection)
             connectionsChanged.signalAll()
-        } finally {
-            connectionsLock.unlock()
         }
     }
 
@@ -318,9 +295,7 @@ abstract class JdbcDatabase(private val dbTypes: DatabaseTypes, private val cloc
     fun closeAllConnections() {
         LOG.trace { "closing all connections" }
         var interrupted = false
-        connectionsLock.lock()
-        LOG.trace { "connections lock acquired" }
-        try {
+        connectionsLock.withLock {
             closed = true
             for (c in connections) c.close()
             openConnections -= connections.size
@@ -337,8 +312,6 @@ abstract class JdbcDatabase(private val dbTypes: DatabaseTypes, private val cloc
                 openConnections -= connections.size
                 connections.clear()
             }
-        } finally {
-            connectionsLock.unlock()
         }
         if (interrupted) Thread.currentThread().interrupt()
     }
@@ -697,4 +670,17 @@ abstract class JdbcDatabase(private val dbTypes: DatabaseTypes, private val cloc
         }
     }
 
+    // There's withLock from the kotlin stdlib, but I added logging for debugging here
+    private inline fun <T> Lock.withLock(action: () -> T): T {
+        LOG.trace { "acquiring connections lock" }
+        lock()
+        LOG.trace { "connections lock acquired" }
+        try {
+            return action()
+        } finally {
+            LOG.trace { "releasing connections lock" }
+            unlock()
+        }
+    }
+
 }