一、Delegate为什么要用weak或者assign修饰，不能用strong？
说明：weak、assign修饰的不会使引用计数器加1，strong会使引用计数器加1。
在Dog类中定义一个代理，先用Strong修饰：

#import <Foundation/Foundation.h>

@protocol DogDelegate<NSObject>
-(void)testDog;
@end

@interface Dog : NSObject
@property(nonatomic,strong)id<DogDelegate>delegate;
@end

在person类中使用Dog：

image.png

在viewController类中：

image.png

这种情况下，示意图为：

image.png

可以看出：
1、

@property(nonatomic,strong)Dog *dog;

person对dog有强引用
2、

@property(nonatomic,strong)id<DogDelegate>delegate;

self.dog.delegate = self，这句使delegate又对Person有强引用。

这样一来，当viewController不对Person引用后，dog.delegate对Person还有强引用，所以person不会释放，当然Person中的dog也不会释放，这样就有循环引用的情况。

第二情况：
在Dog类中，如果用weak修饰的话：

#import <Foundation/Foundation.h>

@protocol DogDelegate<NSObject>
-(void)testDog;
@end

@interface Dog : NSObject
@property(nonatomic,weak)id<DogDelegate>delegate;
@end

那么上面的示意图中，delegate对Person的引用为弱引用。
当viewController不对Person引用后，Person的retainCount为0，即person会被释放，因此，Person中的dog也会被释放了。这样就可以避免循环引用的问题了。

二、block的循环引用
文章参考了：https://www.jianshu.com/p/4384a42778bc
首先，不是在block中使用强引用，例如self，都会引起循环引用，这需要视情况而定。
比如： block不是self的属性或者变量时，在block内使用self也不会循环引用：
例如定义一个block：

@interface ViewController ()
{
    void(^myBlock)(void);
}

如果想要在block中，使用self，一般会这样解决循环引用:

__weak typeof(self) weakself = self;
    myBlock = ^(void){
        NSLog(@"----value111-%@====address111--%p-----sel111f=%p",weakself.person,weakself.person,weakself);

    };

这样的确可以解决block中的循环引用的问题，但是也有可能产生另外一个问题：
block中的使用的self已经被释放了，也就是为nil了。
假如:
新建一个继承NSObject的类testObject

#import "testObject.h"

@implementation testObject

-(void)dealloc{
    NSLog(@"本对象已经被销毁了--");
}
@end

我们知道判断一个对象是否被释放最可靠的方法就是看释放执行dealloc。
那么在ViewController中：

@interface ViewController ()
{
    void(^myBlock)(void);
}
@property(nonatomic,strong)testObject *test;
@property(nonatomic,strong)NSString *person;

@end

然后：

__weak typeof (_test) weakself = _test;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i=0; i<10; i++) {
            NSLog(@"-----------llllaaa===%@====%d",weakself,i);
            sleep(1);
        }
    });
    // 3秒后，释放对象
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3*NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        self.test = nil;
    });

也就是说3秒后将test释放，子线程中的block的test就为nil了，打印结果：

2018-03-10 17:02:03.748705+0800 aaa[3856:207467] -----------llllaaa===<testObject: 0x60400001c7b0>====1
2018-03-10 17:02:04.752324+0800 aaa[3856:207467] -----------llllaaa===<testObject: 0x60400001c7b0>====2
2018-03-10 17:02:05.754304+0800 aaa[3856:207467] -----------llllaaa===<testObject: 0x60400001c7b0>====3
2018-03-10 17:02:06.042539+0800 aaa[3856:207349] 本对象已经被销毁了--
2018-03-10 17:02:06.757422+0800 aaa[3856:207467] -----------llllaaa===(null)====4
2018-03-10 17:02:07.759369+0800 aaa[3856:207467] -----------llllaaa===(null)====5
2018-03-10 17:02:08.764179+0800 aaa[3856:207467] -----------llllaaa===(null)====6
2018-03-10 17:02:09.765000+0800 aaa[3856:207467] -----------llllaaa===(null)====7
2018-03-10 17:02:10.769800+0800 aaa[3856:207467] -----------llllaaa===(null)====8
2018-03-10 17:02:11.774028+0800 aaa[3856:207467] -----------llllaaa===(null)====9

怎么解决？在block中再用strong修饰符，

  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        __strong typeof (_test) strongSelf = _test; // 这样处理下
        for (int i=0; i<10; i++) {
            NSLog(@"-----------llllaaa===%@====%d",strongSelf,i);
            sleep(1);
        }
    });
    // 3秒后，释放对象
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3*NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        self.test = nil;
    });

打印：

2018-03-10 17:07:18.166733+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====1
2018-03-10 17:07:19.168924+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====2
2018-03-10 17:07:20.169278+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====3
2018-03-10 17:07:21.170645+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====4
2018-03-10 17:07:22.173204+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====5
2018-03-10 17:07:23.177067+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====6
2018-03-10 17:07:24.181829+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====7
2018-03-10 17:07:25.186076+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====8
2018-03-10 17:07:26.190384+0800 aaa[3905:211388] -----------llllaaa===<testObject: 0x60000000e9c0>====9
2018-03-10 17:07:27.192283+0800 aaa[3905:211388] 本对象已经被销毁了--

三、ios的编译跟链接
编译：只是单纯的检查每个源文件的语法是否合理，并不会检查每个源文件之前的关联关系，一个源文件编译成功就会产生一个目标文件。
链接：检查目标文件之前的关联关系，将相关联的目标文件组合在一起，生成可执行的文件。

四、runtime使用。
说起这个，最容易想起的应该是：交换方法、给分类动态关联属性了。

使用一、交换两个方法。

场景：在保持系统原有方法功能的基础上，添加额外的功能。
需求：加载一张图片：[UIImage imageNamed:@"image"]是无法知道这张图片是否已经加载成功的。
实现：使用runtime将两个方法进行交换
步骤:
1.定义一个Image的分类
2.在分类中定义一个方法，用于跟系统的imageNamed方法交换
3.交换方法。
定义一个UIImage+Image的分类

#import "UIImage+Image.h"
#import <objc/message.h>
@implementation UIImage (Image)

在load方法中用runtime将两个方法进行交换

image.png

image.png

完整代码：

#import "UIImage+Image.h"
#import <objc/message.h>
@implementation UIImage (Image)

// 在类加载进入内存的时候调用，并且只会调用一次
+(void)load{
    // 1.获取imageNamed方法的地址
    Method imageNamedMethod = class_getClassMethod(self, @selector(imageNamed:));
    // 2.获取自己写的replace_imageNamed方法地址
    Method replaceImageMethod = class_getClassMethod(self, @selector(replace_imageNamed:));
    // 3.交换方法地址，相当于交换实现的方式
    
    method_exchangeImplementations(imageNamedMethod, replaceImageMethod
                                   );
}


// 这样就相当于不改变原来功能的基础上增加了新的功能
/**
 注意：这里是不会引起死循环的
 调用：imageNamed: 相当于 调用 replace_imageNamed:
 调用: replace_imageNamed: 相当于 调用 imageNamed:
 */
+(UIImage *)replace_imageNamed:(NSString *)name{
    UIImage *image = [UIImage replace_imageNamed:name];
    if (image) {
        NSLog(@"---method交换成功");
    }else{
        NSLog(@"---method交换失败");
    }
    return image;
}
@end

使用：

#import "ViewController.h"
#import "UIImage+Image.h"
#import "Person.h"
#import "Student.h"
#import "NSObject+testRuntime.h"
#import "NSObject+DictToModel.h"
@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    UIImageView *imageView = [[UIImageView alloc]initWithFrame:CGRectMake(100, 100, 100, 100)];
    imageView.backgroundColor = [UIColor redColor];
    imageView.image = [UIImage imageNamed:@"8.png"];
    [self.view addSubview:imageView];
    

打印

---method交换成功

使用二、给分类动态添加属性
场景：例如给NSObject添加一个分类，在分类中是不能够添加成员属性的，虽然我们用了@property，但是仅仅会自动生成get和set方法的声明，并没有带下划线的属性和方法实现生成。但是我们可以通过runtime就可以做到给它方法的实现。

定义了一个NSObject+testRumtime

#import "NSObject+testRuntime.h"
#import <objc/message.h>
@implementation NSObject (testRuntime)

在.h文件中

#import <Foundation/Foundation.h>

@interface NSObject (testRuntime)

@property(nonatomic,copy)NSString *name;
-(void)obtainMessage;

@end

.m文件中

#import "NSObject+testRuntime.h"
#import <objc/message.h>
@implementation NSObject (testRuntime)
/**
 动态添加属性关联
 objc_setAssociatedObject  将某个值跟某个对象关联起来，将某个值存储到某个对象中
 object  给那个对象添加属性
 key 属性的名称
 value 属性值
 policy 保存策略
 */
-(void)setName:(NSString *)name{
    
    objc_setAssociatedObject(self, @"name", name,OBJC_ASSOCIATION_COPY_NONATOMIC);
}

-(void)obtainMessage{
    NSString *aa = self.name;
    NSLog(@"adasd-=--------%@",aa);
}

-(NSString *)name{
    return objc_getAssociatedObject(self, @"name");
}
@end

使用：

 Person *pp  = [[Person alloc]init];
 pp.name = @"xiaoming";
 NSLog(@"log--the--print--%@",pp.name);

打印：

log--the--print--xiaoming

使用三、将字典转成模型
思路:利用运行时，遍历模型的所有的属性，然后找到属性的名字，作为key到字典中查找value进行赋值。
出现的情况：
1.字典的key跟模型的属性匹配不上（key比模型的属性多，或者模型的属性比key多）
2.模型中套有模型
3.模型属性是数组，数组有模型

注解：根据上面的三种特殊情况，先是字典的key和模型的属性不对应的情况。不对应有两种，一种是字典的键值大于模型属性数量，这时候我们不需要任何处理，因为runtime是先遍历模型所有属性，再去字典中根据属性名找对应值进行赋值，多余的键值对也当然不会去看了；另外一种是模型属性数量大于字典的键值对，这时候由于属性没有对应值会被赋值为nil，就会导致crash，我们只需加一个判断即可。考虑三种情况下面一一注解；

步骤：提供一个NSObject分类，专门字典转模型，以后所有模型都可以通过这个分类实现字典转模型。

实现：
创建一个专门用来字典转模型的分类：NSObject+DicToModel

#import "NSObject+DictToModel.h"
#import <objc/message.h>
@implementation NSObject (DictToModel)

.m文件实现

#import "NSObject+DictToModel.h"
#import <objc/message.h>
@implementation NSObject (DictToModel)

+(instancetype)modelWithDict:(NSDictionary *)dict
{
    // 1.创建对应的对象
    id objc = [[self alloc]init];
    
    /**
     class_copyIvarList 获取某个类中的所有成员变量
     第一个参数: 表示获取哪一个类中的成员变量
     第二个参数: 表示这个类有多少的成员变量，传入的是Int变量的地址，会自动给变量地址赋值的
     返回值:Ivar *  是一个ivar数组来的，会把所有成员属性放在一个数组中，然后通过返回的数组就能全部获取到。
     count 成员变量的个数
     */
    unsigned int count = 0;
    // 获取类中的所有成员变量
    Ivar *ivarList =  class_copyIvarList(self, &count);
    
    for (int i=0; i<count; i++) {
        Ivar ivar = ivarList[I];
        // 获取成员变量的名字
        NSString *ivarName = [NSString stringWithUTF8String:ivar_getName(ivar)];
        // 获取变量的类型
        NSString *ivarType = [NSString stringWithUTF8String:ivar_getTypeEncoding(ivar)];
        
        // 处理成员变量名--->字典中的key(去掉_,从第一个角标开始截取)
        NSString *key = [ivarName substringFromIndex:1];
        // 根据属性名到字典中查找对应的value
        id value = dict[key];
        
        // 二级转换：如果字典中还有字典，也需要把对应字典进行转换
        if ([value isKindOfClass:[NSDictionary class]] && ![ivarType hasPrefix:@"NS"]) {
            
            // 根据字符串的类型生成类对象
            Class modelClass = NSClassFromString(ivarType);
            if (modelClass) {// 有对应的模型才需要转换
                value = [modelClass modelWithDict:value];
            }
        }
        // 三级转换，NSArray中也是字典，把数组中的字典转换成模型
        if ([value isKindOfClass:[NSArray class]]) {
            if ([self respondsToSelector:@selector(arrayContainModelClass)]) {
                // 这里先转换为id类型，方便调用任何对象的方法
                id idSelf = self;
                // 获取数组中字典对应的模型
                NSString *type = [idSelf arrayContainModelClass][key];
        
                // 生成模型
                Class classModel = NSClassFromString(type);
                NSMutableArray *mutableArray = [[NSMutableArray alloc]init];
                // 遍历字典数组，生成模型数组
                for (NSDictionary *dict in value) {
                    // 字典转模型
                    id model = [classModel modelWithDict:dict];
                    [mutableArray addObject:model];
                }
            // 把模型数组赋值给value
                value = mutableArray;
            }
        }
        // 要做一个判断，避免如果模型的属性大于字典的，就会产生nil
        if (value) {
            [objc setValue:value forKey:key];
        }
    }
    return objc;
}


@end

.h

#import <Foundation/Foundation.h>

@protocol ModelDelegate<NSObject>
+(NSDictionary *)arrayContainModelClass;
@end

@interface NSObject (DictToModel)
+(instancetype)modelWithDict:(NSDictionary *)dict;
@end

使用四、动态添加方法
OC是一门动态语言，一个函数是由一个selector(SEL)和一个implement(IML)组成的。其中SEL相当于门牌号，而IML就是住户（函数的实现)，同理，门牌号是可以乱发，但不一定能找到住户的。
ios中，根据门牌号（SEL）查找方法实现是有一个过程的。如图所示：
盗图的，参考http://www.cnblogs.com/biosli/p/NSObject_inherit_2.html

image.png

也就是，当调用了没有对应的IML时，

1.系统首先会执行对象中的resolveInstanceMethod函数来返回BOOL
2.如果调用resolveInstanceMethod还是没找到SEL实现，则会执行对象中的forwardingTargetForSelector来返回一个id
3.如果forwardingTargetForSelector返回的是nil或者self，则还有一次机会，
会执行系统中的methodSignatureForSelector来返回NSMethodSignature,
紧跟着执行对象中的forwardInvocation，
因此一般来说，methodSignatureForSelector跟forwardInvocation是成对出现的。
4.如果第3步还是没有可执行的IML，那么则会调用doesNotRecognizeSelector并且抛出异常。

应用的场景可分为:

在一个函数找不到时，Objective-C提供了三种方式去补救：

1、调用resolveInstanceMethod给个机会让类添加这个实现这个函数

2、调用forwardingTargetForSelector让别的对象去执行这个函数

3、调用methodSignatureForSelector（函数符号制造器）和forwardInvocation（函数执行器）灵活的将目标函数以其他形式执行。

如果都不中，调用doesNotRecognizeSelector抛出异常。

五、HTTP协议：
参考：https://www.cnblogs.com/ranyonsue/p/5984001.html
HTTP：超文本传输协议
一个http请求，包括请求、响应。
HTTP请求之URL

例如：http://www.aspxfans.com:8080/news/index.asp?boardID=5&ID=24618&page=1#name
一个完整的URL包括：
1.协议部分：该URL的协议部分为："http:",这代表网页使用的是HTTP协议。在Internet中可以使用多种协议，如HTTP，FTP等等本例中使用的是HTTP协议。在"HTTP"后面的“//”为分隔符
2.域名部分：该URL的域名部分为“www.aspxfans.com”。一个URL中，也可以使用IP地址作为域名使用。
3.端口部分：跟在域名后面的是端口，域名和端口之间使用“:”作为分隔符。端口不是一个URL必须的部分，如果省略端口部分，将采用默认端口
4.虚拟目录部分：从域名后的第一个“/”开始到最后一个“/”为止，是虚拟目录部分。虚拟目录也不是一个URL必须的部分。本例中的虚拟目录是“/news/”
5.文件名部分：从域名后的最后一个“/”开始到“？”为止，是文件名部分，如果没有“?”,则是从域名后的最后一个“/”开始到“#”为止，是文件部分，如果没有“？”和“#”，那么从域名后的最后一个“/”开始到结束，都是文件名部分。本例中的文件名是“index.asp”。文件名部分也不是一个URL必须的部分，如果省略该部分，则使用默认的文件名
6.锚部分：从“#”开始到最后，都是锚部分。本例中的锚部分是“name”。锚部分也不是一个URL必须的部分
7.参数部分：从“？”开始到“#”为止之间的部分为参数部分，又称搜索部分、查询部分。本例中的参数部分为“boardID=5&ID=24618&page=1”。参数可以允许有多个参数，参数与参数之间用“&”作为分隔符。

HTTP请求之消息Request
客户端发送一个请求消息包括以下格式：

请求行，请求头，空行，请求数据

QQ20180328-0.png

Http请求消息结构.png
请求行以一个方法符号开头，以空格分开，后面跟着请求的URI和协议的版本。
Get请求例子，使用Charles抓取的request：

GET /562f25980001b1b106000338.jpg HTTP/1.1
Host    img.mukewang.com
User-Agent    Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.106 Safari/537.36
Accept    image/webp,image/*,*/*;q=0.8
Referer    http://www.imooc.com/
Accept-Encoding    gzip, deflate, such
Accept-Language    zh-CN,zh;q=0.8
第一部分：请求行，用来说明请求类型,要访问的资源以及所使用的HTTP版本.

GET说明请求类型为GET,[/562f25980001b1b106000338.jpg]为要访问的资源，该行的最后一部分说明使用的是HTTP1.1版本。

第二部分：请求头部，紧接着请求行（即第一行）之后的部分，用来说明服务器要使用的附加信息

从第二行起为请求头部，HOST将指出请求的目的地.User-Agent,服务器端和客户端脚本都能访问它,它是浏览器类型检测逻辑的重要基础.该信息由你的浏览器来定义,并且在每个请求中自动发送等等

第三部分：空行，请求头部后面的空行是必须的

即使第四部分的请求数据为空，也必须有空行。

第四部分：请求数据也叫主体，可以添加任意的其他数据。

这个例子的请求数据为空。

POST请求例子，使用Charles抓取的request：

POST / HTTP1.1
Host:www.wrox.com
User-Agent:Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022)
Content-Type:application/x-www-form-urlencoded
Content-Length:40
Connection: Keep-Alive

name=Professional%20Ajax&publisher=Wiley
第一部分：请求行，第一行明了是post请求，以及http1.1版本。
第二部分：请求头部，第二行至第六行。
第三部分：空行，第七行的空行。
第四部分：请求数据，第八行。

HTTP之响应消息Response

HTTP响应也由四个部分组成，分别是：状态行、消息报头、空行和响应正文。

111.png

例子

HTTP/1.1 200 OK
Date: Fri, 22 May 2009 06:07:21 GMT
Content-Type: text/html; charset=UTF-8

<html>
      <head></head>
      <body>
            <!--body goes here-->
      </body>
</html>
第一部分：状态行，由HTTP协议版本号， 状态码， 状态消息 三部分组成。

第一行为状态行，（HTTP/1.1）表明HTTP版本为1.1版本，状态码为200，状态消息为（ok）

第二部分：消息报头，用来说明客户端要使用的一些附加信息

第二行和第三行为消息报头，
Date:生成响应的日期和时间；Content-Type:指定了MIME类型的HTML(text/html),编码类型是UTF-8

第三部分：空行，消息报头后面的空行是必须的

第四部分：响应正文，服务器返回给客户端的文本信息。

空行后面的html部分为响应正文。

HTTP之状态码
状态代码有三位数字组成，第一个数字定义了响应的类别，共分五种类别:

1xx：指示信息--表示请求已接收，继续处理

2xx：成功--表示请求已被成功接收、理解、接受

3xx：重定向--要完成请求必须进行更进一步的操作

4xx：客户端错误--请求有语法错误或请求无法实现

5xx：服务器端错误--服务器未能实现合法的请求

常见状态码：

200 OK                        //客户端请求成功
400 Bad Request               //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized              //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用 
403 Forbidden                 //服务器收到请求，但是拒绝提供服务
404 Not Found                 //请求资源不存在，eg：输入了错误的URL
500 Internal Server Error     //服务器发生不可预期的错误
503 Server Unavailable        //服务器当前不能处理客户端的请求，一段时间后可能恢复正常
更多状态码http://www.runoob.com/http/http-status-codes.html

TCP三次握手
参考：https://www.jianshu.com/p/ef892323e68f
所谓三次握手（Three-Way Handshake）即建立TCP连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送3个包以确认连接的建立。在socket编程中，这一过程由客户端执行connect来触发，整个流程如下图所示：

］、

（1）第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。

（2）第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。

（3）第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。

简单来说，就是

1、建立连接时，客户端发送SYN包（SYN=i）到服务器，并进入到SYN-SEND状态，等待服务器确认

2、服务器收到SYN包，必须确认客户的SYN（ack=i+1）,同时自己也发送一个SYN包（SYN=k）,即SYN+ACK包，此时服务器进入SYN-RECV状态

3、客户端收到服务器的SYN+ACK包，向服务器发送确认报ACK（ack=k+1）,此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手，客户端与服务器开始传送数据。

SYN攻击：

在三次握手过程中，Server发送SYN-ACK之后，收到Client的ACK之前的TCP连接称为半连接（half-open connect），此时Server处于SYN_RCVD状态，当收到ACK后，Server转入ESTABLISHED状态。SYN攻击就是Client在短时间内伪造大量不存在的IP地址，并向Server不断地发送SYN包，Server回复确认包，并等待Client的确认，由于源地址是不存在的，因此，Server需要不断重发直至超时，这些伪造的SYN包将产时间占用未连接队列，导致正常的SYN请求因为队列满而被丢弃，从而引起网络堵塞甚至系统瘫痪。SYN攻击时一种典型的DDOS攻击，检测SYN攻击的方式非常简单，即当Server上有大量半连接状态且源IP地址是随机的，则可以断定遭到SYN攻击了，使用如下命令可以让之现行：

#netstat -nap | grep SYN_RECV

TCP跟UDP的区别？

TCP （传输控制协议）
建立连接，形成传输通道
通过三次握手完成连接，
必须建立连接，效率较为低下
UDP（用户数据报协议）
将数据源和目的地封装成数据包中，
每个数据报的大小是有限制，在64k之内
因为不需要建立连接，所以是不可靠的
不需要建立连接，速度快。

举例：老师讲课，共享屏幕都学生的电脑上，老师电脑的屏幕就是数据源，学生电脑的ip就是目的地，封装成数据包后，直接扔到学生电脑上，但因为是不需要建立连接的，所以根本不知道学生是否有接收到数据，所以就会出现有时学生屏幕卡顿的情况。

TCP跟HTTP的区别
TCP:传输协议（决定用什么方式进行交互）
HTTP:协议(决定数据的格式） 例如请求头有规定"content-type"为son或者xml，编码格式为url或者utf8等
举例：从广州到北京 可以坐飞机 高铁 火车（指的是传输协议TCP）
到了北京后，进行交流用英语或者国语（指的是HTTP）

六、Socket、HTTP、TCP联系与区别
TCP连接：

手机能够使用联网功能是因为手机底层实现了TCP/IP协议，可以使手机终端通过无线网络建立TCP连接。TCP协议可以对上层网络提供接口，使上层网络数据的传输建立在“无差别”的网络之上。
建立起一个TCP连接需要经过“三次握手”：
第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

HTTP连接：

HTTP协议即超文本传送协议(HypertextTransfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，HTTP协议是建立在TCP协议之上的一种应用。
HTTP连接最显著的特点是客户端发送的每次请求都需要服务器回送响应，在请求结束后，会主动释放连接。从建立连接到关闭连接的过程称为“一次连接”。
1）在HTTP 1.0中，客户端的每次请求都要求建立一次单独的连接，在处理完本次请求后，就自动释放连接。
2）在HTTP 1.1中则可以在一次连接中处理多个请求，并且多个请求可以重叠进行，不需要等待一个请求结束后再发送下一个请求。

Socket（套接字）:

Socket是对TCP/IP协议的封装，Socket本身并不是协议，而是一个调用接口（API），通过Socket，我们才能使用TCP/IP协议。

建立socket连接：

建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket，另一个运行于服务器端，称为ServerSocket。
套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。
服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。
客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。
连 接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户 端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

区别：
这三者在TCP/IP协议族中的位置关系：

image

HTTP是应用层的协议，更靠近用户端；
TCP是传输层的协议；
而socket是从传输层上抽象出来的一个抽象层，本质是接口。

1、TCP连接与HTTP连接的区别
HTTP是基于TCP的，客户端往服务器发送一个HTTP请求时
七、修改127.0.0.1访问localhost
命令：cat /etc/hosts －－－－查看hosts文件的内容
修改hosts文件的内容：

sudo vi /etc/hosts
输入i
输入127.0.0.1 www.xjl.com
按esc 按: 然后输入wq －－－－保存并且退出

判断服务器是否开启的命令：

telnet 127.0.0.1 80