王若风的技术博客

SQLite Insert 语句

SQLite 的 INSERT INTO 语句用于向数据库的某个表中添加新的数据行。

语法

INSERT INTO 语句有两种基本语法，如下所示：

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)] 
VALUES (value1, value2, value3,...valueN);

在这里，column1, column2,…columnN 是要插入数据的表中的列的名称。
如果要为表中的所有列添加值，您也可以不需要在 SQLite 查询中指定列名称。但要确保值的顺序与列在表中的顺序一致。SQLite 的 INSERT INTO 语法如下：

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

实例

假设您已经在 testDB.db 中创建了 COMPANY 表，如下所示：

sqlite> CREATE TABLE COMPANY(
 ID INT PRIMARY KEY NOT NULL,
 NAME TEXT NOT NULL,
 AGE INT NOT NULL,
 ADDRESS CHAR(50),
 SALARY REAL
);

现在，下面的语句将在 COMPANY 表中创建六个记录：

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Kim', 22, 'South-Hall', 45000.00 );

您也可以使用第二种语法在 COMPANY 表中创建一个记录，如下所示：

INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );

上面的所有语句将在 COMPANY 表中创建下列记录。下一章会教您如何从一个表中显示所有这些记录。

ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0

使用一个表来填充另一个表

您可以通过在一个有一组字段的表上使用 select 语句，填充数据到另一个表中。下面是语法：

INSERT INTO first_table_name [(column1, column2, ... columnN)]
 SELECT column1, column2, ...columnN
 FROM second_table_name
 [WHERE condition];

SQLite Select 语句

SQLite 的 SELECT 语句用于从 SQLite 数据库表中获取数据，以结果表的形式返回数据。这些结果表也被称为结果集。

语法

SQLite 的 SELECT 语句的基本语法如下：

SELECT column1, column2, columnN FROM table_name;

在这里，column1, column2…是表的字段，他们的值即是您要获取的。如果您想获取所有可用的字段，那么可以使用下面的语法：

SELECT * FROM table_name;

实例

假设 COMPANY 表有以下记录：

ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0

下面是一个实例，使用 SELECT 语句获取并显示所有这些记录。在这里，前三个命令被用来设置正确格式化的输出。

sqlite>.header on
sqlite>.mode column
sqlite> SELECT * FROM COMPANY;

最后，将得到以下的结果：

ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0

如果只想获取 COMPANY 表中指定的字段，则使用下面的查询：

sqlite> SELECT ID, NAME, SALARY FROM COMPANY;

上面的查询会产生以下结果：

ID NAME SALARY
---------- ---------- ----------
1 Paul 20000.0
2 Allen 15000.0
3 Teddy 20000.0
4 Mark 65000.0
5 David 85000.0
6 Kim 45000.0
7 James 10000.0

设置输出列的宽度

有时，由于要显示的列的默认宽度导致 .mode column，这种情况下，输出被截断。此时，您可以使用 .width num, num…. 命令设置显示列的宽度，如下所示：

sqlite>.width 10, 20, 10
sqlite>SELECT * FROM COMPANY;

上面的 .width 命令设置第一列的宽度为 10，第二列的宽度为 20，第三列的宽度为 10。因此上述 SELECT 语句将得到以下结果：

ID NAME AGE ADDRESS SALARY
---------- -------------------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0

Schema 信息
因为所有的点命令只在 SQLite 提示符中可用，所以当您进行带有 SQLite 的编程时，您要使用下面的带有 sqlite_master 表的 SELECT 语句来列出所有在数据库中创建的表：

sqlite> SELECT tbl_name FROM sqlite_master WHERE type = 'table';

假设在 testDB.db 中已经存在唯一的 COMPANY 表，则将产生以下结果：

tbl_name
----------
COMPANY

您可以列出关于 COMPANY 表的完整信息，如下所示：

sqlite> SELECT sql FROM sqlite_master WHERE type = 'table' AND tbl_name = 'COMPANY';

假设在 testDB.db 中已经存在唯一的 COMPANY 表，则将产生以下结果：

CREATE TABLE COMPANY(
 ID INT PRIMARY KEY NOT NULL,
 NAME TEXT NOT NULL,
 AGE INT NOT NULL,
 ADDRESS CHAR(50),
 SALARY REAL
)

资料整理于：RUNOOB.COM-SQLite 教程
转载请注明出处。

SQLite 数据类型

SQLite 数据类型是一个用来指定任何对象的数据类型的属性。SQLite 中的每一列，每个变量和表达式都有相关的数据类型。

您可以在创建表的同时使用这些数据类型。SQLite 使用一个更普遍的动态类型系统。在 SQLite 中，值的数据类型与值本身是相关的，而不是与它的容器相关。

SQLite 存储类

每个存储在 SQLite 数据库中的值都具有以下存储类之一：

SQLite 的存储类稍微比数据类型更普遍。INTEGER 存储类，例如，包含 6 种不同的不同长度的整数数据类型。

SQLite Affinity 类型

SQLite 支持列上的类型 affinity 概念。任何列仍然可以存储任何类型的数据，但列的首选存储类是它的 affinity。在 SQLite3 数据库中，每个表的列分配为以下类型的 affinity 之一：

SQLite Affinity 及类型名称

下表列出了当创建 SQLite3 表时可使用的各种数据类型名称，同时也显示了相应的应用 Affinity：

Boolean 数据类型

SQLite 没有单独的 Boolean 存储类。相反，布尔值被存储为整数 0（false）和 1（true）。

Date 与 Time 数据类型

SQLite 没有一个单独的用于存储日期和/或时间的存储类，但 SQLite 能够把日期和时间存储为 TEXT、REAL 或 INTEGER 值。

您可以以任何上述格式来存储日期和时间，并且可以使用内置的日期和时间函数来自由转换不同格式。

SQLite 创建数据库

SQLite 的 sqlite3 命令被用来创建新的 SQLite 数据库。您不需要任何特殊的权限即可创建一个数据。

语法

sqlite3 命令的基本语法如下：

$sqlite3 DatabaseName.db

通常情况下，数据库名称在 RDBMS 内应该是唯一的。

实例

如果您想创建一个新的数据库 <testDB.db>，SQLITE3 语句如下所示：

$sqlite3 testDB.db
SQLite version 3.8.10.2 2015-05-20 18:17:19
Enter ".help" for usage hints.
sqlite>

上面的命令将在当前目录下创建一个文件 testDB.db。该文件将被 SQLite 引擎用作数据库。如果您已经注意到 sqlite3 命令在成功创建数据库文件之后，将提供一个 sqlite> 提示符。
一旦数据库被创建，您就可以使用 SQLite 的 .databases 命令来检查它是否在数据库列表中，如下所示：

sqlite>.databases
seq name file 
---- ---------------- --------------------------------------------
0 main /Users/wangruofeng/Documents/SQLitePractice/testDB.db

您可以使用 SQLite .quit 命令退出 sqlite 提示符，如下所示：

sqlite>.quit
$

.dump 命令

您可以在命令提示符中使用 SQLite .dump 点命令来导出完整的数据库在一个文本文件中，如下所示：

$sqlite3 testDB.db .dump > testDB.sql

上面的命令将转换整个 testDB.db 数据库的内容到 SQLite 的语句中，并将其转储到 ASCII 文本文件 testDB.sql 中。您可以通过简单的方式从生成的 testDB.sql 恢复，如下所示：

$sqlite3 testDB.db < testDB.sql

此时的数据库是空的，一旦数据库中有表和数据，您可以尝试上述两个程序。现在，让我们继续学习下一章。

SQLite 附加数据库

假设这样一种情况，当在同一时间有多个数据库可用，您想使用其中的任何一个。SQLite 的 ATTACH DTABASE 语句是用来选择一个特定的数据库，使用该命令后，所有的 SQLite 语句将在附加的数据库下执行。相当于给数据库取一个别名

语法

SQLite 的 ATTACH DATABASE 语句的基本语法如下：

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

如果数据库尚未被创建，上面的命令将创建一个数据库，如果数据库已存在，则把数据库文件名称与逻辑数据库 ‘Alias-Name’ 绑定在一起。

实例
如果想附加一个现有的数据库 testDB.db，则 ATTACH DATABASE 语句将如下所示：

sqlite> ATTACH DATABASE 'testDB.db' as 'TEST';

使用 SQLite .database 命令来显示附加的数据库。

sqlite> .database
seq name file
--- --------------- ----------------------
0 main /home/sqlite/testDB.db
2 test /home/sqlite/testDB.db

数据库名称 main 和 temp 被保留用于主数据库和存储临时表及其他临时数据对象的数据库。这两个数据库名称可用于每个数据库连接，且不应该被用于附加，否则将得到一个警告消息，如下所示：

sqlite> ATTACH DATABASE 'testDB.db' as 'TEMP';
Error: database TEMP is already in use
sqlite> ATTACH DATABASE 'testDB.db' as 'main';
Error: database main is already in use

SQLite 分离数据库

SQLite 的 DETACH DTABASE 语句是用来把命名数据库从一个数据库连接分离和游离出来，连接是之前使用 ATTACH 语句附加的。如果同一个数据库文件已经被附加上多个别名，DETACH 命令将只断开给定名称的连接，而其余的仍然有效。您无法分离 main 或 temp 数据库。

如果数据库是在内存中或者是临时数据库，则该数据库将被摧毁，且内容将会丢失。

语法

SQLite 的 DETACH DATABASE ‘Alias-Name’ 语句的基本语法如下：

DETACH DATABASE 'Alias-Name';

在这里，’Alias-Name’ 与您之前使用 ATTACH 语句附加数据库时所用到的别名相同。

实例

假设在前面的章节中您已经创建了一个数据库，并给它附加了 ‘test’ 和 ‘currentDB’，使用 .database/.databases 命令，我们可以看到：

sqlite> .databases
seq name file
--- --------------- ----------------------
0 main /home/sqlite/testDB.db
2 test /home/sqlite/testDB.db
3 currentDB /home/sqlite/testDB.db

现在，让我们尝试把 ‘currentDB’ 从 testDB.db 中分离出来，如下所示：

sqlite> DETACH DATABASE 'currentDB';

现在，如果检查当前附加的数据库，您会发现，testDB.db 仍与 ‘test’ 和 ‘main’ 保持连接。

sqlite> .databases
seq name file
--- --------------- ----------------------
0 main /home/sqlite/testDB.db
2 test /home/sqlite/testDB.db

SQLite 创建表

SQLite 的 CREATE TABLE 语句用于在任何给定的数据库创建一个新表。创建基本表，涉及到命名表、定义列及每一列的数据类型。

语法

CREATE TABLE 语句的基本语法如下：

CREATE TABLE database_name.table_name(
 column1 datatype PRIMARY KEY(one or more columns),
 column2 datatype,
 column3 datatype,
 .....
 columnN datatype,
);

CREATE TABLE 是告诉数据库系统创建一个新表的关键字。CREATE TABLE 语句后跟着表的唯一的名称或标识。您也可以选择指定带有 table_name 的 database_name。

实例

下面是一个实例，它创建了一个 COMPANY 表，ID 作为主键，NOT NULL 的约束表示在表中创建纪录时这些字段不能为 NULL：

sqlite> CREATE TABLE COMPANY(
 ID INT PRIMARY KEY NOT NULL,
 NAME TEXT NOT NULL,
 AGE INT NOT NULL,
 ADDRESS CHAR(50),
 SALARY REAL
);

让我们再创建一个表，我们将在随后章节的练习中使用：

sqlite> CREATE TABLE DEPARTMENT(
 ID INT PRIMARY KEY NOT NULL,
 DEPT CHAR(50) NOT NULL,
 EMP_ID INT NOT NULL
);

您可以使用 SQLIte 命令中的 .tables/.table 命令来验证表是否已成功创建，该命令用于列出附加数据库中的所有表。

sqlite> .tables
COMPANY DEPARTMENT TEST.COMPANY TEST.DEPARTMENT

在这里，可以看到 COMPANY 表出现两次，一个是主数据库的 COMPANY 表，一个是为 testDB.db 创建的 ‘test’ 别名的 test.COMPANY 表。您可以使用 SQLite .schema 命令得到表的完整信息，如下所示：

sqlite>.schema COMPANY
CREATE TABLE COMPANY(
 ID INT PRIMARY KEY NOT NULL,
 NAME TEXT NOT NULL,
 AGE INT NOT NULL,
 ADDRESS CHAR(50),
 SALARY REAL
);

SQLite 删除表

SQLite 的 DROP TABLE 语句用来删除表定义及其所有相关数据、索引、触发器、约束和该表的权限规范。

使用此命令时要特别注意，因为一旦一个表被删除，表中所有信息也将永远丢失。

语法

DROP TABLE 语句的基本语法如下。您可以选择指定带有表名的数据库名称，如下所示：

DROP TABLE database_name.table_name;

实例

让我们先确认 COMPANY 表已经存在，然后我们将其从数据库中删除。

sqlite> .tables
COMPANY test.COMPANY

这意味着 COMPANY 表已存在数据库中，接下来让我们把它从数据库中删除，如下：

sqlite> DROP TABLE COMPANY;
sqlite>

现在，如果尝试 .TABLES 命令，那么将无法找到 COMPANY 表了：

sqlite> .tables
sqlite>

显示结果为空，意味着已经成功从数据库删除表。

资料整理于：RUNOOB.COM-SQLite 教程
转载请注明出处。

简介：

SQLite 是一个软件库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite 是在世界上最广泛部署的 SQL 数据库引擎。SQLite 源代码不受版权限制。
本教程将告诉您如何使用 SQLite 编程，并让你迅速上手。

什么是 SQLite？

SQLite 是一个进程内的库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它是一个零配置的数据库，这意味着与其他数据库一样，您不需要在系统中配置。
就像其他数据库，SQLite 引擎不是一个独立的进程，可以按应用程序需求进行静态或动态连接。SQLite 直接访问其存储文件

为什么要用 SQLite？

• 不需要一个单独的服务器进程或操作的系统（无服务器的）。
• SQLite 不需要配置，这意味着不需要安装或管理。
• 一个完整的 SQLite 数据库是存储在一个单一的跨平台的磁盘文件。
• SQLite 是非常小的，是轻量级的，完全配置时小于 400KiB，省略可选功能配置时小于 250KiB。
• SQLite 是自给自足的，这意味着不需要任何外部的依赖。
• SQLite 事务是完全兼容 ACID 的，允许从多个进程或线程安全访问。
• SQLite 支持 SQL92（SQL2）标准的大多数查询语言的功能。
• SQLite 使用 ANSI-C 编写的，并提供了简单和易于使用的 API。
• SQLite 可在 UNIX（Linux, Mac OS-X, Android, iOS）和 Windows（Win32, WinCE, WinRT）中运行。

SQLite 命令

与关系数据库进行交互的标准 SQLite 命令类似于 SQL。命令包括 CREATE、SELECT、INSERT、UPDATE、DELETE 和 DROP。这些命令基于它们的操作性质可分为以下几种：

DDL - 数据定义语言

DML - 数据操作语言

DQL - 数据查询语言

在 Mac OS X 上安装 SQLite

最新版本的 Mac OS X 会预安装 SQLite，但是如果没有可用的安装，只需按照如下步骤进行：
请访问 SQLite 下载页面，从源代码区下载 sqlite-autoconf-*.tar.gz。
步骤如下：

$tar xvfz sqlite-autoconf-3071502.tar.gz
$cd sqlite-autoconf-3071502
$./configure --prefix=/usr/local
$make
$make install

上述步骤将在 Mac OS X 机器上安装 SQLite，您可以使用下列命令进行验证：

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

最后，在 SQLite 命令提示符下，使用 SQLite 命令做练习。

SQLite 语法

大小写敏感性

有个重要的点值得注意，SQLite 是不区分大小写的，但也有一些命令是大小写敏感的，比如 GLOB 和 glob 在 SQLite 的语句中有不同的含义。

注释

SQLite 注释是附加的注释，可以在 SQLite 代码中添加注释以增加其可读性，他们可以出现在任何空白处，包括在表达式内和其他 SQL 语句的中间，但它们不能嵌套。
SQL 注释以两个连续的 “-“ 字符（ASCII 0x2d）开始，并扩展至下一个换行符（ASCII 0x0a）或直到输入结束，以先到者为准。
您也可以使用 C 风格的注释，以 “/*“ 开始，并扩展至下一个 “*/“ 字符对或直到输入结束，以先到者为准。SQLite 的注释可以跨越多行。

SQLite 语句

所有的 SQLite 语句可以以任何关键字开始，如 SELECT、INSERT、UPDATE、DELETE、ALTER、DROP 等，所有的语句以分号（;）结束。

SQLite ANALYZE 语句：

ANALYZE;
or
ANALYZE database_name;
or
ANALYZE database_name.table_name;

SQLite AND/OR 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;

SQLite ALTER TABLE 语句：

ALTER TABLE table_name ADD COLUMN column_def...;
SQLite ALTER TABLE 语句（Rename）：
ALTER TABLE table_name RENAME TO new_table_name;

SQLite ATTACH DATABASE 语句：

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';
SQLite BEGIN TRANSACTION 语句：
BEGIN;
or
BEGIN EXCLUSIVE TRANSACTION;

SQLite BETWEEN 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;

SQLite COMMIT 语句：

COMMIT;

SQLite CREATE INDEX 语句：

CREATE INDEX index_name
ON table_name ( column_name COLLATE NOCASE );

SQLite CREATE UNIQUE INDEX 语句：

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

SQLite CREATE TABLE 语句：

CREATE TABLE table_name(
 column1 datatype,
 column2 datatype,
 column3 datatype,
 .....
 columnN datatype,
 PRIMARY KEY( one or more columns )
);

SQLite CREATE TRIGGER 语句：

CREATE TRIGGER database_name.trigger_name
BEFORE INSERT ON table_name FOR EACH ROW
BEGIN
 stmt1;
 stmt2;
 ....
END;

SQLite CREATE VIEW 语句：

CREATE VIEW database_name.view_name AS
SELECT statement....;

SQLite CREATE VIRTUAL TABLE 语句：

CREATE VIRTUAL TABLE database_name.table_name USING weblog( access.log );
or
CREATE VIRTUAL TABLE database_name.table_name USING fts3( );

SQLite COMMIT TRANSACTION 语句：

COMMIT;
SQLite COUNT 子句：
SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;

SQLite DELETE 语句：

DELETE FROM table_name
WHERE {CONDITION};

SQLite DETACH DATABASE 语句：

DETACH DATABASE 'Alias-Name';

SQLite DISTINCT 子句：

SELECT DISTINCT column1, column2....columnN
FROM table_name;

SQLite DROP INDEX 语句：

DROP INDEX database_name.index_name;

SQLite DROP TABLE 语句：

DROP TABLE database_name.table_name;

SQLite DROP VIEW 语句：

DROP INDEX database_name.view_name;

SQLite DROP TRIGGER 语句：

DROP INDEX database_name.trigger_name;

SQLite EXISTS 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE column_name EXISTS (SELECT * FROM table_name );

SQLite EXPLAIN 语句：

EXPLAIN INSERT statement...;
or
EXPLAIN QUERY PLAN SELECT statement...;

SQLite GLOB 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE column_name GLOB { PATTERN };

SQLite GROUP BY 子句：

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;

SQLite HAVING 子句：

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

SQLite INSERT INTO 语句：

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

SQLite IN 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);

SQLite Like 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE column_name LIKE { PATTERN };

SQLite NOT IN 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE column_name NOT IN (val-1, val-2,...val-N);

SQLite ORDER BY 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};

SQLite PRAGMA 语句：

PRAGMA pragma_name;

For example:

PRAGMA page_size;
PRAGMA cache_size = 1024;
PRAGMA table_info(table_name);

SQLite RELEASE SAVEPOINT 语句：

RELEASE savepoint_name;

SQLite REINDEX 语句：

REINDEX collation_name;
REINDEX database_name.index_name;
REINDEX database_name.table_name;

SQLite ROLLBACK 语句：

ROLLBACK;
or
ROLLBACK TO SAVEPOINT savepoint_name;

SQLite SAVEPOINT 语句：

SAVEPOINT savepoint_name;
SQLite SELECT 语句：
SELECT column1, column2....columnN
FROM table_name;

SQLite UPDATE 语句：

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE CONDITION ];

SQLite VACUUM 语句：

VACUUM;

SQLite WHERE 子句：

SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION;

资料整理于：RUNOOB.COM-SQLite 教程
转载请注明出处。

简介

CocoaPods 是 iOS 最常用的第三方类库管理工具，绝大部分有名的开源类库支持 CocoaPods。

CocoaPods 是用 Ruby 实现的，要使用它首先需要有 Ruby 的环境。

安装

幸亏 OS X 系统默认已经可以运行 Ruby 了，我们只需执行以下命令：

1

sudo gem install cocoapods

由于某些原因，执行时会出现下面的错误提示：

1
2
3
4

ERROR :Could not find a valid gem  `cocoapods`  (>= 0), here is why:
        Unable to download data from https://rubygems.org/ - Errno::EPIPI:
        Broken pipe - SSL_connect
(https://rubygems.org/lastest_specs.4.8.gz)

安装成功后，接着执行命令：

1

pod setup

如果 Ruby 环境不够新，可能需要更新以下：

1

sudo gem update --system

至此安装就完成了，我们可以尝试搜索一个第三方类库：

1

pod search AFNetworking

使用

使用 CocoaPods 第一步，是在当前项目下，新建一个 Podfile 文件：

1

touch Podfile

然后利用 vim 打开 Podfile 文件编辑，加入你想要的类库，格式如下：

1
2
3
4
5
6

platform :ios
pod  'Reachability', '3.1.0'

platform :ios, '6.0'
pod 'JSONKit', '1.4'
pod 'AFNetworking', '~> 2.3.1'

如果是拷贝别人的项目，或是一个很久没打开过的项目，可能需要先执行一下：

1

pod update

最后一步，执行命令：

1

pod install

当终端出现类似下面的提示后，就代表成功了：

1

[!] From now no use  `Sample0814.xcworkspace` .

这个时候会看到项目文件夹多了一个 xxx.xcworkspace,以后要通过这个文件
打开项目，老项目 xxx.xcodeproj 不再使用。

1. 上面的每一步都可能出现问题，但大部分问题都是因为局域网的原因，用一个网速稳
   定的境外 VPN 可破
2. 如果上面因为权限问题安装失败，必须每次都要删除

1

rm -rf /User/loginname/Library/Caches/CocoaPods/

因为这个缓冲中会存下你的 github 的东西，造成每次调用上次权限问题的缓存。

3. 关于 Podfile 文件编辑时，第三方版本号的各种写法:

1
2
3
4
5
6
7
8
9

pod 'AFNetworking'      		 # 不显式指定依赖库版本，表示每次都获取最新版本
pod 'AFNetworking', '2.0'        # 只使用 2.0 版本
pod 'AFNetworking', '>2.0'       # 使用高于 2.0 的版本
pod 'AFNetworking', '>=2.0'      # 使用大于或等于 2.0 的版本
pod 'AFNetworking', '<2.0'       # 使用小于 2.0 的版本
pod 'AFNetworking', '<=2.0'      # 使用小于或等于 2.0 的版本
pod 'AFNetworking', '~>0.1.2'    # 使用大于等于 0.1.2 但小于 0.2 的版本，相当于>=0.1.2 并且<0.2.0
pod 'AFNetworking', '~>0.1'      # 使用大于等于 0.1 但小于 1.0 的版本
pod 'AFNetworking', '~>0'        # 高于 0 的版本，写这个限制和什么都不写是一个效果，都表示使用最新版本

参考资料

• 语义化版本 2.0.0

GET 和 POST 是两种最常用的与服务器进行交互的 HTTP 方法。

GET

• GET 的语义是获取指定的 URL 资源, 将数据按照 variable = value 的形式, 添加到 action 所指向的 URL 后面, 并且两者使用 ‘ ? ‘连接, 各变量之间使用 ‘ & ‘连接。
• 对用户来说不安全, 因为在传输过程中, 数据被放在请求的 URL 中。
• 传输的数据量小, 这主要是因为受 URL 长度限制。

URL 长度限制

在 http 协议中，其实并没有对 url 长度作出限制，往往 url 的最大长度和用户浏览器和 Web 服务器有关，不一样的浏览器，能接受的最大长度往往是不一样的，当然，不一样的 Web 服务器能够处理的最大长度的 URL 的能力也是不一样的。

IE 浏览器对 URL 的最大限制为 2083 个字符，如果超过这个数字，提交按钮没有任何反应；

Firefox 浏览器 URL 的长度限制为 65,536 个字符；

Apache(Server)能够接受的最大 URL 长度为 8192 个字符；

如果浏览器的编码为 UTF8 的话，一个汉字最终编码后的字符长度为 9 个字符。

GET 请求示例

POST

• POST 语义是向指定 URL 的资源添加数据。
• 将数据放在数据体中, 按照变量和值相对应的方式, 传递到 action 所指向的 URL。
• 所有数据对用户来说不可见。
• 可以传输大量数据, 上传文件只能使用 POST。

POST 请求示例

在浏览器中判断 GET&POST 请求

因为 POST 请求会向服务器发送数据体, 因此刷新页面时会出现提示窗口. 而 GET 请求不会向服务器发送数据体, 因此没有提示 .

从请求本质来看, GET 请求要比 POST 更安全, 效率也会更高 .(对服务器而言)

iOS 网络发送网络请求的步骤

1. 实例化 URL( 网络资源 ) ;

2. 根据 URL 建立 URLRequest ( 网络请求 ) ;

默认为 GET 请求; 对于 POST 请求, 需要创建请求的数据体 .

3. 利用 URLConnection 发送网络请求(发送请求并获得结果) ;

NSURLConnection 提供了两个静态方法可以直接以同步或异步的方式向服务器发送网络请求.

1
2
3
4
5

同步请求:
sendSynchronousRequest : returningResponse : error :

异步请求:
sendAsynchronousRequest : queue : completionHandler :

在网络请求过程中, 接收数据的过程实际上是通过 NSURLConnectionDataDelegate 来实现的, 常用代理方法包括:

1
2
3
4
5
6
7
8

// 服务器开始返回数据
- (void)connection:didReceiveResponse:
// 收到服务器返回的数据，本方法会被调用多次
- (void)connection:didReceiveData:
// 数据接收完毕，做数据的最后处理
- (void)connectionDidFinishLoading:
// 网络连接错误
- (void)connection:didFailWithError:

备注：欢迎转载，但请一定注明出处！ http://blog.wangruofeng007.com

HTTP POST 使用注意事项：

• http Body 中的 NSData 编码方式要用 NSASCIIStringEncoding 而不是 NSUTF8StringEncoding * 通过
  NSString *postLength = [NSString stringWithFormat:@"%d",[postData length]]; 计算数据的长度

POST 参数设置

1
2
3
4
5
6

//设置 header Content-Length
[request setValue:postLength forHTTPHeaderField:@"Content-Length"];
//设置 header contentType
[request setValue:@"application/x-www-form-urlencoded" forHTTPHeaderField:@"Current-Type"];
//设置 body
[request setHTTPBody:postData];

备注:普通 post 的 header 的 Current-Type 为 application/x-www-form-urlencoded #### Multipart Forms POST 参数设置

1
2
3
4
5
6

//设置 header contentType
NSString *contentType = [NSString stringWithFormat:@"multipart/form-data; boundary=%@", boundary];
[request addValue:contentType forHTTPHeaderField:@"Content-Type"];

//设置 body contentType
[body appendData:[@"Content-Type: application/octet-stream\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding]];

备注: Multipart Forms 的 header 的 Current-Type 为 multipart/form-data request body like this

    --YOUR_BOUNDARY_STRING
    Content-Disposition: form-data; name="photo"; filename="calm.jpg"
    Content-Type: image/jpeg

    YOUR_IMAGE_DATA_GOES_HERE
    --YOUR_BOUNDARY_STRING
    Content-Disposition: form-data; name="message"

    My first message
    --YOUR_BOUNDARY_STRING
    Content-Disposition: form-data; name="user"

    1
    --YOUR_BOUNDARY_STRING

I’m sending over three variables: an image named photo, a string named message, and an integer named user. It’s important to note the linebreaks and the dashes before the boundary string. These must be included in order to build a good request. Now lets write some objective-c:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

NSString *boundary = @"YOUR_BOUNDARY_STRING";
NSString *contentType = [NSString stringWithFormat:@"multipart/form-data; boundary=%@", boundary];
[request addValue:contentType forHTTPHeaderField:@"Content-Type"];

NSMutableData *body = [NSMutableData data];

[body appendData:[[NSString stringWithFormat:@"\r\n--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"photo\"; filename=\"%@.jpg\"\r\n", self.message.photoKey] dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:[@"Content-Type: application/octet-stream\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:[NSData dataWithData:imageData]];

[body appendData:[[NSString stringWithFormat:@"\r\n--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"message\"\r\n\r\n%@", self.message.message] dataUsingEncoding:NSUTF8StringEncoding]];

[body appendData:[[NSString stringWithFormat:@"\r\n--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"user\"\r\n\r\n%d", 1] dataUsingEncoding:NSUTF8StringEncoding]];

[body appendData:[[NSString stringWithFormat:@"\r\n--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];

[request setHTTPBody:body];

Now all we need to do is make a connection to the server and send the request:

[request setHTTPBody:body];

1
2
3
4

NSURLResponse *response;
NSError *error;

[NSURLConnection sendSynchronousRequest:request returningResponse:&response error:&error];

参考资料：

• Sending Multipart Forms with Objective-C
• POST multipart/form-data with Objective-C
• Sending an HTTP POST request on iOS
• The Multipart Content-Type–w3 规范

备注：欢迎转载，但请一定注明出处！ http://blog.wangruofeng007.com

3 种工厂模式

概述：工厂模式是个系列，分为简单工厂模式， 工厂方法模式， 抽象工厂模式，这三种模式也非常常用。这些模式最最经典的就例子就是设计计算器。

• Factory Method (工厂方法模式)
• Abstract Factory (抽象工厂模式）
• Simple Factory（简单工厂模式）

参考 GoF《Design Patterns》一书 GOF 是这样描述工厂模式的：

“Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.”

在基类中定义创建对象的一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。

简单工厂模式

严格的说，简单工厂模式并不是 23 种常用的设计模式之一，它只算工厂模式的一个特殊实现。简单工厂模式在实际中的应用相对于其他 2 个工厂模式用的还是相对少得多，因为它只适应很多简单的情况，最最重要的是它违背了我们在概述中说的开放-封闭原则。因为每次你要新添加一个功能，都需要在生 switch-case 语句（或者 if-else 语句）中去修改代码，添加分支条件

简单工厂模式角色分配：

1. Creator（产品创建者）
   简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

2. Product （ 产品抽象类）
   简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

3. Concrete Product （具体产品）
   是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

简单的工厂模式 UML 图

考虑下面一个事例： 加入你是一个商人，你做的的是手机生意。现在你生产 android 手机和 iphone 等，考虑到以后你可能还会生产其他手机例如 ubuntu 手机。假定你选择了简单工厂模式来实现。那么显然，我们需要所有产品的抽象基类（Product） 即是 Phone 类：

1
2
3
4
5
6

class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};

然后我们需要具体的产品类 Concrete Product： AndroidPhone 和 iOSPhone

1
2
3
4
5
6
7
8
9
10
11

class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl;}  
};  

class IosPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"IosPhone is calling..."<<endl;}  
};

最后我们需要 Creator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class PhoneFactory  
{  
public:  
    Phone* createPhone(string phoneName)  
    {  
        if(phoneName == "AndroidPhone")  
        {  
            return new AndroidPhone();  
        }else if(phoneName == "IosPhone")  
        {  
            return new IosPhone();  
        }  

        return NULL;  
    }  
};

客户端这样实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void main()  
{  
    PhoneFactor factory;  
    Phone* myAndroid = factory.createPhone("AndroidPhone");  
    Phone* myIPhone = factory.createPhone("iOSPhone");  
    if(myAndroid)  
    {  
        myAndroid->call("123");  
        delete myAndroid;  
        myAndroid = NULL;  
    }  

    if(myIPhone)  
    {  
        myIPhone->call("123");  
        delete  myIPhone;  
        myIPhone = NULL;  
    }  
}

这就是简单工厂方法，把所有的创建交给 creator,creator 通过 switch-case(或者 if-else)语句来选择具体创建的对象。简单明了。但是就如上面所说，它最致命的问题的违背了开放-封闭原则。每次你要新添加一个功能，都要修改 factor 里面的 createPhone 代码。 但是工厂方法模式可以解决这个问题。

工厂方法模式

个人觉得工厂方法模式在工厂模式家族中是用的最多模式。上面说过了，如果简单工厂模式，要添加一个新功能，比如我现在要增加 WinPhone 的生产，那么我要修改 PhoneFactory 中的 createPhone 中的分支判断条件。这违背了开放-封闭原则，那为什么不能将创建方法放到子类中呢？
工厂方法的定义就是：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

工厂方法模式角色：

1. 抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
2. 具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
3. 抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
4. 具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应

工厂方法模式 UML 图：

看定义看的晕乎乎的？那么我们来看代码：产品接口，以及其相应的子类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};  

class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl;}  
};  

class iOSPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"iOSPhone is calling..."<<endl;}  
};

上面这个和简单工厂方法还是一样的。接下来不一样的来了…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class PhoneFactory  
{  
public:  
    virtual ~PhoneFactory(){};  
    virtual Phone* createPhone() = 0;  
};  

class AndroidPhoneFactory : public PhoneFactory  
{  
public:  
    virtual Phone* createPhone()  
    {  
        return new AndroidPhone();  
    }  
};  

class IosPhoneFactory : public PhoneFactory  
{  
public:  
    virtual Phone* createPhone()  
    {  
        return new IosPhone();  
    }  
};

工厂方法将 PhoneFactory 抽象成了基类，PhoneFactory 的 createPhone 不在像以前那样将所有的判断塞到里面。而是改由其子类来实现创建功能，这感觉就是权力下放。
客户端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

void main()  
{  
    PhoneFactory*  androidCreator = new AndroidPhoneFactory();  
    PhoneFactory*  iosCreator = new IosPhoneFactory();  
    Phone*  myAndroid = androidCreator->createPhone();  
    Phone* myIPhone = iosCreator->createPhone();  
    if(myAndroid)  
    {  
        myAndroid->call("123");  
        delete myAndroid;  
        myAndroid = NULL;  
    }  

    if(myIPhone)  
    {  
        myIPhone->call("123");  
        delete  myIPhone;  
        myIPhone = NULL;  
    }  

    delete androidCreator;  
    delete iosCreator;  
}

在工厂方法模式中，核心工厂类不在负责产品的创建，而是将具体的创建工作交给子类去完成。也就是后所这个核心工厂仅仅只是提供创建的接口，具体实现方法交给继承它的子类去完成。当我们的系统需要增加其他新功能时，只需要继承 PhoneFactory 这个类，并且实现 createPhone 接口。 不需要对原工厂 PhoneFactory 进行任何修改，这样很好地符合了“开放-封闭“原则。

虽然工厂方法模式满足了”开放-封闭”原则，但是这个模式也仍然有缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，是的系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

抽象工厂模式

在工厂方法模式中，其实我们有一个潜在意识的意识。那就是我们生产的都是同一类产品，例如我们生产的都是手机！那么现在假如现在我们又要生产平板了了呢？那么就要用到抽象工厂模式。我抽象工厂模式也用的比较多在工厂模式家族中，仅次于工厂方法模式。在了解抽象工厂模式之前，还是老生常谈的理清下产品等级结构和产品簇的概念。下面的图还是老图。但是我讲讲我的理解：

产品等级结构：产品的等级结构也就是产品的继承结构。我理解就是同一类产品，比如手机是一个系列，有 android 手机，ios 手机，win 手机，那么这个抽象类手机和他的子类就构成了一个产品等级结构。那其他的平板显然不是和手机一个系列的，一个平板，一个是手机，所以他们是不同的产品等级结构。

产品族: 在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如分为 android 产品，和 ios 产品。其中一个 ios 产品包含 ios 手机和 ios 平板。显然 ios 手机和 ios 平板不是同一个产品等级结构的，因为一个是手机，一个是平板。但他们是同一个产品簇—都是 ios 产品。
希望大家通过上面的例子大家明白了这两个概念。

抽象工厂模式的 UML 图：

接着上面的话题，现在假如我要增加对平板的支持，那么我们肯定先添加两个产品等级结构，一个是手机，一个是平板：

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

//产品等级结构--手机  
class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};  

class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl; }  
};  

class IosPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"IosPhone is calling..."<<endl; }  
};  

//产品等级结构--平板  
class Pad  
{  
public:  
    virtual ~Pad(){};  
    virtual void playMovie() = 0;  
};  

class AndroidPad : public Pad  
{  
public:  
    virtual void playMovie(){ cout<<"AndriodPad is playing movie..."<<endl; }  
};  

class IosPad : public Pad  
{  
public:  
    virtual void playMovie(){ cout<<"IosPad is playing movie..."<<endl; }  
};   

然后具体的工厂我们整个工厂是生产移动设备的所以我们取名为 MobileFactory,然后工厂可以生产平板和手机，故有了 createPhone 和 createPad 两个接口。

1
2
3
4
5
6
7

class MobileFactory  
{  
public:  
    virtual ~MobileFactory(){};  
    virtual Phone* createPhone() = 0;  
    virtual Pad* createPad() = 0;  
};

接着是 android 产品簇 的工厂类，负责生产 android 的手机和平板：

1
2
3
4
5
6
7
8
9
10
11
12

class AndroidFactory : public MobileFactory  
{  
public:  
    Phone* createPhone()  
    {  
        return new AndroidPhone();  
    }  
    Pad* createPad()  
    {  
        return new AndroidPad();  
    }  
};

接着是 ios 的产品簇的工厂类，负责生产 ios 的手机和平板：

1
2
3
4
5
6
7
8
9
10
11
12
13

class IosFactory : public MobileFactory  
{  
public:  
    Phone* createPhone()  
    {  
        return new IosPhone();  
    }  

    Pad* createPad()  
    {  
        return new IosPad();  
    }  
};

最后客户端这样实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void main()  
{  
    MobileFactory*  androidCreator = new AndroidFactory();  
    MobileFactory*  iosCreator = new IosFactory();  
    Phone*  myAndroidPhone = androidCreator->createPhone();  
    Pad* myAndroidPad = androidCreator->createPad();  
    Phone* myIosPhone = iosCreator->createPhone();  
    Pad* myIosPad = iosCreator->createPad();  

    myAndroidPhone->call("123");  
    myAndroidPad->playMovie();  

    myIosPhone->call("123");  
    myIosPad->playMovie();  
    //这里没有做释放和判断，请自己判断和释放  
}

总结：
抽象工厂模式适用于那些有多种产品的产品簇，并且每次使用其中的某一产品簇的产品。
缺点 ： 抽象工厂模式的添加新功能也非常麻烦，比工厂方法模式都还要复杂的多。
优点： 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象

主要用途

工厂方法要解决的问题是对象的创建时机，它提供了一种扩展的策略，很好地符合了开放封闭原则。工厂方法也叫做虚构造器（Virtual Constructor）。

什么时候使用工厂方法

当是如下情况是，可以使用工厂方法：一个类不知道它所必须创建的对象的类时，一个类希望有它的子类决定所创建的对象时。

更多关于工厂方法的介绍，可以参考本文最后给出的参考内容。下面我们就来看看在 iOS 中工厂方法的一种实现方法。

iOS 中工厂方法的实现实例

如下有一个类图，该图描述了下面即将实现的工厂方法（利用工厂方法，创建出不同的形状）。其中 BVShapeFactory 为工厂方法的基类，BVShape 为形状的基类，BVClient 通过 BVShapeFactory，利用 BVShapeFactory 的子类（BVCircleShapeFactory 和 BVSquareShapeFactory）分别创建出 BVCircleShape 和 BVSquareShape。

github 下载地址:https://github.com/BeyondVincent/ios_patterns/tree/master/FactoryMethodPattern

参考资料

• iOS 设计模式——工厂方法（简单工厂模式，工厂方法模式， 抽象工厂模式）
• iOS 设计模式(03):工厂方法
• Objective-C 类族和工厂模式
• Objective C Design Patterns - Factory
• Class Factory Methods–Apple
• iOS Design Patterns–raywenderlich
• Abstract Factory Design Pattern Objective C
• The factory design pattern explained by example-php
• Design Patterns Series, Day 3: Factory and Singleton Patterns–safaribooksonline
• Automagic Factories in Objective-C–bobmccune

备注：欢迎转载，但请一定注明出处！ http://blog.wangruofeng007.com

前言

每个 iOS 应用程序都有个专门用来更新显示 UI 界面、处理用户触摸事件的主线程，因此不能将其他太耗时的操作放在主线程中执行，不然会造成主线程堵塞(出现卡机现象)，带来极坏的用户体验。一般的解决方案就是将那些耗时的操作放到另外一个线程中去执行，多线程编程是防止主线程堵塞，增加运行效率的最佳方法。

iOS 中有 3 种常见的多线程编程方法

1. NSThread 这种方法需要管理线程的生命周期、同步、加锁问题，会导致一定的性能开销

2. NSOperation 和 NSOperationQueue 是基于 OC 实现的。NSOperation 以面向对象的方式封装了需要执行的操作，然后可以将这个操作放到一个 NSOperationQueue 中去异步执行。不必关心线程管理、同步等问题。

3. Grand Centeral Dispatch 简称 GCD，iOS4 才开始支持，是纯 C 语言的 API。自 iPad2 开始，苹果设备开始有了双核 CPU，为了充分利用这 2 个核，GCD 提供了一些新特性来支持多核并行编程

这篇文章简单介绍 NSThread 这 个类，一个 NSThread 实例就代表着一条线程

获取当前线程

1

NSThread *current = [NSThread currentThread];

获取主线程

1
2

NSThread *main = [NSThread mainThread];
    NSLog(@"主线程:%@", main);    

打印结果是：

2013-04-18 21:36:38.599 thread[7499:c07] 主线程:<NSThread: 0x71434e0>{name = (null), num = 1}

num 相当于线程的 id，主线程的 num 是为 1 的

NSThread 的创建

a.动态方法

• (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument;

在第 2 行创建了一条新线程，然后在第 4 行调用 start 方法启动线程，线程启动后会调用 self 的 run: 方法，并且将@”mj”作为方法参数

1
2
3
4

// 初始化线程
NSThread *thread = [[[NSThread alloc] initWithTarget:self selector:@selector(run:) object:@"mj"] autorelease];
// 开启线程
[thread start];

假如 run:方法是这样的：

1
2
3
4

- (void)run:(NSString *)string {
     NSThread *current = [NSThread currentThread];
     NSLog(@"执行了 run:方法-参数：%@，当前线程：%@", string, current);
}

打印结果为：

2013-04-18 21:40:33.102 thread[7542:3e13] 执行了 run:方法-参数：mj，当前线程：<NSThread: 0x889e8d0>{name = (null), num = 3}

可以发现，这条线程的 num 值为 3，说明不是主线程，主线程的 num 为 1

b.静态方法

1

+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;

1

[NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:@"mj"];

c.隐式创建线程

1

[self performSelectorInBackground:@selector(run:) withObject:@"mj"];

会隐式地创建一条新线程，并且在这条线程上调用 self 的 run:方法，以@”mj”为方法参数

暂停当前线程

1

[NSThread sleepForTimeInterval:2];

1
2

NSDate *date = [NSDate dateWithTimeInterval:2 sinceDate:[NSDate date]];  
[NSThread sleepUntilDate:date];

上面两种做法都是暂停当前线程 2 秒

线程的其他操作

a.在指定线程上执行操作

1

[self performSelector:@selector(run) onThread:thread withObject:nil waitUntilDone:YES];

• 上面代码的意思是在 thread 这条线程上调用 self 的 run 方法
• 最后的 YES 代表：上面的代码会阻塞，等 run 方法在 thread 线程执行完毕后，上面的代码才会通过

b.在主线程上执行操作

1

[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];  

在主线程调用 self 的 run 方法

c.在当前线程执行操作

1

[self performSelector:@selector(run) withObject:nil];

在当前线程调用 self 的 run 方法

优缺点

1. 优点： NSThread 比其他多线程方案较轻量级，更直观地控制线程对象
2. 缺点：需要自己管理线程的生命周期，线程同步。线程同步对数据的加锁会有一定的系统开销

备注：欢迎转载，但请一定注明出处！ http://blog.wangruofeng007.com

• 译自 Written by Richard Turton — on October 7, 2014
• 原文链接：http://www.raywenderlich.com/76341/use-nsoperation-nsoperationqueue-swift
• 译者@oneruofeng

Post info: Updated for Xcode 7.1 and Swift 2.1 – 1 January 2016
Update note: This tutorial was updated to iOS 8, Xcode 6.1 and Swift by Richard Turton.
Original post by Tutorial Team member Soheil Azarpour.

每个人都有点击一个按钮或者进入一些文本在 iOS 或者 Mac App 上的令人沮丧的经历，就是突然-WHAM，用户交互停止了响应。

在 Mac 上，你的用户开始盯着一个沙漏或者一个七彩的轮子开始旋转直到它们再次恢复 UI 交互为止。在一个 iOS app 中，用户期望 App 立即响应它们的触摸事件，无响应的 app 给人的感觉是笨重和缓慢，这样通常会导致收到差评。

保持你的 app 的可交互的状态说起来容易做起来难，一旦你的 app 需要执行不仅仅是少量的任务，事情很快就变得很复杂，我们并没有多少事件在主事件循环执行繁重的工作并且同时提供一个可以响应的 UI。

低级的开发者是怎样做的呢？解决方案就是把工作从主线程中移除通过并发。并发意味着你应用所有的操作同时执行在多个流（或者线程）中–这样的话用户界面就能保持响应的要执行的工作。

一种实现并发操作在 iOS 是通过 NSOperation 和 NSOperationQueue 这两个类。在这个教程中，你将学会怎样使用它们！你将从一个没有使用并发的 App 开始，所以它将出现的非常迟钝和无响应。然后你将重做你的应用给它们添加并发操作并且–希望–呈现一个更加响应良好的可交互界面给用户！

我们开始吧

这份样品工程的总的目标的就是展示一个滤镜处理过的图片的表视图。图片将从网络上下载，经过一个滤镜处理后，然后在表视图中显示。

下面是这个 app 模型的示意图

第一个版本尝试

下载你将在这个教程中使用的第一个版本的项目

注意：所以的图片来自 stock.xchng.。一下图片在数据源故意错误命名，以便这里有些例子是图片下载失败好处理失败的情况。

构建并且运行这个工程，最终你将看到这个 app 运行起来显示一列照片。尝试滚动这个列表，很痛苦，不是吗？

传统的相册，运行缓慢

所有的操作都发生在 ListViewController.swift 里，并且最主要的是发生在 tableView(_:cellForRowAtIndexPath:) 方法里。看一下那个方法和注释这里有两件相当集中的事情需要思考：

1. 从网络载入图片数据 。即使网络状况良好，app 将仍然必须等待直到下载完成了才能继续。
2. 使用Core Image给图片加滤镜。这个方法给图片应用一个深褐色的滤镜，假如你想了解更多关于 Core Image 滤镜的知识，请点击Beginning Core Image in Swift

还有，你将载入一系列图片请求从网络当它第一次被请求时:

1

lazy var photos = NSDictionary(contentsOfURL:dataSourceURL)

所有的工作发生在应用的主线程。由于主线程也负责用户交互，让它一直忙于从网络下载东西和给图片加滤镜消磨掉了响应中的 app。你可以通过使用 Xcode 的仪表测量视图获得这样一个快速的概述。你可以通过显示 调试导航 (Commnad+6)接入这个仪表视图,让后选择 CPU 当 app 正在运行的时候。

Xcode 的仪表视图表明，主线程的任务非常重

你会看到那些所有的长钉在 Thread 1 ，那就是 app 的主线程。更多详细的信息你可以运行 app 的 Instruments ,但是那个在 whole other tutorial :].中

是时候考虑怎样改善一下你的用户体验了！

任务，线程和进程

在你专研这篇教程之前，这里有一下技术上的慨念需要理一下，我将定义一些专用术语：

• 任务 ：一个简单单个的需要完成的工作
• 线程 ：操作系统提供的机制允许多个用户操作同时进行在一个应用中
• 进程 ：一个可执行的代码块，它可以由多个线程构成

注意：在 iOS 和 OS X 中，线程的功能由 POSIX 线程 API（或者 pthreads）实现，并且它使操作系统的一部分。而这个又是相当底层的东西，你将发现它很容易犯错误；或许关于线程最糟糕的事情是那些很难被发现的错误！

Foundation 框架包含了一个叫做 NSThread 的类，这让我们处理事情更容易，但是用 NSThread 管理多个线程仍是一件令人头疼的事情。 NSOperation 和 NSOperationQueue 是为了最大化简化处理多线程的更高级的类。

在这个图解中，你会看到进程，线程和任务之间的关系：

进程，线程和任务

正如你所见，一个进程可以包涵多个执行的线程，每个线程能够同时执行多个任务。

在这个图集中, thread 2 执行文件的读的工作，同时 thread 1 执行 UI 相关的代码。这和你应该怎样在 iOS 中构建你的代码（主线程执行任何和 UI 相关的工作，第二线程应当执行慢的或者长时间运行的耗时操作例如读取文件，接入网络等等）有点相似。

NSOperation vs. Grand Central Dispatch (GCD)

你应该听说过Grand Central Dispatch (GCD).。简单的来说， GCD 由语言的特征，运行时库和系统增强组成来提供一个在 iOS 和 OS X 多核硬件中支持并发系统并且综合的改良。假如你想了解更多关于 GCD 相关的知识，有可以阅读我们的Multithreading and Grand Central Dispatch on iOS for Beginners Tutorial。

NSOperation 和 NSOperationQueue 构建在GCD之上。普遍来说，苹果推荐使用最高级别抽象，当需要显示他们一些需要的测量工作时回到最底层。

下面是关于这两者的一些简单比较，将帮助你决定何时何地选择使用 GCD 或者 NSOperation ：

• GCD 是一个轻量级的方式来描述将要被并发执行的工作单元。你不必定制这个工作单元的时刻表；系统为你定制时刻表。在 blocks 中增加依赖是一件头疼的事情。取消或者暂停一个 block 来进行额外的工作为作为开发者的你！ :]

• NSOperation 和 GCD 相比增加了一些额外开支，但是你能够在各种操作之间增加依赖并且恢复，取消，暂停他们。

这个教程将使用 NSOperation ,因为你将处理一个列表为了好的表现并且由于它大量的消耗的资源你需要能够取消一个操作针对某个图片，假如用户已经将那张图片滚出屏幕。即使这些操作在后台线程，假如这里有一打事情在队列里等着它们去处理，这将表现得跟糟糕。

重构 App Model

是时候重构开始的非多线程的模型了！假如你仔细观察先前的模型，你会发现这里有三个可以被改进的线程受困区域。通过切割这三个区域让后把他们放在单独的线程里，主线程的压力将得到缓解并且能够保持和用户交互。

改进后的 model

为了摆脱你应用的瓶颈，你需要一个指定一个线程来响应你的用户时间，一个线程专注于下载资源和图片，一个线程执行图片滤镜操作。在新的模型中，app 从主线程启动让后载入一个空的表视图。同时，app 启动第二个线程开始下载数据资源。

一旦数据资源下载完成，你将通知表视图重新载入。这些事情必须在主线程完成，因为它涉及到用户界面相关的操作。从这一点来说，表视图知道有多少行，并且它知道他将显示图片的 URL 地址，但是她不知道它是否真的有图片！假如你立即开始下载所有的图片在这个点上，这可能导致效率极其低下，因为你不需要一次性把所有图片下载完！

为了让这个变得更好我们能够做什么？

一个更好的模型就是可交互的行在屏幕范围内可见时才开始下载图片。所以你的代码开始将询问表视图有多少行可见。因此，代码应该直到这里有一个未加滤镜的图片等待处理时才开始处理图片加滤镜操作。

为了使 app 更加快速响应，代码将要让图片一旦下载完毕立即显示。让后才开始进行图片加滤镜操作，让后更新 UI 界面来显示已经经过滤镜处理后的图片。下面的图标显示了这个过程的控制流：

Cotroll Flow

为了获得这些对象，你需要跟踪这张图片现在是否正在被下载，一旦完成下载，假如图片的滤镜被应用上。你需要跟跟踪每个操作的状态，它是否正在下载中或者执行滤镜操作，以便你能够取消，暂停或者恢复每个操作当用户滚动的时候。

Okey！ 现在你准备好开始码代码了！ :]

打开你下载的工程，添加一个新的Swift File到你的工程中命名为** PhotoOperations.swift**。添加下面代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class PendingOperations {
  lazy var downloadsInProgress = [NSIndexPath:NSOperation]()
  lazy var downloadQueue:NSOperationQueue = {
    var queue = NSOperationQueue()
    queue.name = "Download queue"
    queue.maxConcurrentOperationCount = 1
    return queue
    }()

  lazy var filtrationsInProgress = [NSIndexPath:NSOperation]()
  lazy var filtrationQueue:NSOperationQueue = {
    var queue = NSOperationQueue()
    queue.name = "Image Filtration queue"
    queue.maxConcurrentOperationCount = 1
    return queue
    }()
}

这回类包含了 2 个字典为了跟踪激活和正在进行中的下载和滤镜操作对表中的每一行，并且两个操作队列都有各自的操作类型。

所有的值被懒加载的方式创建，意味着他们不会被初始化知道他们第一次被接入。这样改善了你 app 的表现性能。

创建一个 NSOperationQueue 是非常简单的，正如你所见，给你的队列命名是非常有用的，因为名字会在仪器或者调速器中显示。 maxConcurrentOperationCount 在这里由于这个教程的缘故被设置成 1，是为了让你看到操作一个接一个完成。你可以离开这一部分允许队列决定他一次处理多少个操作–这样会进一步改善性能。

队列是怎样决定一次运行多少个操作的呢？这是一个非常好的问题！ :] 这取决于硬件。默认， NSOperationQueue 将要处理一写计算在屏幕背后，决定什么是最好的需要看代码是运行在某个具体的平台，和将载入的最大数量的线程数。

考虑到下面的例子，假设系统此时是空闲的，这里有很多资源可用，所以这个队列能够载入可能 8 条并发的线程。下一个时刻你运行程序，系统可能忙于其他不相关的正在抢夺资源的操作，这时队列就仅仅载入 2 个并发的线程。因为你已经设置了一个最大并发操作数，在这个 app 中一次只会进行一个操作。

注意：你可能想知道为什么你必须跟踪所有的激活的和正在进行中操作。队列有一个 operations 的方法，它将返回一个操作的数组，所有为什么不用它呢？在这个工程中这样做效果不是很好。你需要跟踪更表视图行数关联的操作，它可能会重复执行数组每次你需要一个的时候。把它们储存在一个字典中用 index path 来作为他的 key 方便快速和高效的查找。

是时候考虑下载和过滤操作了。添加下列代码到 PhotoOperations.swift: 文件的末尾：

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

class ImageDownloader: NSOperation {
  //1
  let photoRecord: PhotoRecord

  //2
  init(photoRecord: PhotoRecord) {
    self.photoRecord = photoRecord
  }

  //3
  override func main() {
    //4
    if self.cancelled {
      return
    }
    //5
    let imageData = NSData(contentsOfURL:self.photoRecord.url)

    //6
    if self.cancelled {
      return
    }

    //7
    if imageData?.length > 0 {
      self.photoRecord.image = UIImage(data:imageData!)
      self.photoRecord.state = .Downloaded
    }
    else
    {
      self.photoRecord.state = .Failed
      self.photoRecord.image = UIImage(named: "Failed")
    }
  }
}

NSOperation 是一个抽象类，为它的子类而设计。每个子类代表了一个特别的 任务 正如呈现在列表早期那样。

下面是上面代码每行注释到底发生了什么的说明：

1. 添加一个常量引用到和操作相关的 PhotoRecord 对象
2. 创建一个设计初始化方法允许 photo record 参数可以被传进来
3. main 是你在 NSOperation 子类中需要重写的方法，用来执行相关工作
4. 在启动开始前检查是否被取消，操作应该定期检查是否已经被取消在尝试长时间或密集的工作之前
5. 下载图片数据
6. 再次检查是否被取消
7. 假如这里有数据，创建一个图片对象然后把它添加到记录中，同时改变它的状态，假如这里没有数据，把这条记录标记成失败然后设置适当的图片

下一步，你将创建另一个操作来处理图片加滤镜的操作！添加下面的代码到 PhotoOperations.swift 文件末尾：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class ImageFiltration: NSOperation {
  let photoRecord: PhotoRecord

  init(photoRecord: PhotoRecord) {
    self.photoRecord = photoRecord
  }

  override func main () {
    if self.cancelled {
      return
    }

    if self.photoRecord.state != .Downloaded {
      return
    }

    if let filteredImage = self.applySepiaFilter(self.photoRecord.image!) {
      self.photoRecord.image = filteredImage
      self.photoRecord.state = .Filtered
    }
  }
}

除了你对图片应用滤镜（使用一个未实现的方法，因此编译 1 错误）而不是下载它之外，这个看起来和下载操作非常相像。

添加遗失的图片滤镜处理方法到 ImageFiltration 类中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

(image:UIImage) -> UIImage? {
  let inputImage = CIImage(data:UIImagePNGRepresentation(image))

  if self.cancelled {
    return nil
  }
  let context = CIContext(options:nil)
  let filter = CIFilter(name:"CISepiaTone")
  filter.setValue(inputImage, forKey: kCIInputImageKey)
  filter.setValue(0.8, forKey: "inputIntensity")
  let outputImage = filter.outputImage

  if self.cancelled {
    return nil
  }

  let outImage = context.createCGImage(outputImage, fromRect: outputImage.extent())
  let returnImage = UIImage(CGImage: outImage)
  return returnImage
}

图片添加滤镜操作使用先前 ListViewController 中相同的实现。已经把它移动到这里来了以至于它它能在后台的一个单独的操作中完成。再次强调，你应该非常频繁的检查取消操作；最佳实践是在进行任何耗时操作调用之前和之后。一旦加滤镜操作完成，你应该立即设置 photo record 实例的值。

很棒！现在你已经有了所有的工具和基础为了处理后台任务进程的操作。是时候回到控制器修改它以便能利用所有这些新的福利。

切换到 ListViewController.swift 文件，然后删除 lazy var photos 接口声明。添加下面声明：

1
2

var photos = [PhotoRecord]()
let pendingOperations = PendingOperations()

这些将持有一个数组的你在开始创建的 PhotoDetails 对象， PendingOperations 对象来管理操作。

添加一个下载 photos property 列表新的方法到类中：

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

func fetchPhotoDetails() {
  let request = NSURLRequest(URL:dataSourceURL!)
  UIApplication.sharedApplication().networkActivityIndicatorVisible = true

  NSURLConnection.sendAsynchronousRequest(request, queue: NSOperationQueue.mainQueue()) {response,data,error in
    if data != nil {
      let datasourceDictionary = NSPropertyListSerialization.propertyListWithData(data, options: Int(NSPropertyListMutabilityOptions.Immutable.rawValue), format: nil, error: nil) as! NSDictionary

      for(key : AnyObject,value : AnyObject) in datasourceDictionary {
        let name = key as? String
        let url = NSURL(string:value as? String ?? "")
        if name != nil && url != nil {
          let photoRecord = PhotoRecord(name:name!, url:url!)
          self.photos.append(photoRecord)
        }
      }

      self.tableView.reloadData()
    }

    if error != nil {
      let alert = UIAlertView(title:"Oops!",message:error.localizedDescription, delegate:nil, cancelButtonTitle:"OK")
      alert.show()
    }
    UIApplication.sharedApplication().networkActivityIndicatorVisible = false
  }
}

这个方法创建一个异步的网络请求，当完成的时候，将执行 completion block 在主线程。当下载完成 property list 的数据被萃取成一个 NSDictionary ,然后再次处理一个数组的 PhotoRecord 的对象。你不能直接使用这里的 NSOperation ,你应该在主线程中接入它使用 NSOperationQueue.mainQueue() 。

在 viewDidLoad 调用新方法

fetchPhotoDetails()

下一步找到 tableView(_:cellForRowAtIndexPath:) 然后替换它用下面的实现：

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

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
  let cell = tableView.dequeueReusableCellWithIdentifier("CellIdentifier", forIndexPath: indexPath) as! UITableViewCell

  //1
  if cell.accessoryView == nil {
    let indicator = UIActivityIndicatorView(activityIndicatorStyle: .Gray)
    cell.accessoryView = indicator
  }
  let indicator = cell.accessoryView as! UIActivityIndicatorView

  //2
  let photoDetails = photos[indexPath.row]

  //3
  cell.textLabel?.text = photoDetails.name
  cell.imageView?.image = photoDetails.image

  //4
  switch (photoDetails.state){
  case .Filtered:
    indicator.stopAnimating()
  case .Failed:
    indicator.stopAnimating()
    cell.textLabel?.text = "Failed to load"
  case .New, .Downloaded:
    indicator.startAnimating()
    self.startOperationsForPhotoRecord(photoDetails,indexPath:indexPath)
  }

  return cell
}

花点时间来通读注释区域下面的解释：

1. 为了给用户提供反馈，创建 UIActivityIndicatorView 让后把它设成 cell 的 accessory view。
2. 数据源包含 PhotoRecord 实例。抓取正确的数据基于当前行的 indexPath 。
3. cell 的文本标签总是一样的，图片被正确的设置在 PhotoRecord 中当它被处理的时候，以便你能够设置他们两者，而不管记录的状态。
4. 检查记录，正确的设置 activity indicator 和文本，然后开始操作（暂时还没实现）

你可以移除 applySepiaFilter 的实现，因为那个将不再被调用了，添加下面的方法到类中来开始操作：

1
2
3
4
5
6
7
8
9
10

func startOperationsForPhotoRecord(photoDetails: PhotoRecord, indexPath: NSIndexPath){
  switch (photoDetails.state) {
  case .New:
    startDownloadForRecord(photoDetails, indexPath: indexPath)
  case .Downloaded:
    startFiltrationForRecord(photoDetails, indexPath: indexPath)
  default:
    NSLog("do nothing")
  }
}

这里，你将传递一个 PhotoRecord 类型的实例带有它的 index path 。
依据 photo record 的状态，你选开始进行下载还是加滤镜的步骤。

注意：下载图片和给图片加滤镜的方法分开实现，因为这里有可能出现当一个图片正在被下载，用户可能把它滚开了，这样你就不必对它应用滤镜操作。当下一次用户又来到相同的哪行时，你不必重新下载图片；你只需对它应用
图片滤镜即可！ Efficiency rocks! :]

现在你需要实现你在上面调用的方法。记住你创建的自定义的类， PendingOperations ,保持跟踪操作；现在实际上你可以使用它了！添加下面的方法到类中：

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

func startDownloadForRecord(photoDetails: PhotoRecord, indexPath: NSIndexPath){
  //1
  if let downloadOperation = pendingOperations.downloadsInProgress[indexPath] {
    return
  }

  //2
  let downloader = ImageDownloader(photoRecord: photoDetails)
  //3
  downloader.completionBlock = {
    if downloader.cancelled {
      return
    }
    dispatch_async(dispatch_get_main_queue(), {
      self.pendingOperations.downloadsInProgress.removeValueForKey(indexPath)
      self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: .Fade)
    })
  }
  //4
  pendingOperations.downloadsInProgress[indexPath] = downloader
  //5
  pendingOperations.downloadQueue.addOperation(downloader)
}

func startFiltrationForRecord(photoDetails: PhotoRecord, indexPath: NSIndexPath){
  if let filterOperation = pendingOperations.filtrationsInProgress[indexPath]{
    return
  }

  let filterer = ImageFiltration(photoRecord: photoDetails)
  filterer.completionBlock = {
    if filterer.cancelled {
      return
    }
    dispatch_async(dispatch_get_main_queue(), {
      self.pendingOperations.filtrationsInProgress.removeValueForKey(indexPath)
      self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: .Fade)
      })
  }
  pendingOperations.filtrationsInProgress[indexPath] = filterer
  pendingOperations.filtrationQueue.addOperation(filterer)
}

Okey!下面是一个快速列表来帮助你立即上面的代码到底做了什么：

1. 首先，检查特定的 indexPath 来看这里是否已经有一个操作在 downloadsInProgress 中。假如有，忽略它。
2. 假如没有，通过 designated initializer 创建一个 ImageDownloader 实例
3. 添加一个当操作完成时执行的完成 block。这是最好的地方让你其余的应用知道一个操作已经完成。注意完成 block 必须被执行即使这个操作被取消，这相当的重要，所以你需要使用 GCD 来触发重新载入表视图在主线程。
4. 添加操作到 downloadsInProgress 中来保持跟踪一些事情。
5. 添加操作到下载队列中。这是你实际获取这些操作开始运行的方法–队列需要注意的是一旦你添加了操作它就会执行。

过滤图片的方法遵循下面相同的类型，除了它使用 ImageFiltration 和 filtrationsInProgress 来跟踪操作。作为经验，你应该尝试不要重复这个区域的代码 :]

你做到了！你的工程完成了。构建让后运行看有什么改进在操作上！当你滚动表视图的时候，app 并没有停止，还是像它们变得可见一样继续下载图片和给图片加滤镜操作。

原来的图片，现在可以滚动了

是不是很酷？你能看到随做你的进步让你的应用更易于响应能做出的努力 –对用户来说更有趣！

细微的调整

你已经随着这个教程走过漫长的路！你的小项目现在反应灵敏表明了在原来的版本基础上有很多改进。然而，这里任然有一些遗留的细节我们需要考虑。你是想成为一名伟大的程序员，而不仅仅是一名优秀的程序员！

你可能已经注意到了当你滚动表视图时，那些离屏的 cell 仍然在处理下载和给图片加滤镜的操作。假如你快速滚动，app 将忙于下载和给图片处理滤镜的操作，在列表中从最前面甚至到不可见的地方。理想的情况下 app 应该对离开屏幕的 cells 就是现在不可见的取消滤镜操作。

难道你没有把取消的规定放进你的代码里？ 是的，你做了–现在你应该充分利用它们！:]

回到 Xcode，让后打开 ListViewController.swift 文件。去到 tableView(_:cellForRowAtIndexPath:) 方法的实现，封装 startOperationsForPhotoRecord 调用在一个 if 条件向下面的：

1
2
3

if (!tableView.dragging && !tableView.decelerating) {
  self.startOperationsForPhotoRecord(photoDetails, indexPath: indexPath)
}

你需要告诉表视图开始操作仅仅当表视图没有滚动的时候。这实际上是 UIScrollView 的接口，由于 UITableView 是 UIScrollView 的子类，你自动继承了这些接口。

下一步，添加到下面 UIScrollView 代理方法的实现到类中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

override func scrollViewWillBeginDragging(scrollView: UIScrollView) {
  //1
  suspendAllOperations()
}

override func scrollViewDidEndDragging(scrollView: UIScrollView, willDecelerate decelerate: Bool) {
  // 2
  if !decelerate {
    loadImagesForOnscreenCells()
    resumeAllOperations()
  }
}

override func scrollViewDidEndDecelerating(scrollView: UIScrollView) {
  // 3
  loadImagesForOnscreenCells()
  resumeAllOperations()
}

快速走查上面的代码显示在下面：

1. 当用户开始滚动，你想暂停所有的操作让后看看用户想看到什么。你将要实现 suspendAllOperations 在一会儿工夫。
2. 假如 decelerate 的值是 false ,那就意味着停止拖拽表视图，因此你想恢复暂停的，因为 cell 离开屏幕取消的操作，启动在屏幕内 cells 的操作。你将要一起实现 loadImagesForOnscreenCells 和 resumeAllOperations 。
3. 代理方法告诉你表视图已经停止滚动，所以你将做和#2 条相同的处理。

现在，添加下面这些遗失的方法的实现到 ListViewController.swift :

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

func suspendAllOperations () {
  pendingOperations.downloadQueue.suspended = true
  pendingOperations.filtrationQueue.suspended = true
}

func resumeAllOperations () {
  pendingOperations.downloadQueue.suspended = false
  pendingOperations.filtrationQueue.suspended = false
}

func loadImagesForOnscreenCells () {
  //1
  if let pathsArray = tableView.indexPathsForVisibleRows() {
    //2
    var allPendingOperations = Set(pendingOperations.downloadsInProgress.keys.array)
    allPendingOperations.unionInPlace(pendingOperations.filtrationsInProgress.keys.array)

    //3
    var toBeCancelled = allPendingOperations
    let visiblePaths = Set(pathsArray as! [NSIndexPath])
    toBeCancelled.subtractInPlace(visiblePaths)

    //4
    var toBeStarted = visiblePaths
    toBeStarted.subtractInPlace(allPendingOperations)

    // 5
    for indexPath in toBeCancelled {
      if let pendingDownload = pendingOperations.downloadsInProgress[indexPath] {
        pendingDownload.cancel()
      }
      pendingOperations.downloadsInProgress.removeValueForKey(indexPath)
      if let pendingFiltration = pendingOperations.filtrationsInProgress[indexPath] {
        pendingFiltration.cancel()
      }
      pendingOperations.filtrationsInProgress.removeValueForKey(indexPath)
    }

    // 6
    for indexPath in toBeStarted {
      let indexPath = indexPath as NSIndexPath
      let recordToProcess = self.photos[indexPath.row]
      startOperationsForPhotoRecord(recordToProcess, indexPath: indexPath)
    }
  }
}

suspendAllOperations 和 resumeAllOperations 有一个简单的实现。 NSOperationQueues 能够被暂停，通过设置 suspended 接口为 true 。这将暂停队列里面的所有操作–你不能单独暂停一个操作。

loadImagesForOnscreenCells 有一点小复杂。这里发生了什么事？

1. 以一个包含了现在表视图可见的 index paths 的数组开始开始
2. 构造一个所有进行中的操作的集合通过结合所有在下载的进度+所有在处理滤镜的进度。
3. 构造一个 index paths 集合用来取消操作。开始所有的操作，然后移除可见行的 index paths ，这样讲留下一个离开屏幕的行正在执行的操作集合
4. 构造一个 index paths 集合，需要操作启动，用所有可见行的 index paths 启动，让后移除它们中在进行的操作。
5. 遍历那些被取消的操作，取消它们，然后移除它们的引用从 PendingOperations 。
6. 遍历那些将要开始的操作，然后对他们每个调用 startOperationsForPhotoRecord 。

构建运行然后你发现一个更流畅，资源管理德更好的应用！给你自己一轮掌声！

原来的相册，载入东西一次一个

注意到当你完成滚动表视图，在可见区域行的 cell 的图片立即开始处理。

何去何从？

这里是completed version of the project。

注意：此教程写于 Update 17 April 2015: Updated for Xcode 6.3 and Swift 1.2 ,现在 Swift 最新版本 2.1 使用 Xcode7+以上编辑会报错，这里打包一个新语法修改版completed fixed version of the project。

假如你完成这个工程应该花时间来真正理解它，恭喜你！你可以认为你自己是一位更有价值 iOS 开发者了比起在教程刚开始的时候！大多数开发的公司是非常幸运的有一个或者两个人正在知道这个东西。

当时请当心 – 像多层嵌套的 blocks,不必要的使用多线程可能让一个工程变得难以理解对维护你代码的人来说。线程可能引入一些难以捉摸的 bugs，将永远不出现知道你网络非常慢，或者代码运行在一个更快（或更慢）的设备上，或一个不同数量的核的芯片上时。小心测试，尽量使用 Instruments （或者你自己的观察）来确定引入多线程真的有很大改进。

一个有用的特征使用操作时在这里没涉及到就是依赖（ dependency ）。你可以给一个操作添加一个或者更多的操作的依赖。这个操作不会开始直到它所有依赖的操作完成时。例如：

1
2
3
4
5
6

// MyDownloadOperation is a subclass of NSOperation
let downloadOperation = MyDownloadOperation()
// MyFilterOperation  is a subclass of NSOperation
let filterOperation = MyFilterOperation()

filterOperation.addDependency(downloadOperation)

移除依赖：

1

filterOperation.removeDependency(downloadOperation)

这个工程是否能使用依赖简化呢？把你学到的新技能用起来试一试 ：]
有件非常重要的事需要注意的就是一个依赖操作将仍然启动假如它依赖的操作被取消，还有它将自然完成。你需要牢记在心。

假如你有任何评论或者问题关于这个教程或者 NSOperations ,请加Pull request。

译者注：欢迎转载，但请一定注明出处！ http://blog.wangruofeng007.com

本文目录

• 前言
• NSInvocationOperation
• NSBlokcOperation
• NSOperation的其他用法
• 自定义NSOperation
• 参考资料

前言

1.虽然NSThread也可以实现多线程编程，但是需要我们去管理线程的生命周期，还要考虑线程同步、加锁问题，造成一些性能上的开销。我们也可以配合使用NSOperation和NSOperationQueue实现多线程编程，实现步骤大致是这样的

• 先将需要执行的操作封装到一个NSOperation对象中
• 然后将NSOperation对象添加到NSOperationQueue中
• 系统会自动将NSOperation中封装的操作放到一条新线程中执行在此过程中，我们根本不用考虑线程的生命周期、同步、加锁等问题下面列举一个应用场景，比如微博的粉丝列表：

每一行的头像肯定要从新浪服务器下载图片后才能显示的，而且是需要异步下载。这时候你就可以把每一行的图片下载操作封装到一个NSOperation对象中，上面有6行，所以要创建6个NSOperation对象，然后添加到NSOperationQueue中，分别下载不同的图片，下载完毕后，回到对应的行将图片显示出来。

2 .默认情况下，NSOperation并不具备封装操作的能力，必须使用它的子类，使用NSOperation子类的方式有3种：

• NSInvocationOperation
• NSBlockOperation
• 自定义子类继承NSOperation，实现内部相应的方法

这讲先介绍如何用NSOperation封装一个操作，后面再结合NSOperationQueue来使用。

NSInvocationOperation

1
2

NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run:) object:@"mj"];
[operation start];

• 第1行初始化了一个NSInvocationOperation对象，它是基于一个对象和selector来创建操作
• 第2行调用了start方法，紧接着会马上执行封装好的操作，也就是会调用self的run:方法，并且将@”mj”作为方法参数
• 这里要注意：默认情况下，调用了start方法后并不会开一条新线程去执行操作，而是在当前线程同步执行操作。只有将operation放到一个NSOperationQueue中，才会异步执行操作。

NSBlockOperation

a.同步执行一个操作

1
2
3
4
5

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^(){
         NSLog(@"执行了一个新的操作");
 }];
  // 开始执行任务
[operation start];

• 第1行初始化了一个NSBlockOperation对象，它是用一个Block来封装需要执行的操作
• 第2行调用了start方法，紧接着会马上执行Block中的内容
• 这里还是在当前线程同步执行操作，并没有异步执行

b.并发执行多个操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^(){
　　NSLog(@"执行第1次操作，线程：%@", [NSThread currentThread]);
}];

[operation addExecutionBlock:^() {
　　NSLog(@"又执行了1个新的操作，线程：%@", [NSThread currentThread]);
}];

[operation addExecutionBlock:^() {
　　NSLog(@"又执行了1个新的操作，线程：%@", [NSThread currentThread]);
}];

[operation addExecutionBlock:^() {
　　NSLog(@"又执行了1个新的操作，线程：%@", [NSThread currentThread]);
}];

// 开始执行任务
[operation start];

• 第1行初始化了一个NSBlockOperation对象

• 分别在第5、9、13行通过addExecutionBlock:方法添加了新的操作，包括第1行的操作，一共封装了4个操作

• 在第18行调用start方法后，就会并发地执行这4个操作，也就是会在不同线程中执行

    1 2013-02-02 21:38:46.102 thread[4602:c07] 又执行了1个新的操作，线程：<NSThread: 0x7121d50>{name = (null), num = 1}
    2 2013-02-02 21:38:46.102 thread[4602:3f03] 又执行了1个新的操作，线程：<NSThread: 0x742e1d0>{name = (null), num = 5}
    3 2013-02-02 21:38:46.102 thread[4602:1b03] 执行第1次操作，线程：<NSThread: 0x742de50>{name = (null), num = 3}
    4 2013-02-02 21:38:46.102 thread[4602:1303] 又执行了1个新的操作，线程：<NSThread: 0x7157bf0>{name = (null), num = 4}
  

可以看出，每个操作所在线程的num值都不一样，说明是不同线程

NSOperation的其他用法

a.取消操作

operation开始执行之后, 默认会一直执行操作直到完成，我们也可以调用cancel方法中途取消操作

[operation cancel];

b.在操作完成后做一些事情

如果想在一个NSOperation执行完毕后做一些事情，就调用NSOperation的setCompletionBlock方法来设置想做的事情

operation.completionBlock = ^() {
    NSLog(@"执行完毕");
};

当operation封装的操作执行完毕后，就会回调Block里面的内容

自定义NSOperation

如果NSInvocationOperation和NSBlockOperation不能满足需求，我们可以直接新建子类继承NSOperation，并添加任何需要执行的操作。如果只是简单地自定义NSOperation，只需要重载-(void)main这个方法，在这个方法里面添加需要执行的操作。

下面写个子类DownloadOperation来下载图片

a.继承NSOperation，重写main方法

DownloadOperation.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#import <Foundation/Foundation.h>
@protocol DownloadOperationDelegate;

@interface DownloadOperation : NSOperation
// 图片的url路径
@property (nonatomic, copy) NSString *imageUrl;
// 代理
@property (nonatomic, assign) id<DownloadOperationDelegate> delegate;

- (id)initWithUrl:(NSString *)url delegate:(id<DownloadOperationDelegate>)delegate;
@end

// 图片下载的协议
@protocol DownloadOperationDelegate <NSObject>
- (void)downloadFinishWithImage:(UIImage *)image;
@end

DownloadOperation.m

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

#import "DownloadOperation.h"

@implementation DownloadOperation
@synthesize delegate = _delegate;
@synthesize imageUrl = _imageUrl;

// 初始化
- (id)initWithUrl:(NSString *)url delegate:(id<DownloadOperationDelegate>)delegate {
    if (self = [super init]) {
        self.imageUrl = url;
        self.delegate = delegate;
    }
    return self;
}
// 释放内存
- (void)dealloc {
    [super dealloc];
    [_imageUrl release];
}

// 执行主任务
- (void)main {
    // 新建一个自动释放池，如果是异步执行操作，那么将无法访问到主线程的自动释放池
    @autoreleasepool {
        // ....
    }
}
@end

• 在第22行重载了main方法，等会就把下载图片的代码写到这个方法中
• 如果这个DownloadOperation是在异步线程中执行操作，也就是说main方法在异步线程调用，那么将无法访问主线程的自动释放池，所以在第24行创建了一个属于当前线程的自动释放池

b.正确响应取消事件

• 默认情况下，一个NSOperation开始执行之后，会一直执行任务到结束，就比如上面的DownloadOperation，默认会执行完main方法中的所有代码
• NSOperation提供了一个cancel方法，可以取消当前的操作。
• 如果是自定义NSOperation的话，需要手动处理这个取消事件。比如，一旦调用了cancel方法，应该马上终止main方法的执行，并及时回收一些资源。
• 处理取消事件的具体做法是：在main方法中定期地调用isCancelled方法检测操作是否已经被取消，也就是说是否调用了cancel方法，如果返回YES，表示已取消，则立即让main方法返回。
• 以下地方可能需要调用isCancelled方法:
  1. 在执行任何实际的工作之前，也就是在main方法的开头。因为取消可能发生在任何时候，甚至在operation执行之前。
  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
26
27
28
29

- (void)main {
    // 新建一个自动释放池，如果是异步执行操作，那么将无法访问到主线程的自动释放池
    @autoreleasepool {
        if (self.isCancelled) return;

        // 获取图片数据
        NSURL *url = [NSURL URLWithString:self.imageUrl];
        NSData *imageData = [NSData dataWithContentsOfURL:url];

        if (self.isCancelled) {
            url = nil;
            imageData = nil;
            return;
        }

        // 初始化图片
        UIImage *image = [UIImage imageWithData:imageData];

        if (self.isCancelled) {
            image = nil;
            return;
        }

        if ([self.delegate respondsToSelector:@selector(downloadFinishWithImage:)]) {
            // 把图片数据传回到主线程
            [(NSObject *)self.delegate performSelectorOnMainThread:@selector(downloadFinishWithImage:) withObject:image waitUntilDone:NO];
        }
    }
}

• 在第4行main方法的开头就先判断operation有没有被取消。如果被取消了，那就没有必要往下执行了
• 经过第8行下载图片后，在第10行也需要判断操作有没有被取消
• 总之，执行了一段比较耗时的操作之后，都需要判断操作有没有被取消
• 图片下载完毕后，在第26行将图片数据传递给了代理(delegate)对象

参考资料

• NSHipster 的NSOperation
• 雷纯锋的博客的《iOS 并发编程之 Operation Queues》
• objc的并发编程指南《Concurrent Programming》
• StackOverflow: NSOperation vs. Grand Central Dispatch
• Blog: When to use NSOperation vs. GCD

备注：欢迎转载，但请一定注明出处！ http://blog.wangruofeng007.com