Introduction aux bases de Java pour les applications pratiques : explication pratique détaillée de la programmation simultanée

Programmation simultanée Java Explication détaillée et pratique de la programmation simultanée : technologie de traitement de données parallèle multithread pour améliorer les performances des applications. Mécanisme de concurrence Java : Thread : une unité d'exécution légère qui peut exécuter des tâches en parallèle. Verrouillage : synchronisez l'accès aux ressources partagées pour éviter les opérations simultanées. Opérations atomiques : ininterrompues, soit toutes réussissent, soit toutes échouent. Concurrent Collection : classe de collection thread-safe qui permet des opérations multithread. Cas pratique : l'exploration multithread de pages Web utilise ExecutorService et CompletionService pour gérer les threads et collecter les résultats afin d'améliorer l'efficacité de l'exploration.

Explication pratique détaillée de la programmation simultanée Java

Introduction

La programmation simultanée est une technologie de traitement parallèle multithread des données, qui peut améliorer considérablement les performances des applications. En Java, il existe plusieurs mécanismes de concurrence, notamment les threads, les verrous, les opérations atomiques et les collections simultanées.

Threads

Les Threads sont des unités d'exécution légères qui peuvent exécuter des tâches en parallèle. Pour créer un thread, vous pouvez utiliser la classe Thread ou implémenter l'interface Runnable. Thread类或实现Runnable接口。

// 使用 Thread 类创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from thread!");
    }
});

// 使用 Runnable 创建线程
Runnable runnable = () -> System.out.println("Hello from runnable!");
Thread thread = new Thread(runnable);

锁

锁用于同步对共享资源的访问，防止多个线程同时操作同一数据。Java中常用的锁是synchronized关键字和ReentrantLock类。

原子操作

原子操作是一种不可中断的操作，要么全部执行成功，要么全部失败。Java中提供了AtomicInteger等原子类来封装基本类型操作，以确保线程安全。

并发集合

并发集合是线程安全的集合类，允许多个线程同时访问和修改数据，而无需显式同步。常用的并发集合包括ConcurrentHashMap和CopyOnWriteArrayList。

实战案例：多线程爬取网页

下面是一个使用多线程爬取网页的实战案例：

import java.util.concurrent.*;
import java.util.List;

public class WebCrawler {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        CompletionService<String> completionService = new ExecutorCompletionService<>(executor);

        List<String> urls = List.of("url1", "url2", "url3", ..., "urlN");

        for (String url : urls) {
            completionService.submit(() -> fetchPage(url));
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.DAYS);

        for (int i = 0; i < urls.size(); i++) {
            try {
                String page = completionService.take().get();
                System.out.println("Fetched page: " + page);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

    private static String fetchPage(String url) {
        // 模拟爬取网页操作
        return "Page content for " + url;
    }
}

在这个案例中，多个线程并行爬取网页，提高了爬取效率。CompletionServicerrreee

🎜Locks🎜🎜🎜Les verrous sont utilisés pour synchroniser l'accès aux ressources partagées et empêcher plusieurs threads d'exploiter les mêmes données en même temps. Les verrous couramment utilisés en Java sont le mot-clé synchronized et la classe ReentrantLock. 🎜🎜🎜Opérations atomiques🎜🎜🎜Les opérations atomiques sont des opérations ininterruptibles qui soit toutes s'exécutent avec succès, soit toutes échouent. Java fournit des classes atomiques telles que AtomicInteger pour encapsuler les opérations de type de base afin de garantir la sécurité des threads. 🎜🎜🎜Collections concurrentes🎜🎜🎜Les collections concurrentes sont des classes de collection thread-safe qui permettent à plusieurs threads d'accéder et de modifier les données simultanément sans synchronisation explicite. Les collections simultanées couramment utilisées incluent ConcurrentHashMap et CopyOnWriteArrayList. 🎜🎜🎜Cas pratique : Exploration multi-thread de pages Web🎜🎜🎜Ce qui suit est un cas pratique d'utilisation de multi-threads pour explorer des pages Web : 🎜rrreee🎜Dans ce cas, plusieurs threads explorent des pages Web en parallèle, ce qui améliore la efficacité d'exploration. CompletionService est utilisé pour collecter et gérer les résultats renvoyés par les threads, évitant ainsi la complexité de la gestion multi-thread. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!