java中并发的理解

在java中谈到并发，我们一定会想到两种锁，一种synchronized锁，一种ReentrantLock。还有一种轻量级的作用在变量上的volatile，那么他们三个有什么具体区别，和具体怎么用呢？

下面针对他们三个分别说一下原理和作用。

volatile的底层实现原理

---

volatile：

首先我们要知道他是一个关键字，作用在变量上的，保证了线程之间的可见性，在这里什么是可见性呢？是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。

要想理解volatile关键字，得先了解下JAVA的内存模型，Java内存模型的抽象示意图如下：

从图中可以看出：

①每个线程都有一个自己的本地内存空间--线程栈空间线程执行时，先把变量从主内存读取到线程自己的本地内存空间，然后再对该变量进行操作

②对该变量操作完后，在某个时间再把变量刷新回主内存

synchronized：

synchronized是java中的关键字，对于synchronized自我理解可以有两种用法，一种锁对象，一种用在代码块上。在java中每个对象都可以作为锁

1. 普通同步方法，锁的是当前实例对象
2. 静态同步方法，锁的是当前class对象
3. 同步代码块，锁的是括号中代码块的对象

当使用synchronized修饰的时候，别的线程来访问就会挂起，一直到当前锁对象释放别的线程才可以使用，这里就会有一个线程之间状态的转换

所以对于用synchronized来实现的时候如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法，在调用sleep()方法的过程中，线程不会释放对象锁）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，就算是占有锁的线程调用了wait方法（而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池）只有针对此对象调用notify()方法后本线程才进入对象锁定池准备。试想一下，这多么影响程序执行效率。所以就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断）于是便有了Lock。

Lock：

首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：

Lock接口中每个方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。

 lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

1.一般情况下通过tryLock来获取锁时是这样使用的

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //释放锁（一定要释放，不然会发生死锁）
     } 
}else {
    //如果不能获取锁，则直接做其他事情，
}

2.ReentrantLock

ReentrantLock，意思是“可重入锁”，关于可重入锁的概念在下一节讲述。ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法。下面通过一些实例看具体看一下如何使用ReentrantLock。

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    //注意这个地方
    public static void main(String[] args)  {
        final Test test = new Test();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  
     
    public void insert(Thread thread) {
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

Synchronized与volatile区别 :

1.volatile只能修饰变量，而synchronized可以修改变量，方法以及代码块

2.volatile在多线程中不会存在阻塞问题，synchronized会存在阻塞问题

3.volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子 

4.volatile解决的是变量在多个线程之间的可见性，而sychroized解决的是多个线程之间访问资源的同步性

Lock和synchronized的区别：

1.Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

2.synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

3.Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

4.通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

5.Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。