（四）Java并发学习笔记--线程不安全类与写法
常见线程不安全的类有哪些呢
下图中，我们只画出了最常见的几种情况，我们常见的Collections集合都是线程不安全的
- 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();
}
}
运行结果如下：
因为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），这就引发了线程安全问题。
关注公众号
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。
持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
转载内容版权归作者及来源网站所有，本站原创内容转载请注明来源。
-
上一篇
再有人问你volatile是什么，就把这篇文章发给他
Java语言为了解决并发编程中存在的原子性、可见性和有序性问题，提供了一系列和并发处理相关的关键字，比如synchronized、volatile、final、concurren包等。在前一篇文章中，我们也介绍了synchronized的用法及原理。本文，来分析一下另外一个关键字——volatile。 本文就围绕volatile展开，主要介绍volatile的用法、volatile的原理，以及volatile是如何提供可见性和有序性保障的等。 volatile这个关键字，不仅仅在Java语言中有，在很多语言中都有的，而且其用法和语义也都是不尽相同的。尤其在C语言、C++以及Java中，都有volatile关键字。都可以用来声明变量或者对象。下面简单来介绍一下Java语言中的volatile关键字。 volatile的用法 volatile通常被比喻成"轻量级的synchronized"，也是Java并发编程中比较重要的一个关键字。和synchronized不同，volatile是一个变量修饰符，只能用来修饰变量。无法修饰方法及代码块等。 volatile的用法比较简单，只需要在声明一个...
-
下一篇
一文读懂JDK1.7,JDK1.8,JDK1.9的hashmap，hashtable，concurrenthashmap及他们的区别
本篇为威力加强升级版本，读到最后，有惊吓 1：hashmap简介（如下，数组-链表形式） HashMap的存储结构 图中，紫色部分即代表哈希表，也称为哈希数组（默认数组大小是16，每对key-value键值对其实是存在map的内部类entry里的），数组的每个元素都是一个单链表的头节点，跟着的绿色链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。 2：hashmap原理（即put和get原理） 2.1 put原理 1.根据key获取对应hash值：int hash = hash（key.hash.hashcode（）） 2.根据hash值和数组长度确定对应数组引int i = indexFor(hash, table.length); 简单理解就是i = hash值%模以 数组长度（其实是按位与运算）。如果不同的key都映射到了数组的同一位置处，就将其放入单链表中。且新来的是放在头节点。 2.2 get原理 1.通过hash获得对应数组位置，遍历该数组所在链表（key.equals（）） 3：hashcode相同，冲突怎么办？ “头插法”，放到对应的链...
相关文章
文章评论
共有0条评论来说两句吧...
文章二维码
点击排行
推荐阅读
最新文章
- CentOS7,CentOS8安装Elasticsearch6.8.6
- CentOS8,CentOS7,CentOS6编译安装Redis5.0.7
- Windows10,CentOS7,CentOS8安装MongoDB4.0.16
- SpringBoot2编写第一个Controller，响应你的http请求并返回结果
- CentOS6,CentOS7官方镜像安装Oracle11G
- Dcoker安装(在线仓库)，最新的服务器搭配容器使用
- Springboot2将连接池hikari替换为druid，体验最强大的数据库连接池
- Docker快速安装Oracle11G，搭建oracle11g学习环境
- SpringBoot2整合MyBatis，连接MySql数据库做增删改查操作
- SpringBoot2全家桶，快速入门学习开发网站教程
微信收款码
支付宝收款码