Java并发-1

进程

进程是操作系统进行资源资源分配的单位，进程中包含若干线程

线程

线程是CPU进行调度和执行的基本单位

方法区 堆 虚拟机栈 本地方法栈 程序计数器

每个线程拥有自己的栈和PC

多个线程共享方法去和堆

并行和并发

并行

单位时间内，任务同时执行

并发

在一定时间内，任务都执行了

并行是一起执行。并发是宏观上一起执行的，实际上是CPU时间片的轮询

创建线程的方式

继承Thread

继承thread

重写run方法

没有返回值

实现Runnable

重写run方法

没有返回值

相对于继承thread。更新灵活，避免了单继承的局限性

实现Callable

实现callable接口

重写call方法，此方法带有返回值，且有抛出异常

thread构造器无法直接传入，需要通过Runnable的子类，futureTask进行传入

获取数据时，使用futureTask.get()方法获取。此方法是阻塞的

总结

继承thread，每启动一个线程，都是一个新的资源类,不能使用内部非静态变量作为锁。实现Runnable，避免了单继承，多个线程可以共享一个资源类，在使用时，只能使用主线程被final修饰的变量。

Thread线程只能调用一次start()。多次会抛出异常

run()方法的调用是在start0()里面调用的是，是本地native c++方法

线程的生命周期

新建

初始化状态，线程被构建，但是还没有调用start()方法

运行

运行状态，运行状态包含运行态和就绪态。

阻塞

阻塞状态，表示线程阻塞于锁

等待

等待状态，，表示线程进入了等待状态，进入改状态的线程需要等待其他线程通知或中断

超时等待

超时等待，她可以在指定时间后，自行返回

销毁

终止状态，表示当前线程已经执行完毕

线程创建之后处于新建态，调用start()之后处于ready(可运行态)，线程获取到了cpu时间片后处于running（运行态）。

调用sleep方法后，线程会进入阻塞态，sleep结束后，恢复到ready，等待cpu时间片的调用

一个java程序启动，至少包含2个线程 ，一个main线程，一个gc线程

守护线程

//设置为守护线程
setDaemon(true);
如果用户线程结束了，守护线程也会结束

join方法

join方法底层是wait()方法，调用join方法后，调用者就会被阻塞。直到线程运行完后，调用者所在的线程才会继续执行

yield方法

使当前线程由运行态--进入到就绪态 （Ready）。交互cpu时间片

并发编程中的三个问题

可见性

可加性：是指一个线程对共享变量进行修改，其他线程可立即得到修改后的值

案例：

假设新开一个线程，线程里面操作资源类的内容变更，主线程采用while循环判断内容是否更改（采用while可以避免虚假唤醒）。

未加volatile关键字修饰变量。则会一直循环，因为其他线程无法感知到内容实际已修改，即未从工作内存同步到主存中。

使用volatile关键字后，如果变量被线程修改，其他线程可感知到，则案例死循环将终止。

volatile可以保证内存可见性，不能保证原子性。可以防止指令重排

原子性

原子性：在一次或多次操作中，要么操作全部成功，要么全部失败。不会存在中间状态。

解决原子性方案：synchronized 、 cas原子类工具、lock锁机制

synchronized 、AtomicInteger、【lock.lock、lock.unlock】

有序性

有序性：指的是程序中代码的执行顺序，Java在编译和运行时会对代码进行优化（指令重排）来加快程序的速度，但是这样会导致程序的执行顺序和我们编写的代码顺序不同。在并发下，就会产生问题。

初始化一个对象
instance=new Demo();  是被分为三部分
memory=allocate(); 分配内存空间   步骤1
instance(memory) 初始化对象       步骤2
instance=memory； 设置instance指向刚刚分配的内存空间地址。此时instance！=null   步骤3

步骤2和3不存在依赖关系，是否发送重排，单线程下，结果都一样。但是如果步骤3在步骤2前，这个时候instance不为null，但实际初始化工作还没有完成。就会返回一个null的getInstance。这时候数据就出现了问题。

解决方案，加volatile，防止指令重排

CAS

• CAS：cas是比较并交换compareAndSet，是一条CPU并发原语，功能是判断内存某个位置的值是否为预期值，如果是则更新为新的值，这个过程是原子性的。

• 采用Cas+volatile可以保证内存可见性、防止指令重排、以及原子性。解决了并发问题。

• cas底层原理：

• 调用Unsafe类中的Cas方法，jvm帮我们是先出cas汇编指令，它是依赖于硬件的功能，通过她实现原子操作，Cas是CPU的一条原子指令。

• cas的思想就是乐观锁的思想.。java中，采用while循环进行自旋，尝试获取锁或者满足期望值。

CAS三大问题

• 如果cas长时间不成功，会给cpu带来开销，java中，是采用while进行一直循环的
• 只能保证一个共享变量的原子性
• 存在ABA问题

ABA问题

ABA问题指的就是，初始化值为A，如果线程1修改A为B。然后线程2修改A值为C。但是线程1修改成功后，又将B修改为了A。此时，线程2去修改，发现原来的值还是A，她就认为数据没有被修改过，然后就将A修改为了C。但是实际情况，A是被修改过后的，并不是原来默认的A了。

解决方案

增加版本号。通过版本号机制，每次修改，都将版本号+1，修改时，判断版本号是否和自己获取前的一致，一致则修改，否则修改失败。

java juc下的AtomicStampedReference类就是ABA的一种解决方案。

只能保证一个共享变量的原子性

java中采用AtomicReference、AtomicStampedReference 原子引用来保证引用对象之间的原子性

Synchronized优化

synchronized可以同时保证可见性，有序性，原子性

锁消除

锁消除是JIT编译器对synchronized做的优化，在编译的时候，jit通过逃逸分析技术，来分析synchronized锁对象，判断她是不是只可能被一个线程来加锁，没有其他线程来竞争加锁，这个时候编译就不加入monitorenter和monitorexit的指令。仅仅一个线程争用锁的时候，就可以消除这个锁了，提示了代码的执行效率，因为只有一个线程来加锁，就不会涉及到锁的竞争

锁粗化

synchronized(this) { 

}
synchronized(this) {

}
synchronized(this) {

}
----------------------------------------------------
   最终会优化成一个
   synchronized(this) {

}

锁粗化的意思是，如果JIT编译器发现了代码中连续多次加锁释放锁的代码，会结合成一个锁，这就是锁粗化，避免多次加锁释放锁的开销

偏向锁（我偏心）

monitorenter和monitorexit是要使用CAS操作加锁和释放锁的，开销较大。因此，如果发现大概率只有一个线程会主要竞争一个锁，那么就会给这个锁一个偏好，后面她加锁和释放锁，都基于偏好来执行，不需要通过cas，性能会有提升。但是如果有偏好之外的线程来竞争锁，就会回收之前的偏好，但是其他线程来竞争锁的记录交小。

轻量级锁

如果偏向锁没有成功，说明锁的竞争很激烈。那么这个时候就会尝试采用轻量级锁来加锁，就是将对象头的MarkWord里面有一个轻量级锁的指针，尝试指向持有锁的线程，然后判断一下是不是自己加的锁，如果是自己加的锁，那就指向代码。如果不是自己加的锁，那就是加锁失败，说明以及有其他人加锁了，这个时候就会升级为重量级锁

适应性锁

JIT编译器的优化，如果每个线程持有锁的时间非常短，那么一个线程获取不到锁，就会暂停，发生上下文切换，让其他线程来执行，但其他线程很快就释放了锁，然后唤醒暂停的线程，加入锁的竞争，这样线程会频繁的上下文切换，导致开销过大。针对这种情况，可以采用忙等策略，线程没有获取到锁，就进入while循环不停等待，不会暂停发生上下文切换，等到机会获取到锁继续执行就好了。