Hat ein Terminal-Multiplexer Vorteile, wenn er mit einem Kachelfenstermanager verwendet wird?

Sowohl Terminal-Multiplexer (screen, tmux) als auch tastaturgesteuerte Kachelfenstermanager (ratpoison, dwm, xmonad) bieten ähnliche Funktionen. Gibt es einen Vorteil, wenn beide gleichzeitig verwendet werden? Was ist mit Problemen, die auftreten können?

Ich benutze dwm und tmux. Bevor ich lernte, tmux zu verwenden, hatte ich mehrere Terminals für verschiedene Dinge geöffnet und sie in verschiedenen Tags. Jetzt kann ich alles innerhalb einer tmux-Sitzung unter einem einzigen Tag ausführen und trennen und erneut verbinden, ohne den Status zu verlieren, wenn ich X neu starten muss.

Der zusätzliche Vorteil von Terminal-Multiplexern besteht darin, dass Ihre Multiplexer-Sitzungen noch aktiv sind und Sie die Verbindung auch dann wieder herstellen können, wenn X (Ihre Desktop-Sitzung) abstürzt oder Sie sich von X abgemeldet haben.

Verwenden Sie beide: Einen Kachelfenstermanager und einen Terminal-Multiplexer.

Kombinieren Sie sowohl ihre Fähigkeiten als auch ihre Vorteile, um noch bessere Synergien zu erzielen. In meinem i3-Setup zeige ich regelmäßig mehrere Terminals gleichzeitig an, aber alle sind mit derselben tmux-Sitzung verbunden , sodass ich alle tmux-Fenster in jedem der Terminals anzeigen kann .

Tatsächlich verwende ich die Fliesen Fähigkeiten , i3um das Fenster Splitting / Verschieben Funktionalität des Terminal - Multiplexer auf (imho) das Beste aus beiden Welten zu ersetzen / ergänzen.

Das folgende Skript wird hier verwendet, um die Sitzungs- / Erkennungsverbindung und die Bereinigung beim Terminalstart zu verwalten:

#!/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

Nein. In den seltenen Fällen, in denen der Bildschirm innerhalb des Bildschirms oder tmux innerhalb von tmux nützlich ist, bieten beide Programme eine einfache Möglichkeit, die Steuerung an die verschachtelte Instanz zu übergeben.

Der Bildschirm bietet Funktionen für die serielle Konsole, aber ich verwende nur eine dedizierte App (miniterm.py, die mit Python vertrieben wird), wenn ich das brauche. Ansonsten fällt mir nichts ein, was einer tun kann und der andere nicht, aber einer könnte es einfacher machen als der andere.

Ich würde das eine oder andere lernen, und wenn Sie neugierig oder unzufrieden mit dem sind, was Sie ausgewählt haben, versuchen Sie es mit dem anderen. Ich persönlich bevorzuge tmux.

Ein weiterer nützlicher Aspekt eines Terminal-Multiplexers in diesem Szenario ist die Verbindung zu Remote-Servern. Ein typischer Anwendungsfall, den ich finde, ist

1. Öffnen Sie ein Terminalfenster auf meinem lokalen PC.
2. ssh in einen Remote-Server.
3. tmux / screen bietet jetzt Multiplexing auf dem Remote-Server und ermöglicht das einfache Öffnen neuer Terminals / Shells auf dem Remote-Server. Im Vergleich zum Öffnen eines zweiten Terminals auf einem lokalen PC und zum erneuten Verbinden mit einem zweiten SSH ist dies ein Schritt weniger.