Kunci untuk menguasai pengaturcaraan berbilang benang Java: belajar mencipta empat kumpulan benang

Pengaturcaraan berbilang benang Java ialah kemahiran penting dalam pembangunan perisian moden, yang boleh meningkatkan prestasi serentak dan kelajuan tindak balas sistem. Dalam pembangunan sebenar, kita selalunya perlu mengurus dan mengawal sebilangan besar utas. Sebagai alat pengaturcaraan serentak yang penting, kumpulan benang boleh membantu kami mengurus benang dengan cekap dan meningkatkan penggunaan sumber.

Artikel ini akan memperkenalkan empat kaedah penciptaan kumpulan benang yang biasa digunakan dalam Java dan menyediakan contoh kod khusus untuk membantu pembaca menguasai penggunaan kumpulan benang dengan cepat.

1. FixedThreadPool (kumpulan benang saiz tetap)

FixedThreadPool ialah kumpulan benang dengan bilangan utas teras yang tetap, bilangan utas maksimum tanpa had dan masa melahu benang tidak sah. Apabila menyerahkan tugasan, jika terdapat benang terbiar dalam kumpulan benang, ia akan dilaksanakan serta-merta; jika tiada benang terbiar, tugasan akan memasuki baris gilir menyekat dan menunggu. Kumpulan benang bersaiz tetap sesuai untuk melaksanakan tugasan nombor tetap jangka panjang.

Berikut ialah kod contoh untuk membuat kumpulan benang menggunakan FixedThreadPool:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

2 (kumpulan benang cache)

CachedThreadPool ialah nombor utas teras 0, bilangan maksimum benang 0. masa melahu benang ialah 60 saat Kumpulan benang. Apabila menyerahkan tugasan, jika terdapat benang terbiar dalam kumpulan benang, ia akan dilaksanakan serta-merta; jika tiada benang terbiar, utas baharu akan dibuat. Apabila benang melahu selama lebih daripada 60 saat, ia ditamatkan dan dialih keluar daripada kumpulan benang. Kumpulan benang cache sesuai untuk melaksanakan sejumlah besar tugas jangka pendek dan boleh mencipta dan memusnahkan benang secara dinamik mengikut permintaan.

Berikut ialah contoh kod untuk menggunakan CachedThreadPool untuk mencipta kumpulan benang:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

3 ScheduledThreadPool (kumpulan benang berjadual)

ScheduledThreadPool ialah kumpulan benang dengan bilangan teras maksimum yang tidak terhad. benang, digunakan untuk melaksanakan tugas pemasaan atau tugasan berulang. Kumpulan benang mengekalkan baris gilir kelewatan secara dalaman dan memproses tugasan dengan teratur mengikut masa kelewatan.

Berikut ialah kod contoh yang menggunakan ScheduledThreadPool untuk mencipta kumpulan benang dan melaksanakan tugasan berjadual:

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        
        executorService.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("Task 1 is running.");
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        executorService.scheduleWithFixedDelay(new Runnable() {
            public void run() {
                System.out.println("Task 2 is running.");
            }
        }, 0, 1, TimeUnit.SECONDS);
        
        executorService.shutdown();
    }
}

4 SingleThreadExecutor (kumpulan benang tunggal)

SingleThreadExecutor nombor maksimum bagi threadExecutor. daripada urutan 1, Kumpulan benang dengan masa melahu yang tidak sah. Semua tugasan dilaksanakan secara bersiri dalam urutan yang sama dalam urutan masuk dahulu, keluar dahulu. Kumpulan benang berbenang tunggal sesuai untuk senario yang diperlukan untuk memastikan bahawa tugasan dilaksanakan dalam susunan dan susunan tertentu.

Berikut ialah contoh kod untuk menggunakan SingleThreadExecutor untuk mencipta kumpulan benang:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is running.");
                }
            });
        }
        
        executorService.shutdown();
    }
}

Dengan menguasai kaedah penciptaan empat kumpulan benang di atas, kami boleh memilih kumpulan benang yang sesuai mengikut senario yang berbeza, dengan itu meningkatkan prestasi konkurensi dan kelajuan tindak balas daripada program tersebut. Dalam pembangunan sebenar, kita juga perlu memberi perhatian kepada isu keselamatan benang dan tetapan parameter kolam benang yang munasabah untuk memberikan permainan penuh kepada kelebihan kumpulan benang.

Kami berharap contoh kod dan penjelasan yang diberikan dalam artikel ini dapat membantu pembaca dengan cepat menguasai kemahiran menggunakan kumpulan benang dalam pengaturcaraan berbilang benang Java, supaya mereka boleh menggunakan kumpulan benang dengan lebih cekap untuk meningkatkan prestasi program dalam pembangunan sebenar.

Atas ialah kandungan terperinci Kunci untuk menguasai pengaturcaraan berbilang benang Java: belajar mencipta empat kumpulan benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!