Shulou(Shulou.com)06/02 Report--

This article introduces the relevant knowledge of "what to do with Swift5 forced monopolization of memory". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Swift 5 will bring improved memory security for Swift programs, and when other parts of the program modify variables, they are not allowed to be accessed by other variable names. This change has a significant impact on the behavior of existing applications and on the Swift compiler itself.

Exclusive memory access problems can occur in many cases. The compiler can capture most of the problems statically, and the rest can only be handled at run time. Issues that can only be addressed at run time include exclusive violations with escaped closures, class type properties, static properties, and global variables.

To better illustrate this, we can consider a fairly common situation: modify the inout variable of a function, which executes a closure that accesses the above variables using two different names in the same scope:

Func modifyTwice (_ value: inout Int, by modifier: (inout Int)-> ()) {modifier (& value) modifier (& value)} func testCount () {var count = 1 modifyTwice (& count) {$0 + = count} print (count)}

In this example, there is a problem because count is used as the inout parameter for both modifyTwice and modifier. We don't know what the print statement should print out. The first time the count variable is incremented, its value increases to 2. But what is the count value to add to $0 when the second addition is performed? This may depend on many factors, because memory operations are not necessarily instantaneous. To make matters worse, the compiler may introduce optimizations to further complicate the situation.

This problem is related not only to the unpredictability of modifying memory through different variable names at the same time, but also to the complexity of the compiler.

This can lead to unexpected and confusing results. It also leads to highly conservative implementations of compilers and standard libraries, which usually have to ensure the basic reliability of the program (no crashes or undefined behavior), even in unusual circumstances.

All of this means that applications compiled with the Swift 5 compiler will crash at run time if exclusive access violations are found. This behavior was previously available in Swift 4 compiler debug mode, so programs that have only been tested in runtime mode are at risk of crashing when compiled with Swift 5.

The Swift 4 compiler is available, so programs tested only in run-time mode may crash when compiled with Swift 5.

The general way to fix access exclusive violations is to copy data. In our example, this boils down to:

Func modifyTwice (_ value: inout Int, by modifier: (inout Int)-> ()) {modifier (& value) modifier (& value)} func testCount () {var count = 1 let increment = count modifyTwice (& count) {$0 + = increment} print (count)}

In fact, access exclusive violation checking may be disabled, but it is strongly recommended not to do so:

While disabling runtime checking may solve performance problems, it does not mean that exclusive violations are safe. If enforcement is not enabled, the programmer must follow the exclusive rule.

This is the end of the content of "what to do with Swift5 forced monopolization of memory". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.