正文

解锁Java并发核心：四大模型深度解析

/0 浏览量
0410

Java并发编程是Java语言的一个重要特性，它允许程序同时执行多个操作，从而提高程序的响应性和效率。Java并发编程的核心在于理解并发模型，以下是Java并发编程中的四大模型深度解析。

一、线程模型

1.1 线程与进程

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。每个线程都有自己独立的栈空间，但共享进程中的堆内存和其他资源。相较于进程，线程的创建和切换开销更小，因此在需要同时执行多个任务时，多线程成为了一种高效的选择。

1.2 Java中的线程实现

Java提供了两种创建线程的方式：继承Thread类和实现Runnable接口。继承Thread类的方式较为直观，但Java只支持单继承，因此在实际开发中，实现Runnable接口更为灵活。

// 实现Runnable接口的方式
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

二、并发模型

2.1 Master-Worker模型

Master-Worker常用的并行模式之一，核心思想是由两个进程协作工作，master负责接收和分配任务，worker负责处理任务，并把处理结果返回给Master进程，由Master进行汇总，返回给客户端。

下面利用Master-Worker模型实现一个计算1-100立方和的例子：

public class MasterWorkerExample {
    public static void main(String[] args) {
        Master master = new Master();
        master.submitTask(1, 100);
        master.shutdown();
    }
}

class Master {
    private final int totalTasks;
    private final List<Worker> workers;
    private final ConcurrentHashMap<Integer, Long> resultMap;

    public Master() {
        this.totalTasks = 100;
        this.workers = new ArrayList<>(Runtime.getRuntime().availableProcessors());
        this.resultMap = new ConcurrentHashMap<>();
    }

    public void submitTask(int start, int end) {
        for (int i = 0; i < totalTasks; i++) {
            int task = start + i;
            workers.get(i % workers.size()).submit(task);
        }
    }

    public void shutdown() {
        for (Worker worker : workers) {
            worker.shutdown();
        }
        long result = resultMap.values().stream().reduce(0L, Long::sum);
        System.out.println("Result: " + result);
    }
}

class Worker implements Runnable {
    private final int task;
    private final ConcurrentHashMap<Integer, Long> resultMap;

    public Worker(int task, ConcurrentHashMap<Integer, Long> resultMap) {
        this.task = task;
        this.resultMap = resultMap;
    }

    public void submit(int task) {
        Thread thread = new Thread(this);
        thread.start();
    }

    @Override
    public void run() {
        long result = calculateCube(task);
        resultMap.put(task, result);
    }

    private long calculateCube(int number) {
        return number * number * number;
    }

    public void shutdown() {
        Thread.currentThread().interrupt();
    }
}

2.2 生产者-消费者模型

生产者-消费者模型是一种经典的并发模型，它包含两个角色：生产者和消费者。生产者负责生产数据，消费者负责消费数据。生产者和消费者通过共享的数据结构进行交互。

class ProducerConsumerExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

class Producer implements Runnable {
    private final BlockingQueue<Integer> queue;

    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                queue.put(i);
                System.out.println("Produced: " + i);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

class Consumer implements Runnable {
    private final BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                Integer item = queue.take();
                System.out.println("Consumed: " + item);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

2.3 Future模式

Future模式是一种异步编程模式，它允许调用者异步执行一个操作，并获取操作的结果。Future接口提供了检查任务是否完成、获取结果、取消任务等方法。

class FutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return 42;
        });

        try {
            Integer result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

2.4 线程池模型

线程池是一种管理线程的机制，它允许程序在执行多个任务时复用线程，从而提高程序的并发性能。Java提供了ExecutorService接口和ThreadPoolExecutor类来实现线程池。

class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("Task " + Thread.currentThread().getName() + " is running.");
            });
        }

        executor.shutdown();
    }
}

三、总结

Java并发编程中的四大模型（线程模型、Master-Worker模型、生产者-消费者模型、Future模式、线程池模型）是理解并发编程的基础。通过掌握这些模型，可以更好地设计和实现高效的并发程序。

-- 展开阅读全文 --