Delphi For循环占用CPU100%释放问题

Posted 2023-04-17

var
i,j:integer;
for i:=memo1.lines.count-1 downto 0 do
begin
for j:=i-1 downto 0 do
begin
if comparestr(memo1.lines.strings[i],memo1.lines.strings[j])=0 then
begin

memo1.lines.delete(i);
break;
end;
end;
end;

用这个For循环,如果去重复字符串多的话..一直循环,占用CPU100%,速度很慢,请问怎么才能去一个重复字符串后释放一下CPU呢.或者让CPU不到100%..多线程应该可以吧?可是现在学的是基础,还不会.请哪位高手老师指导一下解决这个的方法
sleep(10)
application.ProcessMessages
这两个我都用了!再处理小的字符串时CPU还算可以..
但是.处理上1000的字符串的话...慢慢的CPU使用率就很高了
最后导致程序运行也慢了.!

什么代码都没用，CPU占用是windows在分配，与delphi无关，application.processmessage只是处理其他事件而已，cpu同样会占用很高。

无论是用线程还是什么，只要你的cpu闲置，windows就会考虑尽快用更多的cpu将你的指令执行完毕。

唯一的方法是调低自己的程序优先级，将自己降低，但是这也不保证就不占用cpu时间。

所以你不能考虑cpu占用，只需要考虑你的程序在执行大量代码的时候不会阻塞运行就行了。cpu占用你没法调整。

另外，楼上说的强制将代码循环停滞也是一种方法，不过这个就慢了，本来1秒钟可以计算出来的要分成几十秒钟来算了。 参考技术A 那再加一句休眠看下
sleep(10);
application.ProcessMessages;
我也不想多说啦 参考技术B 喔，想想 参考技术C 使用多线程啊!

svg动画导致持续占用CPU

1、在一次性能优化中突然发现一个svg矢量图动画导致CPU持续占用的问题，该svg在web中使用，

　　即使webview释放之后，CPU依然占用达到10%，6s+上测试结果

　　svg如下所示：

　　

<svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="none" x="0px" y="0px" width="25px" height="25px" viewBox="0 0 25 25">

<path  stroke="#777777" stroke-width="1" stroke-linejoin="round" stroke-linecap="round" fill="none" stroke-dasharray="64,6" stroke-dashoffset="0" d="
M 3.4 5.65
Q 9.5 2.2 11.2 1.15 12.6 0.4 14 1.3
L 21.65 5.75
Q 22.9 6.65 22.85 8.2
L 22.85 17.4
Q 22.8 18.6 21.5 19.25 14.85 23.25 13.6 23.9 12.3 24.55 10.8 23.7 4.3 19.9 3.1 19.1 2.35 18.6 2.15 17.75
L 2.1 7.95
Q 2.1 7.25 2.75 6.35
L 3.4 5.65 Z">
<animate attributeName="stroke-dashoffset" begin="0s" dur="1.5s" from="0" to="70" repeatCount="indefinite"/>
</path>

<path stroke="#777777" stroke-width="1" stroke-linejoin="round" stroke-linecap="round" fill="none" stroke-dasharray="37,4" stroke-dashoffset="41" d="
M 7.15 8.35
L 11.7 5.7
Q 12.55 5.25 13.35 5.8
L 17.85 8.4
Q 18.6 8.95 18.55 9.85
L 18.55 15.25
Q 18.5 15.95 17.75 16.35 13.85 18.7 13.1 19.05 12.35 19.45 11.45 18.95
L 6.95 16.25
Q 6.55 16 6.4 15.45
L 6.35 9.7
Q 6.35 9.25 6.75 8.75
L 7.15 8.35 Z">
<animate attributeName="stroke-dashoffset" begin="0s" dur="1.5s" from="41" to="0" repeatCount="indefinite"/>
</path>

</svg>

　　注意该动画的时间是无限长，指定时间结束之后，CPU将不再占用，因此这可能是webkit中的bug。

　　svg是HTML5中的标准，每个webview都应该支持。未测试WKWebView兼容情况

2、问题解决　　

　　可以看到该svg是由web中的css文件引用，真正的请求是：https://egame.gtimg.cn/club/pgg/v2.5/v2/img/global/loading-fecf2b8eea.svg

　　为了可以将这个问题解决掉，在前端暂无法修复的情况下，我选择使用NSURLProtocol中的方法，hook该请求，并返回404

　　具体操作使用了一个OHHTTPStubs的框架，代码如下：

　　

+ (void)addLoadingSVG_Patch
{
    [OHHTTPStubs stubRequestsPassingTest:^BOOL(NSURLRequest *request) {
        
        NSString *url = [request.URL description];
        if([url hasSuffix:@"svg"] && [[url lastPathComponent] hasPrefix:@"loading"])
        {
            QG_Event(MODULE_LIVE_ASS, @"patch fuck loading animated svg request!!! = %@", request);
            return YES;
        }
        return NO;
    } withStubResponse:^OHHTTPStubsResponse*(NSURLRequest *request) {
        
        return [OHHTTPStubsResponse responseWithFileAtPath:@""
                                                statusCode:404 headers:@{@"Content-Type":@"image/jpeg"}];
    }];
}

　　问题解决

3、NSURLProtocol是苹果的一个协议，其中通过 + (BOOL)canInitWithRequest:(NSURLRequest *)request; 这个方法返回是否要手动接管这个请求

　　通常web的离线缓存基于此实现，接管请求之后，需要自己实现请求的代码，并将返回结果通过NSURLProtocol的client对象回调给上层，例如：

　　在startLoading方法中，实现请求，并返回结果。

- (void)startLoading
{
    self.clientRunLoop = CFRunLoopGetCurrent();
    NSURLRequest* request = self.request;
    id<NSURLProtocolClient> client = self.client;
    
    if (!self.stub)
    {
        NSDictionary* userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
                                  @"It seems like the stub has been removed BEFORE the response had time to be sent.",
                                  NSLocalizedFailureReasonErrorKey,
                                  @"For more info, see https://github.com/AliSoftware/OHHTTPStubs/wiki/OHHTTPStubs-and-asynchronous-tests",
                                  NSLocalizedRecoverySuggestionErrorKey,
                                  request.URL, // Stop right here if request.URL is nil
                                  NSURLErrorFailingURLErrorKey,
                                  nil];
        NSError* error = [NSError errorWithDomain:@"OHHTTPStubs" code:500 userInfo:userInfo];
        [client URLProtocol:self didFailWithError:error];
        if (OHHTTPStubs.sharedInstance.afterStubFinishBlock)
        {
            OHHTTPStubs.sharedInstance.afterStubFinishBlock(request, self.stub, nil, error);
        }
        return;
    }
    
    OHHTTPStubsResponse* responseStub = self.stub.responseBlock(request);
    
    if (OHHTTPStubs.sharedInstance.onStubActivationBlock)
    {
        OHHTTPStubs.sharedInstance.onStubActivationBlock(request, self.stub, responseStub);
    }
    
    if (responseStub.error == nil)
    {
        NSHTTPURLResponse* urlResponse = [[NSHTTPURLResponse alloc] initWithURL:request.URL
                                                                     statusCode:responseStub.statusCode
                                                                    HTTPVersion:@"HTTP/1.1"
                                                                   headerFields:responseStub.httpHeaders];
        
        // Cookies handling
        if (request.HTTPShouldHandleCookies && request.URL)
        {
            NSArray* cookies = [NSHTTPCookie cookiesWithResponseHeaderFields:responseStub.httpHeaders forURL:request.URL];
            if (cookies)
            {
                [NSHTTPCookieStorage.sharedHTTPCookieStorage setCookies:cookies forURL:request.URL mainDocumentURL:request.mainDocumentURL];
            }
        }
        
        
        NSString* redirectLocation = (responseStub.httpHeaders)[@"Location"];
        NSURL* redirectLocationURL;
        if (redirectLocation)
        {
            redirectLocationURL = [NSURL URLWithString:redirectLocation];
        }
        else
        {
            redirectLocationURL = nil;
        }
        [self executeOnClientRunLoopAfterDelay:responseStub.requestTime block:^{
            if (!self.stopped)
            {
                // Notify if a redirection occurred
                if (((responseStub.statusCode > 300) && (responseStub.statusCode < 400)) && redirectLocationURL)
                {
                    NSURLRequest* redirectRequest = [NSURLRequest requestWithURL:redirectLocationURL];
                    [client URLProtocol:self wasRedirectedToRequest:redirectRequest redirectResponse:urlResponse];
                    if (OHHTTPStubs.sharedInstance.onStubRedirectBlock)
                    {
                        OHHTTPStubs.sharedInstance.onStubRedirectBlock(request, redirectRequest, self.stub, responseStub);
                    }
                }
                
                // Send the response (even for redirections)
                [client URLProtocol:self didReceiveResponse:urlResponse cacheStoragePolicy:NSURLCacheStorageNotAllowed];
                if(responseStub.inputStream.streamStatus == NSStreamStatusNotOpen)
                {
                    [responseStub.inputStream open];
                }
                [self streamDataForClient:client
                         withStubResponse:responseStub
                               completion:^(NSError * error)
                 {
                     [responseStub.inputStream close];
                     NSError *blockError = nil;
                     if (error==nil)
                     {
                         [client URLProtocolDidFinishLoading:self];
                     }
                     else
                     {
                         [client URLProtocol:self didFailWithError:responseStub.error];
                         blockError = responseStub.error;
                     }
                     if (OHHTTPStubs.sharedInstance.afterStubFinishBlock)
                     {
                         OHHTTPStubs.sharedInstance.afterStubFinishBlock(request, self.stub, responseStub, blockError);
                     }
                 }];
            }
        }];
    } else {
        // Send the canned error
        [self executeOnClientRunLoopAfterDelay:responseStub.responseTime block:^{
            if (!self.stopped)
            {
                [client URLProtocol:self didFailWithError:responseStub.error];
                if (OHHTTPStubs.sharedInstance.afterStubFinishBlock)
                {
                    OHHTTPStubs.sharedInstance.afterStubFinishBlock(request, self.stub, responseStub, responseStub.error);
                }
            }
        }];
    }
}

- (void)stopLoading
{
    self.stopped = YES;
}