大纲

• 一.Socket简介
• 二.BSD Socket编程准备
  • 1.地址
  • 2.端口
  • 3.网络字节序
  • 4.半相关与全相关
  • 5.网络编程模型
• 三.socket接口编程示例
• 四.使用select
• 五.使用kqueue
• 六.使用流

注:文档中设计涉及的代码也都在本人github目录下，分别为socketServer和socketClient.对应着各个分支。

一.Socket简介

在UNIX系统中,万物皆文件(Everything is a file)。所有的IO操作都可以看作对文件的IO操作，都遵循着这样的操作模式:打开 -> 读/写 -> 关闭，打开操作（如open函数）获取“文件”使用权，返回文件描述符，后继的操作都通过这个文件描述符来进行。很多系统调用都依赖于文件描述符,它是一个无符号整数，每一个用户进程都对应着一个文件描述符表，通过文件描述符就可以找到对应文件的信息。
在类UNIX平台上，对于控制台的标准输入输出以及标准错误输出都有对应的文件描述符，分别为0,1,2。它们定义在

中

1
2
3
#define  STDIN_FILENO   0   /* standard input file descriptor */

#define STDOUT_FILENO   1   /* standard output file descriptor */

#define STDERR_FILENO   2   /* standard error file descriptor */

在Mac系统中，可以通过Activity Monitor来查看某个进程打开的文件和端口。

UNIX内核加入TCP/IP协议的时候，便在系统中引入了一种新的IO操作，只不过由于网络连接的不可靠性，所以网络IO比本地设备的IO复杂很多。这一系列的接口叫做BSD Socket API,当初由伯克利大学研发，最终成为网络开发接口的标准。
网络通信从本质上讲也是进程间通信，只是这两个进程一般在网络中不同计算机上。当然Socket API其实也提供了专门用于本地IPC的使用方式：UNIX Domain Socket，这个这里就不细说了。本文所讲的Socket如无例外，均是说的Internet Socket。

在本地的进程中，每一个进程都可以通过PID来标识，对于网络上的一个计算机中的进程如何标识呢？网络中的计算机可以通过一个IP地址进行标识，一个计算机中的某个进程则可以通过一个无符号整数（端口号）来标识，所以一个网络中的进程可以通过

的方式进行标识。

二.BSD Socket编程准备

在程序中，我们如何保存一个地址呢？在

中的sockaddr便是描述socket地址的结构体类型.

1
2
3
4
5
6
7
8
/*

* [XSI] Structure used by kernel to store most addresses.

*/

struct sockaddr {

    __uint8_t   sa_len;     /* total length */

    sa_family_t sa_family;  /* [XSI] address family */

    char        sa_data[14];    /* [XSI] addr value (actually larger) */

};

为了方便设置用语网络通信的socket地址，引入了sockaddr_in结构体（对于UNIX Domain Socket则对应sockaddr_un）

1
2
3
4
5
6
7
8
9
10
/*

 * Socket address, internet style.

 */

struct sockaddr_in {

    __uint8_t   sin_len;

    sa_family_t sin_family;

    in_port_t   sin_port;//得是网络字节序

    struct  in_addr sin_addr;//in_addr存在的原因则是历史原因，其实质是代表一个IP地址的32位整数

    char        sin_zero[8];//bzero之，纯粹是为了兼容sockaddr

};

在实际编程的时候，经常需要将sockaddr_in强制转换成sockaddr类型。

说到端口我们经常会联想到硬件，在网络编程中的端口其实是一个标识而已，或者说是系统的资源而已。系统提供了端口分配和管理的机制。

谈网络字节序(Endianness)之前我们先说说什么是字节序。字节序又叫端序，就是指计算机中存放 多字节数据的字节的顺序。典型的就是数据存放在内存中或者网络传输时的字节的顺序。常用的字节序有大端序(big-endian)，小端序(litle-endian,另还有不常见的混合序middle-endian)。不同的CPU可能会使用不同的字节序，如X86，PDP-11等处理器为小端序，Motorola 6800,PowerPC 970等使用的是大端序。小端序是指低字节位存放在内存地址的低端，高端序是指高位字节存放在内存的低端。
举个例子来说明什么是大端序和小端序：
比如一个4字节的整数 16进制形式为 0×12345678，最左边是高位。

大端序

小端序

TCP/IP 各层协议将字节序使用的是大端序，我们把TCP/IP协议中使用的字节序称之为网络字节序。
编程的时候可以使用定义在

中的相关的接口进行本地字节序和网络字节序的互转。

1
2
3
4
5
#define ntohs(x)    __DARWIN_OSSwapInt16(x) // 16位整数 网络字节序转主机字节序

#define htons(x)    __DARWIN_OSSwapInt16(x) // 16位整数 主机字节序转网络字节序



#define ntohl(x)    __DARWIN_OSSwapInt32(x)  //32位整数 网络字节序转主机字节序

#define htonl(x)    __DARWIN_OSSwapInt32(x) //32位整数 主机字节序转网络字节序

以上声明中 n代表netwrok， h代表host ，s代表short，l代表long

如果数据是单字节的话，则其没有字节序的说法了。

半相关（half-association）是指一个三元组

,通过这个三元组就可以唯一标识一个网络中的进程,一般用于listening socket。但是实际进行通信的过程，至少需要两个进程，且它们所使用的协议必须一致，所以一个完成的网络通信至少需要一个五元组表示

，这样的五元组叫做全相关。

网络存在的本质其实就是网络中个体之间的在某个领域的信息存在不对等性，所以一般情况下总有一些个体为另一些个体提供服务。提供服务器的我们把它叫做服务器，接受服务的叫做客户端。所以在网络编程中，也存在服务器端和客户端之分。

三.BSD Socket编程详解

下面的例子是一个简单的一对一聊天的程序，分服务器和客户端，且发送消息和接受消息次序固定。

Server端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <stdio.h>

#include <netinet/in.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <string.h>



int main (int argc, const char * argv[])

{

    struct sockaddr_in server_addr;

    server_addr.sin_len = sizeof(struct sockaddr_in);

    server_addr.sin_family = AF_INET;//Address families AF_INET互联网地址簇

    server_addr.sin_port = htons(11332);

    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    bzero(&(server_addr.sin_zero),8);



    //创建socket

    int server_socket = socket(AF_INET, SOCK_STREAM, 0);//SOCK_STREAM 有连接

    if (server_socket == -1) {

        perror("socket error");

        return 1;

    }



    //绑定socket：将创建的socket绑定到本地的IP地址和端口，此socket是半相关的，只是负责侦听客户端的连接请求，并不能用于和客户端通信

    int bind_result = bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr));

    if (bind_result == -1) {

        perror("bind error");

        return 1;

    }



    //listen侦听 第一个参数是套接字，第二个参数为等待接受的连接的队列的大小，在connect请求过来的时候,完成三次握手后先将连接放到这个队列中，直到被accept处理。如果这个队列满了，且有新的连接的时候，对方可能会收到出错信息。

    if (listen(server_socket, 5) == -1) {

        perror("listen error");

        return 1;

    }



    struct sockaddr_in client_address;

    socklen_t address_len;

    int client_socket = accept(server_socket, (struct sockaddr *)&client_address, &address_len);

    //返回的client_socket为一个全相关的socket，其中包含client的地址和端口信息，通过client_socket可以和客户端进行通信。

    if (client_socket == -1) {

        perror("accept error");

        return -1;

    }



    char recv_msg[1024];

    char reply_msg[1024];



    while (1) {

        bzero(recv_msg, 1024);

        bzero(reply_msg, 1024);



        printf("reply:");

        scanf("%s",reply_msg);

        send(client_socket, reply_msg, 1024, 0);



        long byte_num = recv(client_socket,recv_msg,1024,0);

        recv_msg[byte_num] = '\0';

        printf("client said:%s\n",recv_msg);



    }



    return 0;

}

Client端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <stdio.h>

#include <netinet/in.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <string.h>



int main (int argc, const char * argv[])

{

    struct sockaddr_in server_addr;

    server_addr.sin_len = sizeof(struct sockaddr_in);

    server_addr.sin_family = AF_INET;

    server_addr.sin_port = htons(11332);

    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    bzero(&(server_addr.sin_zero),8);



    int server_socket = socket(AF_INET, SOCK_STREAM, 0);

    if (server_socket == -1) {

        perror("socket error");

        return 1;

    }

    char recv_msg[1024];

    char reply_msg[1024];



    if (connect(server_socket, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in))==0)     {

    //connect 成功之后，其实系统将你创建的socket绑定到一个系统分配的端口上，且其为全相关，包含服务器端的信息，可以用来和服务器端进行通信。

        while (1) {

            bzero(recv_msg, 1024);

            bzero(reply_msg, 1024);

            long byte_num = recv(server_socket,recv_msg,1024,0);

            recv_msg[byte_num] = '\0';

            printf("server said:%s\n",recv_msg);



            printf("reply:");

            scanf("%s",reply_msg);

            if (send(server_socket, reply_msg, 1024, 0) == -1) {

                perror("send error");

            }

        }



    }



    // insert code here...

    printf("Hello, World!\n");

    return 0;

}

上面的服务器端和客户端连接成功之后打开的端口的情况是怎么样的呢？

• 服务器端 ,存在一个用于listen的半相关的socket，一个用于和客户端进行通信的全相关的socket
  

• 客户端 存在一个用于和服务器端进行通信的全相关的socket
  

由于accept只运行了一次，所以服务器端一次只能和一个客户端进行通信，且使用的send和recv方法都是阻塞的，所以上面这个例子存在一个问题就是服务器端客户端连接成功之后，发送，接受，发送，接受的次序就被固定了。比如服务器端发送消息之后就等客户端发送消息了，没有接受到客户端的消息之前服务器端是没有办法发送消息的。使用select这个这个系统调用可以解决上面的问题。

四.使用select

select这个系统调用，是一种多路复用IO方案，可以同时对多个文件描述符进行监控，从而知道哪些文件描述符可读，可写或者出错，不过select方法是阻塞的，可以设定超时时间。
select使用的步骤如下:

• 1.创建一个fd_set变量（fd_set实为包含了一个整数数组的结构体），用来存放所有的待检查的文件描述符
• 2.清空fd_set变量，并将需要检查的所有文件描述符加入fd_set
• 3.调用select。若返回-1，则说明出错;返回0,则说明超时，返回正数，则为发生状态变化的文件描述符的个数
• 4.若select返回大于0,则依次查看哪些文件描述符变的可读，并对它们进行处理
• 5.返回步骤2，开始新一轮的检测

若上面的聊天程序使用select进行改写，则是下面这样的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
    #include <stdio.h>

    #include <stdlib.h>

    #include <netinet/in.h>

    #include <sys/socket.h>

    #include <arpa/inet.h>

    #include <string.h>

    #include <unistd.h>

    #define BACKLOG 5 //完成三次握手但没有accept的队列的长度

    #define CONCURRENT_MAX 8 //应用层同时可以处理的连接

    #define SERVER_PORT 11332

    #define BUFFER_SIZE 1024

    #define QUIT_CMD ".quit"

    int client_fds[CONCURRENT_MAX];

    int main (int argc, const char * argv[])

    {

        char input_msg[BUFFER_SIZE];

        char recv_msg[BUFFER_SIZE];   

        //本地地址

        struct sockaddr_in server_addr;

        server_addr.sin_len = sizeof(struct sockaddr_in);

        server_addr.sin_family = AF_INET;

        server_addr.sin_port = htons(SERVER_PORT);

        server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

        bzero(&(server_addr.sin_zero),8);

        //创建socket

        int server_sock_fd = socket(AF_INET, SOCK_STREAM, 0);

        if (server_sock_fd == -1) {

            perror("socket error");

            return 1;

        }

        //绑定socket

        int bind_result = bind(server_sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));

        if (bind_result == -1) {

            perror("bind error");

            return 1;

        }

        //listen

        if (listen(server_sock_fd, BACKLOG) == -1) {

            perror("listen error");

            return 1;

        }

        //fd_set

        fd_set server_fd_set;

        int max_fd = -1;

        struct timeval tv;

        tv.tv_sec = 20;

        tv.tv_usec = 0;

        while (1) {

            FD_ZERO(&server_fd_set);

            //标准输入

            FD_SET(STDIN_FILENO, &server_fd_set);

            if (max_fd < STDIN_FILENO) {

                max_fd = STDIN_FILENO;

            }

            //服务器端socket

            FD_SET(server_sock_fd, &server_fd_set);

            if (max_fd < server_sock_fd) {

                max_fd = server_sock_fd;

            }

            //客户端连接

            for (int i = 0; i < CONCURRENT_MAX; i++) {

                if (client_fds[i]!=0) {

                    FD_SET(client_fds[i], &server_fd_set);



                    if (max_fd < client_fds[i]) {

                        max_fd = client_fds[i];

                    }

                }

            }

            int ret = select(max_fd+1, &server_fd_set, NULL, NULL, &tv);

            if (ret < 0) {

                perror("select 出错\n");

                continue;

            }else if(ret == 0){

                printf("select 超时\n");

                continue;

            }else{

                //ret为未状态发生变化的文件描述符的个数

                if (FD_ISSET(STDIN_FILENO, &server_fd_set)) {

                    //标准输入

                    bzero(input_msg, BUFFER_SIZE);

                    fgets(input_msg, BUFFER_SIZE, stdin);

                    //输入 ".quit" 则退出服务器

                    if (strcmp(input_msg, QUIT_CMD) == 0) {

                        exit(0);

                    }

                    for (int i=0; i<CONCURRENT_MAX; i++) {

                        if (client_fds[i]!=0) {

                            send(client_fds[i], input_msg, BUFFER_SIZE, 0);

                        }

                    }

                }

                if (FD_ISSET(server_sock_fd, &server_fd_set)) {

                    //有新的连接请求

                    struct sockaddr_in client_address;

                    socklen_t address_len;

                    int client_socket_fd = accept(server_sock_fd, (struct sockaddr *)&client_address, &address_len);

                    if (client_socket_fd > 0) {

                        int index = -1;

                        for (int i = 0; i < CONCURRENT_MAX; i++) {

                            if (client_fds[i] == 0) {

                                index = i;

                                client_fds[i] = client_socket_fd;

                                break;

                            }

                        }

                        if (index >= 0) {

                            printf("新客户端(%d)加入成功 %s:%d \n",index,inet_ntoa(client_address.sin_addr),ntohs(client_address.sin_port));

                        }else{

                            bzero(input_msg, BUFFER_SIZE);

                            strcpy(input_msg, "服务器加入的客户端数达到最大值,无法加入!\n");

                            send(client_socket_fd, input_msg, BUFFER_SIZE, 0);

                            printf("客户端连接数达到最大值，新客户端加入失败 %s:%d \n",inet_ntoa(client_address.sin_addr),ntohs(client_address.sin_port));

                        }

                    }

                }

                for (int i = 0; i <CONCURRENT_MAX; i++) {

                    if (client_fds[i]!=0) {

                        if (FD_ISSET(client_fds[i], &server_fd_set)) {

                            //处理某个客户端过来的消息

                            bzero(recv_msg, BUFFER_SIZE);

                            long byte_num = recv(client_fds[i],recv_msg,BUFFER_SIZE,0);

                            if (byte_num > 0) {

                                if (byte_num > BUFFER_SIZE) {

                                    byte_num = BUFFER_SIZE;

                                }

                                recv_msg[byte_num] = '\0';

                                printf("客户端(%d):%s\n",i,recv_msg);

                            }else if(byte_num < 0){

                                printf("从客户端(%d)接受消息出错.\n",i);

                            }else{

                                FD_CLR(client_fds[i], &server_fd_set);

                                client_fds[i] = 0;

                                printf("客户端(%d)退出了\n",i);

                            }

                        }

                    }

                }

            }

        }

        return 0;

    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
    #include <stdio.h>

    #include <netinet/in.h>

    #include <sys/socket.h>

    #include <arpa/inet.h>

    #include <string.h>

    #include <unistd.h>

    #include <stdlib.h>



    #define BUFFER_SIZE 1024



    int main (int argc, const char * argv[])

    {

        struct sockaddr_in server_addr;

        server_addr.sin_len = sizeof(struct sockaddr_in);

        server_addr.sin_family = AF_INET;

        server_addr.sin_port = htons(11332);

        server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

        bzero(&(server_addr.sin_zero),8);



        int server_sock_fd = socket(AF_INET, SOCK_STREAM, 0);

        if (server_sock_fd == -1) {

            perror("socket error");

            return 1;

        }

        char recv_msg[BUFFER_SIZE];

        char input_msg[BUFFER_SIZE];



        if (connect(server_sock_fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in))==0) {

            fd_set client_fd_set;

            struct timeval tv;

            tv.tv_sec = 20;

            tv.tv_usec = 0;





            while (1) {

                FD_ZERO(&client_fd_set);

                FD_SET(STDIN_FILENO, &client_fd_set);

                FD_SET(server_sock_fd, &client_fd_set);



                int ret = select(server_sock_fd + 1, &client_fd_set, NULL, NULL, &tv);

                if (ret < 0 ) {

                    printf("select 出错!\n");

                    continue;

                }else if(ret ==0){

                    printf("select 超时!\n");

                    continue;

                }else{

                    if (FD_ISSET(STDIN_FILENO, &client_fd_set)) {

                        bzero(input_msg, BUFFER_SIZE);

                        fgets(input_msg, BUFFER_SIZE, stdin);

                        if (send(server_sock_fd, input_msg, BUFFER_SIZE, 0) == -1) {

                            perror("发送消息出错!\n");

                        }

                    }



                    if (FD_ISSET(server_sock_fd, &client_fd_set)) {

                        bzero(recv_msg, BUFFER_SIZE);

                        long byte_num = recv(server_sock_fd,recv_msg,BUFFER_SIZE,0);

                        if (byte_num > 0) {

                            if (byte_num > BUFFER_SIZE) {

                                byte_num = BUFFER_SIZE;

                            }

                            recv_msg[byte_num] = '\0';

                            printf("服务器:%s\n",recv_msg);

                        }else if(byte_num < 0){

                            printf("接受消息出错!\n");

                        }else{

                            printf("服务器端退出!\n");

                            exit(0);

                        }



                    }

                }

            }



        }



        return 0;

    }

当然select也有其局限性。当fd_set中的文件描述符较少，或者大都数文件描述符都比较活跃的时候，select的效率还是不错的。Mac系统中已经定义了fd_set 最大可以容纳的文件描述符的个数为1024

1
2
3
4
5
//sys/_structs.h

#define __DARWIN_FD_SETSIZE 1024

/////////////////////////////////////////////

//Kernel.framework sys/select.h

#define FD_SETSIZE  __DARWIN_FD_SETSIZE

每一次select 调用的时候，都涉及到user space和kernel space的内存拷贝，且会对fd_set中的所有文件描述符进行遍历，如果所有的文件描述符均不满足，且没有超时，则当前进程便开始睡眠，直到超时或者有文件描述符状态发生变化。当文件描述符数量较大的时候，将耗费大量的CPU时间。所以后来有新的方案出现了，如windows2000引入的IOCP，Linux Kernel 2.6中成熟的epoll，FreeBSD4.x引入的kqueue。

五.使用kqueue

Mac是基于BSD的内核，所使用的是kqueue（kernel event notification mechanism，详细内容可以Mac中

），kqueue比select先进的地方就在于使用事件触发的机制，且其调用无需每次对所有的文件描述符进行遍历，返回的时候只返回需要处理的事件，而不像select中需要自己去一个个通过FD_ISSET检查。
kqueue默认的触发方式是level 水平触发，可以通过设置event的flag为

使得这个事件变为边沿触发,可能epoll的触发方式无法细化到单个event，需要查证。

kqueue中涉及两个系统调用，kqueue()和kevent()

• kqueue() 创建kernel级别的事件队列，并返回队列的文件描述符
• kevent() 往事件队列中加入订阅事件，或者返回相关的事件数组

kqueue使用的流程一般如下：

• 创建kqueue
• 创建struct kevent变量（注意这里的kevent是结构体类型名），可以通过EV_SET这个宏提供的快捷方式进行创建
• 通过kevent系统调用将创建好的kevent结构体变量加入到kqueue队列中，完成对指定文件描述符的事件的订阅

• 通过kevent系统调用获取满足条件的事件队列，并对每一个事件进行处理

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122
  123
  124
  125
  126
  127
  128
  129
  130
  131
  132
  133
  134
  135
  136
  137
  138
  #include <stdio.h>
  
  #include <stdlib.h>
  
  #include <netinet/in.h>
  
  #include <sys/socket.h>
  
  #include <sys/event.h>
  
  #include <sys/types.h>
  
  #include <sys/time.h>
  
  #include <arpa/inet.h>
  
  #include <string.h>
  
  #include <unistd.h>
  
  #define BACKLOG 5 //完成三次握手但没有accept的队列的长度
  
  #define CONCURRENT_MAX 8 //应用层同时可以处理的连接
  
  #define SERVER_PORT 11332
  
  #define BUFFER_SIZE 1024
  
  #define QUIT_CMD ".quit"
  
  int client_fds[CONCURRENT_MAX];
  
  struct kevent events[10];//CONCURRENT_MAX + 2
  
  int main (int argc, const char * argv[])
  
  {
  
      char input_msg[BUFFER_SIZE];
  
      char recv_msg[BUFFER_SIZE];
  
      //本地地址
  
      struct sockaddr_in server_addr;
  
      server_addr.sin_len = sizeof(struct sockaddr_in);
  
      server_addr.sin_family = AF_INET;
  
      server_addr.sin_port = htons(SERVER_PORT);
  
      server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  
      bzero(&(server_addr.sin_zero),8);
  
      //创建socket
  
      int server_sock_fd = socket(AF_INET, SOCK_STREAM, 0);
  
      if (server_sock_fd == -1) {
  
          perror("socket error");
  
          return 1;
  
      }
  
      //绑定socket
  
      int bind_result = bind(server_sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
  
      if (bind_result == -1) {
  
          perror("bind error");
  
          return 1;
  
      }
  
      //listen
  
      if (listen(server_sock_fd, BACKLOG) == -1) {
  
          perror("listen error");
  
          return 1;
  
      }
  
      struct timespec timeout = {10,0};
  
      //kqueue
  
      int kq = kqueue();
  
      if (kq == -1) {
  
          perror("创建kqueue出错!\n");
  
          exit(1);
  
      }
  
      struct kevent event_change;
  
      EV_SET(&event_change, STDIN_FILENO, EVFILT_READ, EV_ADD, 0, 0, NULL);
  
      kevent(kq, &event_change, 1, NULL, 0, NULL);
  
      EV_SET(&event_change, server_sock_fd, EVFILT_READ, EV_ADD, 0, 0, NULL);
  
      kevent(kq, &event_change, 1, NULL, 0, NULL);
  
      while (1) {
  
          int ret = kevent(kq, NULL, 0, events, 10, &timeout);
  
          if (ret < 0) {
  
              printf("kevent 出错!\n");
  
              continue;
  
          }else if(ret == 0){
  
              printf("kenvent 超时!\n");
  
              continue;
  
          }else{
  
              //ret > 0 返回事件放在events中
  
              for (int i = 0; i < ret; i++) {
  
                  struct kevent current_event = events[i];
  
                  //kevent中的ident就是文件描述符
  
                  if (current_event.ident == STDIN_FILENO) {
  
                      //标准输入
  
                      bzero(input_msg, BUFFER_SIZE);
  
                      fgets(input_msg, BUFFER_SIZE, stdin);
  
                      //输入 ".quit" 则退出服务器
  
                      if (strcmp(input_msg, QUIT_CMD) == 0) {
  
                          exit(0);
  
                      }
  
                      for (int i=0; i<CONCURRENT_MAX; i++) {
  
                          if (client_fds[i]!=0) {
  
                              send(client_fds[i], input_msg, BUFFER_SIZE, 0);
  
                          }
  
                      }
  
                  }else if(current_event.ident == server_sock_fd){
  
                      //有新的连接请求
  
                      struct sockaddr_in client_address;
  
                      socklen_t address_len;
  
                      int client_socket_fd = accept(server_sock_fd, (struct sockaddr *)&client_address, &address_len);
  
                      if (client_socket_fd > 0) {
  
                          int index = -1;
  
                          for (int i = 0; i < CONCURRENT_MAX; i++) {
  
                              if (client_fds[i] == 0) {
  
                                  index = i;
  
                                  client_fds[i] = client_socket_fd;
  
                                  break;
  
                              }
  
                          }
  
                          if (index >= 0) {
  
                              EV_SET(&event_change, client_socket_fd, EVFILT_READ, EV_ADD, 0, 0, NULL);
  
                              kevent(kq, &event_change, 1, NULL, 0, NULL);
  
                              printf("新客户端(fd = %d)加入成功 %s:%d \n",client_socket_fd,inet_ntoa(client_address.sin_addr),ntohs(client_address.sin_port));
  
                          }else{
  
                              bzero(input_msg, BUFFER_SIZE);
  
                              strcpy(input_msg, "服务器加入的客户端数达到最大值,无法加入!\n");
  
                              send(client_socket_fd, input_msg, BUFFER_SIZE, 0);
  
                              printf("客户端连接数达到最大值，新客户端加入失败 %s:%d \n",inet_ntoa(client_address.sin_addr),ntohs(client_address.sin_port));
  
                          }
  
                      }
  
                  }else{
  
                      //处理某个客户端过来的消息
  
                      bzero(recv_msg, BUFFER_SIZE);
  
                      long byte_num = recv((int)current_event.ident,recv_msg,BUFFER_SIZE,0);
  
                      if (byte_num > 0) {
  
                          if (byte_num > BUFFER_SIZE) {
  
                              byte_num = BUFFER_SIZE;
  
                          }
  
                          recv_msg[byte_num] = '\0';
  
                          printf("客户端(fd = %d):%s\n",(int)current_event.ident,recv_msg);
  
                      }else if(byte_num < 0){
  
                          printf("从客户端(fd = %d)接受消息出错.\n",(int)current_event.ident);
  
                      }else{
  
                          EV_SET(&event_change, current_event.ident, EVFILT_READ, EV_DELETE, 0, 0, NULL);
  
                          kevent(kq, &event_change, 1, NULL, 0, NULL);
  
                          close((int)current_event.ident);
  
                          for (int i = 0; i < CONCURRENT_MAX; i++) {
  
                              if (client_fds[i] == (int)current_event.ident) {
  
                                  client_fds[i] = 0;
  
                                  break;
  
                              }
  
                          }
  
                          printf("客户端(fd = %d)退出了\n",(int)current_event.ident);
  
                      }
  
                  }
  
              }
  
          }
  
      }
  
      return 0;
  
  }
  

其实kqueue的应用场景非常的广阔，可以监控文件系统中文件的变化（对文件变化的事件可以粒度非常的细，具体可以查看kqueue的手册），监控系统进程的生命周期。GCD的事件处理便是建立在kqueue之上的。

六.使用Streams

使用Objective-C的一大优点便是面向对象编程，使得逻辑抽象得更加优美，更加符合人类思维。
一开始说过，无论是对于文件的操作或者对于网络的操作，本质上都是IO操作，无非写数据和读数据，可以对这种输入输出进行抽象，抽象成输入流和输出流， 从输入流中读取数据，往输出流中写数据。
Cocoa中的NSInputStream和NSOutputStream便是输入流和输出流的抽象，它们的实现分别基于CoreFoundation中的CFReadStream和CFWriteStream。
输入输出流对runloop有很好的支持。
NSInputStream和CFReadStream以及NSOutputStream和CFWriteStream之间可以通过 “toll-free bridging”实现无缝的类型转换。
CoreFoundation中的CFStream提供了输入输出流和CFSocket绑定的函数。
这样便可以通过输入输出流和远端进行通信了。

首先通过XCode创建一个Foundation(C的也行，但是你得将

改成

)的命令行项目.
创建一个ChatServer的类，包含一个run的方法。在Cocoa的程序中有一点是和C语言不同的，你无需自己去写一个死循环充当runloop，框架本身就对runloop进行了支持，需要做的就是将事件源加入到当前线程的runloop中，然后启动runloop。
所以在run方法中，创建好用于侦听连接请求的socket，socket有对应的处理连接accept的回调函数，以及把它封装成runloop的输入源，加入到当前runloop。
我们还得从标准输入获取需要发送消息，所以使用了CFFileDescriptor，它是文件描述符的objc的封装，加入了runloop的支持，通过它可以将标准输入以输入源的方法加入到当前runloop，当标准输入缓冲区有数据可读的时候，设置好的回调函数便会被调用。
最后启动runloop。

ChatServer中的run方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
- (BOOL)run:(NSError **)error{

    BOOL successful = YES;

    CFSocketContext socketCtxt = {0, self, NULL, NULL, NULL};

    _socket = CFSocketCreate(kCFAllocatorDefault, PF_INET, SOCK_STREAM, 

                             IPPROTO_TCP, 

                             kCFSocketAcceptCallBack,

                             (CFSocketCallBack)&SocketConnectionAcceptedCallBack,

                             &socketCtxt);

    if (NULL == _socket) {

        if (nil != error) {

            *error = [[NSError alloc] 

                      initWithDomain:ServerErrorDomain

                      code:kServerNoSocketsAvailable

                      userInfo:nil];

        }

        successful = NO;

    }

    if(YES == successful) {

        // enable address reuse

        int yes = 1;

        setsockopt(CFSocketGetNative(_socket), 

                   SOL_SOCKET, SO_REUSEADDR,

                   (void *)&yes, sizeof(yes));

        uint8_t packetSize = 128;

        setsockopt(CFSocketGetNative(_socket),

                   SOL_SOCKET, SO_SNDBUF,

                   (void *)&packetSize, sizeof(packetSize));

        setsockopt(CFSocketGetNative(_socket),

                   SOL_SOCKET, SO_RCVBUF,

                   (void *)&packetSize, sizeof(packetSize));

        struct sockaddr_in addr4;

        memset(&addr4, 0, sizeof(addr4));

        addr4.sin_len = sizeof(addr4);

        addr4.sin_family = AF_INET;

        addr4.sin_port = htons(CHAT_SERVER_PORT); 

        addr4.sin_addr.s_addr = htonl(INADDR_ANY);

        NSData *address4 = [NSData dataWithBytes:&addr4 length:sizeof(addr4)];

        if (kCFSocketSuccess != CFSocketSetAddress(_socket, (CFDataRef)address4)) {

            if (error) *error = [[NSError alloc] 

                                 initWithDomain:ServerErrorDomain

                                 code:kServerCouldNotBindToIPv4Address

                                 userInfo:nil];

            if (_socket) CFRelease(_socket);

            _socket = NULL;

            successful = NO;

        } else {

            // now that the binding was successful, we get the port number 

            NSData *addr = [(NSData *)CFSocketCopyAddress(_socket) autorelease];

            memcpy(&addr4, [addr bytes], [addr length]);

            self.port = ntohs(addr4.sin_port);

            // 将socket 输入源加入到当前的runloop

            CFRunLoopRef cfrl = CFRunLoopGetCurrent();

            CFRunLoopSourceRef source4 = CFSocketCreateRunLoopSource(kCFAllocatorDefault, _socket, 0);

            CFRunLoopAddSource(cfrl, source4, kCFRunLoopDefaultMode);

            CFRelease(source4);             

            //标准输入，当在命令行中输入时，回调函数便会被调用

            CFFileDescriptorContext context = {0,self,NULL,NULL,NULL};

            CFFileDescriptorRef stdinFDRef = CFFileDescriptorCreate(kCFAllocatorDefault, STDIN_FILENO, true, FileDescriptorCallBack, &context);

            CFFileDescriptorEnableCallBacks(stdinFDRef,kCFFileDescriptorReadCallBack);

            CFRunLoopSourceRef stdinSource = CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, stdinFDRef, 0);

            CFRunLoopAddSource(cfrl, stdinSource, kCFRunLoopDefaultMode);

            CFRelease(stdinSource);

            CFRelease(stdinFDRef); 

            CFRunLoopRun();

        }

    }

    return successful;

}

当有客户端连接请求过来时， SocketConnectionAcceptedCallBack这个回调函数会被调用，根据新的全相关的socket，生成输入输出流，并设置输入输出流的delegate方法，将其添加到当前的runloop，这样流中有数据过来的时候，delegate方法会被调用。

SocketConnectionAcceptedCallBack函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
static void SocketConnectionAcceptedCallBack(CFSocketRef socket, 

                                             CFSocketCallBackType type, 

                                             CFDataRef address, 

                                             const void *data, void *info) {

    ChatServer *theChatServer = (ChatServer *)info;

    if (kCFSocketAcceptCallBack == type) { 

        // 摘自kCFSocketAcceptCallBack的文档，New connections will be automatically accepted and the callback is called with the data argument being a pointer to a CFSocketNativeHandle of the child socket. This callback is usable only with listening sockets.

        CFSocketNativeHandle nativeSocketHandle = *(CFSocketNativeHandle *)data;

        // create the read and write streams for the connection to the other process

        CFReadStreamRef readStream = NULL;

        CFWriteStreamRef writeStream = NULL;

        CFStreamCreatePairWithSocket(kCFAllocatorDefault, nativeSocketHandle,

                                     &readStream, &writeStream);

        if(NULL != readStream && NULL != writeStream) {

            CFReadStreamSetProperty(readStream, 

                                    kCFStreamPropertyShouldCloseNativeSocket,

                                    kCFBooleanTrue);

            CFWriteStreamSetProperty(writeStream, 

                                     kCFStreamPropertyShouldCloseNativeSocket,

                                     kCFBooleanTrue);

            NSInputStream *inputStream = (NSInputStream *)readStream;//toll-free bridging

            NSOutputStream *outputStream = (NSOutputStream *)writeStream;//toll-free bridging

            inputStream.delegate = theChatServer;

            [inputStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];

            [inputStream open];

            outputStream.delegate = theChatServer;

            [outputStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];

            [outputStream open];

            Client *aClient = [[Client alloc] init];

            aClient.inputStream = inputStream;

            aClient.outputStream = outputStream;

            aClient.sock_fd = nativeSocketHandle;

            [theChatServer.clients setValue:aClient  

                                     forKey:[NSString stringWithFormat:@"%d",inputStream]];

            NSLog(@"有新客户端(sock_fd=%d)加入",nativeSocketHandle);

        } else {

            close(nativeSocketHandle);

        }

        if (readStream) CFRelease(readStream);

        if (writeStream) CFRelease(writeStream);

    }

}

当客户端有数据传过来时，相应的NSInputStream的delegate方法被调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
    - (void) stream:(NSStream*)stream handleEvent:(NSStreamEvent)eventCode {

    switch (eventCode) {

        case NSStreamEventOpenCompleted: {

            break;

        }

        case NSStreamEventHasBytesAvailable: {

            Client *client = [self.clients objectForKey:[NSString stringWithFormat:@"%d",stream]];

            NSMutableData *data = [NSMutableData data];

            uint8_t *buf = calloc(128, sizeof(uint8_t));

            NSUInteger len = 0;

            while([(NSInputStream*)stream hasBytesAvailable]) {

                len = [(NSInputStream*)stream read:buf maxLength:128];

                if(len > 0) {

                    [data appendBytes:buf length:len];

                }

            }

            free(buf);

            if ([data length] == 0) {

                //客户端退出

                NSLog(@"客户端(sock_fd=%d)退出",client.sock_fd);

                [self.clients removeObjectForKey:[NSString stringWithFormat:@"%d",stream]];

                close(client.sock_fd);

            }else{

                NSLog(@"收到客户端(sock_fd=%d)消息:%@",client.sock_fd,[[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] autorelease]);

            }

            break;

        }

        case NSStreamEventHasSpaceAvailable: {

            break;

        }

        case NSStreamEventEndEncountered: {

            break;

        }

        case NSStreamEventErrorOccurred: {

            break;

        }

        default:

            break;

    }

}

当在debug窗口中输入内容并回车时，标准输入缓冲区中便有数据了，这个时候回调函数FileDescriptorCallBack将被调用，处理标准输入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static void FileDescriptorCallBack(CFFileDescriptorRef f,

                                   CFOptionFlags callBackTypes,

                                   void *info){

    int fd = CFFileDescriptorGetNativeDescriptor(f);

    ChatServer *theChatServer = (ChatServer *)info;

    if (fd == STDIN_FILENO) {

        NSData *inputData = [[NSFileHandle fileHandleWithStandardInput] availableData];

        NSString *inputString = [[[NSString alloc] initWithData:inputData encoding:NSUTF8StringEncoding] autorelease];

        NSLog(@"准备发送消息:%@",inputString);

        for (Client *client in [theChatServer.clients allValues]) {

            [client.outputStream write:[inputData bytes] maxLength:[inputData length]];

        }

        //处理完数据之后必须重新Enable 回调函数

        CFFileDescriptorEnableCallBacks(f,kCFFileDescriptorReadCallBack);

    }

}

不管是Mac OS X 还是iOS的文件系统都是建立在UNIX文件系统基础之上的。

在iOS中，一个App的读写权限只局限于自己的沙盒目录中。

沙盒模型到底有哪些好处呢?
安全：别的App无法修改你的程序或数据
保护隐私：别的App无法读取你的程序和数据
方便删除：因为一个App所有产生的内容都在自己的沙盒中，所以删除App只需要将沙盒删除就可以彻底删除程序了

iOS App沙盒中的目录

如果我们想在程序中获取上面某个目录的路径，应该如何实现呢？
下面就讲讲路径的获取，
通过

中的

函数，我们便可以获取我们想要的路径。
此函数具体声明如下:

NSArray *NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory directory, NSSearchPathDomainMask domainMask, BOOL expandTilde);
directory 目录类型 比如Documents目录 就是NSDocumentDirectory
domainMask 在iOS的程序中这个取NSUserDomainMask
expandTilde YES，表示将~展开成完整路径

注意函数返回的类型为数组，在iOS中一般这个数组中只包含一个元素，所以直接取lastObject即可。

1.2 NSFileManager

NSFileManager提供一个类方法获得一个单例。

1
2
/* Returns the default singleton instance.*/

+ (NSFileManager *)defaultManager;

下面罗列了NSFileManager的常用方法

• 新建目录

  1
  - (BOOL)createDirectoryAtPath:(NSString *)path withIntermediateDirectories:(BOOL)createIntermediates attributes:(NSDictionary *)attributes error:(NSError **)error;
  

  createIntermediates这个参数一般为YES，表示如果目录路径中间的某个目录不存在则创建之,如果是NO的话，则要保证所创建目录的父目录都必须已经存在

• 获取目录下的所有文件

  1
  - (NSArray *)contentsOfDirectoryAtPath:(NSString *)path error:(NSError **)error;
  

  如果目录为空，则返回空数组

• 其他的一些方法

  1
  2
  3
  4
  - (BOOL)copyItemAtPath:(NSString *)srcPath toPath:(NSString *)dstPath error:(NSError **)error;
  
  - (BOOL)moveItemAtPath:(NSString *)srcPath toPath:(NSString *)dstPath error:(NSError **)error;
  
  - (BOOL)linkItemAtPath:(NSString *)srcPath toPath:(NSString *)dstPath error:(NSError **)error;
  
  - (BOOL)removeItemAtPath:(NSString *)path error:(NSError **)error;
  

更多的可以查看文档 NSFileManager Class Reference。

在实际项目中，我们一般会写一个工具类来负责项目中所有的路径操作。

2. 归档（Archives） 和 序列化（Serializations）

我们经常听到“序列化”，“反序列化”这样的字眼，其实“序列化”的意思就是将对象转换成字节流以便保存或传输，“反序列化”便是一个相反的过程，从字节流转到对象。

在这节中涉及到一种文件类型plist，plist就是Property List 的缩写,即所谓的属性列表，属性列表有两种数据格式，一种是XML的，方便阅读和编辑；另一种是二进制的，节省存储空间，以及提高效率。

在Objective-C中这个对象和字节流的互转分成两类:

• 归档 普通自定义对象和字节流之间的转换
• 序列化 某些特定类型（NSDictionary, NSArray, NSString, NSDate, NSNumber，NSData）的数据和字节流之间(通常将其保存为plist文件)的转换

不过本质上讲上述两种都是对象图(Object Graph)和字节流之间的转换.
Apple关于序列化和归档的编程指南: Archives and Serializations Programming Guide 。

如果我们需要将自定义的一个对象保存到文件，应该如何做呢？
这里引入两个东西：一个是NSCoding协议 ；另一个是NSKeyedArchiver，NSKeyedArchiver其实继承于NSCoder，可以以键值对的方式将对象的属性进行序列化和反序列化。
具体的过程可以这样描述 通过NSKeyedArchiver 可以将实现了NSCoding协议的对象 和 字节流 相互转换 。

像一些框架中的数据类型如NSDictionary,NSArray,NSString… 都已经实现了NSCoding协议，所以可以直接对他们进行归档操作。

这里来一个比较完整的例子，一个Address类，一个User类，User类下有个Address类型的属性。

Address类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@interface Address : NSObject<NSCoding>{

    NSString *country;

    NSString *city;

}

@property(nonatomic,copy) NSString *country;

@property(nonatomic,copy) NSString *city;

@end

//////////////////////////////////////////////////////

#import "Address.h"



@implementation Address

@synthesize country;

@synthesize city;



- (void)encodeWithCoder:(NSCoder *)aCoder{

    [aCoder encodeObject:country forKey:@"country"];

    [aCoder encodeObject:city forKey:@"city"];

}



- (id)initWithCoder:(NSCoder *)aDecoder{

    if (self = [super init]) {

        [self setCountry:[aDecoder decodeObjectForKey:@"country"]];

        [self setCity:[aDecoder decodeObjectForKey:@"city"]];

    }

    return self;

}



@end

User类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#import <Foundation/Foundation.h>

#import "Address.h"

@interface User : NSObject<NSCoding>{

    NSString *_name;

    NSString *_password;



    Address *_address;

}

@property(nonatomic,copy) NSString *name;

@property(nonatomic,copy) NSString *password;

@property(nonatomic,retain) Address *address;



@end

/////////////////////////////////////////////////////////

#import "User.h"



@implementation User

@synthesize name = _name;

@synthesize password = _password;

@synthesize address = _address;



- (void)encodeWithCoder:(NSCoder *)aCoder{

    [aCoder encodeObject:_name forKey:@"name"];

    [aCoder encodeObject:_password forKey:@"password"];

    [aCoder encodeObject:_address forKey:@"address"];

}

- (id)initWithCoder:(NSCoder *)aDecoder{

    if (self = [super init]) {

        [self setName:[aDecoder decodeObjectForKey:@"name"]];

        [self setPassword:[aDecoder decodeObjectForKey:@"password"]];

        [self setAddress:[aDecoder decodeObjectForKey:@"address"]];

    }

    return self;

}

@end

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
Address *myAddress = [[[Address alloc] init] autorelease];

myAddress.country = @"中国";

myAddress.city = @"杭州";



User *user = [[[User alloc] init] autorelease];

user.name = @"卢克";

user.password = @"lukejin";

user.address = myAddress;



[NSKeyedArchiver archiveRootObject:user toFile:@"/Users/Luke/Desktop/user"];



id object = [NSKeyedUnarchiver unarchiveObjectWithFile:@"/Users/Luke/Desktop/user"];

NSLog(@"Object Class : %@",[object class]);

通过查看文件内容可以发现，保存的是plist的二进制数据格式。
转成XML可以看到如下内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
    <?xml version="1.0" encoding="UTF-8"?>

    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/    PropertyList-1.0.dtd">

    <plist version="1.0">

    <dict>

        <key>$archiver</key>

        <string>NSKeyedArchiver</string>

        <key>$objects</key>

        <array>

            <string>$null</string>

            <dict>

                <key>$class</key>

                <dict>

                    <key>CF$UID</key>

                    <integer>8</integer>

                </dict>

                <key>address</key>

                <dict>

                    <key>CF$UID</key>

                    <integer>4</integer>

                </dict>

                <key>name</key>

                <dict>

                    <key>CF$UID</key>

                    <integer>2</integer>

                </dict>

                <key>password</key>

                <dict>

                    <key>CF$UID</key>

                    <integer>3</integer>

                </dict>

            </dict>

            <string>卢克</string>

            <string>lukejin</string>

            <dict>

                <key>$class</key>

                <dict>

                    <key>CF$UID</key>

                    <integer>7</integer>

                </dict>

                <key>city</key>

                <dict>

                    <key>CF$UID</key>

                    <integer>6</integer>

                </dict>

                <key>country</key>

                <dict>

                    <key>CF$UID</key>

                    <integer>5</integer>

                </dict>

            </dict>

            <string>中国</string>

            <string>杭州</string>

            <dict>

                <key>$classes</key>

                <array>

                    <string>Address</string>

                    <string>NSObject</string>

                </array>

                <key>$classname</key>

                <string>Address</string>

            </dict>

            <dict>

                <key>$classes</key>

                <array>

                    <string>User</string>

                    <string>NSObject</string>

                </array>

                <key>$classname</key>

                <string>User</string>

            </dict>

        </array>

        <key>$top</key>

        <dict>

            <key>root</key>

            <dict>

                <key>CF$UID</key>

                <integer>1</integer>

            </dict>

        </dict>

        <key>$version</key>

        <integer>100000</integer>

    </dict>

    </plist>

在实际的项目中，我们一般是将NSDictionary或NSArray的对象保存到文件或者从文件读取成对象。
当然这种只是适用于数据量不是很大的应用场景。
NSDictionary和NSArray 都有一个写入文件的方法

1
    - (BOOL)writeToFile:(NSString *)path atomically:(BOOL)useAuxiliaryFile;

NSDictionary和NSArray会直接写成plist文件。

序列化可以通过两种途径来进行

写文件

1
2
3
4
   NSMutableDictionary *dataDictionary = [[[NSMutableDictionary alloc] init] autorelease];

    [dataDictionary setValue:[NSNumber numberWithInt:222] forKey:@"intNumber"];

    [dataDictionary setValue:[NSArray arrayWithObjects:@"1",@"2", nil] forKey:@"testArray"];

    [dataDictionary writeToFile:@"/Users/Luke/Desktop/test.plist" atomically:YES];

写完的文件内容如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="UTF-8"?>

    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

    <plist version="1.0">

    <dict>

        <key>intNumber</key>

        <integer>222</integer>

        <key>testArray</key>

        <array>

            <string>1</string>

            <string>2</string>

        </array>

    </dict>

    </plist>

从文件读取

1
NSDictionary *dictionaryFromFile = [NSDictionary dictionaryWithContentsOfFile:@"/Users/Luke/Desktop/test.plist"];

使用NSPropertyListSerialization类

通过NSPropertyListSerialization类可以将数据对象直接转成NSData或者直接写到文件或者流中去.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
NSMutableDictionary *dataDictionary = [[[NSMutableDictionary alloc] init] autorelease];

[dataDictionary setValue:[NSNumber numberWithInt:222] forKey:@"intNumber"];

[dataDictionary setValue:[NSArray arrayWithObjects:@"1",@"2", nil] forKey:@"testArray"];



NSString *error;

NSData *xmlData = [NSPropertyListSerialization dataFromPropertyList:dataDictionary

                                                         format:NSPropertyListXMLFormat_v1_0

                                               errorDescription:&error];

if(xmlData) {

    NSLog(@"No error creating XML data.");

    [xmlData writeToFile:@"/Users/Luke/Desktop/test2.plist" atomically:YES];

}

else {

    if (error) {

        NSLog(@"error:%@", error);

        [error release];

    }

}

读取

1
2
3
4
5
NSDictionary *dictionaryFromFile = (NSDictionary *)[NSPropertyListSerialization 

                                                   propertyListWithData:[NSData dataWithContentsOfFile:@"/Users/Luke/Desktop/test2.plist"] 

                                                    options:0

                                                    format:NULL

                                                    error:&error];

2.2.2 User Defaults

User Defaults 顾名思义就是一个用户为系统以及程序设置的默认值。每个用户都有自己的一套数据，用户和用户之间没法共享的。

我们都知道每一个程序都会保存一些设置数据，比如记住上次窗口的位置和大小，记住是否弹出某些提示信息等。苹果提供了一个统一的解决方案，就是每一个app都有一个plist文件专门用以保存偏好设置数据。
plist文件名默认是程序Bundle identifier,扩展名为plist.

除了程序自己的设置外，系统还有一些全局的或者其它的一些设置，也属于User Defaults的范畴，User Defaults的持久化数据都保存在

目录中.

这里有一点简要的说一下，User Defaults 中存放的key value分放在多个Domain中，取的时候按一定的次序取查找，次序如下:

• The Argument Domain 程序启动的时候以参数的方式传入的
• The Application Domain 通过NSUserDefaults往里面写数据的时候默认就是写到这个Domain的，通过Bundle identifier来标识
• The Global Domain 用户的全局的设置（系统的偏好设置）会放在这个Domain下，比如用户的语言设置，滚动条的设置等，里面的设置会对所有的程序起作用。
• The Languages Domains
• The Registration Domain 这个domain里面的key value是提供默认值的，一般会在程序启动的设置进行设置，他们都不会被持久化到文件的。当某个key对应的值在上面的那些domain中都不存在的时候，就到这里找。

Mac系统还为user defaults提供了很好的命令行工具，

你可以通过下面的方式查看具体使用方式

1
man defaults

可以通过

查看当前用户的所有的domain，通过

读取 The Global Domain 中的所有值。

NSUserDefaults 类来读写Preferences设置，而无需考虑文件位置等细节问题。

NSUserDefaults 用起来和 NSDictionary 很相似，多了一个Domain的概念在里面。
NSUserDefaults 一样提供了一个获取单例的方法.

1
+ (NSUserDefaults *)standardUserDefaults

NSUserDefaults提供了一系列的接口来根据key获取对应的value，搜索的次序按照上面提及到的次序在各个Domain中进行查找。还提供了一系列的 Setting Default Values的方法，这些设置的值都是在 The Application Domain 下的.当然也提供了修改其他Domain下的值的方法，只是需要整体的设置。

Mac上自带安装了SQLite3 ,如果你之前接触过关系型数据库，你可以通过命令行来对SQLite进行初步的认识

1
2
3
4
5
6
7
8
9
$ sqlite3 test.db

SQLite version 3.7.5

Enter ".help" for instructions

Enter SQL statements terminated with a ";"

sqlite>create table if not exists names(id integer primary key asc, name text); 

sqlite> insert into names(name) values('Luke');

sqlite> select * from names;

1|Luke

sqlite>

那如果在代码中使用SQLite呢？

• 添加sqlite的动态链接库 libsqlite3.0.dylib
• 引入头文件 #import “sqlite3.h”

这样之后你便可以通过C的接口来操作数据库了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
sqlite3 *database;//sqlite3的类型其实只是一个结构体struct

NSArray *documentsPaths=NSSearchPathForDirectoriesInDomains(NSDocumentDirectory 

                                                        , NSUserDomainMask 

                                                        , YES); 

NSString *databaseFilePath=[[documentsPaths objectAtIndex:0] stringByAppendingPathComponent:@"luke.db"];



//打开数据库

if (sqlite3_open([databaseFilePath UTF8String], &database)==SQLITE_OK) { 

   NSLog(@"open sqlite db ok."); 

    char *errorMsg; 

    const char *createSql="create table if not exists names (id integer primary key asc,name text)";

    //创建表

    if (sqlite3_exec(database, createSql, NULL, NULL, &errorMsg)==SQLITE_OK) { 

        NSLog(@"create ok."); 

    }else {

        NSLog(@"error: %s",errorMsg); 

        sqlite3_free(errorMsg);

    }





    //插入数据

    const char *insertSql="insert into names (name) values(\"Luke\")"; 

    if (sqlite3_exec(database, insertSql, NULL, NULL, &errorMsg) == SQLITE_OK) { 

        NSLog(@"insert ok."); 

    }else {

        NSLog(@"error: %s",errorMsg); 

        sqlite3_free(errorMsg); 

    }





    const char *selectSql="select id,name from names"; 

    sqlite3_stmt *statement; 

    if (sqlite3_prepare_v2(database, selectSql, -1, &statement, nil) == SQLITE_OK) { 

        NSLog(@"select ok.");

    }



    while (sqlite3_step(statement)==SQLITE_ROW) { 

        int _id=sqlite3_column_int(statement, 0); 

        char *name=(char *)sqlite3_column_text(statement, 1); 

        NSString *nameString = [NSString stringWithCString:name encoding:NSUTF8StringEncoding];

        NSLog(@"row>>id %i, name %@",_id,nameString); 

    }



    sqlite3_finalize(statement);



}



sqlite3_close(database);

你会发现这完全是C语言编程，和Objective-C的代码混在一起格格不入，也很不方便，所以便有人开发了开源的sqlite c接口的wrapper

• FMDB https://github.com/ccgus/fmdb
• EGODatabase https://github.com/enormego/egodatabase (部分代码来自FMDB，thread safe)

具体的使用方法，各自的文档都写的比较清楚。
FMDB不支持多线程同时使用同一个数据库连接进行操作，否则会有线程安全问题，有可能导致数据库文件损坏。EGODatabase则引入了多线程的支持，部分代码借鉴了FMDB，两者在使用上非常的相似。另EGODatabase提供了异步数据库操作的支持，将数据库操作封装成数据库请求（其继承于NSOperation），数据库请求创建好了，丢到一个OperationQueue中被异步的进行执行，当请求数据完成之后 ，相应的delegate方法会被调用，然后你可以在主线程更新显示了.

Block是一个C Level的语法以及运行时的一个特性,非常像标准C中的函数(函数指针)，但是其运行需要编译器和运行时支持,目前LLVM+Clang可以很好的支持Block(苹果修改过的GCC也可以)。Block和函数不同的是其语义 闭包 特性，以及可以有匿名block的存在。
你可以在LLVM的官方网站查看Block语言规范.
你可以通过

运算符来声明一个block变量，或用来表明block定义的开始，而block的代码块则是包含在一对花括号

内的.

1
2
3
4
5
int multiplier = 2;   

int (^myBlock)(int) = ^(int num){   

    return num * multiplier;   

};   

printf("%d",myBlock(4));

上面代码中的

就是Block的变量名,由myBlock变量的声明可以看出，它返回值为int类型，且存在一个int型的参数。
等于号后面就是Block的定义并将其赋值给myBlock .
Block的调用就和C函数的使用类似.

声明Block变量
Block变量保存着指向Block的指针，声明一个Block变量就和声明一个函数指针变量类似，只是将*改成了^.
其他的就和C的类型系统保持一致了。

1
2
3
void (^blockReturningVoidWithVoidArgument)(void);   

int (^blockReturningIntWithIntAndCharArguments)(int, char);   

void (^arrayOfTenBlocksReturningVoidWithIntArgument[10])(int);

另 Block还支持可变参数variadic (…) ，没有参数的话，变量列表的地方必须写上void关键字.

声明Block类型
你可以通过typedef声明Block的类型，这样多个地方需要使用同种类型的Block的时候会比较方便,

1
2
3
typedef float (^MyBlockType)(float, float);   

MyBlockType myFirstBlock = // ... ;   

MyBlockType mySecondBlock = // ... ;

Block创建
声明了一个Block变量之后，可以为这个变量赋值
blockReturningVoidWithVoidArgument = ^{
printf(“%s”,”Block Returing Void With Void Argument.”);
}

当然你可以在声明变量的同时赋值

1
2
3
void (^blockReturningVoidWithVoidArgument)(void) = ^{   

      printf("%s","Block Returing Void With Void Argument.");   

}

Block调用
Block的调用和函数的调用是非常相似的,如上面定义的blockReturningVoidWithVoidArgument，调用的时候则直接

便可.

匿名Block
当一个Block作为函数参数的时候，一般实参都是以匿名Block的方式传过去的。

1
2
3
4
5
6
7
8
9
10
11
12
13
void callVoidVoid(void (^closure)(void)) {   

   closure();   

}   

int main(int argc, char *argv[]) {   

   __block int i = 10;       

   callVoidVoid(^{ ++i; });   

   if (i != 11) {   

       printf("*** %s didn't update i\n", argv[0]);   

       return 1;   

   }   

   printf("%s: success\n", argv[0]);   

   return 0;   

}

当然你也可以直接调用匿名Block，如

1
^{ ++i; }();

3.Block和变量

一个Block的内部是可以引用自身作用域外的变量的，包括static变量，extern变量或自由变量（定义一个变量的时候，如果不加存储修饰符，默认情况下就是自由变量auto,auto变量保存在stack中的.除了auto之外还存在register，static等存储修饰符） ,对于自由变量，在Block中是只读的。在引入block的同时，还引入了一种特殊的变量存储修饰符

,通过它的变量叫做block变量，block变量在block内部可以进行写操作的。这些变量中，自由变量是最特殊的，在Block声明的时候，自由变量在Block内部只读且其值被固定住（自由变量被拷贝了一份，且限定为const），即使在block调用前改变了这个自由变量的值，block调用的时候，看到的却还是block声明的时候的那个值。

代码示例 3.1

1
2
3
4
5
6
7
8
9
10
11
    __block int blockValue = 0;

    int autoValue = 0;



    void(^printValue)(void) = ^{

        printf("blockValue = %d\n",blockValue);

        printf("autoValue = %d\n",autoValue);



    };

    blockValue ++;

    autoValue ++;

    printValue();

3.1中的代码，输出的值为

1
2
blockValue = 1

autoValue = 0

可以看到自由变量尽管自增了，但是在调用printValue这个Block的时候，看到的还是其定义的时候看到的那个autoValue的值,autoValue的值在Block的内部示无法修改的，要不然编译器会报错:

1
Semantic Issue: Variable is not assignable (missing __block type specifier)

Block定义时内存是分配在stack上的，当其作用域结束，就会被自动释放，所以你不需要去担心它的内存情况，我们可以对一个Block进行

操作，

之后，Block会被拷贝到heap中的内存中，且其所有的引用到的自由变量也将会被拷贝，当然你得记得通过

释放heap的内存空间哦。
在objc中Block是和对象一样被看作一等公民的（其实这是objc的Block扩展的功劳），你可以像使用对象那样对Block进行retain（retain只对heap中的Block起作用）,copy以及release操作.

在Block内部如果引用到对象或者对象的成员变量，那么当Block被拷贝

之后，这个对象的引用计数会增加。

代码示例 3.2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
    NSObject *testObject = [[NSObject alloc] init];



    NSLog(@"%lu",[testObject retainCount]); //1

    NSLog(@"%lu",[self retainCount]); //1



    void(^testBlock)(void) = ^{

       NSLog(@"The Test String : %@", testObject);

     NSLog(@"The Window Object : %@", _window);

  };



  NSLog(@"%lu",[testObject retainCount]); //1

   NSLog(@"%lu",[self retainCount]); //1



    void(^testBlock2)(void) = Block_copy(testBlock); //testBlock会被拷贝到heap中,所以用完了要自己调用Block_release进行释放

    NSLog(@"%lu",[testObject retainCount]); //2

    NSLog(@"%lu",[self retainCount]); //2



    testBlock2();



    Block_release(testBlock2);



    NSLog(@"%lu",[testObject retainCount]); //1

    NSLog(@"%lu",[self retainCount]); //1



    [testObject release];

Block的闭包特性使得Block可以脱离其定义的作用域进行运行，所以你可以在一个函数中返回一个Block，在别的线程或者当前线程的RunLoop中进行运行，而不用担心那些引用到的外部变量是否被释放掉了。

4.Block实际应用

那么我们一般什么时候会用到Block呢？
Blocks通常是一小段自包含的代码片段.所以它经常被用于多线程运行的代码单元(如GCD)，或用于处理聚合类元素单元，或者作为某个函数调用完成后的回调函数.

Block用作回调函数比传统的回调函数有以下的优越性:

• 在函数调用的时候，将Block作为一个参数传给函数
• 允许访问本地变量，这样可以避免通过结构体将本地变量封装后传递给回调函数

应用1: Animations & Completion Handler

1
2
3
4
5
6
7
8
9
 [UIView animateWithDuration:2 

                animations:^{

                     self.view.backgroundColor = [UIColor redColor];

                 }  

                 completion:^(BOOL finished){

                     if (finished){

                         self.view.backgroundColor = [UIColor blueColor];

                     } 

                 }];

应用2: Enumeration
对数据集合类中的每一个元素进行遍历，每次传入一个对象，进行处理

1
2
3
4
NSArray *cards = [NSArray arrayWithObjects:@"Jack", @"Queen", @"King", @"Ace", nil];

[cards enumerateObjectsUsingBlock:^(id object, NSUInteger index, BOOL *stop) {

    NSLog(@"%@ card at index %d", object, index);

}];

应用3: Notification Handler

1
2
3
4
5
6
7
    [[NSNotificationCenter defaultCenter] 

     addObserverForName:@"TestNotification" 

     object:nil 

     queue:aNSOperationQueue 

     usingBlock:^(NSNotification *notification){

         NSLog(@"Notification: %@",notification);

     }];

应用4: GCD

1
2
3
4
5
6
7
8
9
         dispatch_queue_t imageDownloadQueue = dispatch_queue_create("Image Download Queue", NULL);

   dispatch_async(imageDownloadQueue, ^{

      NSURL *imageURL = [NSURL URLWithString:@"http://xxx.xx.com/a.png"];

      NSData *imageData = [NSData dataWithContentsOfURL:imageURL];

      UIImage *image = [UIImage imageWithData:imageData];

      dispatch_async(dispatch_get_main_queue(), ^{

          [imageView setImage:image];

      });

  });

首先这是一个功能按钮，按下去会触发相应的动作，比如弹出一个新的窗口。
NSButton 支持设置图片，且可以分别位普通状态和alternate状态(按下去的状态)设置图片，如果你没有设置alternate状态的图片，则按下的时候则显示的比之前的暗些。

为了实现既定的效果，大体的思路是这样的：
1.当鼠标不在按钮上的时候 按钮设置成普通按钮图片
2.当鼠标移到按钮上的时候 按钮设置成hover状态的图片
3.按钮被按下的时候，就使用默认的变暗效果（在hover的基础上变暗）

所以这个时候关键问题变成如何去”订阅”鼠标移到按钮内部以及移出按钮内部的事件消息!
并在相应的响应函数中作出相应的图片设置显示操作。

NSButton使用的使用的鼠标事件处理方式为 “The Mouse-Tracking Loop Approach”
就是只有NSButton的

会被调用，所有的鼠标左键事情比如mouseDragged,mouseUp等都会被放到一个队列中，可以通过

指定mask(比如NSLeftMouseUpMask,NSLeftMouseDraggedMask)获得事情队列中的指定事件.然后对事情做相应的处理。
不过貌似对于hover的效果无需考虑mouseUp和mouseDrag的事件.

我们要找的是鼠标移到按钮区域内和移出按钮区域内的事件.
所以找到了“Using Tracking-Area Objects”
这个的方式也蛮简单，

继承上面的方法，为当前按钮添加一个Tracking-Area,其实就是设置一个控件内的矩形区域以及设置如何跟踪(比如设置跟踪的event NSTrackingMouseEnteredAndExited，NSTrackingMouseMoved，NSTrackingCursorUpdate，设置跟踪的时机 NSTrackingActiveWhenFirstResponder ….).
设置好了之后相应的函数便可以在相应的事件触发后得到响应了。

实现的关键代码片段，继承NSButton

ipa 解压，将png相关文件夹拷贝出来，在命令行下使用/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/pngcrush -revert-iphone-optimizations xxx.png yyy.png

我们都知道一个编译好的iPhone app 其中的png图片一般普通的图片阅读器是无法直接读取的，这是因为XCode在编译的过程中，将图片进行了优化，实际上它已经不是一个png图片了。
这边有一些apple iPhone png自己格式的一些说明
http://iphonedevwiki.net/index.php/CgBI_file_format

在Png数据中，我们最关心的莫过于png的数据块，其中包含了png每一个像素的信息，当然了为了减少存储空间，这些像素信息都是压缩保存的。而且是使用zlib进行压缩的，压缩后 包含zlib header 信息，还有由于解压验证的crc信息。
而iPhone的CgBI格式的png则将原始的png图片作如下变化:

1. 增加一个新的关键块 CgBI Chunk 四个字节
2. zlib的header和CRC信息全部从IDAT中移除
3. 红蓝交换，每一个像素（RGBA）中的R和B进行调换变成BGRA ，解压后每一个像素有四个字节组成，也就是将每一个像素的 第一个字节和第三个字节调换
4. 透明像素处理 Premultiplied Alpha ，这个的意思是为了图像加载变得更快，预先将Alpha的信息乘到像素的颜色信息中去，这样后期计算的时候就可以减少CPU或者GPU计算了

把一个正常的PNG图片优化成iPhone 的png图片格式可以使用XCode自带的工具 /Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/pngcrush -iphone
还有一个第三方的开源工具也可以
https://github.com/DHowett/pincrush

如果你想把一个经过优化后的图片还原成普通图片阅读器可以查看的png图片，就是对上面的过程进行反向处理。
现在可以找到的第三方的转换的一般有如下几个
ipin.py(Python版本) http://www.axelbrz.com.ar/?mod=iphone-png-images-normalizer
iPhonePNG（C版本） http://www.newsfirerss.com/blog/?p=176

经过本人测试，上面的这种第三方的额转换工具都没有对alpha相关的做任何处理，也可以是别的原因，有一些图片转换后的结果和原始图片还是有些出入的。
原图(Flip Board中的一个按钮背景图):

编译后如果使用第三方的python或者C版本的代码来转换，转换后的图片都是这样的，感觉边角的像素有点问题，不过大部分情况下 ，图片都是ok的

我尝试通过修改第三方的代码，想将Premultiplied Alpha 还原过去，但是还是存在各种问题，最终没有结果。
只能最终采用XCode自带的工具进行转换 /Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/pngcrush -revert-iphone-optimizations 1.png 2.png
这个pngcrush是apple改自开源的pngcrush 只可惜苹果修改后的版本却没有开源出来。

为了避免每次都需要在命令行中进行操作，你可以通过automator新建一个shell的service

当然你可以修改脚本，并可以作用于文件和文件夹，对目标进行判断，文件夹则递归文件夹中的png文件进行逐个处理。

一般Swatch手表的计时都是采用所谓的三针计时方式：一个是秒针，一个是分针，另外一个是1/10秒针，当开始计时时，秒针开始计时，走到一圈时即是一分，分针就计为1分，当终止计时时，1/10秒针计算的是1/10秒的时间。所以三针计时方式可以精确到1/10秒。

今天刚拿到上图中的这块表，完全搞不定如何计时。最大的误解就在于那个最长的秒针。尼玛这个最长的秒针不是手表本身的秒针，而是计时的秒针的啊，这完全违反一般的认识啊!!!! 而下方的小圆盘中的不停走动的秒针才是表的正真的秒针啊!!!

左上方是用于计分钟的，一格是一分，右上方是记1/10秒的，一格是1/10秒。而中间的这个最大的秒针是计时用的秒针。
表的右侧有三个功能按钮，在计时归零的状态下，按一下最上方的按钮，最大的秒针开始走动，代表开始计时，再按一下暂停计时，这个时候，1/10秒的地方就会显示对应的10分之几秒，然后再按上方的按钮则继续计时，再按暂停计时。在暂停的时候按下下方的按钮，则进行计时归零。如果归零有偏位，则可以通过拔开中间的按钮一档，然后按上方或者下方的按钮进行秒针和1/10秒的归零位置调整。

说实话，swatch计时功能使用最大的障碍就是使用最大的秒针来作为计时用的秒针（而一般人的认识中这个大指针是表的秒针）。

把一个公司比作一个运行着的程序(进程)，每一个人都是一个线程，你就在循环的运行着，每天处理着事件。
需要处理的任务数较多，就会进去你的任务队列，一个个的按次序做完，有时候你做完了就空闲了，处于等待状态。
1.你的老板会指派一些任务给你做，这个便是线程之间的消息传递。
2.有一些任务可能是定时的，每隔一定的时间你就需要做一下，当然有时候可能某一个定时任务的时间点到了，但是你的手头上正在处理另一个事情，这个时候可能需要等这个事情处理完了在处理定时任务了。所以在Cocoa中Timer的定时执行并不能保证实时。

由于NSTableView需要使用到NSCell的copyWithZone方法在适当的时候复制NSCell，而NSCell默认的copyWithZone方法的实现方式是使用NSCopyObject创建了原始cell对象的一份浅拷贝，所以在复制的时候只会简单的复制指针的值，而不会去深拷贝或者去retain，那么这样程序运行的时候就会出错了。原因就是Cell所引用的某个对象被错误的完全释放了（复制的时候没有retain，但是在释放cell的时候，将这个对象release了一把）。所以在实现copyWithZone的时候可以采用如下方法。

参考文档：
1.内存管理编程指南：实现对象复制
2.NSTableView copies cells – bug or feature?

一.多屏介绍

mac可以支持多屏显示，有一个屏幕是作为主屏存在的，也就是那个显示Menu Bar以及Dock的屏幕。别的屏幕可以作为扩展屏，或者作为镜像屏幕(其实就是两个屏幕的内容一样)。

我们可以将Menubar 拖到任意一个屏幕（改变主屏），我们可以调整屏幕的左右或者上下位置，我们可以调整屏幕的错位大小（就是上下或者左右拖动屏幕，最大程度的时候，两个屏幕角对角，以保证俩个屏幕有相交区域，鼠标从一个屏幕进入另一个屏幕，需要从从相交的区域进去）。

在Cocoa中，我们可以通过NSScreen类获取所有screen的信息。
可以通过 + (NSArray *)screens 这个类方法获取所有的screen对象，其中第一个元素是放置Menu Bar的屏幕。“The screen containing the menu bar is always the first object (index 0) in the array returned by the screens method.”

+ (NSScreen *)mainScreen 这个类方法所获得的screen并不一定是包含Menu bar的screen，而是key window（当前响应用户键盘事件的窗口）所在的screen。

我们可以通过- (NSRect)frame方法获得screen的frame，包括menu bar以及dock的区域。
- (NSRect)visibleFrame获得的区域不包含menu bar以及dock占用的区域。

多个屏幕的情况下，其实系统将所有的screen放置在一个包括所有屏幕的矩形内。
我们可以通过如下方法计算出整个矩形的frame

图中坐标显的是对称的，如果你将其中一个screen上下拖动，就会变得不对称，各个screen的坐标也会随着变化。

在Cocoa中可以通过一个非常简单的方式对屏幕进行截图，方法如下，cropRect为整个screen中的frame。

之前我们用screen的frame获得的区域都是以包含menu bar的屏幕的左下角为坐标原点的。
而在CG的相关方法中，则以左上角为坐标原点。
如果只是在单屏幕的情况下，cropRect的计算就非常简单。但是在多屏的情况下，且各个屏幕的分辨率可能不一样，所以就有点复杂了，比如像刚才的情况，想截图副屏左上角的四分之一的区域，这个时候就需要将包含menubar的screen的左上角作为原点在推算出目标区域坐标。