ThreadLocal 的最佳实践

SimpleDateFormat 众所周知是线程不安全的,多线程中如何保证线程安全又同时兼顾性能问题呢?那就是使用 ThreadLocal 维护 SimpleDateFormat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class SimpleDateFormatThreadTest {

static volatile AtomicInteger n = new AtomicInteger(-1);

static ThreadLocal<DateFormat> sdf ;

static {
sdf =new ThreadLocal<DateFormat>() {
@Override
protected DateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd");
}
};
}

public static void main(String[] args) throws ParseException, InterruptedException {

Set<String> dateSet = new ConcurrentHashSet<>();
Set<Integer> numberSet = new ConcurrentHashSet<>();

Date[] dates = new Date[1000];
for (int i = 0; i < 1000; i++) {
dates[i] = sdf.get().parse(i + 1000 + "-11-22");
}

ExecutorService executorService = Executors.newFixedThreadPool(10);
for(int i=0;i<1000;i++){
executorService.execute(new Runnable() {
@Override
public void run() {
int number = n.incrementAndGet();
String date = sdf.get().format(dates[number]);
numberSet.add(number);
dateSet.add(date);
System.out.println(number+" "+date);
}
});
}
executorService.shutdown();
Thread.sleep(5000);
System.out.println(dateSet.size());
System.out.println(numberSet.size());
}

}

实践证明 sdf 的 parse(String to Date)有严重的线程安全问题,format(Date to String)有轻微的线程安全问题,虽然不太明显,但还是会出现问题,这和内部的实现有关。

简单分析下使用 ThreadLocal 的好处,1000 次转换操作,10 个线程争抢执行,如果每次都去 new 一个 sdf,可见其效率之低,而使用 ThreadLocal,是对每个线程维护一个 sdf,所以最多就只会出现 10 个 sdf,真正项目中,由于操作系统线程分片执行,所以线程不会非常的多,使用 ThreadLocal 的好处也就立竿见影了。

分享到

Transactional 注解使用注意点

@Transactional 可以说是 spring 中最常用的注解之一了,通常情况下我们在需要对一个 service 方法添加事务时,加上这个注解,如果发生 unchecked exception,就会发生 rollback,最典型的例子如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class StudentService {
@Autowired
StudentDao studentDao;

@Transactional
public void innerSave(int i) {
Student student = new Student();
student.setName("test" + i);
studentDao.save(student);
//i=5 会出现异常
int a = 1 / (i - 5);
}
}

在调用 innerSave(5) 时会发运算异常,导致保存操作回滚,不在此赘述了。

新的需求:循环保存 10 个学生,发生异常时要求回滚。
我们理所当然的写出了下面的代码,在 StudentService.java 添加如下方法

1
2
3
4
5
6
7
8
9
public void outerLooper1() {
for (int i = 1; i <= 10; i++) {
try{
innerSave(i);
}catch (Exception e){
e.printStackTrace();
}
}
}

先考虑一下 test5 这个学生有没有保存呢?
结果:
这里写图片描述
依然出现了,考虑下问题出在哪儿了?

其实也好理解,spring 中 @Transactional 的事务开启 ,是基于接口 或者是类的代理被创建的。所以在同一个类中一个普通方法 outerLooper1() 调用另一个有事务的方法 innerSave(),事务是不会起作用的。要解决这个问题,一般我的做法是写一个帮助类,注入到当前类中,来完成事务操作。

1
2
3
4
5
6
7
8
@Autowired
UtilService utilService;

public void outerLooper2() {
for (int i = 1; i <= 10; i++) {
utilService.innerSave(i);
}
}

这里写图片描述
在 spring 中使用事务需要遵守一些规范和了解一些坑点,别想当然。列举一下一些注意点。

  • 在需要事务管理的地方加 @Transactional 注解。@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。

  • @Transactional 注解只能应用到 public 可见度的方法上。如果你在 protectedprivate 或者 package-visible 的方法上使用 @Transactional 注解,它也不会报错,但是这个被注解的方法将不会展示已配置的事务设置。

  • Spring 团队建议在具体的类(或类的方法)上使用 @Transactional 注解,而不要使用在类所要实现的任何接口上。在接口上使用 @Transactional 注解,只能当你设置了基于接口的代理时它才生效。因为注解是 不能继承的,这就意味着如果正在使用基于类的代理时,那么事务的设置将不能被基于类的代理所识别,而且对象也将不会被事务代理所包装。

  • @Transactional 的事务开启 ,或者是基于接口的或者是基于类的代理被创建。所以在同一个类中一个方法调用另一个方法有事务的方法,事务是不会起作用的。

  • 了解事务的隔离级别,各个数据库默认的隔离级别是不一样的,在 spring 中用的是 isolation = Isolation.READ_COMMITTED 来设置;了解事务的传播机制,当发生事务嵌套时,按照业务选择对应的传播机制,用 propagation= Propagation.REQUIRED 来设置。

分享到

简单了解 RPC 实现原理

时下很多企业应用更新换代到分布式,一篇文章了解什么是 RPC。
原作者梁飞,在此记录下他非常简洁的 rpc 实现思路。

查看更多

分享到

java trick--String.intern()

《深入理解 java 虚拟机》第二版中对 String.intern() 方法的讲解中所举的例子非常有意思

不了解 String.intern() 的朋友要理解他其实也很容易,它返回的是一个字符串在字符串常亮池中的引用。直接看下面的 demo

1
2
3
4
5
6
7
8
9
public class Main {
public static void main(String[] args) {
String str1 = new StringBuilder("计算机").append("软件").toString();
System.out.println(str1.intern() == str1);

String str2 = new StringBuilder("ja").append("va").toString();
System.out.println(str2.intern() == str2);
}
}

两者输出的结果如下:

1
2
true
false

我用的 jdk 版本为 Oracle JDK7u45。简单来说,就是一个很奇怪的现象,为什么 java 这个字符串在类加载之前就已经加载到常量池了?

我在知乎找到了具体的说明,如下:

1
2
3
4
5
6
7
8
9
10
11
package sun.misc;

import java.io.PrintStream;

public class Version {
private static final String launcher_name = "java";
private static final String java_version = "1.7.0_79";
private static final String java_runtime_name = "Java(TM) SE Runtime Environment";
private static final String java_runtime_version = "1.7.0_79-b15";
...
}

而 HotSpot JVM 的实现会在类加载时先调用:

1
2
3
4
5
6
7
8
9
public final class System{
...
private static void initializeSystemClass() {
...
sun.misc.Version.init();
...
}
...
}

原来是 sun.misc.Version 这个类在起作用。

分享到

java trick -- intergerCache

看一段代码:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
Integer a=100,b=100,c=150,d=150;
System.out.println(a==b);
System.out.println(c==d);
}
}

这段代码会输出什么?

查看更多

分享到

java trick--system.out.println

多线程在使用 system.out.println 时要留一个有意思的地方

查看更多

分享到

Hello World

分享到

使用 JPA 实现乐观锁

乐观锁的概念就不再赘述了,不了解的朋友请自行百度谷歌之,今天主要说的是在项目中如何使用乐观锁,做成一个小 demo。

持久层使用 jpa 时,默认提供了一个注解 @Version 先看看源码怎么描述这个注解的

1
2
3
4
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface Version {
}

简单来说就是用一个 version 字段来充当乐观锁的作用。
先来设计实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
* Created by xujingfeng on 2017/1/30.
*/
@Entity
@Table(name = "t_student")
public class Student {

@Id
@GenericGenerator(name = "PKUUID", strategy = "uuid2")
@GeneratedValue(generator = "PKUUID")
@Column(length = 36)
private String id;

@Version
private int version;

private String name;

//getter()...
//setter()...
}

查看更多

分享到

使用 zkclient 操作 zookeeper 的学习过程记录

前言

最近开发的分布式 (使用 motan) 项目中使用 zookeeper 作为服务中心来提供注册服务 (@MotanService) 和发现服务(@MotanRefer), 虽然 motan 这个 rpc 框架对服务模块进行了很好的封装,但是以防以后会出现定制化的需求,以及对服务更好的监控,所以有必要了解一下 zookeeper 的基本知识和使用方法。关于 zookeeper 的知识点,网上很多的博客都已经介绍的很详尽了,我写这篇的博客的用意其实也就是将一些零散的却很精妙的博客整理出来,方便以后查阅。短篇以 cp 的方式,长篇的以 url 的方式。

zookeeper 是什么?

ZooKeeper 是一个分布式的,开放源码的分布式应用程序协调服务,是 Google 的 Chubby 一个开源的实现,是 Hadoop 和 Hbase 的重要组件。它是一个为分布式应用提供一致性服务的软件,提供的功能包括:配置维护、域名服务、分布式同步、组服务等。
ZooKeeper 的目标就是封装好复杂易出错的关键服务,将简单易用的接口和性能高效、功能稳定的系统提供给用户。
ZooKeeper 包含一个简单的原语集,提供 Java 和 C 的接口。 ZooKeeper 代码版本中,提供了分布式独享锁、选举、队列的接口。

—- 百度百科

一开始看的云里雾里的,幸好我之前搞过一点 hadoop,对他的生态体系有所了解,这才大概知道他想说什么。提炼几个关键词,并且加入我后面学习的理解,总结一下就是 –

zookeeper 是一个组件,需要安装客户端和服务端,一般用于解决分布式开发下的一些问题。化抽象为具体,你可以把整个 zookeeper 理解成一个树形数据结构,也可以理解为一个文件系统的结构,每个叶子节点都会携带一些信息 (data),并且也可能会携带一些操作 (op)。分布式场景中,每一个客户端都可以访问到这些叶子节点,并且进行一些操作。我们所有使用 zookeeper 的场景几乎都是在 CRUD 某一个或者某些叶子节点,然后会触发对应的操作… 即 zookeeper 本身可以理解为一个 shareData。
—- 来自于博主的口胡

zookeeper 怎么学?

学一个新的中间件的最好方法是先在脑子里面有一个想法:我为什么要学他,是想解决什么问题,他大概是个什么东西,我觉得打开思路的最好方式是看几篇博客 (大多数情况你一开始看不懂,但是混个眼熟),然后看视频,这里我自己是了解过了 zookeeper 原生的 api 之后看了极客学院 的视频

查看更多

分享到