乐趣区

关于java:搞明白synchronized和ReetrantLock

作者：

jiezi

在

上一篇文章，咱们相熟了Java锁的分类。明天，来学习下Java中罕用的乐观锁synchronized和ReetrantLock吧。学习使我高兴，哦耶！

synchronized

synchronized是什么？

synchronized关键字能够保障，一段时间内共享资源只能被一个线程所应用，或者说一段代码一段时间内只能被一个线程执行，并且共享资源对其余线程是可见的。

实际上，synchronized就是，某个线程拿到一个锁，锁住共享资源，当应用完，放开锁，让其余线程申请锁并应用共享资源。

synchronized锁的级别

synchronized作用在一般办法或者代码片段上时，锁为对象自身。作用在static办法或者代码片段上时，锁为类自身。

synchronized的根本应用

咱们构想一个卖票场景，有A、B两个售票窗口卖票，票池(共享资源)只有一个。
试验1

public class SellTicketRunnable implements Runnable {
    // 残余票数
    static int ticket = 1000;
    @Override
    public void run() {
        for (int i=0;i<550;i++){
            sell();
        }
    }
    // 买票操作
    private synchronized void sell() {
        System.out.println(Thread.currentThread().getName()+"开始卖票");
        try {
            // 模仿卖票
            if (ticket <= 0){
                System.out.println(Thread.currentThread().getName()+"窗口告诉，票卖完了~");
            }else {
                Thread.sleep(5);
                ticket--;
                System.out.println(Thread.currentThread().getName()+"出票胜利，当初还有"+ticket+"张票");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"完结卖票");
    }
}

public static void main(String[] args) throws InterruptedException {
        // 代码示例 1 根本应用
        SellTicketRunnable sellTicketRunnable = new SellTicketRunnable();
        Thread thread_1 = new Thread(sellTicketRunnable,"A窗口");
        Thread thread_2 = new Thread(sellTicketRunnable,"B窗口");
        thread_1.start();
        thread_2.start();
        thread_1.join();
        thread_2.join();
        System.out.println("运行完结，剩下"+SellTicketRunnable.ticket+"张票");
}

首先创立售票类SellTicketRunnable，定义布告资源ticket为1000张票，咱们每个窗口模仿卖票550张，如果发现票卖完了，就零碎提醒，否则票数减1。main办法开启两个线程，发现完满运行。发现票数最终为0，并且每个线程访问共享资源的工夫内都是独享的。

A窗口开始卖票
A窗口窗口告诉，票卖完了~
A窗口完结卖票
B窗口开始卖票
B窗口窗口告诉，票卖完了~
B窗口完结卖票
运行完结，剩下0张票

synchronized对象级别的锁

方才只生成了一个SellTicketRunnable，只有一把锁。那咱们生成两个SellTicketRunnable对象，会不会有两把锁呢？
试验2

   SellTicketRunnable sellTicketRunnable = new SellTicketRunnable();
   SellTicketRunnable sellTicketRunnable_backups = new SellTicketRunnable();
   Thread thread_1 = new Thread(sellTicketRunnable,"A窗口");
   Thread thread_2 = new Thread(sellTicketRunnable_backups,"B窗口");
   thread_1.start();
   thread_2.start();
   thread_1.join();
   thread_2.join();
   System.out.println("运行完结，剩下"+SellTicketRunnable.ticket+"张票");
// 运行后果如下：
A窗口开始卖票
B窗口开始卖票
A窗口出票胜利，当初还有999张票
A窗口完结卖票
A窗口开始卖票
B窗口出票胜利，当初还有998张票
B窗口完结卖票
B窗口开始卖票
A窗口出票胜利，当初还有997张票
A窗口完结卖票
...
运行完结，剩下-1张票

将main办法改成上边所示。首先，访问共享资源的工夫不再独享。A窗口还没拜访完数据库呢，B窗口就去拜访了。这最终导致票可能超卖。(就剩1张票了，A、B窗口同时卖出，同时更新共享资源)。当然这段代码你多运行几次才会呈现残余-1的状况，有时候可能为0，毕竟那么巧的事，不是每次都遇到哈。阐明，此时锁是对象级别的。

实际上，如果synchronized作用在对象级别上。内存中，对象的对象头会记录以后获取锁的线程，利用的是Monitor机制。

synchronized类级别的锁

试验3

public class SellTicketRunnablePlus implements Runnable {
    // 残余票数
    static int ticket = 1000;
    @Override
    public void run() {
        for (int i=0;i<550;i++){
            sell();
        }
    }
    public void sell() {
        synchronized(SellTicketRunnablePlus.class){
            System.out.println(Thread.currentThread().getName()+"开始卖票");
            try {
                // 模仿卖票
                if (ticket <= 0){
                    System.out.println(Thread.currentThread().getName()+"窗口告诉，票卖完了~");
                }else {
                    Thread.sleep(5);
                    ticket--;
                    System.out.println(Thread.currentThread().getName()+"出票胜利，当初还有"+ticket+"张票");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"完结卖票");
        }
    }
}
// 运行后果
A窗口开始卖票
A窗口窗口告诉，票卖完了~
A窗口完结卖票
B窗口开始卖票
B窗口窗口告诉，票卖完了~
B窗口完结卖票
运行完结，剩下0张票

将试验2主函数中的SellTicketRunnable类换成SellTicketRunnablePlus。SellTicketRunnablePlus只是给sell办法外部，synchronized锁的是SellTicketRunnablePlus类。此时又是一把锁了，所以两个窗口又能够某段时间内独享共享资源了。

synchronized是重入锁

synchronized能够保障不同线程同一时间只能有有一个独享共享资源，比如说线程1持有了锁，线程2去申请锁的时候，发现线程1持有锁呢，所以线程2须要等会(线程阻塞)。那么线程1在持有锁的状况下，能够再申请一把同样的锁吗？
试验4

public class ReentryTest {
    public synchronized void outMethod(){
        innerMethod();
        System.out.println("这是内部办法，执行了");
    }
    private synchronized void innerMethod(){
        System.out.println("这是外部办法，执行了");
    }
}
// main办法
 ReentryTest reentryTest = new ReentryTest();
 reentryTest.outMethod();
//运行后果
这是外部办法，执行了
这是内部办法，执行了

当线程1执行outMethod办法时，取得了锁。outMethod调用innerMethod办法时，线程1又去申请了同一把锁，发现申请胜利了。可重入锁是指同一个线程能够屡次加同一把锁。

自JDK1.6开始，当只有两个线程竞争锁时，synchronized是轻量级锁，超过两个线程竞争的时候是重量级锁。对于锁的分类，请戳链接: Java锁分类原来是这个样子。

ReetrantLock

synchronized是关键字，很多操作都是隐式的，比如说开释锁、自旋次数等，都是虚拟机帮你搞定的。为了显示操作，并且领有更弱小的性能，ReetrantLock来了。

ReetrantLock根本应用

试验5

        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try{
            // 业务逻辑
        }catch (Exception e){
        }finally {
            lock.unlock();
        }

ReetrantLock须要手动申请锁和开释锁，别离为办法lock和unlock。

ReetrantLock重入性

和synchronized一样，ReetrantLock也具备重入性。
试验6

        ReentrantLock lock = new ReentrantLock();
        int count = 0;
        for (int i = 1; i <= 3; i++) {
            lock.lock();
            System.out.println("阐明获取锁"+ ++count +"次");
        }
        for (int i = 1; i <= 3; i++) {
            lock.unlock();
        }
//
阐明获取锁1次
阐明获取锁2次
阐明获取锁3次

偏心锁和非偏心锁

ReetrantLock能够申请偏心锁或者非偏心锁(理解锁的分类:Java锁分类原来是这个样子)。

首先咱们补充一个知识点，ReetrantLock是实现AQS机制的，就是说所有申请锁的线程，会被按需放到一个队列中，而后顺次获取锁。偏心锁保障了，获取锁的程序性。

试验7

//主函数
        ReentrantLock lock = new ReentrantLock(true);
        for (int i=1;i<=5;i++){
            new Thread(new FairLockThread(lock),"第"+i+"个").start();
        }
// FairLockThread类
public class FairLockThread implements Runnable {
    ReentrantLock lock;
    public FairLockThread(ReentrantLock lock) {
        this.lock = lock;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 2; i++) {
            lock.lock();
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "开始执行了");
            System.out.println(Thread.currentThread().getName() + ":" + lock.getQueueLength());
            lock.unlock();
        }
    }
}
// 后果
第1个开始执行了
第1个:4
第2个开始执行了
第2个:4
第3个开始执行了
第3个:4
第4个开始执行了
第4个:4
第5个开始执行了
第5个:4
第1个开始执行了
第1个:4
第2个开始执行了
第2个:3
第3个开始执行了
第3个:2
第4个开始执行了
第4个:1
第5个开始执行了
第5个:0

ReentrantLocknew的时候传入true，就是申请了一把偏心锁。FairLockThread办法外面让一个线程执行两次申请锁、开释锁操作，并且模仿应用锁0.5秒。getQueueLength办法就是查看，以后队列中阻塞的线程数。能够看出，锁的两遍申请是依照程序的，从1~5。从线程是也能够看出，没有哪个线程能够偷偷的本人两边都执行完。

还是试验7

ReentrantLock lock = new ReentrantLock(false);
// 后果
第2个开始执行了
第2个:4
第2个开始执行了
第2个:4
第1个开始执行了
第1个:3
第1个开始执行了
第1个:3
第3个开始执行了
第3个:2
第4个开始执行了
第4个:2
第4个开始执行了
第4个:2
第5个开始执行了
第5个:1
第5个开始执行了
第5个:1
第3个开始执行了
第3个:0

咱们只须要将主函数，newReentrantLock的时候设置成false，此时申请的就是非偏心锁了。再看运行后果，某个线程执行完第一遍，很大概率上就会执行第二遍。没有依照程序执行，这是不偏心的。

执行完一遍，而后紧接着执行第二遍，不必切换上下文，某线程统一应用CPU，这样效率更快的，所以非偏心锁效率更高。

ReetrantLock可中断，预防死锁问题

试想一下，如果线程1曾经持有锁1，当初想拿锁2，而后就能够开心的完结了。线程2曾经持有锁2，当初想拿锁1，而后就能够开心的完结了。这俩线程还欢快的碰面了，后果谁都不撒手，谁都不能欢快的完结，于是乎，死锁就产生了。

试验8

public class InterruptThread implements Runnable{
    ReentrantLock firstLock;
    ReentrantLock secondLock;
    public InterruptThread(ReentrantLock firstLock, ReentrantLock secondLock) {
        this.firstLock = firstLock;
        this.secondLock = secondLock;
    }
    @Override
    public void run() {
        try {
            firstLock.lock();
            Thread.sleep(1000);
            secondLock.lock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            firstLock.unlock();
            secondLock.unlock();
            System.out.println(Thread.currentThread().getName()+"失常完结!");
        }
    }
}
// 主函数
 ReentrantLock lock = new ReentrantLock();
 ReentrantLock lock2 = new ReentrantLock();
 Thread a = new Thread(new InterruptThread(lock, lock2), "A");
 Thread b = new Thread(new InterruptThread(lock2, lock), "B");
 a.start();
 b.start();
//后果
没有后果...

以上，运行到电脑死机也不会完结了。如果咱们在主函数最初一行前面加上一行

a.interrupt();

运行后果，放个图吧。

能够看出，尽管A就义掉了，然而因为A的中断(放弃持有锁1)。B顺利完成了！为小A默哀一分钟。。。

雷同与不同

雷同

  1. synchronized和ReetrantLock都是乐观锁、可重入锁。

不同

  1. synchronized是隐士申请、开释锁，虚拟机层面保护。ReetrantLock是显示操作，代码保护。
  2. 在JDK1.6之前， synchronized性能极差，1.6之后，它俩性能差不多。
  3. ReetrantLock可中断，防止死锁产生。
  4. ReetrantLock能够申请偏心锁或者非偏心锁，可依据需要定制。

呜呼，从摸索到验证，辣条君用了一天，小伙伴们点个赞再走吧。

评论

发表回复

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

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

更多文章