// Bayangkan fungsi fetchData yang mengembalikan Promise
function fetchUserData() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ name: 'Alice' });
    }, 2000);
  });
}

// Hook pengambilan data hipotetis yang mendukung Suspense
function useUserData() {
  const data = fetch(url);
  if (data.status === 'pending') {
    throw new Promise(resolve => {
      // Inilah yang diintersep oleh Suspense
      setTimeout(() => resolve(null), 2000); 
    });
  }
  return data.value;
}

function UserProfile() {
  const userData = useUserData(); // Panggilan ini mungkin akan menangguhkan (suspend)
  return 
Welcome, {userData.name}!
;
}

function App() {
  return (
    Loading user...

2. Batching Otomatis

Batching adalah proses mengelompokkan beberapa pembaruan state ke dalam satu kali re-render. Secara tradisional, React hanya melakukan batching pembaruan yang terjadi di dalam event handler. Pembaruan yang dimulai di luar event handler (misalnya, di dalam promise atau `setTimeout`) tidak di-batch, yang menyebabkan re-render yang tidak perlu.

Cara kerjanya dengan concurrency: Dengan Concurrent Mode, React secara otomatis melakukan batching semua pembaruan state, terlepas dari mana asalnya. Ini berarti jika Anda memiliki beberapa pembaruan state yang terjadi secara berurutan (misalnya, dari beberapa operasi asinkron yang selesai), React akan mengelompokkannya dan melakukan satu kali re-render, meningkatkan performa dan mengurangi overhead dari beberapa siklus rendering.

Contoh: Misalkan Anda mengambil data dari dua API yang berbeda. Setelah keduanya selesai, Anda memperbarui dua bagian state yang terpisah. Dalam versi React yang lebih lama, ini mungkin memicu dua kali re-render. Di Concurrent Mode, pembaruan ini di-batch, menghasilkan satu kali re-render yang lebih efisien.

3. Transisi (Transitions)

Transisi adalah konsep baru yang diperkenalkan untuk membedakan antara pembaruan yang mendesak dan yang tidak mendesak. Ini adalah mekanisme inti untuk memungkinkan rendering yang dapat diinterupsi.

Pembaruan Mendesak (Urgent Updates): Ini adalah pembaruan yang memerlukan umpan balik segera, seperti mengetik di kolom input, mengklik tombol, atau memanipulasi elemen UI secara langsung. Pembaruan ini harus terasa instan.

Pembaruan Transisi (Transition Updates): Ini adalah pembaruan yang bisa memakan waktu lebih lama dan tidak memerlukan umpan balik segera. Contohnya termasuk merender halaman baru setelah mengklik tautan, memfilter daftar yang besar, atau memperbarui elemen UI terkait yang tidak merespons klik secara langsung. Pembaruan ini dapat diinterupsi.

Cara kerjanya dengan concurrency: Menggunakan API `startTransition`, Anda dapat menandai pembaruan state tertentu sebagai transisi. Scheduler React kemudian akan memperlakukan pembaruan ini dengan prioritas lebih rendah dan dapat menginterupsinya jika terjadi pembaruan yang lebih mendesak. Ini memastikan bahwa saat pembaruan yang tidak mendesak (seperti merender daftar besar) sedang berlangsung, pembaruan yang mendesak (seperti mengetik di bilah pencarian) diprioritaskan, menjaga UI tetap responsif.

Contoh Global: Pertimbangkan sebuah situs web pemesanan perjalanan. Ketika pengguna memilih tujuan baru, ini mungkin memicu serangkaian pembaruan: mengambil data penerbangan, memperbarui ketersediaan hotel, dan merender peta. Jika pengguna segera memutuskan untuk mengubah tanggal perjalanan saat pembaruan awal masih diproses, API `startTransition` memungkinkan React untuk menjeda pembaruan penerbangan/hotel, memproses perubahan tanggal yang mendesak, dan kemudian berpotensi melanjutkan atau memulai kembali pengambilan data penerbangan/hotel berdasarkan tanggal baru. Ini mencegah UI membeku selama urutan pembaruan yang kompleks.

Cuplikan Kode (Ilustrasi):

import { useState, useTransition } from 'react';

function SearchResults() {
  const [isPending, startTransition] = useTransition();
  const [query, setQuery] = useState('');
  const [results, setResults] = useState([]);

  const handleQueryChange = (e) => {
    const newQuery = e.target.value;
    setQuery(newQuery);

    // Tandai pembaruan ini sebagai transisi
    startTransition(() => {
      // Mensimulasikan pengambilan hasil, ini bisa diinterupsi
      fetchResults(newQuery).then(res => setResults(res));
    });
  };

  return (
    

      
      {isPending && 
Loading results...
}
      

        {results.map(item => (
          
{item.name}
        ))}
      
    
  );
}

4. Integrasi Pustaka (Library) dan Ekosistem

Manfaat Concurrent Mode tidak terbatas pada fitur inti React. Seluruh ekosistem sedang beradaptasi. Pustaka yang berinteraksi dengan React, seperti solusi routing atau alat manajemen state, juga dapat memanfaatkan concurrency untuk memberikan pengalaman yang lebih lancar.

Contoh: Pustaka routing dapat menggunakan transisi untuk bernavigasi antar halaman. Jika pengguna bernavigasi pergi sebelum halaman saat ini selesai dirender sepenuhnya, pembaruan routing dapat diinterupsi atau dibatalkan dengan mulus, dan navigasi baru dapat diutamakan. Ini memastikan bahwa pengguna selalu melihat tampilan terbaru yang mereka inginkan.

Cara Mengaktifkan dan Menggunakan Fitur Concurrent

Meskipun Concurrent Mode adalah pergeseran mendasar, mengaktifkan fiturnya umumnya mudah dan seringkali melibatkan perubahan kode minimal, terutama untuk aplikasi baru atau saat mengadopsi fitur seperti Suspense dan Transitions.

1. Versi React

Fitur concurrent tersedia di React 18 dan versi yang lebih baru. Pastikan Anda menggunakan versi yang kompatibel:

npm install react@latest react-dom@latest

2. Root API (`createRoot`)

Cara utama untuk mengaktifkan fitur concurrent adalah dengan menggunakan API `createRoot` yang baru saat me-mount aplikasi Anda:

// index.js atau main.jsx
import ReactDOM from 'react-dom/client';
import App from './App';

const container = document.getElementById('root');
const root = ReactDOM.createRoot(container);
root.render();

Menggunakan `createRoot` secara otomatis mengaktifkan semua fitur concurrent, termasuk batching otomatis, transisi, dan Suspense.

Catatan: API `ReactDOM.render` yang lama tidak mendukung fitur concurrent. Migrasi ke `createRoot` adalah langkah kunci untuk membuka concurrency.

3. Mengimplementasikan Suspense

Seperti yang ditunjukkan sebelumnya, Suspense diimplementasikan dengan membungkus komponen yang melakukan operasi asinkron dengan boundary <Suspense> dan menyediakan prop fallback.

Praktik Terbaik:

• Gunakan boundary <Suspense> secara bersarang untuk mengelola status loading secara granular.
• Gunakan custom hooks yang terintegrasi dengan Suspense untuk logika pengambilan data yang lebih bersih.
• Pertimbangkan untuk menggunakan pustaka seperti Relay atau Apollo Client, yang memiliki dukungan kelas satu untuk Suspense.

4. Menggunakan Transisi (`startTransition`)

Identifikasi pembaruan UI yang tidak mendesak dan bungkus dengan startTransition.

Kapan harus digunakan:

• Memperbarui hasil pencarian setelah pengguna mengetik.
• Bernavigasi antar rute.
• Memfilter daftar atau tabel yang besar.
• Memuat data tambahan yang tidak berdampak langsung pada interaksi pengguna.

Contoh: Untuk pemfilteran kompleks dari dataset besar yang ditampilkan dalam tabel, Anda akan mengatur state filter query dan kemudian memanggil startTransition untuk pemfilteran aktual dan re-rendering baris tabel. Ini memastikan bahwa jika pengguna dengan cepat mengubah kriteria filter lagi, operasi pemfilteran sebelumnya dapat diinterupsi dengan aman.

Manfaat Rendering yang Dapat Diinterupsi untuk Audiens Global

Keuntungan dari rendering yang dapat diinterupsi dan Concurrent Mode menjadi lebih besar ketika mempertimbangkan basis pengguna global dengan kondisi jaringan dan kemampuan perangkat yang beragam.

• Peningkatan Performa yang Dirasakan: Bahkan pada koneksi yang lebih lambat atau perangkat yang kurang bertenaga, UI tetap responsif. Pengguna merasakan aplikasi yang lebih gesit karena interaksi kritis tidak pernah diblokir untuk waktu yang lama.
• Aksesibilitas yang Ditingkatkan: Dengan memprioritaskan interaksi pengguna, aplikasi menjadi lebih mudah diakses oleh pengguna yang mengandalkan teknologi bantu atau yang mungkin memiliki gangguan kognitif yang mendapat manfaat dari antarmuka yang responsif secara konsisten.
• Mengurangi Frustrasi: Pengguna global, yang sering beroperasi di zona waktu yang berbeda dan dengan pengaturan teknis yang bervariasi, menghargai aplikasi yang tidak membeku atau lambat. UX yang lancar menghasilkan keterlibatan dan kepuasan yang lebih tinggi.
• Manajemen Sumber Daya yang Lebih Baik: Pada perangkat seluler atau perangkat keras yang lebih tua, di mana CPU dan memori seringkali terbatas, rendering yang dapat diinterupsi memungkinkan React untuk mengelola sumber daya secara efisien, menjeda tugas yang tidak penting untuk memberi jalan bagi yang kritis.
• Pengalaman yang Konsisten di Seluruh Perangkat: Baik pengguna menggunakan desktop kelas atas di Silicon Valley atau smartphone anggaran di Asia Tenggara, responsivitas inti aplikasi dapat dipertahankan, menjembatani kesenjangan dalam kemampuan perangkat keras dan jaringan.

Pertimbangkan aplikasi belajar bahasa yang digunakan oleh siswa di seluruh dunia. Jika satu siswa sedang mengunduh pelajaran baru (tugas yang berpotensi lama) sementara yang lain mencoba menjawab pertanyaan kosakata cepat, rendering yang dapat diinterupsi memastikan bahwa pertanyaan kosakata dijawab secara instan, meskipun unduhan sedang berlangsung. Ini sangat penting untuk alat pendidikan di mana umpan balik segera sangat vital untuk belajar.

Potensi Tantangan dan Pertimbangan

Meskipun Concurrent Mode menawarkan keuntungan yang signifikan, mengadopsinya juga melibatkan kurva belajar dan beberapa pertimbangan:

• Debugging: Men-debug operasi asinkron dan yang dapat diinterupsi bisa lebih menantang daripada men-debug kode sinkron. Memahami alur eksekusi dan kapan tugas mungkin dijeda atau dilanjutkan memerlukan perhatian yang cermat.
• Pergeseran Model Mental: Pengembang perlu menyesuaikan pemikiran mereka dari model eksekusi yang murni sekuensial ke pendekatan yang lebih konkuren dan berbasis peristiwa. Memahami implikasi dari startTransition dan Suspense adalah kuncinya.
• Pustaka Eksternal: Tidak semua pustaka pihak ketiga diperbarui untuk sadar concurrency. Menggunakan pustaka lama yang melakukan operasi blocking mungkin masih menyebabkan UI membeku. Penting untuk memastikan dependensi Anda kompatibel.
• Manajemen State: Meskipun fitur concurrency bawaan React sangat kuat, skenario manajemen state yang kompleks mungkin memerlukan pertimbangan yang cermat untuk memastikan semua pembaruan ditangani dengan benar dan efisien dalam paradigma concurrent.

Masa Depan Concurrency di React

Perjalanan React menuju concurrency terus berlanjut. Tim terus menyempurnakan scheduler, memperkenalkan API baru, dan meningkatkan pengalaman pengembang. Fitur-fitur seperti Offscreen API (memungkinkan komponen dirender tanpa memengaruhi UI yang dirasakan pengguna, berguna untuk pra-rendering atau tugas latar belakang) semakin memperluas kemungkinan yang dapat dicapai dengan rendering concurrent.

Seiring web menjadi semakin kompleks dan harapan pengguna akan performa dan responsivitas terus meningkat, rendering concurrent menjadi bukan hanya sebuah optimisasi tetapi sebuah keharusan untuk membangun aplikasi modern yang menarik yang melayani audiens global.

Kesimpulan

React Concurrent Mode dan konsep intinya tentang rendering yang dapat diinterupsi merupakan evolusi signifikan dalam cara kita membangun antarmuka pengguna. Dengan memungkinkan React untuk menjeda, melanjutkan, dan memprioritaskan tugas rendering, kita dapat membuat aplikasi yang tidak hanya berkinerja tinggi tetapi juga sangat responsif dan tangguh, bahkan di bawah beban berat atau di lingkungan yang terbatas.

Bagi audiens global, ini berarti pengalaman pengguna yang lebih adil dan menyenangkan. Baik pengguna Anda mengakses aplikasi Anda dari koneksi serat optik berkecepatan tinggi di Eropa atau jaringan seluler di negara berkembang, Concurrent Mode membantu memastikan bahwa aplikasi Anda terasa cepat dan lancar.

Menerapkan fitur seperti Suspense dan Transitions, serta bermigrasi ke Root API yang baru, adalah langkah-langkah penting untuk membuka potensi penuh React. Dengan memahami dan menerapkan konsep-konsep ini, Anda dapat membangun generasi berikutnya dari aplikasi web yang benar-benar memuaskan pengguna di seluruh dunia.

Poin-Poin Penting:

• Concurrent Mode dari React memungkinkan rendering yang dapat diinterupsi, melepaskan diri dari pemblokan sinkron.
• Fitur seperti Suspense, batching otomatis, dan Transitions dibangun di atas fondasi concurrent ini.
• Gunakan createRoot untuk mengaktifkan fitur concurrent.
• Identifikasi dan tandai pembaruan yang tidak mendesak dengan startTransition.
• Rendering concurrent secara signifikan meningkatkan UX untuk pengguna global, terutama pada kondisi jaringan dan perangkat yang bervariasi.
• Tetap update dengan fitur concurrency React yang terus berkembang untuk performa optimal.

Mulai jelajahi Concurrent Mode dalam proyek Anda hari ini dan bangun aplikasi yang lebih cepat, lebih responsif, dan lebih menyenangkan untuk semua orang.