前言：實際項目中經常遇到消息消費失敗了，要進行消息的重發。比如支付消息消費失敗后，要分不同時間段進行N次的消息重發提醒。

本文模擬場景

1. 當金額少於100時，消息消費成功
2. 當金額大於100，小於200時，會進行3次重發，第一次1秒；第二次2秒；第三次3秒。
3. 當金額大於200時，消息消費失敗，會進行5次重發，第一次1秒；第二次2秒；第三次3秒；第四次4秒；第五次5秒。重試五次后，消息自動進入死信隊列，在死信隊列存活60秒后消失。

代碼實例

特別注意代碼與配置文件中的註釋，各個使用說明都已經詳細寫在配置文件中

pom包引入

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cloudstream</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR5</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- ①關鍵配置：引入stream-rabbit 依賴-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <!-- ②關鍵配置：由於stream是基於spring-cloud的，所以這裏要引入 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

配置application.yml文件

注意各個配置的縮進格式，別搞錯了

server:
  port: 8081
spring:
  application:
    name: stream-demo
  #rabbitmq連接配置
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: admin
    password: 123456
  cloud:
    stream:
      bindings:
        #消息生產者，與DelayDemoTopic接口中的DELAY_DEMO_PRODUCER變量值一致
        delay-demo-producer:
          #①定義交換機名
          destination: demo-delay-queue
        #消息消費者，與DelayDemoTopic接口中的DELAY_DEMO_CONSUMER變量值一致
        delay-demo-consumer:
          #定義交換機名，與①一致，就可以使發送和消費都指向一個隊列
          destination: demo-delay-queue
          #分組，這個配置可以開啟消息持久化、可以解決在集群環境下重複消費的問題。
          #比如A、B兩台服務器集群，如果沒有這個配置，則A、B都能收到同樣的消息，如果有該配置則只有其中一台會收到消息
          group: delay-consumer-group
          consumer:
            #最大重試次數，默認為3。不使用默認的，這裏定義為1，由我們程序控制發送時間和次數
            maxAttempts: 1
      rabbit:
        bindings:
          #消息生產者，與DelayDemoTopic接口中的DELAY_DEMO_PRODUCER變量值一致
          delay-demo-producer:
            producer:
              #②申明為延遲隊列
              delayedExchange: true
          #消息消費者，與DelayDemoTopic接口中的DELAY_DEMO_CONSUMER變量值一致
          delay-demo-consumer:
            consumer:
              #申明為延遲隊列，與②的配置的成對出現的
              delayedExchange: true
              #開啟死信隊列
              autoBindDlq: true
              #死信隊列中消息的存活時間
              dlqTtl: 60000

定義隊列通道

1. 定義通道

/**
 * 定義延遲消息通道
 */
public interface DelayDemoTopic {
    /**
     * 生產者，與yml文件配置對應
     */
    String DELAY_DEMO_PRODUCER = "delay-demo-producer";
    /**
     * 消費者，與yml文件配置對應
     */
    String DELAY_DEMO_CONSUMER = "delay-demo-consumer";

    /**
     * 定義消息消費者，在@StreamListener監聽消息的時候用到
     * @return
     */
    @Input(DELAY_DEMO_CONSUMER)
    SubscribableChannel delayDemoConsumer();

    /**
     * 定義消息發送者，在發送消息的時候用到
     * @return
     */
    @Output(DELAY_DEMO_PRODUCER)
    MessageChannel delayDemoProducer();
}

1. 綁定通道

/**
 * 配置消息的binding
 *
 */
@EnableBinding(value = {DelayDemoTopic.class})
@Component
public class MessageConfig {

}

消息發送模擬

/**
 * 發送消息
 */
@RestController
public class SendMessageController {
    @Autowired
    DelayDemoTopic delayDemoTopic;

    @GetMapping("send")
    public Boolean sendMessage(BigDecimal money) throws JsonProcessingException {

        Message<BigDecimal> message = MessageBuilder.withPayload(money)
                //設置消息的延遲時間，首次發送，不設置延遲時間，直接發送
                .setHeader(DelayConstant.X_DELAY_HEADER,0)
                //設置消息已經重試的次數，首次發送，設置為0
                .setHeader(DelayConstant.X_RETRIES_HEADER,0)
                .build();
        return delayDemoTopic.delayDemoProducer().send(message);
    }
}

消息監聽處理

@Component
@Slf4j
public class DelayDemoTopicListener {
    @Autowired
    DelayDemoTopic delayDemoTopic;

    /**
     * 監聽延遲消息通道中的消息
     * @param message
     */
    @StreamListener(value = DelayDemoTopic.DELAY_DEMO_CONSUMER)
    public void listener(Message<BigDecimal> message) {
        //獲取重試次數
        int retries = (int)message.getHeaders().get(DelayConstant.X_RETRIES_HEADER);
        //獲取消息內容
        BigDecimal money = message.getPayload();
        try {
            String now = DateUtils.formatDate(new Date(),"yyyy-MM-dd HH:mm:ss");
            //模擬：如果金額大於200，則消息無法消費成功；金額如果大於100，則重試3次；如果金額小於100，直接消費成功
            if (money.compareTo(new BigDecimal(200)) == 1){
                throw new RuntimeException(now+":金額超出200，無法交易。");
            }else if (money.compareTo(new BigDecimal(100)) == 1 && retries <= 3) {
                if (retries == 0) {
                    throw new RuntimeException(now+":金額超出100，消費失敗，將進入重試。");
                }else {
                    throw new RuntimeException(now+":金額超出100，當前第" + retries + "次重試。");
                }
            }else {
                log.info("消息消費成功！");
            }
        }catch (Exception e) {
            log.error(e.getMessage());
            if (retries < DelayConstant.X_RETRIES_TOTAL){
                //將消息重新塞入隊列
                MessageBuilder<BigDecimal> messageBuilder = MessageBuilder.fromMessage(message)
                        //設置消息的延遲時間
                        .setHeader(DelayConstant.X_DELAY_HEADER,DelayConstant.ruleMap.get(retries + 1))
                        //設置消息已經重試的次數
                        .setHeader(DelayConstant.X_RETRIES_HEADER,retries + 1);
                Message<BigDecimal> reMessage = messageBuilder.build();
                //將消息重新發送到延遲隊列中
                delayDemoTopic.delayDemoProducer().send(reMessage);
            }else {
                //超過重試次數，做相關處理（比如保存數據庫等操作），如果拋出異常，則會自動進入死信隊列
                throw new RuntimeException("超過最大重試次數：" + DelayConstant.X_RETRIES_TOTAL);
            }
        }
    }
}

規則定義

目前寫在一個常量類里，實際項目中，通常會配置在配置文件中

public class DelayConstant {
    /**
     * 定義當前重試次數
     */
    public static final String X_RETRIES_HEADER = "x-retries";
    /**
     * 定義延遲消息，固定值，該配置放到消息的header中，會開啟延遲隊列
     */
    public static final String X_DELAY_HEADER = "x-delay";

    /**
     * 定義最多重試次數
     */
    public static final Integer X_RETRIES_TOTAL = 5;

    /**
     * 定義重試規則，毫秒為單位
     */
    public static final Map<Integer,Integer> ruleMap = new HashMap(){{
        put(1,1000);
        put(2,2000);
        put(3,3000);
        put(4,4000);
        put(5,5000);
    }};
}

測試

經過以上配置和實現就可完成模擬的重發場景。

• 瀏覽器中輸入http://127.0.0.1:8081/send?money=10，可以看到控制台中輸出：

消息消費成功！

• 瀏覽器中輸入http://127.0.0.1:8081/send?money=110，可以看到控制台中輸出：

2020-06-20 10:59:42:金額超出100，消費失敗，將進入重試。
2020-06-20 10:59:43:金額超出100，當前第1次重試。
2020-06-20 10:59:45:金額超出100，當前第2次重試。
2020-06-20 10:59:48:金額超出100，當前第3次重試。
消息消費成功！

• 瀏覽器中輸入http://127.0.0.1:8081/send?money=110，可以看到控制台中輸出：

注意事項

由於本文用到了延遲隊列，需要在rabbitMQ中安裝延遲插件，具體安裝方式，可以查看：延遲隊列安裝參考

源碼獲取

以上示例都可以通過我的GitHub獲取完整的代碼.

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※教你寫出一流的銷售文案?

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

※超省錢租車方案

※產品缺大量曝光嗎?你需要的是一流包裝設計!

Django rest framework源碼分析（2）—-權限

添加權限

（1）API/utils文件夾下新建premission.py文件，代碼如下：

• message是當沒有權限時，提示的信息

# utils/permission.py

class SVIPPremission(object):
    message = "必須是SVIP才能訪問"
    def has_permission(self,request,view):
        if request.user.user_type != 3:
            return False
        return True


class MyPremission(object):
    def has_permission(self,request,view):
        if request.user.user_type == 3:
            return False
        return True

（2）settings.py全局配置權限

#全局
REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES":['API.utils.auth.Authentication',],
    "DEFAULT_PERMISSION_CLASSES":['API.utils.permission.SVIPPremission'],
}

（3）views.py添加權限

• 默認所有的業務都需要SVIP權限才能訪問
• OrderView類裏面沒寫表示使用全局配置的SVIPPremission
• UserInfoView類，因為是普通用戶和VIP用戶可以訪問，不使用全局的，要想局部使用的話，裏面就寫上自己的權限類
• permission_classes = [MyPremission,] #局部使用權限方法

from django.shortcuts import render,HttpResponse
from django.http import JsonResponse
from rest_framework.views import APIView
from API import models
from rest_framework.request import Request
from rest_framework import exceptions
from rest_framework.authentication import BaseAuthentication
from API.utils.permission import SVIPPremission,MyPremission

ORDER_DICT = {
    1:{
        'name':'apple',
        'price':15
    },
    2:{
        'name':'dog',
        'price':100
    }
}

def md5(user):
    import hashlib
    import time
    #當前時間，相當於生成一個隨機的字符串
    ctime = str(time.time())
    m = hashlib.md5(bytes(user,encoding='utf-8'))
    m.update(bytes(ctime,encoding='utf-8'))
    return m.hexdigest()

class AuthView(APIView):
    '''用於用戶登錄驗證'''

    authentication_classes = []      #裏面為空，代表不需要認證
    permission_classes = []          #不裏面為空，代表不需要權限
    def post(self,request,*args,**kwargs):
        ret = {'code':1000,'msg':None}
        try:
            user = request._request.POST.get('username')
            pwd = request._request.POST.get('password')
            obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
            if not obj:
                ret['code'] = 1001
                ret['msg'] = '用戶名或密碼錯誤'
            #為用戶創建token
            token = md5(user)
            #存在就更新，不存在就創建
            models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
            ret['token'] = token
        except Exception as e:
            ret['code'] = 1002
            ret['msg'] = '請求異常'
        return JsonResponse(ret)


class OrderView(APIView):
    '''
    訂單相關業務(只有SVIP用戶才能看)
    '''

    def get(self,request,*args,**kwargs):
        self.dispatch
        #request.user
        #request.auth
        ret = {'code':1000,'msg':None,'data':None}
        try:
            ret['data'] = ORDER_DICT
        except Exception as e:
            pass
        return JsonResponse(ret)


class UserInfoView(APIView):
    '''
       訂單相關業務(普通用戶和VIP用戶可以看)
       '''
    permission_classes = [MyPremission,]    #不用全局的權限配置的話，這裏就要寫自己的局部權限
    def get(self,request,*args,**kwargs):

        print(request.user)
        return HttpResponse('用戶信息')

# urls.py
from django.contrib import admin
from django.urls import path
from API.views import AuthView,OrderView,UserInfoView

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/auth/',AuthView.as_view()),
    path('api/v1/order/',OrderView.as_view()),
    path('api/v1/info/',UserInfoView.as_view()),
]

# API/utils/auth/py
# auth.py

from rest_framework import exceptions
from API import models
from rest_framework.authentication import BaseAuthentication


class Authentication(BaseAuthentication):
    '''用於用戶登錄驗證'''
    def authenticate(self,request):
        token = request._request.GET.get('token')
        token_obj = models.UserToken.objects.filter(token=token).first()
        if not token_obj:
            raise exceptions.AuthenticationFailed('用戶認證失敗')
        #在rest framework內部會將這兩個字段賦值給request，以供後續操作使用
        return (token_obj.user,token_obj)

    def authenticate_header(self, request):
        pass

（4）測試

普通用戶訪問OrderView,提示沒有權限

普通用戶訪問UserInfoView，可以返回信息

權限源碼流程

（1）dispatch

def dispatch(self, request, *args, **kwargs):
    """
    `.dispatch()` is pretty much the same as Django's regular dispatch,
    but with extra hooks for startup, finalize, and exception handling.
    """
    self.args = args
    self.kwargs = kwargs
    #對原始request進行加工，豐富了一些功能
    #Request(
    #     request,
    #     parsers=self.get_parsers(),
    #     authenticators=self.get_authenticators(),
    #     negotiator=self.get_content_negotiator(),
    #     parser_context=parser_context
    # )
    #request(原始request,[BasicAuthentications對象，])
    #獲取原生request,request._request
    #獲取認證類的對象，request.authticators
    #1.封裝request
    request = self.initialize_request(request, *args, **kwargs)
    self.request = request
    self.headers = self.default_response_headers  # deprecate?

    try:
        #2.認證
        self.initial(request, *args, **kwargs)

        # Get the appropriate handler method
        if request.method.lower() in self.http_method_names:
            handler = getattr(self, request.method.lower(),
                                  self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed

        response = handler(request, *args, **kwargs)

    except Exception as exc:
        response = self.handle_exception(exc)

    self.response = self.finalize_response(request, response, *args, **kwargs)
    return self.response

（2）initial

def initial(self, request, *args, **kwargs):
    """
    Runs anything that needs to occur prior to calling the method handler.
    """
    self.format_kwarg = self.get_format_suffix(**kwargs)

    # Perform content negotiation and store the accepted info on the request
    neg = self.perform_content_negotiation(request)
    request.accepted_renderer, request.accepted_media_type = neg

    # Determine the API version, if versioning is in use.
    version, scheme = self.determine_version(request, *args, **kwargs)
    request.version, request.versioning_scheme = version, scheme

    # Ensure that the incoming request is permitted
    #4.實現認證
    self.perform_authentication(request)
    #5.權限判斷
    self.check_permissions(request)
    self.check_throttles(request)

（3）check_permissions

裏面有個has_permission這個就是我們自己寫的權限判斷

def check_permissions(self, request):
    """
    Check if the request should be permitted.
    Raises an appropriate exception if the request is not permitted.
    """
    #[權限類的對象列表]
    for permission in self.get_permissions():
        if not permission.has_permission(request, self):
            self.permission_denied(
                request, message=getattr(permission, 'message', None)
            )

（4）get_permissions

def get_permissions(self):
    """
    Instantiates and returns the list of permissions that this view requires.
    """
    return [permission() for permission in self.permission_classes]

（5）permission_classes

所以settings全局配置就如下

#全局
REST_FRAMEWORK = {
   "DEFAULT_PERMISSION_CLASSES":['API.utils.permission.SVIPPremission'],
}

內置權限

django-rest-framework內置權限BasePermission

默認是沒有限制權限

class BasePermission(object):
    """
    A base class from which all permission classes should inherit.
    """

    def has_permission(self, request, view):
        """
        Return `True` if permission is granted, `False` otherwise.
        """
        return True

    def has_object_permission(self, request, view, obj):
        """
        Return `True` if permission is granted, `False` otherwise.
        """
        return True

我們自己寫的權限類，應該去繼承BasePermission,修改之前寫的permission.py文件

# utils/permission.py

from rest_framework.permissions import BasePermission

class SVIPPremission(BasePermission):
    message = "必須是SVIP才能訪問"
    def has_permission(self,request,view):
        if request.user.user_type != 3:
            return False
        return True


class MyPremission(BasePermission):
    def has_permission(self,request,view):
        if request.user.user_type == 3:
            return False
        return True

總結：

（1）使用

• 自己寫的權限類：1.必須繼承BasePermission類； 2.必須實現：has_permission方法

（2）返回值

• True 有權訪問
• False 無權訪問

（3）局部

• permission_classes = [MyPremission,]

（4）全局

REST_FRAMEWORK = {
   #權限
    "DEFAULT_PERMISSION_CLASSES":['API.utils.permission.SVIPPremission'],
}

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※幫你省時又省力,新北清潔一流服務好口碑

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!

一、 進程

        簡單來說，進程是對資源的抽象，是資源的容器，在傳統操作系統中，進程是資源分配的基本單位，而且是執行的基本單位，進程支持併發執行，因為每個進程有獨立的數據，獨立的堆棧空間。一個程序想要併發執行，開多個進程即可。

Q1：在單核下，進程之間如何同時執行？

        首先要區分兩個概念——併發和并行

• 併發：併發是指在一段微小的時間段中，有多個程序代碼段被CPU執行，宏觀上表現出來就是多個程序能”同時“執行。
• 并行：并行是指在一個時間點，有多個程序段代碼被CPU執行，它才是真正的同時執行。

        所以應該說進程之間是併發執行。對於CPU來講，它不知道進程的存在，CPU主要與寄存器打交道。有一些常用的寄存器，如程序計數器寄存器，這個寄存器存儲了將要執行的指令的地址，這個寄存器的地址指向哪，CPU就去哪。還有一些堆棧寄存器和通用寄存器等等等，總之，這些數據構成了一個程序的執行環境，這個執行環境就叫做”上下文（Context）“，進程之間切換本質就是保存這些數據到內存，術語叫做”保存現場“，然後恢復某個進程的執行環境，也即是”恢復現場“，整個過程術語叫做“上下文切換”，具體點就是進程上下文切換，這就是進程之間能併發執行的本質——頻繁的切換進程上下文。這個功能是由操作系統提供的，是內核態的，對應用軟件開發人員透明。

二、 線程

        進程雖然支持併發，但是對併發不是很友好，不友好是指每開啟一個進程，都要重新分配一部分資源，而線程相對進程來說，創建線程的代價比創建進程要小，所以引入線程能更好的提高併發性。在現代操作系統中，進程變成了資源分配的基本單位，而線程變成了執行的基本單位，每個線程都有獨立的堆棧空間，同一個進程的所有線程共享代碼段和地址空間等共享資源。相應的上下文切換從進程上下文切換變成了線程上下文切換。

三、 為什麼要引入進程和線程

1. 提高CPU利用率，在早期的單道批處理系統中，如果執行中的代碼需要依賴與外部條件，將會導致CPU空閑，例如文件讀取，等待鍵盤信號輸入，這將浪費大量的CPU時間。引入多進程和線程可以解決CPU利用率低這個問題。
2. 隔離程序之間的數據（每個進程都有單獨的地址空間），保證系統運行的穩定性。
3. 提高系統的響應性和交互能力。

四、 在C#中創建託管線程

1. Thread類

在.NET中，託管線程分為：

• 前台線程
• 後台線程

一個.Net程序中，至少要有一個前台線程，所有前台線程結束了，所有的後台線程將會被公共語言運行時（CLR）強制銷毀，程序執行結束。

如下將在控制台程序中創建一個後台線程

 1 static void Main(string[] args)
 2 {
 3      var t = new Thread(() =>
 4      {
 5          Thread.Sleep(1000);
 6          Console.WriteLine("執行完畢");
 7      });
 8     t.IsBackground = true;
 9      t.Start();
10 }

View Code

 

主線程（默認是前台線程）執行完畢，程序直接退出。

但IsBackground 屬性改為false時，控制台會打印“執行完畢”。

2. 有什麼問題

直接使用Thread類來進行多線程編程浪費資源（服務器端更加明顯）且不方便，舉個栗子。

假如我寫一個Web服務器程序，每個請求創建一個線程，那麼每一次我都要new一個Thread對象，然後傳入處理HttpRequest的委託，處理完之後，線程將會被銷毀，這將會導致浪費大量CPU時間和內存，在早期CPU性能不行和內存資源珍貴的情況下這個缺點會被放大，在現在這個缺點不是很明顯，原因是硬件上來了。

不方便體現在哪呢？

• 無法直接獲取另一個線程內未被捕捉的異常
• 無法直接獲取線程函數的返回值

 

 1 public static void ThrowException()
 2 {
 3      throw new Exception("發生異常");
 4 }
 5 static void Main(string[] args)
 6 {
 7      var t = new Thread(() =>
 8      {
 9          Thread.Sleep(1000);
10          ThrowException();
11      });
12     t.IsBackground = false;
13      try
14      {
15          t.Start();
16      }
17      catch(Exception e)
18      {
19          Console.WriteLine(e.Message);
20      }
21 }

View Code

 

上述代碼將會導致程序奔潰，如下圖。

 

要想直接獲取返回值和可以直接從主線程捕捉線程函數內未捕捉的異常，我們可以這麼做。

新建一個MyTask.cs文件，內容如下

 1 using System;
 2 using System.Threading;
 3 namespace ConsoleApp1
 4 {
 5      public class MyTask
 6      {
 7          private Thread _thread;
 8          private Action _action;
 9          private Exception _innerException;
10         public MyTask()
11          {
12         }
13          public MyTask(Action action)
14          {
15              _action = action;
16          }
17          protected virtual void Excute()
18          {
19              try
20              {
21                  _action();
22              }
23              catch(Exception e)
24              {
25                  _innerException = e;
26              }
27       
28          }
29          public void Start()
30          {
31              if (_thread != null) throw new InvalidOperationException("任務已經開始");
32              _thread = new Thread(() => Excute());
33              _thread.Start();
34          }
35          public void Start(Action action)
36          {
37              _action = action;
38              if (_thread != null) throw new InvalidOperationException("任務已經開始");
39              _thread = new Thread(() => Excute());
40              _thread.Start();
41          }
42         public void Wait()
43          {
44              _thread.Join();
45              if (_innerException != null) throw _innerException;
46          }
47      }
48     public class MyTask<T> : MyTask
49      {
50          private Func<T> _func { get; }
51          private T _result;
52          public T Result {
53              
54              private set => _result = value;
55              get 
56              {
57                  base.Wait();
58                  return _result;
59              }
60          }
61          public MyTask(Func<T> func)
62          {
63              _func = func;
64          }
65         public new void Start() 
66          {
67              base.Start(() =>
68              {
69                  Result = _func();
70              });
71          }
72     }
73 }

View Code

 

簡單的包裝了一下（不要在意細節），我們便可以實現我們想要的效果。

測試代碼如下

 1 public static void ThrowException()
 2 {
 3      throw new Exception("發生異常");
 4 }
 5 public static void Test3()
 6 {
 7      MyTask<string> myTask = new MyTask<string>(() =>
 8      {
 9          Thread.Sleep(1000);
10          return "執行完畢";
11      });
12     myTask.Start();
13     try
14      {
15          Console.WriteLine(myTask.Result);
16      }
17      catch (Exception e)
18      {
19          Console.WriteLine(e.Message);
20      }
21 }
22 public static void Test2()
23 {
24      MyTask<string> myTask = new MyTask<string>(() =>
25      {
26          Thread.Sleep(1000);
27          ThrowException();
28          return "執行完畢";
29      });
30     myTask.Start();
31     try
32      {
33          Console.WriteLine(myTask.Result);
34      }
35      catch(Exception e)
36      {
37          Console.WriteLine(e.Message);
38      }
39 }
40 public static void Test1()
41 {
42      MyTask myTask = new MyTask(() =>
43      {
44          Thread.Sleep(1000);
45          ThrowException();
46      });
47      myTask.Start();
48     try
49      {
50          myTask.Wait();
51      }
52      catch (Exception e)
53      {
54          Console.WriteLine(e.Message);
55      }
56 }
57 static void Main(string[] args)
58 {
59      Test1();
60      Test2();
61      Test3();
62 }

 

可以看到，我們可以通過簡單包裝Thread對象，便可實現如下效果

• 直接讀取線程函數返回值
• 直接捕捉線程函數未捕捉的異常（前提是調用了Wait()函數或者Result屬性）

這是理解和運用Task的基礎，Task功能非常完善，但是運用好Task需要掌握許多概念，下面再說。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※教你寫出一流的銷售文案?

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

※超省錢租車方案

※產品缺大量曝光嗎?你需要的是一流包裝設計!

近日，日本廣島大學相關人員創辦的高新技術企業在廣島市內召開新車發佈會，展示了一款最新研發的，車體附有特殊海綿袋，“無論撞上多少次，車身都會恢復原樣”。

這款電動汽車名為“i SAVE YOU”。身為公司社長的廣島大學大學院教授升島努表示：“這款汽車是為老年人和主婦設計的”。該電動汽車為三輪，最高時速50公里。帳篷質地的袋子裡塞入海綿，然後覆蓋在車身四周吸收撞擊時的衝擊力。若發生碰撞時的車速為每小時約10公里，則完全不會對車身產生影響，搭乘者也不會受傷。充電1次可行駛約30公里，駕駛員須持有普通駕照。

這款汽車的研發得到了馬自達公司資深技術人員的協助、以及縣內中小企業的支持，耗時4年左右才完成。車輛售價為89萬日元和79萬日元兩種，銷售目標為一年1千輛。

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※教你寫出一流的銷售文案?

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

※超省錢租車方案

※產品缺大量曝光嗎?你需要的是一流包裝設計!