diff --git a/core/src/main/java/org/bitcoinj/coinjoin/utils/CoinJoinManager.java b/core/src/main/java/org/bitcoinj/coinjoin/utils/CoinJoinManager.java
index 7477db337..443606543 100644
--- a/core/src/main/java/org/bitcoinj/coinjoin/utils/CoinJoinManager.java
+++ b/core/src/main/java/org/bitcoinj/coinjoin/utils/CoinJoinManager.java
@@ -71,6 +71,7 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
@@ -507,10 +508,14 @@ public void processTransaction(Transaction tx) {
     public final PreMessageReceivedEventListener preMessageReceivedEventListener = (peer, m) -> {
         if (m instanceof CoinJoinQueue) {
             // Offload DSQueue message processing to thread pool to avoid blocking network I/O thread
-            messageProcessingExecutor.execute(() -> {
-                processMessage(peer, m);
-            });
-            // Return null as dsq meessages are only processed above
+            try {
+                messageProcessingExecutor.execute(() -> {
+                    processMessage(peer, m);
+                });
+            } catch (RejectedExecutionException e) {
+                // Executor was shutdown - ignore, we're shutting down
+            }
+            // Return null as dsq messages are only processed above
             return null;
         } else if (isCoinJoinMessage(m)) {
             // Process other CoinJoin messages synchronously
diff --git a/core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java b/core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java
index 338465622..e41bb9d71 100644
--- a/core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java
+++ b/core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java
@@ -1134,8 +1134,8 @@ public void handleChainLock(StoredBlock chainLockedBlock) {
                         handleNewBestChain(prevBlock, newTip, newTip.getHeader(), shouldVerifyTransactions());
                     }
                 } catch (BlockStoreException | PrunedException x) {
-                    log.info("handle chain lock exception:", x);
-                    // swallow
+                    log.debug("handle chain lock exception:", x);
+                    // swallow - expected during shutdown
                 }
             }
         } finally {
diff --git a/core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java b/core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java
index f8d1f6636..ba351a530 100644
--- a/core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java
+++ b/core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java
@@ -202,14 +202,19 @@ public TransactionConfidence get(Sha256Hash hash) {
     }
 
     public ArrayList<TransactionConfidence> get(StoredBlock block) {
-        ArrayList<TransactionConfidence> results = Lists.newArrayList();
-        for (Map.Entry<Sha256Hash, WeakConfidenceReference> entry: table.entrySet()) {
-            TransactionConfidence confidence = entry.getValue().get();
-            if (confidence != null && confidence.getConfidenceType() == TransactionConfidence.ConfidenceType.BUILDING &&
-                    confidence.getAppearedAtChainHeight() <= block.getHeight()) {
-                results.add(confidence);
+        lock.lock();
+        try {
+            ArrayList<TransactionConfidence> results = Lists.newArrayList();
+            for (Map.Entry<Sha256Hash, WeakConfidenceReference> entry: table.entrySet()) {
+                TransactionConfidence confidence = entry.getValue().get();
+                if (confidence != null && confidence.getConfidenceType() == TransactionConfidence.ConfidenceType.BUILDING &&
+                        confidence.getAppearedAtChainHeight() <= block.getHeight()) {
+                    results.add(confidence);
+                }
             }
+            return results;
+        } finally {
+            lock.unlock();
         }
-        return results;
     }
 }
diff --git a/core/src/main/java/org/bitcoinj/utils/Threading.java b/core/src/main/java/org/bitcoinj/utils/Threading.java
index 9e60575da..e2b1fae45 100644
--- a/core/src/main/java/org/bitcoinj/utils/Threading.java
+++ b/core/src/main/java/org/bitcoinj/utils/Threading.java
@@ -31,6 +31,7 @@
 import java.lang.management.ThreadMXBean;
 import java.util.concurrent.*;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 /**
  * Various threading related utilities. Provides a wrapper around explicit lock creation that lets you control whether
@@ -192,6 +193,13 @@ public static CycleDetectingLockFactory.Policy getPolicy() {
         return policy;
     }
 
+    public static ReentrantReadWriteLock readWriteLock(String name) {
+        if (Utils.isAndroidRuntime() && useDefaultAndroidPolicy)
+            return new ReentrantReadWriteLock(true);
+        else
+            return factory.newReentrantReadWriteLock(name, true);
+    }
+
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
     // Generic worker pool.
diff --git a/core/src/main/java/org/bitcoinj/wallet/AbstractKeyChainGroupExtension.java b/core/src/main/java/org/bitcoinj/wallet/AbstractKeyChainGroupExtension.java
index f075239a4..05ff0502d 100644
--- a/core/src/main/java/org/bitcoinj/wallet/AbstractKeyChainGroupExtension.java
+++ b/core/src/main/java/org/bitcoinj/wallet/AbstractKeyChainGroupExtension.java
@@ -544,4 +544,9 @@ public void setWallet(Wallet wallet) {
     public int getCombinedKeyLookaheadEpochs() {
         return hasKeyChains() ? getKeyChainGroup().getCombinedKeyLookaheadEpochs() : 0;
     }
+
+    @Override
+    public int getTotalIssuedKeys() {
+        return hasKeyChains() ? getKeyChainGroup().getTotalIssuedKeys() : 0;
+    }
 }
diff --git a/core/src/main/java/org/bitcoinj/wallet/AnyKeyChainGroup.java b/core/src/main/java/org/bitcoinj/wallet/AnyKeyChainGroup.java
index 09cc45118..596ec6da5 100644
--- a/core/src/main/java/org/bitcoinj/wallet/AnyKeyChainGroup.java
+++ b/core/src/main/java/org/bitcoinj/wallet/AnyKeyChainGroup.java
@@ -651,6 +651,17 @@ public int numKeys() {
         return result;
     }
 
+    /**
+     * Returns number of keys used on external and internal paths.
+     */
+    public int getTotalIssuedKeys() {
+        int result = basic.numKeys();
+        if (chains != null)
+            for (AnyDeterministicKeyChain chain : chains)
+                result += chain.numLeafKeysIssued();
+        return result;
+    }
+
     /**
      * Removes a key that was imported into the basic key chain. You cannot remove deterministic keys.
      * @throws IllegalArgumentException if the key is deterministic.
diff --git a/core/src/main/java/org/bitcoinj/wallet/CoinJoinExtension.java b/core/src/main/java/org/bitcoinj/wallet/CoinJoinExtension.java
index 42aee8f25..b7299807c 100644
--- a/core/src/main/java/org/bitcoinj/wallet/CoinJoinExtension.java
+++ b/core/src/main/java/org/bitcoinj/wallet/CoinJoinExtension.java
@@ -227,6 +227,9 @@ public void deserializeWalletExtension(Wallet containingWallet, byte[] data) thr
         if (containingWallet instanceof WalletEx && coinJoinProto.hasOutpointRoundsCache()) {
             WalletEx walletEx = (WalletEx) containingWallet;
             Protos.OutpointRoundsCache cacheProto = coinJoinProto.getOutpointRoundsCache();
+            // Pre-size HashMap to avoid resizing during deserialization
+            int entryCount = cacheProto.getEntriesCount();
+            walletEx.mapOutpointRoundsCache = new HashMap<>(entryCount * 4 / 3 + 1);
             for (Protos.OutpointRoundsEntry entryProto : cacheProto.getEntriesList()) {
                 Sha256Hash txHash = Sha256Hash.wrap(entryProto.getTransactionHash().toByteArray());
                 long outputIndex = entryProto.getOutputIndex();
diff --git a/core/src/main/java/org/bitcoinj/wallet/KeyChainGroup.java b/core/src/main/java/org/bitcoinj/wallet/KeyChainGroup.java
index 7ed2241f9..633919cf3 100644
--- a/core/src/main/java/org/bitcoinj/wallet/KeyChainGroup.java
+++ b/core/src/main/java/org/bitcoinj/wallet/KeyChainGroup.java
@@ -627,6 +627,17 @@ public int numKeys() {
         return result;
     }
 
+    /**
+     * Returns number of keys used on external and internal paths.
+     */
+    public int getTotalIssuedKeys() {
+        int result = basic.numKeys();
+        if (chains != null)
+            for (DeterministicKeyChain chain : chains)
+                result += chain.numLeafKeysIssued();
+        return result;
+    }
+
     /**
      * Removes a key that was imported into the basic key chain. You cannot remove deterministic keys.
      * @throws java.lang.IllegalArgumentException if the key is deterministic.
diff --git a/core/src/main/java/org/bitcoinj/wallet/KeyChainGroupExtension.java b/core/src/main/java/org/bitcoinj/wallet/KeyChainGroupExtension.java
index 20f36be09..5b3ee19be 100644
--- a/core/src/main/java/org/bitcoinj/wallet/KeyChainGroupExtension.java
+++ b/core/src/main/java/org/bitcoinj/wallet/KeyChainGroupExtension.java
@@ -96,4 +96,5 @@ default String toString(boolean includeLookahead, boolean includePrivateKeys, @N
     boolean isTransactionRevelant(Transaction tx);
 
     int getCombinedKeyLookaheadEpochs();
+    int getTotalIssuedKeys();
 }
diff --git a/core/src/main/java/org/bitcoinj/wallet/Wallet.java b/core/src/main/java/org/bitcoinj/wallet/Wallet.java
index be17cca03..6974f841f 100644
--- a/core/src/main/java/org/bitcoinj/wallet/Wallet.java
+++ b/core/src/main/java/org/bitcoinj/wallet/Wallet.java
@@ -133,7 +133,7 @@ public class Wallet extends BaseTaggableObject
 
     // Ordering: lock > keyChainGroupLock. KeyChainGroup is protected separately to allow fast querying of current receive address
     // even if the wallet itself is busy e.g. saving or processing a big reorg. Useful for reducing UI latency.
-    protected final ReentrantLock lock = Threading.lock("wallet");
+    protected final ReentrantReadWriteLock lock = Threading.readWriteLock("wallet");
     protected final ReentrantLock keyChainGroupLock = Threading.lock("wallet-keychaingroup");
 
     // The various pools below give quick access to wallet-relevant transactions by the state they're in:
@@ -521,17 +521,17 @@ public void onConfidenceChanged(TransactionConfidence confidence, TransactionCon
                 // to us to listen for that. Other types of confidence changes (type, etc) are triggered by us,
                 // so we'll queue up a wallet change event in other parts of the code.
                 if (reason == ChangeReason.SEEN_PEERS) {
-                    lock.lock();
+                    lock.writeLock().lock();
                     try {
                         checkBalanceFuturesLocked(null);
                         Transaction tx = getTransaction(confidence.getTransactionHash());
                         queueOnTransactionConfidenceChanged(tx);
                         maybeQueueOnWalletChanged();
                     } finally {
-                        lock.unlock();
+                        lock.writeLock().unlock();
                     }
                 } else if(reason == ChangeReason.IX_TYPE || reason == ChangeReason.REJECT) {
-                    lock.lock();
+                    lock.writeLock().lock();
                     try {
                         Transaction tx = getTransaction(confidence.getTransactionHash());
                         queueOnTransactionConfidenceChanged(tx);
@@ -539,7 +539,7 @@ public void onConfidenceChanged(TransactionConfidence confidence, TransactionCon
                         //save the wallet when an InstantSend transaction is locked
                         saveLater();
                     } finally {
-                         lock.unlock();;
+                         lock.writeLock().unlock();
                     }
                 }
             }
@@ -583,23 +583,23 @@ public DeterministicKeyChain getActiveKeyChain() {
      * will be thrown</p>
      */
     public final void addTransactionSigner(TransactionSigner signer) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             if (signer.isReady())
                 signers.add(signer);
             else
                 throw new IllegalStateException("Signer instance is not ready to be added into Wallet: " + signer.getClass());
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
     public List<TransactionSigner> getTransactionSigners() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return ImmutableList.copyOf(signers);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -859,20 +859,20 @@ public boolean removeKey(ECKey key) {
      * Returns the number of keys in the key chain group, including lookahead keys.
      */
     public int getKeyChainGroupSize() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             keyChainGroupLock.lock();
             try {
-                int walletKeys = keyChainGroup.numKeys();
-                if (receivingFromFriendsGroup != null) walletKeys += receivingFromFriendsGroup.numKeys();
-                if (sendingToFriendsGroup != null) walletKeys += sendingToFriendsGroup.numKeys();
-                for (KeyChainGroupExtension ext : keyChainExtensions.values()) walletKeys += ext.numKeys();
+                int walletKeys = keyChainGroup.getTotalIssuedKeys();
+                if (receivingFromFriendsGroup != null) walletKeys += receivingFromFriendsGroup.getTotalIssuedKeys();
+                if (sendingToFriendsGroup != null) walletKeys += sendingToFriendsGroup.getTotalIssuedKeys();
+                for (KeyChainGroupExtension ext : keyChainExtensions.values()) walletKeys += ext.getTotalIssuedKeys();
                 return walletKeys;
             } finally {
                 keyChainGroupLock.unlock();
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -1142,7 +1142,7 @@ public boolean removeWatchedAddresses(final List<Address> addresses) {
      * @return true if successful
      */
     public boolean removeWatchedScripts(final List<Script> scripts) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             for (final Script script : scripts) {
                 if (!watchedScripts.contains(script))
@@ -1155,7 +1155,7 @@ public boolean removeWatchedScripts(final List<Script> scripts) {
             saveNow();
             return true;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -1676,7 +1676,7 @@ public List<Protos.Key> serializeKeyChainGroupToProtobuf() {
     /** Saves the wallet first to the given temp file, then renames to the dest file. */
     public void saveToFile(File temp, File destFile) throws IOException {
         FileOutputStream stream = null;
-        lock.lock();
+        lock.writeLock().lock();
         try {
             stream = new FileOutputStream(temp);
             saveToFileStream(stream);
@@ -1701,7 +1701,7 @@ public void saveToFile(File temp, File destFile) throws IOException {
             log.error("Failed whilst saving wallet", e);
             throw e;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
             if (stream != null) {
                 stream.close();
             }
@@ -1733,11 +1733,11 @@ public void saveToFile(File f) throws IOException {
      * even if it's loaded from a protocol buffer.</p>
      */
     public void setAcceptRiskyTransactions(boolean acceptRiskyTransactions) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             this.acceptRiskyTransactions = acceptRiskyTransactions;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -1745,11 +1745,11 @@ public void setAcceptRiskyTransactions(boolean acceptRiskyTransactions) {
      * See {@link Wallet#setAcceptRiskyTransactions(boolean)} for an explanation of this property.
      */
     public boolean isAcceptRiskyTransactions() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return acceptRiskyTransactions;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -1759,11 +1759,11 @@ public boolean isAcceptRiskyTransactions() {
      * behaviour with {@link #setAcceptRiskyTransactions(boolean)}.
      */
     public void setRiskAnalyzer(RiskAnalysis.Analyzer analyzer) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             this.riskAnalyzer = checkNotNull(analyzer);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -1771,11 +1771,11 @@ public void setRiskAnalyzer(RiskAnalysis.Analyzer analyzer) {
      * Gets the current {@link RiskAnalysis} implementation. The default is {@link DefaultRiskAnalysis}.
      */
     public RiskAnalysis.Analyzer getRiskAnalyzer() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return riskAnalyzer;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -1803,7 +1803,7 @@ public RiskAnalysis.Analyzer getRiskAnalyzer() {
      */
     public WalletFiles autosaveToFile(File f, long delayTime, TimeUnit timeUnit,
                                       @Nullable WalletFiles.Listener eventListener) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             checkState(vFileManager == null, "Already auto saving this wallet.");
             WalletFiles manager = new WalletFiles(this, f, delayTime, timeUnit);
@@ -1812,7 +1812,7 @@ public WalletFiles autosaveToFile(File f, long delayTime, TimeUnit timeUnit,
             vFileManager = manager;
             return manager;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -1824,14 +1824,14 @@ public WalletFiles autosaveToFile(File f, long delayTime, TimeUnit timeUnit,
      * </p>
      */
     public void shutdownAutosaveAndWait() {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             WalletFiles files = vFileManager;
             vFileManager = null;
             checkState(files != null, "Auto saving not enabled.");
             files.shutdownAndWait();
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -1879,11 +1879,11 @@ public boolean isNotifyTxOnNextBlock() {
      * {@link WalletProtobufSerializer}.
      */
     public void saveToFileStream(OutputStream f) throws IOException {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             new WalletProtobufSerializer().writeWallet(this, f);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -1942,7 +1942,7 @@ public boolean isConsistent() {
      * inconsistency.
      */
     public void isConsistentOrThrow() throws IllegalStateException {
-        lock.lock();
+        lock.readLock().lock();
         try {
             // Calculate expected size first (no object allocation)
             int expectedSize = unspent.size() + spent.size() + pending.size() + dead.size();
@@ -1968,7 +1968,7 @@ public void isConsistentOrThrow() throws IllegalStateException {
                 }
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -1984,7 +1984,7 @@ public void isConsistentOrThrow() throws IllegalStateException {
      */
     // TODO: a test fails when using this in receive()
     public boolean validateTransaction(Transaction tx) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             Sha256Hash txHash = tx.getTxId();
 
@@ -2008,7 +2008,7 @@ public boolean validateTransaction(Transaction tx) {
 
             return true;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -2075,7 +2075,7 @@ public static Wallet loadFromFileStream(InputStream stream, @Nullable WalletExte
     public boolean notifyTransactionIsInBlock(Sha256Hash txHash, StoredBlock block,
                                               BlockChain.NewBlockType blockType,
                                               int relativityOffset) throws VerificationException {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             Transaction tx = transactions.get(txHash);
             if (tx == null) {
@@ -2091,7 +2091,7 @@ public boolean notifyTransactionIsInBlock(Sha256Hash txHash, StoredBlock block,
             receive(tx, block, blockType, relativityOffset);
             return true;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -2112,7 +2112,7 @@ public void receivePending(Transaction tx, @Nullable List<Transaction> dependenc
         // Can run in a peer thread. This method will only be called if a prior call to isPendingTransactionRelevant
         // returned true, so we already know by this point that it sends coins to or from our wallet, or is a double
         // spend against one of our other pending transactions.
-        lock.lock();
+        lock.writeLock().lock();
         try {
             tx.verify();
             // Ignore it if we already know about this transaction. Receiving a pending transaction never moves it
@@ -2145,7 +2145,7 @@ public void receivePending(Transaction tx, @Nullable List<Transaction> dependenc
             // timestamp on the transaction and registers/runs event listeners.
             commitTx(tx);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
         // maybeRotateKeys() will ignore pending transactions so we don't bother calling it here (see the comments
         // in that function for an explanation of why).
@@ -2156,7 +2156,7 @@ public void receiveLock(Transaction tx) throws VerificationException {
         // Can run in a peer thread. This method will only be called if a prior call to isPendingTransactionLockRelevant
         // returned true, so we already know by this point that it sends coins to or from our wallet, or is a double
         // spend against one of our other pending transactions.
-        lock.lock();
+        lock.writeLock().lock();
         try {
             tx.verify();
 
@@ -2169,7 +2169,7 @@ public void receiveLock(Transaction tx) throws VerificationException {
             //pending.remove(lockedTx);
 
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
         // maybeRotateKeys() will ignore pending transactions so we don't bother calling it here (see the comments
         // in that function for an explanation of why).
@@ -2183,7 +2183,7 @@ public void receiveLock(Transaction tx) throws VerificationException {
      * using the factory returned by {@link #getRiskAnalyzer()} and use it directly.
      */
     public boolean isTransactionRisky(Transaction tx, @Nullable List<Transaction> dependencies) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             if (dependencies == null)
                 dependencies = ImmutableList.of();
@@ -2195,7 +2195,7 @@ public boolean isTransactionRisky(Transaction tx, @Nullable List<Transaction> de
             }
             return false;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -2221,7 +2221,7 @@ public void receivePending(Transaction tx, @Nullable List<Transaction> dependenc
      * will soon be called with the transactions dependencies as well.
      */
     public boolean isPendingTransactionRelevant(Transaction tx) throws ScriptException {
-        lock.lock();
+        lock.readLock().lock();
         try {
             // Ignore it if we already know about this transaction. Receiving a pending transaction never moves it
             // between pools.
@@ -2240,13 +2240,13 @@ public boolean isPendingTransactionRelevant(Transaction tx) throws ScriptExcepti
             }
             return true;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     @Deprecated
     public boolean isPendingTransactionLockRelevant(Transaction tx) throws ScriptException {
-        lock.lock();
+        lock.readLock().lock();
         try {
             boolean hasPendingTxLockRequest = getPendingTransactions().contains(tx);
             if(!hasPendingTxLockRequest)
@@ -2267,7 +2267,7 @@ public boolean isPendingTransactionLockRelevant(Transaction tx) throws ScriptExc
             }
             return true;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -2280,7 +2280,7 @@ public boolean isPendingTransactionLockRelevant(Transaction tx) throws ScriptExc
      * it will not be considered relevant.</p>
      */
     public boolean isTransactionRelevant(Transaction tx) throws ScriptException {
-        lock.lock();
+        lock.readLock().lock();
         try {
             boolean isRevelant = false;
             for (KeyChainGroupExtension extension : keyChainExtensions.values()) {
@@ -2291,7 +2291,7 @@ public boolean isTransactionRelevant(Transaction tx) throws ScriptException {
                    tx.getValueSentToMe(this).signum() > 0 ||
                    !findDoubleSpendsAgainst(tx, transactions).isEmpty();
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -2301,7 +2301,7 @@ public boolean isTransactionRelevant(Transaction tx) throws ScriptException {
      * @return The set of transactions that double spend "tx".
      */
     private Set<Transaction> findDoubleSpendsAgainst(Transaction tx, Map<Sha256Hash, Transaction> candidates) {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.getReadHoldCount() > 0 || lock.writeLock().isHeldByCurrentThread());
         if (tx.isCoinBase()) return Sets.newHashSet();
 
         // Use the index for O(I) lookup instead of O(W × I) scan
@@ -2323,7 +2323,7 @@ private Set<Transaction> findDoubleSpendsAgainst(Transaction tx, Map<Sha256Hash,
     }
 
     private void removeFromSpentOutpointsIndex(Transaction tx) {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         for (TransactionInput input : tx.getInputs()) {
             TransactionOutPoint outpoint = input.getOutpoint();
             Set<Sha256Hash> txHashes = spentOutpointsIndex.get(outpoint);
@@ -2384,13 +2384,13 @@ void addTransactionsDependingOn(Set<Transaction> txSet, Set<Transaction> txPool)
     public void receiveFromBlock(Transaction tx, StoredBlock block,
                                  BlockChain.NewBlockType blockType,
                                  int relativityOffset) throws VerificationException {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             if (!isTransactionRelevant(tx))
                 return;
             receive(tx, block, blockType, relativityOffset);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -2400,7 +2400,7 @@ public void receiveFromBlock(Transaction tx, StoredBlock block,
     private void receive(Transaction tx, StoredBlock block, BlockChain.NewBlockType blockType,
                          int relativityOffset) throws VerificationException {
         // Runs in a peer thread.
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
 
         Coin prevBalance = getBalance();
         Sha256Hash txHash = tx.getTxId();
@@ -2623,7 +2623,7 @@ public void notifyNewBestBlock(StoredBlock block) throws VerificationException {
         Sha256Hash newBlockHash = block.getHeader().getHash();
         if (newBlockHash.equals(getLastBlockSeenHash()))
             return;
-        lock.lock();
+        lock.writeLock().lock();
         try {
             // Store the new block hash.
             setLastBlockSeenHash(newBlockHash);
@@ -2689,7 +2689,7 @@ public void notifyNewBestBlock(StoredBlock block) throws VerificationException {
                 saveLater();
             }
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -2697,7 +2697,7 @@ public void notifyNewBestBlock(StoredBlock block) throws VerificationException {
      * update transaction depths and notify
      */
     public void updateTransactionDepth() {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             Set<Transaction> transactions = getTransactions(true);
             for (Transaction tx : transactions) {
@@ -2718,7 +2718,7 @@ public void updateTransactionDepth() {
             }
             informConfidenceListenersIfNotReorganizing();
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -2728,7 +2728,7 @@ public void updateTransactionDepth() {
      * re-org. Places the tx into the right pool, handles coinbase transactions, handles double-spends and so on.
      */
     private void processTxFromBestChain(Transaction tx, boolean forceAddToPool) throws VerificationException {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         checkState(!pending.containsKey(tx.getTxId()));
 
         // This TX may spend our existing outputs even though it was not pending. This can happen in unit
@@ -2816,7 +2816,7 @@ private void processTxFromBestChain(Transaction tx, boolean forceAddToPool) thro
      * @param fromChain If true, the tx appeared on the current best chain, if false it was pending.
      */
     private void updateForSpends(Transaction tx, boolean fromChain) throws VerificationException {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         if (fromChain)
             checkState(!pending.containsKey(tx.getTxId()));
         for (TransactionInput input : tx.getInputs()) {
@@ -2960,7 +2960,7 @@ private void killTxns(Set<Transaction> txnsToKill, @Nullable Transaction overrid
      * If the owned transactions outputs are not all marked as spent, and it's in the spent map, move it.
      */
     protected void maybeMovePool(Transaction tx, String context) {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         if (tx.isEveryOwnedOutputSpent(this)) {
             // There's nothing left I can spend in this transaction.
             if (unspent.remove(tx.getTxId()) != null) {
@@ -2994,7 +2994,7 @@ protected void maybeMovePool(Transaction tx, String context) {
      */
     public boolean maybeCommitTx(Transaction tx) throws VerificationException {
         tx.verify();
-        lock.lock();
+        lock.writeLock().lock();
         try {
             if (pending.containsKey(tx.getTxId()))
                 return false;
@@ -3079,7 +3079,7 @@ public boolean maybeCommitTx(Transaction tx) throws VerificationException {
             informConfidenceListenersIfNotReorganizing();
             saveNow();
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
         return true;
     }
@@ -3320,7 +3320,7 @@ public boolean removeTransactionConfidenceEventListener(TransactionConfidenceEve
 
 
     private void queueOnTransactionConfidenceChanged(final Transaction tx) {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         for (final ListenerRegistration<TransactionConfidenceEventListener> registration : transactionConfidenceListeners) {
             if (registration.executor == Threading.SAME_THREAD) {
                 registration.listener.onTransactionConfidenceChanged(this, tx);
@@ -3338,7 +3338,7 @@ public void run() {
     protected void maybeQueueOnWalletChanged() {
         // Don't invoke the callback in some circumstances, eg, whilst we are re-organizing or fiddling with
         // transactions due to a new block arriving. It will be called later instead.
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         checkState(onWalletChangedSuppressions >= 0);
         if (onWalletChangedSuppressions > 0) return;
         for (final ListenerRegistration<WalletChangeEventListener> registration : changeListeners) {
@@ -3352,7 +3352,7 @@ public void run() {
     }
 
     protected void queueOnCoinsReceived(final Transaction tx, final Coin balance, final Coin newBalance) {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         for (final ListenerRegistration<WalletCoinsReceivedEventListener> registration : coinsReceivedListeners) {
             registration.executor.execute(new Runnable() {
                 @Override
@@ -3364,7 +3364,7 @@ public void run() {
     }
 
     protected void queueOnCoinsSent(final Transaction tx, final Coin prevBalance, final Coin newBalance) {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         for (final ListenerRegistration<WalletCoinsSentEventListener> registration : coinsSentListeners) {
             registration.executor.execute(new Runnable() {
                 @Override
@@ -3376,7 +3376,7 @@ public void run() {
     }
 
     protected void queueOnReorganize() {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         checkState(insideReorg);
         for (final ListenerRegistration<WalletReorganizeEventListener> registration : reorganizeListeners) {
             registration.executor.execute(new Runnable() {
@@ -3389,7 +3389,7 @@ public void run() {
     }
 
     protected void queueOnReset() {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         for (final ListenerRegistration<WalletResetEventListener> registration : resetListeners) {
             registration.executor.execute(new Runnable() {
                 @Override
@@ -3422,7 +3422,7 @@ public void run() {
      * @param includeDead     If true, transactions that were overridden by a double spend are included.
      */
     public Set<Transaction> getTransactions(boolean includeDead) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             int capacity = unspent.size() + spent.size() + pending.size() + (includeDead ? dead.size(): 0);
             Set<Transaction> all = new HashSet<>(capacity);
@@ -3433,7 +3433,7 @@ public Set<Transaction> getTransactions(boolean includeDead) {
                 all.addAll(dead.values());
             return all;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -3442,11 +3442,11 @@ public Set<Transaction> getTransactions(boolean includeDead) {
      * @param includeDead     If true, transactions that were overridden by a double spend are included.
      */
     public int getTransactionCount(boolean includeDead) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return unspent.size() + spent.size() + pending.size() + (includeDead ? dead.size(): 0);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -3455,7 +3455,7 @@ public int getTransactionCount(boolean includeDead) {
      * @param includeDead     If true, transactions that were overridden by a double spend are included.
      */
     public Collection<Transaction> getTransactionList(boolean includeDead) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             int capacity = unspent.size() + spent.size() + pending.size() + (includeDead ? dead.size(): 0);
             ArrayList<Transaction> all = new ArrayList<>(capacity);
@@ -3466,7 +3466,7 @@ public Collection<Transaction> getTransactionList(boolean includeDead) {
                 all.addAll(dead.values());
             return all;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -3474,7 +3474,7 @@ public Collection<Transaction> getTransactionList(boolean includeDead) {
      * Returns a set of all WalletTransactions in the wallet.
      */
     public Iterable<WalletTransaction> getWalletTransactions() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             Set<WalletTransaction> all = new HashSet<>();
             addWalletTransactionsToSet(all, Pool.UNSPENT, unspent.values());
@@ -3483,7 +3483,7 @@ public Iterable<WalletTransaction> getWalletTransactions() {
             addWalletTransactionsToSet(all, Pool.PENDING, pending.values());
             return all;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -3500,11 +3500,11 @@ private static void addWalletTransactionsToSet(Set<WalletTransaction> txns,
      * applications. It does not trigger auto saving.
      */
     public void addWalletTransaction(WalletTransaction wtx) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             addWalletTransaction(wtx.getPool(), wtx.getTransaction());
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -3512,7 +3512,7 @@ public void addWalletTransaction(WalletTransaction wtx) {
      * Adds the given transaction to the given pools and registers a confidence change listener on it.
      */
     protected void addWalletTransaction(Pool pool, Transaction tx) {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         transactions.put(tx.getTxId(), tx);
         switch (pool) {
         case UNSPENT:
@@ -3550,7 +3550,7 @@ protected void addWalletTransaction(Pool pool, Transaction tx) {
      * Returns a WalletTransaction for the given hash.
      */
     public WalletTransaction getWalletTransaction(Sha256Hash hash) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             // TODO: optimize this method to loop through all tx's only once
             Set<WalletTransaction> all = new HashSet<>();
@@ -3563,7 +3563,7 @@ public WalletTransaction getWalletTransaction(Sha256Hash hash) {
                     return wtx;
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
         return null;
     }
@@ -3584,7 +3584,7 @@ public List<Transaction> getTransactionsByTime() {
      * depending on how the wallet is implemented (eg if backed by a database).</p>
      */
     public List<Transaction> getRecentTransactions(int numTransactions, boolean includeDead) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             checkArgument(numTransactions >= 0);
             // Firstly, put all transactions into an array.
@@ -3602,7 +3602,7 @@ public List<Transaction> getRecentTransactions(int numTransactions, boolean incl
                 return all;
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -3611,17 +3611,17 @@ public List<Transaction> getRecentTransactions(int numTransactions, boolean incl
      */
     @Nullable
     public Transaction getTransaction(Sha256Hash hash) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return transactions.get(hash);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     @Override
     public Map<Sha256Hash, Transaction> getTransactionPool(Pool pool) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             switch (pool) {
                 case UNSPENT:
@@ -3638,7 +3638,7 @@ public Map<Sha256Hash, Transaction> getTransactionPool(Pool pool) {
                     throw new RuntimeException("Unknown wallet transaction type " + pool);
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -3648,7 +3648,7 @@ public Map<Sha256Hash, Transaction> getTransactionPool(Pool pool) {
      * be fired.
      */
     public void reset() {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             clearTransactions();
             spentOutpointsIndex.clear();
@@ -3659,7 +3659,7 @@ public void reset() {
             queueOnReset();
             maybeQueueOnWalletChanged();
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -3669,7 +3669,7 @@ public void reset() {
      * Triggers auto saving.
      */
     public void clearTransactions(int fromHeight) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             if (fromHeight == 0) {
                 clearTransactions();
@@ -3678,7 +3678,7 @@ public void clearTransactions(int fromHeight) {
                 throw new UnsupportedOperationException();
             }
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -3697,7 +3697,7 @@ private void clearTransactions() {
      * @param excludeImmatureCoinbases Whether to ignore outputs that are unspendable due to being immature.
      */
     public List<TransactionOutput> getWatchedOutputs(boolean excludeImmatureCoinbases) {
-        lock.lock();
+        lock.readLock().lock();
         keyChainGroupLock.lock();
         try {
             LinkedList<TransactionOutput> candidates = Lists.newLinkedList();
@@ -3717,7 +3717,7 @@ public List<TransactionOutput> getWatchedOutputs(boolean excludeImmatureCoinbase
             return candidates;
         } finally {
             keyChainGroupLock.unlock();
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -3726,7 +3726,7 @@ public List<TransactionOutput> getWatchedOutputs(boolean excludeImmatureCoinbase
      * outputs have not been spent.
      */
     public void cleanup() {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             boolean dirty = false;
             for (Iterator<Transaction> i = pending.values().iterator(); i.hasNext();) {
@@ -3763,12 +3763,12 @@ public void cleanup() {
                     log.info("Estimated balance is now: {}", getBalance(BalanceType.ESTIMATED).toFriendlyString());
             }
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
     EnumSet<Pool> getContainingPools(Transaction tx) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             EnumSet<Pool> result = EnumSet.noneOf(Pool.class);
             Sha256Hash txHash = tx.getTxId();
@@ -3786,13 +3786,13 @@ EnumSet<Pool> getContainingPools(Transaction tx) {
             }
             return result;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     @VisibleForTesting
     public int getPoolSize(WalletTransaction.Pool pool) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             switch (pool) {
                 case UNSPENT:
@@ -3806,13 +3806,13 @@ public int getPoolSize(WalletTransaction.Pool pool) {
             }
             throw new RuntimeException("Unreachable");
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     @VisibleForTesting
     public boolean poolContainsTxHash(final WalletTransaction.Pool pool, final Sha256Hash txHash) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             switch (pool) {
                 case UNSPENT:
@@ -3826,17 +3826,17 @@ public boolean poolContainsTxHash(final WalletTransaction.Pool pool, final Sha25
             }
             throw new RuntimeException("Unreachable");
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     /** Returns a copy of the internal unspent outputs list */
     public List<TransactionOutput> getUnspents() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return new ArrayList<>(myUnspents);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -3876,7 +3876,7 @@ public String toString(boolean includePrivateKeys, @Nullable KeyParameter aesKey
      */
     public String toString(boolean includeLookahead, boolean includePrivateKeys, @Nullable KeyParameter aesKey,
             boolean includeTransactions, boolean includeExtensions, @Nullable AbstractBlockChain chain, boolean includeDebugInfo) {
-        lock.lock();
+        lock.readLock().lock();
         keyChainGroupLock.lock();
         try {
             StringBuilder builder = new StringBuilder("Wallet\n");
@@ -3959,13 +3959,13 @@ public String toString(boolean includeLookahead, boolean includePrivateKeys, @Nu
             return builder.toString();
         } finally {
             keyChainGroupLock.unlock();
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     private void toStringHelper(StringBuilder builder, Map<Sha256Hash, Transaction> transactionMap,
                                 @Nullable AbstractBlockChain chain, @Nullable Comparator<Transaction> sortOrder) {
-        checkState(lock.isHeldByCurrentThread());
+        // checkState(lock.readLock().isHeldByCurrentThread());
 
         final Collection<Transaction> txns;
         if (sortOrder != null) {
@@ -3996,11 +3996,11 @@ private void toStringHelper(StringBuilder builder, Map<Sha256Hash, Transaction>
      * Returns an immutable view of the transactions currently waiting for network confirmations.
      */
     public Collection<Transaction> getPendingTransactions() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return Collections.unmodifiableCollection(pending.values());
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -4034,38 +4034,38 @@ public long getEarliestKeyCreationTime() {
     /** Returns the hash of the last seen best-chain block, or null if the wallet is too old to store this data. */
     @Nullable
     public Sha256Hash getLastBlockSeenHash() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return lastBlockSeenHash;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     public void setLastBlockSeenHash(@Nullable Sha256Hash lastBlockSeenHash) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             this.lastBlockSeenHash = lastBlockSeenHash;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
     public void setLastBlockSeenHeight(int lastBlockSeenHeight) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             this.lastBlockSeenHeight = lastBlockSeenHeight;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
     public void setLastBlockSeenTimeSecs(long timeSecs) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             lastBlockSeenTimeSecs = timeSecs;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -4077,11 +4077,11 @@ public void setLastBlockSeenTimeSecs(long timeSecs) {
      * time then this method returns zero.
      */
     public long getLastBlockSeenTimeSecs() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return lastBlockSeenTimeSecs;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -4106,11 +4106,11 @@ public Date getLastBlockSeenTime() {
      * is old and doesn't have that data.
      */
     public int getLastBlockSeenHeight() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return lastBlockSeenHeight;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -4214,7 +4214,7 @@ public Coin getBalance() {
      * Returns the balance of this wallet as calculated by the provided balanceType.
      */
     public Coin getBalance(BalanceType balanceType) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             if (balanceType == BalanceType.AVAILABLE || balanceType == BalanceType.AVAILABLE_SPENDABLE) {
                 List<TransactionOutput> candidates = calculateAllSpendCandidates(true, balanceType == BalanceType.AVAILABLE_SPENDABLE);
@@ -4233,7 +4233,7 @@ public Coin getBalance(BalanceType balanceType) {
                 throw new AssertionError("Unknown balance type");  // Unreachable.
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -4243,14 +4243,14 @@ public Coin getBalance(BalanceType balanceType) {
      * possible and returns the total.
      */
     public Coin getBalance(CoinSelector selector) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             checkNotNull(selector);
             List<TransactionOutput> candidates = calculateAllSpendCandidates(true, false);
             CoinSelection selection = selector.select(params.getMaxMoney(), candidates);
             return selection.valueGathered;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -4276,7 +4276,7 @@ private static class BalanceFutureRequest {
      * chance to be updated.</p>
      */
     public ListenableFuture<Coin> getBalanceFuture(final Coin value, final BalanceType type) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             final SettableFuture<Coin> future = SettableFuture.create();
             final Coin current = getBalance(type);
@@ -4295,14 +4295,14 @@ public ListenableFuture<Coin> getBalanceFuture(final Coin value, final BalanceTy
             }
             return future;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     // Runs any balance futures in the user code thread.
     @SuppressWarnings("FieldAccessNotGuarded")
     private void checkBalanceFuturesLocked(@Nullable Coin avail) {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         final ListIterator<BalanceFutureRequest> it = balanceFutureRequests.listIterator();
         while (it.hasNext()) {
             final BalanceFutureRequest req = it.next();
@@ -4486,13 +4486,15 @@ public Transaction createSend(Address address, Coin value) throws InsufficientMo
      * @throws MultipleOpReturnRequested if there is more than one OP_RETURN output for the resultant transaction.
      */
     public Transaction sendCoinsOffline(SendRequest request) throws InsufficientMoneyException {
-        lock.lock();
+        checkState(lock.getReadHoldCount() == 0,
+                "Cannot hold read lock when calling sendCoinsOffline (would deadlock on write lock upgrade)");
+        lock.writeLock().lock();
         try {
             completeTx(request);
             commitTx(request.tx);
             return request.tx;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -4551,7 +4553,8 @@ public SendResult sendCoins(TransactionBroadcaster broadcaster, Address to, Coin
     public SendResult sendCoins(TransactionBroadcaster broadcaster, SendRequest request) throws InsufficientMoneyException {
         // Should not be locked here, as we're going to call into the broadcaster and that might want to hold its
         // own lock. sendCoinsOffline handles everything that needs to be locked.
-        checkState(!lock.isHeldByCurrentThread());
+        checkState(!lock.writeLock().isHeldByCurrentThread());
+        checkState(lock.getReadHoldCount() == 0, "Cannot hold read lock when calling sendCoins (would deadlock on write lock upgrade)");
 
         // Commit the TX to the wallet immediately so the spent coins won't be reused.
         // TODO: We should probably allow the request to specify tx commit only after the network has accepted it.
@@ -4644,7 +4647,7 @@ public static class ExceededMaxTransactionSize extends CompletionException {}
      * @throws MultipleOpReturnRequested if there is more than one OP_RETURN output for the resultant transaction.
      */
     public void completeTx(SendRequest req) throws InsufficientMoneyException {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             checkArgument(!req.completed, "Given SendRequest has already been completed.");
             // Calculate the amount of value we need to import.
@@ -4771,7 +4774,7 @@ public void completeTx(SendRequest req) throws InsufficientMoneyException {
             req.completed = true;
             log.info("  completed: {}", req.tx);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -4782,7 +4785,7 @@ public void completeTx(SendRequest req) throws InsufficientMoneyException {
      * transaction will be complete in the end.</p>
      */
     public void signTransaction(SendRequest req) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             Transaction tx = req.tx;
             List<TransactionInput> inputs = tx.getInputs();
@@ -4829,7 +4832,7 @@ public void signTransaction(SendRequest req) {
             // resolve missing sigs if any
             new MissingSigResolutionSigner(req.missingSigsMode).signInputs(proposal, maybeDecryptingKeyBag);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -4865,7 +4868,7 @@ public List<TransactionOutput> calculateAllSpendCandidates() {
      * @param excludeUnsignable Whether to ignore outputs that we are tracking but don't have the keys to sign for.
      */
     public List<TransactionOutput> calculateAllSpendCandidates(boolean excludeImmatureCoinbases, boolean excludeUnsignable) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             List<TransactionOutput> candidates;
             if (vUTXOProvider == null) {
@@ -4883,7 +4886,7 @@ public List<TransactionOutput> calculateAllSpendCandidates(boolean excludeImmatu
             }
             return candidates;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -4931,7 +4934,7 @@ public boolean canSignFor(Script script) {
      * @return The list of candidates.
      */
     protected LinkedList<TransactionOutput> calculateAllSpendCandidatesFromUTXOProvider(boolean excludeImmatureCoinbases) {
-        checkState(lock.isHeldByCurrentThread());
+        // checkState(lock.isHeldByCurrentThread());
         UTXOProvider utxoProvider = checkNotNull(vUTXOProvider, "No UTXO provider has been set");
         LinkedList<TransactionOutput> candidates = Lists.newLinkedList();
         try {
@@ -4983,11 +4986,11 @@ protected List<UTXO> getStoredOutputsFromUTXOProvider() throws UTXOProviderExcep
 
     /** Returns the {@link CoinSelector} object which controls which outputs can be spent by this wallet. */
     public CoinSelector getCoinSelector() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return coinSelector;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -4998,11 +5001,11 @@ public CoinSelector getCoinSelector() {
      * operation by changing {@link SendRequest#coinSelector}.
      */
     public void setCoinSelector(CoinSelector coinSelector) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             this.coinSelector = checkNotNull(coinSelector);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -5020,11 +5023,11 @@ public void allowSpendingUnconfirmedTransactions() {
      * @return The UTXO provider.
      */
     @Nullable public UTXOProvider getUTXOProvider() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return vUTXOProvider;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -5038,12 +5041,12 @@ public void allowSpendingUnconfirmedTransactions() {
      * The association is not serialized.</p>
      */
     public void setUTXOProvider(@Nullable UTXOProvider provider) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             checkArgument(provider == null || provider.getParams().equals(params));
             this.vUTXOProvider = provider;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -5129,7 +5132,7 @@ public TxOffsetPair(Transaction tx, int offset) {
      */
     @Override
     public void reorganize(StoredBlock splitPoint, List<StoredBlock> oldBlocks, List<StoredBlock> newBlocks) throws VerificationException {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             // This runs on any peer thread with the block chain locked.
             //
@@ -5270,7 +5273,7 @@ public void reorganize(StoredBlock splitPoint, List<StoredBlock> oldBlocks, List
             informConfidenceListenersIfNotReorganizing();
             saveLater();
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -5304,7 +5307,7 @@ private void subtractDepth(int depthToSubtract, Collection<Transaction> transact
     public void beginBloomFilterCalculation() {
         if (bloomFilterGuard.incrementAndGet() > 1)
             return;
-        lock.lock();
+        lock.writeLock().lock();
         keyChainGroupLock.lock();
         //noinspection FieldAccessNotGuarded
         calcBloomOutPointsLocked();
@@ -5356,7 +5359,7 @@ public void endBloomFilterCalculation() {
             return;
         bloomOutPoints.clear();
         keyChainGroupLock.unlock();
-        lock.unlock();
+        lock.writeLock().unlock();
     }
 
     /**
@@ -5550,7 +5553,7 @@ public boolean checkForFilterExhaustion(FilteredBlock block) {
      */
     public void addExtension(WalletExtension extension) {
         String id = checkNotNull(extension).getWalletExtensionID();
-        lock.lock();
+        lock.writeLock().lock();
         try {
             if (extensions.containsKey(id))
                 throw new IllegalStateException("Cannot add two extensions with the same ID: " + id);
@@ -5559,7 +5562,7 @@ public void addExtension(WalletExtension extension) {
             else extensions.put(id, extension);
             saveNow();
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -5568,7 +5571,7 @@ public void addExtension(WalletExtension extension) {
      */
     public WalletExtension addOrGetExistingExtension(WalletExtension extension) {
         String id = checkNotNull(extension).getWalletExtensionID();
-        lock.lock();
+        lock.writeLock().lock();
         try {
             WalletExtension previousExtension = extensions.get(id);
             if (previousExtension == null) {
@@ -5582,7 +5585,7 @@ public WalletExtension addOrGetExistingExtension(WalletExtension extension) {
             saveNow();
             return extension;
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -5593,51 +5596,51 @@ public WalletExtension addOrGetExistingExtension(WalletExtension extension) {
      */
     public void addOrUpdateExtension(WalletExtension extension) {
         String id = checkNotNull(extension).getWalletExtensionID();
-        lock.lock();
+        lock.writeLock().lock();
         try {
             extensions.put(id, extension);
             saveNow();
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
     /** Returns a snapshot of all registered extension objects. The extensions themselves are not copied. */
     public Map<String, WalletExtension> getExtensions() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return ImmutableMap.copyOf(extensions);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     /** Returns a snapshot of all registered extension objects. The extensions themselves are not copied. */
     public Map<String, KeyChainGroupExtension> getKeyChainExtensions() {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return ImmutableMap.copyOf(keyChainExtensions);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
     
     /** checks for the existance of an extension */
     public boolean hasExtension(String id) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return extensions.containsKey(id) || keyChainExtensions.containsKey(id);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     public KeyChainGroupExtension getKeyChainExtension(String id) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return keyChainExtensions.get(id);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
      
@@ -5647,7 +5650,7 @@ public KeyChainGroupExtension getKeyChainExtension(String id) {
      * if already present.
      */
     public void deserializeExtension(WalletExtension extension, byte[] data) throws Exception {
-        lock.lock();
+        lock.writeLock().lock();
         keyChainGroupLock.lock();
         try {
             // This method exists partly to establish a lock ordering of wallet > extension.
@@ -5665,7 +5668,7 @@ public void deserializeExtension(WalletExtension extension, byte[] data) throws
             throw throwable;
         } finally {
             keyChainGroupLock.unlock();
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -5692,7 +5695,7 @@ private static class FeeCalculation {
 
     private FeeCalculation calculateFee(SendRequest req, Coin value, List<TransactionInput> originalInputs,
                                        boolean needAtLeastReferenceFee, List<TransactionOutput> candidates) throws InsufficientMoneyException {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         FeeCalculation result;
         Coin fee = Coin.ZERO;
         while (true) {
@@ -5863,7 +5866,7 @@ private int estimateBytesForSigning(CoinSelection selection) {
      */
     public void setTransactionBroadcaster(@Nullable org.bitcoinj.core.TransactionBroadcaster broadcaster) {
         Transaction[] toBroadcast = {};
-        lock.lock();
+        lock.writeLock().lock();
         try {
             if (vTransactionBroadcaster == broadcaster)
                 return;
@@ -5872,7 +5875,7 @@ public void setTransactionBroadcaster(@Nullable org.bitcoinj.core.TransactionBro
                 return;
             toBroadcast = pending.values().toArray(toBroadcast);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
         // Now use it to upload any pending transactions we have that are marked as not being seen by any peers yet.
         // Don't hold the wallet lock whilst doing this, so if the broadcaster accesses the wallet at some point there
@@ -6001,7 +6004,7 @@ public ListenableFuture<List<Transaction>> doMaintenance(@Nullable KeyParameter
     public ListenableFuture<List<Transaction>> doMaintenance(KeyChainGroupStructure structure,
             @Nullable KeyParameter aesKey, boolean signAndSend) throws DeterministicUpgradeRequiresPassword {
         List<Transaction> txns;
-        lock.lock();
+        lock.writeLock().lock();
         keyChainGroupLock.lock();
         try {
             txns = maybeRotateKeys(structure, aesKey, signAndSend);
@@ -6009,9 +6012,10 @@ public ListenableFuture<List<Transaction>> doMaintenance(KeyChainGroupStructure
                 return Futures.immediateFuture(txns);
         } finally {
             keyChainGroupLock.unlock();
-            lock.unlock();
+            lock.writeLock().unlock();
         }
-        checkState(!lock.isHeldByCurrentThread());
+        checkState(!lock.writeLock().isHeldByCurrentThread());
+        checkState(lock.getReadHoldCount() == 0, "Cannot hold read lock when broadcasting (would deadlock on write lock upgrade)");
         ArrayList<ListenableFuture<Transaction>> futures = new ArrayList<>(txns.size());
         TransactionBroadcaster broadcaster = vTransactionBroadcaster;
         for (Transaction tx : txns) {
@@ -6040,7 +6044,7 @@ public void onFailure(Throwable throwable) {
     @GuardedBy("keyChainGroupLock")
     private List<Transaction> maybeRotateKeys(KeyChainGroupStructure structure, @Nullable KeyParameter aesKey,
             boolean sign) throws DeterministicUpgradeRequiresPassword {
-        checkState(lock.isHeldByCurrentThread());
+        checkState(lock.writeLock().isHeldByCurrentThread());
         checkState(keyChainGroupLock.isHeldByCurrentThread());
         List<Transaction> results = Lists.newLinkedList();
         // TODO: Handle chain replays here.
@@ -6116,7 +6120,7 @@ private List<Transaction> maybeRotateKeys(KeyChainGroupStructure structure, @Nul
 
     @Nullable
     private Transaction rekeyOneBatch(long timeSecs, @Nullable KeyParameter aesKey, List<Transaction> others, boolean sign) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             // Build the transaction using some custom logic for our special needs. Last parameter to
             // KeyTimeCoinSelector is whether to ignore pending transactions or not.
@@ -6155,7 +6159,7 @@ private Transaction rekeyOneBatch(long timeSecs, @Nullable KeyParameter aesKey,
         } catch (VerificationException e) {
             throw new RuntimeException(e);  // Cannot happen.
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
     //endregion
@@ -6561,47 +6565,47 @@ public boolean isLockedOutput(Sha256Hash hash, long index) {
 
     @Override
     public boolean isLockedOutput(TransactionOutPoint outPoint) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return lockedOutputs.contains(outPoint);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     /** locks an unspent outpoint so that it cannot be spent */
     @Override
     public boolean lockOutput(TransactionOutPoint outPoint) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             log.info("lock output: {}:{}", outPoint.getHash(), outPoint.getIndex());
             return lockedOutputs.add(outPoint);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
     /** unlocks an outpoint so that it cannot be spent */
     public void unlockOutput(TransactionOutPoint outPoint) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             log.info("unlock output: {}:{}", outPoint.getHash(), outPoint.getIndex());
             lockedOutputs.remove(outPoint);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
     public void addManualNotifyConfidenceChangeTransaction(Transaction tx) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             manualConfidenceChangeTransactions.merge(tx, 1, Integer::sum);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
     public void removeManualNotifyConfidenceChangeTransaction(Transaction tx) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             Integer count = manualConfidenceChangeTransactions.get(tx);
             if (count != null) {
@@ -6612,7 +6616,7 @@ public void removeManualNotifyConfidenceChangeTransaction(Transaction tx) {
                 }
             }
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 }
diff --git a/core/src/main/java/org/bitcoinj/wallet/WalletEx.java b/core/src/main/java/org/bitcoinj/wallet/WalletEx.java
index db63cd7b0..248532629 100644
--- a/core/src/main/java/org/bitcoinj/wallet/WalletEx.java
+++ b/core/src/main/java/org/bitcoinj/wallet/WalletEx.java
@@ -201,7 +201,7 @@ public Coin getCoinJoinBalance() {
      */
     @Override
     public Coin getBalance(BalanceType balanceType) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             if (balanceType == BalanceType.AVAILABLE || balanceType == BalanceType.AVAILABLE_SPENDABLE) {
                 List<TransactionOutput> candidates = calculateAllSpendCandidates(true, balanceType == BalanceType.AVAILABLE_SPENDABLE);
@@ -236,7 +236,7 @@ public Coin getBalance(BalanceType balanceType) {
                 throw new AssertionError("Unknown balance type");  // Unreachable.
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -284,7 +284,7 @@ public boolean hasCollateralInputs(boolean onlyConfirmed) {
     }
 
     public boolean isSpent(Sha256Hash hash, long index) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             // TODO: should this be spent.contains(hash)?
             Transaction tx = unspent.get(hash);
@@ -294,18 +294,18 @@ public boolean isSpent(Sha256Hash hash, long index) {
 
             return tx.getOutput(index).getSpentBy() != null;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
     HashMap<TransactionOutPoint, Integer> mapOutpointRoundsCache = new HashMap<>();
     // Recursively determine the rounds of a given input (How deep is the CoinJoin chain for a given input)
     public int getRealOutpointCoinJoinRounds(TransactionOutPoint outPoint) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return getRealOutpointCoinJoinRounds(outPoint, 0);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -326,7 +326,7 @@ boolean isMine(TransactionOutput txout) {
     }
 
     boolean isMine(TransactionInput input) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             Transaction tx = getTransaction(input.getOutpoint().getHash());
             if (tx != null) {
@@ -335,24 +335,24 @@ boolean isMine(TransactionInput input) {
                 }
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
         return false;
     }
 
+    
     @VisibleForTesting
     public void markAsFullyMixed(TransactionOutPoint outPoint) {
-        lock.lock();
+        lock.writeLock().lock();
         try {
             mapOutpointRoundsCache.put(outPoint, 19);
         } finally {
-            lock.unlock();
+            lock.writeLock().unlock();
         }
     }
 
+    // only call from other getRealOutputCoinJoinRounds
     int getRealOutpointCoinJoinRounds(TransactionOutPoint outpoint, int rounds) {
-        checkState(lock.isHeldByCurrentThread());
-
         final int roundsMax = CoinJoinConstants.MAX_COINJOIN_ROUNDS + CoinJoinClientOptions.getRandomRounds();
         if (rounds >= roundsMax) {
             // there can only be roundsMax rounds max
@@ -501,7 +501,7 @@ public List<CompactTallyItem> selectCoinsGroupedByAddresses(boolean skipDenomina
                 DefaultCoinSelector.get().select(MAX_MONEY, candidates) :
                 ZeroConfCoinSelector.get().select(MAX_MONEY, candidates);
 
-        lock.lock();
+        lock.readLock().lock();
         try {
             // Try using the cache for already confirmed mixable inputs.
             // This should only be used if maxOupointsPerAddress was NOT specified.
@@ -615,7 +615,7 @@ public List<CompactTallyItem> selectCoinsGroupedByAddresses(boolean skipDenomina
 
             return vecTallyRet;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -624,7 +624,7 @@ public List<CompactTallyItem> selectCoinsGroupedByAddresses(boolean skipDenomina
      * Count the number of unspent outputs that have a certain value
      */
     public int countInputsWithAmount(Coin inputValue) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             int count = 0;
             for (TransactionOutput output : myUnspents) {
@@ -639,7 +639,7 @@ public int countInputsWithAmount(Coin inputValue) {
             }
             return count;
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -710,11 +710,11 @@ boolean getDestData(TransactionDestination dest, String key, StringBuilder value
     }
 
     boolean isUsedDestination(TransactionDestination destination) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             return isMine(destination) && getDestData(destination, "used", null);
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -748,7 +748,7 @@ public void availableCoins(ArrayList<TransactionOutput> vCoins,
                                Coin nMinimumSumAmount, int maximumCount,
                                int minDepth, int maxDepth
     ) {
-        lock.lock();
+        lock.readLock().lock();
         try {
             vCoins.clear();
             CoinType nCoinType = coinControl != null ? coinControl.getCoinType() : CoinType.ALL_COINS;
@@ -841,7 +841,7 @@ public void availableCoins(ArrayList<TransactionOutput> vCoins,
                 }
             }
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
@@ -905,7 +905,7 @@ public int compare(TransactionOutput transactionOutput, TransactionOutput transa
         }
     }
     public boolean selectDenominatedAmounts(Coin valueMax, Set<Coin> setAmountsRet) {
-        lock.lock();
+        lock.readLock().lock();
         try {
 
             Coin valueTotal = Coin.ZERO;
@@ -928,7 +928,7 @@ public boolean selectDenominatedAmounts(Coin valueMax, Set<Coin> setAmountsRet)
 
             return valueTotal.isGreaterThanOrEqualTo(CoinJoin.getSmallestDenomination());
         } finally {
-            lock.unlock();
+            lock.readLock().unlock();
         }
     }
 
diff --git a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
index f770f8f06..99d77d1be 100644
--- a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
+++ b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
@@ -19,6 +19,7 @@
 
 import org.bitcoinj.coinjoin.utils.CoinJoinTransactionType;
 import org.bitcoinj.core.*;
+import org.bitcoinj.utils.ContextPropagatingThreadFactory;
 import org.bitcoinj.core.TransactionConfidence.ConfidenceType;
 import org.bitcoinj.crypto.BLSLazySignature;
 import org.bitcoinj.crypto.KeyCrypter;
@@ -54,6 +55,9 @@
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static org.bitcoinj.wallet.Protos.TransactionType.COINJOIN_SEND;
@@ -103,6 +107,7 @@ public interface WalletFactory {
 
     private final WalletFactory factory;
     private KeyChainFactory keyChainFactory;
+    private volatile boolean lastSaveParallel = false;
 
     public WalletProtobufSerializer() {
         this(new WalletFactory() {
@@ -166,12 +171,7 @@ private int calculateOptimalBufferSize(Wallet wallet) {
             return walletWriteBufferSize;
         }
 
-        int transactionCount = wallet.getTransactions(false).size();
-        int watchedScriptCount = wallet.getWatchedScripts().size();
-        int keyCount = wallet.getKeyChainGroupSize();
-
-        // Estimate wallet complexity score
-        int complexityScore = transactionCount + (watchedScriptCount * 2) + keyCount;
+        int complexityScore = getComplexityScore(wallet);
 
         if (complexityScore < 100) {
             // Small wallet: 8KB buffer
@@ -188,6 +188,15 @@ private int calculateOptimalBufferSize(Wallet wallet) {
         }
     }
 
+    private static int getComplexityScore(Wallet wallet) {
+        int transactionCount = wallet.getTransactionCount(true);
+        int watchedScriptCount = wallet.getWatchedScripts().size();
+        int keyCount = wallet.getKeyChainGroupSize();
+
+        // Estimate wallet complexity score
+        return transactionCount + (watchedScriptCount * 2) + keyCount;
+    }
+
     /**
      * Formats the given wallet (transactions and keys) to the given output stream in protocol buffer format.<p>
      *
@@ -235,83 +244,292 @@ public String walletToText(Wallet wallet) {
      * additional data fields set, before serialization takes place.
      */
     public Protos.Wallet walletToProto(Wallet wallet) {
-        Protos.Wallet.Builder walletBuilder = Protos.Wallet.newBuilder();
-        walletBuilder.setNetworkIdentifier(wallet.getNetworkParameters().getId());
-        if (wallet.getDescription() != null) {
-            walletBuilder.setDescription(wallet.getDescription());
-        }
+        // Timing variables for profiling
+        long methodStart = System.currentTimeMillis();
+        final long[] txTime = {0};
+        final long[] keysTime = {0};
+        final long[] extensionsTime = {0};
+        final long[] friendRecvTime = {0};
+        final long[] friendSendTime = {0};
+        final int[] txCount = {0};
+
+        int complexityScore = getComplexityScore(wallet);
+        boolean isLargeWallet = complexityScore > 10_000;
+        if (isLargeWallet) {
+            // Capture all data from wallet on main thread (which holds the lock) to avoid deadlock
+            Iterable<WalletTransaction> walletTransactions = wallet.getWalletTransactions();
+            Collection<WalletExtension> walletExtensions = wallet.getExtensions().values();
+            Collection<KeyChainGroupExtension> keyChainExtensions = wallet.getKeyChainExtensions().values();
+            FriendKeyChainGroup receivingFromFriends = wallet.receivingFromFriendsGroup;
+            FriendKeyChainGroup sendingToFriends = wallet.sendingToFriendsGroup;
+
+            ExecutorService executor = Executors.newFixedThreadPool(4,
+                    new ContextPropagatingThreadFactory("wallet-serializer"));
+            try {
+                // Start heavy operations in parallel using pre-captured data
+                CompletableFuture<List<Protos.Transaction>> txFuture = CompletableFuture.supplyAsync(() -> {
+                    long start = System.currentTimeMillis();
+                    List<Protos.Transaction> txProtos = new ArrayList<>();
+                    for (WalletTransaction wtx : walletTransactions) {
+                        txProtos.add(makeTxProto(wtx));
+                    }
+                    txTime[0] = System.currentTimeMillis() - start;
+                    txCount[0] = txProtos.size();
+                    return txProtos;
+                }, executor);
+
+                CompletableFuture<List<Protos.Key>> keysFuture = CompletableFuture.supplyAsync(() -> {
+                    long start = System.currentTimeMillis();
+                    List<Protos.Key> keys = wallet.serializeKeyChainGroupToProtobuf();
+                    keysTime[0] = System.currentTimeMillis() - start;
+                    return keys;
+                }, executor);
+
+                CompletableFuture<List<Protos.Extension>> extensionsFuture = CompletableFuture.supplyAsync(() -> {
+                    long start = System.currentTimeMillis();
+                    List<Protos.Extension> exts = serializeExtensions(walletExtensions, keyChainExtensions);
+                    extensionsTime[0] = System.currentTimeMillis() - start;
+                    return exts;
+                }, executor);
+
+                CompletableFuture<List<Protos.Key>> friendKeysReceivingFuture = CompletableFuture.supplyAsync(() -> {
+                    long start = System.currentTimeMillis();
+                    List<Protos.Key> keys;
+                    if (receivingFromFriends != null && receivingFromFriends.hasKeyChains()) {
+                        keys = receivingFromFriends.serializeToProtobuf();
+                    } else {
+                        keys = Collections.emptyList();
+                    }
+                    friendRecvTime[0] = System.currentTimeMillis() - start;
+                    return keys;
+                }, executor);
+
+                CompletableFuture<List<Protos.Key>> friendKeysSendingFuture = CompletableFuture.supplyAsync(() -> {
+                    long start = System.currentTimeMillis();
+                    List<Protos.Key> keys;
+                    if (sendingToFriends != null && sendingToFriends.hasKeyChains()) {
+                        keys = sendingToFriends.serializeToProtobuf();
+                    } else {
+                        keys = Collections.emptyList();
+                    }
+                    friendSendTime[0] = System.currentTimeMillis() - start;
+                    return keys;
+                }, executor);
+
+                // Build wallet while waiting for parallel tasks
+                Protos.Wallet.Builder walletBuilder = Protos.Wallet.newBuilder();
+                walletBuilder.setNetworkIdentifier(wallet.getNetworkParameters().getId());
+                if (wallet.getDescription() != null) {
+                    walletBuilder.setDescription(wallet.getDescription());
+                }
 
-        for (WalletTransaction wtx : wallet.getWalletTransactions()) {
-            Protos.Transaction txProto = makeTxProto(wtx);
-            walletBuilder.addTransaction(txProto);
-        }
+                for (Script script : wallet.getWatchedScripts()) {
+                    Protos.Script protoScript =
+                            Protos.Script.newBuilder()
+                                    .setProgram(ByteString.copyFrom(script.getProgram()))
+                                    .setCreationTimestamp(script.getCreationTimeSeconds() * 1000)
+                                    .build();
+                    walletBuilder.addWatchedScript(protoScript);
+                }
+
+                // Populate the lastSeenBlockHash field.
+                Sha256Hash lastSeenBlockHash = wallet.getLastBlockSeenHash();
+                if (lastSeenBlockHash != null) {
+                    walletBuilder.setLastSeenBlockHash(hashToByteString(lastSeenBlockHash));
+                    walletBuilder.setLastSeenBlockHeight(wallet.getLastBlockSeenHeight());
+                }
+                if (wallet.getLastBlockSeenTimeSecs() > 0)
+                    walletBuilder.setLastSeenBlockTimeSecs(wallet.getLastBlockSeenTimeSecs());
+
+                // Populate the scrypt parameters.
+                KeyCrypter keyCrypter = wallet.getKeyCrypter();
+                if (keyCrypter == null) {
+                    walletBuilder.setEncryptionType(EncryptionType.UNENCRYPTED);
+                } else {
+                    walletBuilder.setEncryptionType(keyCrypter.getUnderstoodEncryptionType());
+                    if (keyCrypter instanceof KeyCrypterScrypt) {
+                        KeyCrypterScrypt keyCrypterScrypt = (KeyCrypterScrypt) keyCrypter;
+                        walletBuilder.setEncryptionParameters(keyCrypterScrypt.getScryptParameters());
+                    } else {
+                        throw new RuntimeException("The wallet has encryption of type '" + keyCrypter.getUnderstoodEncryptionType() + "' but this WalletProtobufSerializer does not know how to persist this.");
+                    }
+                }
 
-        walletBuilder.addAllKey(wallet.serializeKeyChainGroupToProtobuf());
+                if (wallet.getKeyRotationTime() != null) {
+                    long timeSecs = wallet.getKeyRotationTime().getTime() / 1000;
+                    walletBuilder.setKeyRotationTime(timeSecs);
+                }
 
-        for (Script script : wallet.getWatchedScripts()) {
-            Protos.Script protoScript =
-                    Protos.Script.newBuilder()
-                            .setProgram(ByteString.copyFrom(script.getProgram()))
-                            .setCreationTimestamp(script.getCreationTimeSeconds() * 1000)
-                            .build();
+                for (Map.Entry<String, ByteString> entry : wallet.getTags().entrySet()) {
+                    Protos.Tag.Builder tag = Protos.Tag.newBuilder().setTag(entry.getKey()).setData(entry.getValue());
+                    walletBuilder.addTags(tag);
+                }
 
-            walletBuilder.addWatchedScript(protoScript);
-        }
+                walletBuilder.setVersion(wallet.getVersion());
 
-        // Populate the lastSeenBlockHash field.
-        Sha256Hash lastSeenBlockHash = wallet.getLastBlockSeenHash();
-        if (lastSeenBlockHash != null) {
-            walletBuilder.setLastSeenBlockHash(hashToByteString(lastSeenBlockHash));
-            walletBuilder.setLastSeenBlockHeight(wallet.getLastBlockSeenHeight());
-        }
-        if (wallet.getLastBlockSeenTimeSecs() > 0)
-            walletBuilder.setLastSeenBlockTimeSecs(wallet.getLastBlockSeenTimeSecs());
-
-        // Populate the scrypt parameters.
-        KeyCrypter keyCrypter = wallet.getKeyCrypter();
-        if (keyCrypter == null) {
-            // The wallet is unencrypted.
-            walletBuilder.setEncryptionType(EncryptionType.UNENCRYPTED);
+                // Wait for parallel tasks and add results - join shorter tasks first, transactions last
+                walletBuilder.addAllKey(keysFuture.join());
+
+                List<Protos.Key> friendKeysReceiving = friendKeysReceivingFuture.join();
+                if (!friendKeysReceiving.isEmpty()) {
+                    walletBuilder.addAllKeysForFriends(friendKeysReceiving);
+                }
+
+                List<Protos.Key> friendKeysSending = friendKeysSendingFuture.join();
+                if (!friendKeysSending.isEmpty()) {
+                    walletBuilder.addAllKeysFromFriends(friendKeysSending);
+                }
+                // Join extensions and transactions in completion order - whichever finishes first gets added first
+                CompletableFuture.anyOf(extensionsFuture, txFuture).join();
+                if (extensionsFuture.isDone()) {
+                    walletBuilder.addAllExtension(extensionsFuture.join());
+                    walletBuilder.addAllTransaction(txFuture.join());
+                } else {
+                    walletBuilder.addAllTransaction(txFuture.join());
+                    walletBuilder.addAllExtension(extensionsFuture.join());
+                }
+
+                long buildStart = System.currentTimeMillis();
+                Protos.Wallet result = walletBuilder.build();
+                long buildTime = System.currentTimeMillis() - buildStart;
+
+                long totalTime = System.currentTimeMillis() - methodStart;
+                log.info("walletToProto (parallel={}) timing: {}ms total, transactions={}ms[{}tx], keys={}ms, extensions={}ms, " +
+                                "friendRecv={}ms, friendSend={}ms, build={}ms",
+                        complexityScore,
+                        totalTime, txTime[0], txCount[0], keysTime[0], extensionsTime[0],
+                        friendRecvTime[0], friendSendTime[0], buildTime);
+                lastSaveParallel = true;
+                return result;
+            } finally {
+                executor.shutdown();
+            }
         } else {
-            // The wallet is encrypted.
-            walletBuilder.setEncryptionType(keyCrypter.getUnderstoodEncryptionType());
-            if (keyCrypter instanceof KeyCrypterScrypt) {
-                KeyCrypterScrypt keyCrypterScrypt = (KeyCrypterScrypt) keyCrypter;
-                walletBuilder.setEncryptionParameters(keyCrypterScrypt.getScryptParameters());
+            // Serial mode - use nanoTime for sub-millisecond precision
+            long serialStart = System.nanoTime();
+
+            Protos.Wallet.Builder walletBuilder = Protos.Wallet.newBuilder();
+            walletBuilder.setNetworkIdentifier(wallet.getNetworkParameters().getId());
+            if (wallet.getDescription() != null) {
+                walletBuilder.setDescription(wallet.getDescription());
+            }
+            long initTime = System.nanoTime() - serialStart;
+
+            long txStart = System.nanoTime();
+            int txCountSerial = 0;
+            for (WalletTransaction wtx : wallet.getWalletTransactions()) {
+                Protos.Transaction txProto = makeTxProto(wtx);
+                walletBuilder.addTransaction(txProto);
+                txCountSerial++;
+            }
+            long txTimeSerial = System.nanoTime() - txStart;
+
+            long keysStart = System.nanoTime();
+            walletBuilder.addAllKey(wallet.serializeKeyChainGroupToProtobuf());
+            long keysTimeSerial = System.nanoTime() - keysStart;
+
+            long scriptsStart = System.nanoTime();
+            int scriptCount = 0;
+            for (Script script : wallet.getWatchedScripts()) {
+                Protos.Script protoScript =
+                        Protos.Script.newBuilder()
+                                .setProgram(ByteString.copyFrom(script.getProgram()))
+                                .setCreationTimestamp(script.getCreationTimeSeconds() * 1000)
+                                .build();
+                walletBuilder.addWatchedScript(protoScript);
+                scriptCount++;
+            }
+            long scriptsTime = System.nanoTime() - scriptsStart;
+
+            long metadataStart = System.nanoTime();
+            // Populate the lastSeenBlockHash field.
+            Sha256Hash lastSeenBlockHash = wallet.getLastBlockSeenHash();
+            if (lastSeenBlockHash != null) {
+                walletBuilder.setLastSeenBlockHash(hashToByteString(lastSeenBlockHash));
+                walletBuilder.setLastSeenBlockHeight(wallet.getLastBlockSeenHeight());
+            }
+            if (wallet.getLastBlockSeenTimeSecs() > 0)
+                walletBuilder.setLastSeenBlockTimeSecs(wallet.getLastBlockSeenTimeSecs());
+
+            // Populate the scrypt parameters.
+            KeyCrypter keyCrypter = wallet.getKeyCrypter();
+            if (keyCrypter == null) {
+                walletBuilder.setEncryptionType(EncryptionType.UNENCRYPTED);
             } else {
-                // Some other form of encryption has been specified that we do not know how to persist.
-                throw new RuntimeException("The wallet has encryption of type '" + keyCrypter.getUnderstoodEncryptionType() + "' but this WalletProtobufSerializer does not know how to persist this.");
+                walletBuilder.setEncryptionType(keyCrypter.getUnderstoodEncryptionType());
+                if (keyCrypter instanceof KeyCrypterScrypt) {
+                    KeyCrypterScrypt keyCrypterScrypt = (KeyCrypterScrypt) keyCrypter;
+                    walletBuilder.setEncryptionParameters(keyCrypterScrypt.getScryptParameters());
+                } else {
+                    throw new RuntimeException("The wallet has encryption of type '" + keyCrypter.getUnderstoodEncryptionType() + "' but this WalletProtobufSerializer does not know how to persist this.");
+                }
             }
-        }
 
-        if (wallet.getKeyRotationTime() != null) {
-            long timeSecs = wallet.getKeyRotationTime().getTime() / 1000;
-            walletBuilder.setKeyRotationTime(timeSecs);
-        }
+            if (wallet.getKeyRotationTime() != null) {
+                long timeSecs = wallet.getKeyRotationTime().getTime() / 1000;
+                walletBuilder.setKeyRotationTime(timeSecs);
+            }
 
-        populateExtensions(wallet, walletBuilder);
+            for (Map.Entry<String, ByteString> entry : wallet.getTags().entrySet()) {
+                Protos.Tag.Builder tag = Protos.Tag.newBuilder().setTag(entry.getKey()).setData(entry.getValue());
+                walletBuilder.addTags(tag);
+            }
+            walletBuilder.setVersion(wallet.getVersion());
+            long metadataTime = System.nanoTime() - metadataStart;
 
-        for (Map.Entry<String, ByteString> entry : wallet.getTags().entrySet()) {
-            Protos.Tag.Builder tag = Protos.Tag.newBuilder().setTag(entry.getKey()).setData(entry.getValue());
-            walletBuilder.addTags(tag);
-        }
+            long extStart = System.nanoTime();
+            populateExtensions(wallet, walletBuilder);
+            long extTimeSerial = System.nanoTime() - extStart;
 
-        // Populate the wallet version.
-        walletBuilder.setVersion(wallet.getVersion());
+            long friendRecvStart = System.nanoTime();
+            if(wallet.receivingFromFriendsGroup != null && wallet.receivingFromFriendsGroup.hasKeyChains()) {
+                List<Protos.Key> keys = wallet.receivingFromFriendsGroup.serializeToProtobuf();
+                walletBuilder.addAllKeysForFriends(keys);
+            }
+            long friendRecvTimeSerial = System.nanoTime() - friendRecvStart;
 
-        //Add FriendKeyChains:  Receiving
-        if(wallet.receivingFromFriendsGroup != null && wallet.receivingFromFriendsGroup.hasKeyChains()) {
-            List<Protos.Key> keys = wallet.receivingFromFriendsGroup.serializeToProtobuf();
-            walletBuilder.addAllKeysForFriends(keys);
+            long friendSendStart = System.nanoTime();
+            if(wallet.sendingToFriendsGroup != null && wallet.sendingToFriendsGroup.hasKeyChains()) {
+                List<Protos.Key> keys = wallet.sendingToFriendsGroup.serializeToProtobuf();
+                walletBuilder.addAllKeysFromFriends(keys);
+            }
+            long friendSendTimeSerial = System.nanoTime() - friendSendStart;
+
+            long buildStart = System.nanoTime();
+            Protos.Wallet result = walletBuilder.build();
+            long buildTimeSerial = System.nanoTime() - buildStart;
+
+            long totalTime = System.currentTimeMillis() - methodStart;
+            // Convert nanoTime to milliseconds for logging
+            log.info("walletToProto (serial={}) timing: {}ms total, init={}ms, tx={}ms[{}], keys={}ms, " +
+                            "scripts={}ms[{}], metadata={}ms, ext={}ms, friendRecv={}ms, friendSend={}ms, build={}ms",
+                    complexityScore,
+                    totalTime, initTime/1_000_000, txTimeSerial/1_000_000, txCountSerial, keysTimeSerial/1_000_000,
+                    scriptsTime/1_000_000, scriptCount, metadataTime/1_000_000, extTimeSerial/1_000_000,
+                    friendRecvTimeSerial/1_000_000, friendSendTimeSerial/1_000_000, buildTimeSerial/1_000_000);
+            lastSaveParallel = false;
+            return result;
         }
+    }
 
-        //Add FriendKeyChains:  Sending
-        if(wallet.sendingToFriendsGroup != null && wallet.sendingToFriendsGroup.hasKeyChains()) {
-            List<Protos.Key> keys = wallet.sendingToFriendsGroup.serializeToProtobuf();
-            walletBuilder.addAllKeysFromFriends(keys);
+    private static List<Protos.Extension> serializeExtensions(Collection<WalletExtension> walletExtensions,
+                                                               Collection<KeyChainGroupExtension> keyChainExtensions) {
+        List<Protos.Extension> extensions = new ArrayList<>();
+        for (WalletExtension extension : walletExtensions) {
+            Protos.Extension.Builder proto = Protos.Extension.newBuilder();
+            proto.setId(extension.getWalletExtensionID());
+            proto.setMandatory(extension.isWalletExtensionMandatory());
+            proto.setData(ByteString.copyFrom(extension.serializeWalletExtension()));
+            extensions.add(proto.build());
         }
-
-        return walletBuilder.build();
+        for (KeyChainGroupExtension extension : keyChainExtensions) {
+            Protos.Extension.Builder proto = Protos.Extension.newBuilder();
+            proto.setId(extension.getWalletExtensionID());
+            proto.setMandatory(extension.isWalletExtensionMandatory());
+            proto.setData(ByteString.copyFrom(extension.serializeWalletExtension()));
+            extensions.add(proto.build());
+        }
+        return extensions;
     }
 
     private static void populateExtensions(Wallet wallet, Protos.Wallet.Builder walletBuilder) {
@@ -1166,4 +1384,8 @@ public static boolean isWallet(InputStream is) {
             return false;
         }
     }
+
+    public boolean isLastSaveParallel() {
+        return lastSaveParallel;
+    }
 }
diff --git a/core/src/test/java/org/bitcoinj/store/WalletProtobufSerializerTest.java b/core/src/test/java/org/bitcoinj/store/WalletProtobufSerializerTest.java
index 72b3efb9b..7a3cde00a 100644
--- a/core/src/test/java/org/bitcoinj/store/WalletProtobufSerializerTest.java
+++ b/core/src/test/java/org/bitcoinj/store/WalletProtobufSerializerTest.java
@@ -160,7 +160,7 @@ public void oneTx() throws Exception {
         assertEquals(Protos.Key.Type.ORIGINAL, walletProto.getKey(0).getType());
         assertEquals(0, walletProto.getExtensionCount());
         assertEquals(1, walletProto.getTransactionCount());
-        assertEquals(18, walletProto.getKeyCount());
+        assertEquals(6, walletProto.getKeyCount());
         
         Protos.Transaction t1p = walletProto.getTransaction(0);
         assertEquals(0, t1p.getBlockHashCount());
diff --git a/core/src/test/java/org/bitcoinj/wallet/LargeCoinJoinWalletTest.java b/core/src/test/java/org/bitcoinj/wallet/LargeCoinJoinWalletTest.java
index f24e141d6..ba28517ba 100644
--- a/core/src/test/java/org/bitcoinj/wallet/LargeCoinJoinWalletTest.java
+++ b/core/src/test/java/org/bitcoinj/wallet/LargeCoinJoinWalletTest.java
@@ -28,6 +28,7 @@
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionInput;
 import org.bitcoinj.params.TestNet3Params;
+import org.bitcoinj.script.Script;
 import org.bitcoinj.utils.BriefLogFormatter;
 import org.junit.Before;
 import org.junit.Ignore;
@@ -46,6 +47,7 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
 public class LargeCoinJoinWalletTest {
@@ -516,6 +518,25 @@ public void walletConsistencyAndCachingPerformanceTest() throws IOException, Unr
         }
     }
 
+    @Test
+    public void walletProtoSaveTest() {
+        WalletProtobufSerializer serializer = new WalletProtobufSerializer();
+        Protos.Wallet fullWalletProto = serializer.walletToProto(wallet);
+        assertTrue(serializer.isLastSaveParallel());
+
+        wallet.reset();
+        Protos.Wallet resetWalletProto = serializer.walletToProto(wallet);
+        assertTrue(serializer.isLastSaveParallel());
+
+        assertNotEquals(0, fullWalletProto.getTransactionCount());
+        assertEquals(0, resetWalletProto.getTransactionCount());
+
+        Wallet smallWallet = Wallet.createDeterministic(wallet.getParams(), Script.ScriptType.P2PKH);
+        Protos.Wallet smallWalletProto = serializer.walletToProto(smallWallet);
+        assertFalse(serializer.isLastSaveParallel());
+        assertEquals(0, smallWalletProto.getTransactionCount());
+    }
+    
     /**
      * Compare two wallets for transaction consistency
      */