1. 使用线程池

在Java中，我们可以使用ExecutorService来创建一个线程池，以优化线程的创建和管理。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 提交任务到线程池
        for (int i = 0; i < 100; i++) {
            executorService.submit(() -> {
                // 执行任务逻辑
                System.out.println("Handling task");
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

2. 使用限流器

可以使用Google的Guava库中的RateLimiter来实现限流。

import com.google.common.util.concurrent.RateLimiter;

public class RateLimiterExample {
    public static void main(String[] args) {
        // 创建一个每秒只允许两个许可的限流器
        RateLimiter rateLimiter = RateLimiter.create(2.0);

        // 模拟请求
        for (int i = 0; i < 10; i++) {
            rateLimiter.acquire(); // 获取许可
            System.out.println("Request " + i + " is allowed");
        }
    }
}

3. 使用消息队列

以RabbitMQ为例，以下是如何配置RabbitMQ以及Java代码示例。

RabbitMQ配置（Docker）:

version: '3'
services:
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"

Java生产者代码示例：

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class RabbitMQProducer {
    private final static String QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);
            String message = "Hello World!";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

Java消费者代码示例：

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class RabbitMQConsumer {
    private final static String QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            // 模拟任务处理时间
            doWork(message);
            System.out.println(" [x] Done");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }

    private static void doWork(String task) {
        for (char ch : task.toCharArray()) {
            if (ch == '.') {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException _ignored) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}

4. 使用Nginx进行负载均衡

Nginx配置示例：

http {
    upstream myapp1 {
        server srv1.example.com;
        server srv2.example.com;
        server srv3.example.com;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://myapp1;
        }
    }
}

以上示例代码和配置展示了如何在Java应用程序中处理高并发情况，以及如何配置相关中间件来支持高并发处理。实际部署时，可能还需要根据具体情况进行调整和优化。