带你读《Java并发编程的艺术》之一:并发编程的挑战-阿里云开发者社区

开发者社区> 每日读本书> 正文

带你读《Java并发编程的艺术》之一:并发编程的挑战

简介: 本书结合JDK的源码介绍了Java并发框架、线程池的实现原理,帮助读者做到知其所以然。

Java核心技术系列
点击这里查看第二章:Java并发机制的底层实现原理
点击这里查看第三章:Java内存模型

Java并发编程的艺术-立.jpg

Java并发编程的艺术

方腾飞 魏鹏 程晓明 著

前  言

为什么要写这本书
记得第一次写并发编程的文章时还是在2012年,当时花了几个星期的时间写了一篇文章《深入分析volatile的实现原理》,准备在自己的博客中发表。在同事建法的建议下,怀着试一试的心态投向了InfoQ,庆幸的是半小时后得到InfoQ主编采纳的回复,高兴之情无以言表。这也是我第一次在专业媒体上发表文章,而后在InfoQ编辑张龙的不断鼓励和支持下,我陆续在InfoQ发表了几篇与并发编程相关的文章,于是便形成了“聊聊并发”专栏。在这个专栏的写作过程中,我得到快速的成长和非常多的帮助,在此非常感谢InfoQ的编辑们。2013年,华章的福川兄找到我,问有没有兴趣写一本书,当时觉得自己资历尚浅,婉言拒绝了。后来和福川兄一直保持联系,最后允许我花两年的时间来完成本书,所以答应了下来。由于并发编程领域的技术点非常多且深,所以陆续又邀请了同事魏鹏和朋友晓明一起参与到本书的编写当中。

写本书的过程也是对自己研究和掌握的技术点进行整理的过程,希望本书能帮助读者快速掌握并发编程技术。

本书一共11章,由三名作者共同编写完成,其中第3章和第10章节由程晓明编写,第4章和第5章由魏鹏编写,其他7章由方腾飞编写。

本书特色
本书结合JDK的源码介绍了Java并发框架、线程池的实现原理,帮助读者做到知其所以然。

本书对原理的剖析不仅仅局限于Java层面,而是深入到JVM,甚至CPU层面来进行讲解,帮助读者从更底层看并发技术。

本书结合线上应用,给出了一些并发编程实战技巧,以及线上处理并发问题的步骤和思路。

读者对象
Java开发工程师
架构师
并发编程爱好者
开设相关课程的大专院校师生

如何阅读本书
阅读本书之前,你必须有一定的Java基础和开发经验,最好还有一定的并发编程基础。如果你是一名并发编程初学者,建议按照顺序阅读本书,并按照书中的例子进行编码和实战。如果你有一定的并发编程经验,可以把本书当做一个手册,直接看需要学习的章节。以下是各章节的基本介绍。

第1章介绍Java并发编程的挑战,向读者说明进入并发编程的世界可能会遇到哪些问题,以及如何解决。
第2章介绍Java并发编程的底层实现原理,介绍在CPU和JVM这个层面是如何帮助Java实现并发编程的。
第3章介绍深入介绍了Java的内存模型。Java线程之间的通信对程序员完全透明,内存可见性问题很容易困扰Java程序员,本章试图揭开Java内存模型的神秘面纱。
第4章从介绍多线程技术带来的好处开始,讲述了如何启动和终止线程以及线程的状态,详细阐述了多线程之间进行通信的基本方式和等待/通知经典范式。
第5章介绍Java并发包中与锁相关的API和组件,以及这些API和组件的使用方式与实现细节。
第6章介绍了Java中的大部分并发容器,并深入剖析其实现原理,让读者领略大师的设计技巧。
第7章介绍了Java中的原子操作类,并给出一些实例。
第8章介绍了Java中提供的并发工具类,这是并发编程中的瑞士军刀。
第9章介绍了Java中的线程池实现原理和使用建议。
第10章介绍了Executor框架的整体结构和成员组件。
第11章介绍几个并发编程的实战,以及排查并发编程造成问题的方法。

精彩导读

第1章:并发编程的挑战

并发编程的目的是为了让程序运行得更快,但是,并不是启动更多的线程就能让程序最大限度地并发执行。在进行并发编程时,如果希望通过多线程执行任务让程序运行得更快,会面临非常多的挑战,比如上下文切换的问题、死锁的问题,以及受限于硬件和软件的资源限制问题,本章会介绍几种并发编程的挑战以及解决方案。

1.1 上下文切换
即使是单核处理器也支持多线程执行代码,CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间,因为时间片非常短,所以CPU通过不停地切换线程执行,让我们感觉多个线程是同时执行的,时间片一般是几十毫秒(ms)。
CPU通过时间片分配算法来循环执行任务,当前任务执行一个时间片后会切换到下一个任务。但是,在切换前会保存上一个任务的状态,以便下次切换回这个任务时,可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。
这就像我们同时读两本书,当我们在读一本英文的技术书时,发现某个单词不认识,于是便打开中英文字典,但是在放下英文技术书之前,大脑必须先记住这本书读到了多少页的第多少行,等查完单词之后,能够继续读这本书。这样的切换是会影响读书效率的,同样上下文切换也会影响多线程的执行速度。

1.1.1 多线程一定快吗
下面的代码演示串行和并发执行并累加操作的时间,请分析:下面的代码并发执行一定比串行执行快吗?

public class ConcurrencyTest {

    private static f?inal long count = 10000l;

    public static void main(String[] args) throws InterruptedException {
            concurrency();
            serial();
    }

    private static void concurrency() throws InterruptedException {
            long start = System.currentTimeMillis();
            Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                            int a = 0;
                            for (long i = 0; i < count; i++) {
                                    a += 5;
                            }
                    }
            });
            thread.start();
            int b = 0;
            for (long i = 0; i < count; i++) {
                    b--;
            }
            long time = System.currentTimeMillis() - start;
            thread.join();
            System.out.println("concurrency :" + time+"ms,b="+b);
    }

    private static void serial() {
            long start = System.currentTimeMillis();
            int a = 0;
            for (long i = 0; i < count; i++) {
                    a += 5;
            }
            int b = 0;
            for (long i = 0; i < count; i++) {
                    b--;
            }
            long time = System.currentTimeMillis() - start;
            System.out.println("serial:" + time+"ms,b="+b+",a="+a);
    }

}

上述问题的答案是“不一定”,测试结果如表1-1所示。

表1-1 测试结果

循环次数 串行执行耗时/ms 并发执行耗时 并发比串行快多少
1亿 130 77 约1倍
1千万 18 9 约1倍
1百万 5 5 差不多
10万 4 3
1万 0 1

从表1-1可以发现,当并发执行累加操作不超过百万次时,速度会比串行执行累加操作要慢。那么,为什么并发执行的速度会比串行慢呢?这是因为线程有创建和上下文切换的
开销。

1.1.2 测试上下文切换次数和时长
下面我们来看看有什么工具可以度量上下文切换带来的消耗。
使用Lmbench3可以测量上下文切换的时长。
使用vmstat可以测量上下文切换的次数。
下面是利用vmstat测量上下文切换次数的示例。
$ vmstat 1
procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 0 127876 398928 2297092 0 0 0 4 2 2 0 0 99 0 0
0 0 0 127868 398928 2297092 0 0 0 0 595 1171 0 1 99 0 0
0 0 0 127868 398928 2297092 0 0 0 0 590 1180 1 0 100 0 0
0 0 0 127868 398928 2297092 0 0 0 0 567 1135 0 1 99 0 0
CS(Content Switch)表示上下文切换的次数,从上面的测试结果中我们可以看到,上下文每1秒切换1000多次。

1.1.3 如何减少上下文切换
减少上下文切换的方法有无锁并发编程、CAS算法、使用最少线程和使用协程。
无锁并发编程。多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以用一些办法来避免使用锁,如将数据的ID按照Hash算法取模分段,不同的线程处理不同段的数据。
CAS算法。Java的Atomic包使用CAS算法来更新数据,而不需要加锁。
使用最少线程。避免创建不需要的线程,比如任务很少,但是创建了很多线程来处理,这样会造成大量线程都处于等待状态。
协程:在单线程里实现多任务的调度,并在单线程里维持多个任务间的切换。

1.1.4 减少上下文切换实战
本节将通过减少线上大量WAITING的线程,来减少上下文切换次数。

第一步:用jstack命令dump线程信息,看看pid为3117的进程里的线程都在做什么。
sudo -u admin /opt/ifeve/java/bin/jstack 31177 > /home/tengfei.fangtf/dump17

第二步:统计所有线程分别处于什么状态,发现300多个线程处于WAITING(onobject-monitor)状态。
[tengfei.fangtf@ifeve ~]$ grep java.lang.Thread.State dump17 | awk '{print $2$3$4$5}'

| sort | uniq -c

39 RUNNABLE
21 TIMED_WAITING(onobjectmonitor)
6 TIMED_WAITING(parking)
51 TIMED_WAITING(sleeping)
305 WAITING(onobjectmonitor)
3 WAITING(parking)

第三步:打开dump文件查看处于WAITING(onobjectmonitor)的线程在做什么。发现这些线程基本全是JBOSS的工作线程,在await。说明JBOSS线程池里线程接收到的任务太少,大量线程都闲着。
"http-0.0.0.0-7001-97" daemon prio=10 tid=0x000000004f6a8000 nid=0x555e in

Object.wait() [0x0000000052423000]

java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)

  • waiting on <0x00000007969b2280> (a org.apache.tomcat.util.net.AprEndpoint$Worker)
  1. java.lang.Object.wait(Object.java:485)

at org.apache.tomcat.util.net.AprEndpoint$Worker.await(AprEndpoint.java:1464)

  • locked <0x00000007969b2280> (a org.apache.tomcat.util.net.AprEndpoint$Worker)
  1. org.apache.tomcat.util.net.AprEndpoint$Worker.run(AprEndpoint.java:1489)

at java.lang.Thread.run(Thread.java:662)

第四步:减少JBOSS的工作线程数,找到JBOSS的线程池配置信息,将maxThreads降到100。
emptySessionPath="false" minSpareThreads="40" maxSpareThreads="75"

 maxPostSize="512000" protocol="HTTP/1.1"

enableLookups="false" redirectPort="8443" acceptCount="200" bufferSize="16384"
connectionTimeout="15000" disableUploadTimeout="false" useBodyEncodingForURI=

 "true">

第五步:重启JBOSS,再dump线程信息,然后统计WAITING(onobjectmonitor)的线程,发现减少了175个。WAITING的线程少了,系统上下文切换的次数就会少,因为每一次从WAITTING到RUNNABLE都会进行一次上下文的切换。读者也可以使用vmstat命令测试一下。
[tengfei.fangtf@ifeve ~]$ grep java.lang.Thread.State dump17 | awk '{print $2$3$4$5}'

| sort | uniq -c

44 RUNNABLE
22 TIMED_WAITING(onobjectmonitor)
9 TIMED_WAITING(parking)
36 TIMED_WAITING(sleeping)
130 WAITING(onobjectmonitor)
1 WAITING(parking)

1.2 死锁
锁是个非常有用的工具,运用场景非常多,因为它使用起来非常简单,而且易于理解。但同时它也会带来一些困扰,那就是可能会引起死锁,一旦产生死锁,就会造成系统功能不可用。让我们先来看一段代码,这段代码会引起死锁,使线程t1和线程t2互相等待对方释放锁。

public class DeadLockDemo {

privat static String A = "A";
private static String B = "B";

public static void main(String[] args) {

        new DeadLockDemo().deadLock();
}

private void deadLock() {
        Thread t1 = new Thread(new Runnable() {
                @Override
                publicvoid run() {
                        synchronized (A) {
                                try { Thread.currentThread().sleep(2000);
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                                synchronized (B) {
                                        System.out.println("1");
                                }
                        }
                }
        });

        Thread t2 = new Thread(new Runnable() {
                @Override
                publicvoid run() {
                        synchronized (B) {
                                synchronized (A) {
                                        System.out.println("2");
                                }
                        }
                }
        });

        t1.start();
        t2.start();
   }

}

这段代码只是演示死锁的场景,在现实中你可能不会写出这样的代码。但是,在一些更为复杂的场景中,你可能会遇到这样的问题,比如t1拿到锁之后,因为一些异常情况没有释放锁(死循环)。又或者是t1拿到一个数据库锁,释放锁的时候抛出了异常,没释放掉。
一旦出现死锁,业务是可感知的,因为不能继续提供服务了,那么只能通过dump线程查看到底是哪个线程出现了问题,以下线程信息告诉我们是DeadLockDemo类的第42行和第31行引起的死锁。

"Thread-2" prio=5 tid=7fc0458d1000 nid=0x116c1c000 waiting for monitor entry [116c1b000]
java.lang.Thread.State: BLOCKED (on object monitor)
    at com.ifeve.book.forkjoin.DeadLockDemo$2.run(DeadLockDemo.java:42)
    - waiting to lock <7fb2f3ec0> (a java.lang.String)
    - locked <7fb2f3ef8> (a java.lang.String)
    at java.lang.Thread.run(Thread.java:695)

"Thread-1" prio=5 tid=7fc0430f6800 nid=0x116b19000 waiting for monitor entry [116b18000]
java.lang.Thread.State: BLOCKED (on object monitor)
    at com.ifeve.book.forkjoin.DeadLockDemo$1.run(DeadLockDemo.java:31)
    - waiting to lock <7fb2f3ef8> (a java.lang.String)
    - locked <7fb2f3ec0> (a java.lang.String)
    at java.lang.Thread.run(Thread.java:695)

现在我们介绍避免死锁的几个常见方法。
避免一个线程同时获取多个锁。
避免一个线程在锁内同时占用多个资源,尽量保证每个锁只占用一个资源。
尝试使用定时锁,使用lock.tryLock(timeout)来替代使用内部锁机制。
对于数据库锁,加锁和解锁必须在一个数据库连接里,否则会出现解锁失败的情况。

1.3 资源限制的挑战
(1)什么是资源限制
资源限制是指在进行并发编程时,程序的执行速度受限于计算机硬件资源或软件资源。例如,服务器的带宽只有2Mb/s,某个资源的下载速度是1Mb/s每秒,系统启动10个线程下载资源,下载速度不会变成10Mb/s,所以在进行并发编程时,要考虑这些资源的限制。硬件资源限制有带宽的上传/下载速度、硬盘读写速度和CPU的处理速度。软件资源限制有数据库的连接数和socket连接数等。

(2)资源限制引发的问题
在并发编程中,将代码执行速度加快的原则是将代码中串行执行的部分变成并发执行,但是如果将某段串行的代码并发执行,因为受限于资源,仍然在串行执行,这时候程序不仅不会加快执行,反而会更慢,因为增加了上下文切换和资源调度的时间。例如,之前看到一段程序使用多线程在办公网并发地下载和处理数据时,导致CPU利用率达到100%,几个小时都不能运行完成任务,后来修改成单线程,一个小时就执行完成了。

(3)如何解决资源限制的问题
对于硬件资源限制,可以考虑使用集群并行执行程序。既然单机的资源有限制,那么就让程序在多机上运行。比如使用ODPS、Hadoop或者自己搭建服务器集群,不同的机器处理不同的数据。可以通过“数据ID%机器数”,计算得到一个机器编号,然后由对应编号的机器处理这笔数据。
对于软件资源限制,可以考虑使用资源池将资源复用。比如使用连接池将数据库和Socket连接复用,或者在调用对方webservice接口获取数据时,只建立一个连接。

(4)在资源限制情况下进行并发编程
如何在资源限制的情况下,让程序执行得更快呢?方法就是,根据不同的资源限制调整程序的并发度,比如下载文件程序依赖于两个资源——带宽和硬盘读写速度。有数据库操作时,涉及数据库连接数,如果SQL语句执行非常快,而线程的数量比数据库连接数大很多,则某些线程会被阻塞,等待数据库连接。

1.4 本章小结
本章介绍了在进行并发编程时,大家可能会遇到的几个挑战,并给出了一些解决建议。有的并发程序写得不严谨,在并发下如果出现问题,定位起来会比较耗时和棘手。所以,对于Java开发工程师而言,笔者强烈建议多使用JDK并发包提供的并发容器和工具类来解决并发问题,因为这些类都已经通过了充分的测试和优化,均可解决了本章提到的几个
挑战。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:

技术人必读书目

官方博客
官网链接