Вопрос

Существуют ли в Rust какие-либо стратегии/рекомендации по обработке редко обновляемых, совместно используемых и изменяемых значений?

Пример

struct SharedMutableResource {
    some_value: String,

    // time at which value must be refreshed
    // probably daily or weekly
    expires_at: chrono::DateTime<chrono::Utc>, 
}

impl SharedMutableResource {
    pub fn get_some_value(&mut self) -> &str {
        if self.expires_at < Utc::now() {
            // some refresh method
            self.some_value = some_new_value;
        }

        self.some_value.as_str()
    }
}

struct AsyncRequiresResource {
    resource: Arc<SharedMutableResource>,
}

impl AsyncRequiresResource {
    pub fn borrow_resource(&self) -> Value {
        // is there any way to avoid borrowing as mut here for every request
        let some_value = self.resource.get_mut().get_some_value();
        
        // do something with the value
    }
}

Некоторый контекст

Я пытаюсь создать реализацию ротации ключей для подписи моих JWT, в идеале меняя ключи от ежедневного до еженедельного. Эти запросы будут поступать асинхронно и должны получить доступ к значению ключа для подписи и проверки токенов. Однако ключи будут чередоваться в зависимости от временных ограничений, поэтому их можно будет обновить по любому запросу.

Проблема

Помня о безопасности потоков, прямо сейчас я пытаюсь найти оптимальный способ обработки доступа к ключу. В идеале он должен храниться в памяти в стеке во время выполнения, так как я понимаю, что это самый быстрый метод извлечения (для большинства запросов потребуется JWT, и поэтому я хотел бы убедиться, что во время этого процесса я избегаю как можно больше замедлений, таких как подключение к db или операции ввода-вывода). Однако, поскольку это должно быть потокобезопасным, у меня есть две идеи, но ни одна из них не кажется очень хорошей.

1. Используйте асинхронные дуги (Arc<Mutex> вместо Arc)
   Плюсы

   • Безопасность потока сохраняется
   • Очень небольшая модификация того, что у меня сейчас есть

   Минусы

   • Атомарные операции для каждого отдельного запроса
   • В основном все запросы становятся синхронными, поскольку они ожидают блокировки, чтобы запрос мог быть обработан.

2. Используйте асинхронный поток (thread::spawn(task))
   Плюсы

   • Безопасность потока сохраняется
   • Позволяет улучшить асинхронную обработку запросов

   Минусы

   • Кажется расточительным создавать целый поток, который будет запускаться только один раз в день/неделю, чтобы внести одно изменение.

Резюме

По сути, оба способа кажутся мне довольно расточительными для изменений, которые случаются очень редко. Я бы не беспокоился о дополнительных накладных расходах для фактического изменения значения, поскольку это происходит так нечасто, но для того, чтобы поддерживать высокие скорости чтения в рамках моих (по общему признанию, наложенных мной) ограничений, мне трудно найти путь вперед. Есть ли какие-либо инструменты, стратегии или какие-то ограничения, которые мне нужно отбросить / иметь неправильное понимание, чтобы разрешить нечасто изменяемые данные с высокой скоростью чтения?