After 3 years of iOS development, he only needed 5 minutes to convince the interviewer

Preface

The one who borrows the carriage and horse is not good at running, but he can travel a thousand miles; the one who borrows the boat and oar is not good at swimming, but he can cross the river. The gentleman is not born different, but he is good at borrowing from things.

We once used the joy of white tea to wait for someone, and used the blooming and falling of flowers to sigh that we are not surprised by fame or disgrace.

A program is a file that can be run. A program has at least one process, and a process has at least one thread, namely the main thread.

text

• A program is a file that can be run. A program has at least one process, and a process has at least one thread, namely the main thread.
• Process: The ongoing program is called a process, which is responsible for the memory allocation of the program. Each process has its own independent virtual memory space. A program runs once, and has an independent memory unit during the execution process, while multiple threads share a piece of memory.
• What is a thread: A thread is the basic unit in a process (executable code segment). Threads can run concurrently to improve execution efficiency.
• The purpose of creating a thread is to start a new executable code segment and run it simultaneously with the code in the main thread to prevent the interface from freezing. It is the main means of implementing asynchronous technology, such as asynchronous network downloads.

1. Runloop knowledge points supplement

1 Impact of dragging UITextView on RunLoop mode in the simulator

1.1 performSelector: method

—-Explanation of this method: When this method is executed, it will be affected by the runloop operation mode. The default setting is defaultmode. When dragging, the runloop switches modes, so it will not be executed.

Code block and explanation one:

 //Since this method sets the RunLoop operation mode to two, when the user slides the UITextView, the RunLoop switches the mode and continues to execute, so the picture can be set
    [self.imageView1 performSelector:@selector(setImage:) withObject:[UIImage imageNamed:@ "/Users/xiaofeng/Desktop/Snip20160319_18.png" ] afterDelay:5.0 inModes:@[UITrackingRunLoopMode,NSDefaultRunLoopMode]];

Code block and explanation two:

 //The execution of this method will be affected by the outside world. When the user slides the UITextView, the image will not be set after 2 seconds. The runloop runs in the default mode. When the user slides the UITextView, the mode is switched, so the image will not be set.
    [self.imageView1 performSelector:@selector(setImage:) withObject:[UIImage imageNamed:@ "/Users/xiaofeng/Desktop/Snip20160319_15.png" ] afterDelay:2.0];

2 Question: How can I keep a thread alive and then let it jump to another task under certain circumstances?

Two resident threads

3. How to ensure that the thread does not die: create a RunLoop loop; then set the data source or timer

• 3.1 The first method: start an infinite loop -> such as a while infinite loop, to keep the thread alive. Although this can ensure that the thread does not die, it cannot ensure that the thread can perform other tasks (not advisable)
• 3.2 The second method: Opening a RunLoop loop can also ensure that the thread does not die, but it needs to be executed manually and the running mode needs to be set. Otherwise, if the RunLoop loop is only opened without setting the mode, the RunLoop will exit directly after it is opened and will not continue to execute (opening the RunLoop requires completing the specified three steps)

4 Requirements: When you click the create thread button, a thread is created, and then when you click the child thread to start doing other work, the child thread starts to perform other work

1 Create a subthread button:

 #pragma mark - create a child thread button
 - (IBAction)creatBtnClick:(id)sender
 {
 //Create a child thread
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(task) object:nil]; 
      
 [thread start];
 //If this code is not added, the thread will be released immediately after executing the task method. The purpose of writing this code here is to ensure that the thread does not die and can continue to execute other tasks
 self.thread = thread;
 }

Create a method implementation in the child thread button: In the task method, we only need to print the current thread.

Let the child thread start to continue working:

 #pragma mark - Let the thread continue working 
  
 - (IBAction)goOnBtnClick:(id)sender
 {
    [self performSelector:@selector(task2) onThread:self.thread withObject:nil waitUntilDone:YES];
 }

Question: If you run it like this, you will get an error.

Cause of error: Although self.thread = thread is written above to ensure that the child thread will not be released, the child thread is actually in a dead state because the runloop is not turned on. Therefore, an error will be reported when clicking to let the child thread continue to work.

Solution: Create a RunLoop for the child thread, keep the child thread running, and then call other methods that require the child thread to work by setting them in the method.

 #pragma mark - tasks that work in threads
 - (void)task
 {
    NSLog(@ "1------%@" ,[NSThread currentThread]);
 //Create RunLoop
    NSRunLoop *runLoop = [NSRunLoop currentRunLoop]; 
   
 //Create a timer (this method requires manual mode setting)
    NSTimer *timer = [NSTimer timerWithTimeInterval:2.0 target:self selector:@selector(timeRun) userInfo:nil repeats:YES];
 //
 // //Add to runloop and set the mode
    [runLoop addTimer:timer forMode:NSDefaultRunLoopMode];
 // [runLoop addPort:[NSPort port] forMode:NSDefaultRunLoopMode]; 
  
 //Start runloop 
  
 [runLoop run];
    NSLog(@ "%s-------2-----%@" ,__func__,[NSThread currentThread]);
 }

Note: The code for creating the clock and adding the clock to the runloop can be written as the following sentence, which can also ensure that the thread is not in a dead state.

 [runLoop addPort:[NSPort port] forMode:NSDefaultRunLoopMode];

5 RunLoop's automatic release pool

• When the RunLoop is created for the first time
• ***When RunLoop exits once
• Creation and destruction at other times: When RunLoop is about to sleep, the previous autorelease pool will be destroyed and a new one will be created.

6 Application of RunLoop in the network (just look at the code)

 - (void)delegate1
 {
 // Determine the request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login?username=520it&pwd=520it&type=JSON" ];
 //Create a mutable request object
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
 //Set up the proxy
    NSURLConnection *connention = [[NSURLConnection alloc] initWithRequest:request delegate:self startImmediately:YES]; 
  
 //Adding this code can change the thread in which the proxy method is executed. By default, it is executed in the main thread, but after adding this code, the proxy method will be executed in the child thread
    [connention setDelegateQueue:[[NSOperationQueue alloc] init]]; 
  
 //Start sending request
 //1) This method will add the connention object as a source to the runloop and set the running mode to default
 //2) If the current runloop does not exist, this method will automatically create and start the runloop of the current child thread
 [connention start];

Three Networks

1 Comparison between GET and POST:

• GET request parameters follow the URL directly (?)
• POST request parameters are in the request body

2 HTTP basic communication process: client -> request -> server; server -> response -> client

 Specific steps:
 2.1 Determine the request path
 2.2 Get the host name
 2.3 DNS domain name resolution
 2.4 Get the port number
 2.5 Connect to port 80 of 120.25.226.186
 2.6 Sending an HTTP GET request
 2.7 Receiving the server's response
 2.8 Closing a link

3 Requests and Responses

ask:

• Request header: contains the client's environment description, client request information, etc.
• Request body: the specific data sent by the client to the server, such as file data (only available for POST requests)

response:

• Response header: contains a description of the server and the returned data
• Response body: The specific data returned by the server to the client, such as file data

As shown:

4 HTTP Request

Third-party frameworks for HTTP requests: ASIHttpRequest (deprecated); AFNetworking (main); MKNetworking

Apple's own:

• NSURLConnection: simple to use, the oldest, most classic and most direct solution
• NSURLSession: More powerful than NSURLConnection, Apple currently recommends using this technology (important)
• CFNetwork: the underlying layer of NSURL*, pure C language

Third-party framework: (Enterprise development basically uses a third-party framework)

• ASIHttpRequest: Nicknamed "HTTP Terminator", it is extremely powerful, but unfortunately it has stopped updating.
• AFNetworking: Easy to use, provides basic common functions, has many maintainers and users (important)
• MKNsetworking: Easy to use, produced in India, India's hometown, with few maintenance and users

Four GET methods

• Concept: Two ways to send network requests, the main difference is already written above
• Sending a synchronous request

Specific steps:

 1> Determine the request path
 2> Create a request object
 3> Send request
 4 > Parse received data

 #pragma mark - Send synchronous request
 - (void)sendSync
 {
 // Determine the request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login?username=520it&pwd=520it&type=JSON" ]; 
  
 //Create a request object
    NSURLRequest *request = [NSURLRequest requestWithURL:url]; 
  
 //Initialize the response header information (set to empty)
    NSHTTPURLResponse *response = nil;
 // Initialize error message
 NSError *error = nil; 
  
 //Send request
 /**
 * *** parameter: request object
 *
 * The second parameter: response header information (the address passed in)
 *
 * The third parameter: error message (if the request fails, then error has a value) (the address passed in)
 */
    NSData *data = [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:&error]; 
  
 //Parse the returned response data
    NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
 }

3 Sending asynchronous requests

Note: The main difference between synchronous and asynchronous requests is the different methods used to send requests.

 #pragma mark - Send asynchronous request 
  
 - (void)sendAsync
 {
 // Determine the request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login?username=520it&pwd=520it&type=JSON" ]; 
  
 //Create a request object
    NSURLRequest *resquest = [NSURLRequest requestWithURL:url]; 
  
 //Send request
 /**
 * Parameter 1: request object
 *
 * Parameter 2: queue (acts on completionHandler)
 *
 * Parameter three: response information (response header; response data)
 response response header information
 data response body information
 connectionError Error message
 */
    [NSURLConnection sendAsynchronousRequest:resquest queue:[[NSOperationQueue alloc] init] completionHandler:^(NSURLResponse * _Nullable response, NSData * _Nullable data, NSError * _Nullable connectionError) {
 //Parse the data
        NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
 }];
 }

4 Sending network requests using a proxy

Note: You need to follow the protocol:

 <nsurlconnectiondatadelegate></nsurlconnectiondatadelegate>

Proxy method sending, which includes three ways to set up the proxy

 #pragma mark - proxy method sends request
 - (void)sendAsyncDelegate
 {
 // Determine the request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login?username=520it&pwd=520it&type=JSON" ]; 
  
 //Create a request object
    NSURLRequest *request = [NSURLRequest requestWithURL:url]; 
  
 //Set up the proxy
 //***Set proxy:
    [NSURLConnection connectionWithRequest:request delegate:self];
 //The second way to set up the proxy:
    NSURLConnection *connection1 = [[NSURLConnection alloc] initWithRequest:request delegate:self];
 //The third way to set up the proxy:
    NSURLConnection *connection2 = [[NSURLConnection alloc] initWithRequest:request delegate:self startImmediately:YES]; 
  
 [connection2 start];
 }

Implementing methods in the proxy

 #pragma mark - proxy method
 //Called when the request fails
 - (void) connection :(NSURLConnection *) connection didFailWithError:(NSError *)error
 {
    NSLog(@ "%s------%@" ,__func__,[NSThread currentThread]);
 }
 //Receive response header information
 - (void) connection :(NSURLConnection *) connection didReceiveResponse:(NSURLResponse *)response
 {
    NSLog(@ "%s------%@" ,__func__,[NSThread currentThread]); 
  
 //Create a binary data
    self.responseData = [NSMutableData data]; 
  
 }
 //Receive the response body (if the data is large enough, this method will be called multiple times)
 - (void) connection :(NSURLConnection *) connection didReceiveData:(NSData *)data
 {
    NSLog(@ "%s------%@" ,__func__,[NSThread currentThread]);
 //Concatenate binary data
    [self.responseData appendData:data];
 } 
  
 //Receiving completed (regardless of success or failure)
 - (void)connectionDidFinishLoading:(NSURLConnection *) connection  
 {
    NSLog(@ "%s------%@" ,__func__,[NSThread currentThread]); 
  
 //Parse the data
    NSLog(@ "%@" ,[[NSString alloc] initWithData:self.responseData encoding:NSUTF8StringEncoding]);
 }

Five POST methods

1 Look at the code directly, it is marked above

 - (void)touchesBegan:(NSSet*)touches withEvent:(UIEvent *)event
 {
 //Create request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login" ];
 //Create a mutable request object
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url]; 
  
 //Modify the request method
    request.HTTPMethod = @ "POST" ; 
  
 //Set request timeout
    request.timeoutInterval = 10; 
  
    NSURLResponse *response = nil; 
  
 NSError *error = nil; 
  
 //Set the request header information
    [request setValue:@ "jjjj" forHTTPHeaderField:@ "uuuuu" ]; 
  
 //Set the request body (parameters)
    request.HTTPBody = [@ "username=520it&pwd=520it&type=JSON" dataUsingEncoding:NSUTF8StringEncoding]; 
  
 //***Method: Send request (asynchronous request)
    [NSURLConnection sendAsynchronousRequest:request queue:[[NSOperationQueue alloc] init] completionHandler:^(NSURLResponse * _Nullable response, NSData * _Nullable data, NSError * _Nullable connectionError) {
 //Parse the data
        if (connectionError == nil) {
            NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]); 
  
 } else {
            NSLog(@ "%@" ,connectionError);
 }
 }]; 
  
 //The second method: send request (synchronous request)
    NSData *data = [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:&error];
 //Parse the data
    NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
 }

6 Chinese Conversion

1. Determine whether transcoding is needed: Check whether the request path contains Chinese characters. If so, transcoding is required.
2. In the method of setting an additional parameter of the proxy: if it is set to NO, then when it is manually started, the underlying start will add the thread to the runloop, but if it is set to yes, then the runloop needs to be created manually, just like when there is no parameter.

GET transcoding:

 #pragma mark - GET transcoding
 - (void)get
 {
 //Confirm the request string
 NSString *strurl = @ "http://120.25.226.186:32812/login2?username=(Chinese characters to be converted)&pwd=520it&type=JSON" ; 
  
 //Transcoding
    strurl = [strurl stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]; 
  
 //Determine the path
    NSURL *url = [NSURL URLWithString:strurl]; 
  
 //Create a mutable request object
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url]; 
  
 //Send request --->GET request  
    [NSURLConnection sendAsynchronousRequest:request queue:[[NSOperationQueue alloc] init] completionHandler:^(NSURLResponse * _Nullable response, NSData * _Nullable data, NSError * _Nullable connectionError) {
 //Parse the data
        if (connectionError == nil) {
            NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
 } else {
            NSLog(@ "%@" ,connectionError);
 }
 }];
 }

POST transcoding:

 #pragma mark - POST transcoding
 - (void)post
 {
 //Determine the string of the request path
    NSString *urlstr = @ "http://120.25.226.186:32812/login2" ; 
  
 //Confirm the url
    NSURL *url = [NSURL URLWithString:urlstr]; 
  
 //Create a request object
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url]; 
  
 //Convert to POST format
    request.HTTPMethod = @ "POST" ;
 //Transcoding
 request.HTTPBody = [@ "username=(Chinese characters to be converted)&pwd=520it&type=JSON" dataUsingEncoding:NSUTF8StringEncoding ];
    NSURLResponse *response = nil;
 NSError *error = nil; 
  
 //Send request (synchronous request)
    NSData *data = [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:&error];
 //Parse the data
    NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]); 
  
 //Send request (asynchronous request)
    [NSURLConnection sendAsynchronousRequest:request queue:[NSOperationQueue mainQueue] completionHandler:^(NSURLResponse * _Nullable response, NSData * _Nullable data, NSError * _Nullable connectionError) {
 //Parse the data
        if (connectionError == nil) {
            NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
 } else {
            NSLog(@ "%@" ,connectionError);
 } 
  
 }];
 }

Seven simple uses of NSURLSession

1 NSURLSession —-> GET usage:

 - (void)get
 {
 // Determine the request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login?username=520it&pwd=520it&type=JSON" ];
 //Create a request object
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
 //Get the session object (a singleton)
    NSURLSession *session = [NSURLSession sharedSession]; 
  
 //Create a task based on the session object
 /**
 * Parameter 1: request object
 *
 * Parameter 2: response header information; response body data information; error information
 *
 *
 */
    NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
 //Parse the data
        NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
 //This block is called in the child thread
         NSLog(@ "%@" ,[NSThread currentThread]);
 } ]; 
  
 //Execute task
 [dataTask resume];
 }

2 GET usage 2:

 - (void)get1
 {
 // Determine the request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login?username=520it&pwd=520it&type=JSON" ]; 
  
 //Create a request object
 // NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url]; 
  
 //Create a session object
    NSURLSession *session = [NSURLSession sharedSession]; 
  
 //Create a task based on the session object
    NSURLSessionDataTask *dataTask = [session dataTaskWithURL:url completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
 //This block is called in the child thread
         NSLog(@ "%@" ,[NSThread currentThread]);
 }];
 //Start task
 [dataTask resume];
 }

3 The difference between GET1 and GET2 is that they create different tasks based on the session object, but their usage is the same.

4 POST usage:

 - (void)post
 {
 // Determine the request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login" ]; 
  
 //Create a mutable request object
    NSMutableURLRequest *resquest = [NSMutableURLRequest requestWithURL:url]; 
  
 //Convert format
    resquest.HTTPMethod = @ "POST" ; 
  
 //Set the request body information
    resquest.HTTPBody = [@ "username=520it&pwd=520it&type=JSON" dataUsingEncoding:NSUTF8StringEncoding]; 
  
 //Get the session
    NSURLSession *session = [NSURLSession sharedSession]; 
  
 //Create a task using the session object
    NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:resquest completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) { 
  
 //Parse the data
 if (error == nil) {
            NSLog(@ "%@" ,[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
 } else {
            NSLog(@ "%@" ,error);
 }
 //This block is called in the child thread
        NSLog(@ "%@" ,[NSThread currentThread]);
 }]; 
  
 //Execute task resume ------>Resume  
 [dataTask resume];
 }

Eight NSURLSession proxy methods

1 Main method (set up the proxy in it)

 - (void)sessionGet
 {
 // Determine the request path
    NSURL *url = [NSURL URLWithString:@ "http://120.25.226.186:32812/login?username=520it&pwd=520it&type=JSON" ];
 //Create a mutable request object
    NSURLRequest *request = [NSURLRequest requestWithURL:url]; 
  
 //Get the session (delegateQueue: determines whether the proxy task is executed in the child thread or the main thread)
    NSURLSession *session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:self delegateQueue:[NSOperationQueue mainQueue]]; 
  
 //Create task
    NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request];
 //Execute task
 [dataTask resume]; 
  
 }

2 Proxy Methods

Note: Pay special attention to the first proxy method because you need to call back to tell the system how to process the data returned by the server. If you don't write it, the following two proxy methods will not be called because the completionHandler does not tell the system how to process the server data.

 #pragma mark - proxy method
 //Receive response
 - (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveResponse:(NSURLResponse *)response completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler
 {
    NSLog(@ "%s-------%@" ,__func__,[NSThread currentThread]); 
  
    self.data = [NSMutableData data];
 //In this method, the completionHandler callback needs to be used to tell the system how to process the data returned by the server
    completionHandler(NSURLSessionResponseAllow);
 }
 //Receive binary data (call multiple times if the amount of data is large)
 - (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data
 { 
  
    NSLog(@ "%s-----%@" ,__func__,[NSThread currentThread]);
 //Splicing data
    [self.data appendData:data]; 
  
 }
 //Called when completed or failed
 - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
 {
    NSLog(@ "%s------%@" ,__func__,[[NSString alloc] initWithData:self.data encoding:NSUTF8StringEncoding]);
    NSLog(@ "%@" ,[NSThread currentThread]);
 }