java高并发解决方案_长文慎入-探索Java并发编程与高并发解决方案
所有示例代码,请见/下载于
1 基本概念
1.1 并发
同时拥有两个或者多个线程,如果程序在单核处理器上运行多个线程将交替地换入或者换出内存,这些线程是同时“存在"的,每个线程都处于执行过程中的某个状态,如果运行在多核处理器上,此时,程序中的每个线程都将分配到一个处理器核上,因此可以同时运行.
1.2 高并发( High Concurrency)
互联网分布式系统架构设计中必须考虑的因素之一,通常是指,通过设计保证系统能够同时并行处理很多请求.
1.3 区别与联系
并发: 多个线程操作相同的资源,保证线程安全,合理使用资源
高并发:服务能同时处理很多请求,提高程序性能
2 CPU
2.1 CPU 多级缓存
为什么需要CPU cache
CPU的频率太快了,快到主存跟不上
如此,在处理器时钟周期内,CPU常常需要等待主存,浪费资源。所以cache的出现,是为了缓解CPU和内存之间速度的不匹配问题(结构:cpu-> cache-> memory ).
CPU cache的意义
1) 时间局部性
如果某个数据被访问,那么在不久的将来它很可能被再次访问
2) 空间局部性
如果某个数据被访问,那么与它相邻的数据很快也可能被访问
2.2 缓存一致性(MESI)
用于保证多个 CPU cache 之间缓存共享数据的一致
M-modified被修改
该缓存行只被缓存在该 CPU 的缓存中,并且是被修改过的,与主存中数据是不一致的,需在未来某个时间点写回主存,该时间是允许在其他CPU 读取主存中相应的内存之前,当这里的值被写入主存之后,该缓存行状态变为 E
E-exclusive独享
缓存行只被缓存在该 CPU 的缓存中,未被修改过,与主存中数据一致
可在任何时刻当被其他 CPU读取该内存时变成 S 态,被修改时变为 M态
S-shared共享
该缓存行可被多个 CPU 缓存,与主存中数据一致
I-invalid无效
乱序执行优化
处理器为提高运算速度而做出违背代码原有顺序的优化
并发的优势与风险
3 项目准备
3.1 项目初始化
3.2 并发模拟-Jmeter压测
3.3 并发模拟-代码
CountDownLatch
Semaphore(信号量)
以上二者通常和线程池搭配
下面开始做并发模拟
package com.mmall.concurrency;
import com.mmall.concurrency.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* @author shishusheng
* @date 18/4/1
*/
@Slf4j
@NotThreadSafe
public class ConcurrencyTest {
/**
* 请求总数
*/
public static int clientTotal = 5000;
/**
* 同时并发执行的线程数
*/
public static int threadTotal = 200;
public static int count = 0;
public static void main(String[] args) throws Exception {
//定义线程池
ExecutorService executorService = Executors.newCachedThreadPool();
//定义信号量,给出允许并发的线程数目
final Semaphore semaphore = new Semaphore(threadTotal);
//统计计数结果
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
//将请求放入线程池
for (int i = 0; i < clientTotal ; i++) {
executorService.execute(() -> {
try {
//信号量的获取
semaphore.acquire();
add();
//释放
semaphore.release();
} catch (Exception e) {
log.error("exception", e);
}
countDownLatch.countDown();
});
}
countDownLatch.await();
//关闭线程池
executorService.shutdown();
log.info("count:{}", count);
}
/**
* 统计方法
*/
private static void add() {
count++;
}
}
运行发现结果随机,所以非线程安全
4线程安全性
4.1 线程安全性
当多个线程访问某个类时,不管运行时环境采用何种调度方式或者这些进程将如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类是线程安全的
4.2 原子性
4.2.1 Atomic 包
AtomicXXX:CAS,Unsafe.compareAndSwapInt
提供了互斥访问,同一时刻只能有一个线程来对它进行操作
package com.mmall.concurrency.example.atomic;
import com.mmall.concurrency.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicLong;
/**
* @author shishusheng
*/
@Slf4j
@ThreadSafe
public class AtomicExample2 {
/**
* 请求总数
*/
public static int clientTotal = 5000;
/**
* 同时并发执行的线程数
*/
public static int threadTotal = 200;
/**
* 工作内存
*/
public static AtomicLong count = new AtomicLong(0);
public static void main(String[] args) throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
final Semaphore semaphore = new Semaphore(threadTotal);
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
for (int i = 0; i < clientTotal ; i++) {
executorService.execute(() -> {
try {
System.out.println();
semaphore.acquire();
add();
semaphore.release();
} catch (Exception e) {
log.error("exception", e);
}
countDownLatch.countDown();
});
}
countDownLatch.await();
executorService.shutdown();
//主内存
log.info("count:{}", count.get());
}
private static void add() {
count.incrementAndGet();
// count.getAndIncrement();
}
}
package com.mmall.concurrency.example.atomic;
import com.mmall.concurrency.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.atomic.AtomicReference;
/**
* @author shishusheng
* @date 18/4/3
*/
@Slf4j
@ThreadSafe
public class AtomicExample4 {
private static AtomicReference count = new AtomicReference<>(0);
public static void main(String[] args) {
// 2
count.compareAndSet(0, 2);
// no
count.compareAndSet(0, 1);
// no
count.compareAndSet(1, 3);
// 4
count.compareAndSet(2, 4);
// no
count.compareAndSet(3, 5);
log.info("count:{}", count.get());
}
}
AtomicReference,AtomicReferenceFieldUpdater
AtomicBoolean
AtomicStampReference : CAS的 ABA 问题
4.2.2 锁
synchronized:依赖 JVM
修饰代码块:大括号括起来的代码,作用于调用的对象
修饰方法: 整个方法,作用于调用的对象
修饰静态方法:整个静态方法,作用于所有对象
package com.mmall.concurrency.example.count;
import com.mmall.concurrency.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* @author shishusheng
*/
@Slf4j
@ThreadSafe
public class CountExample3 {
/**
* 请求总数
*/
public static int clientTotal = 5000;
/**
* 同时并发执行的线程数
*/
public static int threadTotal = 200;
public static int count = 0;
public static void main(String[] args) throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
final Semaphore semaphore = new Semaphore(threadTotal);
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
for (int i = 0; i < clientTotal ; i++) {
executorService.execute(() -> {
try {
semaphore.acquire();
add();
semaphore.release();
} catch (Exception e) {
log.error("exception", e);
}
countDownLatch.countDown();
});
}
countDownLatch.await();
executorService.shutdown();
log.info("count:{}", count);
}
private synchronized static void add() {
count++;
}
}
synchronized 修正计数类方法
修饰类:括号括起来的部分,作用于所有对象
子类继承父类的被 synchronized 修饰方法时,是没有 synchronized 修饰的!!!
Lock: 依赖特殊的 CPU 指令,代码实现
4.2.3 对比
synchronized: 不可中断锁,适合竞争不激烈,可读性好
Lock: 可中断锁,多样化同步,竞争激烈时能维持常态
Atomic: 竞争激烈时能维持常态,比Lock性能好; 只能同步一
个值
4.3 可见性
一个线程对主内存的修改可以及时的被其他线程观察到
4.3.1 导致共享变量在线程间不可见的原因
线程交叉执行
重排序结合线程交叉执行
共享变量更新后的值没有在工作内存与主存间及时更新
4.3.2 可见性之synchronized
JMM关于synchronized的规定
线程解锁前,必须把共享变量的最新值刷新到主内存
线程加锁时,将清空工作内存中共享变量的值,从而使
用共享变量时需要从主内存中重新读取最新的值(加锁与解锁是同一把锁)
4.3.3 可见性之volatile
通过加入内存屏障和禁止重排序优化来实现
对volatile变量写操作时,会在写操作后加入一条store
屏障指令,将本地内存中的共享变量值刷新到主内存
对volatile变量读操作时,会在读操作前加入一条load
屏障指令,从主内存中读取共享变量
volatile使用
volatile boolean inited = false;
//线程1:
context = loadContext();
inited= true;
// 线程2:
while( !inited ){
sleep();
}
doSomethingWithConfig(context)
4.4 有序性
一个线程观察其他线程中的指令执行顺序,由于指令重排序的存在,该观察结果一般杂乱无序
JMM允许编译器和处理器对指令进行重排序,但是重排序过程不会影响到单线程程序的执行,却会影响到多线程并发执行的正确性
4.4.1 happens-before 规则
5发布对象
5.1 安全发布对象
package com.mmall.concurrency.example.singleton;
import com.mmall.concurrency.annoations.NotThreadSafe;
/**
* 懒汉模式 -》 双重同步锁单例模式
* 单例实例在第一次使用时进行创建
* @author shishusheng
*/
@NotThreadSafe
public class SingletonExample4 {
/**
* 私有构造函数
*/
private SingletonExample4() {
}
// 1、memory = allocate() 分配对象的内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
// JVM和cpu优化,发生了指令重排
// 1、memory = allocate() 分配对象的内存空间
// 3、instance = memory 设置instance指向刚分配的内存
// 2、ctorInstance() 初始化对象
/**
* 单例对象
*/
private static SingletonExample4 instance = null;
/**
* 静态的工厂方法
*
* @return
*/
public static SingletonExample4 getInstance() {
// 双重检测机制 // B
if (instance == null) {
// 同步锁
synchronized (SingletonExample4.class) {
if (instance == null) {
// A - 3
instance = new SingletonExample4();
}
}
}
return instance;
}
}
7 AQS
7.1 介绍
使用Node实现FIFO队列,可以用于构建锁或者其他同步装置的基础框架
利用了一个int类型表示状态
使用方法是继承
子类通过继承并通过实现它的方法管理其状态{acquire 和release} 的方法操纵状态
可以同时实现排它锁和共享锁模式(独占、共享)
同步组件
CountDownLatch
package com.mmall.concurrency.example.aqs;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author shishusheng
*/
@Slf4j
public class CountDownLatchExample1 {
private final static int threadCount = 200;
public static void main(String[] args) throws Exception {
ExecutorService exec = Executors.newCachedThreadPool();
final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
final int threadNum = i;
exec.execute(() -> {
try {
test(threadNum);
} catch (Exception e) {
log.error("exception", e);
} finally {
countDownLatch.countDown();
}
});
}
countDownLatch.await();
log.info("finish");
exec.shutdown();
}
private static void test(int threadNum) throws Exception {
Thread.sleep(100);
log.info("{}", threadNum);
Thread.sleep(100);
}
}
package com.mmall.concurrency.example.aqs;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 指定时间内处理任务
*
* @author shishusheng
*
*/
@Slf4j
public class CountDownLatchExample2 {
private final static int threadCount = 200;
public static void main(String[] args) throws Exception {
ExecutorService exec = Executors.newCachedThreadPool();
final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
final int threadNum = i;
exec.execute(() -> {
try {
test(threadNum);
} catch (Exception e) {
log.error("exception", e);
} finally {
countDownLatch.countDown();
}
});
}
countDownLatch.await(10, TimeUnit.MILLISECONDS);
log.info("finish");
exec.shutdown();
}
private static void test(int threadNum) throws Exception {
Thread.sleep(100);
log.info("{}", threadNum);
}
}
Semaphore用法
CycliBarrier
package com.mmall.concurrency.example.aqs;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author shishusheng
*/
@Slf4j
public class CyclicBarrierExample1 {
private static CyclicBarrier barrier = new CyclicBarrier(5);
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int threadNum = i;
Thread.sleep(1000);
executor.execute(() -> {
try {
race(threadNum);
} catch (Exception e) {
log.error("exception", e);
}
});
}
executor.shutdown();
}
private static void race(int threadNum) throws Exception {
Thread.sleep(1000);
log.info("{} is ready", threadNum);
barrier.await();
log.info("{} continue", threadNum);
}
}
package com.mmall.concurrency.example.aqs;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* @author shishusheng
*/
@Slf4j
public class CyclicBarrierExample2 {
private static CyclicBarrier barrier = new CyclicBarrier(5);
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int threadNum = i;
Thread.sleep(1000);
executor.execute(() -> {
try {
race(threadNum);
} catch (Exception e) {
log.error("exception", e);
}
});
}
executor.shutdown();
}
private static void race(int threadNum) throws Exception {
Thread.sleep(1000);
log.info("{} is ready", threadNum);
try {
barrier.await(2000, TimeUnit.MILLISECONDS);
} catch (Exception e) {
log.warn("BarrierException", e);
}
log.info("{} continue", threadNum);
}
}
package com.mmall.concurrency.example.aqs;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* @author shishusheng
*/
@Slf4j
public class SemaphoreExample3 {
private final static int threadCount = 20;
public static void main(String[] args) throws Exception {
ExecutorService exec = Executors.newCachedThreadPool();
final Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < threadCount; i++) {
final int threadNum = i;
exec.execute(() -> {
try {
// 尝试获取一个许可
if (semaphore.tryAcquire()) {
test(threadNum);
// 释放一个许可
semaphore.release();
}
} catch (Exception e) {
log.error("exception", e);
}
});
}
exec.shutdown();
}
private static void test(int threadNum) throws Exception {
log.info("{}", threadNum);
Thread.sleep(1000);
}
}
9 线程池
9.1 newCachedThreadPool
9.2 newFixedThreadPool
9.3 newSingleThreadExecutor
看出是顺序执行的
9.4 newScheduledThreadPool
10 死锁
java高并发解决方案_长文慎入-探索Java并发编程与高并发解决方案相关推荐
- 深度学习的几何观点:1流形分布定律、2学习能力的上限。附顾险峰教授简历(长文慎入,公号回复“深度学习流形分布”可下载PDF资料)
深度学习的几何观点:1流形分布定律.2学习能力的上限.附顾险峰教授简历(长文慎入,公号回复"深度学习流形分布"可下载PDF资料) 原创: 顾险峰 数据简化DataSimp 今天 数 ...
- 长文慎入,如何快速开发区块链游戏
长文慎入,如何快速开发区块链游戏 译者注: 原文: 初始发行 Enjin整合 初始整合 客户端SDK GUI 客户端SDK API Enjin的API是GraphQL Enjin推荐 使用服务器 排列 ...
- java开发高端说法_扣丁学堂教你如何成为JavaEE高端开发人才
俗话说干一行爱一行,行行出状元.这句话在如今飞速发展的互联网时代依然实用,如今不少参加学习技术的小伙伴都希望自己可以成为专业的高端开发人才,本篇文章扣丁学堂教你如何成为高端开发人才. 互联网时代,对人 ...
- java 优秀源码_想要快速进阶Java架构师?这份超强(长)学习计划单 请签收!...
优秀工程师的成长之路就是一条不断打怪升级之路的"修仙之路"! 而Java程序员一向比别人更难,如果说大家都在修仙的话,java程序员简直神似"剑修",入行枯燥精 ...
- java护照号码校验_学无止境之小白学java……第001天
学习主题:预科阶段 对应视频: http://www.itbaizhan.cn/course/id/18.html 对应作业: 1. 为什么需要学编程,什么样的人可以做程序员? 编程是现实逻辑的表达, ...
- java青蛙过河打字_趣味算法——青蛙过河(JAVA)
青蛙过河是一个非常有趣的智力游戏,其大意如下: 一条河之间有若干个石块间隔,有两队青蛙在过河,每队有3只青蛙,这些青蛙只能向前移动,不能向后移动,且一次只能有一只青蛙向前移动.在移动过程中,青蛙可以向 ...
- java面试题成都_成都汇智动力-java面试——多线程面试题
原标题:成都汇智动力-java面试--多线程面试题 1.多线程有什么用?发挥多核CPU的优势 防止阻塞 便于建模 2.创建线程的方式继承Thread类 实现Runnable接口 至于哪个好,不用说肯定 ...
- java 判断是否夏令时_确定指定日期的Java夏令时(DST)是否处于活动状态
我有一个Java类,它占用一个位置的纬度/经度,并在夏时制开启和关闭时返回GMT偏移量.我正在寻找一个简单的方法来确定Java如果当前日期是在夏令时间,所以我可以应用正确的偏移量.目前,我只对美国时区 ...
- window服务器cpu过高的排查_线上服务器发生CPU占用率过高应该如何排查并定位问题?...
国外开发者平台 HankerRank 发布的 2018 年开发者技能调查报告中有一项关于"雇主最看重哪些核心能力"的调查,结果显示如下: 排名前几的比较受重视的能力分别为:解决问题 ...
最新文章
- 手机 x PC 交叉感染?360 安全研究员演示“混血攻击”
- 002_Java日志
- 2021热度不减的在线教育,正在努力成为线下教育的有益补充
- 深度学习框架TensorFlow(3.变量)
- C++如何调用父类的方法?
- Linux 中文无法显示或显示方块
- 【暖*墟】#洛谷网课1.30# 树上问题
- 7.企业安全建设入门(基于开源软件打造企业网络安全) --- 蜜罐与攻击欺骗
- spring boot默认扫描的路径
- 微信开发者工具使用bug
- c语言单片机编程 实例教程,51单片机的C语言编程基础及实例教程
- Python数据可视化的例子——折线图(line)
- 调用百度API(七)——获取百度API token 通用代码
- android 指南针 原理,手机指南针原理是什么?安卓/苹果手机指南针app工作原理介绍...
- java如何进行word文档的合并
- 【C++札记】类的分离式写法
- 2016年全国高中数学联赛加试T3解答
- 安卓开发之 在应用中使用数据库
- openwrt拨号上网设置
- 计算机网络安全的脆弱性,网络安全及网络安全评估的脆弱性分析