Zhixingheyi

定制Manjaro

mc.liuxuan@gmail.com (Foredoomed) — Thu, 08 Feb 2018 19:14:00 +0800

首先官网下载Manjaro的ISO文件，然后用rufus将镜像写入U盘再安装。

0. 切换中国源

$ sudo pacman-mirrors -c China
$ sudo pacman-optimize && sync
$ sudo pacman -Syyu

1. 安装archlinuxcn-keyring

$ sudo pacman -S archlinuxcn-keyring

如果安装失败就执行：

$ sudo pacman -Syu haveged
$ sudo systemctl start haveged
$ sudo systemctl enable haveged
$ sudo rm -rf /etc/pacman.d/gnupg
$ sudo pacman-key --init
$ sudo pacman-key --populate archlinux
$ sudo pacman -S archlinuxcn-keyring
$ sudo pacman-key --populate archlinuxcn
$ sudo pacman -Syy && sudo pacman -S archlinuxcn-keyring

2. 安装yaourt和pacaur

$ sudo pacman -S yaourt pacaur

3. 安装fish shell

$ sudo pacman -S fish
$ chsh -s /usr/bin/fish

4. 安装Mac主题

下载主题到~/.themes, 下载图标到~/.icons。然后在Tweak Tool中设置刚才下载的主题和图标。

用火焰图分析Java程序性能

mc.liuxuan@gmail.com (Foredoomed) — Thu, 08 Feb 2018 19:14:00 +0800

火焰图是一个非常好的性能分析工具，在火焰图上可以很直观的看到哪个方法执行的时间长，而这个方法就是可以优化的点。在生成火焰图之前需要收集JVM的运行时数据，我用的是一个叫async-profiler的工具。首先下载解压后进入目录执行make命令，执行完会生成build文件夹。然后执行chmod 777 *命令，让等会需要执行的文件能够被执行。

好了，现在开始收集数据。首先执行jcmd命令找到你要监控的Java程序的进程ID，打个比方1024。然后执行命令：

./profiler.sh -d 300 -o collapsed -f /tmp/collapsed.txt 1234

这个命令的含义是：收集进程ID为1234的程序执行数据300秒，保存到格式为collapsed，文件名为collapsed.txt的文件。等5分钟后，collapsed.txt文件就生成了，有了这个数据文件就可以生成火焰图了。首先下载火焰图工具FlameGraph，解压后进入目录并执行命令：

/flamegraph.pl --colors=java /tmp/collapsed.txt > collapsed.svg

等执行完后用浏览器打开collapsed.svg就可以看到火焰图了：

从上图可以看到iBatis的executeSelectKey方法占用了相当长的CPU时间，所以要考虑去掉insert语句里的selectKey标签。

定制Ubuntu

mc.liuxuan@gmail.com (Foredoomed) — Wed, 07 Feb 2018 19:14:00 +0800

0. 安装Flatabulous主题和图标

$ sudo add-apt-repository ppa:noobslab/themes 
$ sudo apt-get update 
$ sudo apt-get install flatabulous-theme

$ sudo add-apt-repository ppa:noobslab/icons 
$ sudo apt-get update 
$ sudo apt-get install ultra-flat-icons

1. 安装文泉驿微黑字体

$ sudo apt-get install fonts-wqy-microhei

2. 安装终端字体

先从这里下载字体，解压后进入目录执行：

$ ./install.sh

3. 安装浏览器

$ sudo apt-get install chromium-browser

或者

$ wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb 
$ sudo gdebi google-chrome-stable_current_amd64.deb

4. 安装Flash Player

$ sudo apt-get install pepperflashplugin-nonfree

如果安装失败，可以使用下面的命令重新安装：

$ sudo dpkg-reconfigure pepperflashplugin-nonfree

5. 安装多媒体解码器

$ sudo apt-get install ubuntu-restricted-extras

6. 安装rar工具

$ sudo apt-get install unace p7zip-rar sharutils rar arj lunzip lzip

7. 安装剪贴板管理器

$ sudo apt-get install glipper

或者

$ sudo apt-get install clipit

8. 修改日期格式

修改日期格式为12小时格式显示月份名称、日期和时间。在”使用自定义日期格式”的选框中填入

%B %e, %I:%M %p

9. 安装Guake

$ sudo apt-get install guake

Guake需要配置，以便在每次登陆时启动。系统设置 > 启动程序，然后点击添加/usr/bin/guake

10. 安装unity-tweak-tool

用这个工具设置刚才安装的主题，图标，字体等。

$ sudo apt-get install unity-tweak-tool

11. 安装gnome-tweak-tool

用这个工具设置开机启动项。

$ sudo apt-get install gnome-tweak-tool

12. 安装fish shell

$ sudo apt-get install fish

13. 清除不必要的包

$ sudo apt-get autoremove

JavaScirpt的立即调用函数表达式

mc.liuxuan@gmail.com (Foredoomed) — Fri, 24 Oct 2014 21:31:00 +0800

说起JavaScript的立即调用的函数表达式(IIFE,Immediately-Invoked Function Expression),随便找一个JS框架或者类库就能看到它的存在。不过，最近在看Underscore.js源代码的时候又发现了一种新的写法，这马上激起了我的好奇心，所以这次就来好好地研究一下。

0. IIFE的写法

IIFE的作用就是限制函数和变量的作用域，常见写法有两种：

// Crockford's preference
(function() {
  console.log('Hello World.');
}());
 
(function() {
  console.log('Hello World.');
})();

为什么像这样写法就是IIFE了呢？这是因为JS解释器规定了小括号内的内容必定是表达式，而不可能是函数声明或其他。当然IIFE还可以写成下面这种形式：

!function(){ console.log('Hello World.'); }();
 
~function(){ console.log('Hello World.'); }();
 
-function(){ console.log('Hello World.'); }();
 
+function(){ console.log('Hello World.'); }();

上面这样写法也是IIFE的原因就是：!,~,-,+操作符后只能跟表达式，所以JS解释器就会把这些符号后的JS语句作为表示式处理。

不过在Underscore.js的源代码中，它的IIFE都不是上面的这些写法，而是写成这样的：

(function() {
 
}.call(this));

那么问题来了，Underscore.js为什么要这么写？要弄清楚这个问题，首先要搞清楚JS的函数调用。

1. JavaScirpt的函数调用

在ECMAScript 5.1规范中，关于函数调用部分是这样描述的：

15.3.4.4 Function.prototype.call (thisArg [ , arg1 [ , arg2, … ] ] ) When the call method is called on an object func with argument thisArg and optional arguments arg1, arg2 etc, the following steps are taken:

If IsCallable(func) is false, then throw a TypeError exception. Let argList be an empty List. If this method was called with more than one argument then in left to right order starting with arg1 append each argument as the last element of argList Return the result of calling the [[Call]] internal method of func, providing thisArg as the this value and argList as the list of arguments. The length property of the call method is 1.

NOTE The thisArg value is passed without modification as the this value. This is a change from Edition 3, where a undefined or null thisArg is replaced with the global object and ToObject is applied to all other values and that result is passed as the this value.

也就是说当调用函数类型的原型中的call函数时，第一个参数是thisValue，从第二个参数开始才是真正的函数的参数。例如：

function test(arg) {
  console.log(this + " is not " + arg);
}
 
test.call("foo", "bar") // foo is not bar

可以看到，在test函数被调用的时候，this的值被设置成了字符串foo，这也就验证了ECMAScript规范中的说明。讲了这么多有同学可能会有疑问，比如：我们自己调用函数肯定不会像这样调用原型里的call函数，而是直接用函数名加小括号的形式来完成函数的调用，那么call函数跟我们有什么关系呢。那接下来就来说明这两种调用方式的联系。

2. 一般函数调用与call函数的联系

我们先来定义一个函数，在这个函数里把this的值打印出来：

function test() {
  console.log(this);
}
 
test(); // Window

有趣的事情发生了，this没有作为参数传入，但是默认设置成了Window对象。联系ECMAScript中关于函数调用的规范，我们可以得到这样的推测：

在JS解释器执行函数的时候，会把形如function([args...])形式的函数调用转换成形如function.call(Window, [args...])的函数调用。

通过这样的转换，Window对象自然而然成为了函数默认的this的值。我们已经越来越接近真相了，下面来看一下成员函数中this的值是怎么样的。

3. 成员函数中的this

同样，首先定义一个类，然后在其中再定义一个成员函数：

var foo = {
  bar: function(arg) {
    console.log(arg);
    console.log(this);
  }
}

执行一下这个bar函数试试：

foo.bar("hello world"); // hello world Object

可以看到打印出来的this的值是一个Object，而这个Object对象的类型就是foo。那么跟一般函数的转换调用一样，成员函数在被调用的过程中也有一个转换的过程，这个过程就是：

foo.bar("hello world") => foo.bar.call(foo, "hello world")

到这里为止，关于JS函数调用的基础知识已经完备，现在回到本文的开头，来研究一下Underscore.js的IIFE写法。

4. Underscore.js的IIFE写法

Underscore.js的IIFE是这样写的：

(function(){
 
}.call(this));

这样就显示地指定call函数第一个参数为this，那么这个this的值是什么呢？如果这段代码是在浏览器里执行的话，this就是Window对象。但是如果是在服务器端执行的话，那么这个this就是上下文对象了。直接看代码：

function Foo() {
  this.foo = true;
 
  (function () {
      console.log(this); // Window
  })();
 
  (function () {
      console.log(this.foo); // undefined
  }());
 
  (function () {
      console.log(this.foo); // true
  }).call(this);
}
 
var foo = new Foo;

从上面的代码可以看出，这样的写法保证了在IIFE内部引用到的this值是这个IIFE在上下文当中的对象。

下拉刷新TableView

mc.liuxuan@gmail.com (Foredoomed) — Tue, 04 Mar 2014 23:09:00 +0800

下拉刷新自从被Tweetie创始人洛伦•布里切特(Loren Brichter)发明后，到现在可以说已经成为了TableView的标配功能。而我的RSS阅读器自然也不能例外，所以今天给它加上下拉刷新的功能。

首先选中TableViewController，然后打开Attribute Inspector面板，把Refreshing设置为Enabled，就像下面这样：

然后修改用来刷新TableView的loadFeed方法：

- (IBAction)loadFeed {
  [self.refreshControl beginRefreshing];
  AFHTTPRequestOperationManager *manager =
      [AFHTTPRequestOperationManager manager];

  AFHTTPResponseSerializer *responseSerializer =
      [AFHTTPResponseSerializer serializer];

  responseSerializer.acceptableContentTypes =
      [NSSet setWithObjects:@"application/atom+xml", nil];
  manager.responseSerializer = responseSerializer;

    [manager GET:URL parameters:nil
         success:^(AFHTTPRequestOperation *operation, id responseObject){
      NSData *response = (NSData *)responseObject;
      Feed *feed = [FeedParser parse:response];
      self.feed = feed;

      [self.tableView reloadData];
      [self.refreshControl endRefreshing];
    }
failure:
  ^(AFHTTPRequestOperation * operation, NSError * error) {
    NSLog(@"error: , %@", error);
  }];
}

与之前相比，在进入loadFeed方法之后就调用[self.refreshControl beginRefreshing]来显示转动的图片，然后在更新完成后再调用[self.refreshControl endRefreshing]来隐藏图片。还有就是把方法的返回类型由void变成了IBAction，这样做的目的是为了能够让Refresh Control和loadFeed方法直接关联。所以最后一步只需要在Document Outline中按住Ctrl键，拖动Refresh Control到loadFeed方法上就可以了。

运行程序看一下效果如何：

用AFNetworking为TableView异步加载数据

mc.liuxuan@gmail.com (Foredoomed) — Sat, 01 Mar 2014 10:58:00 +0800

为了让APP有更好的用户体验，所以是不能阻塞主线程的，而RSS的获取和解析都需要一定的时间，所以需要异步地来处理这些工作。

首先要准备一下UI部分。在stroyboard中，删除项目自动生成的ViewController，重新拖一个TableViewController上去，然后分别创建一个TableViewController类，继承UITableViewController，和TableCell类，继承UITableViewCell。

在TableViewController.h中定义一个Feed属性：

#import <UIKit/UIKit.h>
#import "Feed.h"

@interface TableViewController : UITableViewController
@property(nonatomic, retain) Feed *feed;
@end

在TableCell.h中定义一个Label属性：

#import <UIKit/UIKit.h>

@interface TableCell : UITableViewCell
@property(nonatomic, strong) IBOutlet UILabel *entryLabel;

@end

把解析RSS的代码放到TableViewController.m中：

- (void)loadFeed {
  AFHTTPRequestOperationManager *manager =
      [AFHTTPRequestOperationManager manager];

  AFHTTPResponseSerializer *responseSerializer =
      [AFHTTPResponseSerializer serializer];

  responseSerializer.acceptableContentTypes =
      [NSSet setWithObjects:@"application/atom+xml", nil];
  manager.responseSerializer = responseSerializer;

    [manager GET:URL parameters:nil
         success:^(AFHTTPRequestOperation *operation, id responseObject){
      NSData *response = (NSData *)responseObject;
      Feed *feed = [FeedParser parse:response];
      self.feed = feed;

      [self.tableView reloadData];
    }
failure:
  ^(AFHTTPRequestOperation * operation, NSError * error) {
    NSLog(@"error: , %@", error);
  }];
}

重写TableView的数据源方法：

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {

  // Return the number of sections.
  return 1;
}

- (NSInteger)tableView:(UITableView *)tableView
    numberOfRowsInSection:(NSInteger)section {

  // Return the number of rows in the section.
  return self.feed.entries.count;
}

- (UITableViewCell *)tableView:(UITableView *)tableView
         cellForRowAtIndexPath:(NSIndexPath *)indexPath {
  static NSString *CellIdentifier = @"TableCell";
  TableCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier
                                                    forIndexPath:indexPath];

  // Configure the cell...

  int row = [indexPath row];
  Entry *entry = [self.feed.entries objectAtIndex:row];
  cell.entryLabel.text = entry.title;

  return cell;
}

完成后的TableViewController.m就会是这样的：

#import "TableViewController.h"
#import "AFNetworking.h"
#import "Feed.h"
#import "FeedParser.h"
#import "Entry.h"
#import "TableCell.h"

@interface TableViewController ()

@end

static NSString *const URL = @"http://v2ex.com/index.xml";

@implementation TableViewController

- (void)loadFeed {
  AFHTTPRequestOperationManager *manager =
      [AFHTTPRequestOperationManager manager];

  AFHTTPResponseSerializer *responseSerializer =
      [AFHTTPResponseSerializer serializer];

  responseSerializer.acceptableContentTypes =
      [NSSet setWithObjects:@"application/atom+xml", nil];
  manager.responseSerializer = responseSerializer;

    [manager GET:URL parameters:nil
         success:^(AFHTTPRequestOperation *operation, id responseObject){
      NSData *response = (NSData *)responseObject;
      Feed *feed = [FeedParser parse:response];
      self.feed = feed;

      [self.tableView reloadData];
    }
failure:
  ^(AFHTTPRequestOperation * operation, NSError * error) {
    NSLog(@"error: , %@", error);
  }];
}

- (id)initWithStyle:(UITableViewStyle)style {
  self = [super initWithStyle:style];
  if (self) {
    // Custom initialization
  }
  return self;
}

- (void)viewDidLoad {
  [super viewDidLoad];

  // Uncomment the following line to preserve selection between presentations.
  // self.clearsSelectionOnViewWillAppear = NO;

  // Uncomment the following line to display an Edit button in the navigation
  // bar for this view controller.
  // self.navigationItem.rightBarButtonItem = self.editButtonItem;

  [self loadFeed];
}

- (void)didReceiveMemoryWarning {
  [super didReceiveMemoryWarning];
  // Dispose of any resources that can be recreated.
}

#pragma mark - Table view data source

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {

  // Return the number of sections.
  return 1;
}

- (NSInteger)tableView:(UITableView *)tableView
    numberOfRowsInSection:(NSInteger)section {

  // Return the number of rows in the section.
  return self.feed.entries.count;
}

- (UITableViewCell *)tableView:(UITableView *)tableView
         cellForRowAtIndexPath:(NSIndexPath *)indexPath {
  static NSString *CellIdentifier = @"TableCell";
  TableCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier
                                                    forIndexPath:indexPath];

  // Configure the cell...

  int row = [indexPath row];
  Entry *entry = [self.feed.entries objectAtIndex:row];
  cell.entryLabel.text = entry.title;

  return cell;
}

@end

最后运行看一下结果：

Objective-C中的锁及应用

mc.liuxuan@gmail.com (Foredoomed) — Wed, 26 Feb 2014 18:45:00 +0800

在多线程编程中，锁是非常重要的工具，而Objective-C提供了好几种不同类型的锁，下面就来看一下这些锁都是怎么用的。

0. POSIX Mutex Lock

Mutex lock也就是互斥锁，是Unix/Linux平台上提供的一套同步机制。互斥锁提供了三个函数，从函数名就可以知道他们的作用：

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

函数pthread_mutex_trylock和pthread_mutex_lock的功能完全一致，只不过前者在获取锁失败的情况下会立即返回，而后者则会一直阻塞在那里直到获取到锁为止。互斥锁的使用非常的简单，直接调用上面三个API就可以了：

pthread_mutex_t mutex;
void MyInitFunction()
{
    pthread_mutex_init(&mutex, NULL);
}
 
void MyLockingFunction()
{
    pthread_mutex_lock(&mutex);
    // Do work.
    pthread_mutex_unlock(&mutex);
}

1. NSLock

NSLock类使用的是POSIX线程来实现它的锁操作，而且需要注意的是必须在同一线程内发送unlock消息，否则会发生不确定的情况。NSLock不能被用来实现迭代锁，因为如果发生lock消息两次的话，整个线程将被永久锁住。

BOOL moreToDo = YES;
NSLock *theLock = [[NSLock alloc] init];
...
while (moreToDo) {
    /* Do another increment of calculation */
    /* until there’s no more to do. */
    if ([theLock tryLock]) {
        /* Update display used by all threads. */
        [theLock unlock];
    }
}

2. @synchronized

@synchronized是在Objective-C中最简单方法，只要有个Objective-C对象就可以完成线程同步操作。

- (void)myMethod:(id)anObj
{
    @synchronized(anObj)
    {
        // Everything between the braces is protected by the @synchronized directive.
    }
}

需要注意的是，@synchronized会隐式地添加异常处理代码，也就是当发生异常时会自动释放互斥锁，所以会有一定的性能损耗。

3. NSRecursiveLock

NSRecursiveLock类定义了可以被同一线程获取多次而不会造成死锁的锁。NSRecursiveLock可以被用在递归调用中，但是只有当多次获取的锁全部释放时，NSRecursiveLock才能被其他线程获取。

NSRecursiveLock *theLock = [[NSRecursiveLock alloc] init];
 
void MyRecursiveFunction(int value)
{
    [theLock lock];
    if (value != 0)
    {
        --value;
        MyRecursiveFunction(value);
    }
    [theLock unlock];
}
 
MyRecursiveFunction(5);

4. NSConditionLock

NSConditionLock定义了一个条件互斥锁，也就是当条件成立时就会获取到锁，反之就会释放锁。因为这个特性，条件锁可以被用在有特定顺序的处理流程中，比如生产者-消费者问题。

id condLock = [[NSConditionLock alloc] initWithCondition:NO_DATA];
 
// producer
while(true)
{
    [condLock lock];
    /* Add data to the queue. */
    [condLock unlockWithCondition:HAS_DATA];
}
 
// consumer
while (true)
{
    [condLock lockWhenCondition:HAS_DATA];
    /* Remove data from the queue. */
    [condLock unlockWithCondition:(isEmpty ? NO_DATA : HAS_DATA)];
 
    // Process the data locally.
}

条件锁的初始状态是NO_DATA，所以生产者线程在这个时候就会获取到锁，生产完成后再把状态设置为HAS_DATA；这时消费者线程发现条件变成HAS_DATA后就可以获取到锁，直到消费结束后再把状态设置成NO_DATA。

5. NSDistributedLock

NSDistributedLock是跨进程的分布式锁，底层是用文件系统实现的互斥锁。NSDistributedLock没有实现NSLocking协议，所以没有会阻塞线程的lock方法，取而代之的是非阻塞的tryLock方法。NSDistributedLock只有在锁持有者显式地释放后才会被释放，也就是说当持有锁的应用崩溃后，其他应用就不能访问受保护的共享资源了。

6. NSCondition

NSCondition类是互斥锁和条件锁的结合体，也就是一个线程在等待信号而阻塞时，可以被另外一个线程唤醒。需要注意的是，由于操作系统实现的差异，即使在代码中没有发送signal消息，线程也有可能被唤醒，所以需要增加谓词变量来保证程序的正确性。

[cocoaCondition lock];
while (timeToDoWork <= 0)
    [cocoaCondition wait];
 
timeToDoWork--;
 
// Do real work here.
 
[cocoaCondition unlock];

在其他线程中唤醒：

[cocoaCondition lock];
timeToDoWork++;
[cocoaCondition signal];
[cocoaCondition unlock];

7. POSIX Conditions

在Unix/Linux平台上也提供了一套条件互斥锁的API：

// 初始化
int pthread_cond_init (pthread_cond_t *cond, pthread_condattr_t *attr);
 
// 等待（会阻塞）
int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut);
 
// 定时等待
int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mut, const struct timespec *abstime);
 
// 唤醒
int pthread_cond_signal (pthread_cond_t *cond);
 
// 广播唤醒
int pthread_cond_broadcast (pthread_cond_t *cond);
 
// 销毁
int pthread_cond_destroy (pthread_cond_t *cond);

和NSCondition类一样，POSIX Conditions也需要和谓词配合使用以确保程序的正确性。

pthread_mutex_t mutex;
pthread_cond_t condition;
Boolean     ready_to_go = true;
 
void MyCondInitFunction()
{
    pthread_mutex_init(&mutex);
    pthread_cond_init(&condition, NULL);
}
 
void MyWaitOnConditionFunction()
{
    // Lock the mutex.
    pthread_mutex_lock(&mutex);
 
    // If the predicate is already set, then the while loop is bypassed;
    // otherwise, the thread sleeps until the predicate is set.
    while(ready_to_go == false)
    {
        pthread_cond_wait(&condition, &mutex);
    }
 
    // Do work. (The mutex should stay locked.)
 
    // Reset the predicate and release the mutex.
    ready_to_go = false;
    pthread_mutex_unlock(&mutex);
}
 
void SignalThreadUsingCondition()
{
    // At this point, there should be work for the other thread to do.
    pthread_mutex_lock(&mutex);
    ready_to_go = true;
 
    // Signal the other thread to begin work.
    pthread_cond_signal(&condition);
 
    pthread_mutex_unlock(&mutex);
}

参考资料

[1] Threading Programming Guide

Objective-C中Block的实现

mc.liuxuan@gmail.com (Foredoomed) — Tue, 25 Feb 2014 19:36:00 +0800

Block是苹果公司在OS X 10.6和iOS 4之后引入的Objective-C语言的扩展。由于Block的出现使得Objective-C拥有了编写类似函数式语言中闭包的能力，现在在许多开源类库中都可以看到Block被用作回调函数的情况。因为Objective-C是用C语言实现的，而C并不原生支持闭包，所以我感兴趣的是Block的底层是怎么实现的。

在Clang的Block Implementation Specification文档中可以找到编译后的Block的结构：

struct Block_literal_1 {
    void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct Block_descriptor_1 {
    unsigned long int reserved;         // NULL
        unsigned long int size;         // sizeof(struct Block_literal_1)
        // optional helper functions
        void (*copy_helper)(void *dst, void *src);     // IFF (1<<25)
        void (*dispose_helper)(void *src);             // IFF (1<<25)
        // required ABI.2010.3.16
        const char *signature;                         // IFF (1<<30)
    } *descriptor;
    // imported variables
};

可以看到在Block结构体中含有isa指针，这就证明了Block其实就是对象，并具有一般对象的所有功能。这个isa指针被初始化为_NSConcreteStackBlock或者_NSConcreteGlobalBlock类的地址。在没有开启ARC的情况下，如果Block中包含有局部变量则isa被初始化为前者，否则就被初始化为后者。而当ARC开启后，如果Block中包含有局部变量则isa被初始化为_NSConcreteMallocBlock，否则就被初始化为_NSConcreteGlobalBlock。invoke是一个函数指针，它指向的是Block被转换成函数的地址。最后的imported variables部分是Block需要访问的外部的局部变量，他们在编译就会被拷贝到Block中，这样一来Block就是成为一个闭包了。

在Clang的文档上有个Block的例子：

^ { printf("hello world\n"); }

上面这个Block会被编译成：

struct __block_literal_1 {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(struct __block_literal_1 *);
    struct __block_descriptor_1 *descriptor;
};
 
void __block_invoke_1(struct __block_literal_1 *_block) {
    printf("hello world\n");
}
 
static struct __block_descriptor_1 {
    unsigned long int reserved;
    unsigned long int Block_size;
} __block_descriptor_1 = { 0, sizeof(struct __block_literal_1), __block_invoke_1 };

最终Block就会变成：

struct __block_literal_1 _block_literal = {
     &_NSConcreteStackBlock,
     (1<<29), <uninitialized>,
     __block_invoke_1,
     &__block_descriptor_1
};

参考资料

[1] Objective-C Wiki
[2] Block Implementation Specification

Objective-C的对象模型

mc.liuxuan@gmail.com (Foredoomed) — Mon, 24 Feb 2014 19:49:00 +0800

Objective-C是一门面向对象，并且在C的基础上加入了Smalltalk式的消息机制而形成的编程语言，它主要被苹果公司用于开发Mac OS X和iOS操作系统。既然Objective-C是面向对象的编程语言，那么我感兴趣的就是对象在内存中是怎么组织和表示的，消息机制又是怎么实现的。

0.NSObject

NSObject类和Java中的Object类有点相似，都是所有一切类的父类，也就是根类。那么NSObject又是一个怎样的类呢。打开NSObject.h头文件就可以看到NSObject的源码：

@interface NSObject <NSObject>
{
    Class isa;
}

可以看到NSObject是实现了NSObject protocol的Interface，它里面只包含了一个类型为Class的isa属性。isa是『is a』的意思，连起来就是『is a class』，也就是说这个属性保存了有关类的信息。同样来看一下Class的源码，它被定义在objc.h头文件中：

typedef struct objc_class *Class;

Class是objcclass类型，objcclass被定义在objc-class.h：

struct objc_class {          
    struct objc_class *isa; 
    struct objc_class *super_class; 
    const char *name;       
    long version;
    long info;
    long instance_size;
    struct objc_ivar_list *ivars;
 
#if defined(Release3CompatibilityBuild)
    struct objc_method_list *methods;
#else
    struct objc_method_list **methodLists;
#endif
 
    struct objc_cache *cache;
    struct objc_protocol_list *protocols;
};

可以看到obj_class是一个结构体，它包含了所有运行时需要的有关类的信息，包括这个类的父类是什么类，实例变量，方法，协议等。有趣的是，obj_class中也有一个isa属性，那么它又指向哪里呢？它指向的是一个叫做metaclass的对象，并且类型也是obj_class。所以实例化一个类会有两个对象：本身和metaclass对象。这样做的目的是把实例方法的信息保存到自己本身的类中，而把类方法保存到metaclass类里。那么metaclass中的isa指向哪里呢？因为metaclass类是没有metaclass方法的，所有就不需要再多一个类来保存metaclass类的方法信息，因此，metaclass对象的isa指向自己，形成一个闭环结构。

1.消息机制

在Objective-C中，方法的调用和其他面向对象语言(例如Java)有点区别。在Java中的方法调用可以写成一般形式为：

object.method(argument);

但是在Objective-C里要这样写：

[object method:argument];

两者的区别是：Java的方法调用是直接调用实例对象的方法，而Objective-C则是发送消息一个消息。发送消息的目标在编译时是不知道的，而是在运行时决定。方法是由selector或者SEL确定的，也就是表示方法名的字符串。消息的接收对象不能保证一定会返回结果，当这种情况发生时就会抛出异常。

编译器会把发送消息的语句

[receiver message]

转换为：

objc_msgSend(receiver, selector, arg1, arg2, ...)

在objc_msgSend方法中做的是通过receiver和selector找到要调用的方法，这个方法的类型是IMP型的，然后就可以执行这个方法并把返回值返回出去。这里的IMP类型就是要调用方法的C语言实现，也就是一个C函数指针。

2.id

id被定义在objc.h中：

typedef struct objc_object {
    Class isa;
} *id;

可以看到id就是objc_object结构体，它包含了一个isa指针指向类的描述信息，这样的话id就可以用来动态描述类的类型了。

id的作用类似于Javascript中的var，也就是说用id关键字声明的变量在编译时并不知道其具体类型，而是在运行时决定。因为有id关键字的存在，所以Objective-C就不是单纯的面向对象语言，而是面向对象语言和动态语言的混合体，从这点来看Objective-C倒跟C#有点像。

参考资料

[1] Objective-C Wiki
[2] Concepts in Objective-C Programming: Object Modeling
[3] Objective-C Runtime Programming Guide

初试AFNetworking

mc.liuxuan@gmail.com (Foredoomed) — Sun, 23 Feb 2014 20:24:00 +0800

RSS还是要通过发送网络请求来获取的，Objective-C中的NSURLConnection类可以完成对网络的请求处理。但是还有一个更方便好用的开源网络库：AFNetworking。

首先创建一个RSSService类，然后再定义一个getRSS方法：

//
//  RSSService.h
//  vot
//
//  Created by Foredoomed on 2/23/14.
//  Copyright (c) 2014 Foredoomed. All rights reserved.
//

#import <Foundation/Foundation.h>

@class Feed;

@interface RSSService : NSObject

- (void *)getRSS;

@end

在实现类中用AFHTTPRequestOperationManager这个类发送GET请求：

//
//  RSSService.m
//  vot
//
//  Created by Foredoomed on 2/23/14.
//  Copyright (c) 2014 Foredoomed. All rights reserved.
//

#import "NetWorkService.h"
#import "AFNetworking.h"
#import "Feed.h"
#import "FeedParser.h"
#import "Entry.h"

static NSString *const URL = @"http://v2ex.com/index.xml";

@implementation RSSService

- (void)getRSS {
  AFHTTPRequestOperationManager *manager =
      [AFHTTPRequestOperationManager manager];

  AFHTTPResponseSerializer *responseSerializer =
      [AFHTTPResponseSerializer serializer];

  responseSerializer.acceptableContentTypes =
      [NSSet setWithObjects:@"application/atom+xml", nil];
  manager.responseSerializer = responseSerializer;

  [manager GET:URL parameters:nil
  success:^(AFHTTPRequestOperation *operation, id responseObject){
      NSData *data = (NSData *)responseObject;
      Feed *feed = [FeedParser parse:data];

      if (feed != nil) {
        for (Entry *entry in feed.entries) {
          NSLog(@"%@", entry.title);
        }
      }
    }
  failure:^(AFHTTPRequestOperation * operation, NSError * error) {
    NSLog(@"error: , %@", error);
  }];
}

@end

这里，AFHTTPRequestOperationManager发送的是异步请求，所以block中的代码执行会有时间差，这就好比Javascript中回调函数的存在。从试用的结果来看，AFNetworking对网络操作非常方便，以后再试试别的功能。