Java高并发之设计模式，设计思想(1)

该方式既解决了同步问题, 也解决了写法繁琐问题. 推荐使用改写法.

缺点在于无法响应事件来重新初始化INSTANCE.

饿汉式

public class Singleton1 {

private Singleton1() {}

private static final Singleton1 single = new Singleton1();

public static Singleton1 getInstance() {

return single;

}

}

缺点在于对象在一开始就直接初始化了.

Future模式

该模式的核心思想是异步调用. 有点类似于异步的ajax请求.

当调用某个方法时, 可能该方法耗时较久, 而在主函数中也不急于立刻获取结果.

因此可以让调用者立刻返回一个凭证, 该方法放到另外线程执行,后续主函数拿凭证再去获取方法的执行结果即可, 其结构图如下

jdk中内置了Future模式的支持, 其接口如下:

通过FutureTask实现

注意其中两个耗时操作.

• 如果doOtherThing耗时2s, 则整个函数耗时2s左右.

• 如果doOtherThing耗时0.2s, 则整个函数耗时取决于RealData.costTime, 即1s左右结束.

public class FutureDemo1 {

public static void main(String[] args) throws InterruptedException, ExecutionException {

FutureTask future = new FutureTask(new Callable() {

@Override

public String call() throws Exception {

return new RealData().costTime();

}

});

ExecutorService service = Executors.newCachedThreadPool();

service.submit(future);

System.out.println(“RealData方法调用完毕”);

// 模拟主函数中其他耗时操作

doOtherThing();

// 获取RealData方法的结果

System.out.println(future.get());

}

private static void doOtherThing() throws InterruptedException {

Thread.sleep(2000L);

}

}

class RealData {

public String costTime() {

try {

// 模拟RealData耗时操作

Thread.sleep(1000L);

return “result”;

} catch (InterruptedException e) {

e.printStackTrace();

}

return “exception”;

}

}

通过Future实现

与上述FutureTask不同的是, RealData需要实现Callable接口.

public class FutureDemo2 {

public static void main(String[] args) throws InterruptedException, ExecutionException {

ExecutorService service = Executors.newCachedThreadPool();

Future future = service.submit(new RealData2());

System.out.println(“RealData2方法调用完毕”);

// 模拟主函数中其他耗时操作

doOtherThing();

// 获取RealData2方法的结果

System.out.println(future.get());

}

private static void doOtherThing() throws InterruptedException {

Thread.sleep(2000L);

}

}

class RealData2 implements Callable{

public String costTime() {

try {

// 模拟RealData耗时操作

Thread.sleep(1000L);

return “result”;

} catch (InterruptedException e) {

e.printStackTrace();

}

return “exception”;

}

@Override

public String call() throws Exception {

return costTime();

}

}

另外Future本身还提供了一些额外的简单控制功能, 其API如下

// 取消任务

boolean cancel(boolean mayInterruptIfRunning);

// 是否已经取消

boolean isCancelled();

// 是否已经完成

boolean isDone();

// 取得返回对象

V get() throws InterruptedException, ExecutionException;

// 取得返回对象, 并可以设置超时时间

V get(long timeout, TimeUnit unit)

throws InterruptedException, ExecutionException, TimeoutException;

生产消费者模式

生产者-消费者模式是一个经典的多线程设计模式. 它为多线程间的协作提供了良好的解决方案。

在生产者-消费者模式中，通常由两类线程，即若干个生产者线程和若干个消费者线程。

生产者线程负责提交用户请求，消费者线程则负责具体处理生产者提交的任务。

生产者和消费者之间则通过共享内存缓冲区进行通信, 其结构图如下

PCData为我们需要处理的元数据模型, 生产者构建PCData, 并放入缓冲队列.

消费者从缓冲队列中获取数据, 并执行计算.

生产者核心代码

while(isRunning) {

Thread.sleep(r.nextInt(SLEEP_TIME));

data = new PCData(count.incrementAndGet);

// 构造任务数据

System.out.println(data + " is put into queue");

if (!queue.offer(data, 2, TimeUnit.SECONDS)) {

// 将数据放入队列缓冲区中

System.out.println("faild to put data : " + data);

}

}

消费者核心代码

while (true) {

PCData data = queue.take();

// 提取任务

if (data != null) {

// 获取数据, 执行计算操作

int re = data.getData() * 10;

System.out.println("after cal, value is : " + re);

Thread.sleep(r.nextInt(SLEEP_TIME));

}

}

生产消费者模式可以有效对数据解耦, 优化系统结构.

降低生产者和消费者线程相互之间的依赖与性能要求.

一般使用BlockingQueue作为数据缓冲队列, 他是通过锁和阻塞来实现数据之间的同步,

如果对缓冲队列有性能要求, 则可以使用基于CAS无锁设计的ConcurrentLinkedQueue.

分而治之

严格来讲, 分而治之不算一种模式, 而是一种思想.

它可以将一个大任务拆解为若干个小任务并行执行, 提高系统吞吐量.

我们主要讲两个场景, Master-Worker模式, ForkJoin线程池.

Master-Worker模式

该模式核心思想是系统由两类进行协助工作: Master进程, Worker进程.

Master负责接收与分配任务, Worker负责处理任务. 当各个Worker处理完成后,

将结果返回给Master进行归纳与总结.

假设一个场景, 需要计算100个任务, 并对结果求和, Master持有10个子进程.

Master代码

public class MasterDemo {

// 盛装任务的集合

private ConcurrentLinkedQueue workQueue = new ConcurrentLinkedQueue();

// 所有worker

private HashMap<String, Thread> workers = new HashMap<>();

// 每一个worker并行执行任务的结果

private ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<>();

public MasterDemo(WorkerDemo worker, int workerCount) {

// 每个worker对象都需要持有queue的引用, 用于领任务与提交结果

worker.setResultMap(resultMap);

worker.setWorkQueue(workQueue);

for (int i = 0; i < workerCount; i++) {

workers.put("子节点: " + i, new Thread(worker));

}

}

// 提交任务

public void submit(TaskDemo task) {

workQueue.add(task);

}

// 启动所有的子任务

public void execute(){

for (Map.Entry<String, Thread> entry : workers.entrySet()) {

entry.getValue().start();

}

}

// 判断所有的任务是否执行结束

public boolean isComplete() {

for (Map.Entry<String, Thread> entry : workers.entrySet()) {

if (entry.getValue().getState() != Thread.State.TERMINATED) {

return false;

}

}

return true;

}

// 获取最终汇总的结果

public int getResult() {

int result = 0;

for (Map.Entry<String, Object> entry : resultMap.entrySet()) {

result += Integer.parseInt(entry.getValue().toString());

}

return result;

}

}

Worker代码

public class WorkerDemo implements Runnable{

private ConcurrentLinkedQueue workQueue;

private ConcurrentHashMap<String, Object> resultMap;

@Override

public void run() {

while (true) {

TaskDemo input = this.workQueue.poll();

// 所有任务已经执行完毕

if (input == null) {

break;

}

// 模拟对task进行处理, 返回结果

int result = input.getPrice();

this.resultMap.put(input.getId() + “”, result);

System.out.println("任务执行完毕, 当前线程: " + Thread.currentThread().getName());

}

}

public ConcurrentLinkedQueue getWorkQueue() {

return workQueue;

}

public void setWorkQueue(ConcurrentLinkedQueue workQueue) {

this.workQueue = workQueue;

}

public ConcurrentHashMap<String, Object> getResultMap() {

return resultMap;

}

public void setResultMap(ConcurrentHashMap<String, Object> resultMap) {

this.resultMap = resultMap;

}

}

public class TaskDemo {

private int id;

private String name;

private int price;

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getPrice() {

return price;

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
blic int getPrice() {

return price;

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-ALqz102A-1715821578570)]

[外链图片转存中…(img-oRLwtQsi-1715821578571)]

[外链图片转存中…(img-3vQFtqlM-1715821578571)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！