Tag：高并发编程  JAVA

深入理解高并发编程
     写在前面
     关于作者
     源码分析篇
          程序员究竟要不要读源码
          线程与线程池
               线程与多线程
                    1 线程
                    2 多线程
               线程的实现方式
                    1 继承Thread类代码
                    2 实现Runnable接口的代码
                    3 实现Callable接口的代码
               线程的生命周期
                    1 生命周期
                    2 代码示例
          线程的执行顺序
               线程的执行顺序是不确定的
               如何确保线程的执行顺序
                    1 确保线程执行顺序的简单示例
                    2 join方法如何确保线程的执行顺序
          Java中的Callable和Future
               Callable接口
                    1 Callable接口介绍
                    2 实现Callable接口的重要类分析
               两种异步模型与深度解析Future接口
                    两种异步模型
                    深度解析Future接口
          SimpleDateFormat类的线程安全问题
               重现SimpleDateFormat类的线程安全问题
               SimpleDateFormat类为何不是线程安全的
               解决SimpleDateFormat类的线程安全问题
                    1 局部变量法
                    2 synchronized锁方式
                    3 Lock锁方式
                    4 ThreadLocal方式
                    5 DateTimeFormatter方式
                    6 joda-time方式
          深度解析ThreadPoolExecutor类源码
               抛砖引玉
               Thread直接创建线程的弊端
               线程池的好处
               线程池
                    1 线程池类结构关系
                    2 创建线程池常用的类Executors
                    3 线程池实例的几种状态
                    4 合理配置线程的一些建议
               线程池最核心的类之一ThreadPoolExecutor
                    1 构造方法
                    2 ThreadPoolExecutor提供的启动和停止任务的方法
                    3 ThreadPoolExecutor提供的适用于监控的方法
          深度解析线程池中重要的顶层接口和抽象类
               接口和抽象类总览
               Executor接口
               ExecutorService接口
               AbstractExecutorService抽象类
               ScheduledExecutorService接口
          从源码角度分析创建线程池究竟有哪些方式
               前言
               使用Executors工具类创建线程池
               使用ThreadPoolExecutor类创建线程池
               使用ForkJoinPool类创建线程池
               使用ScheduledThreadPoolExecutor类创建线程池
          通过源码深度解析ThreadPoolExecutor类是如何保证线程池正确运行的问题
               ThreadPoolExecutor类中的重要属性
                    ctl相关的属性
                    其他重要属性
               ThreadPoolExecutor类中的重要内部类
                    Worker内部类
                    拒绝策略内部类
          通过ThreadPoolExecutor类的源码深度解析线程池执行任务的核心流程
               核心逻辑概述
               execute[Runnable]方法
               addWorker[Runnable
               addWorkerFailed[Worker]方法
               拒绝策略
          通过源码深度分析线程池中Worker线程的执行流程
               Worker类分析
               runWorker[Worker]方法
               getTask()方法
               beforeExecute[Thread
               afterExecute[Runnable
               processWorkerExit[Worker
               tryTerminate()方法
               terminated()方法
          从源码角度深度解析线程池是如何实现优雅退出的
               shutdown()方法
               shutdownNow()方法
               awaitTermination[long
          深入理解ScheduledThreadPoolExecutor与Timer的区别和简单示例
               二者的区别
                    线程角度
                    系统时间敏感度
                    是否捕获异常
                    任务是否具备优先级
                    是否支持对任务排序
                    能否获取返回的结果
               二者简单的示例
                    Timer类简单示例
                    ScheduledThreadPoolExecutor类简单示例
          深度解析ScheduledThreadPoolExecutor类的源代码
               构造方法
               schedule方法
               decorateTask方法
               scheduleAtFixedRate方法
               scheduleWithFixedDelay方法
               triggerTime方法
               overflowFree方法
               delayedExecute方法
               reExecutePeriodic方法
               onShutdown方法
          深入理解Thread类源码
               前言
               Thread类的继承关系
               Thread类的源码剖析
                    Thread类定义
                    加载本地资源
                    Thread中的成员变量
                    线程的状态定义
                    Thread类的构造方法
                    init()方法
                    run()方法
                    start()方法
                    sleep()方法
                    join()方法
                    interrupt()方法
               总结
          AQS中的CountDownLatch、Semaphore与CyclicBarrier
               CountDownLatch
                    概述
                    使用场景
                    代码示例
               Semaphore
                    概述
                    使用场景
                    代码示例
               CyclicBarrier
                    概述
                    使用场景
                    CyclicBarrier与CountDownLatch的区别
                    代码示例
          AQS中的ReentrantLock、ReentrantReadWriteLock、StampedLock与Condition
          ReentrantLock
               概述
                    ReentrantLock[可重入锁]与synchronized区别
                    ReentrantLock独有的功能
                    synchronized的优势
                    ReentrantLock中的部分方法说明
                    代码示例
               ReentrantReadWriteLock
                    概述
                    代码示例
               StampedLock
                    概述
                    代码示例
               Condition
                    概述
                    代码示例
          ThreadLocal学会了这些，你也能和面试官扯皮了
               前言
               什么是ThreadLocal
               ThreadLocal使用示例
               ThreadLocal原理
                    set()方法
                    get()方法
                    remove()方法
               ThreadLocal变量不具有传递性
               InheritableThreadLocal使用示例
               InheritableThreadLocal原理
          又一个朋友面试栽在了Thread类的stop()方法和interrupt()方法上
               stop()方法
               interrupt()方法
                    通过异常接收通知
                    主动检测通知
     基础案例篇
          工作了3年的程序员小菜面试高并发岗位被吊打虐哭
               写在前面
               面试经过
               总结
          导致并发编程频繁出问题的幕后黑手
               写在前面
               并发编程的难点
               操作系统做出的努力
                    CPU增加了缓存
                    操作系统增加了进程和线程
                    优化CPU指令执行顺序
               揪出幕后黑手
               总结
                    [源头一]缓存导致的可见性问题
                    [源头二]线程切换带来的原子性问题
                    [源头三]编译优化带来的有序性问题
               总结
          解密诡异并发问题的第一个幕后黑手可见性问题
               写在前面
               可见性
               可见性问题
                    单核CPU不存在可见性问题
                    多核CPU存在可见性问题
                    Java中的可见性问题
               代码示例
               总结
               结尾
          解密导致并发问题的第二个幕后黑手原子性问题
               写在前面
               原子性
               线程切换
               原子性问题
               Java中的原子性问题
               总结
               写在最后
               文末福利
          解密导致并发问题的第三个幕后黑手有序性问题
               写在前面
               有序性
               指令重排序
               有序性问题
               总结
          如何解决可见性和有序性问题]这次彻底懂了
               写在前面
               问题排查
               什么是Java内存模型
               volatile为何能保证线程间可见
               Happens-Before原则
               [原则一]程序次序规则
               [原则二]volatile变量规则
               [原则三]传递规则
               [原则四]锁定规则
               [原则五]线程启动规则
               [原则六]线程终结规则
               [原则七]线程中断规则
               [原则八]对象终结原则
               再说final关键字
               Java内存模式的底层实现
          synchronized原理
               synchronized的基本使用
                    1 没有同步的情况
                    2 对普通方法同步
                    3 静态方法[类]同步
                    4 代码块同步
               synchronized 原理
               运行结果解释
               总结
          为何在32位多核CPU上执行long型变量的写操作会出现诡异的Bug问题
               写在前面
               诡异的问题
               原因分析
                    32位单核CPU
                    32位多核CPU
               总结
          如何使用互斥锁解决多线程的原子性问题
               前言
               如何保证原子性
               锁模型
               改进的锁模型
               Java中的synchronized锁
               synchronized揭秘
                    分析反编译代码块
                    分析反编译方法
               再次深究count+=1的问题
               修改测试用例
               总结
          ThreadLocal学会了这些，你也能和面试官扯皮了
               前言
               什么是ThreadLocal
               ThreadLocal使用示例
               ThreadLocal原理
                    set()方法
                    get()方法
                    remove()方法
               ThreadLocal变量不具有传递性
               InheritableThreadLocal使用示例
               InheritableThreadLocal原理
          学好并发编程，关键是要理解这三个核心问题
               写在前面
               分工
               同步
               互斥
               总结
               写在最后
          什么是ForkJoin看这一篇就够了
               写在前面
               Java并发编程的发展
                    并发与并行
                         并发
                         并行
               分治法
                    基本思想
                    步骤
                    典型应用
               ForkJoin并行处理框架
                    ForkJoin框架概述
                    ForkJoin框架原理
                    工作窃取算法
                    ForkJoin框架的实现
               ForkJoin示例程序
               写在最后
          大家都在使用Redisson实现分布式锁了
               写在前面
               可重入锁[Reentrant Lock
               公平锁[Fair Lock
               联锁[MultiLock
               红锁[RedLock
               读写锁[ReadWriteLock
               信号量[Semaphore
               可过期性信号量[PermitExpirableSemaphore
               闭锁[CountDownLatch
               写在最后
          为何高并发系统中都要使用消息队列
               写在前面
               场景分析
               消息队列的好处
               消息队列特性
               高并发系统为何使用消息队列
               总结
               写在最后
          高并发环境下如何优化Tomcat配置]看完我懂了
               写在前面
               Tomcat运行模式
               Tomcat并发优化
                    安装APR
                    Tomcat优化
               写在最后
          不废话，言简意赅介绍BlockingQueue
               写在前面
               BlockingQueue概述
               BlockingQueue的实现类
               写在最后
          高并发环境下如何防止Tomcat内存溢出
               写在前面
               设置启动初始内存
               防止所用的JVM内存溢出
                    1 java_lang_OutOfMemoryError: Java heap space
                    2 java_lang_OutOfMemoryError: PermGen space
                    3 分析java_lang_OutOfMemoryError: PermGen space
               写在最后
          高并发下常见的限流方案
               写在前面
               限流算法
                    令牌桶算法
                    漏桶算法
                    令牌桶和漏桶对比
               单机限流
               应用级限流
                    限流总并发/连接/请求数
                    限流总资源数
                    限流某个接口的总并发/请求数
                    限流某个接口的时间窗请求数
                    平滑限流某个接口的请求数
               分布式限流
                    redis+lua实现的lua脚本
               写在最后
          Redis如何助力高并发秒杀系统
               写在前面
               秒杀业务
               秒杀三阶段
               Redis助力秒杀系统
               Lua脚本完美解决超卖问题
          一文搞懂PV、UV、VV、IP及其关系与计算
               写在前面
               小伙伴的疑问
               什么是PV
               什么是UV
               什么是VV
               什么是IP
               实例说明
          优化加锁方式时竟然死锁了
               写在前面
               为何需要优化加锁方式
               初步优化加锁方式
               死锁的问题分析
               死锁的必要条件
               死锁的预防
               总结
               写在最后
          如何使用互斥锁解决多线程的原子性问题
               如何保证原子性
               锁模型
               改进的锁模型
               Java中的synchronized锁
               再次深究count+=1的问题
               修改测试用例
               总结
          高并发环境下诡异的加锁问题[你加的锁未必安全
               声明
               前言
               分析场景
               没有直接业务关系的场景
               存在直接业务关系的场景
               正确的加锁
               写在最后
          高并发场景下创建多少线程才合适]一条公式帮你搞定
               CPU密集型程序
               I/O密集型程序
                    单核CPU
                    多核CPU
               总结
          终于弄懂为什么局部变量是线程安全的了
               写在前面
               前言
               著名的斐波那契数列
               方法是如何被执行的
               局部变量存放在哪里
               调用栈与线程
               线程封闭
               写在最后
          线程的生命周期其实没有我们想象的那么简单
               写在前面
               通用的线程生命周期
                    初始状态
                    可运行状态
                    运行状态
                    休眠状态
                    终止状态
               Java中的线程生命周期
                    RUNNABLE与BLOCKED的状态转换
                    RUNNABLE与WAITING状态转换
               RUNNABLE与TIMED_WAITING状态转换
                    从NEW到RUNNABLE状态
                    RUNNABLE到TERMINATED状态
               写在最后
     实战案例篇
          如何实现亿级流量下的分布式限流]这些理论你必须掌握
               写在前面
               高并发系统限流
               什么是限流
               限流有哪些使用场景
          如何实现亿级流量下的分布式限流]这些算法你必须掌握
               写在前面
               计数器
               漏桶算法
               令牌桶算法
               令牌桶算法实现
               Guava令牌桶算法的特点
          亿级流量场景下如何为HTTP接口限流]看完我懂了
               写在前面
               HTTP接口限流实战
               不使用注解实现接口限流
                    搭建项目
                    创建核心类
                    运行项目
                    不使用注解实现限流缺点
               使用注解实现接口限流
                    实现自定义注解
                    自定义注解切面实现
                    运行部署项目
               基于限流算法实现限流的缺点
          亿级流量场景下如何实现分布式限流]看完我彻底懂了
               写在前面
               Redis+Lua脚本实现分布式限流思路
               Redis+Lua脚本实现分布式限流案例
                    创建注解
                    创建切面类
                    创建limit_lua脚本文件
                    接口添加注解
               测试分布式限流
               Nginx+Lua实现分布式限流
               灵魂拷问
          如何实现亿级流量下的分布式限流
               高并发系统限流
               什么是限流
               限流有哪些使用场景
               常见的限流算法
                    计数器
                    漏桶算法
                    令牌桶算法
                    令牌桶算法实现
                    Guava令牌桶算法的特点
               HTTP接口限流实战
                    不使用注解实现接口限流
                    搭建项目
                    创建核心类
                    运行项目
                    不使用注解实现限流缺点
               使用注解实现接口限流
                    实现自定义注解
                    自定义注解切面实现
                    运行部署项目
               基于限流算法实现限流的缺点
               分布式限流实战
               Redis+Lua脚本实现分布式限流思路
               Redis+Lua脚本实现分布式限流案例
                    创建注解
                    创建切面类
                    创建limit_lua脚本文件
                    接口添加注解
               测试分布式限流
               Nginx+Lua实现分布式限流
               灵魂拷问
     面试篇
          面试官：讲讲高并发场景下如何优化加锁方式
               写在前面
               前言
               问题分析
               线程的等待与通知机制
               用Java实现线程的等待与通知机制
                    实现方式
                    实现原理
               具体实现
                    实现逻辑
                    实现代码
               notify()和notifyAll()的区别
          面试官：讲讲什么是缓存穿透]击穿]雪崩]如何解决
               写在前面
               缓存穿透
                    什么是缓存穿透
                    如何解决缓存穿透问题
               缓存击穿
                    什么是缓存击穿
                    如何解决缓存击穿问题
               缓存雪崩
                    什么是缓存雪崩
                    如何解决缓存雪崩问题
          面试官：Java中提供了synchronized，为什么还要提供Lock呢
               写在前面
               再造轮子
               为何提供Lock接口
               死锁问题
               synchronized的局限性
               解决问题
          面试官：说说缓存最关心的问题是什么]有哪些类型]回收策略和算法
               写在前面
               缓存命中率
               缓存类型
                    堆内存
                    堆外内存
                    磁盘缓存
                    分布式缓存
               缓存回收策略
                    基于空间
                    基于容量
                    基于时间
                    基于对象引用
               回收算法
          面试官：性能优化有哪些衡量指标]需要注意什么
               写在前面
               面试场景
               衡量指标
               性能指标
               响应时间
               并发量
               秒开率
               正确性
               优化需要注意的问题
          面试官问我如何使用Nginx实现限流，我如此回答轻松拿到了Offer
               写在前面
               限流措施
               Nginx官方的限流模块
               limit_req_zone 参数配置
                    limit_req_zone参数说明
                    limit_req_zone示例
               ngx_http_limit_conn_module 参数配置
                    ngx_http_limit_conn_module 参数说明
               Nginx限流实战
                    限制访问速率
                    burst缓存处理
                    nodelay降低排队时间
                    自定义返回值
          如何设计一个支撑高并发大流量的系统
               写在前面
               高并发架构相关概念
                    什么是并发
                    高并发具体关心什么
               高并发解决方案案例
               高并发下的经验公式
                    通过QPS和PV计算部署服务器的台数
                    服务器计算
                    峰值QPS和机器计算公式
          关于乐观锁和悲观锁，蚂蚁金服面试官问了我这几个问题
               写在前面
               何谓悲观锁与乐观锁
                    悲观锁
                    乐观锁
               两种锁的使用场景
               乐观锁的实现方式
                    版本号机制
                    CAS 算法
               乐观锁的缺点
                    ABA 问题
                    循环时间长开销大
                    只能保证一个共享变量的原子操作
               CAS 与 synchronized 的使用场景
          关于线程池，蚂蚁金服面试官问了我这些内容
               写在前面
               面试汇总
                    Java中的线程池是如何实现的
                    创建线程池的几个核心构造参数
                    线程池中的线程是怎么创建的]是一开始就随着线程池的启动创建好的吗
                    既然提到可以通过配置不同参数创建出不同的线程池，那么Java中默认实现好的线程池又有哪些呢]请比较它们的异同。
                    什么是Java的内存模型，Java中各个线程是怎么彼此看到对方的变量的
                    请谈谈volatile有什么特点，为什么它能保证变量对所有线程的可见性
                    既然volatile能够保证线程间的变量可见性，是不是就意味着基于volatile变量的运算就是并发安全的
                    请对比下volatile对比Synchronized的异同。
                    请谈谈ThreadLocal是怎么解决并发安全的
                    很多人都说要慎用ThreadLocal，谈谈你的理解，使用ThreadLocal需要注意些什么
          高并发环境下构建缓存服务需要注意哪些问题]我和阿里P9聊了很久
               写在前面
               缓存特征
               缓存命中率影响因素
               提高缓存命中率的方法
               缓存的分类和应用场景
               高并发场景下缓存常见问题
     系统架构篇
          高并发秒杀系统架构解密，不是所有的秒杀都是秒杀
               前言
               电商系统架构
               秒杀系统的特点
                    秒杀系统的业务特点
                    秒杀系统的技术特点
               秒杀系统方案
               秒杀系统时序图
                    同步下单流程
                         1 用户发起秒杀请求
                         2 提交订单
                    异步下单流程
                         1 用户发起秒杀请求
                         2 异步处理
                         3 短轮询查询秒杀结果
                         4 秒杀结算
                         5 提交订单
               高并发黑科技与致胜奇招
                    暗度陈仓
                    移花接木
               写在最后
          高并发分布式锁架构解密，不是所有的锁都是分布式锁
               写在前面
               锁用来解决什么问题呢
               电商超卖问题
               JVM中提供的锁
               JVM锁原理
               JVM锁的短板
               分布式锁
               Redis如何实现分布式锁
                    Redis命令
                    引入分布式锁
                    引入try-finally代码块
                    引入Redis超时机制
                    坑位分析
                    在开发集成角度分析代码
                    如何实现加锁和解锁的归一化
                    继续分析
                    可重入性分析
                    解决可重入性问题
                    阻塞与非阻塞锁
                    锁失效问题
               实现分布式锁的基本要求
               通用分布式解决方案
               CAP理论
               红锁的实现
               高并发黑科技与致胜奇招
                    暗度陈仓
                    移花接木
     结束语
     重磅福利
     写在最后

BCCN本地下载 

 

>> 评论

 

热门Tag：