Дмитрий Беляев

fn main() {
    let src: Vec<[u8; 1]> = (0..u8::MAX).map(|i| [i]).collect();
    let mut info =  Vec::<&str>::with_capacity(u8::MAX.into());
    for u in &src {
        let t = std::str::from_utf8(&*u).unwrap_or("Err");
        info.push(t);
    }
    println!("\n{:#?}", info);
}

но надо понимать, что info будет связан лайфтаймом с src, чтоб избавится от этого нужно хранить в нём не &str а String или Box<str>

fn main() {
    let info: Vec<Box<str>> = (0..u8::MAX).map(|i| {
        let u = [i];
        let t = std::str::from_utf8(&u).unwrap_or("Err");
        t.into()
    }).collect();
    println!("\n{:#?}", info);
}

Очень упрощенно HashMap можно представить следующим образом:

pub struct HashMap<K, V> {
    table: Table<(K, V)>,
}

struct Table<T> {
    // битовая маска занятых ячеек в items
    mask: u64,
    items: Box<[std::mem::MaybeUninit<Item<T>>; 64]>,
    len: usize,
}

struct Item<T> {
    data: T,
    next: Option<std::ptr::NonNull<Item<T>>>,
}

А Entry так:

pub enum Entry<'a, K, V> {
    Vacant(VacantEntry<'a, K, V>),
    Occupied(OccupiedEntry<'a, K, V>),
}

pub struct VacantEntry<'a, K, V> {
    hash: u64,
    key: K,
    table: &'a mut Table<(K, V)>,
}

pub struct OccupiedEntry<'a, K, V> {
    elem: Bucket<(K, V)>,
    table: &'a mut Table<(K, V)>,
}

// указатель на Item.data
struct Bucket<T> {
    ptr: std::ptr::NonNull<T>,
}

Как можно заметить у Entry есть лайфтайм, который связывает его с HashMap от которой он создан. А внутри есть мутабельная ссылка с этим лайфтаймом на таблицу с данными HashMap.
Метод entry упрощенно выглядит примерно так:

impl<K, V> HashMap<K, V> {
    pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V>
    where
        K: Eq + std::hash::Hash,
    {
        use std::hash::Hasher as _;
        let mut hasher = self.get_hasher();
        key.hash(&mut hasher);
        let hash = hasher.finish();

        if let Some(elem) = self.table.find(hash, |(k, _)| key == *k) {
            Entry::Occupied(OccupiedEntry {
                elem,
                table: &mut self.table,
            })
        } else {
            Entry::Vacant(VacantEntry {
                hash,
                key,
                table: &mut self.table,
            })
        }
    }

    fn get_hasher(&self) -> impl std::hash::Hasher {
        todo!()
    }
}

impl<T> Table<T> {
    fn find(&self, hash: u64, is_match: impl FnMut(&T) -> bool) -> Option<Bucket<T>> {
        todo!()
    }
}

Как видим мутабельная ссылка всё же есть, только она завернута в структуру, так как одной этой ссылки не достаточно, так как в случае свободной Entry нам нужно хранить ещё и ключ, а заодно и хэш (чтоб не считать его снова), а в случае занятой - указатель на бакет (область памяти где храниться пара ключ и значение).

Крэйт - это в первую очередь дерево модулей. Каждый крэйт содержит как минимум 1 корневой модуль (обычно это main.rs или lib.rs, но так же это могут быть модули доп бинарников, модули интеграционных тестов, модули примеров). Так же к крэйту относятся модули, которые объявили в других модулях этого крейта (ключевое слово mod).
Помимо этого крэйт - это сущность которой оперирует компилятор rustc, крэйт является единицей компиляции, то есть в rustc на компиляцию попадает крэйт целиком (на вход подаём корневой модуль, а он уже сам бегает по всему дереву согласно объявлениям mod).

Пакет - это сущность которой оперирует cargo. Компилятор rustc ничего не знает про пакеты. По простому пакет это папка с файлом Cargo.toml, в котором есть секция package (бывают ещё Cargo.toml объявляющие только workspace). Пакет состоит из крейтов, притом должен быть как минимум 1 крейт бинарника или библиотеки, а библиотечный крейт может быть только 1 или отсутствовать вовсе.
Пакет - это то, что публикуется в registry (такие как crates.io).
Так же в зависимостях мы указываем именно пакеты (но только те, что содержат крэйт-библиотеку).
Так же именно пакеты указываются в команде cargo install, при этом будут собраны все бинарные крейты входящие в пакет, а получившиеся исполняемые файлы будут помещены .cargo/bin

Cargo считывает все конфигурационные файлы начиная с папки проекта (там где файл Cargo.lock и папка target) и во всех его родительских папках, а так же в домашней папке cargo.
https://doc.rust-lang.org/cargo/reference/config.h...
То есть в данном примере будут работать оба этих файла.

Я бы проверял в сторону работает ли это условие:
cfg(all(windows, target_env="msvc"))

Написать derive макрос. Правда стоит соизмерить трудозатраты.
Или написать обычный декларативный макрос (не так гибко как derive, но написать проще).

А вообще, Rust не Java/C#, trait - не интерфейс.
Если приведете не абстрактные примеры, вполне возможно, что задача решается проще.

Вам же явно написали:#![feature(custom_test_frameworks)]

Атрибуты вида #[something] применяются к айтему под ними, атрибуты вида #![something] - к айтему в котором они находятся (должны находится в самом верху).
https://doc.rust-lang.org/reference/attributes.html

Ну и еще, feature работает только в nightly тулчейне.

Онлайн запускалка кода (плэйграунд): https://play.rust-lang.org
Официальный список задач для тренировки от создателей языка: https://github.com/rust-lang/rustlings
ну и + то что уже Василий Банников написал

Кэширование, сжатие, https все же лучше на nginx переложить

Сумбурный вопрос, но если правильно понял, то автор хочет получить Vec<&str> элементы которого ссылаются на исходный вектор байт и в каждом элементе строка из 1 символа:

let u01 = vec![59, 13, 10, 32, 47, 42];
let u01_str = std::str::from_utf8(&u01).expect("invalid utf8");
let mut u02 = Vec::with_capacity(u01.len());
let mut i0 = 0;
for (i, _) in u01_str.char_indices().skip(1) {
    u02.push(&u01_str[i0..i]);
    i0 = i;
}
u02.push(&u01_str[i0..]);
println!("u02 = {:?}", u02);

Начну с того, что код представленный автором в комментах к вопросу имеет deadlock между мьютексом и recv() из канала и завершается лишь по тому, что мы не ждем фоновые потоки. Вариант без deadlock будет выглядеть так:

fn test() {
    let mut channels = Arc::new(Mutex::new(Vec::with_capacity(PAR)));
    let mut joins = Vec::with_capacity(PAR);
    for _ in 0..N / PAR {
        for _ in 0..PAR {
            let mut channels = Arc::clone(&channels);
            joins.push(thread::spawn(move || {
                get(channels.lock().unwrap());
            }));
        }
    }
    for j in joins {
        j.join().unwrap();
    }
}

#[inline(always)]
fn get(mut channels: MutexGuard<Vec<mpsc::Sender<i32>>>) -> i32 {
    let (tx, rx) = mpsc::channel();
    channels.push(tx);
    if channels.len() == PAR {
        exec(channels);
    } else {
        drop(channels); // drop гварда отпускает мьютекс
    }
    rx.recv().unwrap()
}

#[inline(always)]
fn exec(mut channels: MutexGuard<Vec<mpsc::Sender<i32>>>) {
    let mut i = 0;
    for c in channels.iter() {
        i += 1;
        c.send(1).unwrap();
    }
    println!("{}", i);
    channels.clear();
    // а здесь гвард дропнется сам
}

Вторая проблема в том, что все потоки выполняются по сути по очереди, так как ждут разблокировки мьютекса от других потоков, из-за чего многопоточка тут не дает никаких преимуществ, а лишь создает накладные расходы. Ради эксперимента я попробовал заменить мьютекс на еще один канал:

fn test() {
    let (tx, rx) = mpsc::channel::<mpsc::Sender<i32>>();
    let mut handles = Vec::with_capacity(N + 1);
    handles.push(thread::spawn(move || exec(rx)));
    for _ in 0..N {
        let tx = tx.clone();
        handles.push(thread::spawn(move || {
            get(tx);
        }))
    }
    drop(tx);
    for handle in handles {
        handle.join().unwrap();
    }
}

fn get(sender: mpsc::Sender<mpsc::Sender<i32>>) -> i32 {
    let (tx, rx) = mpsc::channel();
    sender.send(tx).unwrap();
    rx.recv().unwrap()
}

fn exec(receiver: mpsc::Receiver<mpsc::Sender<i32>>) {
    let mut channels = Vec::with_capacity(PAR);
    loop {
        for _ in 0..PAR {
            let Ok(tx) = receiver.recv() else {
                return;
            };
            channels.push(tx);
        }
        let mut i = 0;
        for c in channels.iter() {
            i += 1;
            c.send(1).unwrap();
        }
        println!("{}", i);
        channels.clear();
    }
}

Но особо это профита не дает, так как основной пожиратель перфоманса - switch context в ОС. Тысячи потоков делают только хуже. Запускать потоков сильно больше чем есть ядер - это вообще плохая идея. Просто ради интереса переписал еще раз на асинхронных каналах tokio:

async fn test() {
    let (tx, rx) = mpsc::unbounded_channel::<mpsc::UnboundedSender<i32>>();
    let mut handles = Vec::with_capacity(N + 1);
    handles.push(tokio::spawn(async move { exec(rx).await }));
    for _ in 0..N {
        let tx = tx.clone();
        handles.push(tokio::spawn(async move {
            get(tx).await;
        }))
    }
    drop(tx);
    for handle in handles {
        handle.await.unwrap();
    }
}

async fn get(sender: mpsc::UnboundedSender<mpsc::UnboundedSender<i32>>) -> i32 {
    let (tx, mut rx) = mpsc::unbounded_channel();
    sender.send(tx).unwrap();
    rx.recv().await.unwrap()
}

async fn exec(mut receiver: mpsc::UnboundedReceiver<mpsc::UnboundedSender<i32>>) {
    let mut channels = Vec::with_capacity(PAR);
    loop {
        for _ in 0..PAR {
            let Some(tx) = receiver.recv().await else {
                return;
            };
            channels.push(tx);
        }
        let mut i = 0;
        for c in channels.iter() {
            i += 1;
            c.send(1).unwrap();
        }
        println!("{}", i);
        channels.clear();
    }
}

и запустил в многопоточном рантайме в дефолтной конфигурации (количество воркеров == количеству ядер), работает быстрее в 19 раз.

P.S. без I/O операций асинхронщина тоже создает ненужные накладные расходы, я ее здесь использовал только из-за простоты переписывания, лучше взять обычный thread pool с синхронными тасками.

https://doc.rust-lang.org/std/path/struct.Path.htm...

let cwd = std::env::current_dir().unwrap().parent().unwrap();

FROM rust:latest as build

WORKDIR /test-tcp

COPY ./Cargo.lock ./Cargo.lock
COPY ./Cargo.toml ./Cargo.toml
COPY ./src ./src

RUN cargo build --release

FROM debian:buster-slim

COPY --from=build /test-tcp/target/release/test-tcp /usr/src/test-tcp

CMD ["/usr/src/test-tcp"]

Проблема в том, что в докере Вы создаете пустой проект из шаблона cargo
RUN USER=root cargo new --bin test-tcp
и компилируете его, потом копируете src
Да, там есть еще один билд после этого, но я попробовал собрать Ваш Dockerfile у себя, и получил на втором билде результат инкрементальной сборки без изменений. То есть cargo не увидел, что папка src поменялась.

Arc нужно клонировать до move в замыкание, которое запускается на потоке. Если данные используются только на чтение, то этого будет достаточно, если данные будут меняться из нескольких потоков, то следует дополнительно обернуть их в Mutex/RwLock (или из std::sync или из библиотеки parking_lot).

use std::sync::Arc;

fn main() {
    let data = Arc::new(vec![1, 2, 3]);

    let thread_1 = std::thread::spawn({
        let data = Arc::clone(&data);
        move || {
            println!("Thread 1 data: {:?}", data);
        }
    });

    let thread_2 = std::thread::spawn({
        let data = Arc::clone(&data);
        move || {
            println!("Thread 2 data: {:?}", data);
        }
    });

    thread_1.join().unwrap();
    thread_2.join().unwrap();
}

Передавать так можно хоть вектор, хоть свою структуру, главное чтоб у типа был трейт Send и лайфтайм 'static (все владеющие типы имеют такой лайфтайм).
Так как передаем мы по сути Arc, то Send должен быть у него, а он будет для любого содержимого реализующего Sync.

Я обернул создание отдельного потока в функцию и так передавал в поток данные. Удобно, что такую функцию могу вынести в отдельный файл-модуль. Но не смог такое сделать динамически в цикле для группы потоков. Хочу подойти к варианту, когда поток, который закончил выполнение своего кода (раньше других), можно опять запустить из main и передать ему новую задачу (новые данные), - структуру данных, которую привёл в основном вопросе.

Если правильно понял, то Вам нужен thread pool. Можно использовать из библиотеки rayon: https://docs.rs/rayon/1.7.0/rayon/struct.ThreadPoo...
Но если хочется повелосипедить, можно нечто такое сделать:

use std::{
    sync::{
        mpsc::{self, Sender},
        Arc, Mutex,
    },
    thread::{self, JoinHandle},
};

type Task = Box<dyn FnOnce() + Send + 'static>;

pub struct ThreadPool {
    handles: Vec<JoinHandle<()>>,
    task_sender: Sender<Task>,
}

impl ThreadPool {
    pub fn new() -> Self {
        let threads_count = thread::available_parallelism()
            .map(|n| n.get())
            .unwrap_or(2);
        let (task_sender, task_receiver) = mpsc::channel::<Task>();
        let task_receiver = Arc::new(Mutex::new(task_receiver));
        let mut handles = Vec::with_capacity(threads_count);
        for _ in 0..threads_count {
            let task_receiver = Arc::clone(&task_receiver);
            handles.push(thread::spawn(move || loop {
                let task_receiver = task_receiver.lock().unwrap_or_else(|e| e.into_inner());
                let Ok(task) = task_receiver.recv() else {
                    return;
                };
                drop(task_receiver);
                task();
            }));
        }
        Self {
            handles,
            task_sender,
        }
    }

    pub fn spawn_task<F: FnOnce() + Send + 'static>(&self, f: F) {
        self.task_sender.send(Box::new(f)).expect("All threads ended");
    }

    pub fn join(self) -> thread::Result<()> {
        drop(self.task_sender);
        for handle in self.handles {
            handle.join()?;
        }
        Ok(())
    }
}

#[test]
fn thread_pool() {
    let pool = ThreadPool::new();
    for i in 0..500 {
        pool.spawn_task(move || {
            println!("Task {} working on thread {:?}", i, thread::current().id());
        });
    }
    pool.join().unwrap();
}

use chrono::prelude::*;
use std::sync::mpsc;
use std::sync::mpsc::{Receiver, Sender};
use std::{thread, time};

fn main() {
    println!("- - - - -");
    let mut children = Vec::with_capacity(3);

    for id in 0..children.capacity() {
        let child = thread::spawn(move || {
            let mut date_times = Vec::with_capacity(5);
            for i in 0..date_times.capacity() {
                let t: DateTime<Local> = Local::now();
                date_times.push(t);
                println!("{:?}_ поток, задача _{:?}, время: {:?}", id, i, t);
                thread::sleep(time::Duration::from_millis(3));
            }
            (id, date_times)
        });

        children.push(child);
    }

    for child in children {
        let (id, date_times) = child.join().expect("Дочерний поток паникует");
        println!("thd_{} = {:?}", id, date_times);
    }
    println!("- - - - -");
}