java池化技术研究

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class ObjectPool<T> {
    private BlockingQueue<T> pool;
    public ObjectPool(int poolSize) {
        pool = new LinkedBlockingQueue<>(poolSize);
        for (int i = 0; i < poolSize; i++) {
            pool.add(createObject());
        }
    }
    public T borrowObject() throws InterruptedException {
        return pool.take();
    }
    public void returnObject(T object) {
        pool.offer(object);
    }
    private T createObject() {
        // 创建对象的逻辑
        // 这里只是一个示例，实际使用时可以根据需要进行适当的修改
        return null;
    }
}

import java.util.concurrent.ConcurrentLinkedQueue;
public class MemoryPool {
    private ConcurrentLinkedQueue<Object> pool;
    public MemoryPool(int size) {
        pool = new ConcurrentLinkedQueue<>();
        for (int i = 0; i < size; i++) {
            pool.add(new Object());
        }
    }
    public Object borrowObject() {
        if (pool.isEmpty()) {
            return new Object();
        } else {
            return pool.poll();
        }
    }
    public void returnObject(Object obj) {
        pool.add(obj);
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class ConnectionPoolExample {
    public static void main(String[] args) {
        // 创建一个连接池，初始大小为10，最大大小为20，空闲连接超时时间10秒
        ConnectionPool connectionPool = new ConnectionPool(10, 20, 10);
        // 创建一个线程池，用于模拟高并发场景
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        // 模拟100个并发请求
        for (int i = 0; i < 100; i++) {
            executorService.execute(() -> {
                // 从连接池中获取一个连接
                Connection connection = connectionPool.getConnection();
                // 执行一些操作
                connection.doSomething();
                // 将连接归还给连接池
                connectionPool.releaseConnection(connection);
            });
        }
        // 关闭线程池
        executorService.shutdown();
        try {
            // 等待所有请求执行完毕
            executorService.awaitTermination(1, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 关闭连接池
        connectionPool.close();
    }
}
class ConnectionPool {
    private int connectionPoolSize;
    private int maxPoolSize;
    private long idleTimeout;
    private BlockingQueue<Connection> connections;
    public ConnectionPool(int connectionPoolSize, int maxPoolSize, long idleTimeout) {
        this.connectionPoolSize = connectionPoolSize;
        this.maxPoolSize = maxPoolSize;
        this.idleTimeout = idleTimeout;
        this.connections = new LinkedBlockingQueue<>(maxPoolSize);
    }
    public Connection getConnection() {
        // 先尝试从连接池中取出一个连接
        Connection connection = connections.poll();
        if (connection == null) {
            // 连接池中没有连接可用，需要创建新的连接
            if (connectionPoolSize >= maxPoolSize) {
                // 连接池已满，无法创建新连接，等待空闲连接归还到连接池
                try {
                    connection = connections.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                connection = createConnection();
                connectionPoolSize++;
            }
        }
        return connection;
    }
    public void releaseConnection(Connection connection) {
        // 将连接归还到连接池
        if (connections.size() < maxPoolSize) {
            connections.offer(connection);
        } else {
            // 连接池已满，无法归还更多连接，需要关闭连接
            connection.close();
            connectionPoolSize--;
        }
    }
    public void close() {
        // 关闭所有连接
        for (Connection connection : connections) {
            connection.close();
        }
    }
    private Connection createConnection() {
        // 创建一个新的连接
        return new Connection();
    }
}
class Connection {
    public void doSomething() {
        // 执行一些操作
    }
    public void close() {
        // 关闭连接
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池，容量为10
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            final int taskId = i;
            executor.execute(new Runnable() {
                public void run() {
                    System.out.println("Task " + taskId + " is being executed.");
                    // 执行具体的任务逻辑
                    // ...
                }
            });
        }
        // 关闭线程池
        executor.shutdown();
    }
}