并发编的挑战

上下文切换（并行不一定比串行快）

时间片是CPU分配给各个线程的时间，一般是几十毫秒。因为时间片非常短，所以CPU通过不停地切换线程执行，达到多个线程同时执行的效果

CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换

减少上下文切换的方法有无锁并发编程、CAS算法、使用最少线程和使用协程

无锁并发编程：如将数据的ID按照Hash算法取模分段，不同的线程处理不同的段的数据

CAS算法：Java的Atomic包使用CAS算法来更新数据，而不需要加锁

使用最少线程：避免创建不需要的线程

协程：在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换

死锁

锁是个非常有用的工具，运用场景非常多。但同时它也会带来一些困扰，那就是可能会引起死锁，一旦产生死锁，就会造成系统功能不可用。

避免死锁的常用方法

• 避免一个线程同时获取多个锁
• 避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源
• 尝试使用定向锁，使用lock.tryLock(timeout)来替代使用内部锁机制
• 对于数据库锁，加锁和解锁必现在一个数据库连接池里，否则会出现解锁失败的现象

资源限制

资源限制是指在进行并发编程时，程序的执行速度受限于计算机硬件或软件资源。硬件资源限制有带宽的上传/下载速度、硬盘读写速度和CPU处理速度。软件资源限制有数据库的连接数和socket连接数等。
对于硬件资源限制，可以考虑使用集群并行执行程序。对于软件资源限制，可以考虑使用资源池将资源复用。需要根据不同的资源限制调整程序的并发度

Java内存模型

Java的并发采用的是共享内存模型，Java线程之间的通讯总是隐式进行，整个通信过程对程序员完全透明。Java线程之间的通信由Java内存模型（JMM）控制，JMM决定一个线程对共享变量的写入核实对另一个线程可见

1. 线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接在主内存中读写

2. 不同线程之间无法直接访问其他线程工作内存中的变量，线程间变量值的传递需要通过主内存来完成。

3. 线程1对共享变量的修改，要想被线程2及时看到，必须经过如下2个过程：

   把工作内存1中更新过的共享变量刷新到主内存中

   将主内存中最新的共享变量的值更新到工作内存2中

可见性、原子性、重排序

可见性：一个线程对共享变量的修改，更够及时的被其他线程看到

原子性：即不可再分了，不能分为多步操作。比如赋值或者return。比如"a = 1;"和 "return a;"这样的操作都具有原子性。类似"a += b"这样的操作不具有原子性，在某些JVM中"a += b"可能要经过这样三个步骤：

1. 取出a和b
2. 计算a+b
3. 将计算结果写入内存

重排序：重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段

Volatile

volatile是轻量级的synchronized，它在多处理器开发中保证了共享变量的“可见性”

Volatile实现内存可见性是通过store和load指令完成的；也就是对volatile变量执行写操作时，会在写操作后加入一条store指令，即强迫线程将最新的值刷新到主内存中；而在读操作时，会加入一条load指令，即强迫从主内存中读入变量的值。但volatile不保证volatile变量的原子性。

class MyThread extends Thread {             
   private volatile boolean isStop = false;          
   public void run() {      
       while (!isStop) {      
           System.out.println("do something");      
       }      
   }      
   public void setStop() {      
       isStop = true;      
   }            
}    

线程执行run()的时候我们需要在线程中不停的做一些事情，比如while循环，那么这时候该如何停止线程呢？如果线程做的事情不是耗时的，那么只需要使用一个标志即可。如果需要退出时，调用setStop()即可。这里就使用了关键字volatile，这个关键字的目的是如果修改了isStop的值，那么在while循环中可以立即读取到修改后的值

Synchronized

原理

Synchronized在JVM的实现原理，主要是使用了monitorenter和monitorexit指令实现。monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证整个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个monitor与之关联，当且有一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁

synchronized用的锁是存在Java对象头里面的。Java对象头里的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位。在运行期间，Mark Word里存储的数据会随着锁标志位的变化而变化
锁的状态总共有四种：无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁（但是锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级）。JDK 1.6中默认是开启偏向锁和轻量级锁的，我们也可以通过-XX:-UseBiasedLocking来禁用偏向锁

锁	定义	优点	缺点	适用场景
偏向锁	偏向锁，顾名思义，它会偏向于第一个访问锁的线程，如果在接下来的运行过程中，该锁没有被其他的线程访问，则持有偏向锁的线程将永远不需要触发同步。如果在运行过程中，遇到了其他线程抢占锁，则持有偏向锁的线程会被挂起，JVM会尝试消除它身上的偏向锁，将锁恢复到标准的轻量级锁。	加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距。	如果线程间存在锁竞争，会带来额外的锁撤销的消耗。	适用于只有一个线程访问同步块场景。
轻量级锁	线程的阻塞和唤醒需要CPU从用户态转为核心态，频繁的阻塞和唤醒对CPU来说是一件负担很重的工作。同时我们可以发现，很多对象锁的锁定状态只会持续很短的一段时间，例如整数的自加操作，在很短的时间内阻塞并唤醒线程显然不值得，为此引入了自旋锁	竞争的线程不会阻塞，提高了程序的响应速度。	如果始终得不到锁竞争的线程使用自旋会消耗CPU。	追求响应时间。同步块执行速度非常快。
重量级锁	重量锁在JVM中又叫对象监视器（Monitor），它很像C中的Mutex，除了具备Mutex互斥的功能，它还负责实现了Semaphore的功能，也就是说它至少包含一个竞争锁的队列，和一个信号阻塞队列（wait队列），前者负责做互斥，后一个用于做线程同步	线程竞争不使用自旋，不会消耗CPU。	线程阻塞，响应时间缓慢。	追求吞吐量。同步块执行速度较长。

用法

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

• 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
• 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
• 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
• synchronized关键字不能继承

Synchronized和Volatile的比较

1. Synchronized保证内存可见性和操作的原子性
2. Volatile只能保证内存可见性
3. Volatile不需要加锁，比Synchronized更轻量级，并不会阻塞线程（volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。）
4. volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化（如编译器重排序的优化）.
5. volatile是变量修饰符，仅能用于变量，而synchronized是一个方法或块的修饰符。

参考资料

《Java并发编程的艺术》

内存可见性和原子性：Synchronized和Volatile的比较

Java中Synchronized的用法