diff --git a/internal/ceres/block_jacobi_preconditioner.cc b/internal/ceres/block_jacobi_preconditioner.cc
index b7ee002..81eb419 100644
--- a/internal/ceres/block_jacobi_preconditioner.cc
+++ b/internal/ceres/block_jacobi_preconditioner.cc
@@ -75,13 +75,14 @@
                   MatrixRef m(cell_info->values, row_stride, col_stride);
                   ConstMatrixRef b(
                       values + cell.position, row_block_size, col_block_size);
-                  std::lock_guard<std::mutex> l(cell_info->m);
+                  auto lock =
+                      MakeConditionalLock(options_.num_threads, cell_info->m);
                   // clang-format off
                   MatrixTransposeMatrixMultiply<Eigen::Dynamic, Eigen::Dynamic,
-                   Eigen::Dynamic,Eigen::Dynamic, 1>(
-                   values + cell.position, row_block_size,col_block_size,
-                   values + cell.position, row_block_size,col_block_size,
-                   cell_info->values,r, c,row_stride,col_stride);
+                      Eigen::Dynamic,Eigen::Dynamic, 1>(
+                          values + cell.position, row_block_size,col_block_size,
+                          values + cell.position, row_block_size,col_block_size,
+                          cell_info->values,r, c,row_stride,col_stride);
                   // clang-format on
                 }
               });
@@ -193,7 +194,7 @@
           // MatrixTransposeMatrixMultiply, otherwise we could use it
           // here to further speed up the following expression.
           auto b = row_block.middleCols(c, col_block_size);
-          std::lock_guard<std::mutex> l(locks_[col]);
+          auto lock = MakeConditionalLock(options_.num_threads, locks_[col]);
           m.noalias() += b.transpose() * b;
           c += col_block_size;
         }
diff --git a/internal/ceres/parallel_for.h b/internal/ceres/parallel_for.h
index 3c3d887..234c7db 100644
--- a/internal/ceres/parallel_for.h
+++ b/internal/ceres/parallel_for.h
@@ -33,6 +33,7 @@
 #define CERES_INTERNAL_PARALLEL_FOR_H_
 
 #include <functional>
+#include <mutex>
 
 #include "ceres/context_impl.h"
 #include "ceres/internal/disable_warnings.h"
@@ -41,6 +42,13 @@
 
 namespace ceres::internal {
 
+// Use a dummy mutex if num_threads = 1.
+inline decltype(auto) MakeConditionalLock(const int num_threads,
+                                          std::mutex& m) {
+  return (num_threads == 1) ? std::unique_lock<std::mutex>{}
+                            : std::unique_lock<std::mutex>{m};
+}
+
 // Returns the maximum number of threads supported by the threading backend
 // Ceres was compiled with.
 CERES_NO_EXPORT
diff --git a/internal/ceres/schur_eliminator_impl.h b/internal/ceres/schur_eliminator_impl.h
index 62b7487..884c0cf 100644
--- a/internal/ceres/schur_eliminator_impl.h
+++ b/internal/ceres/schur_eliminator_impl.h
@@ -1,5 +1,5 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2015 Google Inc. All rights reserved.
+// Copyright 2022 Google Inc. All rights reserved.
 // http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
@@ -205,8 +205,6 @@
                     const int block_size = bs->cols[i].size;
                     typename EigenTypes<Eigen::Dynamic>::ConstVectorRef diag(
                         D + bs->cols[i].position, block_size);
-
-                    std::lock_guard<std::mutex> l(cell_info->m);
                     MatrixRef m(cell_info->values, row_stride, col_stride);
                     m.block(r, c, block_size, block_size).diagonal() +=
                         diag.array().square().matrix();
@@ -409,7 +407,7 @@
       const int block_id = row.cells[c].block_id;
       const int block_size = bs->cols[block_id].size;
       const int block = block_id - num_eliminate_blocks_;
-      std::lock_guard<std::mutex> l(*rhs_locks_[block]);
+      auto lock = MakeConditionalLock(num_threads_, *rhs_locks_[block]);
       // clang-format off
       MatrixTransposeVectorMultiply<kRowBlockSize, kFBlockSize, 1>(
           values + row.cells[c].position,
@@ -549,7 +547,7 @@
           lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
       if (cell_info != nullptr) {
         const int block2_size = bs->cols[it2->first].size;
-        std::lock_guard<std::mutex> l(cell_info->m);
+        auto lock = MakeConditionalLock(num_threads_, cell_info->m);
         // clang-format off
         MatrixMatrixMultiply
             <kFBlockSize, kEBlockSize, kEBlockSize, kFBlockSize, -1>(
@@ -626,7 +624,7 @@
     CellInfo* cell_info =
         lhs->GetCell(block1, block1, &r, &c, &row_stride, &col_stride);
     if (cell_info != nullptr) {
-      std::lock_guard<std::mutex> l(cell_info->m);
+      auto lock = MakeConditionalLock(num_threads_, cell_info->m);
       // This multiply currently ignores the fact that this is a
       // symmetric outer product.
       // clang-format off
@@ -647,7 +645,7 @@
           lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
       if (cell_info != nullptr) {
         const int block2_size = bs->cols[row.cells[j].block_id].size;
-        std::lock_guard<std::mutex> l(cell_info->m);
+        auto lock = MakeConditionalLock(num_threads_, cell_info->m);
         // clang-format off
         MatrixTransposeMatrixMultiply
             <Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, 1>(
@@ -681,7 +679,7 @@
     CellInfo* cell_info =
         lhs->GetCell(block1, block1, &r, &c, &row_stride, &col_stride);
     if (cell_info != nullptr) {
-      std::lock_guard<std::mutex> l(cell_info->m);
+      auto lock = MakeConditionalLock(num_threads_, cell_info->m);
       // block += b1.transpose() * b1;
       // clang-format off
       MatrixTransposeMatrixMultiply
@@ -702,7 +700,7 @@
           lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
       if (cell_info != nullptr) {
         // block += b1.transpose() * b2;
-        std::lock_guard<std::mutex> l(cell_info->m);
+        auto lock = MakeConditionalLock(num_threads_, cell_info->m);
         // clang-format off
         MatrixTransposeMatrixMultiply
             <kRowBlockSize, kFBlockSize, kRowBlockSize, kFBlockSize, 1>(