标签分类
当前位置:首页 > 程序设计电子书 > Java电子书网盘下载
精通Java并发编程 精通Java并发编程
萧曵 丶

萧曵 丶 提供上传

资源
21
粉丝
12
喜欢
10
评论
12

    精通Java并发编程 PDF 影印第2版

    Java电子书
    • 发布时间:

    给大家带来的一篇关于Java相关的电子书资源,介绍了关于Java编程、并发编程方面的内容,本书是由人民邮电出版社出版,格式为PDF,资源大小200.7 MB,哈维尔编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:9.4,更多相关的学习资源可以参阅 程序设计电子书Java电子书Java视频、等栏目。

  • 精通Java并发编程 PDF 下载
  • 下载地址:https://pan.baidu.com/s/1M31YDFwJW8f6oGCLoafycA
  • 分享码:1a46
  • 精通Java并发编程 PDF

    Java特性非凡,有套十分强劲的高并发API,在其中包括很多随时随地能用又极为灵便的原素,可用以轻轻松松保持一切种类的高并发手机应用程序。 这书从高并发解决的角度讨论Java程序编写。最先详解了高并发手机应用程序的结构设计,论述了怎样对串行优化算法开展并行处理化解决。随后详细介绍了Thread类和Runnable插口,他们是Java高并发API的关键构成。然后探讨了怎样运用Java高并发API的各种各样原素,及其怎样在强劲的真實高并发手机应用程序中保持他们。*后详解了检测高并发Java手机应用程序的专用工具和方法,概述详细介绍了JVM中的别的高并发体制。 - 把握高并发手机应用程序务必遵照的标准 - 并行处理化串行优化算法以提高特性,一起不容易造成统计数据不相同和死锁 - 灵活运用Java高并发API的全部原素 - 运用电动执行机构将进程管理方法与手机应用程序的别的一部分防护开开 - 应用Phaser类高并发实行可分成好几个环节的每日任务 - 根据Fork/Join架构,运用并行处理版分治设计方案统一范式解决困难 - 应用并行处理流和反映流 - 保持MapReduce和MapCollect实体模型 - 操纵Java高并发API出示的高并发数据结构和同歩体制 - 为大数据挖掘、深度学习等实际上难题保持高效率解决方法 

    Java 出示了一整套十分强劲的高并发API,能够轻轻松松保持一切种类的高并发手机应用程序。这书叙述Java 高并发API *关键的原素,包含电动执行机构架构、Phaser 类、Fork/Join 架构、流API、高并发数据结构、同歩体制,并展现怎样在实际上开发设计中应用他们。除此之外,这书还详细介绍了设计方案高并发手机应用程序的策略来支撑环境变化在校园营销推广环节中所带来的新问题、设计模式、保持优良高并发手机应用程序的提醒和方法、检测高并发手机应用程序的专用工具和方式,及其怎么使用朝向Java 虚拟机的别的计算机语言保持高并发手机应用程序。

    目录

    • 第 1 章 第 一步:并发设计原理    1
    • 1.1 基本的并发概念 1
    • 1.1.1 并发与并行 1
    • 1.1.2 同步 2
    • 1.1.3 不可变对象 2
    • 1.1.4 原子操作和原子变量 3
    • 1.1.5 共享内存与消息传递 3
    • 1.2 并发应用程序中可能出现的问题 3
    • 1.2.1 数据竞争 3
    • 1.2.2 死锁 4
    • 1.2.3 活锁 4
    • 1.2.4 资源不足 4
    • 1.2.5 优先权反转 5
    • 1.3 设计并发算法的方法论 5
    • 1.3.1 起点:算法的一个串行版本 5
    • 1.3.2 第 1 步:分析 5
    • 1.3.3 第 2 步:设计 5
    • 1.3.4 第3 步:实现 6
    • 1.3.5 第4 步:测试 6
    • 1.3.6 第5 步:调整 6
    • 1.3.7 结论 7
    • 1.4 Java 并发API 8
    • 1.4.1 基本并发类 8
    • 1.4.2 同步机制 8
    • 1.4.3 执行器 9
    • 1.4.4 Fork/Join 框架 9
    • 1.4.5 并行流 9
    • 1.4.6 并发数据结构 9
    • 1.5 并发设计模式 10
    • 1.5.1 信号模式 10
    • 1.5.2 会合模式 11
    • 1.5.3 互斥模式 11
    • 1.5.4 多元复用模式 12
    • 1.5.5 栅栏模式 12
    • 1.5.6 双重检查锁定模式 12
    • 1.5.7 读 写锁模式 13
    • 1.5.8 线程池模式 14
    • 1.5.9 线程局部存储模式 14
    • 1.6 设计并发算法的提示和技巧 14
    • 1.6.1 正确识别独立任务 14
    • 1.6.2 在尽可能高的层面上实施并发处理 15
    • 1.6.3 考虑伸缩性 15
    • 1.6.4 使用线程安全API 15
    • 1.6.5 绝不要假定执行顺序 16
    • 1.6.6 在静态和共享场合尽可能使用局部线程变量 16
    • 1.6.7 寻找更易于并行处理的算法版本 17
    • 1.6.8 尽可能使用不可变对象 17
    • 1.6.9 通过对锁排序来避免死锁 17
    • 1.6.10 使用原子变量代替同步 18
    • 1.6.11 占有锁的时间尽可能短 19
    • 1.6.12 谨慎使用延迟初始化 19
    • 1.6.13 避免在临界段中使用阻塞操作 19
    • 1.7 小结 20
    • 第 2 章 使用基本元素:Thread 和Runnable 21
    • 2.1 Java 中的线程 21
    • 2.1.1 Java 中的线程:特征和状态 22
    • 2.1.2 Thread 类和Runnable 接口 23
    • 2.2 第 一个例子:矩阵乘法 24
    • 2.2.1 公共类 24
    • 2.2.2 串行版本 25
    • 2.2.3 并行版本 25
    • 2.3 第二个例子:文件搜索 32
    • 2.3.1 公共类 32
    • 2.3.2 串行版本 32
    • 2.3.3 并发版本 33
    • 2.3.4 对比解决方案 37
    • 2.4 小结 38
    • 第3 章 管理大量线程:执行器 39
    • 3.1 执行器简介 39
    • 3.1.1 执行器的基本特征 39
    • 3.1.2 执行器框架的基本组件 40
    • 3.2 第 一个例子:k-最近邻算法 40
    • 3.2.1 k-最近邻算法:串行版本 41
    • 3.2.2 k-最近邻算法:细粒度并发版本 42
    • 3.2.3 k-最近邻算法:粗粒度并发版本 45
    • 3.2.4 对比解决方案 46
    • 3.3 第二个例子:客户端/服务器环境下的并发处理 48
    • 3.3.1 客户端/服务器:串行版 48
    • 3.3.2 客户端/服务器:并行版本 51
    • 3.3.3 额外的并发服务器组件 54
    • 3.3.4 对比两种解决方案 59
    • 3.3.5 其他重要方法 61
    • 3.4 小结 62
    • 第4 章 充分利用执行器 63
    • 4.1 执行器的高级特性 63
    • 4.1.1 任务的撤销 63
    • 4.1.2 任务执行调度 64
    • 4.1.3 重载执行器方法 64
    • 4.1.4 更改一些初始化参数 64
    • 4.2 第 一个例子:高级服务器应用程序 65
    • 4.2.1 ServerExecutor 类 65
    • 4.2.2 命令类 70
    • 4.2.3 服务器部件 72
    • 4.2.4 客户端部件 78
    • 4.3 第二个例子:执行周期性任务 79
    • 4.3.1 公共部件 79
    • 4.3.2 基础阅读器 81
    • 4.3.3 高级阅读器 84
    • 4.4 有关执行器的其他信息 87
    • 4.5 小结 87
    • 第5 章 从任务获取数据:Callable接口与Future 接口 88
    • 5.1 Callable 接口和Future 接口简介 88
    • 5.1.1 Callable 接口 88
    • 5.1.2 Future 接口 89
    • 5.2 第 一个例子:单词最佳匹配算法 89
    • 5.2.1 公共类 90
    • 5.2.2 最佳匹配算法:串行版本 91
    • 5.2.3 最佳匹配算法:第 一个并发版本 92
    • 5.2.4 最佳匹配算法:第二个并发版本 95
    • 5.2.5 单词存在算法:串行版本 96
    • 5.2.6 单词存在算法:并行版本 98
    • 5.2.7 对比解决方案 100
    • 5.3 第二个例子:为文档集创建倒排索引 102
    • 5.3.1 公共类 103
    • 5.3.2 串行版本 104
    • 5.3.3 第 一个并发版本:每个文档一个任务 105
    • 5.3.4 第二个并发版本:每个任务多个文档 109
    • 5.3.5 对比解决方案 112
    • 5.3.6 其他相关方法 113
    • 5.4 小结 113
    • 第6 章 运行分为多阶段的任务:Phaser 类 115
    • 6.1 Phaser 类简介 115
    • 6.1.1 参与者的注册与注销 116
    • 6.1.2 同步阶段变更 116
    • 6.1.3 其他功能 116
    • 6.2 第 一个例子:关键字抽取算法 117
    • 6.2.1 公共类 118
    • 6.2.2 串行版本 121
    • 6.2.3 并发版本 123
    • 6.2.4 对比两种解决方案 128
    • 6.3 第二个例子:遗传算法 129
    • 6.3.1 公共类 130
    • 6.3.2 串行版本 132
    • 6.3.3 并发版本 134
    • 6.3.4 对比两种解决方案 139
    • 6.4 小结 141
    • 第7 章 优化分治解决方案:
    • Fork/Join 框架 142
    • 7.1 Fork/Join 框架简介 142
    • 7.1.1 Fork/Join 框架的基本特征 143
    • 7.1.2 Fork/Join 框架的局限性 143
    • 7.1.3 Fork/Join 框架的组件 144
    • 7.2 第 一个例子:k-means 聚类算法 144
    • 7.2.1 公共类 145
    • 7.2.2 串行版本 149
    • 7.2.3 并发版本 151
    • 7.2.4 对比解决方案 155
    • 7.3 第二个例子:数据筛选算法 157
    • 7.3.1 公共特性 157
    • 7.3.2 串行版 157
    • 7.3.3 并发版本 159
    • 7.3.4 对比两个版本 165
    • 7.4 第三个例子:归并排序算法 166
    • 7.4.1 共享类 166
    • 7.4.2 串行版本 167
    • 7.4.3 并发版本 169
    • 7.4.4 对比两个版本 172
    • 7.5 Fork/Join 框架的其他方法 172
    • 7.6 小结 173
    • 第8 章 使用并行流处理大规模数据集:MapReduce 模型 174
    • 8.1 流的简介 174
    • 8.1.1 流的基本特征 174
    • 8.1.2 流的组成部分 175
    • 8.1.3 MapReduce 与MapCollect 177
    • 8.2 第 一个例子:数值综合分析应用程序 178
    • 8.2.1 并发版本 178
    • 8.2.2 串行版本 185
    • 8.2.3 对比两个版本 186
    • 8.3 第二个例子:信息检索工具 186
    • 8.3.1 约简操作简介 187
    • 8.3.2 第 一种方式:全文档查询 188
    • 8.3.3 第二种方式:约简的文档查询 191
    • 8.3.4 第三种方式:生成一个含有结果的HTML 文件 191
    • 8.3.5 第四种方式:预先载入倒排索引 194
    • 8.3.6 第五种方式:使用我们的执行器 195
    • 8.3.7 从倒排索引获取数据:ConcurrentData 类 196
    • 8.3.8 获取文件中的单词数 196
    • 8.3.9 获取文件的平均tfxidf 值 196
    • 8.3.10 获取索引中的最大tfxidf值和最小tfxidf 值 197
    • 8.3.11 ConcurrentMain 类 198
    • 8.3.12 串行版 199
    • 8.3.13 对比两种解决方案 199
    • 8.4 小结 202
    • 第9 章 使用并行流处理大规模数据集:MapCollect 模型 203
    • 9.1 使用流收集数据 203
    • 9.2 第 一个例子:无索引条件下的数据搜索 205
    • 9.2.1 基本类 205
    • 9.2.2 第 一种方式:基本搜索 207
    • 9.2.3 第二种方式:高级搜索 209
    • 9.2.4 本例的串行实现 211
    • 9.2.5 对比实现方案 211
    • 9.3 第二个例子:推荐系统 212
    • 9.3.1 公共类 212
    • 9.3.2 推荐系统:主类 213
    • 9.3.3 ConcurrentLoaderAccumulator 类 215
    • 9.3.4 串行版 216
    • 9.3.5 对比两个版本 216
    • 9.4 第三个例子:社交网络中的共同联系人 217
    • 9.4.1 基本类 218
    • 9.4.2 并发版本 219
    • 9.4.3 串行版本 223
    • 9.4.4 对比两个版本 223
    • 9.5 小结 224
    • 第 10 章 异步流处理:反应流 225
    • 10.1 Java 反应流简介 225
    • 10.1.1 Flow.Publisher 接口 226
    • 10.1.2 Flow.Subscriber 接口 226
    • 10.1.3 Flow.Subscription 接口 226
    • 10.1.4 SubmissionPublisher 类 226
    • 10.2 第 一个例子:面向事件通知的集中式系统 227
    • 10.2.1 Event 类 227
    • 10.2.2 Producer 类 227
    • 10.2.3 Consumer 类 228
    • 10.2.4 Main 类 230
    • 10.3 第二个例子:新闻系统 231
    • 10.3.1 News 类 232
    • 10.3.2 发布者相关的类 232
    • 10.3.3 Consumer 类 235
    • 10.3.4 Main 类 236
    • 10.4 小结 238
    • 第 11 章 探究并发数据结构和同步工具 240
    • 11.1 并发数据结构 240
    • 11.1.1 阻塞型数据结构和非阻塞型数据结构 241
    • 11.1.2 并发数据结构 241
    • 11.1.3 使用新特性 244
    • 11.1.4 原子变量 251
    • 11.1.5 变量句柄 252
    • 11.2 同步机制 254
    • 11.2.1 CommonTask 类 255
    • 11.2.2 Lock 接口 255
    • 11.2.3 Semaphore 类 256
    • 11.2.4 CountDownLatch 类 258
    • 11.2.5 CyclicBarrier 类 259
    • 11.2.6 CompletableFuture 类 261
    • 11.3 小结 268
    • 第 12 章 测试与监视并发应用程序 269
    • 12.1 监视并发对象 269
    • 12.1.1 监视线程 269
    • 12.1.2 监视锁 270
    • 12.1.3 监视执行器 272
    • 12.1.4 监视Fork/Join 框架 273
    • 12.1.5 监视Phaser 274
    • 12.1.6 监视流API 275
    • 12.2 监视并发应用程序 276
    • 12.2.1 Overview 选项卡 278
    • 12.2.2 Memory 选项卡 279
    • 12.2.3 Threads 选项卡 280
    • 12.2.4 Classes 选项卡 280
    • 12.2.5 VM Summary 选项卡 281
    • 12.2.6 MBeans 选项卡 283
    • 12.2.7 About 选项卡 284
    • 12.3 测试并发应用程序 284
    • 12.3.1 使用MultithreadedTC 测试并发应用程序 285
    • 12.3.2 使用Java Pathfinder 测试并发应用程序 288
    • 12.4 小结 293
    • 第 13 章 JVM 中的并发处理:Clojure、带有GPars 库的Groovy 以及Scala 294
    • 13.1 Clojure 的并发处理 294
    • 13.1.1 使用Java 元素 295
    • 13.1.2 引用类型 295
    • 13.1.3 Ref 对象 298
    • 13.1.4 Delay 299
    • 13.1.5 Future 300
    • 13.1.6 Promise 301
    • 13.2 Groovy 及其GPars 库的并发处理 302
    • 13.3 软件事务性内存 302
    • 13.3.1 使用Java 元素 302
    • 13.3.2 数据并行处理 303
    • 13.3.3 Fork/Join 处理 307
    • 13.3.4 Actor 308
    • 13.3.5 Agent 315
    • 13.3.6 Dataf low 316
    • 13.4 Scala 的并发处理 322
    • 13.4.1 Scala 中的Future 对象 322
    • 13.4.2 Promise 328
    • 13.5 小结 329

    上一篇:精通以太坊智能合约开发  下一篇:京东平台运营攻略

    展开 +

    收起 -

    码小辫二维码
     ←点击下载即可登录

    Java相关电子书
    学习笔记
    网友NO.686038

    详解java并发之重入锁-ReentrantLock

    前言 目前主流的锁有两种,一种是synchronized,另一种就是ReentrantLock,JDK优化到现在目前为止synchronized的性能已经和重入锁不分伯仲了,但是重入锁的功能和灵活性要比这个关键字多的多,所以重入锁是可以完全替代synchronized关键字的。下面就来介绍这个重入锁。 正文 ReentrantLock重入锁是Lock接口里最重要的实现,也是在实际开发中应用最多的一个,我这篇文章更接近实际开发的应用场景,为开发者提供直接上手应用。所以不是所有方法我都讲解,有些冷门的方法我不会介绍或一句带过。 一、首先先看声明一个重入锁需要使用到那几个构造方法 public ReentrantLock() { sync = new NonfairSync(); }public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); } 推荐声明方式 private static ReentrantLock lock = new ReentrantLock(true);private static ReentrantLock locka = new ReentrantLock(); 重点说明: ReentrantLock提供了两个构造方法,对应两种声明方式。 第一种声明的是公平锁,所谓公平锁,就是按照时间先后顺序,使先等待的线程先得到锁,而且,公平锁不会产生饥饿锁,也就是只要排队等待,最终能等待到获取锁的机会。 第二种声明的是非公平锁,所谓非公平锁就和公平锁概念相反,线程等待的顺序并不一定是执行的顺序,也就是后来进来的线程可能先被……

    网友NO.429589

    Java并发之传统线程同步通信技术代码详解

    本文研究的主要是Java并发之传统线程同步通信技术的相关代码示例,具体介绍如下。 先看一个问题: 有两个线程,子线程先执行10次,然后主线程执行5次,然后再切换到子线程执行10,再主线程执行5次……如此往返执行50次。 看完这个问题,很明显要用到线程间的通信了, 先分析一下思路:首先肯定要有两个线程,然后每个线程中肯定有个50次的循环,因为每个线程都要往返执行任务50次,主线程的任务是执行5次,子线程的任务是执行10次。线程间通信技术主要用到 wait() 方法和 notify() 方法。wait()方法会导致当前线程等待,并释放所持有的锁, notify() 方法表示唤醒在此对象监视器上等待的单个线程。下面来一步步完成这道线程间通信问题。 首先不考虑主线程和子线程之间的通信,先把各个线程所要执行的任务写好: public class TraditionalThreadCommunication {public static void main(String[] args) {//开启一个子线程new Thread(new Runnable() {@Override public void run() {for (int i = 1; i = 50; i ++) {synchronized (TraditionalThreadCommunication.class) {//子线程任务:执行10次 for (int j = 1;j = 10; j ++) {System.out.println("sub thread sequence of " + j + ", loop of " + i);}}}}}).start();//main方法即主线程for (int i = 1; i = 50; i ++) {synchronized (TraditionalThreadCommunication.class) {//主线程任务:执行5次for (i……

    网友NO.761184

    Java使用代码模拟高并发操作的示例

    在java中,使用了synchronized关键字和Lock锁实现了资源的并发访问控制,在同一时间只允许唯一了线程进入临界区访问资源(读锁除外),这样子控制的主要目的是为了解决多个线程并发同一资源造成的数据不一致的问题。在另外一种场景下,一个资源有多个副本可供同时使用,比如打印机房有多个打印机、厕所有多个坑可供同时使用,这种情况下,Java提供了另外的并发访问控制--资源的多副本的并发访问控制,今天使用的Semaphore即是其中的一种。 Java通过代码模拟高并发可以以最快的方式发现我们系统中潜在的线程安全性问题,此处使用Semaphore(信号量)和 CountDownLatch(闭锁)搭配ExecutorService(线程池)来进行模拟,主要介绍如下: 1、Semaphore JDK 1.5之后会提供这个类 Semaphore是一种基于计数的信号量。它可以设定一个阈值,基于此,多个线程竞争获取许可信号,做完自己的申请后归还,超过阈值后,线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池,资源池之类的,比如数据库连接池,我们也可以创建计数为1的Semaphore,将其作为一种类似互斥锁的机制,这也叫二元信号量,表示两种互斥状态。 2、CountDownLatch JDK 1.5之后会提供这个类, CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如……

    网友NO.469497

    java并发问题概述

    1什么是并发问题。 多个进程或线程同时(或着说在同一段时间内)访问同一资源会产生并发问题。 银行两操作员同时操作同一账户就是典型的例子。比如A、B操作员同时读取一余额为1000元的账户,A操作员为该账户增加100元,B操作员同时为该账户减去50元,A先提交,B后提交。最后实际账户余额为1000-50=950元,但本该为1000+100-50=1050。这就是典型的并发问题。如何解决?可以用锁。 2java中synchronized的用法 用法1 public class Test{public synchronized void print(){….;}} 某线程执行print()方法,则该对象将加锁。其它线程将无法执行该对象的所有synchronized块。 用法2 public class Test{public void print(){synchronized(this){//锁住本对象 …;}}} 同用法1, 但更能体现synchronized用法的本质。 用法3 public class Test{private String a = “test”;public void print(){synchronized(a){//锁住a对象 …;}}public synchronized void t(){…;//这个同步代码块不会因为print()而锁定.}} 执行print(),会给对象a加锁,注意不是给Test的对象加锁,也就是说Test对象的其它synchronized方法不会因为print()而被锁。同步代码块执行完,则释放对a的锁。 为了锁住一个对象的代码块而不影响该对象其它synchronized块的高性能写法: public class Test{private byte[] lock = new byte[0];public void print(){synchronized(lock){…;}}public synchronized void t(){………

    Copyright 2018-2019 xz577.com 码农之家

    版权责任说明