关于多线程:多线程3Lock

上一篇中说过了 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…