等待超时模式
假设超时时间是T,那么可以推断出在当前时间 now+T 之后就会超时
定义如下变量
- 等待持续时间:REMAINING = T
- 超时时间: FUTURE=now+T
这是仅需要wait(REMAINING)即可,在wait(REMAINING)返回之后将会执行: REMAINING = FUTURE-now. 如果REMAINING小于等于0,表示已经超时,直接退出,否则将继续执行 wait(REMAINING).
上述描述等待超时模式的伪代码如下
public synchronized Object get(long mills) throws InterruptedException{
long future = System.currentTimeMillis() + mills;
long remaining = mills;
while((result == null) && remaining > 0){
wait(remaining);
remaining = future - System.currentTimeMillis();
}
return result;
}
接下来写一个简单的数据库连接池示例:
类 ConnectionDriver
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.util.concurrent.TimeUnit;
/**
* @author chendong
* @date 2019/9/5 22:25
*/
public class ConnectionDriver {
static class ConnectionHandler implements InvocationHandler{
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(method.getName().equalsIgnoreCase("commit")){
TimeUnit.MILLISECONDS.sleep(100);
}
return null;
}
}
public static final Connection createConnection(){
return (Connection) Proxy.newProxyInstance(ConnectionDriver.class.getClassLoader(), new Class<?>[]{Connection.class}, new ConnectionHandler());
}
}
类 ConnectionPool
import java.sql.Connection;
import java.util.LinkedList;
/**
* @author chendong
* @date 2019/9/5 22:28
*/
public class ConnectionPool {
private LinkedList<Connection> pool = new LinkedList<Connection>();
public ConnectionPool(int initialSize){
if(initialSize > 0){
for(int i = 0; i < initialSize; i++){
pool.addLast(ConnectionDriver.createConnection());
}
}
}
public void releaseConnection(Connection connection){
if(connection != null){
synchronized (pool){
// 链接释放后需要进行通知,这样其他消费者能够感知到连接池中已经归还了一个链接
pool.addLast(connection);
pool.notifyAll();
}
}
}
// 在mills 之内无法获取到链接,将会返回null
public Connection fetchConnection(long mills) throws InterruptedException {
synchronized (pool){
if(mills < 0){
while (pool.isEmpty()){
pool.wait();
}
return pool.removeFirst();
}else{
long future = System.currentTimeMillis() + mills;
long remaining = mills;
while(pool.isEmpty() && remaining > 0){
pool.wait(remaining);
remaining = future - System.currentTimeMillis();
}
Connection result = null;
if(!pool.isEmpty()){
result = pool.removeFirst();
}
return result;
}
}
}
}
类 ConnectionPoolTest
import java.sql.Connection;
import java.sql.SQLException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
/**
* @author chendong
* @date 2019/9/5 22:36
*/
public class ConnectionPoolTest {
static ConnectionPool pool = new ConnectionPool(10);
// 保证所有ConnectionRunner能够同时开始
static CountDownLatch start = new CountDownLatch(1);
// main线程将会等待所有ConnectionRunner结束后才能继续执行
static CountDownLatch end;
static class ConnectionRunner implements Runnable{
int count;
AtomicInteger got;
AtomicInteger notGot;
public ConnectionRunner(int count, AtomicInteger got, AtomicInteger notGot){
this.count = count;
this.got = got;
this.notGot = notGot;
}
@Override
public void run() {
try {
start.await(); // 等所有线程同时执行
} catch (InterruptedException e) {
e.printStackTrace();
}
while (count > 0){
try {
// 从线程池获取连接,如果1000ms内无法获取到,将会返回null
// 分别统计链接获取的数量 got和为获取的数量notGot
Connection connection = pool.fetchConnection(1000);
if(connection != null){
try {
connection.createStatement();
connection.commit();
} catch (SQLException e) {
e.printStackTrace();
} finally {
pool.releaseConnection(connection);
got.incrementAndGet();
}
}else {
notGot.incrementAndGet();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
count--;
}
}
end.countDown();
}
}
public static void main(String[] args) throws InterruptedException {
int threadCount = 30;
end = new CountDownLatch(threadCount);
int count = 20;
AtomicInteger got = new AtomicInteger();
AtomicInteger notGot = new AtomicInteger();
for(int i = 0; i < threadCount; i++){
Thread thread = new Thread(new ConnectionRunner(count, got, notGot), "ConnectionRunnerThread");
thread.start();
}
start.countDown(); // 使所有线程同时执行
end.await();
System.out.println("total invoke: " + threadCount*count);
System.out.println("got connection: " + got);
System.out.println("not got connection: " + notGot);
}
}
输出结果
threadCount | invoke | got | not got |
---|---|---|---|
10 | 200 | 20 | 0 |
20 | 400 | 389 | 11 |
30 | 600 | 549 | 51 |
我们通过修改threadCount的值,可以看出随着客户端线程的逐渐增加,客户端出现超时无法获取连接的比例不断升高。但是线程是不会一直挂在连接获取的请求上,而是按时返回。并告知客户端连接获取出现问题,是系统的一种自我保护措施。