你有考虑过DeferClose()的风险吗

本文转载自微信公众号「Golang技术分享」，作者机器铃砍菜刀 。转载本文请联系Golang技术分享公众号。

10年积累的网站设计、网站制作经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先做网站后付款的网站建设流程，更有南浔免费网站建设让你可以放心的选择与我们合作。

作为一名 Gopher，我们很容易形成一个编程惯例：每当有一个实现了 io.Closer 接口的对象 x 时，在得到对象并检查错误之后，会立即使用 defer x.Close() 以保证函数返回时 x 对象的关闭 。以下给出两个惯用写法例子。

HTTP 请求

 
 
 
 
    
  
  
  
  
  1. 1resp, err := http.Get("https://golang.google.cn/") 
    2.   
  
  
  
  2. 2if err != nil { 
    3.   
  
  
  
  3. 3    return err 
    4.   
  
  
  
  4. 4} 
    5.   
  
  
  
  5. 5defer resp.Body.Close() 
    6.   
  
  
  
  6. 6// The following code: handle resp 
    7.

访问文件

 
 
 
 
    
  
  
  
  
  1. 1f, err := os.Open("/home/golangshare/gopher.txt") 
    2.   
  
  
  
  2. 2if err != nil { 
    3.   
  
  
  
  3. 3    return err 
    4.   
  
  
  
  4. 4} 
    5.   
  
  
  
  5. 5defer f.Close() 
    6.   
  
  
  
  6. 6// The following code: handle f 
    7.

存在问题

实际上，这种写法是存在潜在问题的。defer x.Close() 会忽略它的返回值，但在执行 x.Close() 时，我们并不能保证 x 一定能正常关闭，万一它返回错误应该怎么办?这种写法，会让程序有可能出现非常难以排查的错误。

那么，Close() 方法会返回什么错误呢?在 POSIX 操作系统中，例如 Linux 或者 maxOS，关闭文件的 Close() 函数最终是调用了系统方法 close()，我们可以通过 man close 手册，查看 close() 可能会返回什么错误

 
 
 
 
    
  
  
  
  
  1. 1ERRORS 
    2.   
  
  
  
  2. 2     The close() system call will fail if: 
    3.   
  
  
  
  3. 3 
    4.   
  
  
  
  4. 4     [EBADF]            fildes is not a valid, active file descriptor. 
    5.   
  
  
  
  5. 5 
    6.   
  
  
  
  6. 6     [EINTR]            Its execution was interrupted by a signal. 
    7.   
  
  
  
  7. 7 
    8.   
  
  
  
  8. 8     [EIO]              A previously-uncommitted write(2) encountered an 
    9.   
  
  
  
  9. 9                        input/output error. 
    10.

错误 EBADF 表示无效文件描述符 fd，与本文中的情况无关;EINTR 是指的 Unix 信号打断;那么本文中可能存在的错误是 EIO。

EIO 的错误是指未提交读，这是什么错误呢?

计算机存储层次结构

EIO 错误是指文件的 write() 的读还未提交时就调用了 close() 方法。

上图是一个经典的计算机存储器层级结构，在这个层次结构中，从上至下，设备的访问速度越来越慢，容量越来越大。存储器层级结构的主要思想是上一层的存储器作为低一层存储器的高速缓存。

CPU 访问寄存器会非常之快，相比之下，访问 RAM 就会很慢，而访问磁盘或者网络，那意味着就是蹉跎光阴。如果每个 write() 调用都将数据同步地提交到磁盘，那么系统的整体性能将会极度降低，而我们的计算机是不会这样工作的。当我们调用 write() 时，数据并没有立即被写到目标载体上，计算机存储器每层载体都在缓存数据，在合适的时机下，将数据刷到下一层载体，这将写入调用的同步、缓慢、阻塞的同步转为了快速、异步的过程。

这样看来，EIO 错误的确是我们需要提防的错误。这意味着如果我们尝试将数据保存到磁盘，在 defer x.Close() 执行时，操作系统还并未将数据刷到磁盘，这时我们应该获取到该错误提示(只要数据还未落盘，那数据就没有持久化成功，它就是有可能丢失的，例如出现停电事故，这部分数据就永久消失了，且我们会毫不知情)。但是按照上文的惯例写法，我们程序得到的是 nil 错误。

解决方案

我们针对关闭文件的情况，来探讨几种可行性改造方案

  • 第一种方案，那就是不使用 defer
 
 
 
 
    
  
  
  
  
  1.  1func solution01() error { 
    2.   
  
  
  
  2.  2    f, err := os.Create("/home/golangshare/gopher.txt") 
    3.   
  
  
  
  3.  3    if err != nil { 
    4.   
  
  
  
  4.  4        return err 
    5.   
  
  
  
  5.  5    } 
    6.   
  
  
  
  6.  6 
    7.   
  
  
  
  7.  7    if _, err = io.WriteString(f, "hello gopher"); err != nil { 
    8.   
  
  
  
  8.  8        f.Close() 
    9.   
  
  
  
  9.  9        return err 
    10.   
  
  
  
  10. 10    } 
    11.   
  
  
  
  11. 11 
    12.   
  
  
  
  12. 12    return f.Close() 
    13.   
  
  
  
  13. 13} 
    14.

这种写法就需要我们在 io.WriteString 执行失败时，明确调用 f.Close() 进行关闭。但是这种方案，需要在每个发生错误的地方都要加上关闭语句 f.Close()，如果对 f 的写操作 case 较多，容易存在遗漏关闭文件的风险。

  • 第二种方案是，通过命名返回值 err 和闭包来处理
 
 
 
 
    
  
  
  
  
  1.  1func solution02() (err error) { 
    2.   
  
  
  
  2.  2    f, err := os.Create("/home/golangshare/gopher.txt") 
    3.   
  
  
  
  3.  3    if err != nil { 
    4.   
  
  
  
  4.  4        return 
    5.   
  
  
  
  5.  5    } 
    6.   
  
  
  
  6.  6 
    7.   
  
  
  
  7.  7    defer func() { 
    8.   
  
  
  
  8.  8        closeErr := f.Close() 
    9.   
  
  
  
  9.  9        if err == nil { 
    10.   
  
  
  
  10. 10            err = closeErr 
    11.   
  
  
  
  11. 11        } 
    12.   
  
  
  
  12. 12    }() 
    13.   
  
  
  
  13. 13 
    14.   
  
  
  
  14. 14    _, err = io.WriteString(f, "hello gopher") 
    15.   
  
  
  
  15. 15    return 
    16.   
  
  
  
  16. 16} 
    17.

这种方案解决了方案一中忘记关闭文件的风险，如果有更多 if err !=nil 的条件分支，这种模式可以有效降低代码行数。

  • 第三种方案是，在函数最后 return 语句之前，显示调用一次 f.Close()
 
 
 
 
    
  
  
  
  
  1.  1func solution03() error { 
    2.   
  
  
  
  2.  2    f, err := os.Create("/home/golangshare/gopher.txt") 
    3.   
  
  
  
  3.  3    if err != nil { 
    4.   
  
  
  
  4.  4        return err 
    5.   
  
  
  
  5.  5    } 
    6.   
  
  
  
  6.  6    defer f.Close() 
    7.   
  
  
  
  7.  7 
    8.   
  
  
  
  8.  8    if _, err := io.WriteString(f, "hello gopher"); err != nil { 
    9.   
  
  
  
  9.  9        return err 
    10.   
  
  
  
  10. 10    } 
    11.   
  
  
  
  11. 11 
    12.   
  
  
  
  12. 12    if err := f.Close(); err != nil { 
    13.   
  
  
  
  13. 13        return err 
    14.   
  
  
  
  14. 14    } 
    15.   
  
  
  
  15. 15    return nil 
    16.   
  
  
  
  16. 16} 
    17.

这种解决方案能在 io.WriteString 发生错误时，由于 defer f.Close() 的存在能得到 close 调用。也能在 io.WriteString 未发生错误，但缓存未刷新到磁盘时，得到 err := f.Close() 的错误，而且由于 defer f.Close() 并不会返回错误，所以并不担心两次 Close() 调用会将错误覆盖。

  • 最后一种方案是，函数 return 时执行 f.Sync()
 
 
 
 
    
  
  
  
  
  1.  1func solution04() error { 
    2.   
  
  
  
  2.  2    f, err := os.Create("/home/golangshare/gopher.txt") 
    3.   
  
  
  
  3.  3    if err != nil { 
    4.   
  
  
  
  4.  4        return err 
    5.   
  
  
  
  5.  5    } 
    6.   
  
  
  
  6.  6    defer f.Close() 
    7.   
  
  
  
  7.  7 
    8.   
  
  
  
  8.  8    if _, err = io.WriteString(f, "hello world"); err != nil { 
    9.   
  
  
  
  9.  9        return err 
    10.   
  
  
  
  10. 10    } 
    11.   
  
  
  
  11. 11 
    12.   
  
  
  
  12. 12    return f.Sync() 
    13.   
  
  
  
  13. 13} 
    14.

由于调用 close() 是最后一次获取操作系统返回错误的机会，但是在我们关闭文件时，缓存不一定被会刷到磁盘上。那么，我们可以调用 f.Sync() (其内部调用系统函数 fsync )强制性让内核将缓存持久到磁盘上去。

 
 
 
 
    
  
  
  
  
  1.  1// Sync commits the current contents of the file to stable storage. 
    2.   
  
  
  
  2.  2// Typically, this means flushing the file system's in-memory copy 
    3.   
  
  
  
  3.  3// of recently written data to disk. 
    4.   
  
  
  
  4.  4func (f *File) Sync() error { 
    5.   
  
  
  
  5.  5    if err := f.checkValid("sync"); err != nil { 
    6.   
  
  
  
  6.  6        return err 
    7.   
  
  
  
  7.  7    } 
    8.   
  
  
  
  8.  8    if e := f.pfd.Fsync(); e != nil { 
    9.   
  
  
  
  9.  9        return f.wrapErr("sync", e) 
    10.   
  
  
  
  10. 10    } 
    11.   
  
  
  
  11. 11    return nil 
    12.   
  
  
  
  12. 12} 
    13.

由于 fsync 的调用，这种模式能很好地避免 close 出现的 EIO。可以预见的是，由于强制性刷盘，这种方案虽然能很好地保证数据安全性，但是在执行效率上却会大打折扣。

文章名称：你有考虑过DeferClose()的风险吗
文章起源：http://www.gawzjz.com/qtweb/news21/192421.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站营销知识

各行业网站

江油网站建设　　 　贵州义龙电信机房　　 　普能电气　　 　四川德阳主机托管　　 　自适应网站　　 　网站推广　　 　网站制作　　 　香港云空间　　 　温江网站建设　　 　成都IDC机房托管　　 　雅安网站建设　　 　简阳机房托管　　 　成都服务器托管　　 　混凝土搅拌罐车　　 　外贸营销网站建设　　 　广安网站建设　　 　成都网站设计　　 　高端定制网站建设　　 　APP定制开发　　 　成都SEO优化公司