JUC笔记(上)-复习 涉及死锁 volatile synchronized CAS 原子操作

一、上下文切换

即使单核CPU也可以进行多线程执行代码，CPU会给每个线程分配CPU时间片来实现这个机制。时间片非常短，所以CPU会不断地切换线程执行，从而让我们感觉多个线程是同时执行的。时间片一般是十几毫秒(ms)。通过时间片分配算法执行。

二、多线程一定要快吗？

这跟我们CPU核数有一定的关系，当为单核处理器时。观看以下代码：

public class ConcurrencyTest {
private static final 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);
}
}

案例来自于Java并发编程的艺术。

在执行的次数不同时，串行和并行所执行的时间之间的大小之比是不同的。当循环次数较少时，串行要比并行更快一些。

三、如何减少上下文切换

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

无锁并发编程：多线程争抢锁时会触发上下文的切换，所以多线程处理数据，使用一些方法来避免使用到锁。

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

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

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

四、死锁

以下代码会产生死锁：

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();
}
}

避免死锁的几个常用的方法：

避免一个线程同时获得多个锁。

避免一个线程在锁内同时占用多个资源，尽量保证一个锁只占用一个资源。

尝试获取锁时，可以使用tryLock(timeout)来代替内部锁机制。

对于数据库锁，加锁和解锁必须在一个数据库连接内。

五、资源限制

什么是资源限制

资源限制是指在进行并发编程时，程序的执行速度受限于计算机硬件资源或软件资源。

例如，服务器的带宽只有2Mb/s，某个资源的下载速度是1Mb/s每秒，系统启动10个线程下载资

源，下载速度不会变成10Mb/s，所以在进行并发编程时，要考虑这些资源的限制。硬件资源限

制有带宽的上传/下载速度、硬盘读写速度和CPU的处理速度。软件资源限制有数据库的连接

数和socket连接数等。

如何解决资源限制的问题

对于硬件资源限制，可以考虑使用集群并行执行程序。既然单机的资源有限制，那么就让

程序在多机上运行。比如使用ODPS、Hadoop或者自己搭建服务器集群，不同的机器处理不同

的数据。可以通过“数据ID%机器数”，计算得到一个机器编号，然后由对应编号的机器处理这

笔数据。

对于软件资源限制，可以考虑使用资源池将资源复用。比如使用连接池将数据库和Socket

连接复用，或者在调用对方webservice接口获取数据时，只建立一个连接。

六、volatile的应用

先来看一下CPU常用术语。

volatile的原理：

七、synchronized的实现原理与应用

sync实现同步的基础：java中每个对象都可以作为锁。具体表现为以下三种：

        对于普通同步方法来说：锁的是当前实例对象。

        对于静态同步方法来说：锁的是当前类的Class对象。

        对于同步方法块来说：锁的是sync后括号里配置的对象。

7.1、Java对象头

sync用的锁是存放在Java对象头中的。

Java对象头里的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位。32位JVM

的Mark Word的默认存储结构如表：

Mark Word中存储的数据会随着锁标志位的变化而变化：

7.2、sync锁的升级与对比

sync锁一共有四个状态：无锁->偏向锁->轻量级锁->重量级锁。

锁只可以升级不可以降级。

偏向锁：

当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的MarkWord里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下MarkWord中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

偏向锁的获取和撤销流程

偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，

持有偏向锁的线程才会释放锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有正

在执行的字节码）。它会首先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，

如果线程不处于活动状态，则将对象头设置成无锁状态；如果线程仍然活着，拥有偏向锁的栈

会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向于其他

线程，要么恢复到无锁或者标记对象不适合作为偏向锁，最后唤醒暂停的线程。图2-1中的线

程1演示了偏向锁初始化的流程，线程2演示了偏向锁撤销的流程。

7.3、轻量级锁

(1)轻量级锁加锁
线程在执行同步块之前，JVIM会先在当前线程的栈桢中创建用于存储锁记录的空间，并
将对象头中的MarkWord复制到锁记录中，官方称为Displaced MarkWord。然后线程尝试使用
CAS将对象头中的MarkWord替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失
败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。
(2)轻量级锁解锁
轻量级解锁时，会使用原子的CAS操作将DisplacedMarkWord替换回到对象头，如果成
功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。图2-2是
两个线程同时争夺锁，导致锁膨胀的流程图。

·锁的优缺点

八、原子操作的实现原理

先来看一些相关的术语

有些处理器使用基于对缓存加锁或者总线加锁的方式来保证多处理器之间的原子操作。

1）使用总线锁来保证原子性。

处理器使用总线锁就是来解决这个问题的。所谓总线锁就是使用处理器提供的一个

LOCK＃信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该

处理器可以独占共享内存。

2）使用缓存锁来保证原子性

频繁使用的内存会缓存在处理器的L1、L2和L3高速缓存里，那么原子操作就可以直接在

处理器内部缓存中进行，并不需要声明总线锁，所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存 行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声言LOCK＃信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子

性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处

理器回写已被锁定的缓存行的数据时，会使缓存行无效。

但是有两种情况处理器不会使用缓存锁定。

第一种情况是：当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行

（cache line）时，则处理器会调用总线锁定。

第二种情况是：有些处理器不支持缓存锁定。对于Intel 486和Pentium处理器，就算锁定的

内存区域在处理器的缓存行中也会调用总线锁定。

九、Java如何实现原子操作

中Java中可以使用锁和循环CAS来实现原子操作。

以下是使用循环CAS实现线程安全的操作。

private AtomicInteger atomicI = new AtomicInteger(0);
private int i = 0;
public static void main(String[] args) {
final Counter cas = new Counter();
List<Thread> ts = new ArrayList<Thread>(600);
long start = System.currentTimeMillis();
for (int j = 0; j < 100; j++) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
cas.count();
cas.safeCount();
}
}
});
ts.add(t);
}
for (Thread t : ts) {
t.start();
}
// 等待所有线程执行完成
for (Thread t : ts) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(cas.i);
System.out.println(cas.atomicI.get());
System.out.println(System.currentTimeMillis() - start);
}
/** * 使用CAS实现线程安全计数器 */
private void safeCount() {
for (;;) {
int i = atomicI.get();
boolean suc = atomicI.compareAndSet(i, ++i);
if (suc) {
break;
}
}
}
/**
* 非线程安全计数器
*/
private void count() {
i++;
}
}

 JDK的并发包里提供了一些类来支持原子操作，如AtomicBoolean（用原子 方式更新的boolean值）、AtomicInteger（用原子方式更新的int值）和AtomicLong（用原子方式更 新的long值）。这些原子包装类还提供了有用的工具方法，比如以原子的方式将当前值自增1和 自减1。 

CAS实现原子操作的三大问题：

ABA问题。

循环时间长开销大。

只能保证一个共享变量的原子操作。