多线程(3)Lock

上一篇中说过了synchronized和它的使用范围，看起来已经可以处理所有情况了，那为什么还需要Lock呢？

Lock和synchronized

上篇中说到，被synchronized修饰的代码块只能由获取锁的线程执行，在释放锁之前，其他线程只能等待，这样就很影响效率，比如，一份文件不能同时写，但是允许同时读，这种情况synchronized就无法完成，此时需要一个机制使多个线程可以同时执行读操作。

注意：Lock需要手动去释放，如果在执行完没有释放锁，就有可能造成死锁现象，synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用。

可重入锁

可重入锁，可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁，可重入锁有以下两种：

• synchronized
• ReentrantLock

synchronized

public class ReentrantLockDemo {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (this) {
                    System.out.println("第1次获取锁，这个锁是：" + this);
                    int index = 1;
                    while (true) {
                        synchronized (this) {
                            System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this);
                        }
                        if (index == 10) {
                            break;
                        }
                    }
                }
            }
        }).start();
    }
}

运行结果

每次获取的都是同一个锁

第1次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第2次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第3次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第4次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第5次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第6次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第7次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第8次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第9次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81
第10次获取锁，这个锁是：com.example.offer.thread.lock.ReentrantLockDemo$1@3cc49e81

ReentrantLock锁定和释放次数相同

public class ReentrantLockDemo2 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("线程1第1次获取锁，这个锁是：" + lock);
                    int index = 1;
                    while (true) {
                        try {
                            lock.lock();
                            System.out.println("线程1第" + (++index) + "次获取锁，这个锁是：" + lock);
                            if (index == 10) {
                                break;
                            }
                        } finally {
                            //ReentrantLock不会自动释放，需要手动释放锁，否则会有死锁问题
                            lock.unlock();
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("线程2第1次获取锁，这个锁是：" + lock);
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
}

运行结果

每次获取的都是同一个锁

线程1第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第2次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第3次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第4次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第5次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第6次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第7次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第8次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第9次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程1第10次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-0]
线程2第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@32c3e0c4[Locked by thread Thread-1]

ReentrantLock锁定和释放次数不同

public class ReentrantLockDemo3 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("线程1第1次获取锁，这个锁是：" + lock);
                    int index = 1;
                    while (true) {
                        try {
                            lock.lock();
                            System.out.println("线程1第" + (++index) + "次获取锁，这个锁是：" + lock);
                            if (index == 10) {
                                break;
                            }
                        } finally {
                            //ReentrantLock不会自动释放，需要手动释放锁，否则会有死锁问题，比如此时加锁次数大于解锁次数
                            if (index < 8) {
                                lock.unlock();
                            }
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("线程2第1次获取锁，这个锁是：" + lock);
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
}

运行结果

每次获取的都是同一个锁，但是因为加锁次数大于解锁次数，所以线程2一直无法运行

线程1第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第2次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第3次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第4次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第5次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第6次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第7次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第8次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第9次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]
线程1第10次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@72460481[Locked by thread Thread-0]

为什么要有可重入锁

public class Demo1 {
    Demo1 demo1 = new Demo1();
    demo1.functionA();
    public synchronized void functionA(){
        System.out.println("iAmFunctionA");
        functionB();
    }
    public synchronized void functionB(){
        System.out.println("iAmFunctionB");
    }
}

SynchronizedDemo修饰的是代码块，锁定对象即实例化出来的对象demo1，如果锁定类，那就锁定Demo1

functionA()和functionB()都是同步方法，当线程进入funcitonA()会获得该类的对象锁，这个锁"demo1"，在functionA()对方法functionB()做了调用，但是functionB()也是同步的，因此该线程需要再次获得该对象锁（demo1）。其他线程是无法获该对象锁的。

可重入锁的作用就是为了避免死锁

ReentrantLock

Lock

Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

public class LockDemo {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        final LockDemo lockDemo = new LockDemo();

        new Thread() {
            public void run() {
                lockDemo.insert(Thread.currentThread());
            };
        }.start();

        new Thread() {
            public void run() {
                lockDemo.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();
        }
    }
}

运行结果

Thread-0得到了锁
Thread-0释放了锁
Thread-1得到了锁
Thread-1释放了锁

tryLock

tryLock()方法有返回值，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

public class TryLockDemo {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    //注意这个地方

    public static void main(String[] args) {
        final TryLockDemo tryLockDemo = new TryLockDemo();

        new Thread() {
            public void run() {
                tryLockDemo.insert(Thread.currentThread());
            };
        }.start();

        new Thread() {
            public void run() {
                tryLockDemo.insert(Thread.currentThread());
            };
        }.start();
    }

    public void insert(Thread thread) {
        if (lock.tryLock()) {
            try {
                System.out.println(thread.getName() + "得到了锁");
                for (int i = 0; i < 5; i++) {
                    arrayList.add(i);
                }
                Thread.sleep(100);
            } catch (Exception e) {
                // TODO: handle exception
            } finally {
                System.out.println(thread.getName() + "释放了锁");
                lock.unlock();
            }
        } else {
            System.out.println(thread.getName() + "获取锁失败");
        }
    }
}

运行结果

Thread-0得到了锁
Thread-1获取锁失败
Thread-0释放了锁

lockInterruptibly

lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

public class LockInterruptiblyDemo {
    private Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        LockInterruptiblyDemo test = new LockInterruptiblyDemo();
        MyThread thread1 = new MyThread(test);
        MyThread thread2 = new MyThread(test);
        thread1.start();
        thread2.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.interrupt();
    }

    public void insert(Thread thread) throws InterruptedException {
        lock.lockInterruptibly();
        try {
            System.out.println(thread.getName() + "得到了锁");
            long startTime = System.currentTimeMillis();
            for (; ; ) {
                if (System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
                    break;
                //插入数据
            }
        } finally {
            System.out.println(Thread.currentThread().getName() + "执行finally");
            lock.unlock();
            System.out.println(thread.getName() + "释放了锁");
        }
    }
}

class MyThread extends Thread {
    private LockInterruptiblyDemo test = null;

    public MyThread(LockInterruptiblyDemo test) {
        this.test = test;
    }

    @Override
    public void run() {

        try {
            test.insert(Thread.currentThread());
        } catch (InterruptedException e) {
            //中断线程
            Thread.currentThread().interrupt();
            System.out.println(Thread.currentThread().getName() + "被中断");
        }
    }
}

ReadWriteLock

ReadWriteLock是一个接口

ReentrantReadWriteLock

ReentrantReadWriteLock中有readLock()和writeLock()用来获取读锁和写锁

public class ReentrantReadWriteLockDemo {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        final ReentrantReadWriteLockDemo test = new ReentrantReadWriteLockDemo();

        new Thread() {
            public void run() {
                test.get(Thread.currentThread());
            }

            ;
        }.start();

        new Thread() {
            public void run() {
                test.get(Thread.currentThread());
            }

            ;
        }.start();

    }

    public synchronized void get(Thread thread) {
        int index = 0;
        while (index < 5) {
            System.out.println(thread.getName() + "正在进行读操作");
            index++;
        }
        System.out.println(thread.getName() + "读操作完毕");
    }
}

运行结果

使用synchronized，一个线程获取到锁后，其他线程无法读取

Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0读操作完毕
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1读操作完毕

public class ReentrantReadWriteLockDemo1 {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        final ReentrantReadWriteLockDemo1 test = new ReentrantReadWriteLockDemo1();

        new Thread() {
            public void run() {
                test.get(Thread.currentThread());
            }

            ;
        }.start();

        new Thread() {
            public void run() {
                test.get(Thread.currentThread());
            }

            ;
        }.start();

    }

    public void get(Thread thread) {
        rwl.readLock().lock();
        try {
            int index = 0;
            while (index < 5) {
                System.out.println(thread.getName() + "正在进行读操作");
                index++;
            }
        } finally {
            rwl.readLock().unlock();
        }
    }
}

运行结果

使用ReentrantReadWriteLock，一个线程获取到锁后，其他线程也可以进行操作。

有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-1读操作完毕
Thread-0读操作完毕

Lock和synchronized的选择

　　总结来说，Lock和synchronized有以下几点不同：

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

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

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

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

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

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

各种锁

可重入锁

　　如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

• synchronized
• ReentrantLock

可中断锁

　　可中断锁：顾名思义，就是可以相应中断的锁。在Java中，synchronized就不是可中断锁，而Lock是可中断锁。如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。

• Lock

公平锁

　　公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

​ 在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

读写锁

　　读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

​ 正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

　　ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

　　可以通过readLock()获取读锁，通过writeLock()获取写锁。

• ReentrantReadWriteLock

　　参考资料：

　　https://www.cnblogs.com/dolph...