Java 并发变成同步机制
并发编程的演进：
批处理——多进程——多线程
在多线程变成中，由于多个线程共享进程的变量，有可能出现同时访问一个资源的情况，因此需要使用同步机制。
java的内存模型：
Java内存模型规定所有的变量都存在主存当中，每个线程都有自己的工作内存，线程对变量的所有操作都必须在工作内存中进行，而不能直接在主存进行操作。并且每个线程不能访问其他线程的工作内存。
关键字：
原子操作：原子为不可再分操作。只有对象的读取和赋值是原子操作。int i=10 是原子操作。int x = y；不是原子操作
violation：可见关键字
Synchronized：内部隐示锁
lock： ReentrantLock(显示锁) + ReentrantReadWriteLock(读写锁)
violation关键字:
一旦一个共享变量被volatile修饰之后，那么就具备了两层含义。
1)可见性: 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
它会强制将对缓存的修改操作立即写入主存，同时会导致其他CPU对应的缓存无效。
通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中
2) 有序性： 禁止进行指令重排序。
需要注意的是violation不保证原子性。
比如：
public volatile int inc = 0;
inc++;
在多线程中不同依靠violation关键字保证原子操作。
使用volatile关键字的场景：
1) 多变量的写操作不依赖于当前值
2) 该变量没有包含在具有其他变量的不变式中。
使用例子：状态标记量：
volatile boolean inited = false;
//线程1:
context = loadContext();
inited = true;
//线程2:
while(!inited ){
sleep()
}
doSomethingwithconfig(context);synchronized：
把一些不是原子操作组合成原子操作。
(1) synchronized方法
示例代码：
public class InsertData {
public synchronized void insert(){
for(int i=0; i<10;++i){
System.out.println(Thread.currentThread().getName() + ": 执行，变量i = "+i);
}
}
public synchronized void insert2() {
System.out.println(Thread.currentThread().getName()+ "start inset2");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ "end inset2");
}
public static synchronized void insert3(){
System.out.println(Thread.currentThread().getName() + "insert3");
}
public void insert4(){
System.out.println(Thread.currentThread().getName()+"insert4");
}
}public class SynTest {
@Test
public void test() throws InterruptedException {
InsertData insertData = new InsertData();
new Thread(new Runnable() {
@Override
public void run() {
insertData.insert();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
insertData.insert();
}
}).start();
Thread.sleep(8000);
}
}1)当一个线程正在访问一个对象的synchronized方法，那么其他 线程不能访问该对象的synchronized方法，这个原因很简单，是因为对当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized方法。
2) 当一个线程正在访问对象的synchronized方法，那么其他线程能访问该对象的非synchronized方法。
3) 如果该方法是非static的，则该锁是对象锁。如果方法是static的，则该锁是类锁。对象锁和类锁不互斥。
4) 对于synchronized方法或者synchronized代码块，当出现异常时，JVM会自动释放当前线程占用的锁，因此不会由于异常导致出现死锁现象。
(2) synchronized 代码块
synchronized(synObject){
}
当在某个线程中执行这段代码块，该线程会获取对象synObject的锁，从而使其他线程无法同时访问该代码块。
synObject可是是this，代码获取当前对象的锁，也可以是类中的一个属性，也可以是方法的一个object类型的入参，代表获取该对象的锁。
synchronized代码块使用起来比synchronized方法要灵活得多。如果一个方法中只有一部分代码需要同步，如果此时对整个方法用synchronized进行同步，会影响执行效率。而使用synchronized代码块就可以避免这个问题。
synchronized的缺陷：
当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只有两种情况：
1) 获取锁的线程执行完了代码块，然后线程释放对应锁的占有。
2) 线程执行发生异常，此时JVM会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待IO或者其他原因(比如调用sleep方法)被阻塞了，但是又没有释放锁，其他线程变只能干巴巴地等待，严重影响程序执行效率。所以就需要有一种机制可以不让等待的线程一直无限地等待下去(比如只等待一定时间或者能够相应中断)，通过lock就可以办到。
Lock
1) ReentrantLock：
使用事例：
采用lock，必须主动释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被释放，防止死锁的发生。
Lock lock =new ReentrantLock();
lock.lock();
try{
//执行业务逻辑代码
}catch (Exception e){
}finally {
lock.unlock();
}2) ReentrantReadWriteLock： 读写锁
readLock用来获取读锁，writeLock用来获取写锁。
读锁可以被多个线程占有。
一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
一个线程已经占用了写锁，则其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
Lock和synchronized的选择：
总结来说，Lock和synchronized有以下几点不同：
1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
lock是可中断的锁，而synchronized是不可中断锁。lock只能中断等待锁的线程，不能中断正在执行的线程。
4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）Lock可以提高多个线程进行读操作的效率。
在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
相同：
1) synchronized和lock都是可重入的锁。
参考资料：http://www.cnblogs.com/dolphin0520/p/3920373.html
http://www.cnblogs.com/dolphin0520/p/3923737.html
http://www.cnblogs.com/dolphin0520/p/3923167.html