Introduction to Java Basics to Practical Applications: Detailed Practical Explanation of Concurrent Programming

Java concurrent programming practical detailed explanation of concurrent programming: multi-threaded parallel data processing technology to improve application performance. Java concurrency mechanism: Thread: a lightweight execution unit that can execute tasks in parallel. Lock: Synchronize shared resource access to avoid simultaneous operations. Atomic operations: uninterruptible, either all succeed or all fail. Concurrent Collection: Thread-safe collection class that allows multi-threaded operations. Practical case: Multi-threaded crawling of web pages uses ExecutorService and CompletionService to manage threads and collect results to improve crawling efficiency.

Detailed practical explanation of Java concurrent programming

Introduction

Concurrent programming is multi-threading Technology that processes data in parallel can significantly improve application performance. In Java, there are multiple concurrency mechanisms, including threads, locks, atomic operations, and concurrent collections.

Threads

Threads are lightweight execution units that can execute tasks in parallel. To create a thread, you can use the Thread class or implement the Runnable interface.

// 使用 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);

Lock

Lock is used to synchronize access to shared resources and prevent multiple threads from operating the same data at the same time. Commonly used locks in Java are the synchronized keyword and the ReentrantLock class.

Atomic operation

Atomic operation is an uninterruptible operation, either all executions succeed or all fail. Java provides atomic classes such as AtomicInteger to encapsulate basic type operations to ensure thread safety.

Concurrent Collections

Concurrent collections are thread-safe collection classes that allow multiple threads to access and modify data simultaneously without explicit synchronization. Commonly used concurrent collections include ConcurrentHashMap and CopyOnWriteArrayList.

Practical case: Multi-threaded crawling of web pages

The following is a practical case of using multi-threading to crawl web pages:

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;
    }
}

In this case , multiple threads crawl web pages in parallel, improving crawling efficiency. CompletionService is used to collect and manage the results returned by threads, avoiding the complexity of multi-thread management.

The above is the detailed content of Introduction to Java Basics to Practical Applications: Detailed Practical Explanation of Concurrent Programming. For more information, please follow other related articles on the PHP Chinese website!