IOS development interview strategy (KVO, KVC, multithreading, lock, runloop, timer)

KVO & KVC

KVO

Usage and underlying principles

• Usage method ： Add observers , Then how to implement the listening agent

• KVO
  The bottom layer uses  
  isa-swizling
  Technology .

• OC
  Each object in / Class has
  isa
  The pointer , 
  isa
    Indicates which class the object is .

• When a property of an object is registered with  observer, The system will create a new intermediate class （
  intermediate class
  ） Inherit the original
  class
  , Put the object's
  isa
  Pointer to intermediate class .

• Then the intermediate class will override
  setter
  Method , call
  setter
  Previous call
  willChangeValueForKey
  ,  call
  setter
  Then call
  didChangeValueForKey
  , This notifies all observers that the value has changed .

• Rewrote  
  -class
    Method , Trying to deceive us, this class has not changed , It's the original kind of .

KVO Advantages and disadvantages

• advantage

• 1、 The association and synchronization of two objects can be realized conveniently and quickly , for example
  view & model

• 2、 Changes in new and old values can be observed

• 3、 You can easily observe the data changes of nested types

• shortcoming

• 1、 Observation object passing
  string
  Type settings , If you write it wrong or the variable name changes , It can pass at compile time, but it will happen at run time
  crash

• 2、 Observing multiple values requires multiple values in the proxy method
  if
  Judge

• 3、 Forgetting to remove the observer or repeatedly removing the observer can lead to
  crash

How to trigger manually

KVO

• KVO
  The mechanism is through
  willChangeValueForKey:
  and
  didChangeValueForKey:
  Triggered by two methods .

• Call before observing object changes
  willChangeValueForKey:

• After watching the change of objects
  didChangeValueForKey:

• Therefore, you only need to call it manually before and after changing the observation value .

to KVO Add filter

• rewrite
  automaticallyNotifiesObserversForKey
  , Need to be screened
  key
  return
  NO
  .

• setter
  Manually triggered after adding judgment in
  KVO

Use KVC Modification will trigger KVO Do you ？

• Meeting , as long as
  accessInstanceVariablesDirectly
  return
  YES
  , adopt KVC Modifying the value of a member variable triggers KVO.

• This explanation KVC Internal call
  willChangeValueForKey:
  Methods and
  didChangeValueForKey:
  Method

Modifying member variables directly triggers KVO Do you ？

• Can't

KVO Collapse and protection of

• KVO  Number of add and remove does not match , Most are removed more than registered .

• Observed
  dealloc
  Is still registered  KVO, Cause crash .

• Added observers , But not implemented  
  observeValueForKeyPath:ofObject:change:context:
   .  Protection plan 1：

• Use it directly facebook Open source framework
  KVOController
    Protection plan 2：

• Customize a hash table , Record the relationship between the observer and the observed object .

• Use
  fishhook
  Replace  
  addObserver:forKeyPath:options:context:
  , Judge whether the same observer already exists before adding , Add... If it doesn't exist , Avoid repeated triggering bug.

• Use
  fishhook
  Replace
  removeObserver:forKeyPath:
  and
  removeObserver:forKeyPath:context
  , Judge whether there is a corresponding relationship before removing , Release only if it exists .

• Use
  fishhook
  Replace
  dealloc
  , perform
  dealloc
  Determine whether there are observers that have not been removed before , Remove if it exists first .

KVC Underlying principle

setValue:forKey:

The implementation of the

• lookup
  setKey:
  Methods and
  _setKey:
  Method , Pass parameters directly as soon as they are found , Calling method ;

• If not found
  setKey:
  and
  _setKey:
  Method , see
  accessInstanceVariablesDirectly
  Return value of method , If you return
  NO
  （ Direct access to member variables is not allowed ）, call
  setValue:forUndefineKey:
  And throw an exception
  NSUnknownKeyException
  ;

• If
  accessInstanceVariablesDirectly
  Method returns
  YES
  （ You can access its member variables ）, Just look it up in order  
  _key、_isKey、key、isKey
    These four member variables , If it is found, it will be assigned directly ; If we don't find out , call
  setValue:forUndefineKey:
  And throw an exception
  NSUnknownKeyException
  .

valueForKey:

The implementation of the

• according to
  getKey,key,isKey
  How to find the order of , Call directly as soon as you find it ;

• If not found ,
  accessInstanceVariablesDirectly
  return
  YES
  （ You can access its member variables ）, Find in order
  _key、_isKey、key、isKey
    These four member variables , Just find it ; If the member variable is not found , call
  valueforUndefineKey
  And throw an exception
  NSUnknownKeyException
  .

• accessInstanceVariablesDirectly
  return
  NO
  （ Direct access to member variables is not allowed ）, Then call
  valueforUndefineKey:
  Method , And throw an exception
  NSUnknownKeyException
  ;

Multithreading

Difference between process and thread

• process ： A process is an application running in the system , A process has multiple threads .

• Threads ： A thread is a unit in a process , Want to perform a task ,  There must be at least one thread . The main thread is turned on by default when the program starts .

What's the state of the process

• Not Running
  ： Not running .

• Inactive
  ： Front desk inactive . At the front desk , But you can't accept event handling .

• Active
  ： Foreground activity status . At the front desk , Can accept event handling .

• Background
  ： Backstage status . Backstage , If you have executable code , Can execute code , Code execution completed , The program is suspended .

• Suspended
  ： Pending state . Backstage , Can't execute code , If there is not enough memory , The program will be killed .

What is thread safety ？

• Multiple threads access a piece of code at the same time , It will not cause data confusion

How to ensure thread safety ？

• Lock through thread

• pthread_mutex
    The mutex （C Language ）

• @synchronized

• NSLock
    Object lock

• NSRecursiveLock
    Recursive lock

• NSCondition & NSConditionLock
    Conditional lock

• dispatch_semaphore
   GCD The semaphore realizes locking

• OSSpinLock
  spinlocks （ Not recommended ）

• os_unfair_lock
  spinlocks （IOS10 Replace later
  OSSpinLock
  ）

Projects you come into contact with , Which scenarios apply thread safety ？

• Additions and deletions to the online list , Need to lock to keep it thread safe .

iOS

How many types of threads are there in development ？ Talk about

• 1、
  pthread

• C Language implementation of cross platform general multithreading API

• It's very difficult to use , No use.

• 2、
  NSThread

• OC
  Object oriented multithreading
  API

• Simple and easy to use , You can manipulate Thread objects directly .

• Need to manually manage the lifecycle

• 3、
  GCD

• C Language implementation of multi-core parallelism CPU programme , It can run multi-core more reasonably
  CPU

• It can automatically manage the life cycle

• 4、
  NSOperation

• OC
  be based on
  GCD
  Encapsulation

• Fully object-oriented multithreading scheme

• It can automatically manage the life cycle

GCD What queue is there , Which queues are provided by default

• Serial synchronization queue , The tasks are in order （ Serial ）, Execute on current thread （ Sync ）

• Serial asynchronous queue , The tasks are in order （ Serial ）, Open up new threads to execute （ asynchronous ）

• Parallel synchronization queue , The tasks are in order （ Cannot embody parallelism ）, Execute on current thread （ Sync ）

• Parallel asynchronous queue , The task is carried out at the same time （ parallel ）, Open up new threads to execute （ asynchronous ）

• Main queue and global queue are provided by default

GCD

The main thread  &  The relationship between the home team

• The main queue task is executed only in the main thread

• The main thread is running a  
  runloop
  , Except for the task of the main line , also  UI  Processing and drawing tasks .

Describe the difference between synchronous and asynchronous threads ?

• Thread synchronization means that there are currently multiple threads , You must wait for one thread to finish executing before you can execute the next thread .

• Thread asynchrony refers to a thread executing , His next thread doesn't have to wait for him to finish executing .

Thread synchronization

• GCD
  The serial queue of , The tasks are executed one by one

• NSOperationQueue
  Set up
  maxConcurrentOperationCount = 1
  , Only... At the same time 1 individual
  NSOperation
  Be performed

• Use
  dispatch_semaphore
  Semaphores block threads , Release until the task is completed

• dispatch_group
  It can also be blocked until all tasks are completed

Under what circumstances will thread deadlock

• Serial queue , The task in progress A Add a synchronization task to the serial queue B, Can cause AB The two tasks are waiting for each other , Formation of a deadlock .

• Priority reversal ,
  OSSpinlock

dispatch_once

Realization principle

• dispatch_once
  Need to
  dispatch_once_t
  Parameters of type , It's actually a long plastic surgery

• Handle
  block
  Will judge the incoming
  dispatch_once_t
  Is it 0, by 0 Express
  block
    Has not yet been performed .

• Put... After execution
  token
  To change the value of 1, The next time you come in, judge whether it's not 0 Don't deal with it directly .

performSelector

and

runloop

The relationship between

• call  
  performSelecter:afterDelay:
   , Inside it will create a
  Timer
  And add... To the current thread
  RunLoop
   .

• If the current thread
  Runloop
  Didn't run , This method will fail .

• Other
  performSelector
  A series of methods are similar

Sub thread execution  

[p performSelector:@selector(func) withObject:nil afterDelay:4]

  What's going to happen ？

• The above method is placed in the sub thread , In fact, an internal will be created
  NSTimer
  Timer .

• The child thread will not be turned on by default
  runloop
  , If it is necessary to carry out
  func
  The function has to be turned on manually
  runloop

Why only refresh in the main thread UI

• UIKit
  It's not thread safe ,UI The operation involves rendering and accessing
  View
  Properties of , Asynchronous operation will have read and write problems , Locking it will consume a lot of resources and slow down the running speed .

• The starting point of the program
  UIApplication
  Initialize in the main thread , All user events （ Touch interaction ） Are passed in the main thread , therefore
  view
  Events can only be responded to on the main thread .

A queue is responsible for inserting data , A queue is responsible for reading operations , Operate a stored queue at the same time , How to ensure smooth progress

• Use
  GCD
  The fence function realizes multiple single write

• When reading, use  
  dispatch_sync
    Return data immediately

• Use... When writing  
  dispatch_barrier_async
    Write after blocking other operations

• Be careful not to use global queues , Because there are other operations in the global queue

lock

Why locks are needed ？

• In multithreaded programming, threads interfere with each other , For example, multiple threads access a resource .

• Need some synchronization tools , Make sure it's safe when threads interact .

What is a mutex

• If the shared data has been locked by other threads , The thread will sleep and wait for the lock

• Once the accessed resource is unlocked , The thread waiting for the resource will be awakened .

• It is recommended to use mutex when the task is complex and takes a long time

• advantage

• Thread hibernates when resources are not available ,cpu You can schedule other threads to work

• shortcoming

• There is the overhead of thread scheduling

• If the task time is short , Thread scheduling is reduced cpu The efficiency of

What is spin lock

• If the shared data has been locked by another thread , Threads wait for locks in a dead loop

• Once the accessed resource is unlocked , The thread waiting for the resource will execute immediately

• Suitable for holding the lock for a short time

• advantage ：

• Spin locks do not cause threads to sleep , No thread scheduling and CPU Time consuming operations such as time slice rotation .

• If you can get the lock in a short time , The efficiency of spin lock is much higher than that of mutual exclusion lock .

• shortcoming ：

• Spin lock always occupied CPU, In a busy state without a lock .

• If you can't get the lock in a short time , send CPU Low efficiency .

• Spin locks do not implement recursive calls .

Read-write lock

• Read write locks are also known as  
  rw lock
  perhaps  
  readwrite lock

• Not the most commonly used , Generally, it is only used for database operation .

• The specific operation is multi read and single write , Write operations can only be performed serially , And cannot be read while writing ; Reading needs to support multi-threaded operation , And cannot write when reading

Tell me about the locks you know

• pthread_mutex
    The mutex （C Language ）

• @synchronized

• NSLock
    Object lock

• NSRecursiveLock
    Recursive lock

• NSCondition & NSConditionLock
    Conditional lock

• dispatch_semaphore
   GCD The semaphore realizes locking

• OSSpinLock
  spinlocks （ It is not recommended to use ）

• os_unfair_lock
  spinlocks （IOS10 Replace later
  OSSpinLock
  ）

say something

@synchronized

• principle

• The inside should be a reentrant mutex （
  recursive_mutex_t
  ）

• At the bottom is the list , Storage SyncData,SyncData It contains a  
  threadCount
  , Is the number of threads accessing resources .

• objc_sync_enter(obj),objc_sync_exit(obj)
  , adopt
  obj
  The address of
  hash
  Pass parameter search
  SyncData
  , Lock and unlock .

• Incoming
  obj
  Be released or be
  nil
  , It will release the lock

• advantage

• The lock function can be realized without creating a lock object

• Easy to use , Code readability

• shortcoming

• Lock the code as little as possible

• The performance is not so good

• Note that the object of the lock must be the same
  OC
  object

say something

NSLock

• follow
  NSLocking
  agreement

• Be careful

• The same thread
  lock
  and
  unlock
  You need to be in pairs

• The same thread runs continuously
  lock
  Twice will cause a deadlock

say something

NSRecursiveLock

• NSRecursiveLock
  It's a recursive lock

• Be careful

• The same process
  lock
  Multiple times without deadlock

• When the same thread
  lock & unlock
  The lock will only be released when the number is the same , Other threads can be locked

say something

NSCondition & NSConditionLock

• Conditional lock ： Execute locked code when conditions are met ; If the condition is not met, the thread will be blocked , Until another thread sends an unlock signal .

• NSCondition
  Object actually acts as a lock and a Thread Checker

• Locks protect data sources , Executing tasks triggered by conditions .

• The thread checker determines whether to block the thread according to the condition .

• Manual waiting and manual signal release are required

• One
  wait
  Must correspond to a
  signal
  , All need to be used in one wake-up
  broadcast

• NSConditionLock
  yes
  NSCondition
  Encapsulation

• Through different
  condition
  Values trigger different operations

• Unlock through
  unlockWithCondition
    modify
  condition
  Implement task dependencies

• adopt
  condition
  Automatically determine whether to block or wake up the thread

say something GCD The semaphore realizes the lock

• dispatch_semaphore_creat(0)
  Generate a semaphore
  semaphore = 0
  （  The value passed in can control the number of parallel tasks ）

• dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
    send
  semaphore - 1
  , When the value is less than 0 Has reached the awaited

• dispatch_semaphore_signal(semaphore)
  Signal , send
  semaphore + 1
  , When the value is greater than or equal to 0 release

say something

OSSpinLock

• OSSpinLock
  It's a spin lock , Busy waiting lock

• Spin lock has the problem of priority reversal , When a thread has priority, it may cause the following situations .

• A low priority thread accesses some data first , At this time, the spin lock is used to lock .

• A high priority thread accesses the data again , High priority threads will always occupy CPU Resources are busy waiting for access

• As a result, threads with low priority do not CPU Resources complete the task , The lock cannot be released .

• Due to the problems of spin lock itself , So Apple has been abandoned
  OSSpinLock
  .

say something  

os_unfair_lock

• iOS10 Replace later
  OSSpinLock
  Lock of , No longer busy waiting

• Hibernate when resources are not available , When the resource is obtained, the kernel wakes up the thread

• There is no strengthening of fairness and order , The thread that releases the lock may immediately re lock , The thread waiting for the lock may fail to lock successfully after waking up .

• Although priority inversion is solved , But it also causes hunger （
  starvation
  ）

• starvation
    The greedy thread takes up too many resources , Other threads cannot access shared resources .

5 A thread reads a file , How to achieve at most only 2 Two threads read this file at the same time

• dispatch_semaphore
  Semaphore control

Objective-C Atomic and non atomic properties in

• OC When defining properties, there are
  nonatomic
  and
  atomic
  Two options

• atomic
  ： Atomic properties , by
  setter/getter
  All methods are locked （ The default is
  atomic
  ）, Thread safety , It takes a lot of resources

• nonatomic
  ： Non atomic properties , No locks , Non-thread safety

atomic

  Decorated attributes  

int a

, Execute on different threads  

self.a = self.a + 1

  Ten thousand times , Will the value of this attribute be 10000 ？

• Can't , The point syntax on the left calls
  setter
  , The call on the right is
  getter
  , This line is not atomic .

atomic

Can thread safety be guaranteed ？

• You can't , Only guarantee
  setter
  and
  getter
  Security in the current thread

• When a thread reads a property value several times in a row , Other threads are changing values at the same time , In the end, we can't get the expected value

• A thread is getting the value of the current property ,  Another thread released this property , May cause breakdown

nonatomic

Is a non atomic operator , Why

nonatomic

no need

atomic

？

• If the object does not need to consider multithreading , Please add this attribute to modify , This will make the compiler generate less mutex locking code , Can improve efficiency .

• Use
  atomic
  , The compiler will be there
  setter
  and
  getter
  Method to automatically generate mutex code , Avoid asynchronous reading and writing of this variable .

Some people say yes

atomic

Memory consumption , Do you think? ？

• Because it locks automatically , So performance ratio
  nonatomic
  Bad .

atomic

Why does it fail

• atomic
  Modified attributes are automatically generated by the compiler
  get/set
  Method to realize atomic operation , If you rewrite any one ,
  atomic
  Keyword properties will be invalidated

nonatomic

Realization

atomic

  The implementation of the

runloop

runloop

What is it? ？

• There is a circular mechanism for managing events in the system

• runloop
    Is to use this cycle , Objects that manage messages and events .

runloop

  Is it equal to  

while(1) { do something ... }

 ？

• No

• while(1)
    It's a busy state , Need to occupy resources all the time .

• runloop
    Go to sleep when there are no messages to process , Here comes the news , Wake up when you need to deal with .

runloop

The basic model of

• iOS There are five of them
  runLoop
  Pattern

• UIInitializationRunLoopMode
  （ Enter the first... After startup
  Mode
  , It will not be used after startup , Switch to  
  kCFRunLoopDefaultMode
  ）

• kCFRunLoopDefaultMode
  （App Default
  Mode
  , Usually the main thread is in this  
  Mode
    Run under ）

• UITrackingRunLoopMode
  （ Interface tracking  
  Mode
  , be used for  
  ScrollView
    Track touch slide , Make sure that the interface doesn't slide under any other  
  Mode
    influence ）

• NSRunLoopCommonModes
   （ This is a fake
  Mode
  , Equivalent to
  NSDefaultRunLoopMode
  and
  NSEventTrackingRunLoopMode
  The combination of  ）

• GSEventReceiveRunLoopMode
  （ Accept the inside of the system event  
  Mode
  , It's not usually used ）

runLoop

The basic principle of

• The mainline in the system will be turned on by default
  runloop
  Detect events , When there are no events to deal with
  runloop
  Will be dormant .

• Once an event triggers , For example, the user clicks on the screen , Will wake up
  runloop
  Put into listening state , Then deal with the incident .

• After the event processing is completed, it will enter sleep again , Wait for the next event to wake up

runloop

Relationship with thread

• runloop
  One to one correspondence with thread .

• When the main thread is created, it is enabled by default
  runloop
  , To keep the program running .

• Threaded
  runloop
  It's lazy , Manual opening required .

runloop

Event handling process

• Events will trigger
  runloop
  The entry function of
  CFRunLoopRunSpecific
  , The function will first notify
  observer
  Switch the state to
  kCFRunLoopEntry
  , And then through
  __CFRunLoopRun
  start-up
  runloop
  Handling events

• __CFRunLoopRun
  The core of is a
  do - while
  loop , The cycle is as follows

runloop

How was it awakened

• When there is no message to process , Sleep threads to avoid resource consumption . Switch from user state to kernel state , Waiting for news ;

• When there is a message to process , Wake up the thread now , Go back to user mode to process messages ;

• source0
  Direct wake-up via screen trigger

• source0
  By calling
  mach_msg()
  Function to transfer control of the current thread to kernel state / User mode .

What is user mode 、 Nuclear mentality

• Kernel mode ： Run the operating system program  , Indicates that after an application process executes a system call , or I/O  interrupt , After the clock is interrupted , The process is in kernel execution

• User mode ： Run the user program  , Indicates that the process is executing in user state

runloop The state of

runLoop

  The method of Caton detection

• NSRunLoop
    The processing time is mainly in the following two cases

• kCFRunLoopBeforeSources
    and  
  kCFRunLoopBeforeWaiting
    Between

• kCFRunLoopAfterWaiting
    after

• The above two times are too long , It can be determined that the main route is stuck at this time

• You can add
  Observer
  To the main thread
  Runloop
  in , monitor
  Runloop
  State switching takes time , Monitor Caton

• Use one
  do-while
  Cyclic treatment of subgrade , The semaphore sets the threshold to judge whether it is stuck

• dispatch_semaphore_wait
    Return value  
  Not 0
    Express
  timeout
  What happened to carton

• Get the stack of Caton and pass it to the back end , reanalysis

How to start a resident thread

timer

NSTimer、CADisplayLink、dispatch_source_t

  The advantages and disadvantages of

• NSTimer

• The advantage is that
  target-action
  Pattern , Simple to use

• The disadvantage of careless citation is that it is easy to cause circulation . Need to rely on
  runloop
  ,
  runloop
  If it is blocked, it will be delayed until the next time
  runloop
  Cycle to execute , Therefore, the time accuracy is also slightly insufficient

• CADisplayLink

• The advantage is high precision , Call... After each refresh , Suitable for timing without stopping redrawing , For example, video

• The disadvantage is that it is easy to accidentally cause circular references .
  selector
  The cycle interval is greater than the interval between redrawing each frame , Will result in skipping several call opportunities . Single execution cannot be set .

• dispatch_source_t

• be based on
  GCD
  , High precision , Do not rely on
  runloop
  , Easy to use , Favorite timer

• It should be noted that the timer must be held when using , Otherwise, it will be released in advance .

NSTimer What happens when the child thread executes ？

• NSTimer
  When the sub thread calls, the sub thread needs to be opened manually
  runloop

• [[NSRunLoop currentRunLoop] run];

NSTimer

Why not ？

• If
  runloop
  At the right time
  NSTimer
  Arrival trigger time ,
  NSTimer
  The trigger will be postponed to the next
  runloop
  cycle

NSTimer

A circular quotation of ？

GCD timer