Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Lock:tuple

Peristiwa Lock:tuple terjadi saat proses backend menunggu perolehan kunci pada tuple.

Versi mesin yang didukung

Informasi peristiwa tunggu ini didukung untuk semua versi Aurora PostgreSQL.

Konteks

Peristiwa Lock:tuple menunjukkan bahwa backend sedang menunggu untuk memperoleh kunci pada tuple, sementara backend lain memegang kunci yang bertentangan pada tuple yang sama. Tabel berikut menggambarkan skenario saat sesi membuat peristiwa Lock:tuple.

Atau Anda dapat menyimulasikan peristiwa tunggu ini dengan menggunakan alat benchmarking pgbench. Konfigurasikan jumlah sesi bersamaan yang tinggi untuk memperbarui baris yang sama pada tabel dengan file SQL khusus.

Untuk mempelajari selengkapnya tentang mode kunci yang bertentangan, lihat Penguncian Eksplisit pada dokumentasi PostgreSQL. Untuk mempelajari selengkapnya tentang pgbench, lihat pgbench pada dokumentasi PostgreSQL.

Kemungkinan penyebab peningkatan peristiwa tunggu

Saat peristiwa ini ditampilkan lebih dari biasanya, mungkin menunjukkan masalah performa, penyebab umumnya terdiri dari berikut:

Untuk informasi selengkapnya, lihat Penguncian Tingkat Baris pada dokumentasi PostgreSQL.

Tindakan

Kami merekomendasikan berbagai tindakan tergantung pada penyebab peristiwa tunggu Anda.

Menyelidiki logika aplikasi

Cari tahu apakah sesi pemblokir telah berada pada status idle in transaction dalam waktu yang lama. Jika demikian, coba akhiri sesi pemblokir sebagai solusi jangka pendek. Anda dapat menggunakan fungsi pg_terminate_backend. Untuk informasi selengkapnya tentang fungsi ini, lihat Fungsi Pemberi Sinyal Server pada dokumentasi PostgreSQL.

Untuk solusi jangka panjang, lakukan hal berikut:

Menemukan sesi pemblokir

Saat peristiwa tunggu Lock:tuple terjadi, identifikasi pemblokir dan sesi yang diblokir dengan mencari tahu kunci yang bergantung satu sama lain. Untuk informasi selengkapnya, lihat Informasi dependensi kunci pada wiki PostgreSQL. Untuk menganalisis peristiwa Lock:tuple yang lampau, gunakan fungsi Aurora aurora_stat_backend_waits.

Contoh berikut memberikan kueri semua sesi, memfilter tuple, dan mengurutkan berdasarkan wait_time.

--AURORA_STAT_BACKEND_WAITS
      SELECT a.pid, 
             a.usename, 
             a.app_name, 
             a.current_query,
             a.current_wait_type, 
             a.current_wait_event, 
             a.current_state, 
             wt.type_name AS wait_type, 
             we.event_name AS wait_event, 
             a.waits, 
             a.wait_time
        FROM (SELECT pid, 
                     usename, 
                     left(application_name,16) AS app_name,
                     coalesce(wait_event_type,'CPU') AS current_wait_type,
                     coalesce(wait_event,'CPU') AS current_wait_event, 
                     state AS current_state,
                     left(query,80) as current_query,
                     (aurora_stat_backend_waits(pid)).* 
                FROM pg_stat_activity 
               WHERE pid <> pg_backend_pid()
                 AND usename<>'rdsadmin') a
NATURAL JOIN aurora_stat_wait_type() wt 
NATURAL JOIN aurora_stat_wait_event() we
WHERE we.event_name = 'tuple'
    ORDER BY a.wait_time;

  pid  | usename | app_name |                 current_query                  | current_wait_type | current_wait_event | current_state | wait_type | wait_event | waits | wait_time
-------+---------+----------+------------------------------------------------+-------------------+--------------------+---------------+-----------+------------+-------+-----------
 32136 | sys     | psql     | /*session3*/ update tab set col=1 where col=1; | Lock              | tuple              | active        | Lock      | tuple      |     1 |   1000018
 11999 | sys     | psql     | /*session4*/ update tab set col=1 where col=1; | Lock              | tuple              | active        | Lock      | tuple      |     1 |   1000024

Mengurangi konkurensi saat tinggi

Peristiwa Lock:tuple mungkin terjadi terus-menerus, terutama pada waktu beban kerja yang sibuk. Dalam situasi ini, coba kurangi konkurensi tinggi untuk baris yang sangat sibuk. Sering kali, hanya beberapa baris mengontrol antrean atau logika Boolean, yang membuat baris ini sangat sibuk.

Anda dapat mengurangi konkurensi dengan menggunakan pendekatan yang berbeda berdasarkan ketentuan bisnis, logika aplikasi, dan jenis beban kerja. Misalnya, Anda dapat melakukan hal berikut:

Memecahkan masalah

Lock:tuple dapat terjadi dengan masalah seperti kekurangan CPU atau penggunaan maksimum bandwidth Amazon EBS. Untuk mengurangi masalah, pertimbangkan pendekatan berikut: