fg komutunun süper ipucu: Ctrl+Z, terminal oturumunuzu kaydeder.
Yayınlandı: 18 April 2026
- Sorun: meşgul bir terminal
- Üç zorunlu komut
- Senaryo 1: Uzun derleme
- Senaryo 2: Unutulmuş editör
- Senaryo 3: Durdurulan opencode süreci
- Senaryo 4 : Çok sayıda işi aynı anda yönetme
- fg, bg, Ctrl+Z, Ctrl+C ve & arasındaki farklar
- Bir işin tam yaşam döngüsü
- İleri seviye ipuçları
- Yaygın tuzaklar ve hatalar
- Özet diyagram
- Fg neden düşük tahmin ediliyor?
- Teknik not: sinyaller
- Sonuç
- Referanslar
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 :
-
Bağlam kaybı yok: LLM oturumu, konuşma geçmişi, açılan dosyalar — her şey korunur
-
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 |
|---|---|---|
|
Ön plandaki süreci askıya al |
Gönderim`SIGTSTP` |
|
Varsayılan işi ön planda devam ettir |
|
|
İş n’i öne alın |
|
|
Varsayılan işi arka planda sürdürün |
|
|
Arka planda n işini devam ettirir |
|
|
Mevcut kabuğun işlerini listele |
|
|
Tamamla iş n |
|
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? |
|---|---|---|---|
|
|
İşlemi (dondurulmuş, bellekte) askıya alır |
Evet :`fg` ou |
|
|
İşlemi sonlandır (tamamlandı) |
Hayır : süreç yok edildi |
|
|
İşlemi öldür + core dump |
Hayır : süreç yok edildi |
|
— |
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:
-
IDE’ler terminali gizler.: VS Code bir terminal entegreli, ama çoklu sekmeler yaparlar`fg`Daha az gerekli görünüyor
-
Grafik araçları CLI’lerin yerini alıyor.: dosya yöneticileri, sistem monitörleri, grafiksel Git istemcileri
-
tmux ve screenbu multipleksörler aynı sorunu farklı şekilde çözerler, ama`fg`daha basit ve her zaman mevcut
Ancak,`fg`dir :
-
**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 |
|
|
Kesinti — işlemi sonlandırır. |
3 |
|
|
Çekirdek dökümüyle çık |
18 |
|
|
Etkileşimli durdur — süreci askıya alır |
19 |
|
|
Devam eder — askıya alınmış bir süreci yeniden başlatır |
15 |
|
|
Temiz sonlandırma |
9 |
|
|
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
-
man bash— JOB CONTROL bölümü -
man signal— POSIX sinyalleri listesi