怎样在java主方法中实现资源池化

在Java主方法中实现资源池化，可以通过以下几个步骤来完成：

1. 创建一个资源类（Resource）：

public class Resource {
    public void useResource() {
        System.out.println("Using resource...");
    }
}

2. 创建一个资源池类（ResourcePool）：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ResourcePool {
    private BlockingQueue<Resource> pool;
    private int maxResources;

    public ResourcePool(int maxResources) {
        this.maxResources = maxResources;
        this.pool = new ArrayBlockingQueue<>(maxResources);
        initializePool();
    }

    private void initializePool() {
        for (int i = 0; i < maxResources; i++) {
            pool.offer(new Resource());
        }
    }

    public Resource acquireResource() throws InterruptedException {
        return pool.take();
    }

    public void releaseResource(Resource resource) throws InterruptedException {
        pool.put(resource);
    }
}

在这个类中，我们使用了一个BlockingQueue来存储资源对象。acquireResource()方法用于从池中获取一个资源，如果池中没有可用资源，则会阻塞等待。releaseResource()方法用于将资源归还给池中。

3. 在主方法中使用资源池：

public class Main {
    public static void main(String[] args) {
        int maxResources = 5;
        ResourcePool resourcePool = new ResourcePool(maxResources);

        Runnable task = () -> {
            try {
                Resource resource = resourcePool.acquireResource();
                System.out.println(Thread.currentThread().getName() + " acquired resource.");
                resource.useResource();
                System.out.println(Thread.currentThread().getName() + " released resource.");
                resourcePool.releaseResource(resource);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(task, "Thread-" + i).start();
        }
    }
}

在这个例子中，我们创建了一个资源池，最大资源数为5。然后创建了10个线程，每个线程都会尝试从资源池中获取资源，使用资源，然后将资源归还给资源池。由于资源池的大小有限，所以当一个线程正在使用资源时，其他线程会等待直到资源被释放。