Actually use the value of --threads in compressors

src/cli/mod.rs

@@ -13,7 +13,7 @@ use fs_err as fs;
 pub use self::args::{CliArgs, Subcommand};
 use crate::{
     accessible::set_accessible,
-    utils::{is_path_stdin, logger::set_log_display_level, FileVisibilityPolicy},
+    utils::{is_path_stdin, logger::set_log_display_level, threads::set_thread_count, FileVisibilityPolicy},
     QuestionPolicy,
 };
 
@@ -29,6 +29,11 @@ impl CliArgs {
         set_accessible(args.accessible);
         set_log_display_level(args.quiet);
 
+        match args.threads {
+            Some(0) | None => {}
+            Some(threads) => set_thread_count(threads),
+        }
+
         let (Subcommand::Compress { files, .. }
         | Subcommand::Decompress { files, .. }
         | Subcommand::List { archives: files, .. }) = &mut args.cmd;

src/commands/compress.rs

@@ -12,7 +12,11 @@ use crate::{
     archive,
     commands::warn_user_about_loading_zip_in_memory,
     extension::{split_first_compression_format, CompressionFormat::*, Extension},
-    utils::{io::lock_and_flush_output_stdio, user_wants_to_continue, FileVisibilityPolicy},
+    utils::{
+        io::lock_and_flush_output_stdio,
+        threads::{logical_thread_count, physical_thread_count},
+        user_wants_to_continue, FileVisibilityPolicy,
+    },
     QuestionAction, QuestionPolicy, BUFFER_CAPACITY,
 };
 
@@ -52,6 +56,8 @@ pub fn compress_files(
                     .compression_level(
                         level.map_or_else(Default::default, |l| gzp::Compression::new((l as u32).clamp(0, 9))),
                     )
+                    .num_threads(logical_thread_count())
+                    .expect("gpz: num_threads must be greater than 0")
                     .from_writer(encoder);
                 parz
             }),
@@ -84,7 +90,7 @@ pub fn compress_files(
                 let dict_size = options.lzma_options.dict_size as u64;
                 options.set_block_size(NonZeroU64::new(dict_size));
                 // Use up to 256 PHYSICAL cores for compression
-                let writer = lzma_rust2::XzWriterMt::new(encoder, options, num_cpus::get_physical() as u32)?;
+                let writer = lzma_rust2::XzWriterMt::new(encoder, options, physical_thread_count() as u32)?;
                 Box::new(writer.auto_finish())
             }
             Lzip => {
@@ -99,6 +105,8 @@ pub fn compress_files(
                     .compression_level(gzp::par::compress::Compression::new(
                         level.map_or_else(Default::default, |l| (l as u32).clamp(0, 9)),
                     ))
+                    .num_threads(logical_thread_count())
+                    .expect("gpz: num_threads must be greater than 0")
                     .from_writer(encoder);
 
                 parz
@@ -111,7 +119,7 @@ pub fn compress_files(
                     }),
                 )?;
                 // Use all available PHYSICAL cores for compression
-                zstd_encoder.multithread(num_cpus::get_physical() as u32)?;
+                zstd_encoder.multithread(physical_thread_count() as u32)?;
                 Box::new(zstd_encoder.auto_finish())
             }
             Brotli => {

src/utils/mod.rs

@@ -10,6 +10,7 @@ mod fs;
 pub mod io;
 pub mod logger;
 mod question;
+pub mod threads;
 
 pub use self::{
     file_visibility::FileVisibilityPolicy,

src/utils/threads.rs

@@ -0,0 +1,20 @@
+use std::sync::OnceLock;
+
+static USER_DEFINED_THREAD_COUNT: OnceLock<usize> = OnceLock::new();
+
+pub fn logical_thread_count() -> usize {
+    USER_DEFINED_THREAD_COUNT.get().copied().unwrap_or(num_cpus::get())
+}
+
+pub fn physical_thread_count() -> usize {
+    USER_DEFINED_THREAD_COUNT
+        .get()
+        .copied()
+        .unwrap_or(num_cpus::get_physical())
+}
+
+pub fn set_thread_count(value: usize) {
+    if USER_DEFINED_THREAD_COUNT.get().is_none() {
+        USER_DEFINED_THREAD_COUNT.set(value).unwrap();
+    }
+}