Java并发编程：使用ThreadPoolExecutor提高电商系统（大促销活动）的高峰期性能_电商 高并发 java

ThreadPoolExecutor在电商系统的高峰期处理大量用户请求时非常有用。下面我将用一个具体的场景来说明，并附上一些代码。

场景1：用户结算

假设我们的电商系统正在进行一场大促销活动，用户对结算页面的访问量突然增加。我们希望通过ThreadPoolExecutor来提高系统的并发性能和响应速度。

步骤一：定义结算任务（CartCheckoutTask）

首先，我们定义一个结算任务（CartCheckoutTask），这个任务会从购物车中获取用户购买的商品，然后调用我们的结算服务进行结算。

public class CartCheckoutTask implements Runnable {
    private CartService cartService;
    private User user;

    public CartCheckoutTask(CartService cartService, User user) {
        this.cartService = cartService;
        this.user = user;
    }

    @Override
    public void run() {
        try {
            // 获取用户的购物车内容
            Cart cart = cartService.getCart(user.getId());
            // 调用结算服务进行结算
            PaymentResult paymentResult = cartService.checkout(cart);
            // 处理结算结果...
        } catch (Exception e) {
            // 记录错误日志...
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

步骤二：创建结算任务处理器ThreadPoolManager

然后，我们创建一个ThreadPoolExecutor来处理这些任务。在创建ThreadPoolExecutor时，我们需要指定核心线程数、最大线程数、线程存活时间以及任务队列。

import java.util.concurrent.*;

public class ThreadPoolManager {
    private static ThreadPoolExecutor threadPoolExecutor;

    public static void init(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit) {
        threadPoolExecutor = new ThreadPoolExecutor(
            corePoolSize,
            maximumPoolSize,
            keepAliveTime,
            unit,
            new LinkedBlockingQueue<Runnable>(),
            new ThreadFactory() {
                private int counter = 0;
                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = new Thread(r);
                    thread.setName("ThreadPoolExecutor-" + (counter++));
                    thread.setPriority(Thread.NORM_PRIORITY);
                    return thread;
                }
            }
        );
    }

    public static void submitCheckoutTask(CartCheckoutTask task) {
        threadPoolExecutor.submit(task);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

步骤三：用户提交结算

最后，当用户点击结算按钮时，我们将创建一个CartCheckoutTask，并将其提交到ThreadPoolExecutor中进行处理。

// 初始化线程池，设置核心线程数、最大线程数、线程存活时间等  
ThreadPoolManager.init(4, 16, 60, TimeUnit.SECONDS); 
  
Button checkoutButton = new Button("Checkout");
checkoutButton.setOnClickListener(e -> {
    CartCheckoutTask task = new CartCheckoutTask(cartService, user);
    ThreadPoolManager.submitCheckoutTask(task);
});
1
2
3
4
5
6
7
8

在上述代码中，我们首先初始化了ThreadPoolManager，设置了线程池的相关参数。然后，在用户点击结算按钮时，我们创建一个CartCheckoutTask对象，并将其提交到ThreadPoolExecutor中，由线程池自动管理和执行该任务。这样可以避免每个用户的请求都创建一个新线程的开销，提高了系统的性能和稳定性。

这样，我们就使用ThreadPoolExecutor成功地提高了电商系统的并发性能和响应速度。在高峰期，系统可以同时处理多个用户的结算请求，而不会因为单个用户的请求过载导致系统崩溃。

场景2：异步处理用户请求:商品查询、订单查询

电商系统在高峰期除了处理大量的用户结算请求外，还可能面临其他类型的请求，比如商品查询、订单查询等。对于这些请求，使用ThreadPoolExecutor可以异步处理，避免阻塞主线程。

步骤一：定义商品查询任务ProductSearchTask

public class ProductSearchTask implements Runnable {  
    private ProductService productService;  
    private Query query;  
  
    public ProductSearchTask(ProductService productService, Query query) {  
        this.productService = productService;  
        this.query = query;  
    }  
  
    @Override  
    public void run() {  
        try {  
            // 调用产品服务进行查询，并返回结果  
            List<Product> products = productService.search(query);  
            // 处理查询结果...  
        } catch (Exception e) {  
            // 记录错误日志...  
        }  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在上述代码中，我们定义了一个ProductSearchTask类，实现了Runnable接口。在run()方法中，我们调用ProductService的search()方法进行商品查询，并返回结果。这里的ProductSearchTask可以被视为一个任务，提交给ThreadPoolExecutor进行处理。

步骤二：提交给ThreadPoolExecutor进行处理

ThreadPoolManager.init(4, 16, 60, TimeUnit.SECONDS); // 初始化线程池，设置核心线程数、最大线程数、线程存活时间等  
  
Button searchButton = new Button("Search");  
searchButton.setOnClickListener(e -> {  
    ProductSearchTask task = new ProductSearchTask(productService, query);  
    ThreadPoolManager.submitSearchTask(task); // 提交任务到线程池  
});
1
2
3
4
5
6
7

在上述代码中，我们首先初始化了ThreadPoolManager，设置了线程池的相关参数。然后，在用户点击搜索按钮时，我们创建一个ProductSearchTask对象，并将其提交到ThreadPoolExecutor中，由线程池自动管理和执行该任务。这样可以避免每个用户的请求都创建一个新线程的开销，提高了系统的性能和稳定性。同时，通过异步处理用户的查询请求，避免了阻塞主线程，提高了系统的响应速度。

场景3：异步处理用户评论

电商系统在高峰期可能会面临大量的用户评论请求。对于这些请求，使用ThreadPoolExecutor可以异步处理，避免阻塞主线程。

public class CommentProcessingTask implements Runnable {
    private CommentService commentService;
    private Comment comment;

    public CommentProcessingTask(CommentService commentService, Comment comment) {
        this.commentService = commentService;
        this.comment = comment;
    }

    @Override
    public void run() {
        try {
            // 调用评论服务进行评论处理
            commentService.processComment(comment);
        } catch (Exception e) {
            // 记录错误日志...
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在上述代码中，我们定义了一个CommentProcessingTask类，实现了Runnable接口。在run()方法中，我们调用CommentService的processComment()方法对用户评论进行处理。这里的CommentProcessingTask可以被视为一个任务，提交给ThreadPoolExecutor进行处理。

ThreadPoolManager.init(4, 16, 60, TimeUnit.SECONDS); // 初始化线程池，设置核心线程数、最大线程数、线程存活时间等

Button commentButton = new Button("Comment");
commentButton.setOnClickListener(e -> {
    CommentProcessingTask task = new CommentProcessingTask(commentService, comment);
    ThreadPoolManager.submitCommentTask(task); // 提交任务到线程池
});
1
2
3
4
5
6
7

在上述代码中，我们首先初始化了ThreadPoolManager，设置了线程池的相关参数。然后，在用户点击评论按钮时，我们创建一个CommentProcessingTask对象，并将其提交到ThreadPoolExecutor中，由线程池自动管理和执行该任务。这样可以避免每个用户的请求都创建一个新线程的开销，提高了系统的性能和稳定性。同时，通过异步处理用户的评论请求，避免了阻塞主线程，提高了系统的响应速度。

场景4：异步发送短信验证码

电商系统在用户注册、登录等场景下可能需要发送短信验证码。使用ThreadPoolExecutor可以异步发送短信验证码，避免阻塞主线程。

public class SmsVerificationTask implements Runnable {
    private SmsService smsService;
    private String phoneNumber;
    private String code;

    public SmsVerificationTask(SmsService smsService, String phoneNumber, String code) {
        this.smsService = smsService;
        this.phoneNumber = phoneNumber;
        this.code = code;
    }

    @Override
    public void run() {
        try {
            // 调用短信服务发送短信验证码
            smsService.sendVerificationCode(phoneNumber, code);
        } catch (Exception e) {
            // 记录错误日志...
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在上述代码中，我们定义了一个SmsVerificationTask类，实现了Runnable接口。在run()方法中，我们调用SmsService的sendVerificationCode()方法发送短信验证码。这里的SmsVerificationTask可以被视为一个任务，提交给ThreadPoolExecutor进行处理。

ThreadPoolManager.init(4, 16, 60, TimeUnit.SECONDS); // 初始化线程池，设置核心线程数、最大线程数、线程存活时间等

Button sendSmsButton = new Button("Send Sms");
sendSmsButton.setOnClickListener(e -> {
    SmsVerificationTask task = new SmsVerificationTask(smsService, phoneNumber, code);
    ThreadPoolManager.submitSmsTask(task); // 提交任务到线程池
});
1
2
3
4
5
6
7

在上述代码中，我们首先初始化了ThreadPoolManager，设置了线程池的相关参数。然后，在用户点击发送短信按钮时，我们创建一个SmsVerificationTask对象，并将其提交到ThreadPoolExecutor中，由线程池自动管理和执行该任务。这样可以避免每个用户的请求都创建一个新线程的开销，提高了系统的性能和稳定性。同时，通过异步发送短信验证码，避免了阻塞主线程，提高了系统的响应速度。