okuma süresi : 10 minutes

Fırlatırsınız`./gradlew build`, terminal 3 dakika boyunca engelleniyor, ve başka bir şey yapmanız gerekiyor beklerken ? Yeni bir sekme açmaya gerek yok.`Ctrl+Z`İşlemi askıya alır,`fg`Onu tam olarak siz biraktığınız yere geri getirir. Bir geliştiricinin günlük yaşamındaki en az tahmin edilen Unix ipucu.

Sorun: meşgul bir terminal

Her bir geliştirici bu durumu yaşamıştır:

$ ./gradlew build
> Building...

Terminal kilitli. Daha fazla komut giremezsiniz. Bir dosyayı görüntülemek ve bir işlemi başlatmak istiyorsunuz.git status, veya bir portun meşgul olduğunu kontrol etmek.

@startuml
skinparam backgroundColor #FEFEFE

actor Développeur as dev
participant "terminal" as term
participant "Gradle\n( processus )" as gradle

dev -> term : ./gradlew oluşturmak
term -> gradle : Başlat build'i
gradle -> term : Terminali işgal eder\n(pas de prompt)
dev -> term : Bir komut girmek istiyor
term --> dev : Engellenmiş terminal

note right of dev
Derlemenin süresince geliştirici paralize olur.
end note
@enduml

Çoğu geliştirici yeni bir terminal açar. Ancak daha zarif, daha hızlı ve yerel bir çözüm vardır: iş yönetimi.

Üç zorunlu komut

Ctrl+Z — Duraklatma (SIGTSTP)

`Ctrl+Z`Sinyalı gönder.`SIGTSTP`Ön plan sürecine. Süreçaskıda— ölmedi — ve terminal promptunu bulur.

$ ./gradlew build
> Building...
^Z
[1]+  Stoppé    ./gradlew build
$

Köşeli parantez içindeki sayı`[1]` est le iş numarası. Le `+`Varsayılan işi gösterir

fg — Durdurulan işi ön planda devam ettirmek

`fg`Duraklatılmış işi ön plana getirir; işlem tam olarak durduğu yerden devam eder.

$ fg
./gradlew build
> Building... (reprend où il en était)

Belirli bir iş numarasıyla :

$ fg %2

bg — Arka planda devam et

`bg`İşlemi terminali bloke etmeden sürdürür. Uzun derlemeler için idealdir.

$ bg
[1]+ ./gradlew build &
$

Le `&`Sona erdiğinde, sürecin arka planda çalıştığı anlamına gelir.

jobs — Shell işlerini listele

$ jobs
[1]-  Stoppé    vim README.md
[2]+  En cours   ./gradlew build
@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

state "ön plan\n(terminal bloqué)" as fg #LightCoral
state "Suspendu\n(Ctrl+Z)" as stopped #LightYellow
state "arkaplan\n(bg)" as bg_ #LightGreen

[*] --> fg : Lance une commande
fg --> stopped : Ctrl+Z\n(SIGTSTP)
stopped --> fg : fg\nöne al
stopped --> bg_ : bg\narkaplanda devam eder
bg_ --> fg : fg\nön plana getirir
fg --> [*] : Komut tamamlandı

note right of stopped
Süreç dondurulmuş ama ölü değil.
end note

note left of bg_
Terminal boşta
derleme devam ediyor
end note
@enduml

Senaryo 1: Uzun derleme

Bu en yaygın kullanım durumudur. Bir Gradle derlemesi çalıştırıyorsunuz, terminal bloke oluyor ve başka bir şey yapmanız gerekiyor.

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor Développeur as dev
participant "terminal" as term
participant "Gradle" as gradle
database "Durum\nsüreç" as state

dev -> term : ./gradlew derleme
term -> gradle : Build'i başlat
gradle -> state : Devam ediyor (FG)
dev -> term : Ctrl+Z
term -> state : Askıya alınmış (job [1])
term --> dev : (Empty output)

dev -> term : git status
term --> dev : çalışma ağacı temiz

dev -> term : fg
term -> state : Devam et (FG)
gradle --> dev : Derleme başarılı ✓

note right of state
Süreç Gradle
asla öldürulmamıştır
Tam olarak devam eder
kaldığı yer
end note
@enduml

Adım adım

$ ./gradlew build
> Building...
^Z
[1]+  Stoppé    ./gradlew build

$ git status
On branch main
nothing to commit, working tree clean

$ fg
./gradlew build
> Building...
BUILD SUCCESSFUL in 2m 34s

Senaryo 2: Unutulmuş editör

İçerisiniz`vim`, başka bir dosyayı sans çıkmadan incelemeniz gerekiyor`vim`.

# Dans vim, en mode commande :
:shell
$ cat /path/to/other/file.txt
$ exit
# Retour dans vim

Ama ağır. İle`Ctrl+Z`, hemen olur:

# Dans vim, n'importe quel moment :
Ctrl+Z
[1]+  Stoppé    vim README.md

$ cat /path/to/other/file.txt
# ... lire le fichier ...

$ fg
vim README.md
# Retour exact là où on en était, curseur en place
@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor Développeur as dev
participant "vim" as vim
participant "Shell" as shell

dev -> vim : Devam eden düzenleme
dev -> vim : Ctrl+Z
vim -> shell : Askıya alınmış (iş [1])
dev -> shell : cat autre_fichier.txt
shell --> dev : dosyanın içeriği
dev -> shell : fg
shell -> vim : Devam eder (iş [1])
vim --> dev : İmleç tam\naynı konumda

note right of vim
vim geri yükler
inttamamiyla durum:
imleç konumu,
tampon, geri alma yığını
end note
@enduml
vim`Durumu mükemmel şekilde bir […​]'den sonra geri yükler`fg: imleç konumu, tampon içeriği, geri alma geçmişi — her şey korunuyor.

Senaryo 3: Durdurulan opencode süreci

Bu makalenin motivasyonunu sağlayan senaryo budur. Kullanıyorsunuz.opencode(komut satırı aracı ile kodunuz üzerindeki bir LLM’yi pilotlamak), ve işlem askıya alındı.

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif
skinparam componentStyle rectangle

actor Développeur as dev
participant "opencode\n(LLM agent)" as agent
participant "Kabuk" as shell
participant "git" as git

dev -> agent : Aktif oturum
agent -> agent : Tour de parole\ndu LLM en cours

note over agent
Ctrl+Z kod analizinin ortasında gerçekleşir
end note

dev -> agent : Ctrl+Z
agent -> shell : Suspendu (job [1])
dev -> git : git diff
git --> dev : görünür değişiklikler
dev -> shell : fg
shell -> agent : Devam eder (job [1])
agent --> dev : Reprend exactement\nl'analyse en cours

note right of agent
Bağlam kaybı yok
LLM yanıtına devam eder
tam olarak kaldığı yerde
end note
@enduml
$ opencode
# ... session en cours, LLM analyse le code ...
^Z
[1]+  Stoppé    opencode

$ git diff HEAD~1
# vérifier les changements récents

$ fg
opencode
# Le LLM reprend là où il s'était arrêté

Avantaj iki katlıdır :

  1. Bağlam kaybı yok: LLM oturumu, konuşma geçmişi, açılan dosyalar — her şey korunur

  2. Yeniden başlatma yok: opencode’i yeniden başlatmaya, bağlamı yeniden yüklemeye veya sorunu LLM’e yeniden açıklamaya gerek yok

Senaryo 4 : Çok sayıda işi aynı anda yönetme

fg et `bg`Birden fazla süreç askıya alındığında belirli bir süreci hedef almak için bir iş numarası kabul ederler.

$ vim config.yml
^Z
[1]+  Stoppé    vim config.yml

$ ./gradlew test
^Z
[2]+  Stoppé    ./gradlew test

$ htop
^Z
[3]+  Stoppé    htop

$ jobs
[1]   Stoppé    vim config.yml
[2]-  Stoppé    ./gradlew test
[3]+  Stoppé    htop

$ fg %2
./gradlew test
# Le build reprend en avant-plan

$ bg %3
[3] htop &
# htop reprend en arrière-plan
@startuml
skinparam backgroundColor #FEFEFE

rectangle "Askıya alınmış işler" as jobs #LightYellow {
  card "[1] vim config.yml" as j1
  card "[2] ./gradlew test" as j2
  card "[3] htop" as j3
}

rectangle "İşlemler" as actions #LightGreen {
  card "fg %2\n→ ön plan" as a1
  card "bg %3\n→ arka plan" as a2
  card "fg %1\n→ ön plan" as a3
}

jobs --> actions : fg/bg + iş numarası
actions --> j2 : devam eder
actions --> j3 : Arka planda

note bottom of jobs
Her iş, tam durumunu suspend/resume arasında korur.
end note
@enduml

İş komutları özeti

sipariş Etki Örnek

Ctrl+Z

Ön plandaki süreci askıya al

Gönderim`SIGTSTP`

fg

Varsayılan işi ön planda devam ettir

fg ou fg %1

fg %n

İş n’i öne alın

fg %2

bg

Varsayılan işi arka planda sürdürün

bg ou bg %1

bg %n

Arka planda n işini devam ettirir

bg %2

jobs

Mevcut kabuğun işlerini listele

jobs -l(PID ile)

kill %n

Tamamla iş n

kill %2

fg, bg, Ctrl+Z, Ctrl+C ve & arasındaki farklar

Çoğu geliştirici bu mekanizmaları karıştırır. İşte net bir açıklama.

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

rectangle "**Ctrl+Z**\nSIGTSTP" as ctrlz #LightYellow {
  card "İşlemi askıya al\n(il est toujours en mémoire)\nUtilisable fg ile/bg" as c1
}

rectangle "**Ctrl+C**\nSIGINT" as ctrlc #LightCoral {
  card "İşlemi sonlandır\n(pas de retour possible)\nPerte her durumda" as c2
}

rectangle "**& **\n(arrière-plan)" as ampersand #LightGreen {
  card "Doğrudan başlat\narkaplandanTerminal anında boş" as c3
}

rectangle "**fg**\n(foreground)" as fg_ #SkyBlue {
  card "Bir işi getir\nön planda askıya alınmışnTerminal meşgul" as c4
}

rectangle "**bg**\n(background)" as bg_ #Lavender {
  card "Bir işi sürdür\narkaplanda askıya alınmışnTerminal boş" as c5
}

ctrlz -right-> fg_ : fg devam etmek için
ctrlz -right-> bg_ : bg için devam etmek\narka planda
ctrlc -right-> c2 : Dönüş yok\nİşlem öldürüldü

note bottom of ctrlz
İşlem **donmuş**
ama **ölmemiş**
end note

note bottom of ampersand
Alternatif : Çalıştır
./gradlew build &
doğrudan arka planda
end note
@enduml
Kısayol/Komut Sinyal Etki Geriye dön?

Ctrl+Z

SIGTSTP

İşlemi (dondurulmuş, bellekte) askıya alır

Evet :`fg` ou bg

Ctrl+C

SIGINT

İşlemi sonlandır (tamamlandı)

Hayır : süreç yok edildi

Ctrl+\

SIGQUIT

İşlemi öldür + core dump

Hayır : süreç yok edildi

commande &

—

Arka planda doğrudan başlat

`fg`öne almak için

Ctrl+Z`dırzararsız. Süreç bellekte olduğu gibi donar. Hemen devam edebilirsiniz`fg. Bir pause, bir stop değil.

Bir işin tam yaşam döngüsü

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

title Bir kabuk işinin tam yaşam döngüsü
state "Olmayan" as none
state "Ön plan\n(occupe le terminal)" as foreground #LightCoral
state "Askıya alındı\n(Ctrl+Z / SIGTSTP)" as suspended #LightYellow
state "Arka plan\n(bg ou &)" as background #LightGreen
state "Tamamlandı\n(exit code 0)" as done #LightGray

[*] --> none
none --> foreground : bir komut gir
foreground --> suspended : Ctrl+Z
foreground --> done : normal son

suspended --> foreground : fg
suspended --> background : bg
suspended --> done : öldür %n

background --> foreground : fg
background --> done : normal son\n(en arrière-plan)
background --> suspended : Ctrl+Z\n(si fg puis Ctrl+Z)

done --> [*]

note right of suspended
Askıya alınmış durum
tümünün merkezi
iş sistemi
end note
@enduml

İleri seviye ipuçları

fg ile en güncel iş ve alternatif eğitim

fg`Argüman olmadan işaretli işi getirir.+(en güncel). Ancak kullanabilirsiniz.%-`önceki işi hedeflemek için :

$ vim file1.txt
^Z
[1]+  Stoppé    vim file1.txt

$ vim file2.txt
^Z
[2]+  Stoppé    vim file2.txt

$ fg      # ramène job [2] (le plus récent)
$ fg %-   # ramène job [1] (le précédent)

bir işi düzgünce öldürmek

$ jobs
[1]-  Stoppé    vim config.yml
[2]+  Stoppé    ./gradlew test

$ kill %2       # envoie SIGTERM au job 2
$ kill -9 %1    # envoie SIGKILL au job 1 (force)

désown : kabuktan ayrılmak

disown`Kabuğun işler tablosundan bir iş çıkarılır. İşlem çalışmaya devam eder ancak artık geri getirilemez ile`fg:

$ ./gradlew build &
[1] 12345

$ disown %1
# Le processus continue mais n'est plus lié au shell
# Ça survives à la fermeture du terminal

Uzun süreçler için nohup ile birlikte kullanın

Bir sürecin terminalin kapatılmasından sonra hayatta kalması için:

$ nohup ./gradlew build &
[1] 12345
$ disown %1
# Le build continue même si vous fermez le terminal
@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

rectangle "fg" as fg_ #SkyBlue {
  card "En son işi\ngetir (+)" as f1
  card "Belirli bir işi\nhedefle: fg %n" as f2
  card "Değiştir : fg %-" as f3
}

rectangle "kill %n" as kill_ #LightCoral {
  card "SIGTERM (temiz)" as k1
  card "SIGKILL -9 (zorla)" as k2
}

rectangle "disown" as disown #Lavender {
  card "Shell'den ayır\n(survit à la déconnexion)" as d1
}

rectangle "nohup + &" as nohup_ #LightGreen {
  card "Korunan işlem\nkarşı SIGHUP\n(survit à la fermeture\ndu terminal)" as n1
}

fg_ -right-> kill_ : gerekiyorsa\nbitir
kill_ -right-> disown_ : ya da ayır
nohup_ -left-> fg_ : fg öne\ngetirir

note bottom of disown_
disown sonrası, fg artık işi geri getiremez
end note
@enduml

Yaygın tuzaklar ve hatalar

Ctrl+Z ve Ctrl+C’yi karıştırma

Bu en sık yapılan hata.Ctrl+C`İşlemi öldürür.`Ctrl+Z(onu) askıya alır. Eğer basarsınız`Ctrl+C`Refleks olarak tüm durum kaybolur — açık dosyalar, LLM oturumları, devam eden derlemeler.

@startuml
skinparam backgroundColor #FEFEFE

rectangle "Ctrl+Z (SIGTSTP)" as z #LightGreen {
  card "Bellekte donmuş süreç" as z1
  card "fg onu bozulmadan geri getirir" as z2
  card "Kayıp yok" as z3
}

rectangle "Ctrl+C (SIGINT)" as c #LightCoral {
  card "Süreç tamamlandı" as c1
  card "Durum kalıcı olarak kayboldu" as c2
  card "Geri dönüş mümkün değil" as c3
}

note bottom of z
Duraklat → Devam Et
end note

note bottom of c
Kill → Kayıp
end note
@enduml

İşler kabukta yerel

jobs, fg et `bg`seulement süreçleri başlatan kabukta çalışırlar. Eğer yeni bir terminal açarsanız, işleri görmeyeceksiniz de l'

# Terminal 1
$ vim file.txt
^Z
[1]+  Stoppé    vim file.txt

# Terminal 2 (nouveau)
$ jobs
# (rien — les jobs sont locaux au shell)

Sistem genelindeki süreçleri görmek için kullanın,ps ou htop:

ps aux | grep vim

İşler kabuk kapanınca hayatta kalmaz.

Terminale kapanırsanız, askıya alınmış veya arka planda çalışan tüm işler silinir. Bir süreç hayatta kalmasını sağlamak için kullanın`nohup` + disown :

$ nohup ./gradlew build &
[1] 12345
$ disown %1
# Fermer le terminal → le build continue

Etkileşimli süreçler ve fg

Bazı etkileşimli programlar bir sonra iyi değildir.Ctrl+Z + fg. Nadir olsa da olur :

  • Sinyal kullanan bazı programlar (vim, htop, less) iyi yönetir`Ctrl+Z`)

  • Uzun ağ programları (ssh, opencode) genellikle doğru şekilde alırlar

  • (ncurses) ile terminali değiştiren programlar bazen terminali beklenmedik bir duruma bırakabilir.

Bozuk bir terminalde bir sonra`fg`, yazın :

reset

Özet diyagram

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif
skinparam ArrowColor #444444

title "fg — her şeyi değiştiren ipucu"

rectangle "**Problem**" as problem #LightCoral {
  card "Terminal engellemiş\nbir işlem tarafından" as p1
  card "Yeni bir terminal\nacmak = ağır bir çözüm" as p2
}

rectangle "**Solution**" as solution #LightGreen {
  card "Ctrl+Z → askıya al" as s1
  card "fg → devam et" as s2
  card "bg → arka plana al" as s3
  card "jobs → askıya alınmış işleri gör" as s4
}

rectangle "**Avantages**" as advantages #SkyBlue {
  card "Bağlam kaybı yok" as a1
  card "Yeniden başlatma yok" as a2
  card "Tek bir terminal yeterli" as a3
}

problem -right-> solution : "Yerel çözüm\nUnix 40 yıldan beri"
solution -right-> advantages : "Sonuç"

note bottom of advantages
fg bir gizli ipucu değil
Temel bir mekanizma
Unix kabuğu
end note
@enduml

Fg neden düşük tahmin ediliyor?

Çoğu modern geliştirici keşfeder.`fg`Geç, belki de asla. Birkaç neden:

  1. IDE’ler terminali gizler.: VS Code bir terminal entegreli, ama çoklu sekmeler yaparlar`fg`Daha az gerekli görünüyor

  2. Grafik araçları CLI’lerin yerini alıyor.: dosya yöneticileri, sistem monitörleri, grafiksel Git istemcileri

  3. tmux ve screenbu multipleksörler aynı sorunu farklı şekilde çözerler, ama`fg`daha basit ve her zaman mevcut

Ancak,`fg`dir :

  1. **evanselel? Wait check spelling: In Turkish it’s "evrensel". So output:

evrenselHer POSIX kabuğunda (bash, zsh, fish …​) mevcuttur 2. Bağıl olmadantmux veya screen kurmaya gerek yok. 3. Anlık fotoğraf: iki vuruşlar (Ctrl+Z`sonra`fg) durdurmak ve devam ettirmek 4. Bağlam Koruyucu**: süreç durumu bozulmamıştır

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

rectangle "Fg neden\nazımsanılıyor ?" as why #LightCoral {
  card "IDE ile terminal\nçoklu sekme" as w1
  card "Grafik araçlar\nCLI-i yerine geçen" as w2
  card "tmux/screen\nsorunu çözüyorlar\nbaşka bir şekilde" as w3
}

rectangle "Fg neden\nüstün ?" as superior #LightGreen {
  card "Evrensel : bash,\nzsh, fish, sh..." as s1
  card "Bağımsızlık yok :\nkurulum gerekmiyor" as s2
  card "İki kez tuşlama :\\nCtrl+Z ardından fg" as s3
  card "Bağlam korundu :\ndurum kaybı yok" as s4
}

why -right-> superior : "Basitlik\nher zaman kazanır"
@enduml

Teknik not: sinyaller

Merak edenler için, İşte ilişkili sinyaller:

sinyal İsim Gönderen Etki

2

SIGINT

Ctrl+C

Kesinti — işlemi sonlandırır.

3

SIGQUIT

Ctrl+\

Çekirdek dökümüyle çık

18

SIGTSTP

Ctrl+Z

Etkileşimli durdur — süreci askıya alır

19

SIGCONT

fg/bg

Devam eder — askıya alınmış bir süreci yeniden başlatır

15

SIGTERM

kill %n

Temiz sonlandırma

9

SIGKILL

kill -9 %n

Zorunlu sonlandırma (intersepta alınamaz)

Tüm akış:

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontName sans-serif

participant "Kullanıcı" as user
participant "Shell" as shell
participant "Süreç" as proc

user -> shell : Ctrl+Z
shell -> proc : SIGTSTP (sinyal 18)
note right of proc : donmuş süreç\n bellekte

user -> shell : fg
shell -> proc : SIGCONT (sinyal 19)
note right of proc : İşlem ön planda devam ediyor

user -> shell :
shell -> proc : SIGCONT (sinyal 19)
note right of proc : İşlem devam ediyor\narka planda

user -> shell : Ctrl+C
shell -> proc : SIGINT (sinyal 2)
note right of proc : İşlem tamamlandı\nkaybolan durum
@enduml

Sonuç

`fg`Bu, gizli bir ipucu değil — bu Unix kabuğunun temel mekanizmasıdır ve 1970’lerden beri kullanılmaktadır. Çoğu geliştiricinin bunu fark etmemesi, günümüzün bir belirtileridir: IDE’ler ve multiplexörler bizleri temellerden uzaklaştırmıştır.

Ama bir SSH sunucusunda olduğunuzda, bir minimal terminalde, veya sadece kullanırken`opencode`ve LLM tam iş yapıyor —Ctrl+Z, fg, bg, `jobs`Sizin en iyi arkadaşlarınız

_ Ctrl+Z askıya alır, fg devam ettirir. Bu terminalin duraklatma-oynatma işlevi. _

Referanslar

İlgili Makaleler