并发编程的目的是为了让程序运行得更快，但是，并不是启动更多的线程就能让程序最大限度地并发执行。在并发编程时，如果希望通过多线程执行任务让程序运行得更快，会面临非常多的挑战，比如：上下文的切换问题、死锁问题、以及受限制于硬件和软件资源限制问题。
上下文切换
即使单核处理器也支持多线程执行代码，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并发编程艺术 高清pdf : 1.并发变成的挑战 2. java并发机制的底层实现原理 3. java 内存模型 4. java并发编程基础 5.java中的锁。。。。。。。
在进行并发编程时，如果希望通过多线程执行任务让程序运行的更快，会面临非常多的挑战，比如上下文切换的问题，死锁的问题，以及受限于硬件和软件的资源限制问题，本章会介绍几种并发编程的挑战，以及解决方案。
第1章介绍Java并发编程的挑战，向读者说明进入并发编程的世界可能会遇到哪些问题，以及如何解决。 第2章介绍Java并发编程的底层实现原理，介绍在CPU和JVM这个层面是如何帮助Java实现并发编程的。 第3章介绍深入介绍...
这一功能为使用Java编程语言的程序员提供了解并发编程这一诱人但同时也非常具有挑战性的选择。, 本书通过帮助读者理解有关并发编程的模式及其利弊，向读者展示了如何更精确地使用Java平台的线程模型。, 这里，读者将...
第一章 并发编程的挑战 第二章 Java并发机制的底层实现原理 volatile的两条实现原则： 1. Lock前缀指令会引起处理器缓存回写到内存 2. 一个处理器的缓存回写到内存会导致其他处理器的缓存无效。 volatile...
通过深入学习，您将建立坚实的并发编程基础，能够更好地理解和应对多线程编程中的挑战。 并发编程概述： 引入并发编程的基本概念，解释为什么多线程编程在现代应用中至关重要。 线程和进程： 解释线程和进程的区别，...
这一功能为使用Java编程语言的程序员提供了解并发编程这一诱人但同时也非常具有挑战性的选择。 本书通过帮助读者理解有关并发编程的模式及其利弊，向读者展示了如何更精确地使用Java平台的线程模型。
第1章介绍Java并发编程的挑战，向读者说明进入并发编程的世界可能会遇到哪些问题，以及如何解决。第2章介绍Java并发编程的底层实现原理，介绍在CPU和JVM这个层面是如何帮助Java实现并发编程的。第3章介绍深入介绍了...
第1章介绍Java并发编程的挑战，会向读者说明可能会遇到哪些问题，以及如何解决。第2章Java并发编程的底层实现原理，从CPU和JVM2个层面剖析。第3章详细深入介绍了Java的内存模型。第4章从介绍多线程技术带来的好处...
通过深入学习，您将能够更好地理解并发编程的挑战，掌握构建高性能、高可伸缩性的并发应用所需的技能。 在资源内容中，我们将涵盖以下关键方面： 首先，我们将简要概述 JUC 库的重要性以及它在现代多核处理器环境中...
在现代软件开发中，多核处理器的普及使得并发编程成为开发者不可忽视的技能。Java 并发编程中的 JUC（java.util....深入理解和掌握 JUC 和 AQS，可以让开发者更好地应对多线程并发编程中的挑战，提高程序性能和稳定性。
Java并发编程最全面试题，包括并发编程基础知识、并发理论...本文档适用于将要参加Java开发相关岗位面试、或者想要提高Java并发编程相关技能的同学，更好的理解和掌握Java并发编程的相关知识，更好的应对面试机会和挑战
在进行并发编程时，如果希望通过多线程执行任务让程序运行得更快，会面临非常多的挑战，比如上下文切换的问题、死锁的问题，以及受限于硬件和软件的资源限制问题，本章会介绍几种并发编程的挑战以及解决方案。
它以并发编程和多线程技术为核心，致力于解决高性能处理的需求。无论是开发者、计算机专业学生，还是对高并发多线程技术感兴趣的初学者，都能从中获得丰富的知识和实践经验。 该代码适用于各种需要高并发、多线程...
1、时间片 2、并行一定更快吗 3、如何避免频繁的上下文切换
在进行并发编程时，如果希望通过多线程执行任务让程序运行的更快，会面临非常多的挑战，比如上下文切换的问题，死锁的问题，以及受限于硬件和软件的资源限制问题，本章会介绍几种并发编程的挑战，以及解决方案。
实战Java高并发程序设计课是一门针对Java开发者的培训课程，重点关注如何设计和优化高并发的程序。...这门课程旨在帮助开发者掌握并发编程的核心知识，提升程序性能和可靠性，应对高并发场景的挑战。 视频大小：5.6G
1.1上下文切换 1.1.1 多线程一定快吗 1.1.2 测试上下文切换次数和时长 1.1.3 如何减少上下文切换 1.1.4 减少上下文切换实战流程 1.2
一、并发编程的挑战 1.1 如何减少上下文切换 无锁并发编程：多线程竞争锁时，会引起上下文切换，所以多线程处理数据时，可以用一些办法来避免使用锁，如将数据的ID按照Hash算法取模分段，不同的线程处理不同段的数据...
并发编程的挑战 Java并发机制的底层原理 Java内存模型 Java并发编程基础 Java中的锁 Java并发容器和框架 Java中的13个原子操作类 Java中的并发工具类 Java中的线程池 Executor框架 Java并发编程实践