海同科技，欢迎您！
就业
培训
资料
职坐标
IT知识库

编程语言

站
热门城市 全国站>
    其他省市
      搜索
      快速购买 快速购买  >
      icon 400-636-0069

      热门课程

      IT学院

      职坐标首页 IT知识库 编程语言 JAVA
      选择在海同培训： 30 天 1411 名， 今日申请 31 人 IT培训咨询 >>
      JAVA程序实例：多线程并发编程之互斥锁 Reentrant Lock
      小职 2018-03-01 来源 ：网络 阅读 1066 评论 0

      摘要：讲解JAVA程序实例之Java多线程并发编程之互斥锁 Reentrant Lock！通过关键字 synchronized 获取的锁，我们称为同步锁。

      Java 中的锁通常分为两种：

      讲解JAVA程序实例之Java多线程并发编程之互斥锁 Reentrant Lock！

      · 通过关键字 synchronized 获取的锁，我们称为同步锁。

      · java.util.concurrent（JUC）包里的锁，如通过继承接口 Lock 而实现的 ReentrantLock（互斥锁），继承 ReadWriteLock 实现的 ReentrantReadWriteLock（读写锁）。

      本篇主要介绍 ReentrantLock（互斥锁）。

      ReentrantLock（互斥锁）

      ReentrantLock 互斥锁，在同一时间只能被一个线程所占有，在被持有后并未释放之前，其他线程若想获得该锁只能等待或放弃。

      ReentrantLock 互斥锁是可重入锁，即某一线程可多次获得该锁。

      公平锁 and 非公平锁

          public ReentrantLock() {
        sync = new NonfairSync();
    }
 
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

      由 ReentrantLock 的构造函数可见，在实例化 ReentrantLock 的时候我们可以选择实例化一个公平锁或非公平锁，而默认会构造一个非公平锁。

      公平锁与非公平锁区别在于竞争锁时的有序与否。公平锁可确保有序性（FIFO 队列），非公平锁不能确保有序性（即使也有 FIFO 队列）。

      然而，公平是要付出代价的，公平锁比非公平锁要耗性能，所以在非必须确保公平的条件下，一般使用非公平锁可提高吞吐率。所以 ReentrantLock 默认的构造函数也是“不公平”的。

      一般使用

      DEMO1：
public class Test {
 
    private static class Counter {
 
        private ReentrantLock mReentrantLock = new ReentrantLock();
 
        public void count() {
            mReentrantLock.lock();
            try {
                for (int i = 0; i < 6; i++) {
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                }
            } finally {
            // 必须在 finally 释放锁
                mReentrantLock.unlock();
            }
        }
    }
 
    private static class MyThread extends Thread {
 
        private Counter mCounter;
 
        public MyThread(Counter counter) {
            mCounter = counter;
        }
 
        @Override
        public void run() {
            super.run();
            mCounter.count();
        }
    }
 
    public static void main(String[] var0) {
        Counter counter = new Counter();
        // 注：myThread1 和 myThread2 是调用同一个对象 counter
        MyThread myThread1 = new MyThread(counter);
        MyThread myThread2 = new MyThread(counter);
        myThread1.start();
        myThread2.start();
    }
}

      DEMO1 输出：

      Thread-0， i = 0

      Thread-0， i = 1

      Thread-0， i = 2

      Thread-0， i = 3

      Thread-0， i = 4

      Thread-0， i = 5

      Thread-1， i = 0

      Thread-1， i = 1

      Thread-1， i = 2

      Thread-1， i = 3

      Thread-1， i = 4

      Thread-1， i = 5

      DEMO1 仅使用了 ReentrantLock 的 lock 和 unlock 来提现一般锁的特性，确保线程的有序执行。此种场景 synchronized 也适用。

      锁的作用域

      DEMO2：
public class Test {
 
    private static class Counter {
 
        private ReentrantLock mReentrantLock = new ReentrantLock();
 
        public void count() {
            for (int i = 0; i < 6; i++) {
                mReentrantLock.lock();
                // 模拟耗时，突出线程是否阻塞
                try{
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                // 必须在 finally 释放锁
                    mReentrantLock.unlock();
                }
            }
        }
 
        public void doOtherThing(){
            for (int i = 0; i < 6; i++) {
                // 模拟耗时，突出线程是否阻塞
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
            }
        }
    }
 
    public static void main(String[] var0) {
        final Counter counter = new Counter();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.count();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.doOtherThing();
            }
        }).start();
    }
}

      DEMO2 输出：

      Thread-0， i = 0

      Thread-1 doOtherThing， i = 0

      Thread-0， i = 1

      Thread-1 doOtherThing， i = 1

      Thread-0， i = 2

      Thread-1 doOtherThing， i = 2

      Thread-0， i = 3

      Thread-1 doOtherThing， i = 3

      Thread-0， i = 4

      Thread-1 doOtherThing， i = 4

      Thread-0， i = 5

      Thread-1 doOtherThing， i = 5

      DEMO3:
public class Test {
 
    private static class Counter {
 
        private ReentrantLock mReentrantLock = new ReentrantLock();
 
        public void count() {
            for (int i = 0; i < 6; i++) {
                mReentrantLock.lock();
                // 模拟耗时，突出线程是否阻塞
                try{
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 必须在 finally 释放锁
                    mReentrantLock.unlock();
                }
            }
        }
 
        public void doOtherThing(){
            mReentrantLock.lock();
            try{
                for (int i = 0; i < 6; i++) {
                    // 模拟耗时，突出线程是否阻塞
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
                }
            }finally {
                mReentrantLock.unlock();
            }
 
        }
    }
 
    public static void main(String[] var0) {
        final Counter counter = new Counter();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.count();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.doOtherThing();
            }
        }).start();
    }
}

      DEMO3 输出：

      Thread-0， i = 0

      Thread-0， i = 1

      Thread-0， i = 2

      Thread-0， i = 3

      Thread-0， i = 4

      Thread-0， i = 5

      Thread-1 doOtherThing， i = 0

      Thread-1 doOtherThing， i = 1

      Thread-1 doOtherThing， i = 2

      Thread-1 doOtherThing， i = 3

      Thread-1 doOtherThing， i = 4

      Thread-1 doOtherThing， i = 5

      结合 DEMO2 和 DEMO3 输出可见，锁的作用域在于 mReentrantLock，因为所来自于 mReentrantLock。

      可终止等待

      DEMO4：

      public class Test {
 
    static final int TIMEOUT = 300;
 
    private static class Counter {
 
        private ReentrantLock mReentrantLock = new ReentrantLock();
 
        public void count() {
            try{
                //lock() 不可中断
                mReentrantLock.lock();
                // 模拟耗时，突出线程是否阻塞
                for (int i = 0; i < 6; i++) {
                    long startTime = System.currentTimeMillis();
                    while (true) {
                        if (System.currentTimeMillis() - startTime > 100)
                            break;
                    }
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                }
            } finally {
                // 必须在 finally 释放锁
                mReentrantLock.unlock();
            }
        }
 
        public void doOtherThing(){
            try{
                //lockInterruptibly() 可中断，若线程没有中断，则获取锁
                mReentrantLock.lockInterruptibly();
                for (int i = 0; i < 6; i++) {
                    // 模拟耗时，突出线程是否阻塞
                    long startTime = System.currentTimeMillis();
                    while (true) {
                        if (System.currentTimeMillis() - startTime > 100)
                            break;
                    }
                    System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
                }
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " 中断 ");
            }finally {
                // 若当前线程持有锁，则释放
                if(mReentrantLock.isHeldByCurrentThread()){
                    mReentrantLock.unlock();
                }
            }
        }
    }
 
    public static void main(String[] var0) {
        final Counter counter = new Counter();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.count();
            }
        }).start();
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                counter.doOtherThing();
            }
        });
        thread2.start();
        long start = System.currentTimeMillis();
        while (true){
            if (System.currentTimeMillis() - start > TIMEOUT) {
                // 若线程还在运行，尝试中断
                if(thread2.isAlive()){
                    System.out.println(" 不等了，尝试中断 ");
                    thread2.interrupt();
                }
                break;
            }
        }
    }
}

      DEMO4 输出：

      Thread-0， i = 0

      Thread-0， i = 1

      Thread-0， i = 2

      不等了，尝试中断

      Thread-1 中断

      Thread-0， i = 3

      Thread-0， i = 4

      Thread-0， i = 5

      线程 thread2 等待 300ms 后 timeout，中断等待成功。

      若把 TIMEOUT 改成 3000ms，输出结果：（正常运行）

      Thread-0， i = 0

      Thread-0， i = 1

      Thread-0， i = 2

      Thread-0， i = 3

      Thread-0， i = 4

      Thread-0， i = 5

      Thread-1 doOtherThing， i = 0

      Thread-1 doOtherThing， i = 1

      Thread-1 doOtherThing， i = 2

      Thread-1 doOtherThing， i = 3

      Thread-1 doOtherThing， i = 4

      Thread-1 doOtherThing， i = 5

      定时锁

      DEMO5：

      public class Test {
 
    static final int TIMEOUT = 3000;
 
    private static class Counter {
 
        private ReentrantLock mReentrantLock = new ReentrantLock();
 
        public void count() {
            try{
                //lock() 不可中断
                mReentrantLock.lock();
                // 模拟耗时，突出线程是否阻塞
                for (int i = 0; i < 6; i++) {
                    long startTime = System.currentTimeMillis();
                    while (true) {
                        if (System.currentTimeMillis() - startTime > 100)
                            break;
                    }
                    System.out.println(Thread.currentThread().getName() + "， i = " + i);
                }
            } finally {
                // 必须在 finally 释放锁
                mReentrantLock.unlock();
            }
        }
 
        public void doOtherThing(){
            try{
                //tryLock(long timeout, TimeUnit unit) 尝试获得锁
                boolean isLock = mReentrantLock.tryLock(300, TimeUnit.MILLISECONDS);
                System.out.println(Thread.currentThread().getName() + " isLock:" + isLock);
                if(isLock){
                    for (int i = 0; i < 6; i++) {
                        // 模拟耗时，突出线程是否阻塞
                        long startTime = System.currentTimeMillis();
                        while (true) {
                            if (System.currentTimeMillis() - startTime > 100)
                                break;
                        }
                        System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);
                    }
                }else{
                    System.out.println(Thread.currentThread().getName() + " timeout");
                }
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " 中断 ");
            }finally {
                // 若当前线程持有锁，则释放
                if(mReentrantLock.isHeldByCurrentThread()){
                    mReentrantLock.unlock();
                }
            }
        }
    }
 
    public static void main(String[] var0) {
        final Counter counter = new Counter();
        new Thread(new Runnable() {
            @Override
            public void run() {
                counter.count();
            }
        }).start();
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                counter.doOtherThing();
            }
        });
        thread2.start();
    }
}

      DEMO5 输出：

      Thread-0， i = 0Thread-0， i = 1Thread-0， i = 2Thread-1 isLock:falseThread-1 timeoutThread-0， i = 3Thread-0， i = 4Thread-0， i = 5

      tryLock() 尝试获得锁，tryLock(long timeout, TimeUnit unit) 在给定的 timeout 时间内尝试获得锁，若超时，则不带锁往下走，所以必须加以判断。

      ReentrantLock or synchronized

      ReentrantLock 、synchronized 之间如何选择？

      ReentrantLock 在性能上 比 synchronized 更胜一筹。

      ReentrantLock 需格外小心，因为需要显式释放锁，lock() 后记得 unlock()，而且必须在 finally 里面，否则容易造成死锁。

      synchronized 隐式自动释放锁，使用方便。

      ReentrantLock 扩展性好，可中断锁，定时锁，自由控制。

      synchronized 一但进入阻塞等待，则无法中断等待。

       

      本文由职坐标整理并发布，希望对同学们学习Java的知识有所帮助。了解更多详情请关注职坐标Java频道!

      java语言程序设计pdf java小程序实例下载 java小程序实例大全
      本文由 @小职 发布于职坐标。未经许可，禁止转载。
      喜欢 | 38 不喜欢 | 2
      看完这篇文章有何感觉？已经有40人表态，95%的人喜欢 快给朋友分享吧~
      评论（0）
      后参与评论
      加入IT交流圈
      JAVA工程师交流群 +加入
      大数据架构师交流群 +加入
      人工智能Python交流群 +加入
      WEB/H5前端交流群 +加入
      职坐标公众号
      编程语言 直通车
      • 索取资料 索取资料 索取资料
      • 答疑解惑 答疑解惑 答疑解惑
      • 技术交流 技术交流 技术交流
      • 职业测评 职业测评 职业测评
      • 面试技巧 面试技巧 面试技巧
      • 高薪秘笈 高薪秘笈 高薪秘笈
      海同师资推荐 更多>>
      黄骈
      黄骈 联系TA
      认证System Analyst，System Architect
      程光淼
      程光淼 联系TA
      精通C、C++等语言、智能芯片开发
      热门就业培训班 更多>>
      【零基础】人工智能+Python全栈开发课程
      【零基础】人工智能+Python全栈开发课程
      人工智能+Python技术风口浪潮
      【零基础】JavaEE高级开发工程师课程
      【零基础】JavaEE高级开发工程师课程
      0基础入学Java课程
      【零基础】大数据与分布式架构师课程
      【零基础】大数据与分布式架构师课程
      培训大数据分布式架构
      JAVA30天热搜词 更多>>
      java语言学习 java从入门到精通第3版pdf java7从入门到精通 java从入门到精通精讲教程 java语言编程 java从入门到精通下载 java语言包教学视频 java语言基础 java从入门到精通第3版光盘 会java好找工作吗 java程序设计实例 java语言程序设计进阶pdf java小程序实例下载 java9新特性 java经典实例 java经典编程300例 java语言程序设计8 java窗口程序实例 java应用程序实例 java语言程序设计基础篇所有答案

      您输入的评论内容中包含违禁敏感词

      我知道了

      助您圆梦职场 匹配合适岗位
      验证码手机号，获得海同独家IT培训资料
      选择就业方向：
      人工智能物联网
      大数据开发/分析
      人工智能Python
      Java全栈开发
      WEB前端+H5

      请输入正确的手机号码

      请输入正确的验证码

      获取验证码

      您今天的短信下发次数太多了，明天再试试吧！

      提交

      我们会在第一时间安排职业规划师联系您！

      您也可以联系我们的职业规划师咨询：

      小职老师的微信号：z_zhizuobiao
      小职老师的微信号：z_zhizuobiao

      版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
      上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com，All Rights Reserved.
       沪公网安备 31011502005948号    

      关于我们 │ 法律声明 │ 联系我们

      ©2015 www.zhizuobiao.com All Rights Reserved

      208小时内训课程
      在线客服