Perlindungan benang dan teknologi pengesanan jalan buntu di Jawa

Perlindungan benang dan teknologi pengesanan kebuntuan dalam Java

Sebagai bahasa pengaturcaraan berorientasikan objek yang digunakan secara meluas dalam aplikasi peringkat perusahaan, Java mempunyai keupayaan pengaturcaraan berbilang benang yang berkuasa. Dalam proses permohonan sebenar, perlindungan benang dan teknologi pengesanan jalan buntu adalah penting, mereka boleh memastikan keselamatan benang dan kebolehpercayaan aplikasi dengan berkesan. Artikel ini akan membincangkan perkara ini.

1. Teknologi perlindungan benang

Perlindungan benang merujuk kepada menyekat dan mengawal sumber yang dikongsi untuk memastikan program berbilang benang dapat memastikan ketepatan dan integriti data apabila mengakses sumber dikongsi yang sama pada masa yang sama masa. Java menyediakan tiga teknologi perlindungan benang: kunci mutex, semaphore dan pembolehubah keadaan.

1. Kunci Mutex

Kunci Mutex ialah teknologi perlindungan benang yang paling asas. Di bawah perlindungan kunci mutex, hanya satu utas boleh mengakses sumber yang dikongsi dan utas lain mesti menunggu kunci mutex dilepaskan sebelum mereka boleh mengaksesnya. Di Jawa, kunci mutex dilaksanakan terutamanya melalui kata kunci yang disegerakkan.

Berikut ialah contoh kunci mutex mudah:

class Counter {
    private int count = 0;
    //使用 synchronized 实现互斥锁
    public synchronized void increment(){
        count += 1;
        //模拟执行某些操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
}
public class MutexExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        //创建两个线程并行执行
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
        //等待两个线程执行完毕
        t1.join();
        t2.join();
    }
}

2. Semaphore

Semaphore ialah teknologi perlindungan benang yang boleh diakses oleh berbilang benang. Ia mengekalkan bilangan utas yang boleh mengakses sumber yang dikongsi melalui pembilang Apabila utas ingin mengakses sumber yang dikongsi, ia perlu memohon semaphore terlebih dahulu Jika pembilang semaphore lebih daripada 0, utas boleh mengakses sumber yang dikongsi. jika tidak, benang mesti menunggu semaphore Pembilang hanya boleh diakses jika ia lebih besar daripada 0.

Di Java, semaphore terutamanya dilaksanakan melalui kelas Semaphore Contohnya adalah seperti berikut:

import java.util.concurrent.Semaphore;
class Counter {
    private int count = 0;
    private Semaphore sem = new Semaphore(1);
    //使用 Semaphore 实现线程保护
    public void increment(){
        try {
            sem.acquire();
            count += 1;
            //模拟执行某些操作
            Thread.sleep(1000);
            System.out.println(count);
            sem.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class SemaphoreExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        //创建两个线程并行执行
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
        //等待两个线程执行完毕
        t1.join();
        t2.join();
    }
}

3 Pembolehubah keadaan

Pembolehubah keadaan ialah kaedah yang membenarkan utas untuk menunggu syarat tertentu untuk dipenuhi Teknologi perlindungan benang yang meneruskan pelaksanaan kemudian, yang boleh digunakan bersama dengan kunci mutex. Di Java, pembolehubah keadaan terutamanya dilaksanakan melalui antara muka Keadaan dan kelas ReentrantLock Contoh adalah seperti berikut:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
class Counter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();
    private Condition cond = lock.newCondition();
    public void increment() {
        lock.lock();
        try {
            count += 1;
            //模拟执行某些操作
            Thread.sleep(1000);
            System.out.println(count);
            cond.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void waitUntil(int target) {
        lock.lock();
        try {
            while (count < target) {
                cond.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class ConditionVariableExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        //创建两个线程并行执行
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            counter.waitUntil(3);
            System.out.println("Target reached");
        });
        t1.start();
        t2.start();
        //等待两个线程执行完毕
        t1.join();
        t2.join();
    }
}

2. Teknologi pengesanan kebuntuan

Kebuntuan merujuk kepada berbilang benang yang menunggu satu sama lain untuk. melepaskan data yang mereka pegang sumber, menyebabkan program tidak dapat meneruskan pelaksanaan. Java menyediakan alat dan teknik untuk mengesan dan mengelakkan kebuntuan.

1.jstack

jstack ialah alat yang disediakan oleh persekitaran masa jalan Java Ia boleh digunakan untuk melihat status CPU yang diduduki oleh setiap utas dalam mesin maya Java dan kunci yang dipegang oleh benang dan kunci menunggu. jstack mengeluarkan surih tindanan benang untuk melihat sumber yang diduduki oleh benang untuk menentukan sama ada terdapat jalan buntu.

2.jvisualvm

jvisualvm ialah alat grafik yang disertakan dengan JDK, yang boleh digunakan untuk memantau penggunaan sumber seperti benang, CPU, memori dan tindanan. Melalui jvisualvm, kami boleh menyemak sumber yang diduduki oleh benang dengan mudah, mengesan dan mendiagnosis kebuntuan dalam masa, dan mengambil langkah yang sepadan dengan tepat pada masanya.

3.ThreadMXBean

ThreadMXBean ialah salah satu antara muka pengurusan Java Ia menyediakan beberapa alatan dan kaedah yang boleh digunakan untuk memantau dan mengurus utas dalam JVM, termasuk status utas dan penggunaan CPU utas. . situasi, kunci pendudukan benang, kebuntuan benang dan maklumat lain. Dengan menggunakan ThreadMXBean, kami boleh mengesan masalah kebuntuan dengan mudah dalam program dan membuat pelarasan dan pengoptimuman tepat pada masanya.

Ringkasan

Artikel ini menyediakan pengenalan ringkas dan contoh demonstrasi perlindungan benang dan teknologi pengesanan jalan buntu di Jawa. Dalam pembangunan sebenar, kita mesti memahami dan menguasai teknologi ini dengan teliti untuk memastikan ketepatan dan kebolehpercayaan program berbilang benang, dengan itu meningkatkan prestasi dan kestabilan aplikasi.

Atas ialah kandungan terperinci Perlindungan benang dan teknologi pengesanan jalan buntu di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!