专栏首页Java学习录浅谈Java中的锁:Synchronized、重入锁、读写锁

浅谈Java中的锁:Synchronized、重入锁、读写锁

Java开发必须要掌握的知识点就包括如何使用锁在多线程的环境下控制对资源的访问限制

Synchronized

首先我们来看一段简单的代码:

public class NotSyncDemo {    public static int i=0;    static class ThreadDemo extends Thread {        @Override        public void run() {           for (int j=0;j<10000;j++){               i++;           }        }    }    public static void main(String[] args) throws InterruptedException {        ThreadDemo t1=new ThreadDemo();        ThreadDemo t2=new ThreadDemo();        t1.start();t2.start();        t1.join();        t2.join();        System.out.println(i);    }}

上方的代码使用了2个线程同时对静态变量i进行++操作,理想中的结果最后输出的i的值应该是20000才对,但是如果你执行这段代码的时候你会发现最后的结果始终是一个比20000小的数。这个就是由于JMM规定线程操作变量的时候只能先从主内存读取到工作内存,操作完毕后在写到主内存。而当多个线程并发操作一个变量时很可能就会有一个线程读取到另外一个线程还没有写到主内存的值从而引起上方的现象。更多关于JMM的知识请参考此文章:Java多线程内存模型

想要避免这种多线程并发操作引起的数据异常问题一个简单的解决方案就是加锁。JDK提供的synchronize就是一个很好的选择。

synchronize的作用就是实现线程间的同步,使用它加锁的代码同一时刻只能有一个线程访问,既然是单线程访问那么就肯定不存在并发操作了。

synchronize可以有多种用法,下面给出各个用法的示例代码。

Synchronized的三种使用方式

给指定对象加锁,进入代码前需要获得对象的锁

public class SyncObjDemo {    public static Object obj = new Object();    public static int i = 0;    static class ThreadDemo extends Thread {        @Override        public void run() {            for (int j = 0; j < 10000; j++) {                synchronized (obj) {                    i++;                }            }        }    }    public static void main(String[] args) throws InterruptedException {        ThreadDemo t1 = new ThreadDemo();        ThreadDemo t2 = new ThreadDemo();        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println(i);    }}

给方法加锁,相当于给当前实例加锁,进入代码前需要获得当前实例的锁

public class SyncMethodDemo {    public static int i = 0;    static class ThreadDemo extends Thread {        @Override        public void run() {            for (int j = 0; j < 10000; j++) {                 add();            }        }        public synchronized void add(){            i++;        }    }    public static void main(String[] args) throws InterruptedException {        ThreadDemo threadDemo=new ThreadDemo();        Thread t1 = new Thread(threadDemo);        Thread t2 = new Thread(threadDemo);        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println(i);    }}

给静态方法加锁,相当于给当前类加锁,进入代码前需要获得当前类的锁。这种方式请慎用,都锁住整个类了,那效率能高哪去

public static synchronized void add(){            i++;        }

重入锁

在JDK6还没有优化synchronize之前还有一个锁比它表现的更为亮眼,这个锁就是重入锁。

我们来看一下一个简单的使用重入锁的案例:

public class ReentrantLockDemo {    public static ReentrantLock lock = new ReentrantLock();    public static int i = 0;
    static class ThreadDemo extends Thread {        @Override        public void run() {            for (int j = 0; j < 10000; j++) {                lock.lock();                 try {                     i++;                 }finally {                     lock.unlock();                 }            }        }    }
    public static void main(String[] args) throws InterruptedException {        ThreadDemo t1 = new ThreadDemo();        ThreadDemo t2 = new ThreadDemo();        t1.start();        t2.start();        t1.join();        t2.join();        System.out.println(i);    }}

上方代码使用重入锁同样实现了synchronize的功能。并且呢,我们可以看到使用冲入锁是显示的指定什么时候加锁什么时候释放的,这样对于一些流程控制就会更加的有优势。

再来看这个锁为什么叫做重入锁呢,这是因为这种锁是可以反复进入的,比如说如下操作是允许的。

lock.lock();lock.lock();try {  i++;}finally {    lock.unlock();    lock.unlock();}

不过需要注意的是如果多次加锁的话同样也要记得多次释放,否则资源是不能被其他线程使用的。

在之前的文章:多线程基本概念 中有提到过因为线程优先级而导致的饥饿问题,重入锁提供了一种公平锁的功能,可以忽略线程的优先级,让所有线程公平竞争。使用公平锁的方式只需要在重入锁的构造方法传入一个true就可以了。

    public static ReentrantLock lock = new ReentrantLock(true);

重入锁还提供了一些高级功能,例如中断。

对于synchronize来说,如果一个线程获取资源的时候要么阻塞要么就是获取到资源,这样的情况是无法解决死锁问题的。而重入锁则可以响应中断,通过放弃资源而解决死锁问题。

使用中断的时候只需要把原先的lock.lock()改成lock.lockInterruptibly()就OK了。

来看代码示例:

public class ReentrantLockInterruptDemo {    public static ReentrantLock lock1 = new ReentrantLock();    public static ReentrantLock lock2 = new ReentrantLock();    static class ThreadDemo extends Thread {        int i = 0;        public ThreadDemo(int i) {            this.i = i;        }
        @Override        public void run() {            try {                if (i == 1) {                    lock1.lockInterruptibly();                    try {                        Thread.sleep(1000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    lock2.lockInterruptibly();                } else {                    lock2.lockInterruptibly();                    try {                        Thread.sleep(1000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    lock1.lockInterruptibly();                }                System.out.println(Thread.currentThread().getName() + "完成任务");            } catch (InterruptedException e) {                e.printStackTrace();            } finally {                if (lock1.isHeldByCurrentThread()) {                    lock1.unlock();                }                if (lock2.isHeldByCurrentThread()) {                    lock2.unlock();                }                System.out.println(Thread.currentThread().getName() + "退出");            }        }    }
    public static void main(String[] args) throws InterruptedException {        Thread t1 = new Thread(new ThreadDemo(1),"t1");        Thread t2 = new Thread(new ThreadDemo(2),"t2");        t1.start();        t2.start();        Thread.sleep(1500);        t1.interrupt();    }}

查看上方代码我们可以看到,线程t1启动后先占有lock1,然后会在睡眠1秒之后试图占有lock2,而t2则先占有lock2,然后试图占有lock1。这个过程则势必会发生死锁。而如果再这个时候我们给t1一个中断的信号t1就会响应中断从而放弃资源,继而解决死锁问题。

除了提供中断解决死锁以外,重入锁还提供了限时等待功能来解决这个问题。

限时等待的使用方式是使用lock.tryLock(2,TimeUnit.SECONDS)

这个方法有两个参数,前面是等待时长,后面是等待时长的计时单位,如果在等待时长范围内获取到了锁就会返回true。

请看代码示例:

public class ReentrantLockTimeDemo {    public static ReentrantLock lock = new ReentrantLock();    static class ThreadDemo extends Thread {        @Override        public void run() {            try {                if (lock.tryLock(2, TimeUnit.SECONDS)) {                    try {                        System.out.println(Thread.currentThread().getName() + "获取锁成功");                        Thread.sleep(3000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                } else {                    System.out.println(Thread.currentThread().getName() + "获取锁失败");                }            } catch (InterruptedException e) {                e.printStackTrace();            } finally {                if (lock.isHeldByCurrentThread()) {                    lock.unlock();                }            }        }    }    public static void main(String[] args) throws InterruptedException {        Thread t1 = new Thread(new ThreadDemo(), "t1");        Thread t2 = new Thread(new ThreadDemo(), "t2");        t1.start();        t2.start();    }}

同样的tryLock也可以不带参数,不带参数的时候就是表示立即获取,获取不成功就直接返回false

我们知道synchronize配合wait和notify可以实现等待通知的功能,重入锁同样也提供了这种功能的实现。那就是condition。使用lock.newCondition()就可以获得一个Condition对象。

下面请看使用Condition的代码示例:

public class ReentrantLockWaitNotifyThread {    public static ReentrantLock lock = new ReentrantLock();    public static Condition condition = lock.newCondition();    static class WaitThreadDemo extends Thread {        @Override        public void run() {            try {                System.out.println("WaitThread wait,time=" + System.currentTimeMillis());                lock.lock();                condition.await();            } catch (InterruptedException e) {                e.printStackTrace();            }finally {                lock.unlock();                System.out.println("WaitThread end,time=" + System.currentTimeMillis());            }        }    }    static class NotifyThreadDemo extends Thread {        @Override        public void run() {                lock.lock();                System.out.println("NotifyThread notify,time=" + System.currentTimeMillis());                condition.signal();                try {                    Thread.sleep(2000);                } catch (InterruptedException e) {                    e.printStackTrace();                }finally {                    lock.unlock();                    System.out.println("NotifyThread end,time=" + System.currentTimeMillis());                }            }    }
    public static void main(String[] args) {        WaitThreadDemo waitThreadDemo = new WaitThreadDemo();        NotifyThreadDemo notifyThreadDemo = new NotifyThreadDemo();        waitThreadDemo.start();        try {            Thread.sleep(100);        } catch (InterruptedException e) {            e.printStackTrace();        }        notifyThreadDemo.start();    }}

读写锁

通过上方的内容我们知道了为了解决线程安全问题,JDK提供了相当多的锁来帮助我们。但是如果多线程并发读的情况下是不会出现线程安全问题的,那么有没有一种锁可以在读的时候不控制,读写冲突的时候才会控制呢。答案是有的,JDK提供了读写分离锁来实现读写分离的功能。

这里给出使用读写锁的一个代码示例

public class ReadWriteLockDemo {    public static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();    public static Lock readLock = readWriteLock.readLock();    public static Lock writeLock = readWriteLock.writeLock();
    public static void read(Lock lock) {        lock.lock();        try {            System.out.println("readTime:" + System.currentTimeMillis());            Thread.sleep(2000);        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            lock.unlock();        }    }
    public static void write(Lock lock) {        lock.lock();        try {            System.err.println("writeTime:" + System.currentTimeMillis());            Thread.sleep(2000);        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            lock.unlock();        }    }
    static class ReadThread extends Thread {        @Override        public void run() {            read(readLock);        }    }
    static class WriteThread extends Thread {        @Override        public void run() {            write(writeLock);        }    }
    public static void main(String[] args) throws InterruptedException {        for (int i = 0; i < 10; i++) {            new ReadThread().start();        }        new WriteThread().start();        new WriteThread().start();        new WriteThread().start();    }}

上方代码模拟了10个线程并发读,3个线程并发写的状况,如果我们使用synchronize或者重入锁的时候我想上方最后的耗时应该是26秒多。但是如果你执行 一下上方的代码你就会发现仅仅只花费了6秒多。这就是读写锁的魅力。

本文分享自微信公众号 - Java学习录(Javaxuexilu),作者:Java学习录

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-03-23

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • JVM的类加载机制

    加载是第一阶段,因为此时的虚拟机中还没有class的相关信息,必须将class文件加载到虚拟机中才能进行接下来的操作。加载的过程主要分为以下3个步骤:

    Java学习录
  • EurekaClient自动装配及启动流程解析

    老规矩,先看spring.factories文件,其中引入了一个配置类EurekaDiscoveryClientConfigServiceBootstrapCo...

    Java学习录
  • 基于注解的SpringAOP源码解析(二)

    在上篇文章中我们搭建了一个阅读源码的demo工程,然后简单介绍了一下@EnableAspectJAutoProxy注解,这个注解最重要的功能就是为向Spring...

    Java学习录
  • 结构型设计模式:装饰器(者)模式实例介绍

    我觉得装饰者模式是在已有功能的基础之上,动态地添加更多 功能的一种方式,这些新加的代码装饰了原有类的 核心职责或主要行为。

    程序你好
  • 微信小程序开发工具 微信小程序平台开发小程序公司

    小程序倡导更加便捷的生活服务理念,无需下载,唾手可得,即用即走,未来,普通人的生活里,小程序将无处不在。

    微信小程序开发加盟服务商
  • 程序猿之间的各种鄙视链,你是否也曾经被屌?

    程序员——是一个集思维、情商、行为都异于其他传统岗位的群体。清高自傲、闷骚、会修电脑、宅、不善交际、几百年不洗的衬衫牛仔双肩包…,代表着程序员这个群体的鲜明标签...

    Java技术栈
  • Java多线程学习(六)Lock锁的使用

    我自己总结的Java学习的系统知识点以及面试问题,目前已经开源,会一直完善下去,欢迎建议和指导欢迎Star: https://github.com/Snailc...

    用户2164320
  • xls数据导出会内存溢出

    我们在后台开发的时候,经常会碰到数据导出。我们一般都是试用xls格式进行导出。但是有个问题,就是使用类库对内存的占用特别的大。结果稍微复杂一些的数据就会导致内存...

    魔王卷子
  • Java外观模式(门面模式Facade)

      外观模式也叫门面模式,是开发过程中使用频率非常高的一种设计模式,但非常容易理解。

    用户4919348
  • Django-Form表单(验证、定制、错误信息、Select)

    封装到类的对象里,obj=UserInfo(request.POST)

    菲宇

扫码关注云+社区

领取腾讯云代金券