Prinsip dan senario penggunaan Disegerakkan dalam Java dan analisis penggunaan dan perbezaan antara muka Boleh Panggil

1. Ciri asas

1. Ia bermula dengan penguncian yang optimistik, ia akan ditukar kepada penguncian yang pesimis

2. Mulakan dengan pelaksanaan kunci ringan Jika kunci dipegang untuk masa yang lama, ia akan ditukar menjadi kunci kelas berat.

3 Kunci putaran berkemungkinan besar digunakan apabila melaksanakan kunci ringan Kunci >2. Proses penguncian

JVM membahagikan kunci yang disegerakkan kepada keadaan kunci bebas kunci, berat sebelah, kunci ringan dan kunci berat. Ia akan dinaik taraf secara berurutan mengikut situasi.

Bias lock

Anggap bahawa protagonis lelaki adalah kunci dan protagonis perempuan adalah benang Jika hanya benang ini menggunakan kunci ini, maka lelaki protagonis dan protagonis wanita Walaupun protagonis tidak mendapat sijil perkahwinan (mengelakkan operasi kos tinggi), dia masih boleh hidup bahagia Namun, protagonis wanita muncul dan cuba bersaing untuk protagonis lelaki, tidak kira betapa mahalnya operasi mendapatkan sijil nikah, srikandi mesti juga Tindakan ini selesai, biarlah protagonis wanita menyerah

Kunci berat sebelah tidak benar-benar "mengunci", ia hanya membuat "tanda kunci berat sebelah" dalam pengepala objek untuk merekodkan benang mana yang dimiliki oleh kunci Jika tiada benang susulan lain untuk bersaing untuk kunci, maka tidak perlu melakukan operasi penyegerakan lain (mengelakkan overhed mengunci dan membuka kunci jika lain). benang bersaing untuk mendapatkan kunci kemudian (ia baru sahaja direkodkan dalam objek kunci yang mempunyai benang kunci semasa, ia adalah mudah Kenal pasti sama ada benang yang sedang memohon kunci ialah benang yang direkodkan sebelum ini), kemudian batalkan keadaan kunci berat sebelah asal dan masukkan keadaan kunci ringan umum

Penguncian berat sebelah pada asasnya bersamaan dengan "penguncian tertunda". tanda itu, jika tidak, anda tidak boleh membezakan bila penguncian sebenar diperlukan

Kunci berat sebelah bukan penguncian sebenar, tetapi hanya merekodkan tanda dalam pengepala objek kunci (merakam benang yang menjadi milik kunci). Jika tiada utas lain mengambil bahagian dalam bersaing untuk kunci, maka operasi penguncian tidak akan dilakukan, sekali gus mengurangkan overhed program Setelah utas lain benar-benar terlibat Pertandingan Benang, kemudian batalkan keadaan kunci berat sebelah, masukkan keadaan kunci ringan

Kunci ringan

Apabila utas lain memasuki pertandingan, keadaan kunci berat sebelah dihapuskan, masukkan Status kunci ringan (kunci putaran mudah suai di sini dilaksanakan melalui CAS >Semak dan kemas kini sekeping memori melalui CAS (seperti null => dirujuk oleh utas)

Jika kemas kini berjaya, penguncian dianggap berjaya

Jika kemas kini gagal, kunci dianggap sibuk dan penantian seperti putaran berterusan (tanpa melepaskan CPU).

Operasi putaran adalah Mengekalkan CPU melahu adalah pembaziran sumber CPU Oleh itu, putaran di sini tidak akan berterusan selama-lamanya , tetapi akan berhenti berputar selepas mencapai masa tertentu/bilangan percubaan semula Ini adalah apa yang dipanggil "adaptif"

Kunci heavyweight

Jika persaingan menjadi lebih sengit dan putaran tidak dapat memperoleh. status kunci dengan cepat, ia akan berkembang menjadi kunci kelas berat Kunci kelas berat di sini merujuk kepada penggunaan mutex yang disediakan oleh kernel.

Untuk melakukan operasi mengunci, mula-mula masukkan keadaan kernel.

Dalam keadaan kernel, tentukan sama ada kunci semasa sudah diduduki

Jika kunci tidak diduduki, penguncian berjaya dan suis Kembali ke mod pengguna.

Jika kunci telah diisi , kunci gagal Pada masa ini, utas memasuki baris gilir menunggu kunci dan tergantung Menunggu untuk dikejutkan oleh sistem pengendalian.

Selepas beberapa siri, kunci itu dikeluarkan oleh utas lain. , dan sistem pengendalian juga mengingati benang yang digantung, jadi ia membangkitkan benang dan cuba mendapatkan semula kunci

3. Operasi pengoptimuman lain

Penghapusan kunci

Pengkompil + JVM menentukan sama ada kunci boleh dihapuskan Jika boleh, hapuskan sahaja terus

Sesetengah kod aplikasi menggunakan disegerakkan, tetapi ia sebenarnya tidak digunakan dalam persekitaran berbilang benang (Contohnya, StringBuffer)

Pada masa ini, setiap panggilan untuk ditambahkan akan melibatkan penguncian dan membuka kunci. . Pemimpin, terangkan tugas kerja kepada orang bawahan

Kaedah 1:

Panggil, terangkan tugasan 1, tutup telefon.

Panggil, terangkan tugasan 2. Tutup telefon.

Panggil, beri tugas 3, tutup telefon

StringBuffer sb = new StringBuffer();
sb.append("a");
sb.append("b");
sb.append("c");
sb.append("d");

Kaedah 2:

Panggil, beri tugas 1, tugas 2, tugas 3, tutup telefon

4. Antara muka boleh dipanggil

Apa itu Boleh Dipanggil

Boleh Dipanggil ialah antara muka Ia bersamaan dengan merangkumkan "nilai pulangan" dalam utas Ia adalah mudah untuk pengaturcara menggunakan pelbagai benang. Hasil pengiraan.

Callable 和 Runnable 相对, 都是描述一个 "任务". Callable 描述的是带有返回值的任务, Runnable 描述的是不带返回值的任务.Callable 通常需要搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为 Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定. FutureTask 就可以负责这个等待结果出来的工作.

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable 版本

public class Text {
 
    static class Result{
        public int sum = 0;
        public Object locker = new Object();
    }
 
    public static void main(String[] args) throws InterruptedException {
        Result result = new Result();
 
        Thread t = new Thread(){
            @Override
            public void run() {
                int sum = 0;
                for (int i = 0; i <=10000; i++){
                    sum += i;
                }
                result.sum = sum;
 
                synchronized (result.locker){
                    result.locker.notify();
                }
            }
        };
        t.start();
        synchronized (result.locker){
            while (result.sum == 0){
                result.locker.wait();
            }
        }
        System.out.println(result.sum);
    }
}

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 使用 Callable 版本

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class Text1 {
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <=1000; i++){
                    sum += i;
                }
                return sum;
            }
        };
        //由于Thread不能直接传一个callable实例，就需要一个辅助类来包装
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
        //尝试在主线程获取结果
        //如果FutureTask中的结果还没生成。此时就会阻塞等待
        //一直等到最终的线程把这个结果算出来，get返回
        Integer result = futureTask.get();
        System.out.println(result);
    }
}

Atas ialah kandungan terperinci Prinsip dan senario penggunaan Disegerakkan dalam Java dan analisis penggunaan dan perbezaan antara muka Boleh Panggil. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!