专栏首页bingfeng-技术Java中确保线程安全最常用的两种方式

Java中确保线程安全最常用的两种方式

阅读本文大概需要11分钟。

上篇文章我们简单聊了什么是多线程,我想大家对多线程已经有了一个初步的了解,没看的没有放下文章链接 什么是线程安全,你真的了解吗?

上篇我们搞清楚了什么样的线程是安全的,我们今天先来看段代码:

public void threadMethod(int j) {

     int i = 1;

    j = j + i;
}

大家觉得这段代码是线程安全的吗?

毫无疑问,它绝对是线程安全的,我们来分析一下为什么它是线程安全的?

我们可以看到这段代码是没有任何状态的,什么意思,就是说我们这段代码不包含任何的作用域,也没有去引用其他类中的域进行引用,它所执行的作用范围与执行结果只存在它这条线程的局部变量中,并且只能由正在执行的线程进行访问。当前线程的访问不会对另一个访问同一个方法的线程造成任何的影响。

两个线程同时访问这个方法,因为没有共享的数据,所以他们之间的行为并不会影响其他线程的操作和结果,所以说无状态的对象也是线程安全的。

添加一个状态呢?

如果我们给这段代码添加一个状态,添加一个count,来记录这个方法并命中的次数,每请求一次count+1,那么这个时候这个线程还是安全的吗?

public class ThreadDemo {

    int count = 0; // 记录方法的命中次数

    public void threadMethod(int j) {
        
        count++ ;

        int i = 1;

        j = j + i;
    }
}

很明显已经不是了,单线程运行起来确实是没有任何问题的,但是当出现多条线程并发访问这个方法的时候,问题就出现了,我们先来分析下count+1这个操作。

进入这个方法之后首先要读取count的值,然后修改count的值,最后才把这把值赋值给count,总共包含了三步过程:“读取”一>“修改”一>“赋值”,既然这个过程是分步的,那么我们先来看下面这张图,看看你能不能看出问题:

可以发现,count的值并不是正确的结果,当线程A读取到count的值,但是还没有进行修改的时候,线程B已经进来了,然后线程B读取到的还是count为1的值,正因为如此所以我们的count值已经出现了偏差,那么这样的程序放在我们的代码中是存在很多的隐患的。

2、如何确保线程安全?

既然存在线程安全的问题,那么肯定得想办法解决这个问题,怎么解决?我们说说常见的几种方式。

1、synchronized

synchronized关键字就是用来控制线程同步的,保证我们的线程在多线程环境下,不被多个线程同时执行,确保我们数据的完整性,使用方法一般是加在方法上。

public class ThreadDemo {

    int count = 0; // 记录方法的命中次数

    public synchronized void threadMethod(int j) {

        count++ ;

        int i = 1;

        j = j + i;
    }
}

这样就可以确保我们的线程同步了,同时这里需要注意一个大家平时忽略的问题,首先synchronized锁的是括号里的对象,而不是代码,其次,对于非静态的synchronized方法,锁的是对象本身也就是this

当synchronized锁住一个对象之后,别的线程如果想要获取锁对象,那么就必须等这个线程执行完释放锁对象之后才可以,否则一直处于等待状态。

注意点:虽然加synchronized关键字可以让我们的线程变的安全,但是我们在用的时候也要注意缩小synchronized的使用范围,如果随意使用时很影响程序的性能,别的对象想拿到锁,结果你没用锁还一直把锁占用,这样就应了一句话:占着茅坑不拉屎,属实有点浪费资源。

2、Lock

先来说说它跟synchronized有什么区别吧,Lock是在Java1.6被引入进来的,Lock的引入让锁有了可操作性,什么意思?就是我们在需要的时候去手动的获取锁和释放锁,甚至我们还可以中断获取以及超时获取的同步特性,但是从使用上说Lock明显没有synchronized使用起来方便快捷。

我们先来看下一般是如何使用的:

private Lock lock = new ReentrantLock(); // ReentrantLock是Lock的子类

    private void method(Thread thread){
        lock.lock(); // 获取锁对象
        try {
            System.out.println("线程名:"+thread.getName() + "获得了锁");
            // Thread.sleep(2000);
        }catch(Exception e){
            e.printStackTrace();
        } finally {
            System.out.println("线程名:"+thread.getName() + "释放了锁");
            lock.unlock(); // 释放锁对象
        }
    }

进入方法我们首先要获取到锁,然后去执行我们业务代码,这里跟synchronized不同的是,Lock获取的所对象需要我们亲自去进行释放,为了防止我们代码出现异常,所以我们的释放锁操作放在finally中,因为finally中的代码无论如何都是会执行的。

写个主方法,开启两个线程测试一下我们的程序是否正常:

public static void main(String[] args) {
        LockTest lockTest = new LockTest();

        // 线程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                // Thread.currentThread()  返回当前线程的引用
                lockTest.method(Thread.currentThread());
            }
        }, "t1");

        // 线程2
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t2");

        t1.start();
        t2.start();
    }

结果:

可以看出我们的执行是没有任何问题的。

其实在Lock还有几种获取锁的方式,我们这里再说一种就是tryLock()这个方法跟Lock()是有区别的,Lock在获取锁的时候如果拿不到锁就一直处于等待状态,直到拿到锁,但是tryLock()却不是这样的,tryLock是有一个Boolean的返回值的,如果没有拿到锁直接返回false,停止等待,它不会像Lock()那样去一直等待获取锁。

我们来看下代码:

private void method(Thread thread){
        // lock.lock(); // 获取锁对象
        if (lock.tryLock()) {
            try {
                System.out.println("线程名:"+thread.getName() + "获得了锁");
                // Thread.sleep(2000);
            }catch(Exception e){
                e.printStackTrace();
            } finally {
                System.out.println("线程名:"+thread.getName() + "释放了锁");
                lock.unlock(); // 释放锁对象
            }
        }
    }

结果:我们继续使用刚才的两个线程进行测试可以发现,在线程t1获取到锁之后,线程t2立马进来,然后发现锁已经被占用,那么这个时候它也不在继续等待。

似乎这种方法感觉不是很完美,如果我第一个线程拿到锁的时间比第二个线程进来的时间还要长,是不是也拿不到锁对象,那我能不能用一中方式来控制一下,让后面等待的线程可以需要等待5秒,如果5秒之后还获取不到锁,那么就停止等,其实tryLock()是可以进行设置等待的相应时间的。

private void method(Thread thread) throws InterruptedException {
        // lock.lock(); // 获取锁对象

        // 如果2秒内获取不到锁对象,那就不再等待
        if (lock.tryLock(2,TimeUnit.SECONDS)) {
            try {
                System.out.println("线程名:"+thread.getName() + "获得了锁");

                // 这里睡眠3秒
                Thread.sleep(3000);
            }catch(Exception e){
                e.printStackTrace();
            } finally {
                System.out.println("线程名:"+thread.getName() + "释放了锁");
                lock.unlock(); // 释放锁对象
            }
        }
    }

结果:看上面的代码我们可以发现,虽然我们获取锁对象的时候可以等待2秒,但是我们线程t1在获取锁对象之后执行任务缺花费了3秒,那么这个时候线程t2是不在等待的。

我们再来改一下这个等待时间,改为5秒,再来看下结果:

private void method(Thread thread) throws InterruptedException {
        // lock.lock(); // 获取锁对象

        // 如果5秒内获取不到锁对象,那就不再等待
        if (lock.tryLock(5,TimeUnit.SECONDS)) {
            try {
                System.out.println("线程名:"+thread.getName() + "获得了锁");
            }catch(Exception e){
                e.printStackTrace();
            } finally {
                System.out.println("线程名:"+thread.getName() + "释放了锁");
                lock.unlock(); // 释放锁对象
            }
        }
    }

结果:这个时候我们可以看到,线程t2等到5秒获取到了锁对象,执行了任务代码。

这就是使用Lock来保证我们线程安全的方式,其实Lock还有好多的方法来操作我们的锁对象,这里我们就不多说了,大家有兴趣可以看一下API。

PS:现在你能做到如何确保一个方法是线程安全的吗?

谢谢支持

如果文章存在如何技术问题,欢迎大家评论区指正,大家一起学习交流,原创不易,你的点赞转发对我是最好的支持

本文分享自微信公众号 - 一个程序员的成长(xiaozaibuluo),作者:一个程序员的成长

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

原始发表时间:2018-08-31

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

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 线程中断以及线程中断引发的那些问题,你值得了解

    上周写了一篇多线程的文章,其实更多方面是偏基础一点的文章,而且也比较大白话,争取人人都能看的明白,再举一些常见的例子,能很好的帮助大家理解多线程,文章发表之后我...

    一个程序员的成长
  • 一文看懂线程的生命周期,利用线程池模拟群发短信

    Java给多线程编程提供了内置的支持。,一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务,能满足程序员编写高效率...

    一个程序员的成长
  • Executors使用不当引起的内存泄漏

    这周刚上班突然有一个项目内存溢出了,排查了半天终于找到问题所在,在此记录下,防止后面再次出现类似的情况。

    一个程序员的成长
  • java多线程实现原理

    java的内存模式 线程 - 工作内存 - 主存。线程会读写工作内存,CPU会周期性的将工作数据刷入主存,如果多个线程写工作内存,就会导致每个线程的工作内存、主...

    逝兮诚
  • 你不知道的线程池构造方法的那些趣事?

    欢迎关注我的公众号“彤哥读源码”,查看更多源码系列文章, 与彤哥一起畅游源码的海洋。

    彤哥
  • Java--线程的创建和启动

    SuperHeroes
  • 注意 ansi c 库函数 在多线程时可能出错的问题

    https://blog.csdn.net/qq_22423659/article/details/53426953

    用户7886150
  • JAVA线程之ThreadLocal与栈封闭(六)

    PS:这次说了线程封闭的概念,其实很容易理解只要知道在ThreadLocal是JVM内部维护了一个Map就可以了。栈封闭没有纤细概述,跟局部变量是一个概念。

    IT故事会
  • 翻译 | 可重入与线程安全

      在整个文档中,术语:「可重入和线程安全」用于标记类和函数,以表示它们如何在多线程应用程序中使用:

    Qt君
  • ReentrantLock源码解析

    在java编程中,经常需要多代码进行加锁来防止多线程可能引起的数据不一致。而锁的类型有公平锁和非公平锁。公平锁的意义就是按照顺序,而非公平锁则是相反的。也就是说...

    写一点笔记

扫码关注云+社区

领取腾讯云代金券