快捷導(dǎo)航

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

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

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

前言

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

Executor框架

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

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

示例

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

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

        // 提交任務(wù)給線程池執(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ā)訪問(wèn)和修改共享資源。

Semaphore（信號(hào)量）：用于控制同時(shí)訪問(wèn)某個(gè)特定資源的操作數(shù)量，通過(guò)協(xié)調(diào)各個(gè)線程以保證合理的使用公共資源。
CountDownLatch：允許一個(gè)或多個(gè)線程等待其他線程完成操作。
CyclicBarrier：允許一組線程相互等待，直到所有線程都到達(dá)某個(gè)公共屏障點(diǎn)。
Phaser：提供了更靈活的回合制同步，是CyclicBarrier的通用版本，支持動(dòng)態(tài)地增減參與者。
Exchanger：允許兩個(gè)線程在匯合點(diǎn)交換數(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.");
            // 模擬任務(wù)執(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.");
            // 模擬任務(wù)執(zhí)行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Task 2 finished.");
            latch.countDown();
        }).start();

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

鎖

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

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

示例（使用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());
            // 模擬任務(wù)執(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：一個(gè)高效的線程安全的HashMap實(shí)現(xiàn)。
CopyOnWriteArrayList和CopyOnWriteArraySet：寫時(shí)復(fù)制技術(shù)的應(yīng)用，適合讀多寫少的并發(fā)場(chǎng)景。
BlockingQueue接口：支持兩個(gè)附加操作的Queue，即在隊(duì)列為空時(shí)獲取元素的線程會(huì)等待隊(duì)列變?yōu)榉强?，?duì)列滿時(shí)插入元素的線程會(huì)等待隊(duì)列可用。

示例（使用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包中，提供了一組原子類用于在單個(gè)變量上進(jìn)行無(wú)鎖的線程安全操作。

AtomicInteger、AtomicLong、AtomicBoolean等：提供了基本類型的原子操作。
AtomicReference：提供了對(duì)象引用的原子操作。
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增加計(jì)數(shù)器
        new Thread(() -> counter.incrementAndGet()).start();

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

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

CompletableFuture

CompletableFuture是在Java 8中引入的，提供了一個(gè)異步編程的框架。通過(guò)CompletableFuture，可以將回調(diào)式的編程風(fēng)格與Future的優(yōu)勢(shì)結(jié)合起來(lái)，實(shí)現(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提供了一套強(qiáng)大的工具集，用于簡(jiǎn)化多線程程序的開發(fā)。無(wú)論是執(zhí)行大量異步任務(wù)的線程池管理，還是精細(xì)的線程同步控制，或是高效的并發(fā)數(shù)據(jù)結(jié)構(gòu)，Java并發(fā)包都能提供相應(yīng)的解決方案。通過(guò)合理利用這些工具，可以大幅提升Java應(yīng)用程序的性能、可靠性和可維護(hù)性。了解并掌握這些并發(fā)工具，對(duì)于每一個(gè)Java開發(fā)者來(lái)說(shuō)都是非常重要的。

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

您可能感興趣的文章: