1. package com.hikktn.thread;
    3. import java.sql.*;
    4. import java.util.Map;
    5. import java.util.Properties;
    6. import java.util.Random;
    7. import java.util.concurrent.Executor;
    8. import java.util.concurrent.atomic.AtomicIntegerArray;
    10. /**
    11.  * ThreadPoolTest
    12.  * <p>
    13.  * <p>
    14.  * encoding:UTF-8
    15.  *
    16.  * @author lisonglin 15:23 2022/4/4
    17.  */
    18. public class ThreadPoolTest {
    19.     public static void main(String[] args) {
    20.         ThreadPool threadPool = new ThreadPool(2);
    21.         for (int i = 0; i < 5; i++) {
    22.             new Thread(() -> {
    23.                 Connection connection = threadPool.getConnection();
    24.                 try {
    25.                     Thread.sleep(new Random().nextInt(1000));
    26.                 } catch (InterruptedException e) {
    27.                     e.printStackTrace();
    28.                 }
    29.                 threadPool.releaseConnection(connection);
    30.             }).start();
    31.         }
    32.     }
    33. }
    35. class ThreadPool {
    36.     /**
    37.      * 线程池中线程的最大数量
    38.      */
    39.     private final int poolSize;
    40.     /**
    41.      * 连接对象数组
    42.      */
    43.     private Connection[] connections;
    44.     /**
    45.      * 连接状态数组 0 空闲 1 占用
    46.      */
    47.     private AtomicIntegerArray states;
    49.     /**
    50.      * 初始化线程池
    51.      *
    52.      * @param poolSize
    53.      */
    54.     public ThreadPool(int poolSize) {
    55.         this.poolSize = poolSize;
    56.         this.connections = new Connection[poolSize];
    57.         this.states = new AtomicIntegerArray(new int[poolSize]);
    58.         for (int i = 0; i < poolSize; i++) {
    59.             connections[i] = new MockConnection(Thread.currentThread().getName() + " connection:" + (i + 1));
    60.         }
    61.     }
    63.     /**
    64.      * 获取连接
    65.      *
    66.      */
    67.     public Connection getConnection() {
    68.         while (true) {
    69.             for (int i = 0; i < poolSize; i++) {
    70.                 if (states.get(i) == 0) {
    71.                     if (states.compareAndSet(i, 0, 1)) {
    72.                         System.out.println(Thread.currentThread().getName() + " get connection:" + connections[i]);
    73.                         return connections[i];
    74.                     }
    75.                 }
    76.             }
    78.             synchronized (this) {
    79.                 try {
    80.                     System.out.println(Thread.currentThread().getName() + " wait for connection");
    81.                     wait();
    82.                 } catch (InterruptedException e) {
    83.                     e.printStackTrace();
    84.                 }
    85.             }
    86.         }
    87.     }
    89.     /**
    90.      * 释放连接
    91.      */
    92.     public void releaseConnection(Connection connection) {
    93.         for (int i = 0; i < poolSize; i++) {
    94.             if (connection == connections[i]) {
    95.                 if (states.compareAndSet(i, 1, 0)) {
    96.                     System.out.println(Thread.currentThread().getName() + " release connection:" + connection);
    97.                     synchronized (this) {
    98.                         notifyAll();
    99.                     }
    100.                     break;
    101.                 }
    102.             }
    103.         }
    104.     }
    105. }
    107. class MockConnection implements Connection {
    108.     private final String name;
    110.     public MockConnection(String name) {
    111.         this.name = name;
    112.     }
    114.     @Override
    115.     public String toString() {
    116.         return "MockConnection{" +
    117.                 "name='" + name + '\'' +
    118.                 '}';
    119.     }
    121.     @Override
    122.     public Statement createStatement() throws SQLException {
    123.         return null;
    124.     }
    126.     @Override
    127.     public PreparedStatement prepareStatement(String sql) throws SQLException {
    128.         return null;
    129.     }
    131.     @Override
    132.     public CallableStatement prepareCall(String sql) throws SQLException {
    133.         return null;
    134.     }
    136.     @Override
    137.     public String nativeSQL(String sql) throws SQLException {
    138.         return null;
    139.     }
    141.     @Override
    142.     public void setAutoCommit(boolean autoCommit) throws SQLException {
    144.     }
    146.     @Override
    147.     public boolean getAutoCommit() throws SQLException {
    148.         return false;
    149.     }
    151.     @Override
    152.     public void commit() throws SQLException {
    154.     }
    156.     @Override
    157.     public void rollback() throws SQLException {
    159.     }
    161.     @Override
    162.     public void close() throws SQLException {
    164.     }
    166.     @Override
    167.     public boolean isClosed() throws SQLException {
    168.         return false;
    169.     }
    171.     @Override
    172.     public DatabaseMetaData getMetaData() throws SQLException {
    173.         return null;
    174.     }
    176.     @Override
    177.     public void setReadOnly(boolean readOnly) throws SQLException {
    179.     }
    181.     @Override
    182.     public boolean isReadOnly() throws SQLException {
    183.         return false;
    184.     }
    186.     @Override
    187.     public void setCatalog(String catalog) throws SQLException {
    189.     }
    191.     @Override
    192.     public String getCatalog() throws SQLException {
    193.         return null;
    194.     }
    196.     @Override
    197.     public void setTransactionIsolation(int level) throws SQLException {
    199.     }
    201.     @Override
    202.     public int getTransactionIsolation() throws SQLException {
    203.         return 0;
    204.     }
    206.     @Override
    207.     public SQLWarning getWarnings() throws SQLException {
    208.         return null;
    209.     }
    211.     @Override
    212.     public void clearWarnings() throws SQLException {
    214.     }
    216.     @Override
    217.     public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
    218.         return null;
    219.     }
    221.     @Override
    222.     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
    223.         return null;
    224.     }
    226.     @Override
    227.     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
    228.         return null;
    229.     }
    231.     @Override
    232.     public Map<String, Class<?>> getTypeMap() throws SQLException {
    233.         return null;
    234.     }
    236.     @Override
    237.     public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
    239.     }
    241.     @Override
    242.     public void setHoldability(int holdability) throws SQLException {
    244.     }
    246.     @Override
    247.     public int getHoldability() throws SQLException {
    248.         return 0;
    249.     }
    251.     @Override
    252.     public Savepoint setSavepoint() throws SQLException {
    253.         return null;
    254.     }
    256.     @Override
    257.     public Savepoint setSavepoint(String name) throws SQLException {
    258.         return null;
    259.     }
    261.     @Override
    262.     public void rollback(Savepoint savepoint) throws SQLException {
    264.     }
    266.     @Override
    267.     public void releaseSavepoint(Savepoint savepoint) throws SQLException {
    269.     }
    271.     @Override
    272.     public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
    273.         return null;
    274.     }
    276.     @Override
    277.     public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
    278.         return null;
    279.     }
    281.     @Override
    282.     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
    283.         return null;
    284.     }
    286.     @Override
    287.     public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
    288.         return null;
    289.     }
    291.     @Override
    292.     public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
    293.         return null;
    294.     }
    296.     @Override
    297.     public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
    298.         return null;
    299.     }
    301.     @Override
    302.     public Clob createClob() throws SQLException {
    303.         return null;
    304.     }
    306.     @Override
    307.     public Blob createBlob() throws SQLException {
    308.         return null;
    309.     }
    311.     @Override
    312.     public NClob createNClob() throws SQLException {
    313.         return null;
    314.     }
    316.     @Override
    317.     public SQLXML createSQLXML() throws SQLException {
    318.         return null;
    319.     }
    321.     @Override
    322.     public boolean isValid(int timeout) throws SQLException {
    323.         return false;
    324.     }
    326.     @Override
    327.     public void setClientInfo(String name, String value) throws SQLClientInfoException {
    329.     }
    331.     @Override
    332.     public void setClientInfo(Properties properties) throws SQLClientInfoException {
    334.     }
    336.     @Override
    337.     public String getClientInfo(String name) throws SQLException {
    338.         return null;
    339.     }
    341.     @Override
    342.     public Properties getClientInfo() throws SQLException {
    343.         return null;
    344.     }
    346.     @Override
    347.     public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
    348.         return null;
    349.     }
    351.     @Override
    352.     public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
    353.         return null;
    354.     }
    356.     @Override
    357.     public void setSchema(String schema) throws SQLException {
    359.     }
    361.     @Override
    362.     public String getSchema() throws SQLException {
    363.         return null;
    364.     }
    366.     @Override
    367.     public void abort(Executor executor) throws SQLException {
    369.     }
    371.     @Override
    372.     public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
    374.     }
    376.     @Override
    377.     public int getNetworkTimeout() throws SQLException {
    378.         return 0;
    379.     }
    381.     @Override
    382.     public <T> T unwrap(Class<T> iface) throws SQLException {
    383.         return null;
    384.     }
    386.     @Override
    387.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
    388.         return false;
    389.     }
    390. }
    1. Thread-0 get connection:MockConnection{name='main connection:1'}
    2. Thread-2 wait for connection
    3. Thread-1 get connection:MockConnection{name='main connection:2'}
    4. Thread-3 wait for connection
    5. Thread-4 wait for connection
    6. Thread-1 release connection:MockConnection{name='main connection:2'}
    7. Thread-4 get connection:MockConnection{name='main connection:2'}
    8. Thread-3 wait for connection
    9. Thread-2 wait for connection
    10. Thread-0 release connection:MockConnection{name='main connection:1'}
    11. Thread-2 get connection:MockConnection{name='main connection:1'}
    12. Thread-3 wait for connection
    13. Thread-2 release connection:MockConnection{name='main connection:1'}
    14. Thread-3 get connection:MockConnection{name='main connection:1'}
    15. Thread-4 release connection:MockConnection{name='main connection:2'}
    16. Thread-3 release connection:MockConnection{name='main connection:1'}