（四）Java并发学习笔记--线程不安全类与写法

最新推荐文章于 2021-02-28 11:15:05 发布
最新推荐文章于 2021-02-28 11:15:05 发布
阅读量90 收藏
点赞数
文章标签： java
原文链接：https://yq.aliyun.com/articles/636352
版权

常见线程不安全的类有哪些呢

下图中，我们只画出了最常见的几种情况，我们常见的Collections集合都是线程不安全的

img_7b4cfca9014827d8915693666ddf8a5b.png
  • StringBuilder-demo:
@Slf4j
public class StringExample1 {

    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;

    public static StringBuilder stringBuilder = new StringBuilder();

    private  static void update() {
        stringBuilder.append("1");
    }

    public static void main(String[] args)throws Exception {

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size:{}",stringBuilder.length());

    }

}

我测试的时候输出为，4985（因为线程不安全，所以每次的输出可能是不同的），如果StringBuilder类为线程安全的话，输出应该为5000

  • StringBuffer-demo
@Slf4j
public class StringExample2 {

    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;

    public static StringBuffer stringBuffer = new StringBuffer();

    private  static void update() {
        stringBuffer.append("1");
    }

    public static void main(String[] args)throws Exception {

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size:{}",stringBuffer.length());

    }

}

输出为5000，且多次测试结果均为5000，证明StringBuffer类是线程安全的，通过看StringBuffer的实现可发现，其所有的实现都是加了synchronized关键字的，虽然可以保证线程安全但是性能是有损耗的，这也证明了StringBuilder的存在价值，如果定义StringBuilder为局部变量时是没有线程安全问题的，这就用到了上篇博客我们讲的堆栈封闭原理

  • simpleDateFormat-demo1
@Slf4j
public class DateFormatExample1 {

    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");

    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;


    private  static void update() {
        try {
            simpleDateFormat.parse("20180208");
        } catch (ParseException e) {
            log.error("parse exception",e);
        }
    }

    public static void main(String[] args)throws Exception {

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();

    }
}

运行结果如下：


img_7dc5e8eba8918d5f0c199b3679620ed4.png

因为simpleDateFormat为线程不安全的类，所以在多线程访问的时候出现了异常

  • simpleDateFormat-demo2:
@Slf4j
public class DateFormatExample2 {


    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;


    private  static void update() {
        try {
            //用堆栈封闭的方式
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
            simpleDateFormat.parse("20180208");
        } catch (ParseException e) {
            log.error("parse exception",e);
        }
    }

    public static void main(String[] args)throws Exception {

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();

    }
}

此demo为demo1的改进版，将SimpleDateFormat声明为局部变量，运用了堆栈封闭的方式保证了线程安全，运行此demo是没有异常抛出的

  • jodatime-demo
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

@Slf4j
public class DateFormatExample3 {


    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;

    private static DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyyMMdd");


    private  static void update(int i) {
        log.info("{},{}",i,DateTime.parse("20180208", dateTimeFormatter).toDate());
    }

    public static void main(String[] args)throws Exception {

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {

            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();

    }
}

此demo引用了joda.time包，保证了线程安全，在实际的开发中，我们更推荐做日期转换的时候使用此包，这种处理方法不仅能保证线程安全，而且还有其它的优势。我导入的包如下：

        <dependency>
          <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.9</version>
        </dependency>

以下我们做ArrayList，HashMap，HashSet的实例演示，它们都是线程不安全的，还好我们一般都将它们定义为局部变量（堆栈封闭），如果我们将它们定义为成员变量或static修饰的变量，在多个线程同时访问的时候就很容易出问题。

  • ArrayList-demo

@Slf4j
public class ArrayListExample {

    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;

    //arraylist是线程不安全的
    private static List<Integer> list = new ArrayList<>();


    private  static void update(int i) {
        list.add(i);
    }

    public static void main(String[] args)throws Exception {

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {

            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size:{}", list.size());

    }
}

如果是线程安全的输出应该为5000，实际输出为4945，且每次运行输出的值可能不一样，所以它是线程不安全的

  • HashSet-demo
@Slf4j
public class HashSetExample {

    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;

    //HashSet是线程不安全的
    private static Set<Integer> set = new HashSet<>();


    private  static void update(int i) {
        set.add(i);
    }

    public static void main(String[] args)throws Exception {

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {

            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size:{}", set.size());

    }
}

输出为4985，是线程不安全的(线程安全的话输出为5000)

  • HashMap-demo
@Slf4j
public class HashMapExample {

    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;

    //HashMap是线程不安全的
    private static Map<Integer,Integer> map = new HashMap<>();


    private  static void update(int i) {
        map.put(i,i);
    }

    public static void main(String[] args)throws Exception {

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {

            final int count = i;
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    update(count);
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("size:{}", map.size());

    }
}

输出为4886（且每次运行输出值可能不同），是线程不安全的（线程安全的话输出为5000）

线程不安全的写法

典型的线程不安全的写法是：先检查，再执行

if（condition（a））{handle（a）；} 就算a是一个线程安全的类所对应的对象，对a的处理handle（a）也是原子性的，但由于这两步之间的不是原子性的也会引发线程安全问题，如A、B两个线程都通过了a的判断条件，A线程执行handle（a）之后，a已经不符合condition（a）的判断条件了，可是此时B线程仍然要执行handle（a），这就引发了线程安全问题。

weixin_34405925
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Semaphore 用法和原理剖析！
程序员cxuan的个人主页
04-16 2014
这是并发线程工具类的第二篇文章，在第一篇中，我们分析过 CountDownLatch 的相关内容，你可以参考 一文搞懂 CountDownLatch 用法和源码！ 那么本篇文章我们继续来和你聊聊并发工具类的第二篇文章 — Semaphore 。 认识 Semaphore Semaphore 是什么 Semaphore 一般译作 信号量，它也是一种线程同步工具，主要用于多个线程对共享资源进行并行操作的一种工具类。它代表了一种许可的概念，是否允许多线程对同一资源进行操作的许可，使用 Semaphore 可以控制
并发编程与高并发（三）：线程安全策略
帅过驴的袋鼠的博客
09-22 378
一、不可变对象 二、线程封闭 三、线程不安全类与写法 四、同步容器
线程安全（八）Semaphore
relife
06-05 590
0.前言 Semaphore ：信号量，使用AQS类型的同步状态持有当前可用许可的数量。 1.方法分析 1.1.构造方法： Semaphore(int permits):创建具有给定许可数的计数信号量并设置为非公平信号量。 Semaphore(int permits,boolean fair):当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。 1.2.方法 void acquire():从此信号量获取一个许可前线程将一直阻塞。 void acquire(int n):从此信号量
线程同步：Semaphore、CyclicBarrier、CountDownLatch
胡飞洋的技术积累
07-15 317
一、SemaphoreSemaphore：信号量，用于限制某段代码的并发数。当permits为1，相当于synchronized。直接上代码： /** * test Semaphore * 信号量，用于限制某段代码的并发数。 * 当N为1，相当于synchronized */ private void threadTest5() { ...
Java之——SimpleDateFormat 线程不安全问题及解决方法
冰河的专栏
12-18 3860
今天，给大家带来一篇Java SimpleDateFormat在多线程环境下不安全的文章，Java SimpleDateFormat 是线程不安全的，当在多线程环境下使用一个DateFormat的时候是有问题的，如下面的例子 package com.lya.date; import java.text.SimpleDateFormat; import java.util.ArrayList; i
JAVA并发编程实践-线程安全-学习笔记
07-20
线程安全就是对共享的、可变的状态进行管理，对象的状态就是它的数据，换句话说就是在不可控制的并发访问中保护数据。
JAVA并发编程实践-线程的关闭与取消-学习笔记
最新发布
07-22
java中没有提供任何机制，来安全是强迫线程停止手头的工作，Thread.stop和 Thread.suspend方法存在严重的缺陷，不能使用。程序不应该立即停止，应该采用中断这种协作机制来处理，正确的做法是:先清除当前进程中的...
JAVA并发编程实践-线程对象与组合对象-学习笔记
07-20
使用java.util.concurrent类库构造安全的并发应用程序的基础。共享其实就是某一线程的数据改变对其它线程可见，否则就会出现脏数据。
JAVA并发编程-2-线程并发工具类
01-20
JAVA并发编程-2-线程并发工具类一、Fork/Join1、分而治之与工作密取2、使用标准范式3、Fork/Join的同步用法4、Fork/Join的异步用法二、CountDownLatch三、CyclicBarrier四、Semaphore信号量五、Exchanger ...
JAVA并发编程实践-线程执行-学习笔记
07-21
围绕任务执行来管理应用程序时，第一步要指明一个清晰的任务边界，理想情况下，任务是 独立活动的，它的工作并不依赖于其他任务的状态、结果或边界效应，独立有利于并发性。应用程 序应该在负荷过载时平缓地劣化，而...
并发编程（九）：线程不安全的类与写法
weixin_30369041的博客
05-08 155
什么是线程不安全的类呢？ 如果一个类的对象同时被多个线程访问，如果不做特殊的同步或并发处理，很容易表现出线程不安全的现象，比如抛出异常、逻辑处理错误等，这种类我们就称为线程不安全的类 常见线程不安全的类有哪些呢 下图中，我们只画出了最常见的几种情况，我们常见的Collections集合都是线程不安全的 StringBuilder-demo @Slf...
【面試(自己看)】一、JUC多线程及高并发(2)之集合的线程不安全问题
hardworking_boy的博客
03-22 121
【大厂原题】 我们知道ArrayList是线程不安全的,请编码写一个不安全的案例并给出解决方案
ExecutorService关闭线程池
王仁一的博客
12-02 3188
public class ExcutorTest {     static ExecutorService threadPool = Executors.newFixedThreadPool(1000);     public static int count = 0;     public static void main(String[] str) {         Task task =...
java service 线程安全_关于java：ExecutorService(特别是ThreadPoolExecutor)线程安全吗？...
weixin_36352415的博客
02-28 1041
ExecutorService是否保证线程安全？我将把来自不同线程的作业提交到同一个ThreadPoolExecutor，在交互/提交任务之前，是否必须同步对执行者的访问？(与其他答案相反)记录了线程安全协定：在interface javadocs中查找(与方法的javadoc相对)。例如，在ExecutorService javadoc的底部，您可以找到：Memory consistency e...
线程不安全的原因
geelong的博客
05-02 243
  package ThreadTest; public class ThreadTest { public static void main(String args[]){ MyThread mt = new MyThread() ; // 定义线程对象 Thread t1 = new Thread(mt) ; // 定义Th...
Java并发编程(8)——常见的线程安全问题
黄规速博客:学如逆水行舟，不进则退
06-03 5226
多个线程同时执行也能工作的代码就是线程安全的代码 如果一段代码可以保证多个线程访问的时候正确操作共享数据，那么它是线程安全的。 具体说明： java并发线程实战(1) 线程安全和机制原理 专栏总结java5：并发编程 总结常见的线程并发问题：...
线程不安全类与写法
技术分享，读书笔记，面试宝典，算法积累，应有尽有～
09-18 200
此篇文章我们来验证一些类是否是线程安全，而且列举一些平时开发中线程不安全的写法，主要如下： StringBuilder 和 StringBuffer SimpleDateFormat 和 JodaTime ArrayList，HashSet，HashMap等Collections
Spring 中线程的安全问题
weixin_46164384的博客
05-25 386
一、首先，介绍spring容器中的Bean 作用域有如下5种： singleton 单例模式 prototype 原型模式 request (WebApplicationContext环境) session (WebApplicationContext环境) global-session (WebApplicationContext环境) singleton 在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例。spring默认是singleton。 prototype
如何处理线程安全问题？
进击的熊
05-24 257
线程安全问题案例 public class Demo03Ticket { public static void main(String[] args) { Runnable r = new Ticket(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.setName("一号窗口");
java多线程不共享_9、Java并发性和多线程-线程安全与共享资源
06-09
另外，在Java中还有一些线程安全的集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，它们在实现上已经考虑了多线程访问的情况，可以直接用于多线程环境下。 总之，保证线程安全和正确使用共享资源是Java多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值