第一章.java&golang的区别之:闭包

对于golang一直存有觊觎之心，但一直苦于没有下定决心去学习研究，最近开始接触golang。就我个人来说，学习golang的原动力是因为想要站在java语言之外来审视java和其它语言的区别，再就是想瞻仰一下如此NB的语言。年前就想在2019年做一件事情，希望能从各个细节处做一次java和golang的对比分析，不评判语言的优劣，只想用简单的语言和可以随时执行的代码来表达出两者的区别和底层涉及到的原理。今天是情人节，馒头妈妈在加班，送给自己一件贴心的礼物，写下第一篇对比文章：java&golang的区别之:闭包。

关于闭包到底是啥，建议参考知乎上的解释：https://www.zhihu.com/question/51402215/answer/556617311

• java8之前的闭包

在java8之前，java其实就已经对闭包有了一定层面的支持，实现的闭包方式主要是靠匿名类来实现的，下面是java程序员经常写的一段代码：

public class ClosureBeforeJava8 {
    int y = 1;

    public static void main(String[] args) {
        final int x = 0;
        ClosureBeforeJava8 closureBeforeJava8 = new ClosureBeforeJava8();
        Runnable run = closureBeforeJava8.getRunnable();
        new Thread(run).start();
    }

    public Runnable getRunnable() {
        final int x = 0;
        Runnable run = new Runnable() {
            @Override
            public void run() {
16  
                System.out.println("local varable x is:" + x);
                //System.out.println("member varable y is:" + this.y); //error
            }
        };
        return run;
    }
}

上段代码的输出：local varable x is:0

在代码的第13行到第20行，通过匿名类的方式实现了Runnable接口的run()方法，实现了一部分操作的集合(run方法)，并将这些操作映射为java的对象，在java中就可以实现将函数以变量的方式进行传递了，如果仅仅是传递函数指针，那还不能算是闭包，我们再注意第17行代码，在这段被封装可以在不同的java对象间传递的代码，引用了上层方法的局部变量，这个就有些闭包的意思在里面了。但是第18行被注释掉的代码在匿名类的情况下却无法编译通过，也就是封装的函数里面，无法引用上层方法所在对象的成员变量。总结一下，java8之前的闭包特点如下：

1.可以实现封装的函数在jvm里进行传递，可以在不同的对象里进行调用；

2.被封装的函数，可以调用上层的方法里的局部变量，但是此局部变量必须为final，也就是不可以更改的(基础类型不可以更改，引用类型不可以变更地址)；

3.被封装的函数，不可以调用上层方法所在对象的成员变量；

• java8里对闭包的支持

java8里对于闭包的支持，其实也就是lamda表达式，我们再来看一下上段代码在lamda表达式方式下的写法：

public class ClosureInJava8 {
    int y = 1;

    public static void main(String[] args) throws Exception{
        final int x = 0;
        ClosureInJava8 closureInJava8 = new ClosureInJava8();
        Runnable run = closureInJava8.getRunnable();
        Thread thread1 = new Thread(run);
        thread1.start();
        thread1.join();
        new Thread(run).start();
    }

    public Runnable getRunnable() {
        final int x = 0;
        Runnable run = () -> {
             
            System.out.println("local varable x is:" + x);
            System.out.println("member varable y is:" + this.y++);
        };
        return run;
    }
}

 上面对代码输出：

local varable x is:0
member varable y is:1
local varable x is:0
member varable y is:2

在代码的第16行到第20行，通过lamda表达式的方式实现了函数的封装（关于lamda表达式的用法，大家可以自行google）。通过代码的输出，大家可以发现，在lamda表达式的书写方式下，封装函数不但可以引用上层方法的effectively final类型(java8的特性之一，其实也是final类型)的局部变量，还可以引用上层方法所在对象的成员变量，并可以在其它线程和方法中对此成员变量进行修改。总结一下：java8对于闭包支持的特点如下：

1.通过lamda表达式的方式可以实现函数的封装，并可以在jvm里进行传递；

2.lamda表达式，可以调用上层的方法里的局部变量，但是此局部变量必须为final或者是effectively final，也就是不可以更改的(基础类型不可以更改，引用类型不可以变更地址)；

3.lamda表达式，可以调用和修改上层方法所在对象的成员变量；

由于还没时间分析jdk和hotspot的源码，在此只能猜测推理，第2点和第3点的情况。关于第2点：上层方法的局部变量必须是final修饰的，网上的文章大部分都是说因为多线程并发的原因，无法在lamda表达式里进行修改上层方法的局部变量，这点上我是不同意这个观点的。我认为主要原因是：java在定义局部变量时，对于基础类型都是创建在stack frame上的，而一个方法执行完毕后，此方法所对应的stack frame也就没有意义了，试想一下，lamda表达式所依赖的上层方法的局部变量的存储区(stack frame)都消失了，我们还怎么能够修改这个变量，这是毫无意义的，在java里也很难实现这一点，除非像golang一下，在特定情况下，更改局部变量的存储区域(在heap里存储)。关于第3点：实现起来就比较容易，就是在lamda表达式的对象里，创建一个引用地址，地址指向原上层方法所在对象的堆存储地址即可。

• golang里对闭包的支持

golang里对于闭包的支持，理解起来就非常容易了，就是函数可以作为变量来传递使用，代码如下：

package main

import "fmt"

func main()  {
    ch := make(chan int ,1)
    ch2 := make(chan int ,1)
    fn := closureGet()
    go func() {
        fn()
        ch <-1
    }()
    go func() {
        fn()
        ch2 <-1
    }()
    <-ch
    <-ch2
}

func closureGet() func(){
    x := 1
    y := 2
    fn := func(){
        x = x +y
        fmt.Printf("local varable x is:%d y is:%d \n", x, y)
    }
    return fn
}

代码输出如下：

local varable x is:3 y is:2
local varable x is:5 y is:2

代码的第24行到27行，定义了一个方法fn，此方法可以使用上层方法的局部变量，总结一下：

1.golang的闭包在表达形式上，理解起来非常容易，就是函数可以作为变量，来直接传递；

2.golang的封装函数可以没有限制的使用上层函数里的局部变量，并且在不同的goroutine里修改的值，都会有所体现。

关于第2点，大家可以参考文章：https://studygolang.com/articles/11627  中关于golang闭包的讲解部分。

• 总结

golang的闭包从语言的简洁性、理解的难易程度、支持的力度上来说，确实还是优于java的。本文作为java和golang对比分析的第一篇文章，由于调研分析的时间有限，难免有疏忽之处，欢迎各位指正。