并发编程的目的是为了让程序运行得更快，但是，并不是启动更多的线程就能让程序最大限度地并发执行。在并发编程时，如果希望通过多线程执行任务让程序运行得更快，会面临非常多的挑战，比如：上下文的切换问题、死锁问题、以及受限制于硬件和软件资源限制问题。
上下文切换
即使单核处理器也支持多线程执行代码，CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间，因为时间片非常短，所以CPU通过不停切换线程执行，让我们感觉多个线程是同时执行的，时间片一般是几十毫秒。
CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。 从系统的角度理解上下文切换请移步至这篇文章<<Linux进程管理>>。
多线程一定快？
下面的代码并发执行一定比串行快吗？
public class ConcurrencyTest {
private static final long count = 10000 * 1000l;
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 (int 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.printf("concurrency: %d ms,b=%d \n", time, b);
}
private static void serial() {
long start = System.currentTimeMillis();
int a = 0;
for (int i = 0; i < count; i++) {
a += 5;
}
int b = 0;
for (int i = 0; i < count; i++) {
b--;
}
long time = System.currentTimeMillis() - start;
System.out.printf("serial: %d ms,a=%d, b=%d \n", time, a, b);
}
}
测试结果表明：并发不一定比串行快，当并发执行累加操作不超过100万次时，速度会比串行累加操作要慢。这是因为线程有创建和上下文切换的开销。
测试上下文切换次数和时长
- 使用Lmbench3可以测量上下文切换的时长
- 使用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 1 0 0 13195448 182308 4539940 0 0 0 731 1 1 3 2 94 1 0 2 0 0 13195936 182308 4540052 0 0 0 0 12681 32658 1 1 98 0 0 0 0 0 13195960 182308 4540164 0 0 0 0 12578 32297 2 1 98 0 0 1 0 0 13195736 182308 4540280 0 0 0 48 12892 33908 2 1 97 0 0 0 0 0 13195984 182308 4540384 0 0 0 4 12602 32801 1 1 98 0 0 2 0 0 13159652 182308 4576968 0 0 0 0 13576 34423 5 1 94 0 0 0 0 0 12983152 182308 4754012 0 0 0 0 13622 33814 5 2 93 0 0
CS(Content Switch)表示上下文切换的次数，从数据中可以看到上下1秒切换1W多次。
如何减少上下文切换
减少上下文切换的方法有: 无锁并发编程、CAS算法、使用最少线程和协程。
- 无锁并发编程：多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以一些办法来避免使用锁，比如将数据的ID按照Hash算法取模分段，不同的线程处理不同段的数据。
- CAS算法：Java的Atomic包使用CAS算法来更新数据，而不需要加锁。
- 使用最小线程：避免创建不需要的线程，比如任务很少，但是创建了很多的线程来处理，这样会造成大量的线程处于等待状态。
- 协程：在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换。
通过jstack查看线程状态，如果有大量WAITING状态的线程，减少线程数达到减少上下文切换。
jstack 3616 |grep "java.lang.Thread.State" |awk '{print $2$3$4$5}'|sort | uniq -c
16 RUNNABLE
6 TIMED_WAITING(parking)
4 WAITING(onobjectmonitor)
2 WAITING(parking)
LMbench：http://www.bitmover.com/lmbench/
死锁
锁是一个非常有用的工具，运用场景非常多，因为它使用起来非常简单，而且易于理解。但同时它也会带来一些困扰，那就是可能会引起死锁，一旦产生死锁，就会造成系统功能不可用。下面的代码就会产生死锁。
public class DeadLockDemo {
private static String A = "A";
private static String B = "B";
public static void main(String[] args) throws InterruptedException {
new DeadLockDemo().deadLock();
}
private void deadLock() throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (A) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (B) {
System.out.println("x");
}
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (B) {
synchronized (A) {
System.out.println("y");
}
}
}
});
t1.start();
t2.start();
}
}
死锁的堆栈信息
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.45-b02 mixed mode):
"DestroyJavaVM" #12 prio=5 os_prio=0 tid=0x0000000001c8d800 nid=0x27e8 waiting o
n condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Thread-1" #11 prio=5 os_prio=0 tid=0x0000000016508000 nid=0x2e34 waiting for mo
nitor entry [0x00000000175ff000]
java.lang.Thread.State: BLOCKED (on object monitor)
at com.javagc.art.chapter1.DeadLockDemo$2.run(DeadLockDemo.java:34)
- waiting to lock <0x00000000eb2fe9b0> (a java.lang.String)
- locked <0x00000000eb2fe9e0> (a java.lang.String)
at java.lang.Thread.run(Unknown Source)
"Thread-0" #10 prio=5 os_prio=0 tid=0x0000000016507800 nid=0x2d28 waiting for mo
nitor entry [0x00000000173af000]
java.lang.Thread.State: BLOCKED (on object monitor)
at com.javagc.art.chapter1.DeadLockDemo$1.run(DeadLockDemo.java:24)
- waiting to lock <0x00000000eb2fe9e0> (a java.lang.String)
- locked <0x00000000eb2fe9b0> (a java.lang.String)
at java.lang.Thread.run(Unknown Source)
"Service Thread" #9 daemon prio=9 os_prio=0 tid=0x00000000164a3800 nid=0x2b20 ru
nnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"C1 CompilerThread2" #8 daemon prio=9 os_prio=2 tid=0x0000000016440000 nid=0x27b
c waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"C2 CompilerThread1" #7 daemon prio=9 os_prio=2 tid=0x000000001643a800 nid=0x2be
8 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"C2 CompilerThread0" #6 daemon prio=9 os_prio=2 tid=0x0000000016435800 nid=0x2a4
c waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Attach Listener" #5 daemon prio=5 os_prio=2 tid=0x0000000016433000 nid=0x2b34 w
aiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Signal Dispatcher" #4 daemon prio=9 os_prio=2 tid=0x0000000014f8f000 nid=0x2bc4
runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Finalizer" #3 daemon prio=8 os_prio=1 tid=0x0000000014f23000 nid=0x2874 in Obje
ct.wait() [0x000000001641f000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000000eb206f58> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(Unknown Source)
- locked <0x00000000eb206f58> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(Unknown Source)
at java.lang.ref.Finalizer$FinalizerThread.run(Unknown Source)
"Reference Handler" #2 daemon prio=10 os_prio=2 tid=0x0000000014f21800 nid=0x262
4 in Object.wait() [0x0000000015f7f000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000000eb206998> (a java.lang.ref.Reference$Lock)
at java.lang.Object.wait(Unknown Source)
at java.lang.ref.Reference$ReferenceHandler.run(Unknown Source)
- locked <0x00000000eb206998> (a java.lang.ref.Reference$Lock)
"VM Thread" os_prio=2 tid=0x0000000014f1c000 nid=0x27c0 runnable
"GC task thread#0 (ParallelGC)" os_prio=0 tid=0x000000000234c000 nid=0x2714 runn
able
"GC task thread#1 (ParallelGC)" os_prio=0 tid=0x000000000234d800 nid=0x2b3c runn
able
"GC task thread#2 (ParallelGC)" os_prio=0 tid=0x000000000234f000 nid=0x2ee0 runn
able
"GC task thread#3 (ParallelGC)" os_prio=0 tid=0x0000000002352800 nid=0x215c runn
able
"VM Periodic Task Thread" os_prio=2 tid=0x00000000164c1000 nid=0x2df0 waiting on
condition
JNI global references: 6
Found one Java-level deadlock:
=============================
"Thread-1":
waiting to lock monitor 0x0000000014f28328 (object 0x00000000eb2fe9b0, a java.
lang.String),
which is held by "Thread-0"
"Thread-0":
waiting to lock monitor 0x0000000014f297c8 (object 0x00000000eb2fe9e0, a java.
lang.String),
which is held by "Thread-1"
Java stack information for the threads listed above:
===================================================
"Thread-1":
at com.javagc.art.chapter1.DeadLockDemo$2.run(DeadLockDemo.java:34)
- waiting to lock <0x00000000eb2fe9b0> (a java.lang.String)
- locked <0x00000000eb2fe9e0> (a java.lang.String)
at java.lang.Thread.run(Unknown Source)
"Thread-0":
at com.javagc.art.chapter1.DeadLockDemo$1.run(DeadLockDemo.java:24)
- waiting to lock <0x00000000eb2fe9e0> (a java.lang.String)
- locked <0x00000000eb2fe9b0> (a java.lang.String)
at java.lang.Thread.run(Unknown Source)
Found 1 deadlock.
避免死锁几个常见方法：
- 避免一个线程同时获取多个锁
- 避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源
- 尝试使用定时锁，使用lock.tryLock(timeout)来替代使用内部锁机制。
- 对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。
相关推荐
本书开篇即指出，随着现代计算机系统越来越依赖于多核处理器的并行计算能力，Java开发人员面临着前所未有的并发编程挑战。这些挑战包括但不限于数据一致性问题、死锁、资源竞争等。为了克服这些困难，作者们在第一章...
7. **并发编程挑战**：探讨死锁、活锁、饥饿等并发问题及其解决策略，以及线程安全的编程习惯和陷阱。 8. **并发性能优化**：讲述如何分析和优化并发程序的性能，使用Java性能监控工具，如JConsole和VisualVM，以及...
该书为读者提供了一个全面而深入的理解多处理器系统中的并发编程挑战和解决方案的机会。 #### 二、并发编程简介 并发编程是一种编程方法，它允许程序中的多个任务或线程同时执行。在多处理器系统中，这种能力尤为...
JAVA并发编程艺术 高清pdf : 1.并发变成的挑战 2. java并发机制的底层实现原理 3. java 内存模型 4. java并发编程基础 5.java中的锁。。。。。。。
《JAVA并发编程实践》这本书是Java开发者深入理解并发编程的重要参考资料。它涵盖了Java并发的核心概念、工具和最佳实践，旨在帮助...通过学习这本书，你将能够有效地应对并发编程中的挑战，提升你的多线程编程能力。
6. **并发编程挑战** - 线程安全集合：如Vector、HashTable，虽然保证线程安全，但性能较差，推荐使用并发集合如ConcurrentHashMap、CopyOnWriteArrayList。 - 内存模型：理解JMM（Java内存模型）对于编写高效、...
Java并发编程是Java开发中的重要领域，特别是在多核处理器和分布式系统中，高效地利用并发可以极大地提升程序的性能和响应速度。这份“java并发编程内部分享PPT”显然是一个深入探讨这一主题的资料，旨在帮助开发者...
并发编程挑战** 并发编程中常见的挑战包括竞态条件、死锁、资源争抢等，开发者需要理解这些问题并学会如何避免它们。此外，线程安全的编程也是一大难题，尤其是在多线程访问共享数据时。 总结来说，Java并发编程...
在**基础案例篇**，作者通过实际问题，如并发编程中的常见问题和挑战，引导读者理解并发编程中的可见性和有序性问题，以及如何解决这些问题。 **实战案例篇**探讨了在亿级流量场景下如何实现分布式限流和HTTP接口限...
8. **并发编程挑战** - **死锁**：多个线程互相等待对方释放资源，导致无法继续执行。 - **活锁**：线程不断尝试获取资源，但一直不成功，造成资源浪费。 - **饥饿**：某线程因其他线程持续占用资源而无法获得...
《Java并发编程实战》是Java开发者深入理解和掌握并发编程的一本经典著作...通过阅读《Java并发编程实战》，读者可以深入学习这些知识点，从而更好地应对多线程环境下的编程挑战，编写出更加健壮和高效的Java应用程序。
通过阅读《Java并发编程艺术》这本书，开发者可以系统地学习Java多线程编程的各个方面，从而在实际工作中更好地应对并发编程的挑战，提高软件的性能和稳定性。无论是初学者还是经验丰富的开发人员，都能从中受益匪浅...
《Java虚拟机并发编程》这本书深入探讨了Java平台上的并发处理技术，特别是在Java虚拟机（JVM）上。这本书由知名编程导师Venkat Subramaniam撰写，旨在帮助读者掌握在JVM上进行高效并发编程的技能。 并发编程是现代...
《Java并发编程艺术》这本书是Java开发者深入理解并发编程的重要参考。并发编程是现代多核处理器环境下不可或缺的技术，它能够充分利用系统资源，提高程序的执行效率。以下将详细阐述Java并发编程的一些核心知识点：...
第1章介绍Java并发编程的挑战，向读者说明进入并发编程的世界可能会遇到哪些问题，以及如何解决。 第2章介绍Java并发编程的底层实现原理，介绍在CPU和JVM这个层面是如何帮助Java实现并发编程的。 第3章介绍深入介绍...
《JAVA并发编程实践》是...总而言之，《JAVA并发编程实践》是一本全面而深入的指南，无论是对于初学者还是经验丰富的开发者，都能从中获得宝贵的洞见和实践经验，提升并发编程的能力，更好地应对多线程环境下的挑战。
第一章 并发编程的挑战 第二章 Java并发机制的底层实现原理 volatile的两条实现原则： 1. Lock前缀指令会引起处理器缓存回写到内存 2. 一个处理器的缓存回写到内存会导致其他处理器的缓存无效。 volatile...