并发型模型

有哪些并发型模型

• 生产者-消费者模式

• 管道-过滤器模式

• 观察者模式

• 读写锁模式

• 信号量模式

• 顺序执行模式

• 线程池模式

• 委托模式

• 并行迭代模式

• 并行算法模式

生产者-消费者模式

以下是一个简单的Java代码实现生产者-消费者模式：

import java.util.LinkedList;
import java.util.Queue;
public class ProducerConsumer {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        int maxSize = 10;
        Thread producer = new Producer(queue, maxSize);
        Thread consumer = new Consumer(queue, maxSize);
        producer.start();
        consumer.start();
    }
}
class Producer extends Thread {
    private Queue<Integer> queue;
    private int maxSize;
    public Producer(Queue<Integer> queue, int maxSize) {
        this.queue = queue;
        this.maxSize = maxSize;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.size() == maxSize) {
                    try {
                        System.out.println("Queue is full, waiting for consumer");
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int number = (int) (Math.random() * 100);
                System.out.println("Producing number: " + number);
                queue.add(number);
                queue.notifyAll();
            }
        }
    }
}
class Consumer extends Thread {
    private Queue<Integer> queue;
    private int maxSize;
    public Consumer(Queue<Integer> queue, int maxSize) {
        this.queue = queue;
        this.maxSize = maxSize;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    try {
                        System.out.println("Queue is empty, waiting for producer");
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int number = queue.remove();
                System.out.println("Consuming number: " + number);
                queue.notifyAll();
            }
        }
    }
}

说明：

• 在这个例子中，Producer和Consumer都是继承了Thread类的子类。Producer和Consumer都有一个Queue和maxSize参数。Producer和Consumer都在无限循环中运行，当队列满时，Producer会等待，当队列为空时，Consumer会等待。当Producer生产一个数并将其添加到队列中时，它会通知所有等待的线程，包括Consumer。当Consumer从队列中删除一个数时，它也会通知所有等待的线程，包括Producer。这样就可以保证Producer和Consumer之间的同步。

管道-过滤器模式

import java.util.ArrayList;
import java.util.List;
public class PipeFilter {
    public static void main(String[] args) {
        List<String> inputs = new ArrayList<>();
        inputs.add("1");
        inputs.add("2");
        inputs.add("3");
        inputs.add("4");
        inputs.add("5");
        inputs.add("6");
        inputs.add("7");
        inputs.add("8");
        inputs.add("9");
        inputs.add("10");
        Filter<String, Integer> filter1 = new Filter<String, Integer>() {
            @Override
            public Integer process(String input) {
                return Integer.parseInt(input) * 2;
            }
        };
        Filter<Integer, String> filter2 = new Filter<Integer, String>() {
            @Override
            public String process(Integer input) {
                return input.toString();
            }
        };
        Pipe<String, Integer> pipe1 = new Pipe<>(inputs, filter1);
        Pipe<Integer, String> pipe2 = new Pipe<>(pipe1.getResults(), filter2);
        for (String input : inputs) {
            System.out.println(pipe2.process(input));
        }
    }
}
interface Filter<I, O> {
    O process(I input);
}
class Pipe<I, O> {
    private List<O> results = new ArrayList<>();
    public Pipe(List<I> inputs, Filter<I, O> filter) {
        for (I input : inputs) {
            results.add(filter.process(input));
        }
    }
    public List<O> getResults() {
        return results;
    }
    public O process(I input) {
        return null; // not implemented
    }
}

说明：

• 在这个例子中，我们定义了一个Filter接口，它有一个process方法，将一个输入转换为一个输出。然后我们定义了一个Pipe类，它有一个List作为输入和一个Filter。Pipe的构造函数遍历所有输入，使用Filter将它们转化为输出，并将结果保存在一个List中。我们还定义了一个process方法，该方法接受一个输入并返回一个输出，但是在这个例子中没有实现。最后，我们创建了两个Pipe实例，其中第一个使用Filter将字符串转换为整数，第二个使用Filter将整数转换为字符串。我们将输入传递给第一个Pipe，然后将结果传递给第二个Pipe，最终输出结果。

观察者模式

读写锁模式

信号量模式

顺序执行模式

线程池模式

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("Task " + i);
            executorService.execute(worker);
        }
        executorService.shutdown();
        while (!executorService.isTerminated()) {
        }
        System.out.println("Finished all tasks");
    }
}
class WorkerThread implements Runnable {
    private String task;
    public WorkerThread(String task) {
        this.task = task;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " " + task + " is being processed");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " " + task + " has been processed");
    }
}

说明：

• 在这个例子中，我们使用了Java内置的Executors类来创建一个具有5个线程的固定大小的线程池。然后我们创建了10个任务，并将每个任务提交给线程池。每个任务都是一个WorkerThread实例，它实现了Runnable接口。WorkerThread的run方法打印了正在处理的任务名称，并休眠1秒钟来模拟任务处理。然后它再次打印任务名称，表示任务已经完成处理。最后，我们关闭线程池并等待所有任务完成，然后打印“Finished all tasks”表示所有任务都已经完成。

委托模式

并行迭代模式

并行算法模式