iOS termination function exit

1. Exit Function

The C,c++ function exit is used to terminate the current program, and the function is defined as follows:

1. void exit (int status);

The official notes are as follows:

Terminates the process normally, performing the regular cleanup for terminating programs.
Normal program termination performs the following (in the same order):

• Objects associated with the current thread with thread storage duration is destroyed (c++11 only).
• Objects with static storage duration is destroyed (c + +) and functions registered withatexit is called.
• All C streams (open with functions in <cstudio>) is closed (and flushed, if buffered), and all files created with T Mpfile is removed.
• Control is returned to the host environment.
  

The third 4th is easier to understand than to start a discussion .

1th:

The thread storage here refers to threads that are locally stored, valid for the threaded scope, and c++11 define the thread storage as follows:

[HTML]View Plaincopy

1. Thread_local Object obj; object is a C + + class
2. thread_local int value = 1;

2nd:static storage refers to a variable defined in the global or static mode of a function that is stored in a static store (as distinct from the heap and stack), such as: [HTML]View Plaincopy

1. Object GOBJ;
3. void Fun () {
5. Static Object sobj;
7. }

The function set by atexit is called during exit, and the ATEXIT function is defined as follows: [HTML]View Plaincopy

1. int atexit (void (*func) (void));

Atexit examples are as follows: [CPP]View Plaincopy

2. / * Atexit Example * /   
4. #include <stdio.h>/* puts * /   
6. #include <stdlib.h>/* atexit * /   
10. void fnExit1 (void)
12. {
14. Puts ("Exit function 1." )  );
16. }
20. void fnExit2 (void)
22. {
24. Puts ("Exit function 2." )  );
26. }
30. int Main ()
32. {
34. Atexit (FNEXIT1);
36. Atexit (FNEXIT2);
38. Puts ("Main function." )  );
40. Exit (0);
42. }

the output is: [HTML]View Plaincopy

1. Main function.
2. Exit function 2.
3. Exit function 1.

for C + + object destruction Order, you can see the following example: [CPP]View Plaincopy

2. #include <stdio.h>   
4. #include <stdlib.h>   
6. #include <unistd.h>   
8. #include <thread>   
10. #include <string>   
12. #include <iostream>   
16. class MyObject
18. {
20. Public :  
22. std::string str;
24. Public :  
26. MyObject (std::string str) {
28. This  ->str = str;
30. }
34. ~myobject () {
36. printf ("%s--%s\n", __function__, Str.c_str ());
38. }
40. };
46. void thread_fun (int N)
48. {
50. Thread_local MyObject threadobj ("thread_local subthread obj");
52. //do something   
54. Sleep (2);
56. }
60. void Exit_fun () {
62. MyObject threadobj ("atexit obj");
64. //do something   
66. Sleep (1);
68. }
72. MyObject obj ("Global obj");
74. int Main (int argc, const char * argv[])
76. {
78. Thread_local MyObject threadobj ("thread_local mainthread obj");
80. Static  MyObject staticobj ("fun static obj");
82. std::thread t (thread_fun, 1);
84. Atexit (Exit_fun);
88. Sleep (2);
90. Exit (0);
92. }

Output: [CPP]View Plaincopy

1. ~myobject--thread_local subthread obj
2. ~myobject--thread_local mainthread obj
3. ~myobject--Atexit obj
4. ~myobject--Fun static obj
5. ~myobject--Global obj
6. Program ended with exit code:0

As can be seen from the above, for the 2nd is to call Atexit first, and then clean up the static storage

2. Exit vs Abort

void abort (void);

The abort function is actually sending SIGABRT signal, which terminates the program directly if it is not processed, and does not do cleanup operations at this time, which is equivalent to terminating the program directly.

3. IOS Exit Function
double-clicking the Home Manual Kill program will call the Exit function to close the program, the __cxa_finalize function will perform the above mentioned cleanup work.

if the appdelegate applicationwillterminate function is overloaded, the function is called before exit is executed, and the developer program processing opportunity is provided before terminating .


If the program has retreated to the background and is in the suspend state, then manual kill does not call exit as above, but sends Sigkill signal to terminate the program directly.

4. Exit and multithreadingWhen exit is invoked, if other threads are executing and accessing the global or Staic C + + object, it is possible that an unexpected memory error has occurred because these objects have been destroyed, such as: SIGBUS,SIGSEGV. To avoid this problem you can have some of the following processing scenarios:
1). Move the object from the static storage on the heap to avoid the exit process destroying the object with unintended resultsFor example: [HTML]View Plaincopy

1. MyObject gObj ("Global obj");
2. ------>
3. myobject* pObj = new MyObject ("Global obj ptr");

2). Use Atexit to register callbacks, or end child threads in Applicationwillterminate (IOS) to avoid referencing objects that might be destroyed.


5. Terminate the program on iOS
1). Active call exit or user termination (program does not enter suspend state, ApplicationdidenterbackgroundNo callback )

You can call exit (0) to terminate the program directly on iOS, as well as clean up C + + object as mentioned above cleanup. (Note: IOS 7.0 simulator is not cleaned, iphone and 7.1 simulator are OK, estimated to be simulator bug)
2). If the program has entered the suspend state Applicationdidenterbackground has been callback, the system will send the Sigkill directly to the end of the Force program

iOS termination function exit