Concurrent----ReadWriteLock(读写锁)及Lock和synhronized的选择

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();
}

一个用来获取读锁，一个用来获取写锁。将文件的读写操作分开，分成2个锁来分配线程,从而实现多个线程可以同时进行读操作。

实现类–ReentrantReadWriteLock

对于一般的锁，入ReentrantLock，其一般都是“独占式”，也即在同一时刻只能有一个线程能够访问锁定的代码。如果对于共享资源的访问“读”多于“写”，那么“独占锁”没有读写锁的效率高。所谓“读写锁”指的是对共享资源的访问提供一个读锁和一个写锁，当访问方式是读取操作时使用度锁即可，当访问方式是修改操作时，则使用写锁。读锁和写锁之间有一定的制约性。

• 当有读锁锁定资源时，其余的读锁可以共享式的访问资源，但是会阻塞写锁对资源的获取。
• 当有写锁锁定资源时，将阻塞其余所有的读锁(除了该线程本身–重入)和写锁的获取。

示例

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Demo11 {
    ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    int m = 100;
    public static void main(String[] args) {
        Demo11 d = new Demo11();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    d.get(Thread.currentThread());

                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    d.get2(Thread.currentThread());
                }
            }).start();



    }

    public  void get(Thread thread){
//        rwLock.readLock().lock();
        //如果为写锁，则当前线程执行此方法，另一个线程想执行另一个get2()方法获取读锁，无法获取
        rwLock.writeLock().lock();
        try {
            int a = 10;
            while (a>=0) {
                a--;
                m--;
                System.out.println(thread.getName() + "正在写"+",m="+m);
                TimeUnit.SECONDS.sleep(1);
            }
            System.out.println("写操作完毕");
        }catch (Exception e){

        }finally {
//            rwLock.readLock().unlock();
            rwLock.writeLock().unlock();
        }


    }
    public  void get2(Thread thread){
        rwLock.readLock().lock();
        try {
            int a = 10;
            while (a>=0) {
                m--;
                a--;
                System.out.println(thread.getName() + "正在读"+",m="+m);
                TimeUnit.SECONDS.sleep(1);
            }
            System.out.println("读操作完毕");
        }catch (Exception e){

        }finally {
            rwLock.readLock().unlock();
        }

    }
}

ReentrantReadWriteLock具有重入性。

package cn.tedu.concurrent;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * synchronized的造成的阻塞可重入
 */
public class ReentrantDemo1 {
    ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public  void m1(){
        try {
            readWriteLock.readLock().lock();
            System.out.println("m1..start");
            this.m2();
        }finally {
            readWriteLock.readLock().unlock();
        }
    }
    public  void m2(){
        try {
            readWriteLock.readLock().lock();
            System.out.println("m2..start");
        }finally {
            readWriteLock.readLock().unlock();
        }

    }

    public static void main(String[] args) {
        ReentrantDemo1 rd = new ReentrantDemo1();
        rd.m1();
    }

}

Lock和synhronized的选择

首先先说明一点synchronized是支持重入锁的

package cn.tedu.concurrent;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * synchronized的造成的阻塞可重入
 */
public class ReentrantDemo1 {

    public synchronized void m1(){
            System.out.println("m1..start");
            this.m2();
    }

    public synchronized void m2(){
            System.out.println("m2..start");

    }


    public static void main(String[] args) {
        ReentrantDemo1 rd = new ReentrantDemo1();
        rd.m1();
    }

}

Lock和synchronized有以下几点不同：

1. Lock是一个接口，而synchronized是java中的关键字，synchronize的内置语言实现的
2. synchronized在发生异常时，会自动释放线程线程占用的锁，因此不会导致死锁现象的发生；而Lock在发生异常的时候，如果没有主动通过unlock()方法去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁。
3. Lock可以让等待锁的线程响应中断，而synchronized不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断。
4. 通过Lock可以知道有没有成功获取锁，而synchronized无法办到
5. Lock可以提高多个线程进行读操作的效率

jdk之后对synchronized进行了优化，所以在溢写并发量比较低的情况下二者的效率是差不多的。