java 并发专题

最新推荐文章于 2022-10-30 18:49:03 发布

weixin_37946518

最新推荐文章于 2022-10-30 18:49:03 发布

阅读量141

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_37946518/article/details/100551514

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

大纲：

1.并发理论：并发编程要解决的三大问题；介绍可见性与有序性问题的根源重排序；学习Java内存模型（JMM），理解JMM如何解决这些问题以实现并发编程的。

https://mp.weixin.qq.com/s/rkl916p8RIErGn58DNcihw

https://mp.weixin.qq.com/s/i5Uty83gyjOJ2fVy0Jurkg

https://mp.weixin.qq.com/s/78eoufVBzsHX5b9cCHP69A

2.并发关键字：深入volatile、synchronized、final关键字的作用，都解决了什么问题，以及其实现原理。

3.并发基础：并发编程中用到的一些基本概念，如：死锁、饥饿与公平等；线程的创建、运行、调度。

4.CAS原子操作：并发编程的基础与核心CAS的实现原理，以及Java中的CAS原子操作。

5.Lock体系：JDK的Lock对于synchronized有哪些优势；Lock如何通过AQS与LockSupport工具实现的；Lock的使用。

6.并发工具：介绍java.util.concurrent包下提供的并发工具倒计时器CountDownLatch、循环栅栏CyclicBarrier、资源访问控制Semaphore、数据交换Exchanger的用法，并深入分析实现原理。

7.并发容器：介绍java.util.concurrent包下提供的并发容器ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentLinkedQueue、ThreadLocal、及阻塞队列的用法，并深入分析实现原理。

8.线程池（Executor体系）：介绍线程池ThreadPoolExecutor和ScheduledThreadPoolExecutor的用法，分析线程池执行流程和原理。

FutureTask的用法及解析

Future模式去除了主函数中的等待时间，并合得原来需要等待的时间段可以用于处理其它业务逻辑，从而充分利用计算机资源。

场景一：多任务计算

package com.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTest1 {

	public static void main(String[] args) {

		// 创建2个固定线程池（使用了预定义的配置）
		ExecutorService executor = Executors.newFixedThreadPool(2);

		try {

			FutureTask<Integer> future = new FutureTask<Integer>(new Task()) {
				// 异步任务执行完成，回调（可省略）
				@Override
				protected void done() {
					try {
						System.out.println("future.done():" + get());
					} catch (InterruptedException e) {
						e.printStackTrace();
					} catch (ExecutionException e) {
						e.printStackTrace();
					}
				}
			};

			executor.execute(future);

			Thread.sleep(1000);
			// 可以取消异步任务
			// future.cancel(true);

			// 阻塞，等待异步任务执行完毕-获取异步任务的返回值
			System.out.println("future.get():" + future.get());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		} finally {
			// 关闭线程 (这步一定要处理，不然线程一直增多)+
			if (executor != null && !executor.isShutdown()) {
				executor.shutdown();
			}
		}
	}

	// 异步任务
	static class Task implements Callable<Integer> {
		// 返回异步任务的执行结果
		@Override
		public Integer call() throws Exception {
			int i = 0;
			for (; i < 10; i++) {
				try {
					System.out.println(Thread.currentThread().getName() + "_" + i);
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			return i;
		}
	}

}

场景二：FutureTask在高并发环境下确保任务只执行一次

package com.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.FutureTask;

import com.mongodb.connection.Connection;

public class FutureTest2 {

	private ConcurrentHashMap<String, FutureTask<Connection>> connectionPool = new ConcurrentHashMap<String, FutureTask<Connection>>();

	public Connection getConnection(String key) throws Exception {
		FutureTask<Connection> connectionTask = connectionPool.get(key);
		if (connectionTask != null) {
			return connectionTask.get();
		} else {
			FutureTask<Connection> newTask = new FutureTask<Connection>(new Callable<Connection>() {
				@Override
				public Connection call() throws Exception {
					return createConnection();
				}
			});
			connectionTask = connectionPool.putIfAbsent(key, newTask);
			if (connectionTask == null) {
				connectionTask = newTask;
				connectionTask.run();
			}
			return connectionTask.get();
		}
	}

	// 创建Connection（根据业务需求，自定义Connection）
	private Connection createConnection() {
		System.out.println("createConnection");
		return null;
	}

	public static void main(String[] args) {
		FutureTest2 test2 = new FutureTest2();
		FutureTest2 test3 = new FutureTest2();
		try {
			test2.getConnection("aaa");
			test2.getConnection("aaa");
			test3.getConnection("aaa");
			test3.getConnection("aaa");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}