Jak zsynchronizować timer z wątkiem głównym?

cześć
bardzo bym prosił o poradę, wskazówkę jak się robi timer w RUST, który można zsynchronizować z wątkiem głównym,

rzecz jest prosta
mamy grę tetris (w ramach nauki rust, pisze sobie tetrisa w konsoli)

jak wiadomo w tetrisie co np 1 sekundę klocek spada o jeden poziom w dół
ale gracz może obróć, przesunąć klocek

o ile w C# jest to proste (dla mnie)

public void GameLoop()
{
   var timer = new Timer(TimerHandler, null, 0, 1000); // tutaj reakcja na cykliczne zdarzenie czasowe - timer 
   while (true) {
      //tutaj reakcje na zdarzenia od gracza
   }

}

w RUST nie potrafię przekazać tego samego stanu gry do timera i do petli gry

fn main() {
     let well = Well::new();
     let canvas = Canvas::new();
     let pieces = Pieces::new();
     let mut game_state = GameState::new();
     let game = Game::new();

     let arc_well = Arc::new(Mutex::new(well.clone()));
     let arc_canvas = Arc::new(Mutex::new(canvas));
     let arc_pieces = Arc::new(Mutex::new(pieces.clone()));
     let arc_game_state = Arc::new(Mutex::new(game_state));
     let arc_game = Arc::new(Mutex::new(game));

     let timer = timer::Timer::new();

     let __ = timer.schedule_repeating(chrono::Duration::seconds(1), move || {
         let shared_game = Arc::clone(&arc_game);
         let shared_pieces = Arc::clone(&arc_pieces);
         let shared_game_state = Arc::clone(&arc_game_state);
          tick(&arc_canvas, &shared_pieces, &arc_well, shared_game, &shared_game_state);
      });

      loop {
          let event = read();
          let _ = game.handle_key(&canvas
                          , &pieces
                          , &well
                                  , &mut  arc_game_state.lock().unwrap()
                                  , event.unwrap());
      }
}

efekt mam taki że reaguje na zdarzenie timer i na zdarzenia gracza, ale mam jakby dwie gry - dwa stany gry
i to widać
dla timera klocek porusza się w dół
dla zdarzeń gracza reaguje tylko na akcje gracza

jak uwspólnić ten stan
żeby funkcja tick i game.handle_key - pracowały na tych samych obiektach?

jako że to moje początki z RUTS mam nadzieję, że nie zrazi Was ogólny styl pisania
chodzi mi o to, żeby dzialało jak chcę

z góry dziękuję za odpowiedź

wydaje mi się że zrozumiałem współdzielenie stanów

fn main() {
     let well = Well::new();
     let canvas = Canvas::new();
     let pieces = Pieces::new();
     let mut game_state = GameState::new();
     let game = Game::new();

     let tick_duration = Duration::from_secs(1);

     let arc_well = Arc::new(Mutex::new(well));
     let arc_canvas = Arc::new(Mutex::new(canvas));
     let arc_pieces = Arc::new(Mutex::new(pieces));
     let arc_game_state = Arc::new(Mutex::new(game_state));
     let arc_game = Arc::new(Mutex::new(Game::new()));

     let timer = timer::Timer::new();

    let shared_well = Arc::clone(&arc_well);
    let shared_canvas = Arc::clone(&arc_canvas);
    let shared_pieces = Arc::clone(&arc_pieces);
    let shared_game_state = Arc::clone(&arc_game_state);
    let shared_game = Arc::clone(&arc_game);

     let guard = timer.schedule_repeating(chrono::Duration::seconds(1),  move || {
          tick(&shared_canvas, &shared_pieces, &shared_well, &shared_game, &shared_game_state);
      });



      loop {
          let event = read();

          let __ = arc_game.lock().unwrap().handle_key(
              arc_canvas.lock().unwrap().deref(),
              arc_pieces.lock().unwrap().deref(),
              arc_well.lock().unwrap().deref(),
              arc_game_state.lock().unwrap().deref_mut(),
              event.unwrap()
          );
      }
  }