Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。
 
        想要运用androidstudio调用.go文件中的方法，具体操作如下：
 
        1.安装go环境（mac系统）
 
        （1）安装Homebrew命令： ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
 
        （2）使用brew安装go命令：brew install go
 
        （3）使用go env查看当前go版本，以及路径配置相关属性，记住GOROOT的值下面会用到。
 
         （4）修改go路径环境：
 
                 主要是GOROOT和GOPATH
 
                    GOROOT：就是go的安装环境
 
                  GOPATH：作为编译后二进制的存放目的地和import包时的搜索路径。其实说通俗点就是你的go项目工作目录。通常情况下GOPATH包含三个目录：bin、pkg、src。（src目录下主要存放go的源文件；pkg目录存放编译好的库文件，主要是*.a文件;bin目录主要存放可执行文件）
 
               那么重点操作来了，使用命令：vim ~/.bash_profile
 
               现在已经进入了文件中，输入
 
 
GOROOT=上面记录的值
 
 
export GOROOT
 
 
export GOPATH=在你的目录中建立一个go环境目录，如mygopath
 
 
export GOBIN=$GOPATH/bin
 
 
export PATH=$PATH:$GOBIN:$GOROOT/bin
 
编辑完之后退出保存文件，然后使用命令source ~/.bash_profile
 
使之生效，然后再使用命令go env查看当前环境，可以发现已经是你配置文件中设置的路径环境了。
 
2.安装gomobile环境
 
     （1）安装gomobile命令：go get golang.org/x/mobile/cmd/gomobile（可能需要翻墙）
 
    （2）go配置android sdk环境变量，输入命令：export ANDROID_HOME=你的sdk路径，可以在androidstudio中local.properties中查看
 
（3）gomobile初始化ndk，执行命令：gomobile init -ndk  你的ndk路径，同上可以找到
 
（4）如上所说，建立自己的gopath目录，gopath目录下面有src，bin，pkg三个文件夹，在src下建一个文件夹hello，名字随意，将你要使用的.go文件放到hello中。
 
（5）见证奇迹的时刻到了，进入到gopath目录中的bin目录下执行命令：cd  你的gopath路径 + "/bin" ，然后输入命令：
 
gomobile bind -target=android hello,只需等待几十秒就会在gopath的bin目录中生成.aar文件，这个文件android端就可以使用了。
 
 
 
3.androidstudio调用生成的.aar文件。
 
      （1）androidstudio新建一个工程
 
      （2）将生成的.aar文件放到libs下面
 
      （3）在你的app下面的build.gradle中加入如下代码即可
 
                
 
repositories {
    flatDir {
        dirs 'libs' //this way we can find the .aar file in libs folder
    }
}
 
dependencies {
    compile (name:'tudun', ext:'aar')
}
 
 
 
大功告成，现在重新编译就可以调用go中的方法了，是不是很简单，只要一步一步按照命令操作即可！

 

 
文章目录
 
简介
JAVA提供`provider`和`consumer`
`proto`文件介绍
java grpc provider
java grpc consumer
  
go提供`provider`和`consumer`
生成grpc文件
go grpc provider
go grpc consumer
  
测试
java 提供grpc服务
go 提供grpc服务
  
参考

 
简介
 
语言中立，支持多种语言；
基于 IDL 文件定义服务，通过 proto3 工具生成指定语言的数据结构、服务端接口以及客户端 Stub；
通信协议基于标准的 HTTP/2 设计，支持双向流、消息头压缩、单 TCP 的多路复用、服务端推送等特性，这些特性使得 gRPC 在移动端设备上更加省电和节省网络流量；
序列化支持 PB（Protocol Buffer）和 JSON，PB 是一种语言无关的高性能序列化框架，基于 HTTP/2 + PB, 保障了 RPC 调用的高性能。
 
JAVA提供provider和consumer
 
proto文件介绍
 
syntax
指定语言版本
syntax
指定语言版本
option
修改配置选项
service
声明一个服务
rpc
声明一个方法
resturns
方法的返回值
message
定义一个消息类型
repeated
数组
stream
用流来交互
一个栗子🌰,helloworld.proto：
 
syntax = "proto3";  //语法声明

// Greeter 微服务
service Greeter {
// Sends a greeting
rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// HelloRequest 请求数据格式
message HelloRequest {
string name = 1;
}

// HelloReply 响应数据格式
message HelloReply {
string message = 1;
}
 
java grpc provider
 
创建fast-common-grpc-proto，用来生成grpc相关接口。依赖如下，这个还配置了build，可以通过编译生成相关接口。
 
<dependencies>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>${protobuf.version}</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty</artifactId>
            <version>${grpc.version}</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
            <version>${grpc.version}</version>
        </dependency>
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
            <version>${grpc.version}</version>
        </dependency>
    </dependencies>

    <build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>${os-maven-plugin.version}</version>
            </extension>
        </extensions>
        <plugins>
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>${protobuf-maven-plugin.version}</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
 
把上面的helloworld.proto复制到 java/main/proto下，注意一定要是proto文件夹，点击compile会成生成grpc接口文件
 
 
将文件GreeterGrpc、Helloworld复制到grpc包下面，创建GreeterServer文件
 
 GreeterServer的代码如下,继承 GreeterGrpc.GreeterImplBase 重写里面的sayHello方法
 
@Component
public class GreeterServer extends GreeterGrpc.GreeterImplBase implements InitializingBean {
    @Value("${gRPC.port}")
    private int port;

    @Override
    public void afterPropertiesSet() throws Exception {
        ServerBuilder.forPort(port)
                .addService(new GreeterServer())
                .build()
                .start();
    }

    @Override
    public void sayHello(Helloworld.HelloRequest request,
                         io.grpc.stub.StreamObserver<Helloworld.HelloReply> responseObserver) {
        Helloworld.HelloReply result = Helloworld.HelloReply.newBuilder().setMessage(request.getName()).build();
        responseObserver.onNext(result);
        responseObserver.onCompleted();
    }
}
 
java grpc consumer
 
创建SimpleClient，调用你想要调用的接口。
 
controller和service的代码这里就不给出了。需要的可以看github的代码，后面会给出地址。
 
go提供provider和consumer
 
生成grpc文件
 
在根目录下运行命令
 
protoc -I helloworld/ helloworld/helloworld.proto --go_out=plugins=grpc:helloworld

 
 
go grpc provider
 
创建service.go，代码如下
 
package main

import (
	"context"
	pb "go-grpc/helloworld"
	"log"
	"net"

	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
)

const (
	port = ":50051"
)


type server struct{} //服务对象

// SayHello 实现服务的接口 在proto中定义的所有服务都是接口
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
	lis, err := net.Listen("tcp", port)
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer() //起一个服务
	pb.RegisterGreeterServer(s, &server{})
	// 注册反射服务 这个服务是CLI使用的 跟服务本身没有关系
	reflection.Register(s)
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}
 
go grpc consumer
 
创建client.go，代码如下：
 
package main
import (
	"context"
	"log"
	"os"
	"time"

	pb "go-grpc/helloworld"
	"google.golang.org/grpc"
)

const (
	address     = "localhost:50051"
	defaultName = "world"
)

func main() {
	//建立链接
	conn, err := grpc.Dial(address, grpc.WithInsecure())
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	c := pb.NewGreeterClient(conn)

	// Contact the server and print out its response.
	name := defaultName
	if len(os.Args) > 1 {
		name = os.Args[1]
	}
	// 1秒的上下文
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", r.Message)
}
 
测试
 
接下来测试服务之间的调用
 
java 提供grpc服务
 
java调用java，启动java服务，运行FastCommonGrpcExampleApplication这个类，访问http://localhost:8080/hello
 
go 调用java，运行client.go会看到输出
 
 
go 提供grpc服务
 
java 调用go ，注释掉GreeterServer，启动FastCommonGrpcExampleApplication，启动service.go，访问http://localhost:8080/hello
 
go调用go，运行client.go会看到输出
 
 
go地址：https://github.com/fafeidou/go-grpc
 java地址：https://github.com/fafeidou/fast-cloud-nacos
 
参考
 
 
java grpc: https://www.cnblogs.com/gutousu/p/9951956.html
 
 
入门及服务端创建和调用原理: https://www.cnblogs.com/wxlevel/p/9154246.html#auto_id_24
 
 
grpc（3）：使用 golang 开发 grpc 服务端和客户端 : https://blog.csdn.net/freewebsys/article/details/59483427
 
 
gRPC基于Golang和Java的简单实现: https://www.jianshu.com/p/21d5d7624951
 

参考文档：
 
JNA的官方文档：http://java-native-access.github.io/jna/5.5.0/javadoc/
JNA的github：https://github.com/java-native-access/jna
github的一个case：Calling Go Functions from Other Languages using C Shared Libraries
简书上的一个case：https://www.jianshu.com/p/b19b9715c36b
 
 
1. 基本原理
 
Java Native Access（JNA）提供一组Java工具类用于在运行期间动态访问系统本地库（Native library：如 windows的 dll文件、linux的so文件），而不需要编写任何Native/ JNI 代码。开发人员只要在一个java接口中描述目标 native library 的函数与结构，JNA 将自动实现 Java 接口到 native function的 映射。
 
java type 和 native type 在进行转换的时候，是有一个对应的映射关系的，根据JNA的官方文档（详细请见 Type Mapping的官方描述），以下在表格中列出了部分 type-mapping的关系，这些关系也将会在后面的case中进行测试：
 
C Type
Native Representation
Java Type
char
8-bit integer
byte
int
32-bit integer
int
int
boolean flag
boolean
float
32-bit floating point
float
double
64-bit floating point
double
pointer (e.g. void*),
 array
32- or 64-bit pointer to memory (argument/return)
 contiguous memory (struct member)
<P>[] (array of primitive type)
In addition to the above types, which are supported at the native layer, the JNA Java library automatically handles the following types. All but NativeMapped and NativeLong are converted to Pointer before being passed to the native layer.
const char*
NUL-terminated array (native encoding or jna.encoding)
String
struct*
 struct
pointer to struct (argument or return) (or explicitly)
 struct by value (member of struct) (or explicitly)
Structure
然后基于go语言中的cgo工具，可以将 C type 转化为 Go Type
 
 
 
2. 编写Go函数
 
以下编写6个case进行测试，前3个case是基本类型（int、double、boolean）在java与go之间的传递，后3个case都是string类型的传递。
 
package main

import "C"
import (
	"fmt"
	"math"
	"unsafe"
)

// java:int --> C:int == C.int --> Go:int
//export Add
func Add(a, b C.int) C.int {
	aGo := int(a)
	bGo := int(b)
	res := aGo + bGo
	return C.int(res)
}

// java:double --> C:double == C.double --> Go:float64
//export Cosine
func Cosine(x C.double) C.double {
	xGo := float64(x)
	res := math.Cos(xGo)
	return C.double(res)
}

//
//export Hello1
func Hello1(world string, test string) *C.char {
	res := "Hello1," + world
	fmt.Println(test)
	return C.CString(res)
}

//export Hello2
func Hello2(raw *C.char, size C.int) *C.char {
	data := C.GoBytes(unsafe.Pointer(raw), size)
	dataStr := "Hello2," + string(data)
	return C.CString(dataStr)
}

//export Hello3
func Hello3(test string, raw *C.char, size C.int) *C.char {
	res := "Hello3," + test

	data := C.GoBytes(unsafe.Pointer(raw), size)
	dataStr :=  string(data)
	fmt.Println("Hello3," + dataStr)

	return C.CString(res)
}

func main(){}
 
关于java中string的传递，可以通过两种方式：
 
第一种方式：
 
java中的string，可以编码成为 byte[ ] 数组，根据JNA官方的Type Mapping所述，会映射成为 C中的 一个指针，该指针指向一个 C.char 类型的数组。最后可以借助Cgo，将其转化为go中的 [ ]byte，最后就可以轻易的转化为go中的string。
 
第二种方式：
 
把go程序编译成为 native library文件后，会在目录下生成一个 xxx.h 的C 语言头文件：
 
我们可以看到go中的 string，也就是C中的一个 struct。因此我们可以在java代码中构造一个java的Struct来对应C中的struct。
 
以此为思路，参见JNA官方文档的 Type Mapping：Structs：
 
The Java Structure represents a native struct. By default, this type is treated as a pointer to structure (struct *) on the native side when used as a parameter or return value. When used as a structure field, the structure is interpreted as by value. To force the complementary interpretation, the tagging interfaces Structure.ByValue and Structure.ByReference are provided.
 
The data within a Java Structure is automatically written to native memory just before a native function call with a struct parameter, and automatically read from native memory after the function returns.
 
 
 
/* Code generated by cmd/cgo; DO NOT EDIT. */

/* package command-line-arguments */


#line 1 "cgo-builtin-export-prolog"

#include <stddef.h> /* for ptrdiff_t below */

#ifndef GO_CGO_EXPORT_PROLOGUE_H
#define GO_CGO_EXPORT_PROLOGUE_H

#ifndef GO_CGO_GOSTRING_TYPEDEF
typedef struct { const char *p; ptrdiff_t n; } _GoString_;
#endif

#endif

/* Start of preamble from import "C" comments.  */




/* End of preamble from import "C" comments.  */


/* Start of boilerplate cgo prologue.  */
#line 1 "cgo-gcc-export-header-prolog"

#ifndef GO_CGO_PROLOGUE_H
#define GO_CGO_PROLOGUE_H

typedef signed char GoInt8;
typedef unsigned char GoUint8;
typedef short GoInt16;
typedef unsigned short GoUint16;
typedef int GoInt32;
typedef unsigned int GoUint32;
typedef long long GoInt64;
typedef unsigned long long GoUint64;
typedef GoInt64 GoInt;
typedef GoUint64 GoUint;
typedef __SIZE_TYPE__ GoUintptr;
typedef float GoFloat32;
typedef double GoFloat64;
typedef float _Complex GoComplex64;
typedef double _Complex GoComplex128;

/*
  static assertion to make sure the file is being used on architecture
  at least with matching size of GoInt.
*/
typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1];

#ifndef GO_CGO_GOSTRING_TYPEDEF
typedef _GoString_ GoString;
#endif
typedef void *GoMap;
typedef void *GoChan;
typedef struct { void *t; void *v; } GoInterface;
typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;

#endif

/* End of boilerplate cgo prologue.  */

#ifdef __cplusplus
extern "C" {
#endif


// java:int --> C:int == C.int --> Go:int

extern int Add(int p0, int p1);

// java:double --> C:double == C.double --> Go:float64

extern double Cosine(double p0);

// java:boolean --> C:int == C.int --> Go:int

extern int Boolean(int p0, int p1);

extern char* Hello1(GoString p0, GoString p1);

extern char* Hello2(char* p0, int p1);

extern char* Hello3(GoString p0, char* p1, int p2);

#ifdef __cplusplus
}
#endif
 
3. 编译go程序
 
将go程序编译成为 native library文件。
 
如果是windows系统，则编译命令为：
 
go build -buildmode=c-shared -o test.dll .\test1.go
 
如果是linux系统，则编译命令为：
 
go build -buildmode=c-shared -o libtest.so .\test1.go
 
 
 
4. 动态库在java中的映射
 
首先，我们需要创建一个java中的interface来映射native library，之后我们就可以通过该 interface 的实例来访问native library中的一些函数。
 
然后为了能映射C中的struct，我们还需要编写一个 java的struct - GoString
 
 
 
实例化interface时，引用 .dll文件的 路径 可以设为绝对路径。
 
import com.sun.jna.*;
import com.sun.jna.Native;
import java.util.Arrays;
import java.util.List;
import java.lang.Math;

public class Client {
    public interface Awesome extends Library {
        // GoString class maps to:
        // C type struct { const char *p; GoInt n; }
        public class GoString extends Structure {
            public static class ByValue extends GoString implements Structure.ByValue {}
            public String p;
            public long n;
            protected List getFieldOrder(){
                return Arrays.asList(new String[]{"p","n"});
            }
        }

        int Add(int a, int b);
        double Cosine(double x);
        boolean Boolean(boolean t, boolean f);
        String Hello1(GoString.ByValue world, GoString.ByValue test);
        String Hello2(byte[] raw, int len);
        String Hello3(GoString.ByValue world, byte[] raw, int len);
    }

    public static void main(String[] args) {
        Awesome awesome = Native.loadLibrary("{dir_path}\\test.dll", Awesome.class);
        // {dir_path}\test.dll
        // {dir_path}/libtest.so

        System.out.println("==========================case1: Add==========================");
        System.out.println(awesome.Add(5, 2));                   // case1: Add
        System.out.println("==========================case2: Cosine==========================");
        System.out.println(awesome.Cosine(Math.PI/3));              // case2: Cosine
        System.out.println("==========================case3: Boolean==========================");
        System.out.println(awesome.Boolean(true, false));         // case3: Boolean

        System.out.println("==========================case4: Hello1==========================");
        // case4: Hello1
        Awesome.GoString.ByValue str1 = new Awesome.GoString.ByValue();
        str1.p = "world1";
        str1.n = str1.p.length();

        Awesome.GoString.ByValue test = new Awesome.GoString.ByValue();
        test.p = "test";
        test.n = test.p.length();
        System.out.println(awesome.Hello1(str1, test));

        // case5: Hello2
        System.out.println("==========================case5: Hello2==========================");
        String str = "world2";
        byte raw[] = str.getBytes();
        System.out.println(awesome.Hello2(raw, raw.length));

        // case6: Hello3
        System.out.println("==========================case6: Hello3==========================");
        Awesome.GoString.ByValue str3 = new Awesome.GoString.ByValue();
        str3.p = "test";
        str3.n = str3.p.length();

        String str4 = "world3";
        byte raw3[] = str4.getBytes();
        System.out.println(awesome.Hello3(str3, raw3, raw3.length));
    }
}
 
 
 
输出结果：


==========================case1: Add==========================
7
==========================case2: Cosine==========================
0.5000000000000001
==========================case3: Boolean==========================
java:true --> go: -1
java:false --> go: 0
true
==========================case4: Hello1==========================
test  Hello1,world1
==========================case5: Hello2==========================
Hello2,world2
==========================case6: Hello3==========================
Hello3,world3  test
 
 

Go和Java作为在世界上影响巨大的两门开发语言，在语言特点和应用领域上都存在共通和相似之处。Go从2009年开源至今，在docker、K8s、企业后台等领域都取得了非凡的影响。本文以Golang的主要feature为研究对象，共分为6个章节，在学习这些特性的同时，给出其在Java中对应的实现方式，并会详细分析其中的原理和差异。
 
1.接口
 
在面向对象语言中，接口是一个绕不开的话题和特性，我们首先通过一段代码来看一下Go中的接口是如何设计和使用的。
 
go的实现代码
 
  1、在代码中定义了两个结构体：Teacher和Student；
  2、定义了一个接口：Person，接口中声明了一个方法：notice()；
  3、在Teacher和Student中都存在notice()方法的实现，并且方法签名与Person中的notice()一致；
  4、main包中的全局函数sendMsg(p Person) ，通过输入参数为Person的接口，来调用实现Person接口的notice方法；
  5、函数sendMsg(p Person)，是一个通过接口实现的多态应用；
 

package main
import "fmt"

type Teacher struct {
    Name string
}

type Student struct {
    Name string
}

type Person interface {
    notice()
}

func (t Teacher) notice() {
    fmt.Println(t.Name, "hello")
}

func (s Student) notice() {
    fmt.Println(s.Name, "hello")
}

//sendMsg接收一个实现了Person接口的struct
func sendMsg(p Person) {
    p.notice()
}

func main() {
    t := Teacher{"Teacher Liu"}
    s := Student{"Student Li"}
    sendMsg(t)
    sendMsg(s)
}
 
Java的实现代码
 
  1、Java中至少需要3个文件来实现；
  2、Java使用interface关键字来定义接口；
  3、Java在类中使用implements关键字来显式的实现接口；
  4、Java中的方法是定义在Class里面的；
  5、Person.java中定义Person接口代码；
  6、Teacher.java中定义Teacher类；
  7、Student.java中定义Student类和main方法等；
 
public interface Person {
    public void notice();
}

public class Teacher implements Person{
    public String name;

    public Teacher(String name){
        this.name = name;
    }

    @Override
    public void notice() {
        System.out.println(name+" hello");
    }
}

public class Student implements Person{
    public String name;

    public Student(String name){
        this.name = name;
    }

    @Override
    public void notice() {
        System.out.println(name+" hello");
    }

    public static void sendMsg(Person p){
        p.notice();
    }
    public static void main(String[] args){
        Teacher t = new Teacher("Teacher Liu");
        Student s = new Student("Student Li");
        sendMsg(t);
        sendMsg(s);
    }
}
 
接口小结
 
  1、Go中使用 type interface方式定义，Java使用interface关键字来定义接口；
  2、Go的接口是隐式实现，没有类似于Java中implements的明确方式，只要struct中的方法覆盖了接口的所有方法，便可以认定struct实现了接口；
  3、Go支持空接口，任何类都默认实现了空接口；
  4、Go的接口实现更加灵活；
  5、Java中的方法是定义在Class里面的；
 
2.继承
 
下面的内容是wikipedia关于继承概念的解释：
 
继承（英语：inheritance）是面向对象软件技术当中的一个概念。如果一个类别B“继承自”另一个类别A，就把这个B称为“A的子类”，而把A称为“B的父类别”也可以称“A是B的超类”。继承可以使得子类具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。另外，为子类追加新的属性和方法也是常见的做法。一般静态的面向对象编程语言，继承属于静态的，意即在子类的行为在编译期就已经决定，无法在运行期扩展。有些编程语言支持多重继承，即一个子类可以同时有多个父类，比如C++编程语言；而在有些编程语言中，一个子类只能继承自一个父类，比如Java编程语言，这时可以透过实现接口来实现与多重继承相似的效果。现今面向对象程序设计技巧中，继承并非以继承类别的“行为”为主，而是继承类别的“类型”，使得组件的类型一致。另外在设计模式中提到一个守则，“多用合成，少用继承”，此守则也是用来处理继承无法在运行期动态扩展行为的遗憾。
 
在Go中其实是没有继承的，但是我们可以通过匿名组合来实现继承的效果。下面的Go代码中通过匿名组合的方式来实现了继承的效果。
 
1、定义了两个“父类”，Person和Job;
2、定义了一个“子类”，Teacher；
3、Person中有一个方法ShowName()，Job中有一个方法ShowJob()，Teacher中也有一个ShowName方法；
4、在Struct Teacher中，通过匿名组合的方法，实现了Teacher继承自Person和Job；
 

package main

import (
    "fmt"
)

type Person struct{}

type Job struct{}

func (p *Person) ShowName() {
    fmt.Println("I'm a person.")
}

func (j *Job) ShowJob() {
    fmt.Println("I'm a job.")
}

type Teacher struct {
    Person
    Job
}

func (t *Teacher) ShowName() {
    fmt.Println("Teacher Liu.")
}

func main() {
    t := Teacher{}
    t.Person.ShowName()
    t.ShowName()
    t.ShowJob()
}
 
输出内容为
 
I'm a person.
Teacher Liu.
I'm a job.
 
继承小结
 
  1、Go中使用匿名引入的方式来实现struct继承；
  2、Go中“子类”方法如何和“父类”方法重名(匿名对象和外层对象的方法重名)，默认优先调用外层方法；
  3、Go中可以指定匿名struct以调用内层方法；
  4、Go使用组合的方式，实现了多重继承；
 
3.闭包
 
维基百科中关于闭包的解释：
 
在计算机科学中，闭包（英语：Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures），是在支持头等函数的编程语言中实现词法绑定的一种技术。闭包在实现上是一个结构体，它存储了一个函数（通常是其入口地址）和一个关联的环境（相当于一个符号查找表）。环境里是若干对符号和值的对应关系，它既要包括约束变量（该函数内部绑定的符号），也要包括自由变量（在函数外部定义但在函数内被引用），有些函数也可能没有自由变量。 闭包跟函数最大的不同在于，当捕捉闭包的时候，它的自由变量会在捕捉时被确定，这样即便脱离了捕捉时的上下文，它也能照常运行。捕捉时对于值的处理可以是值拷贝，也可以是名称引用，这通常由语言设计者决定，也可能由用户自行指定（如C++）。
 
Java 中的闭包
 
Java8之前的闭包支持主要是依靠匿名类来实现的
 
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() {
                System.out.println("local varable x is:" + x);
                //System.out.println("member varable y is:" + this.y); //error
            }
        };
        return run;
    }
 
Java8对于闭包的支持
 
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;
    }
}
 
Java闭包小结
 
      1、通过lamda表达式的方式可以实现函数的封装，并可以在jvm里进行传递；
      2、lamda表达式，可以调用上层的方法里的局部变量，但是此局部变量必须为final或者是effectively final，也就是不可以更改的(基础类型不可以更改，引用类型不可以变更地址)；
      3、lamda表达式，可以调用和修改上层方法所在对象的成员变量；
 
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
 
下面的代码中会输出什么？
 
package main

import (
    "fmt"
)

func main() {
    res := closure()
    fmt.Println(res) //0x49a880  返回内层函数函数体地址
    r1 := res()      //执行closure函数返回的匿名函数
    fmt.Println(r1)  //1
    r2 := res()
    fmt.Println(r2) //2 
    //普通的函数应该返回1，而这里存在闭包结构所以返回2 。
    //一个外层函数当中有内层函数，这个内层函数会操作外层函数的局部变量,并且外层函数把内层函数作为返回值,则这里内层函数和外层函数的局部变量,统称为闭包结构。这个外层函数的局部变量的生命周期会发生改变，不会随着外层函数的结束而销毁。
    //所以上面打印的r2 是累计到2 。

    res2 := closure() //再次调用则产生新的闭包结构 局部变量则新定义的
    fmt.Println(res2)
    r3 := res2()
    fmt.Println(r3)
}

//定义一个闭包结构的函数 返回一个匿名函数
func closure() func() int { //外层函数
    //定义局部变量a
    a := 0 //外层函数的局部变量
    //定义内层匿名函数 并直接返回
    return func() int { //内层函数
        a++ //在匿名函数中将变量自增。内层函数用到了外层函数的局部变量，此变量不会随着外层函数的结束销毁
        return a
    }
}
 
Go闭包小结
 
  1、Go的闭包在表达形式上，理解起来非常容易，就是在函数中定义子函数，子函数可以使用上层函数的变量；
  2、Go的封装函数可以没有限制的使用上层函数里的自由变量，并且在不同的Goroutine里修改的值，都会有所体现；
  3、在闭包(fn和fn2)被捕捉时(return fn,fn2)，自由变量(x和y)也被确定了，此后不再依赖于被捕捉时的上下文环境(函数closureGet())；
 
4.channel VS BlockingQueue
 
Go channel
 
不要通过共享内存来通信，而应该通过通信来共享内存
 Go提供一种基于消息机制而非共享内存的通信模型。消息机制认为每个并发单元都是自包含的独立个体，并且拥有自己的变量，但在不同并发单元间这些变量不共享。每个并发单元的输入和输出只有一种，那就是消息。channel是Golang在语言级提供的Goroutine间的通信方式，可以使用channel在两个或多个Goroutine之间传递消息。channel是类型相关的，即一个channel只能传递一种类型的值，需要在声明channel时指定。可以认为channel是一种类型安全的管道。下面是channel的声明和定义的相关代码：
 

// 声明一个channel
var chanName chan ElementType

// 定义一个无缓冲的channel
chanName := make(chan ElementType)

// 定义一个带缓冲的channel
chanName := make(chan ElementType, n)

// 关闭一个channel
close(chanName)
 
  1、向无缓冲的channel写入数据会导致该Goroutine阻塞，直到其他Goroutine从这个channel中读取数据。
  2、向带缓冲的且缓冲已满的channel写入数据会导致该Goroutine阻塞，直到其他Goroutine从这个channel中读取数据。
  3、向带缓冲的且缓冲未满的channel写入数据不会导致该Goroutine阻塞。
  4、从无缓冲的channel读出数据，如果channel中无数据，会导致该Goroutine阻塞，直到其他Goroutine向这个channel中写入数据。
  5、从带缓冲的channel读出数据，如果channel中无数据，会导致该Goroutine阻塞，直到其他Goroutine向这个channel中写入数据。
  6、从带缓冲的channel读出数据，如果channel中有数据，该Goroutine不会阻塞。
 
总结：
 
   无缓冲的channel读写通常都会发生阻塞，带缓冲的channel在channel满时写数据阻塞，在channel空时读数据阻塞。
 
package main

import "fmt"
import "time"

func main() {
    timeout := make(chan bool)

    go func() {
        time.Sleep(3 * time.Second) // sleep 3 seconds
        timeout <- true
    }()

    // 实现了对ch读取操作的超时设置。
    ch := make(chan int)
    select {
    case <-ch:
    case <-timeout:
        fmt.Println("timeout!")
    }
}
 
 1、Golang中的select关键字用于处理异步IO，可以与channel配合使用；
 2、Golang中的select的用法与switch语法非常类似，不同的是select每个case语句里必须是一个IO操作；
 3、select会一直等待等到某个case语句完成才结束；
 
在上面的代码中，我们用到了select来实现了读取channel超时的处理，那么，我们能不能使用select来进行发送消息的超时处理呢？
 
package main

import "fmt"
import "time"

func main() {
    timeout := make(chan bool)

    go func() {
        time.Sleep(3 * time.Second) // sleep 3 seconds
        timeout <- true
    }()

    // 实现了对ch写取操作的超时设置。
    ch := make(chan int)
    select {
    case ch <-1 :
        fmt.Println("send message success.")
    case <-timeout:
        fmt.Println("timeout!")
    }
}
 
switch是可以有default语句的，那么select是否也有default的语句呢？
 
package main

import "fmt"
import "time"

func main() {
    timeout := make(chan bool)

    go func() {
        time.Sleep(3 * time.Second) // sleep 3 seconds
        timeout <- true
    }()

    // 实现了对ch写取操作的超时设置。
    ch := make(chan int)
    select {
    case ch <-1 :
        fmt.Println("send message success.")
    case <-timeout:
        fmt.Println("timeout!")
    default :
        fmt.Println("default case.")
    }
}
 
Java BlockingQueue
 
 
在Java中，BlockingQueue是一个接口，它的实现类有ArrayBlockingQueue、DelayQueue、 LinkedBlockingDeque、LinkedBlockingQueue、PriorityBlockingQueue、SynchronousQueue等，它们的区别主要体现在存储结构上或对元素操作上的不同，但是对于take与put操作的原理，却是类似的。
 
生产者：
 
 1、offer(E e)：如果队列没满，立即返回true；如果队列满了，立即返回false；
 2、put(E e)：如果队列满了，一直阻塞，直到队列不满了或者线程被中断；
 3、offer(E e, long timeout, TimeUnit unit)：在队尾插入一个元素,如果队列已满，则进入等待，直到出现以下三种情况：等待时间超时、当前线程被中断、队列中的部分元素被消费；
 
消费者：
 
 1、poll()：如果没有元素，直接返回null；如果有元素，出队。不会阻塞当前线程；
 2、take()：如果队列空了，一直阻塞，直到队列不为空或者线程被中断；
 3、poll(long timeout, TimeUnit unit)：如果队列不空，出队；如果队列已空且已经超时，返回null；如果队列已空且时间未超时，则进入等待，直到出现以下三种情况：等待时间超时、当前线程被中断、队列中出现了新的元素；
 
小结：
 
 1、Go channel 和 Java BlockingQueue 都是实现生产者和消费者模式；
 2、channel是在语言层面的实现，BlockingQueue是在sdk层面的支持；
 3、Java程序使用线程池，要注意设置队列的大小，否则无界队列容易使得内存被耗光直到程序崩溃；
 4、使用put和offer(E e, long timeout, TimeUnit unit)必须要做好防护，防止因为消费慢而造成的阻塞主线程的情况发生；
 
5.并发数据结构
 
 1、Java 并发数据结构：ConcurrentHashMap、CopyOnWriteArraySet、ConcurrentLinkedQueue、BlockingQueue、ConcurrentSkipListMap...
 2、Go 并发数据结构：sync.Map
 
接下来，我拿两个数据库产品做了一些对比，一个是Golang+rust写的TiDB，另一个是Java写的ElasticSearch。
 
读写锁
 
在ES中只有11个地方使用到了读写锁，而TiDB(TiDB的计算模块)和PD(TiDB的调度模块)中有较多的地方使用到了读写锁。下面的代码是PD中在获取当前的region所在的leader store的源码：
 
// GetLeaderStore returns all Stores that contains the region's leader peer.
func (bc *BasicCluster) GetLeaderStore(region *RegionInfo) *StoreInfo {
    bc.RLock()
    defer bc.RUnlock()
    return bc.Stores.GetStore(region.GetLeader().GetStoreId())
}
 
在TiDB和PD中有较多类似于上面的代码部分，在读的时候用读锁，在写的时候用写锁。根本原因，我觉得是Golang中没有对于并发数据结构的支持，那么这些数据一致性和稳定性的保障都留给了业务开发人员，因此在TiDB这样的底层数据库产品里面，会有很多的读写锁场景出现。
 
并发场景下使用map
 
map是我们在编码过程一定会使用到的数据结构，在jdk1.5之前的时代，如果因为HahsMap使用不当，在并发环境下，一定会出现死链的情况，间接的造成了程序的崩溃。同理在Golang中，我们在并发环境下使用普通的map时，一定要加读写锁的，否则会造成程序崩溃退出。下面是PD中获取某个store的代码：
 
// GetStore searches for a store by ID.
func (bc *BasicCluster) GetStore(storeID uint64) *StoreInfo {
    bc.RLock()
    defer bc.RUnlock()
    return bc.Stores.GetStore(storeID)
}

// GetStore returns a copy of the StoreInfo with the specified storeID.
func (s *StoresInfo) GetStore(storeID uint64) *StoreInfo {
    store, ok := s.stores[storeID]
    if !ok {
        return nil
    }
    return store
}

// StoresInfo contains information about all stores.
type StoresInfo struct {
    stores map[uint64]*StoreInfo
}
 
这段代码如果在Java中，因为jdk底层有大量的并发数据结构的支持，是可以有一些优化点的：
 
  1、bc.RLock() 表明了这个锁的级别是cluster级别的，当我们对于cluster内的所有操作，都需要使用到这个锁，锁的粒度比较粗，我们可以尝试降低锁的粒度；
  2、所有一致性和稳定性有可能出问题的地方，都要加锁处理，程序的复杂度过大；
  3、在Java语言里面，可以使用ConcurrentHashMap，实现在业务代码中无锁处理；
 
下面是ES在RestClient中的一段使用ConcurrentHashMap的代码：
 
private final ConcurrentMap<HttpHost, DeadHostState> blacklist = new ConcurrentHashMap<>();

    static Iterable<Node> selectNodes(NodeTuple<List<Node>> nodeTuple, Map<HttpHost, DeadHostState> blacklist,
                                      AtomicInteger lastNodeIndex, NodeSelector nodeSelector) throws IOException {
        ...
        for (Node node : nodeTuple.nodes) {
            DeadHostState deadness = blacklist.get(node.getHost());
            ...
        }
        ...

    private void onResponse(Node node) {
        DeadHostState removedHost = this.blacklist.remove(node.getHost());
        if (logger.isDebugEnabled() && removedHost != null) {
            logger.debug("removed [" + node + "] from blacklist");
        }
    }

    private void onFailure(Node node) {
        while(true) {
            DeadHostState previousDeadHostState =
                blacklist.putIfAbsent(node.getHost(), new DeadHostState(DeadHostState.DEFAULT_TIME_SUPPLIER));
            ...
        }
        failureListener.onFailure(node);
    }
 
上面的代码体现了在Java中使用到ConcurrentHashmap时：
 
  1、可以做到业务代码层面完全无锁语法，锁是在map内部实现的，简化代码复杂度；
  2、ConcurrentHashmap的分段锁机制减少锁的粒度，提升并发性能；
  3、通过putIfAbsent方法可以实现如果map中不存在key时，则加入value，否则不进行替换的原子操作；
 
小结：
 
 1、并发数据结构的支持是在sdk层面的差异，而非语言本身；
 2、Java因为有并发大师Doug Lea的concurrent包，在并发数据结构的支持上，是领先于Go等其它语言的；
 3、Go中在底层数据结构上实现同样并发性能的程序，对于业务开发程序员的技能要求更高；
 4、在Golang中使用底层数据结构，经常需要使用到读写锁，Java中用的比较少；
 5、Go中由于在业务代码中经常使用到读写锁，很容易扩大锁的粒度，造成性能的下降；
 
6.Goroutine VS thread
 
Go GPM 调度模型
 
本章节内容，主要来源于Golang布道师 Bill的 Scheduling In Go : Part II - Go Scheduler 当 Go 程序启动时，它会为主机上标识的每个虚拟核心提供一个逻辑处理器（P）。如果处理器每个物理核心可以提供多个硬件线程（超线程），那么每个硬件线程都将作为虚拟核心呈现给 Go 程序。为了更好地理解这一点，下面实验都基于如下配置的 MacBook Pro 的系统。
 
 
package main

import (
    "fmt"
    "runtime"
)

func main() {

    // NumCPU 返回当前可用的逻辑处理核心的数量
    fmt.Println(runtime.NumCPU())
}
 
 
每个 P 都被分配一个系统线程 M 。M 代表机器（machine），它仍然是由操作系统管理的，操作系统负责将线程放在一个核心上执行。这意味着当在我的机器上运行 Go 程序时，有 16 个线程可以执行我的工作，每个线程单独连接到一个P。
 
每个 Go 程序都有一个初始 G。G 代表 Go 协程（Goroutine），它是 Go 程序的执行路径。Goroutine 本质上是一个 Coroutine，但因为是 Go 语言，所以把字母 “C” 换成了 “G”，我们得到了这个词。你可以将 Goroutines 看作是应用程序级别的线程，它在许多方面与系统线程都相似。正如系统线程在物理核心上进行上下文切换一样，Goroutines 在 M 上进行上下文切换。
 
最后一个重点是运行队列。Go 调度器中有两个不同的运行队列：全局运行队列(GRQ)和本地运行队列(LRQ)。每个 P 都有一个LRQ，用于管理分配给在P的上下文中执行的 Goroutines，这些 Goroutine 轮流被和P绑定的M进行上下文切换。GRQ 适用于尚未分配给P的 Goroutines。其中有一个过程是将 Goroutines 从 GRQ 转移到 LRQ。Go最新的1.14版本中又对GPM调度模型进行了优化，增加了抢占式调度的安全点。
 我个人觉得GPM调度模型是Go最精华的内容之一，Java社区对于协程已经呼唤了很多年，但是现在还没有看到能可以在语言层面落地的迹象。
 
Java thread
 
在这里，我也列举一些在Java中使用thread的一些小细节：
 
1、Java线程栈的空间大小默认是1M，从内存的角度讲，jvm也很难管理大量的线程，Goroutine栈空间大小可以做到几k;
2、Java可以使用threadlocal来存储和当前线程关联的内容，例如：log4j、pinpoint、skywalking等框架；
3、Java是有threadid的，Golang是不提供Goroutineid的；
4、因为Java的线程模型，所以我们在编写并发的网络编程时，需要借助netty这样的网络框架；
5、每一个多线程的Java服务，后面一定有各式各样的线程池为它服务；
 
7.总结
 
本文通过接口、继承、闭包、Go channel、并发数据结构和协程等6个方面来分别对比分析了Go和Java中对于不同特性的实现方法。并针对闭包、并发数据结构等进行了详细的使用场景和在不同情况下的优缺点进行了对比分析。在Go和Java的语言差异上，肯定不止这6个方面，本文只是选择了在开发过程中，经常遇到的几个方面进行了对比分析。希望能给到对于其中一种语言比较熟悉，但是想要快速学习另一种语言的同学，起到一个思路启发的作用。
 
参考文章：
 
https://mp.weixin.qq.com/s/2zSqBAzEqwsCAQitsXycBQ