¿Un multiplexor de terminal tiene algún beneficio cuando se usa con un administrador de ventanas de mosaico?

Tanto los multiplexores de terminal (pantalla, tmux) como los administradores de ventanas de mosaico controlados por teclado (ratpoison, dwm, xmonad) proporcionan una funcionalidad similar. ¿Hay algún beneficio en usar ambos al mismo tiempo? ¿Qué pasa con los problemas que pueden surgir?

Yo uso dwm y tmux. Antes de aprender a usar tmux, tendría múltiples terminales abiertas para diferentes cosas y las tendría en diferentes etiquetas. Ahora puedo ejecutar todo dentro de una sesión tmux, bajo una sola etiqueta, y puedo separar y volver a conectar sin perder el estado si necesito reiniciar X.

El beneficio adicional de los multiplexores de terminal es que sus sesiones de multiplexores seguirán activas y puede volver a conectarse a ellas incluso si X (su sesión de escritorio) falla o si se desconecta de X.

Utilice ambos: un administrador de ventanas en mosaico y un multiplexor de terminales.

Combine sus capacidades y ventajas para obtener una sinergia aún mejor. En mi configuración de i3, visualizo regularmente varios terminales al mismo tiempo, pero todos ellos están conectados a la misma sesión tmux , por lo que puedo mostrar todas las ventanas tmux en cualquiera de los terminales .

En efecto, utilizo las capacidades de mosaico i3para reemplazar / aumentar la funcionalidad de división / movimiento de ventanas del multiplexor de terminal para (en mi humilde opinión) obtener lo mejor de ambos mundos.

El siguiente script se usa aquí para administrar la conexión de sesión / detección y la limpieza en el inicio del terminal:

#!/bin/bash
# This script attaches the terminal to a common session, where all
# terminals can show any window of the main tmux session independently
# This script also cleans up "old" sessions
# Todo: Cosmetic fix-ups. Make less verbose.

DEBUG="y"
showRun(){ echo Will run: $@;test -z $DEBUG||read -n1 -p"Press ENTER";$@; }

SNAME=${1:-XyZ}

if ! tmux has -t $SNAME; then
    echo -n "Session $SNAME not found, creating it: "
    showRun exec tmux new-session -s $SNAME;
else
    echo -n "Session $SNAME found: "
    MySESSION=$(tmux ls | grep -E "^$SNAME:.*\(attached\)$")
    echo $MySESSION;
    if [ -z "$MySESSION" ] ; then
        echo "Session $SNAME unattached, seizing it:"
        showRun exec tmux attach -t $SNAME \; new-window
    else
        echo "Session $SNAME already attached, finding grouped Sessions:"
        REGEX="group ([^)]*)"
        [[ $MySESSION =~ $REGEX ]]
        GNAME=${BASH_REMATCH[1]}
        GSESSIONS=$(tmux ls | grep "group $GNAME)" | grep -v $SNAME:)
        echo "$GSESSIONS"
        if [ -z "$GSESSIONS" ]; then
            echo "No sessions in group with $SNAME found, creating new one:"
            showRun exec tmux new-session -t $SNAME \; new-window
        else
            FGSESSIONS=$(echo "$GSESSIONS" | grep -v attached )
            if [ -z "$FGSESSIONS" ]; then
                echo "No free sessions in group $GNAME found, creating new one:"
                showRun exec tmux new-session -t $SNAME \; new-window
            else
                echo -e "Free grouped Sessions:\n $FGSESSIONS";
                if echo "$FGSESSIONS" | tail -n +2 | grep . > /dev/null; then
                    echo "Several detached Sessions found, cleaning up:"
                    echo "$FGSESSIONS" | while read SID x ; do
                        if [ -z $KEEPSID ]; then
                            KEEPSID=${SID%:*};
                            echo "Keeping session $KEEPSID for takeover after cleanup"
                        else
                            echo "Cleaning up old detached session $SID"
                            tmux kill-session -t ${SID%:}
                        fi;
                    done
                    KEEPSID=$(tmux ls|grep "group $GNAME)" | grep -v attached);
                    KEEPSID=${KEEPSID%: *}
                    echo "Attaching to session $KEEPSID:"
                    showRun exec tmux attach -t $KEEPSID \; new-window
                else
                    echo "Free session ( ${FGSESSIONS%: *} ) found, seizing it:"
                    showRun exec tmux attach -t ${FGSESSIONS%: *} \; new-window
                fi ;
            fi ;
        fi ;
    fi ;
fi

No. En los casos excepcionales en los que es útil la pantalla dentro de la pantalla o tmux dentro de tmux, ambos programas proporcionan un medio simple de pasar el control a la instancia anidada.

Screen ofrece capacidades de consola en serie, pero solo uso una aplicación dedicada (miniterm.py distribuida con python) cuando la necesito. De lo contrario, no puedo pensar en nada que cualquiera pueda hacer y el otro no, pero uno podría hacerlo más simple que el otro.

Aprendería uno u otro, y si tienes curiosidad o no estás satisfecho con lo que elegiste, prueba con el otro. Prefiero tmux, personalmente.

Otro aspecto útil de un multiplexor de terminal en este escenario es después de conectarse a servidores remotos. Un caso de uso típico que encuentro es

1. Abra una ventana de terminal en mi PC local.
2. ssh en un servidor remoto.
3. tmux / screen ahora proporciona multiplexación en el servidor remoto, permitiendo una fácil apertura de nuevos terminales / shells en el servidor remoto. En comparación con la apertura de un segundo terminal en la PC local y la reconexión con un segundo ssh, este es un paso menos.