Можно ли преобразовать &[T] или Vec<T> в Arc<Mutex<[T]>>?

Я не знаю, каково ваше точное намерение. Я предполагаю, что вам нужен массив, разделяемый потоками.

Как указано в комментарии, массив должен иметь размер. Если этот размер не задан во время компиляции, вам необходимо запомнить массив переменной длины (выделенный в куче) вместе с его размером. Box<[T]> это удобно.

Пожалуйста, найдите ниже три примера. Первый использует ссылку+клон, второй перемещает исходные данные. В случае, если размер известен во время компиляции, третий пример позволяет избежать дополнительной косвенности, о которой вы заботитесь.

Обратите внимание, что если нам нужна только одна косвенность, то она должна использоваться различными контекстами (потоками), чтобы ссылаться на один и тот же мьютекс. Это означает, что блок памяти, содержащий этот мьютекс, должен непосредственно содержать все данные. Если этот размер неизвестен во время компиляции, это звучит как уродливый хак структуры с переменным размером, который мы иногда встречаем в C (довольно подверженный ошибкам, не совсем в духе Rust).

use std::sync::{Arc, Mutex};

fn arc_mutex_from_slice_clone<T: Clone>(v: &[T]) -> Arc<Mutex<Box<[T]>>> {
    let owned = v.to_owned();
    let boxed = owned.into_boxed_slice();
    Arc::new(Mutex::new(boxed))
}

fn arc_mutex_from_vec<T>(v: Vec<T>) -> Arc<Mutex<Box<[T]>>> {
    let boxed = v.into_boxed_slice();
    Arc::new(Mutex::new(boxed))
}

fn arc_mutex_sized_from_vec<T: std::fmt::Debug, const N: usize>(
    v: Vec<T>
) -> Arc<Mutex<[T; N]>> {
    let array = v.try_into().unwrap();
    Arc::new(Mutex::new(array))
}

fn main() {
    let v1 = vec![1, 2, 3];
    let m1 = arc_mutex_from_slice_clone(v1.as_slice());
    println!("m1: {:?}", m1);
    // v1 is still usable since m1 contains a clone
    println!("v: {:?}", v1);
    let m2 = arc_mutex_from_vec(v1);
    println!("m2: {:?}", m2);
    // v1 is not usable anymore since is it moved int m2
    // println!("v: {:?}", v1);
    //
    let v2 = vec![6, 7, 8, 9];
    let m3 = arc_mutex_sized_from_vec::<_, 4>(v2);
    println!("m3: {:?}", m3);
}
/*
m1: Mutex { data: [1, 2, 3], poisoned: false, .. }
v: [1, 2, 3]
m2: Mutex { data: [1, 2, 3], poisoned: false, .. }
m3: Mutex { data: [6, 7, 8, 9], poisoned: false, .. }
*/

На момент написания для безопасного Rust вы можете сделать это, но только если размер массива при распределении известен во время компиляции:

let v: Arc<Mutex<[u8]>> = Arc::new(Mutex::new([0;16]));

По сути, это приводит Arc<Mutex<[u8;16]>> к Arc<Mutex<[u8]>>.

Однако в настоящее время нет способа сделать это безопасно с массивом, размер которого известен только во время выполнения. Сложность заключается в том, что вам нужно будет создать неразмерный Mutex<[u8]> и переместить его в конструктор Arc, но перемещение значений в настоящее время требует, чтобы компилятор знал их размеры.

RFC 1909 может помочь ситуации, но он открыт с 2017 года и конца ему не видно.

Что касается unsafe... Вы могли бы выделить раздел памяти, который может содержать как Mutex<()>, так и массив, и обращаться к нему вручную через смещения байтов. Однако вы должны быть осторожны - вам может потребоваться дополнение между мьютексом и массивом, чтобы удовлетворить выравнивание элемента массива, и убедитесь, что вы не нарушаете никаких гарантий псевдонимов или провидения.