转载

Java同步锁-synchronized与lock

一、synchronized关键字

1、synchronized简介

synchronized实现同步的基础：java中每个对象都可以作为锁。当线程试图访问同步代码时，必须先获得对象锁，退出或抛出异常时必须释放锁。

表现形式为： 代码块同步 和 方法同步 。

2、synchronized的使用场景

方法同步

public synchronized void method1(){}复制代码

锁住的是该对象的 一个实例 ，当不同线程调用该实例对象中该同步方法，线程只有一个得到锁，其余被阻塞。但如果不同线程同时对该类的 不同实例 对象执行 该同步方法 ，则不会阻塞，因为他们使用不同的锁。

代码块同步

synchronized(this)( //ToDo}
或
synchronized(普通变量){    }复制代码

同上

静态方法同步

public synchronized static void method3(){}复制代码

锁住的是该类，当不同线程调用该类的该 static同步方法 时，就只能有 一个线程获得锁 ， 其余线程被阻塞 。

静态代码块

synchronized(Test.class){ //ToDo}
或
synchronized(静态变量){ //ToDo}复制代码

同上

3、synchronized锁升级

锁一共有4种状态，级别从低到高依次是： 无锁状态 、 偏向锁状态 、 轻量级锁 和 重量级锁

锁可以升级但不能降级，意味着偏向锁升级为轻量级锁后不能降级为偏向锁。

偏向锁

大所述情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得所的代价更低而引入偏向锁。

当一个线程访问同步代码并获取锁时，会对对象头和栈帧中的锁记录里保存锁偏向的线程ID，以后该线程再进入和退出同步锁时，不需要进行CAS操作来加锁和解锁，而只是简单地测试一下对象头的Mark Word里是否存储执行当前线程的偏向锁。

偏向锁作用是：在没有别的线程竞争的时候，一直偏向当前线程，当前线程可以一直执行。

轻量级锁（自旋锁）

轻量级锁，由偏向锁升级而来。

偏向锁运行在一个线程进入同步块的情况下，当第二个线程加入锁争用的时候，偏向锁就会升级为轻量级锁。

重量级锁

轻量级锁膨胀之后，就升级为重量级锁。

重量级锁时依赖对象内部的monitor锁来实现的，而monitor又依赖操作系统的MutexLock（互斥锁）来实现的，所以重量级锁也被称为互斥锁（synchronized就是重量级锁）。

偏向锁

优点：加锁和解锁不需要额外的消耗

缺点：线程存在竞争，会带来额外的锁撤销的消耗

场景：单一线程访问同步块场景

轻量级锁

优点：竞争的线程不会阻塞，提高了程序的响应速度。

缺点：线程自旋时不释放CPU

场景：追求响应时间，同步块执行速度非常快。

重量级锁

优点：线程竞争不使用自旋，释放CPU

缺点：线程阻塞，响应时间缓慢。

场景：追求吞吐量，同步块执行速度较长。

二、Lock接口

1、Lock接口

Lock，锁对象。在Lock接口出现之前，Java程序时靠synchronized关键字实现锁功能。而在Java SE5.0之后并发包中新增了Lock接口来实现锁的功能。

它能提供synchronized关键字类似的同步功能，但需要显示获得锁和释放锁，至于二者区别后文补充。

Lock接口的主要方法：

void lock()

执行该方法时，若锁处于空闲状态，当前线程将获得锁。相反，如果锁已经被其他线程持有，则禁止当前线程获得锁。

boolean tryLock()

若锁可用，则获得锁，并立即返回true，否则返回false。

tryLock()和Lock()的区别在于：

tryLock() 只是尝试获得锁，若 锁不可用 ， 不会导致当前线程被禁止 ，当前线程仍然继续往下执行代码。

Lock() 则是一定要获得锁，如果 锁不可用 ，就 一直等待 ，在未获得锁之前，当前线程并不继续向下自行。

void unlock()

执行该方法时，当前线程将释放持有锁，锁只能由持有者释放，若线程没有持有锁，则执行该方法，可能导致异常方式。

Condition newCondition()

条件对象，获得等待通知组件。该组件和当前的锁绑定，当前线程只有获得锁，才会调用该组件的await()方法，调用后，当前线程将释放锁。

2、Reentrantlock的使用

Reentrantlock的使用很简单，只需要显示调用，获得同步锁，释放同步锁即可。

ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平锁
.....................

try {
    lock.lock(); //如果被其它资源锁定，会在此等待锁释放，达到暂停的效果
    //操作
}catch（Exception e）{
   //异常处理
} finally {
    lock.unlock();  //释放锁
}复制代码

reentrantlock锁，在高并发的条件下使用的性能远远高于synchronized关键字。

并且reentratnlock 公平和非公平锁 的队列都是基于锁内部维护的一个 双向链表 ，表结点Node的值就是每一个请求当前锁的线程。

3、ReadWriteLock接口

ReadWriteLock接口中主要方法如下：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}复制代码

ReadWriteLock管理一组锁，一个是只读锁，一个是写锁。

Java并发库中ReentrantReadWriteLock实现了ReadWriteLock接口并添加了可重入的特性。

读锁在 同一时刻 允许有 多个线程 在访问，但是 写进程 访问时，所有的 读线程 和 其他写进程 都 被阻塞 。

读写锁维护 一对锁，一个读锁和一个写锁 ，通过 读写锁分离 ，使得并发性相比一般的排它锁有很大的提升。

ReentrantReadWriteLock读写锁的几个特性 ：

公平选择性
重入性
锁降级

读写锁例子（程序来源于网上： blog.csdn.net/canot/artic… ）：

public class Cache{
  static Map<String,Object> map = new HashMap<String,Object>();
  static ReentrantReadWriteLock  rwl = new ReentrantReadWriteLock();
  static Lock rLock = rwl.readLock();
  static Lock wLock = rwl.writeLock();

  //获取一个key对应的value
  public static final Object get(String key){
     r.lock();
     try{
         return map.get(key);
     }finally{
         r.unlock();
     }
  }

  //设置key对应的value并返回旧的value
  public static fianl Object put(String key,Object value){
     w.lock();
     try{
        return map.put(key,value);
     }final{
        w.unlock();
     }
  }

  //清空缓存
  public static fianl void clear(){
     w.lock();
     try{
        map.clear();
     } finally{
        w.unlock();
     }
  }
}复制代码

读写锁的锁降级

锁降级是指写锁降级成为读锁。如果当前线程持有写锁，然后将其释放再获取读锁的过程不能称为锁降级。锁降级指的在持有写锁的时候再获取读锁,获取到读锁后释放之前写锁的过程称为锁释放。

（程序来源于： blog.csdn.net/qq_38737992… ）

public void work() {
        reentrantReadWriteLock.readLock().lock();
 
        if (!update) {
            reentrantReadWriteLock.readLock().unlock();
 
            // 锁降级开始
            reentrantReadWriteLock.writeLock().lock();
            try {
                if (!update) {
                    // 准备数据
                    ++index;
                    try {
                        TimeUnit.MILLISECONDS.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    update = true;
                }
                reentrantReadWriteLock.readLock().lock();
            } finally {
                reentrantReadWriteLock.writeLock().unlock();
                // 锁降级结束,降级为读锁
            }
        }
        try {
            // 使用数据
            for (int i=0; i<5; i++) {
                try {
                    TimeUnit.MILLISECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" + index);
            }
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }
复制代码