乐趣区

关于多线程:多线程3Lock

作者：

jiezi

在

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

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章