Java并发编程 -- 手动实现可重入Lock-低调大师

Java并发编程 -- 手动实现可重入Lock

2018-03-05 565

Lock就像synchronized块一样是一个线程同步机制。然而，Lock定比synchronized更灵活、更复杂。

Lock和synchronized块的区别

同步块不保证等待输入它的线程被授予访问权限的顺序。
不能将任何参数传递给同步块的条目。
同步块必须完全包含在单个方法中。一个Lock可以在不同的方法中调用lock（）和unlock（）。

简单例子

Lock lock = new ReentrantLock();

lock.lock();

//要保证线程安全的代码

lock.unlock();

其中，你应该能够猜到，lock() 方法是加锁，unlock()方法是解锁。

Lock接口含有的方法

lock()
lockInterruptibly()
tryLock()
tryLock(long timeout, TimeUnit timeUnit)
unlock()

lock（）方法锁定Lock实例。如果锁定实例已被锁定，则线程调用锁定（）将被锁定，直到解锁锁定。

lockInterruptibly（）方法锁定Lock，除非调用该方法的线程已被中断。如果一个线程被阻塞，等待通过此方法锁定Lock，该线程将被中断，并退出此方法调用。（获取锁的时候可以被中断）

tryLock（）方法立即尝试锁定Lock实例。如果锁定成功则返回true;如果Lock已经被锁定，则返回false。 这个方法永远不会阻塞

tryLock（long timeout，TimeUnit timeUnit）的工作方式与tryLock（）方法相似，只是它对超时时间有所规定。

unlock（）方法解锁Lock实例。通常，Lock实现将只允许已锁定Lock的线程调用此方法。调用此方法的其他线程可能会导致未经检查的异常（RuntimeException）。

ReentrantLock实例

ReentrantLock 可重入锁，是Lock的一个子类。我们这里来使用它实现线程安全编程。

package com.lock;

import com.thread.security.Task;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 重入锁
 * Created by Fant.J.
 * 2018/3/6 20:09
 */
public class ReentrantLockTest {

    public int value = 0;

    //实例化重入锁锁
    Lock lock = new ReentrantLock();

    public   int getValue() {
        //加锁
        lock.lock();
        int a = value++;
        //消除锁
        lock.unlock();
        return a;
    }

    public static void main(String[] args) {

        ReentrantLockTest task = new ReentrantLockTest();
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + "  " + task.getValue());
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + "  " + task.getValue());
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }
}

手写自己的Lock实现类

如果有特殊业务需求，我们也可以重写Lock接口，来打造一个自己的lock锁。

package com.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * Created by Fant.J.
 * 2018/3/6 20:12
 */
public class MyLock implements Lock {

    //声明一个判断锁的布尔值
    private boolean isLocked = false;

    /**
     * 必须声明  synchronized 原自行操作，不然jvm不会识别是哪个线程的wait方法，notify也一样
     */
    @Override
    public synchronized void lock() {
        while (isLocked){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isLocked = true;

    }

    @Override
    public synchronized void unlock() {
        isLocked = false;
        notify();
    }


    @Override
    public void lockInterruptibly() throws InterruptedException {

    }


    @Override
    public boolean tryLock() {
        return false;
    }


    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }




    @Override
    public Condition newCondition() {
        return null;
    }
}

然后我们做测试

package com.lock;

/**
 * Created by Fant.J.
 * 2018/3/6 20:24
 */
public class MyLockTest {

    public int value = 0;

    MyLock myLock = new MyLock();

    public int  getValue(){
        myLock.lock();

        value++;

        myLock.unlock();

        return value;
    }

    public static void main(String[] args) {

        MyLockTest task = new MyLockTest();
        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + "  " + task.getValue());
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + "  " + task.getValue());
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }
}

结果没有出现线程安全问题，这里不做截图了，自己可以试试。但是我们写的方法还有一定的问题，就是MyLock这个类不支持可重入锁，意思就是如果有两个锁嵌套，如果相同的线程先调用a方法，再调用带锁的b方法，则就会进入自旋锁。

测试方法源码

package com.lock;

/**
 * Created by Fant.J.
 * 2018/3/6 20:24
 */
public class MyLockTest2 {

    public int value = 0;

    MyLock myLock = new MyLock();

    public void a(){
        myLock.lock();
        System.out.println("a");
        b();
        myLock.unlock();
    }

    public void b(){
        myLock.lock();
        System.out.println("b");
        myLock.unlock();
    }

    public static void main(String[] args) {

        MyLockTest2 task = new MyLockTest2();
        new Thread(){
            @Override
            public void run() {
                task.a();
                }
        }.start();

        new Thread(){
            @Override
            public void run() {
                task.a();
            }
        }.start();
    }
}

执行该方法后，我们会发现，线程停止在打印出"a"后，一直在等待。这就是因为该锁不是可重入锁。

可重入锁的设计

我在这里只贴和上面代码不同的部分。

public class MyLock implements Lock {

    //声明一个判断锁的布尔值
    private boolean isLocked = false;

    Thread lockBy = null;

    int lockCount = 0;

    @Override
    public synchronized void lock() {

        Thread currentThread = Thread.currentThread();  //获取到当前线程
        while (isLocked && currentThread != lockBy){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isLocked = true;
        lockBy = currentThread; //将currentThread线程指向 lockBy线程
        lockCount++;//计数器自增

    }

    @Override
    public synchronized void unlock() {
        if (lockBy == Thread.currentThread()){
            lockCount--;
            if (lockCount ==0 ){
                notify();
                isLocked = false;
            }
        }
    }

}

第一个线程执行a()方法，得到了锁，使lockedBy等于当前线程，也就是说，执行的这个方法的线程获得了这个锁，执行add()方法时，同样要先获得锁，因不满足while循环的条件，也就是不等待，继续进行，将此时的lockedCount变量，也就是当前获得锁的数量加一，当释放了所有的锁，才执行notify()。如果在执行这个方法时，有第二个线程想要执行这个方法，因为lockedBy不等于第二个线程，导致这个线程进入了循环，也就是等待，不断执行wait()方法。只有当第一个线程释放了所有的锁，执行了notify()方法，第二个线程才得以跳出循环，继续执行。

微信关注我们

原文链接：https://yq.aliyun.com/articles/650290

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Java I/O面试题

Java IO是面试中常问到的问题. 参考图输入输出流关系图什么是IO流？它是一种数据的流从源头流到目的地。比如文件拷贝，输入流和输出流都包括了。输入流从文件中读取数据存储到进程(process)中，输出流从进程中读取数据然后写入到目标文件。字节流和字符流的区别。字节流在JDK1.0中就被引进了，用于操作包含ASCII字符的文件。JAVA也支持其他的字符如Unicode，为了读取包含Unicode字符的文件，JAVA语言设计者在JDK1.1中引入了字符流。ASCII作为Unicode的子集，对于英语字符的文件，可以可以使用字节流也可以使用字符流。 Java中流类的超类主要由那些？ java.io.InputStream java.io.OutputStream java.io.Reader java.io.Writer FileInputStream和FileOutputStream是什么？这是在拷贝文件操作的时候，经常用到的两个类。在处理小文件的时候，它们性能表现还不错，在大文件的时候，最好使用BufferedInputStream (或 BufferedReader) ...

2018-03-06

609

一、WCF课程介绍 1.1、Web Service会被WCF取代吗？对于这个问题阿笨的回答是:两者在功能特性上却是有新旧之分，但是对于特定的系统，适合自己的就是最好的。不能哪一个技术框架和行业标准作比较，任何对于二者的比较都是错误的，因为两者根不不在同一个范畴里。就好比不能拿个汽车和交通法规比较一样，这是个误区。阿笨的宗旨就是学完此《C#面向服务编程技术WCF从入门到实战演练》课程，让您从零基础上手后直接将学习的成果运用到实际项目中去。阿笨本次分享的WCF技术是完全来源于切身实际项目中，如何让零基础的童鞋们快速的上手和使用WCF技术！让你感觉到使用WCF技术就像WebSerice一样亲切，让WCF客户端的“调用”成为一种“享受”！ WCF绝对是值得学习的一门技术，并且如果深入研究后会发现，它真的不简单！如果您对本次分享课感兴趣的话，那么请跟着阿笨一起学习吧。废话不多说，直接上干货，我们不生产干货，我们只是干货的搬运工。二、WebService和WCF两者到底有什么区别 WebService：严格来说是行业标准，也就是WebService规范，也称作WS-*规范，既不是框架，也不...

2018-03-06

504

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。