1. import java.sql.*;
    2. import java.util.Map;
    3. import java.util.Properties;
    4. import java.util.concurrent.Executor;
    5. import java.util.concurrent.atomic.AtomicIntegerArray;
    7. public class TestPool {
    8.         public static void main(String[] args) throws InterruptedException {
    9.         Pool pool = new Pool(2);
    10.         for (int i = 0; i <5 ; i++) {
    11.             new Thread(()->{
    12.                 //借连接
    13.                 Connection connection = pool.borrow();
    14.                 try {
    15.                     //模拟连接使用
    16.                     Thread.sleep(1000);
    17.                 } catch (InterruptedException e) {
    18.                     e.printStackTrace();
    19.                 }
    20.                 pool.free(connection);
    21.             }).start();
    22.         }
    23.     }
    24. }
    26. class Pool{
    27.     //1.连接池大小
    28.     private final int poolSize;
    30.     //2.连接数组
    31.     private Connection[] connections;
    33.     //3.连接状态数组：0表示空闲，1表示繁忙，这里用原子数组修饰，使得对其操作均是原子，保证线程安全，不需要在方法里手动实现线程安全
    34.     private AtomicIntegerArray states;
    36.     //4.构造方法
    37.     public Pool(int poolSize) {
    38.         this.poolSize = poolSize;
    39.         //poolSize确定，连接数组以及状态数组则确定
    40.         this.connections = new Connection[poolSize];
    41.         this.states = new AtomicIntegerArray(new int[poolSize]);
    42.         //初始化数组
    43.         for (int i=0;i<poolSize;i++){
    44.             connections[i] = new MockConnection();
    45.         }
    46.     }
    48.     //5.借出连接
    49.     public Connection borrow() throws InterruptedException {
    50.         while (true){
    51.             for (int i=0;i<poolSize;i++){
    52.                 //获取空闲连接
    53.                 if(states.get(i)==0){
    54.                     if (states.compareAndSet(i,0,1)) {
    55.                         return connections[i];
    56.                     }
    57.                 }
    58.             }
    59.             //如果没有空闲连接,调用该方法的当前线程进入等待状态
    60.             synchronized (this){
    61.                 this.wait();
    62.             }
    64.         }
    65.     }
    67.     //6.归还连接
    68.     public void free(Connection conn){
    69.         for (int i = 0; i <poolSize ; i++) {
    70.             //找到需要归还的连接
    71.             if(connections[i]==conn){
    72.                 //注意归还线程的情况下，该连接一定被当前线程持有，不会发生线程竞争，直接set规划即可
    73.                 states.set(i,0);
    74.                 synchronized (this){
    75.                     this.notifyAll();//唤醒在当前对象上等待的所有线程
    76.                 }
    77.                 break;
    78.             }
    79.         }
    80.     }
    81. }
    83. class MockConnection implements Connection{
    84.     public MockConnection() {
    85.         super();
    86.     }
    88.     @Override functions..
    89. }

    几个实现细节需要注意：

    • 连接状态的判断是通过一个状态数组实现的，数组中存储0-1，表示链接空闲or不可用
    • 用Atomatic修饰数组，是要保证对数组的操作均是原子性操作，但不能保证线程安全，原子和线程安全是两码事。
    • borrow()方法要while循环，为了能取到一份Connection对象，而如果一次for循环仍取不到，则要进入wait等待状态
    • borrow()方法中的CAS操作，是解决多线程多次获取同一Connection对象问题，当某一线程的CAS操作无法执行，那么就获取不到该Connection对象。
    • borrow()方法中的CAS实际上即实现对连接数组中每个元素的并发操作，无锁实现。