Contents

1. JMM
2. 可见性问题
3. 并发关键字
1. 3.1. synchronized:
2. 3.2. volatile关键字
4. java重排序：
5. happens-before原则：
6. CAS（Compare and Swap）技术
7. 创建线程的3种方式(Thread和Callable接口有返回值)
1. 7.1. 3种方式的比较
8. 经典面试题：
9. Thread的一些常见方法

干货参考：

概括类的总结：
http://blog.csdn.net/Thousa_Ho/article/details/77131074
15个并发编程的问题
http://ifeve.com/15-java-faq/
非常好的一个系列，有讲解和说明并发的原则
http://ifeve.com/java-concurrency-thread-directory/
大厂面试题并发相关
http://blog.csdn.net/xiaole0313/article/details/62056612

JMM

java内存模型
https://www.zhihu.com/search?type=content&q=java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B

java内存模型：每个线程操作数据是把对象拷贝到本地内存然进行操作，最后写回到主内存当中，不同线程之间不可见。
JMM为了防止重排序引发问题，保证了happens-before法则，这些法则是不会被重排序打乱的。
java的原子性：一个操作是原子操作，那么我们称它具有原子性，JDK1.5后再JUC包下有AotmicInteger来简化并发的原子操作，读取操作复查写入的一个过程。多了一个可见性的复查过程避免线程不安全。unsafe类提供本地方法直接操作内存，从硬件方面实现原子性。

可见性问题

基于java的内存模型，不同线程操作相同变量的时候，因为线程之间不可见，会导致可见性问题。

举例：
主内存中有变量count=100（比如某个对象的成员变量为count是100），现在多个线程去消费这个对象的count。
线程A读取count=100，进行了count消费一个，修改本地内存为99，这个时候并不会直接写回到主内存当中，此时线程B去主内存中读取并消费count，最后线程A结束，写回count为99到主内存，线程B结束的时候，也写回99到主内存，因为可见性问题，导致count被消费2次，但是总量只减少了1。
解决方案（volatile关键字、synchronized、final）

synchronized可以保证线程安全，但是效率低
volatile不能保证线程安全，但是可以缓解线程不可见的问题，比如A消费了count从100到99的时候，会立刻把count写回到主内存，如果B线程这个时候去取count这个对象，取到的就是99，而不是100。
final关键字编译的时候就必须赋值，相当于常量，可以避免线程安全问题，但是运用的场景有限，一旦赋值不允许修改。

并发关键字

synchronized:

锁普通方法和锁this的代码块，都是对象锁，锁静态方法和Test.class是类锁。
有锁方法和无锁方法互相不影响
类锁和对象锁互相不影响
volatile关键字
公用的对象存放在主内存当中，每个线程去处理公用对象的时候会拷贝镜像到本地内存当中，在CPU进行读取，修改，写回到本地内存，最后写回到主内存当中，这时候线程之间不可见。volatile关键字会让读取和写的操作的时候，会立刻通知更新主内存同步，并不保证线程安全。

轻量级的同步机制，实现变量的改变对所有线程可见，并不能避免线程安全
每次读的时候去读主存上的值而不是本地栈中的值，每次写都写到主存当中
该方法中禁止指令重排序优化

java重排序：

编译期：编译器在编译的时候可能会打乱没有依赖关系的代码的编译顺序
CPU执行指令：执行不能保证编译的顺序，且有时候会并发的执行
写入主内存时期：不能保证寄存器写会主内存的顺序是按照代码写的那样
证明java的重排序
注意只有当多个线程的时候才会出现这种情况，单线程一定不会出现这种情况，因为存在线程切换的时候，寄存器未写入到主内存当中，才会这样。

循环输出的话，会出现 a:1,x:0,b:1),y:0) 的情况的出现，可以证明。
因为不存在重排序的话，

如果先执行one线程，则a=1，y一定等于1；
如果先执行other线程的话，则b=1，导致x一定等于1
所以不存在 x和y同时为0的情况发生
除非重排序，先执行x=b=0的时候，再切换线程y=a=0，的时候才会出现这种情况

public class Test {
	static int x = 0, y = 0;
	static int a = 0, b = 0;
	public static void main(String[] args) throws InterruptedException {
	    while(true){
	    	x=y=a=b=0;
	    	test();
	    }
	}
	
	public static void test() throws InterruptedException{
		Thread one = new Thread(new Runnable() {
	        public void run() {
	            a = 1;
	            x = b;
	        }
	    });
	    Thread other = new Thread(new Runnable() {
	        public void run() {
	            b = 1;
	            y = a;
	        }
	    });
	    one.start();other.start();
	    one.join();other.join();
	    if(x+y==0){
	    	System.out.println("a:" + a +",x:" + x + ",b:" + b +")"+ ",y:" + y +")");
	    }
	}
}

happens-before原则：

7个场景总结：

子线程.start()
子线程.join()
volatile
lock
传递性
初始化
单一线程前后性

Each action in a thread happens-before every subsequent action in that thread.
在一个线程当中先执行的代码结果对随后进行的代码可见。（废话，一个线程公用一个本地缓存)
An unlock on a monitor happens-before every subsequent lock on that monitor
对一个监视器进行解锁时的所有操作，对下一个锁的代码是可见的，比如在线程A中改了共有变量n的值，现在线程B获取了相同的锁，它是可以看见改变后n的值的。
A write to a volatile field happens-before every subsequent read of that volatile.
A改了一个volatile的值，对接下来的所有的读取该变量值的线程可见
A可见于B B可见于C，那么A的所有操作也可见于C
start规则：如果线程A执行线程B的start方法，那么线程A的ThreadB.start()happens-before于线程B的任意操作
A执行的操作之后再启动B线程，则A线程之前改过的值对B可见
static int index=1；
index++；
new Thread(new runnable(){
public void run(){
system.out.println(index);
}
}).start();
join规则：如果线程A执行线程B的join方法，那么线程B的任意操作happens-before于线程A从TreadB.join()方法成功返回
main(){
t1.start()
t1.join()
ti修改过的变量对main线程可见
}
对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

CAS（Compare and Swap）技术

乐观锁策略，就是调用本地方法操作内存，实现比较成功就swap的原子性的一个操作。
运用在AotimcInteger包的getAndIncrement方法里。
synchronized其实就是悲观锁，涉及并发的时候，就悲观的认为会不安全，锁住对象。一直到用完才释放。

创建线程的3种方式(Thread和Callable接口有返回值)

线程类继承并重写 Thread的run方法，然后new出来.start()即可
实现runnable接口的类，作为new Thread(参数）的参数，调用start()即可
A类实现Callable接口的call方法，然后作为FutureTask的构造参数，最后加入到线程池里面，或者Thread的构造参数里面启动，然后result.get（）获取返回值
匿名内部类也有上面2种不同的实现Thread方式
3种方式的比较
runnable接口和callable接口的方式是以实现的方式，java是单继承，所以更好。
接口实现类作为target可以复用
runnable有异步的返回值

经典面试题：

在java中wait和sleep方法的不同？
共同点：都会造成当前线程的停止，但是sleep是给当前线程调用的，延缓当前线程的操作，wait是用来做线程间通讯的，会释放锁。
为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？
当你调用start()方法时你将创建新的线程，并且执行在run()方法里的代码。但是如果你直接调用run()方法，它不会创建新的线程也不会执行调用线程的代码
如何阻塞当前线程？

sonThread.join()
CurrentThread.sleep()
obj.wait()

在Java中Lock接口比synchronized块的优势是什么？
提供轮询锁避免死锁、定时轮询锁、可中断的锁、锁分块技术CHashMap、公平锁等等高级灵活的功能。但是缺点是一定要在finally里面 unlock()资源才行。不然会一直在。

ReentrantLock实现了synchronized的公平队列功能
ReentrantReadWriteLock类实现了读写锁的功能，而synchronized做不到
ReentrantLock提供了trylock（）和 trylock（tryTimes）的功能，不等待或者限定时间等待获取锁，更灵活。可以避免死锁的发生。
synchronized（obj){} 执行的时候，尝试获取obj的对象锁，如果获取不成功，当前线程会一直阻塞且无法停止，除非关闭程序，不然直到获取到该obj的锁为止

condition 和内置锁的区别
condition锁的是 lock对象，内置锁锁的是obj，一个lock对象可以有多个condition，从而精准控制不同的谓语，而内置锁做不到。从而避免信号丢失。
比如生产消费模式的阻塞队列，生产产品最大5个，其中红色的产品最多2个，有一个线程专门生产红色的，其他生产线程生产其它颜色，消费者消费了一个非红色产品的时候，如果红色生产线获取了锁，但是又不能生产红色，导致信号的丢失。
用java实现一个生产消费模式
可以使用synciazer（）锁一个对象，然后wait notify实现；也可以用ReentrantLock 的condition await 和signalAll实现，甚至可以是公平所的生产一个消费一个的场景。
进程和线程的区别
进程是操作系统分配资源的最小单位，线程是操作系统调度控制的最小单位。
CPU上下文的切换就是当前线程准备好了环境等待CPU计算，计算完之后，保存计算结果并等待CPU再次光临
monitor Object 设计模式
堆中的所有对象都绑定了一个内置的锁，实现多线程操作的时候，保证只有1个线程可以进行同步操作。
所以就有了 wait sleep notify 方法

Thread的一些常见方法

join()：父线程创建子线程，并start子线程后，调用子线程.join()方法，可以阻塞父线程，直到子线程结束，这里面满足 HB原则
yeild()：尝试出让cpu的执行权
wait()：线程调度里面，在一个锁里面，调用 obj.wait方法，放弃当前线程的执行权，让其他线程开始争夺锁。wait方法必须在锁里面才可以调用，不然报错。notify、notifyAll来唤醒
sleep()：阻塞当前线程，但是并不释放锁，一定时间后，重新争夺CPU执行权。
interrupt() ：并不阻塞当前线程，而是修改子线程的打断标志位，可用于线程之间的调度。

Tornado_Huang's BLOG

Happy Coding

并发编程详细

JMM