Shulou(Shulou.com)06/02 Report--

This article will explain in detail what are the core features of the Go language. The editor thinks it is very practical, so I share it for you as a reference. I hope you can get something after reading this article.

I. thought

Less can be more

The avenue is simple, small and authentic

It's easy to make things complicated, but it's hard to make things simple.

Profound engineering culture

II. Core characteristics

The reason why Go language is powerful is that it can always grasp the pain point of programmers in server-side development and solve problems in the most direct, simple, efficient and stable way. Instead of delving into the specific syntax of the GO language, we will introduce key aspects of the language that are important for simplifying programming to experience the core features of Go.

2.1 concurrent programming

Go language is much more concise than most languages in concurrent programming, which is one of its biggest highlights and an important bargaining chip for it to enter high-concurrency and high-performance scenarios in the future.

Different from the traditional multi-process or multi-thread, the concurrent execution unit of golang is a kind of cooperative program called goroutine.

Because locks are used in shared data scenarios, coupled with GC, its concurrency performance is sometimes not as good as the asynchronous reuse IO model, so golang's concurrency programming is simpler than concurrency performance compared to most languages.

In today's multi-core era, the significance of concurrent programming is self-evident. Of course, many languages support multithreaded, multiprocess programming, but unfortunately, implementation and control is not so easy and enjoyable. Unlike Golang, the language level supports goroutine concurrency (also known as microthreading, which is lighter, less expensive, and higher performance than threads). It is very easy to operate, and the language level provides keywords (go) to start collaborators, and thousands of collaborators can be started on the same machine. A co-program is often understood as a lightweight thread, where a thread can contain multiple co-routines, sharing the heap and not sharing the stack. Generally speaking, the scheduling between collaborations is explicitly implemented by the application, and the context switching does not need to go down to the kernel layer, which is very efficient. There are generally no synchronous communication between cooperators, but there are two kinds of communication in golang: 1) shared memory, even if global variables + mutex locks are used to achieve data sharing; 2) message transmission, even if a unique channel mechanism is used for asynchronous communication.

Compared with the multi-thread implementation of JAVA and the co-program implementation of GO, it is obviously more direct and simple. This is the charm of GO, solving problems in a simple and efficient way, and the keyword go is perhaps the most important symbol of the GO language.

High concurrency is the biggest highlight of Golang language

2.2 memory recovery (GC)

From C to C programming, from a program performance point of view, these two languages allow programmers to manage memory themselves, including memory application and release. Because there is no garbage collection mechanism, CCompact + runs very fast, but with it comes programmers' cautious consideration of memory usage. Because even a little carelessness can lead to a "memory leak" that wastes resources or a "wild pointer" causes a program to crash, although Category 11 later used the concept of smart pointers, programmers still need to be very careful. Later, in order to improve the speed of program development and the robustness of the program, high-level languages such as java and C # introduced the GC mechanism, that is, programmers no longer need to consider memory collection, but provide garbage collectors with language features to collect memory. But it may be followed by a reduction in the efficiency of the program.

The GC process is as follows: first stop the world, scan all the objects, mark the recyclable objects in a bitmap area, then immediately start the world, restore the service, and at the same time start a special gorountine recovery memory into the free list for reuse without physical release. The physical release is performed periodically by specialized threads.

The bottleneck of GC is that all objects are scanned every time. The more objects to be collected, the slower the speed. A rule of thumb is that scanning 10w objects takes 1ms, so try to use a solution with fewer objects. For example, we also consider linked list, map, slice, and array for storage. Each element of linked list and map is an object, while slice or array is an object, so slice or array is good for GC.

The performance of GC may be continuously optimized as the version is updated. Without careful research, there are HotSpot developers on the team who should learn from the design ideas of jvm gc, such as generation recycling, safepoint and so on.

Memory is automatically reclaimed, so developers no longer need to manage memory

Developers focus on business implementation, reducing mental burden

Only new is required to allocate memory, no need to release

2.3 memory allocation

In the initialization phase, a large memory area is allocated directly, and the large memory is divided into blocks of different sizes and put into different free list. When the object allocates space, the appropriate memory block is taken out of the free list. When memory is reclaimed, unused memory is replayed back to the free list. Free memory is merged according to a certain strategy to reduce fragmentation.

2.4 compilation

Compilation involves two issues: compilation speed and dependency management

At present, Golang has two compilers, one is Gccgo based on GCC, and the other is a set of compilers (6g and 8g) for 64-bit x64 and 32-bit x86 computers respectively.

In terms of dependency management, since most of the third-party open source libraries of golang are on github, you can add the corresponding github path to the import of the code, and the library will be downloaded to the project's pkg directory by default.

In addition, compile time will check the usage of all entities in the code by default, and any package or variables that are not used will be compiled and failed. This is the strict side of golang.

2.5 Network programming

Because golang was born in the Internet era, it is born with decentralized, distributed and other characteristics, one of the specific manifestations is to provide rich and convenient network programming interfaces, such as socket with net.Dial (based on tcp/udp, encapsulating the traditional connect, listen, accept and other interfaces), http with http.Get/Post (), rpc with client.Call ('class_name.method_name', args, & reply), and so on.

High performance HTTP Server

2.6 function multiple return values

There are some other high-level languages that do not support the return of multiple functions in Crecast +. But this function is really needed, so in C language, the return value is generally defined as a structure, or returned in the form of a parameter reference to the function. In the go language, as a new language, the target is a powerful language, of course, we can not give up the satisfaction of this requirement, so it is necessary to support the function to return multiple values.

When the function is defined, you can add (a) after the input parameter, indicating that there will be three return values a, b, c. This feature is available in many languages, such as python.

This syntactic sugar feature is of practical significance. For example, we often ask the interface to return a triple (errno,errmsg,data). In most languages that only allow one return value, we can only return the triple in a map or array. The receiver has to write code to check that the return value contains a triple. If multiple return values are allowed, it is enforced directly at the function definition level. Make the code more concise and secure.

2.7 language interactivity

Language interactivity refers to whether the language can interact with other languages, such as libraries compiled by other languages.

Most of the C modules are directly reused in the GE language, which is called Cgo.Cgo, which allows developers to write mixed C code, and then Cgo tools can extract these mixed C codes and generate wrapper code for calling C functions. Developers can basically ignore how this boundary between Go and C is crossed.

Golang can interact with C programs, but not with C++. There are two alternatives: 1) compile C++ into a dynamic library, and then call a piece of c code by go, which dynamically invokes the dynamic library through the dlfcn library (remember export LD_LIBRARY_PATH); 2) use swig (never played)

2.8 exception handling

Golang does not support structured exception resolution such as try...catch because it feels that it will increase the amount of code and will be abused, no matter how small the exception is. The exception handling methods advocated by golang are:

Normal exception: the callee returns the error object, and the caller judges the error object.

Serious exception: refers to a disruptive panic (such as dividing by 0) that uses the defer...recover...panic mechanism to capture processing. Serious exceptions are usually automatically thrown within the golang and do not need to be thrown actively by the user to avoid the situation where the traditional try...catch is written everywhere. Of course, users can also use panic ('xxxx') to throw actively, but this degenerates this mechanism into a structured exception mechanism.

2.9 other interesting features

Type derivation: type definition: syntax such as var abc = 10 is supported to make golang look a bit like a dynamically typed language, but golang is actually strongly typed, and the previous definition is automatically deduced to be an int type.

As a strongly typed language, implicit type conversions are not allowed. Remember one principle: make everything explicit.

To put it simply, Go is a static language that writes like a dynamic language and has the efficiency of dynamic language development.

As long as a type implements all the methods of an interface, it can implement the interface without explicitly inheriting it.

The Go programming specification recommends that each Interface provide only one or two methods. This makes the purpose of each interface very clear. In addition, the implicit derivation of Go also makes us more flexible when organizing program architecture. When writing JAVA/C++ programs, we need to design the parent / subclass / interface at the beginning, because once there is a change later, it will be very painful to modify. Go is different. When you find that some methods can be abstracted into interfaces in the process of implementation, you directly define this interface and OK, other code does not need to make any changes, the automatic derivation of the compiler will help you do everything.

Cannot circulate references: that is, if b is import in a.go, b.go will report import cycle not allowed if import a. The advantage is that you can avoid some potential programming dangers, such as func1 () in a calls func2 () in b, and if func2 () can also call func1 (), it will cause an infinite loop to call.

Defer mechanism: in the go language, the keyword defer is provided, by which you can specify the logical body that needs to be delayed, that is, before the function body return or when panic appears. This mechanism is very suitable for follow-up logical processing, such as avoiding possible resource leakage problems as soon as possible.

It can be said that defer is another very important and practical language feature after goroutine and channel. The introduction of defer can simplify programming to a great extent, and appear more natural in language description, greatly enhancing the readability of the code.

The concept of "package": like python, put code with the same function in a directory, called a package. Packages can be referenced by other packages. The main package is used to generate executable files, and each program has only one main package. The main purpose of the package is to improve the reusability of the code. Other packages can be introduced through package.

Programming specification: the programming specification of the GO language is forced to be integrated into the language, such as clearly defining the location of curly braces, forcing a line, not allowing the import of unused packages, not allowing the definition of unused variables, providing gofmt tools to force formatting code, and so on. Oddly enough, these have also aroused the dissatisfaction of many programmers. Some people have published the XX charges of the GO language, including accusations against the programming specification. You know, from a project management perspective, any development team will develop specific programming specifications for a particular language, especially for companies like Google. The designers of GO believe that instead of writing specifications in documentation, it is better to force integration into the language, which is more direct and makes more use of teamwork and project management.

Cross-compilation: for example, you can develop applications running under Windows on a computer running Linux. This is the first programming language that fully supports UTF-8, not only in that it can handle strings encoded in UTF-8, but also in its source file format using UTF-8 encoding. The Go language is truly internationalized!

III. Function

Here's a short joke:

Once upon a time, there was an IT company that had a tradition of allowing employees 20% free time to develop pilot projects. One day in 2007, several of the company's Daniel were using C++ to develop some tedious but core work, mainly including huge distributed clusters. Daniel felt very annoyed, and then the C++ committee came to their company to give a speech. it is said that C++ will add about 35 new features. One of these bulls, named Rob Pike, heard 10, 000 xxx floating by, "isn't there enough features on C++? simplifying C++ should have a more sense of achievement." So, Rob Pike and several other Daniel discussed how to solve this problem, and after a while, Rob Pike said that we should make our own language, called "go", which is very short and easy to spell. The other Daniel said yes, and then they found a whiteboard and wrote down what functions they hoped to have. In the following time, Daniel happily discussed the features of designing the language. after a long time, they decided to use c as the prototype and learn from some features of other languages to liberate programmers and themselves, and then in 2009, the go language was born.

Here are the features of the Go listed by these Daniel:

Canonical syntax (no symbol table is required to parse)

Garbage collection (unique)

Headless file

Explicit dependence

No cyclic dependence

Constants can only be numbers

Int and int32 are two types.

Letter case setting visibility (letter case sets visibility)

Any type (type) has methods (not types)

No subtype inheritance (not subclass)

Package-level initialization and explicit initialization sequence

The file is compiled into a package

Package package-level globals presented in any order

There is no numeric type conversion (constants play an auxiliary role)

Implicit implementation of the interface (no "implement" declaration)

Embed (not promoted to superclass)

The method is declared according to the function (no special location requirements)

Method is function

Interface has only methods (no data)

Methods are matched by name (not by type)

No constructor and destructor

Postincrement (such as + + I) is a state, not an expression

No preincrement (iTunes +) and predecrement

Assignment is not an expression

Specify the order of evaluation in assignments and function calls (no "sequence point")

No pointer operation

Memory is always initialized with a zero value

Local variable value method

There is no "this" in the method

Segmented stack

No static and other types of comments

No template

Built-in string, slice and map

Array boundary check

This is the end of this article on "what are the core features of Go language". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, please share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.