并发编程学习笔记

进程与线程

并行与并发

• 并发是同一时间应对（dealing with）多件事情的能力

• 并行是同一时间动手做（doing）多件事情的能力

同步与异步

• 需要等待结果返回 ，才能继续运行就是同步

• 不需要等待结果返回 ，就能继续运行就是异步

JAVA线程

创建和运行线程

1. 继承 Thread ，重写 run 方法。

2. 实现 Runnable 接口，重写 run 方法

3. 使用 FutureTask 方式（ 间接实现了 Runnable 接口 ）

public class Test {
    public static class CallerTask implements Callable<String> {
        @Override
        public String call() throws Exception {
            //do some work here
            return null;
        }
    }
    public static void main(String[] args) {
        FutureTask<String> futureTask=new FutureTask<>(new CallerTask());
        new Thread(futureTask).start();
        try {
            String result=futureTask.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 继承的方式可以更好的传递参数，可以在子类中添加成员变量，继承了Thread后不能再继承其他的类。

• 实现Runnable接口的方式只能使用主线程里面被声明为final的变量，但是可以做到任务和代码的分离。

• 前两者都不能拿到任务的返回值，但是FutureTask可以。

查看进程的方法

• tasklist可以查看线程

• taskkill可以杀死线程

• jps 命令查看所有 Java 进程

• jstack <PID> 查看某个 Java 进程（PID）的所有线程状态

• ps -fe 查看所有进程

• ps -fT -p <PID> 查看某个进程（PID）的所有线程

• kill 杀死进程 top 按大写 H 切换是否显示线程

• top -H -p <PID> 查看某个进程（PID）的所有线程

线程运行的原理

• 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

• 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

理解上下文切换

• 当前线程的CPU时间片使用完处于就绪状态时

• 当前线程被其他线程中断时。

• 垃圾回收

方法解析

start() vs run()

join

wait()

1. 其他线程调用了该共享对象的notify()或者notifyall()方法。

2. 其他线程调用了该线程的interrupt()方法。

synchronized (obj){
    while (条件不满足) {
        obj.wait();
    }
}

wait(long timeout)

notify()

notifyAll()

线程中断

• void interrupt()中断线程。当线程A运行时，线程B调用了A的interrupt()方法，那么线程A的中断标志会被设置为true，此时A并没有被中断，会继续往下执行。

• boolean isInterrupted()检测 线程 是否被中断，如果是返回true，否则返回false。

• boolean interrupted()检测当前线程是否被中断，如果是返回true，否则返回false。与boolean isInterrupted()不同的是，该方法如果发现当前线程被中断，则会清除中断标志。

Thread.interrupted();
anotherThread.interrupted();
interrupted()

守护线程和用户线程

• 1️⃣daemon线程（守护线程）

• 2️⃣user线程（用户线程）。

Thread daemonThread=new Thread(new Runnable() {
    @Override
    public void run() {
    }
});
daemonThread.setDaemon(true);

线程的状态

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}
//Thread中的State

• NEW 代表线程创建成功但是尚未启动（还没有执行start方法）。Q：能否重复调用start方法？A：不能。在第一次调用start方法后，线程内部的threadStatus的值就会改变，再次调用会抛出异常。

• RUNNABLE 表示当前线程正在运行中。处于RUNNABLE状态的线程在Java虚拟机中运行，也有可能在等待其他系统资源。

• BLOCKED 阻塞状态。处于BLOCKED状态的线程正等待锁的释放以进入同步区。

• WAITING 等待状态。处于等待状态的线程变成RUNNABLE状态需要其他线程唤醒。如下三个方法会使线程进入等待状态
1. Object.wait()：使当前线程处于等待状态直到另一个线程唤醒它；
2. Thread.join()：等待线程执行完毕，底层调用的是Object实例的wait方法；
3. LockSupport.park()：除非获得调用许可，否则禁用当前线程进行线程调度。

• TIMED_WAITING 超时等待状态。线程等待一个具体的时间，时间到后会被自动唤醒。调用如下方法会使线程进入超时等待状态：
1. Thread.sleep(long millis)：使当前线程睡眠指定时间；
2. Object.wait(long timeout)：线程休眠指定时间，等待期间可以通过notify()/notifyAll()唤醒；
3. Thread.join(long millis)：等待当前线程最多执行millis毫秒，如果millis为0，则会一直执行；
4. LockSupport.parkNanos(long nanos)： 除非获得调用许可，否则禁用当前线程进行线程调度指定时间；
5. LockSupport.parkUntil(long deadline)：同上，也是禁止线程进行调度指定时间；

• TERMINATED 终止状态。此时线程已执行完毕。

共享模型之管程

并发带来的安全隐患

synchronized

用法

synchronized void method() {
  //业务代码
}

synchronized static void method() {
//业务代码
}

synchronized(this) {
  //业务代码
}

• synchronized 关键字加到 static 静态方法和 synchronized(class) 代码块上都是是给 Class 类上锁。

• synchronized 关键字加到实例方法上是给对象实例上锁。

• 尽量不要使用 synchronized(String a) 因为 JVM 中，字符串常量池具有缓存功能！

原理

JAVA对象头

MarkWord

Monitor

1. 如图 Thread-2 首先进入了临界区代码， MarkWord 与 obj 关联， Thread-2 成为了 Monitor 的Owner。

2. Thread-1 和 Thread-3 相继进入临界区代码，都发现Owner已经有人，则会加入 Monitor 的EntryList中阻塞。

3. Thread-2 离开后阻塞的线程重新 非公平 竞争。

升级机制

• 当锁对象调用了hashcode方法时，会撤销偏向锁（因为MarkWord里需要空间存hashcode）

• 轻量级锁的hashcode存在线程栈桢的锁记录里

• 重量级锁会存在monitor对象里

• 偏向锁默认是延迟的，程序开启几秒后才会生效，可以设置参数来禁用延迟。

• 偏向锁也可以被禁用，禁用的原因可以是因为 在竞争状态下，偏向锁十分累赘 。

Q：为什么偏向锁在竞争状态下十分累赘呢？ A：偏向锁升级为轻量级锁时会执行如下操作 1.停止所有拥有锁的线程遍历线程栈 2.一个个修复所记录和MarkWord唤醒 这些操作开销很大。

• 如果没有升级锁，则成功把原来改变的东西还回去

• 如果升级了，这时 MarkWord指向的是Monitor对象 那么CAS失败，进入重量级锁的流程

批量重偏向

批量撤销

锁消除

wait notify

• obj.wait() 让进入 object 监视器的线程到 waitSet 等待

• obj.notify() 在 object 上正在 waitSet 等待的线程中挑一个唤醒

• obj.notifyAll() 让 object 上正在 waitSet 等待的线程全部唤醒

• wait() 方法会释放对象的锁，进入 WaitSet 等待区，从而让其他线程就机会获取对象的锁。无限制等待，直到被notify 为止

• wait(long n) 有时限的等待, 到 n 毫秒后结束等待，或是未到等待时间被 notify

虚假唤醒

synchronized (obj){
    while (条件不满足) {
        obj.wait();
    }
}

Park Unpark

不同

• wait，notify 和 notifyAll 必须配合 Object Monitor 一起使用，而 park，unpark 不必

• park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而 notify 只能随机唤醒一个等待线程，notifyAll 是唤醒所有等待线程，就不那么【精确】

• park & unpark 可以先unpark，而 wait & notify 不能先 notify

原理

• park() 方法会进行如下步骤
1. 检查_counter是否为1，如果是，继续线程不会wait。
2. 如果为0，获得_mutex互斥锁
3. 线程进入_mutex互斥锁的等待队列_cond
4. 无论wait与否，都要将_counter设置为0

• unpark() 会进行如下步骤
1. 设置_counter为1（如果线程没有wait则不会执行接下来的操作）
2. 唤醒线程
3. 设置_counter为0

线程问题

线程死锁

• 互斥条件即资源同时只由一个线程占用。如果线程请求一个已经被占用的资源，则请求者只能等待该资源被释放。

• 请求并持有指至少持有了一个资源的线程请求了一个被占有的新资源，则该线程会被阻塞，同时不释放自己已经持有的资源。

• 不可剥夺被使用的资源在使用完之前不能被其他线程抢占。

• 环路等待指在发生死锁时，必然存在一个线程→资源的环形链。

如何避免线程死锁

• 请求并持有

• 环路等待条件

资源申请的有序性原装则 :指假如线程A和线程B都需要资源1,2,3,...,n时，对资源进行排序，线程A和线程B只有在获取了资源n-1时才能去获取资源n。

线程活锁

线程饥饿

ReentrantLock

对比synchronized

• 可中断

• 可以设置超时时间

• 可以设置为公平锁

• 支持多个条件变量

基本语法

//获得锁
reentrantLock.lock(); try {
// 临界区
} finally { // 释放锁
reentrantLock.unlock(); }

可中断

• 如果没有竞争，那么获得锁，就像 lock 一样。

• 如果有竞争，进入阻塞队列。并且可以被打断。

公平锁

public ReentrantLock(boolean fair){
    sync = fair ? new FairSync() : new NonfairSync();
}

条件变量(Condition)

static ReentrantLock lock = new ReentrantLock();
static Condition waitCigaretteQueue = lock.newCondition();
static Condition waitbreakfastQueue = lock.newCondition();
static volatile boolean hasCigrette = false;
static volatile boolean hasBreakfast = false;

public static void main(String[] args) throws InterruptedException {
    new Thread(() -> {
        try {
            lock.lock();
            while (!hasCigrette) {
                try {
                    waitCigaretteQueue.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("等到了它的烟");
        } finally {
            lock.unlock();
        }
    }).start();
    new Thread(() -> {
        try {
            lock.lock();
            while (!hasBreakfast) {
                try {
                    waitbreakfastQueue.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("等到了它的早餐");
        } finally {
            lock.unlock();
        }
    }).start();
    sleep(1);
    sendBreakfast();
    sleep(1);
    sendCigarette();
}

private static void sendBreakfast() {
    lock.lock();
    try {
        System.out.println("送早餐来了");
        hasBreakfast = true;
        waitbreakfastQueue.signal();
    } finally {
        lock.unlock();
    }
}

private static void sendCigarette() {
    lock.lock();
    try {
        System.out.println("送烟来了");
        hasCigrette = true;
        waitCigaretteQueue.signal();
    } finally {
        lock.unlock();
    }
}

共享模型之内存

可见性

volatile 可以保证可见性，但是却 无法保证原子性 synchronized 可以保证可见性和原子性，但是属于重量级操作，性能低

重排序

• 编译器优化重排编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。

• 指令并行重排现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性(即后一个执行的语句无需依赖前面执行的语句的结果)，处理器可以改变语句对应的机器指令的执行顺序。

• 内存系统重排由于处理器使用缓存和读写缓存冲区，这使得加载(load)和存储(store)操作看上去可能是在乱序执行，因为三级缓存的存在，导致内存与缓存的数据同步存在时间差。

重排序的问题

int num = 0;

// volatile 修饰的变量，可以禁用指令重排 volatile boolean ready = false; 
// 可以防止变量之前的代码被重排序
boolean ready = false; 

// 线程1 执行此方法
public void actor1(I_Result r) {
     if(ready) {
        r.r1 = num + num;
     } 
     else {
        r.r1 = 1;
     }
}
// 线程2 执行此方法
public void actor2(I_Result r) {
     num = 2;
     ready = true;
}

禁止重排序

volatile

原理

• 对 volatile 变量的写指令后会加入写屏障。(保证写屏障之前的写操作, 都能同步到主存中)

• 对 volatile 变量的读指令前会加入读屏障。(保证读屏障之后的读操作, 都能读到主存的数据)

保证可见性

• 当一个线程对volatile修饰的变量进行写操作时，JMM会立即把该线程对应的本地内存中的共享变量的值刷新到主内存；

• 当一个线程对volatile修饰的变量进行读操作时，JMM会把立即该线程对应的本地内存置为无效，从主内存中读取共享变量的值。

禁止指令重排序

volatile不能解决原子性问题

共享模型之无锁

CAS（compaer and swap/set）

与volatile的关系

为什么使用CAS的无锁情况效率更高呢？

CAS的特点

• CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系。

• synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。

• CAS 体现的是无锁并发、无阻塞并发。

JUC工具包

原子整数

• AtomicBoolean

• AtomicInteger

• AtomicLong

AtomicInteger i = new AtomicInteger(0);
// 获取并自增（i = 0, 结果 i = 1, 返回 0），类似于 i++ 
    System.out.println(i.getAndIncrement());
// 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i 
    System.out.println(i.incrementAndGet());
// 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i 
    System.out.println(i.decrementAndGet());
// 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
    System.out.println(i.getAndDecrement());
// 获取并加值（i = 0, 结果 i = 5, 返回 0） 
    System.out.println(i.getAndAdd(5));
// 加值并获取（i = 5, 结果 i = 0, 返回 0） 
    System.out.println(i.addAndGet(-5));
// 获取并更新（i = 1, p 为 i 的当前值, 结果 i = 2, 返回 1） // 其中函数中的操作能保证原子，但函数需要无副作用 
    System.out.println(i.getAndUpdate(p -> p * 2));
// 更新并获取（i = 2, p 为 i 的当前值, 结果 i = 4, 返回 4） // 其中函数中的操作能保证原子，但函数需要无副作用 
    System.out.println(i.updateAndGet(p -> p * 2));
// 获取并计算（i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0） 
// 其中函数中的操作能保证原子，但函数需要无副作用 
// getAndUpdate 如果在 lambda 中引用了外部的局部变量，要保证该局部变量是 final 的 
// getAndAccumulate 可以通过 参数1 来引用外部的局部变量，但因为其不在 lambda 中因此不必是 final 
    System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
// 计算并获取（i = 10, p 为 i 的当前值, x 为参数1, 结果 i = 0, 返回 0） 
// 其中函数中的操作能保证原子，但函数需要无副作用 
    System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));

while(true){
    int prev=i.get();
    int next=prev*10;
    if(i.compareAndSet(prev,next)){
        break;
    }
}

原子引用

• AtomicReference

• AtomicMarkableReference

• AtomicStampedReference

ABA问题

1. 为共享变量加上版本号，每次被修改就+1。AtomicStampedReference 可以完成。

static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
public static void main(String[] args) throws InterruptedException { 
    log.debug("main start..."); 
    // 获取值 A 
    String prev = ref.getReference(); 
    // 获取版本号 
    int stamp = ref.getStamp(); 
    log.debug("版本 {}", stamp); 
    // 如果中间有其它线程干扰，发生了 ABA 现象 
    other(); 
    sleep(1);
    // 尝试改为 C 
    log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
}
private static void other() { 
    new Thread(() -> { 
        log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B", 
                                                        ref.getStamp(), ref.getStamp() + 1));
        log.debug("更新版本为 {}", ref.getStamp());
}, "t1").start(); 
    sleep(0.5); 
    new Thread(() -> { 
        log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A", 
                                                        ref.getStamp(), ref.getStamp() + 1));
        log.debug("更新版本为 {}", ref.getStamp()); 
    }, "t2").start(); }

15:41:34.891 c.Test36 [main] - main start... 
15:41:34.894 c.Test36 [main] - 版本 0 
15:41:34.956 c.Test36 [t1] - change A->B true 
15:41:34.956 c.Test36 [t1] - 更新版本为 1 
15:41:35.457 c.Test36 [t2] - change B->A true 
15:41:35.457 c.Test36 [t2] - 更新版本为 2 
15:41:36.457 c.Test36 [main] - change A->C false

2. 当我们只关心有没有被更改过时，并不关心更改了几次时，就不需要版本号了。使用一个Boolean来代替版本号。AtomicMarkableReference 可以完成。

原子数组

• AtomicIntegerArray

• AtomicLongArray

• AtomicReferenceArray

字段更新器

• AtomicReferenceFieldUpdater // 域 字段

• AtomicIntegerFieldUpdater

• AtomicLongFieldUpdater

原子累加器

• DoubleAccumulator

• DoubleAdder

• LongAccumulator

• LongAdder

• 将竞争的数据进行分解成多个单元，在每个单元中分别进行数据处理。

• 各单元处理完成之后，通过Hash算法进行计算求和，从而得到最终的结果。

• Thread-0累加Cell[0]而Thread-1累加Cell[1]…最后将结果汇总，减少了失败自旋，从而提升性能。

Unsafe对象

共享模型之不可变