How to cancel processing of async commands

[minetake01]

Hello!
When the same command is called during the processing of an asynchronous command, how can I discard the old processing?

You are trying to execute an asynchronous command that takes several seconds to process each time a value is changed. However, if the value is changed too fast, a large number of threads will be created, resulting in 100% CPU utilization.

[minetake01]

I solved mine by keeping a count in Tauri's Manager, adding 1 to the count each time the command is called, and terminating the process if the value has changed between when the processing function was called and now.

[percy507]

Hello, I am facing the same problem😭. Do you mind share your code?

[minetake01]

Note that this code is not a complete solution to this problem. (This method is only applicable if the process is taking a long time due to a large amount of repetitive processing.)

First, make Tauri keep the state of the counter as follows.

pub struct ProcessCount{
    test_process: Arc<Mutex<i32>>,
}

fn main() {
	tauri::Builder::default()
		.manage(ProcessCount {
			test_process: Arc::new(Mutex::new(0)),
		})
        	.run(tauri::generate_context!())
        	.expect("error while running tauri application");
}

When the command is called, add 1 to this counter and keep the state of the counter at the start of processing.
Then, each time iterations are performed, the current state of the counter is compared with the state of the counter at the start of processing, and if different, the processing is aborted at that point.

#[tauri::command]
pub async fn test_command(
    process_count: State<'_, ProcessCount>,
) -> Result<Vec<i32>, ()> {
    let count = process_count.test_process.clone();
    *count.lock().unwrap() += 1;

    let result = test_process(count.clone());
    result.ok_or(())
}

fn test_process(process_count: Arc<Mutex<i32>>) -> Option<Vec<i32>> {
	let orig = *process_count.lock().unwrap();

	let mut vec = vec![];
	for i in 0..1000000 {
		if *process_count.lock().unwrap() != orig {
			return None;
		}
		// Processing that does not take that long.
		vec.push(i);
	}
	Some(vec)
}

[percy507]

Thanks. This is an acceptable compromise.👍

[HezinTUKE]

And did you get a deadlock after calling *process_count.lock().unwrap() in a loop?

[minetake01]

The first lock is unlocked with .unwrap(), so no deadlock occurs.