【098】Java利用对象池配合synchronized同步块实现较高效率的线程同步

业务场景

web服务器端开发的时候，一般我们的Java代码是多线程执行的，并且是多线程地向数据库里插入数据。在插入数据的时候，我们很可能碰到这样一种情况：一个用户在一定条件下，只可能向数据库里插入一条数据。同时许多相关的业务逻辑也是以只有一条数据为基础而设计实现的。为了保证数据的完整性，我们应该确保只有一条数据。但是在实际应用中，服务器程序很可能向数据库插入了多条数据。

为了给读者解释地更明白，我假设下面这样一种场景：

在线考试系统，有一个用户答案表，记录每个用户填写的每道题目的答案。假设表的结构如下:

表名： t_user_answer

主键： c_id

用户ID： c_user_id

题目ID： c_question_id

用户答案： c_user_answer

显然，保存一个用户做的某一道题目的答案，只需要一条记录就够了。也就是说，用户ID和题目ID的组合，理应是唯一的。即从业务上来说，用户ID和题目ID可以做 t_user_answer 的联合主键。当然用联合主键也是解决此问题的办法之一，但是在这篇文字中，我们主要讨论 synchronized 同步块的解决方法。

synchronized(exp){} 代码中，表达式 exp 必须返回某个对象的引用。当线程进入同步块，会给exp返回的对象加锁，当线程离开同步块，会给对象解锁。当两个线程持有同一个exp返回对象，这两个线程互斥，只有其中一个线程执行完同步块里的代码，另一个线程才能进入。如果对象已经被其它线程加锁，则在解锁之前，该线程阻塞。注意，如果两个线程的exp返回的不是同一个对象，哪怕两个对象相等，那么这两个线程也是并发的，互不影响。实际应用中，根据业务调整同步块锁的粒度，可以降低同步块对性能的影响。

演示代码

演示代码一共有三个文件：ZhangChaoLock.java LockObjectPool.java Main.java 。

其中 ZhangChaoLock.java 是同步块中用于加锁的对象。

LockObjectPool.java 是加锁对象的对象池。

Main.java 包含 main 方法，用于测试。

为了演示方便，演示代码没有访问数据库。而是用创建文件来模拟并发的情况。逻辑是这样的：

程序先检查 E:/test 文件夹里面有没有文件，如果有文件，什么也不做。如果没文件，就新建一个文件，文件名是时间戳。在多线程的情况下，理想状况是 E:/test 只有一个新建文件。下面放出代码。

ZhangChaoLock.java

package zc.testSychronized;

/**
* 锁，用于 synchronized 关键字。作用于同步块：
* synchronized(exp){
*   ...
* }
* 中的 exp。
* @author 张超
*
*/
public class ZhangChaoLock {

/**
* 为了方便调试加的id属性
*/
private int id = 0;

public ZhangChaoLock() {
super();
}

public ZhangChaoLock(int id) {
super();
this.id = id;
}

// 按照阿里巴巴的Java代码规范，重写equals方法和hashCode方法。

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ZhangChaoLock other = (ZhangChaoLock) obj;
if (id != other.id)
return false;
return true;
}

/**
* 方便调试，重写toString
*/
@Override
public String toString() {
String superStr = super.toString();
return new StringBuilder().append("QstLock:  ").append(this.id).append("  ---  ").append(superStr).toString();
}

}

LockObjectPool.java

package zc.testSychronized;

/**
* 锁对象的对象池
* @author 张超
*
*/
public final class LockObjectPool {
/**
* 对象池的大小。
*/
private static final int POOL_SIZE;

/**
* 存放对象的数组。
*/
private static final ZhangChaoLock[] arr;

static {
POOL_SIZE = 2000;
arr = new ZhangChaoLock[POOL_SIZE];
for (int i = 0; i < POOL_SIZE; i++) {
ZhangChaoLock lock = new ZhangChaoLock(i);
arr[i] = lock;
}
}

/**
* 取绝对值
* @param a
* @return 整数a的绝对值
*/
private final static int absoluteValue(int a) {

if (a >= 0) {
return a;
} else if (a == Integer.MIN_VALUE) { // 考虑边界值
int b = a + 1;
return -b;
}else {
return -a;
}
}

/**
* 根据字符串str的哈希值，取得对应的锁。
* @param str
* @return
*/
public final static ZhangChaoLock getLock(final String str) {
int hashCode = str.hashCode();
hashCode = absoluteValue(hashCode);
int pos = hashCode % POOL_SIZE;
return arr[pos];
}
}

Main.java

package zc.testSychronized;

import java.io.File;
import java.io.IOException;

public class Main {

/*
test1和test2是测试方法。逻辑如下
1.检查 E:/test 文件夹下有没有文件。如果没有文件就新建一个文件。文件名是时间戳。
2.如果E:/test 文件夹下没有任何文件，就什么操作也不做。
3.运行程序前清空 E:/test。理想状态下，文件夹下应该只有一个文件。

test1 没有并发控制， E:/test 会出现两个文件。
test2 有并发控制， E:/test 会出现一个文件。
test3 两个相同的字符串，因为String 对象不同，所以两个线程是并发的，没有同步。启用对象池主要是为了应对字符串出现test3的情况。

实际应用中，synchronized不会对所有线程加同一把锁。
比如保存学生作业答案，每个线程都有 userId 和 questionId，把userId和questionId 拼成
一个字符串，可以得到一把锁。LockObjectPool利用哈希码尽可能根据 userId questionId 分配不同的锁。
这样，只有持有相同的 userId 和questionId 的多个线程才会互斥。
*/

static void test1(String str) {
File d = new File("E:/test");
File[] files = d.listFiles();

// sleep 是为了方便重现并发问题。
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (files == null || files.length == 0) {
File f = new File("E:/test/" + System.currentTimeMillis() + ".txt");
try {
f.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
} else {
// do nothing
}
}

static void test2(String str) {
ZhangChaoLock lock = LockObjectPool.getLock(str);
System.out.println(lock);
synchronized(lock) {
File d = new File("E:/test");
File[] files = d.listFiles();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (files == null || files.length == 0) {
File f = new File("E:/test/" + System.currentTimeMillis() + ".txt");
try {
f.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
} else {

}
} // end synchronized
}

static void test3(String str) {

synchronized(str) {
File d = new File("E:/test");
File[] files = d.listFiles();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (files == null || files.length == 0) {
File f = new File("E:/test/" + System.currentTimeMillis() + ".txt");
try {
f.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
} else {

}
} // end synchronized
}

public static void main(String[] args) {

Thread t1 = new Thread(new Runnable(){
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//              test1("user1_id_and_question1_id");
test2("user1_id_and_question1_id");
//              test3("user1_id_and_question1_id");
}
});

Thread t2 = new Thread(new Runnable(){
public void run() {
//              test1("user1_id_and_question1_id");
test2("user1_id_and_question1_id");
//              test3(new String("user1_id_and_question1_id"));
}
});

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

}

}