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

Примерно так это можно реализовать:

use chrono::Utc;
use std::{
    io::{self, BufRead as _},
    sync::mpsc::{self, RecvTimeoutError, Sender},
    thread,
    time::{Duration, Instant},
};

enum Op {
    Add(String),
    Del(String),
}

const PRINT_INTERVAL: Duration = Duration::from_secs(10);

fn main() {
    println!("---\n{}\n---\n", Utc::now());

    let (tx, rx) = mpsc::channel();
    start_stdin_thread(tx);

    let mut strings = Vec::new();
    let mut last_print = Instant::now();
    loop {
        match rx.recv_timeout(PRINT_INTERVAL - last_print.elapsed()) {
            Err(RecvTimeoutError::Disconnected) => break,
            Err(RecvTimeoutError::Timeout) => {
                println!("---\n{}\n{:?}\n---\n", Utc::now(), strings);
                last_print = Instant::now();
            }
            Ok(Op::Add(s)) => {
                strings.push(s);
            }
            Ok(Op::Del(s)) => {
                strings.retain(|v| v != &s);
            }
        }
    }
}

fn start_stdin_thread(tx: Sender<Op>) {
    #[derive(Clone, Copy)]
    enum OpRaw {
        Add,
        Del,
    }

    thread::spawn(move || {
        let mut stdin = io::stdin().lock();
        let mut buf = String::with_capacity(1024);
        let mut read_line = |buf: &mut String| -> io::Result<()> {
            buf.clear();
            stdin.read_line(buf).map(|_| ()).inspect_err(|err| {
                eprintln!("Ошибка чтения stdin: {err}");
            })
        };

        loop {
            println!("1. Добавить текст");
            println!("2. Удалить текст");
            print!("Введите номер операции: ");
            if read_line(&mut buf).is_err() {
                break;
            }

            let op = match buf.trim() {
                "1" => OpRaw::Add,
                "2" => OpRaw::Del,
                _ => {
                    eprintln!("Некорректная операция");
                    continue;
                }
            };

            println!(
                "Введите текст на {}:",
                match op {
                    OpRaw::Add => "добавление",
                    OpRaw::Del => "удаление",
                }
            );
            if read_line(&mut buf).is_err() {
                break;
            }

            let text = buf.trim().to_string();
            let op = match op {
                OpRaw::Add => Op::Add(text),
                OpRaw::Del => Op::Del(text),
            };

            if tx.send(op).is_err() {
                break;
            }
        }
    });
}

Во-первых, следует понять, что канал по своей природе - это очередь.
То есть, если пользователь успеет за отведённое время сделать 5 изменений, то наш дочерний поток получит 5 копий вектора, а судя по задаче там ожидается только актуальная последняя копия.
Гораздо логичнее просто пошарить между потоками единственный вектор обёрнутый в Arc<RwLock<...>> или Arc<Mutex<...>>, заодно и памяти меньше сожрём и не будем греть проц бесполезными аллокациями памяти и копированием вектора.

Но если всё же задача другая, то у Receiver канала помимо метода recv, который блокирует поток до получения сообщения, есть ещё методы try_recv (не блокирует поток вообще) и recv_timeout (блокирует, но не дольше переданного таймаута).
https://doc.rust-lang.org/std/sync/mpsc/struct.Rec...
https://doc.rust-lang.org/std/sync/mpsc/struct.Rec...

P.S.

Duration::from_millis(10)

тут явно не 10 секунд...

P.S.S. Перформанс сия кода ушёл в отставку:
В коде есть лишние итерации по вектору.
В коде куча лишних аллокаций и копирования памяти.
Всю задачу можно вообще решить на одном потоке и оно будет работать быстрее ибо про синк кэшей проца тоже не надо забывать.

Ну и так по мелочи:

if console.0 == 1 {
    h_add_del_txt.insert(1, console.1);
} else if console.0 == 2 {
     h_add_del_txt.insert(2, console.1);
} else {  
     // ...
}

match, enum вместо u8

et mut g = String::new();
     io::stdin().read_line(&mut g).expect("Failed to read line");
     let g: String = g.trim().parse().expect("Please type a ...");

WTF?

Ну и паниковать на каждый чих так себе идея...

Для операций сводящихся к арифметике указателей.
Помимо непосредственно арифметики указателей сюда относятся индексация и длина слайсов/массивов/векторов/строк, capacity вектора/строки, размеры и выравнивание типов, смещение полей относительно начала структуры.
Но в целом, где удобно, там и используйте, никто не запрещает использовать usize/isize как и другие int типы

При перемещении адрес на стеке изменится, а адрес памяти выделенной на куче - нет.
Тут очень тонкий момент, который нужно понимать, данные которые мы помещаем в Box или Vec будут размещены на куче, но сами Box и Vec - это такие же структуры, как и любые другие, просто на них есть некоторая логика для управления памятью на куче, в случае 64 битной архитектуры и T: Sized, Box<T> будет занимать 8 байт на стеке и размер T на куче, а Vec<T> - 24 байта на стеке (указатель на начало, длина и фактически выделенная память) и размер T умноженный на capacity на куче.

fn main() {
    let a = Box::new(42);
    println!("Stack address of a: {:p}", &a);
    println!("Heap address of a: {:p}", &*a);
    
    let b = a;
    println!("Stack address of b: {:p}", &b);
    println!("Heap address of b: {:p}", &*b);
}

Stack address of a: 0x7fff59586010
Heap address of a: 0x58cf76717b10
Stack address of b: 0x7fff59586018
Heap address of b: 0x58cf76717b10

Что-то вроде такого:

cat /var/log/nginx/access.log | grep 'GET /path/to/page' | awk '{print $1}' | sort | uniq | wc -l

где /path/to/page - web путь к странице

У меня ровно такая схема как на картинке, с уточнением, что роутер 1 и роутер 2 имеют разные подсети.
В качестве роутера 1 используется мини пк с 4 ethernet, в 2 подключены 2 провайдера между которыми балансируется нагрузка, 2 других объеденены в бридж и рулят подсетью 192.168.32.0/28 и 1 идет в WAN порт роутера 2, а второй в мой рабочий комп.
В качестве роутера 2 - обычный бытовой роутер, для WiFi и тд, он рулит подсетью 192.168.0.0/19 рабочий комп к нему так же подключен второй сетевухой, дабы иметь доступ в локалку.

https://doc.rust-lang.org/std/sync/atomic/struct.A...

use std::sync::atomic::{AtomicU32, Ordering};

async fn create_user(
    Json(payload): Json<FromBrowser>,
 ) -> (StatusCode, Json<User>) {
    static COUNTER: AtomicU32 = AtomicU32::new(0);

    // подготавливаю данные на отправку в браузер:
    let user = User {
       id: payload.id,
       username: payload.username,
       tm: payload.tm,
       cnt: COUNTER.fetch_add(1, Ordering::SeqCst),   // считаю отправки; 
    };

    (StatusCode::CREATED, Json(user))
 }

MaybeUninit под капотом - это union, то есть компилятор ничего не знает, инициализированное там значение или нет и перекладывает эту ответственность на программиста. А значит UB здесь не будет.
То есть спокойно делаете &mut [MaybeUninit<*mut State>], инициализируете элементы и после std::mem::transmute в &mut [*mut State]

document.addEventListener('DOMContentLoaded', () => {
    // ...
}, {once: true});

let arr: [i32; 10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let mut arr2: [i32; 10] = [0; 10];

arr.iter()
    .zip(arr2.iter_mut())
    .filter(|(el, _)| **el % 2 == 0)
    .for_each(|(el, target)| {
        *target = *el;
    });