Pada metrik performa web modern Google Core Web Vitals, metrik Interaction to Next Paint (INP) dan Total Blocking Time (TBT) berfokus langsung pada responsivitas antarmuka. Sebuah website dapat memuat konten visual dengan cepat (skor LCP baik), tetapi jika thread utama browser (main thread) dibebani oleh eksekusi skrip JavaScript yang berat, pengguna akan merasakan keterlambatan respons saat menekan tombol navigasi, membuka filter, atau mengetik di formulir.
Penyebab paling dominan dari tingginya skor TBT adalah keberadaan Long Tasks, yaitu eksekusi JavaScript yang memblokir main thread lebih dari 50 milidetik.
Anatomi Long Task dan Dampaknya pada Main Thread #
Browser menjalankan proses rendering tata letak (layout), penggambaran piksel (paint), dan komputasi JavaScript dalam satu antrean sekuensial pada main thread.
Antrean Main Thread Browser:
[Task Singkat: 20ms] [Task Singkat: 15ms] [========== Long Task: 180ms ==========] [Input User]
├──────── 50ms ────────┤◄─── TBT: 130ms ──►│ (Tertahan)
Ketika sebuah task memakan waktu 180 milidetik:
- Ambang batas aman adalah 50 milidetik.
- Selisih 130 milidetik dihitung sebagai waktu pemblokiran (blocking time).
- Jika pengguna melakukan klik selama rentang 180 milidetik tersebut, browser tidak dapat memproses event input sampai task selesai dieksekusi. Akibatnya, input latency membengkak dan skor INP memburuk.
Total Blocking Time (TBT) adalah akumulasi seluruh blocking time dari task yang melebihi 50 ms antara First Contentful Paint (FCP) dan Time to Interactive (TTI).
Menganalisis Titik Macet di Chrome DevTools Performance Tab #
Untuk mengidentifikasi kode JavaScript yang memicu Long Tasks:
- Buka Chrome DevTools pada jendela penyamaran (Incognito Window).
- Pilih tab Performance, aktifkan CPU: 4x slowdown untuk mensimulasikan perangkat ponsel kelas menengah.
- Rekam interaksi saat memuat halaman atau menekan elemen interaktif.
- Perhatikan bagian antrean Main: cari blok berwarna abu-abu dengan sudut merah bergaris (red corner flag), yang menandakan deteksi Long Task.
- Klik tab Bottom-Up di panel bawah: urutkan berdasarkan Self Time untuk melihat fungsi kalkulasi spesifik mana yang menghabiskan waktu komputasi terbesar (misalnya serialisasi objek besar, manipulasi DOM berulang, atau parsing bundle third-party).
Strategi Remediasi: Pemecahan Task Menggunakan scheduler.yield()
#
Pendekatan konvensional memecah loop besar adalah menggunakan setTimeout(fn, 0). Namun, setTimeout memiliki penalti latensi bawaan minimal 4 milidetik di browser dan menaruh callback di ujung akhir task queue, menunda proses rendering visual.
Standar web modern memperkenalkan API native scheduler.yield(). API ini mengembalikan kendali ke browser untuk menyelesaikan rendering dan memproses event input yang tertunda, lalu melanjutkan eksekusi JavaScript tepat setelahnya tanpa kehilangan prioritas task.
Berikut adalah implementasi helper TypeScript untuk mengeksekusi iterasi data besar secara non-blocking:
// Helper scheduler.yield() dengan fallback requestAnimationFrame / MessageChannel
export async function yieldToMainThread(): Promise<void> {
if ('scheduler' in window && 'yield' in (window as any).scheduler) {
return await (window as any).scheduler.yield();
}
// Fallback untuk browser lawas menggunakan MessageChannel (lebih cepat daripada setTimeout)
return new Promise((resolve) => {
const channel = new MessageChannel();
channel.port1.onmessage = () => resolve();
channel.port2.postMessage(null);
});
}
// Fungsi pemrosesan array besar tanpa memicu Long Task
export async function processLargeDatasetChunked<T, R>(
items: T[],
processItem: (item: T) => R,
maxExecutionTimeMs = 15
): Promise<R[]> {
const results: R[] = [];
let lastYieldTime = performance.now();
for (let i = 0; i < items.length; i++) {
results.push(processItem(items[i]));
// Cek apakah waktu eksekusi saat ini sudah mendekati batas aman
if (performance.now() - lastYieldTime > maxExecutionTimeMs) {
await yieldToMainThread();
lastYieldTime = performance.now();
}
}
return results;
}
Dengan membatasi siklus eksekusi maksimal 15 milidetik per batch, main thread tidak pernah terblokir melebihi 50 milidetik, sehingga TBT terpangkas menjadi 0 milidetik.
Memindahkan Komputasi Berat ke Web Worker #
Jika pemrosesan data membutuhkan perhitungan matematika kompleks, parsing file CSV besar, atau manipulasi gambar kanvas, pekerjaan tersebut harus dipindahkan keluar dari main thread menggunakan Web Worker independen.
// worker.ts: Berjalan di thread background terpisah tanpa akses DOM
self.onmessage = (event: MessageEvent<{ data: number[] }>) => {
const sorted = event.data.data.sort((a, b) => a - b);
self.postMessage({ result: sorted });
};
// main.ts: Main thread tetap responsif untuk interaksi pengguna
const worker = new Worker(new URL('./worker.ts', import.meta.url));
export function sortDataInWorker(numbers: number[]): Promise<number[]> {
return new Promise((resolve) => {
worker.onmessage = (e) => resolve(e.data.result);
worker.postMessage({ data: numbers });
});
}
Optimasi Hydration dan Dynamic Import pada Next.js #
Pada aplikasi berbasis React dan Next.js App Router, Long Tasks sering terjadi saat fase Hydration, yaitu ketika React mengikat event listener ke seluruh markup HTML yang dirender dari server.
Langkah-langkah eliminasi TBT hydration:
- Dynamic Import Komponen Berat:
Gunakannext/dynamicuntuk komponen yang berada di bawah layar (below-the-fold) atau hanya muncul setelah interaksi pengguna (seperti modal, kalkulator kompleks, atau grafik analitik).
import dynamic from 'next/dynamic';
const InteractiveArchitectureDiagram = dynamic(
() => import('@/components/InteractiveArchitectureDiagram'),
{
ssr: false,
loading: () => <div className="h-96 animate-pulse bg-surface-subtle rounded-xl" />,
}
);
- Isolasi Third-Party Scripts:
Skrip pelacakan analitik dan tag marketing adalah sumber utama Long Tasks pihak ketiga. Gunakan strategi pemuatanstrategy="lazyOnload"atau pindahkan eksekusi pelacakan pihak ketiga menggunakan Partytown ke background worker.
Pemantauan RUM (Real User Monitoring) dengan PerformanceObserver #
Untuk memantau durasi Long Tasks yang dialami pengguna secara real-time di lingkungan produksi, manfaatkan API PerformanceObserver:
if (typeof window !== 'undefined' && 'PerformanceObserver' in window) {
try {
const observer = new PerformanceObserver((entryList) => {
for (const entry of entryList.getEntries()) {
if (entry.duration > 50) {
console.warn(`[Long Task Detected] Durasi: ${entry.duration.toFixed(1)} ms`, entry);
// Kirim metrik ke endpoint telemetri internal
}
}
});
observer.observe({ entryTypes: ['longtask'] });
} catch (e) {
// Abaikan jika browser tidak mendukung entryType longtask
}
}
Disiplin memecah eksekusi synchronous, menunda komponen berat, dan memindahkan komputasi intensif ke worker menjamin skor TBT tetap hijau dan antarmuka web selalu responsif terhadap setiap sentuhan pengguna.
