个人中心
gpt4 book ai didi

Java多线程 Guarded Suspension设计模式

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 34 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java多线程 Guarded Suspension设计模式由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

前言:

Guarded Suspension意为保护暂停，其核心思想是仅当服务进程准备好时，才提供服务。设想一种场景，服务器可能会在很短时间内承受大量的客户端请求，客户端请求的数量可能超过服务器本身的即时处理能力，而服务端程序又不能丢弃任何一个客户请求。此时，最佳的处理方案莫过于让客户端要求进行排队，由服务端程序一个接一个处理。这样，既保证了所有的客户端请求均不丢失，同时也避免了服务器由于同时处理太多的请求而崩溃 。

1.Guarded Suspension模式的结构

Guarded Suspension模式的主要成员有：Request、RequestQueue、ClientThread、 ServerThread 。

  • Request：表示客户端请求
  • RequestQueue：用于保存客户端请求队列
  • ClientThread：客户端进程
  • ServerThread：服务器进程

其中，ClientThread负责不断发起请求，并将请求对象放入请求队列。ServerThread则根据其自身的状态，在有能力处理请求时，从RequestQueue中提取请求对象加以处理.

从流程图中可以看到，客户端的请求数量超过了服务线程的能力。在频繁的客户端请求中，RequestQueue充当了中间缓存，存放未处理的请求，保证了客户请求不丢失，同时也保护了服务线程不会受到大量并发的请求，而导致计算机资源不足 。

2. Guarded Suspension模式的简单实现

?
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
public class ClientThread extends Thread {
 
     private final RequestQueue queue;
 
     private final Random random;
 
     private final String sendValue;
 
     public ClientThread(RequestQueue queue, String sendValue) {
         this .queue = queue;
         this .sendValue = sendValue;
         this .random = new Random(System.currentTimeMillis());
     }
 
     @Override
     public void run() {
 
         for ( int i = 0 ; i < 10 ; i++) {
             System.out.println( "Client -> request " + sendValue);
             queue.putRequest( new Request(sendValue));
 
             try {
                 Thread.sleep(random.nextInt( 1000 ));
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
public class Request {
 
     private final String value;
 
     public Request(String value) {
         this .value = value;
     }
 
     public String getValue() {
         return value;
     }
}
?
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
public class RequestQueue {
 
     private final LinkedList<Request> queue = new LinkedList<>();
 
     public Request getRequest() {
         synchronized (queue) {
             while (queue.size() <= 0 ) {
                 try {
                     queue.wait();
                 } catch (InterruptedException e) {
                     return null ;
                 }
             }
             return queue.removeFirst();
         }
     }
 
     public void putRequest(Request request) {
 
         synchronized (queue) {
             queue.addLast(request);
             queue.notifyAll();
         }
     }
}
?
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
30
31
32
33
34
35
36
public class ServerThread extends Thread {
 
     private final RequestQueue queue;
 
     private final Random random;
 
     private volatile boolean closed = false ;
 
     public ServerThread(RequestQueue queue) {
         this .queue = queue;
         random = new Random(System.currentTimeMillis());
     }
 
     @Override
     public void run() {
 
         while (!closed) {
             Request request = queue.getRequest();
             if ( null == request) {
                 System.out.println( "Received the empty request." );
                 continue ;
             }
             System.out.println( "Server ->" + request.getValue());
             try {
                 Thread.sleep(random.nextInt( 1000 ));
             } catch (InterruptedException e) {
                 return ;
             }
         }
     }
 
     public void close() {
         this .closed = true ;
         this .interrupt();
     }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
public class SuspensionClient {
     public static void main(String[] args) throws InterruptedException {
 
         final RequestQueue queue = new RequestQueue();
         new ClientThread(queue, "Jack" ).start();
         ServerThread serverThread =  new ServerThread(queue);
         serverThread.start();
 
         Thread.sleep( 10000 );
         serverThread.close();
     }
}

运行

Client -> request Jack Server ->Jack Client -> request Jack Server ->Jack Client -> request Jack Server ->Jack Client -> request Jack Server ->Jack Client -> request Jack Client -> request Jack Client -> request Jack Server ->Jack Client -> request Jack Client -> request Jack Server ->Jack Client -> request Jack Server ->Jack Server ->Jack Server ->Jack Server ->Jack Received the empty request. 。

到此这篇关于Java多线程 Guarded Suspension设计模式的文章就介绍到这了,更多相关Java多线程 Guarded Suspension内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://juejin.cn/post/7022609159912685575 。

最后此篇关于Java多线程 Guarded Suspension设计模式的文章就讲到这里了,如果你想了解更多关于Java多线程 Guarded Suspension设计模式的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

34 4 0
文章推荐： Java Fluent Mybatis 分页查询与sql日志输出详解流程篇
文章推荐： postman中实现传递@RequestBody参数
文章推荐： Facebook开源一站式服务python时序利器Kats详解
文章推荐： pyhton学习与数据挖掘self原理及应用分析
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com