Java多線程系列之JDK并發(fā)包舉例詳解

更新時間：2024年03月06日 11:05:01 作者：飛影鎧甲

Java并發(fā)包提供了許多用于多線程編程的類和接口,這篇文章主要給大家介紹了關(guān)于Java多線程系列之JDK并發(fā)包的相關(guān)資料,文中通過代碼介紹的非常詳細,需要的朋友可以參考下

前言

Java并發(fā)編程是Java開發(fā)中不可或缺的一部分，它允許開發(fā)者編寫能夠同時執(zhí)行多個任務的應用程序，提高了程序的執(zhí)行效率和響應速度。自從Java 5開始，java.util.concurrent包成為了并發(fā)編程的核心，引入了多種并發(fā)工具類，使得并發(fā)程序的編寫變得更加簡單和高效。本文將深入探討這個包中的各種并發(fā)工具及其用途。

Executor框架

Executor框架是java.util.concurrent包的基石，提供了管理線程池的機制，允許開發(fā)者分離任務的提交與任務的執(zhí)行過程。

Executor接口：定義了一個執(zhí)行提交任務的簡單接口，主要方法為execute(Runnable command)。
ExecutorService接口：是更完善的Executor，提供了生命周期管理的方法，比如shutdown()和submit()，后者可以提交Callable任務并返回Future。
ScheduledExecutorService接口：擴展了ExecutorService，支持定時及周期性任務執(zhí)行。
ThreadPoolExecutor和ScheduledThreadPoolExecutor類：這兩個類是上述接口的具體實現(xiàn)，提供了靈活的線程池管理策略。

示例

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

public class ExecutorExample {
    public static void main(String[] args) {
        // 創(chuàng)建一個固定大小的線程池
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交任務給線程池執(zhí)行
        executor.submit(() -> {
            System.out.println("Task 1 executed by " + Thread.currentThread().getName());
        });

        executor.submit(() -> {
            System.out.println("Task 2 executed by " + Thread.currentThread().getName());
        });

        // 關(guān)閉線程池
        executor.shutdown();
    }
}

同步器

java.util.concurrent包提供了多種同步器，幫助開發(fā)者控制并發(fā)訪問和修改共享資源。

Semaphore（信號量）：用于控制同時訪問某個特定資源的操作數(shù)量，通過協(xié)調(diào)各個線程以保證合理的使用公共資源。
CountDownLatch：允許一個或多個線程等待其他線程完成操作。
CyclicBarrier：允許一組線程相互等待，直到所有線程都到達某個公共屏障點。
Phaser：提供了更靈活的回合制同步，是CyclicBarrier的通用版本，支持動態(tài)地增減參與者。
Exchanger：允許兩個線程在匯合點交換數(shù)據(jù)，用于線程間的數(shù)據(jù)交換。

示例（使用CountDownLatch）：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);

        new Thread(() -> {
            System.out.println("Task 1 started.");
            // 模擬任務執(zhí)行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Task 1 finished.");
            latch.countDown();
        }).start();

        new Thread(() -> {
            System.out.println("Task 2 started.");
            // 模擬任務執(zhí)行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Task 2 finished.");
            latch.countDown();
        }).start();

        // 等待兩個任務都執(zhí)行完畢
        latch.await();
        System.out.println("All tasks finished.");
    }
}

鎖

在java.util.concurrent.locks包中，提供了比synchronized關(guān)鍵字更高級的鎖機制。

Lock接口：比synchronized更靈活的鎖機制，允許嘗試非阻塞地獲取鎖、獲取可中斷鎖以及嘗試獲取鎖直到超時。
ReentrantLock：一個實現(xiàn)了Lock接口的可重入互斥鎖。
ReadWriteLock接口：讀寫鎖，允許多個線程同時讀共享資源，但只有一個線程可以寫。
ReentrantReadWriteLock：實現(xiàn)了ReadWriteLock，提供了讀寫分離的鎖管理機制。

示例（使用ReentrantLock ）：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();

    public void task() {
        lock.lock();
        try {
            System.out.println("Task executed by " + Thread.currentThread().getName());
            // 模擬任務執(zhí)行
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        Thread t1 = new Thread(example::task);
        Thread t2 = new Thread(example::task);
        t1.start();
        t2.start();
    }
}

并發(fā)集合

java.util.concurrent包提供了多種線程安全的集合類。

ConcurrentHashMap：一個高效的線程安全的HashMap實現(xiàn)。
CopyOnWriteArrayList和CopyOnWriteArraySet：寫時復制技術(shù)的應用，適合讀多寫少的并發(fā)場景。
BlockingQueue接口：支持兩個附加操作的Queue，即在隊列為空時獲取元素的線程會等待隊列變?yōu)榉强?，隊列滿時插入元素的線程會等待隊列可用。

示例（使用ConcurrentHashMap）：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
        map.put("key", "value");
        System.out.println(map.get("key"));
    }
}

原子變量

在java.util.concurrent.atomic包中，提供了一組原子類用于在單個變量上進行無鎖的線程安全操作。

AtomicInteger、AtomicLong、AtomicBoolean等：提供了基本類型的原子操作。
AtomicReference：提供了對象引用的原子操作。
AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray：提供了數(shù)組元素的原子操作。

示例（使用AtomicInteger）:

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        // 線程1增加計數(shù)器
        new Thread(() -> counter.incrementAndGet()).start();

        // 線程2增加計數(shù)器
        new Thread(() -> counter.incrementAndGet()).start();

        System.out.println("Counter: " + counter.get());
    }
}

CompletableFuture

CompletableFuture是在Java 8中引入的，提供了一個異步編程的框架。通過CompletableFuture，可以將回調(diào)式的編程風格與Future的優(yōu)勢結(jié)合起來，實現(xiàn)更加靈活的異步編程。

示例

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "Hello from CompletableFuture";
        });

        // 等待異步操作完成并獲取結(jié)果
        String result = future.get();
        System.out.println(result);
    }
}

總結(jié)

Java的并發(fā)包java.util.concurrent提供了一套強大的工具集，用于簡化多線程程序的開發(fā)。無論是執(zhí)行大量異步任務的線程池管理，還是精細的線程同步控制，或是高效的并發(fā)數(shù)據(jù)結(jié)構(gòu)，Java并發(fā)包都能提供相應的解決方案。通過合理利用這些工具，可以大幅提升Java應用程序的性能、可靠性和可維護性。了解并掌握這些并發(fā)工具，對于每一個Java開發(fā)者來說都是非常重要的。

到此這篇關(guān)于Java多線程系列之JDK并發(fā)包的文章就介紹到這了,更多相關(guān)Java多線程JDK并發(fā)包內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: