Cara menggunakan kumpulan benang untuk melaksanakan corak pengguna pengeluar dalam Java 7

Cara menggunakan thread pool untuk melaksanakan model pengeluar-pengguna dalam Java 7

Pengenalan: Thread pool ialah mekanisme pengurusan benang yang biasa digunakan di Java, yang boleh meningkatkan kebolehgunaan semula dan kecekapan benang. Dalam pengaturcaraan serentak, corak pengeluar-pengguna ialah corak reka bentuk biasa yang sesuai untuk kerjasama dan pertukaran data antara berbilang rangkaian. Artikel ini akan memperkenalkan cara menggunakan kumpulan benang untuk melaksanakan corak pengeluar-pengguna dalam Java 7 dan menyediakan contoh kod.

1. Apakah corak pengeluar-pengguna

Corak pengeluar-pengguna ialah corak reka bentuk serentak yang digunakan untuk menyelesaikan masalah pertukaran data antara pengeluar dan pengguna. Dalam corak pengeluar-pengguna, pengeluar bertanggungjawab untuk menjana data dan pengguna bertanggungjawab untuk memproses data. Untuk mencapai kerjasama dan pertukaran data antara benang, biasanya perlu menggunakan penimbal yang dikongsi. Pengeluar menyimpan data ke dalam penimbal, dan pengguna mengeluarkan data daripada penimbal untuk diproses.

2. Kelebihan menggunakan kumpulan benang untuk melaksanakan model pengeluar-pengguna

Secara tradisinya, kita boleh mencapai interaksi berbilang benang antara pengeluar dan pengguna dengan mencipta objek Benang. Walau bagaimanapun, kaedah ini mempunyai beberapa masalah dalam aplikasi praktikal. Pertama, apabila sejumlah besar pengeluar dan pengguna perlu diproses, penciptaan benang dan operasi pemusnahan akan menyebabkan overhed yang besar kepada prestasi sistem. Kedua, terdapat had tertentu pada bilangan utas yang dibuat terlalu banyak akan menyebabkan kehabisan sumber dan overhed penjadualan.

Menggunakan kumpulan benang untuk melaksanakan model pengeluar-pengguna boleh menggunakan sepenuhnya kebolehgunaan semula dan kecekapan benang. Kolam benang boleh pra-membuat bilangan benang tertentu apabila sistem dimulakan dan meletakkannya ke dalam kolam. Apabila tugasan baharu tiba, benang dalam kumpulan benang boleh digunakan semula secara langsung, mengurangkan overhed penciptaan dan pemusnahan benang. Pada masa yang sama, kumpulan benang boleh mengawal bilangan benang dan peruntukan sumber secara fleksibel, dengan itu meningkatkan kestabilan dan kecekapan sistem.

3. Contoh kod menggunakan kumpulan benang untuk melaksanakan corak pengeluar-pengguna

Di bawah kami menggunakan contoh mudah untuk menunjukkan cara menggunakan kumpulan benang untuk melaksanakan corak pengeluar-pengguna.

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

public class ProducerConsumerExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Buffer buffer = new Buffer();

        // 生产者线程
        Runnable producer = new Producer(buffer);
        executorService.submit(producer);

        // 消费者线程
        Runnable consumer = new Consumer(buffer);
        executorService.submit(consumer);

        executorService.shutdown();
    }
}

class Buffer {
    private int value;
    private boolean occupied = false;

    public synchronized void produce(int value) {
        while (occupied) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        this.value = value;
        occupied = true;
        notifyAll();
    }

    public synchronized int consume() {
        while (!occupied) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        occupied = false;
        notifyAll();
        return value;
    }
}

class Producer implements Runnable {
    private static final int MAX_VALUE = 10;
    private Buffer buffer;

    public Producer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < MAX_VALUE; i++) {
            buffer.produce(i);
            System.out.println("Producer produced: " + i);
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

class Consumer implements Runnable {
    private static final int MAX_VALUE = 10;
    private Buffer buffer;

    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < MAX_VALUE; i++) {
            int value = buffer.consume();
            System.out.println("Consumer consumed: " + value);
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

Dalam kod di atas, kami menggunakan kelas kumpulan benang ExecutorService dan Executors dalam Java 7 untuk mencipta kumpulan benang dan menggunakan kumpulan benang panjang tetap newFixedThreadPool untuk mengawal bilangan utas. Dalam kelas Penampan, kami menggunakan kata kunci yang disegerakkan untuk melaksanakan penyegerakan benang dan pengecualian bersama. Apabila terdapat data dalam penimbal, pengeluar perlu menunggu benang pengguna untuk menggunakan data; apabila tiada data dalam penimbal, pengguna perlu menunggu benang pengeluar menghasilkan data.

Melalui kod di atas, kita dapat melihat ciri tipikal model pengeluar-pengguna: utas pengeluar bertanggungjawab untuk menghasilkan data, utas pengguna bertanggungjawab untuk menggunakan data, dan pengeluar dan pengguna bertukar data melalui penimbal dikongsi. . Penggunaan kumpulan benang boleh mengurus kedua-dua benang ini dengan baik, meningkatkan prestasi dan kecekapan sistem.

Kesimpulan: Artikel ini memperkenalkan cara menggunakan kumpulan benang untuk melaksanakan corak pengeluar-pengguna dalam Java 7 dan menyediakan contoh kod yang berkaitan. Dengan menggunakan kumpulan benang, kami boleh menggunakan sepenuhnya kebolehgunaan semula dan kecekapan benang dan meningkatkan kestabilan dan prestasi sistem. Saya harap artikel ini berguna untuk anda mempelajari tentang pengaturcaraan serentak dan kumpulan benang.

Atas ialah kandungan terperinci Cara menggunakan kumpulan benang untuk melaksanakan corak pengguna pengeluar dalam Java 7. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!