Go语言struct之二实例化

为struct分配内存并初始化

struct的定义只是一种内存布局的描述，只有当struct实例化时，才会真正地分配内存，
//因此必须在定义struct并实例化后才能使用struct的字段。
实例化就是根据struct定义的格式创建一份与格式一致的内存区域，struct实例与实例间的内存是完全独立的。
Go语言可以通过多种方式实例化struct，根据实际需要可以选用不同的写法。

基本的实例化形式

struct本身是一种类型，可以像整型、字符串等类型一样，以 var 的方式声明struct即可完成实例化。

//基本实例化格式如下：
var ins T
//其中，T 为结构体类型，ins 为结构体的实例。

 


用结构体表示的点结构（Point）的实例化过程请参见下面的代码：

type Point struct {
    X int
    Y int
}
var p Point
p.X = 10
p.Y = 20

 

在例子中，使用.来访问结构体的成员变量，如p.X和p.Y等，struct成员变量的赋值方法与普通变量一致。

创建指针类型的结构体

Go语言中，还可以使用 new 关键字对类型（包括结构体、整型、浮点数、字符串等）进行实例化，结构体在实例化后会形成指针类型的结构体。

使用 new 的格式如下：

ins := new(T)

其中：
T 为类型，可以是结构体、整型、字符串等。
ins：T 类型被实例化后保存到 ins 变量中，ins 的类型为 *T，属于指针。

 

Go语言让我们可以像访问普通struct一样使用.来访问struct指针的成员。
下面的例子定义了一个Person的结构，Person拥有名字和岁数，实例化Person struct后，可对成员进行赋值，代码如下：

type Player struct{
    Name string
    Age int
}

p := new(Person)
p.Name = "Canon"
p.Age = 30

 

经过 new 实例化的struct实例在成员赋值上与基本实例化的写法一致。

Go语言和 c/c++

在 C/C++ 语言中，使用 new 实例化类型后，访问其成员变量时使用->操作符。

在Go语言中，访问结构体指针的成员变量时可以继续使用.，这是因为Go语言为了方便开发者访问结构体指针的成员变量，使用了 Syntactic sugar 技术，将 ins.Name 形式转换为 (*ins).Name。

取struct的地址实例化

在Go语言中，对结构体进行&取地址操作时，视为对该类型进行一次 new 的实例化操作，取地址格式如下：

ins := &T{}
其中：
//T 表示结构体类型。
//ins 为结构体的实例，类型为 *T，是指针类型。

 

下面使用struct定义一个命令行 Command，Command指令中包含名称、变量关联和注释等，对 Command 进行指针地址的实例化，并完成赋值过程，代码如下：

type Command struct {
    Name    string    // 指令名称
    Var     *int      // 指令绑定的变量
    Comment string    // 指令的注释
}
var version int = 1
cmd := &Command{}
cmd.Name = "version"
cmd.Var = &version
cmd.Comment = "show version"

 

取地址实例化是最广泛的一种struct实例化方式，可以使用函数封装上面的初始化过程，代码如下：

func newCommand(name string, varref *int, comment string) *Command {
    return &Command{
        Name:    name,
        Var:     varref,
        Comment: comment,
    }
}

cmd = newCommand(
    "version",
    &version,
    "show version",
)

 

我们看下 E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\pkg\kubelet\kubelet.go 这个源文件
首先是包引入的规则, 包括go编译器内置包，k8s相互引用包,包别名，同时涉及到两个特别的目录(staging(单独子项目被放置)和vendor(在该包下会引用staging目录内容))
一旦知道引用包的规则，那么看这些代码的位置和实现类就比较简单了.

package kubelet

import (
"context"
"crypto/tls"
"fmt"
"math"
"net"
"net/http"
"net/url"
"os"
"path"
"sort"
"strings"
"sync"
"sync/atomic"
"time"

//...kubernetes-1.10.13\vendor\github.com\golang\glog
"github.com/golang/glog"  
//...kubernetes-1.10.13\vendor\github.com\google/cadvisor/info/v1

cadvisorapi "github.com/google/cadvisor/info/v1"
cadvisorapiv2 "github.com/google/cadvisor/info/v2"

//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\staging\src\k8s.io\api\core\v1
"k8s.io/api/core/v1"
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\staging\src\k8s.io\apimachinery\pkg\apis\meta\v1
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/fields"  
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/clock"
utilruntime "k8s.io/apimachinery/pkg/util/runtime"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/apimachinery/pkg/util/wait"
utilfeature "k8s.io/apiserver/pkg/util/feature"
clientset "k8s.io/client-go/kubernetes"
v1core "k8s.io/client-go/kubernetes/typed/core/v1"
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\staging\src\k8s.io\client-go\listers\core\v1
corelisters "k8s.io/client-go/listers/core/v1"
"k8s.io/client-go/tools/cache"
"k8s.io/client-go/tools/record"
"k8s.io/client-go/util/certificate"
"k8s.io/client-go/util/flowcontrol"
"k8s.io/client-go/util/integer"
api "k8s.io/kubernetes/pkg/apis/core"

//注意k8s.io/kubernetes/路径指向的是根目录,如果你下载之后也就是 E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\staging\src\k8s.io\client-go\listers\core\v1

//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\pkg\cloudprovider
"k8s.io/kubernetes/pkg/cloudprovider"  
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\pkg\features
"k8s.io/kubernetes/pkg/features"
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\pkg\kubelet\apis\cri (容器运行时的接口)
internalapi "k8s.io/kubernetes/pkg/kubelet/apis/cri"
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\pkg\kubelet\apis\kubeletconfig
kubeletconfiginternal "k8s.io/kubernetes/pkg/kubelet/apis/kubeletconfig"
"k8s.io/kubernetes/pkg/kubelet/cadvisor"
kubeletcertificate "k8s.io/kubernetes/pkg/kubelet/certificate"
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\pkg\kubelet\cm
"k8s.io/kubernetes/pkg/kubelet/cm"
"k8s.io/kubernetes/pkg/kubelet/config"
"k8s.io/kubernetes/pkg/kubelet/configmap"
kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
"k8s.io/kubernetes/pkg/kubelet/dockershim"
dockerremote "k8s.io/kubernetes/pkg/kubelet/dockershim/remote"
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\pkg\kubelet\events
"k8s.io/kubernetes/pkg/kubelet/events"
//E:\k8s源码\kubernetes-1.10.13\kubernetes-1.10.13\pkg\kubelet\eviction
"k8s.io/kubernetes/pkg/kubelet/eviction"
"k8s.io/kubernetes/pkg/kubelet/gpu"
"k8s.io/kubernetes/pkg/kubelet/gpu/nvidia"
"k8s.io/kubernetes/pkg/kubelet/images"
"k8s.io/kubernetes/pkg/kubelet/kubeletconfig"
"k8s.io/kubernetes/pkg/kubelet/kuberuntime"
"k8s.io/kubernetes/pkg/kubelet/lifecycle"
"k8s.io/kubernetes/pkg/kubelet/logs"
"k8s.io/kubernetes/pkg/kubelet/metrics"
"k8s.io/kubernetes/pkg/kubelet/metrics/collectors"
"k8s.io/kubernetes/pkg/kubelet/network"
"k8s.io/kubernetes/pkg/kubelet/network/dns"
"k8s.io/kubernetes/pkg/kubelet/pleg"
kubepod "k8s.io/kubernetes/pkg/kubelet/pod"
"k8s.io/kubernetes/pkg/kubelet/preemption"
"k8s.io/kubernetes/pkg/kubelet/prober"
proberesults "k8s.io/kubernetes/pkg/kubelet/prober/results"
"k8s.io/kubernetes/pkg/kubelet/remote"
"k8s.io/kubernetes/pkg/kubelet/rkt"
"k8s.io/kubernetes/pkg/kubelet/secret"
"k8s.io/kubernetes/pkg/kubelet/server"
serverstats "k8s.io/kubernetes/pkg/kubelet/server/stats"
"k8s.io/kubernetes/pkg/kubelet/server/streaming"
"k8s.io/kubernetes/pkg/kubelet/stats"
"k8s.io/kubernetes/pkg/kubelet/status"
"k8s.io/kubernetes/pkg/kubelet/sysctl"
kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
"k8s.io/kubernetes/pkg/kubelet/util/format"
"k8s.io/kubernetes/pkg/kubelet/util/queue"
"k8s.io/kubernetes/pkg/kubelet/util/sliceutils"
"k8s.io/kubernetes/pkg/kubelet/volumemanager"
"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
"k8s.io/kubernetes/pkg/security/apparmor"
utildbus "k8s.io/kubernetes/pkg/util/dbus"
kubeio "k8s.io/kubernetes/pkg/util/io"
utilipt "k8s.io/kubernetes/pkg/util/iptables"
"k8s.io/kubernetes/pkg/util/mount"
nodeutil "k8s.io/kubernetes/pkg/util/node"
"k8s.io/kubernetes/pkg/util/oom"
"k8s.io/kubernetes/pkg/volume"
utilexec "k8s.io/utils/exec"
)


//一个复杂的结构体
type Kubelet struct {
    kubeletConfiguration kubeletconfiginternal.KubeletConfiguration
    hostname        string
    nodeName        types.NodeName
    runtimeCache    kubecontainer.RuntimeCache
    kubeClient      clientset.Interface
    heartbeatClient v1core.CoreV1Interface
    iptClient       utilipt.Interface
    rootDirectory   string

    // onRepeatedHeartbeatFailure is called when a heartbeat operation fails more than once. optional.
    onRepeatedHeartbeatFailure func()

    // podWorkers handle syncing Pods in response to events.
    podWorkers PodWorkers

    // resyncInterval is the interval between periodic full reconciliations of
    // pods on this node.
    resyncInterval time.Duration

    // sourcesReady records the sources seen by the kubelet, it is thread-safe.
    sourcesReady config.SourcesReady

    // podManager is a facade that abstracts away the various sources of pods
    // this Kubelet services.
    podManager kubepod.Manager

    // Needed to observe and respond to situations that could impact node stability
    evictionManager eviction.Manager

    // Optional, defaults to /logs/ from /var/log
    logServer http.Handler
    // Optional, defaults to simple Docker implementation
    runner kubecontainer.ContainerCommandRunner

    // cAdvisor used for container information.
    cadvisor cadvisor.Interface

    // Set to true to have the node register itself with the apiserver.
    registerNode bool
    // List of taints to add to a node object when the kubelet registers itself.
    registerWithTaints []api.Taint
    // Set to true to have the node register itself as schedulable.
    registerSchedulable bool
    // for internal book keeping; access only from within registerWithApiserver
    registrationCompleted bool

    // dnsConfigurer is used for setting up DNS resolver configuration when launching pods.
    dnsConfigurer *dns.Configurer

    // masterServiceNamespace is the namespace that the master service is exposed in.
    masterServiceNamespace string
    // serviceLister knows how to list services
    serviceLister serviceLister
    // nodeInfo knows how to get information about the node for this kubelet.
    nodeInfo predicates.NodeInfo

    // a list of node labels to register
    nodeLabels map[string]string

    // Last timestamp when runtime responded on ping.
    // Mutex is used to protect this value.
    runtimeState *runtimeState

    // Volume plugins.
    volumePluginMgr *volume.VolumePluginMgr

    // Network plugin.
    networkPlugin network.NetworkPlugin

    // Handles container probing.
    probeManager prober.Manager
    // Manages container health check results.
    livenessManager proberesults.Manager

    // How long to keep idle streaming command execution/port forwarding
    // connections open before terminating them
    streamingConnectionIdleTimeout time.Duration

    // The EventRecorder to use
    recorder record.EventRecorder

    // Policy for handling garbage collection of dead containers.
    containerGC kubecontainer.ContainerGC

    // Manager for image garbage collection.
    imageManager images.ImageGCManager

    // Manager for container logs.
    containerLogManager logs.ContainerLogManager

    // Secret manager.
    secretManager secret.Manager

    // ConfigMap manager.
    configMapManager configmap.Manager

    // Cached MachineInfo returned by cadvisor.
    machineInfo *cadvisorapi.MachineInfo

    //Cached RootFsInfo returned by cadvisor
    rootfsInfo *cadvisorapiv2.FsInfo

    // Handles certificate rotations.
    serverCertificateManager certificate.Manager

    // Syncs pods statuses with apiserver; also used as a cache of statuses.
    statusManager status.Manager

    // VolumeManager runs a set of asynchronous loops that figure out which
    // volumes need to be attached/mounted/unmounted/detached based on the pods
    // scheduled on this node and makes it so.
    volumeManager volumemanager.VolumeManager

    // Cloud provider interface.
    cloud cloudprovider.Interface

    // Indicates that the node initialization happens in an external cloud controller
    externalCloudProvider bool
    // Reference to this node.
    nodeRef *v1.ObjectReference

    // The name of the container runtime
    containerRuntimeName string

    // Container runtime.
    containerRuntime kubecontainer.Runtime

    // Container runtime service (needed by container runtime Start()).
    // TODO(CD): try to make this available without holding a reference in this
    //           struct. For example, by adding a getter to generic runtime.
    runtimeService internalapi.RuntimeService

    // reasonCache caches the failure reason of the last creation of all containers, which is
    // used for generating ContainerStatus.
    reasonCache *ReasonCache
    // nodeStatusUpdateFrequency specifies how often kubelet posts node status to master.
    // Note: be cautious when changing the constant, it must work with nodeMonitorGracePeriod
    // in nodecontroller. There are several constraints:
    // 1. nodeMonitorGracePeriod must be N times more than nodeStatusUpdateFrequency, where
    //    N means number of retries allowed for kubelet to post node status. It is pointless
    //    to make nodeMonitorGracePeriod be less than nodeStatusUpdateFrequency, since there
    //    will only be fresh values from Kubelet at an interval of nodeStatusUpdateFrequency.
    //    The constant must be less than podEvictionTimeout.
    // 2. nodeStatusUpdateFrequency needs to be large enough for kubelet to generate node
    //    status. Kubelet may fail to update node status reliably if the value is too small,
    //    as it takes time to gather all necessary node information.
    nodeStatusUpdateFrequency time.Duration
    // Generates pod events.
    pleg pleg.PodLifecycleEventGenerator

    // Store kubecontainer.PodStatus for all pods.
    podCache kubecontainer.Cache

    // os is a facade for various syscalls that need to be mocked during testing.
    os kubecontainer.OSInterface

    // Watcher of out of memory events.
    oomWatcher OOMWatcher

    // Monitor resource usage
    resourceAnalyzer serverstats.ResourceAnalyzer

    // Whether or not we should have the QOS cgroup hierarchy for resource management
    cgroupsPerQOS bool

    // If non-empty, pass this to the container runtime as the root cgroup.
    cgroupRoot string

    // Mounter to use for volumes.
    mounter mount.Interface

    // Writer interface to use for volumes.
    writer kubeio.Writer

    // Manager of non-Runtime containers.
    containerManager cm.ContainerManager

    // Maximum Number of Pods which can be run by this Kubelet
    maxPods int

    // Monitor Kubelet's sync loop
    syncLoopMonitor atomic.Value

    // Container restart Backoff
    backOff *flowcontrol.Backoff

    // Channel for sending pods to kill.
    podKillingCh chan *kubecontainer.PodPair

    // Information about the ports which are opened by daemons on Node running this Kubelet server.
    daemonEndpoints *v1.NodeDaemonEndpoints

    // A queue used to trigger pod workers.
    workQueue queue.WorkQueue

    // oneTimeInitializer is used to initialize modules that are dependent on the runtime to be up.
    oneTimeInitializer sync.Once

    // If non-nil, use this IP address for the node
    nodeIP net.IP

    // use this function to validate the kubelet nodeIP
    nodeIPValidator func(net.IP) error

    // If non-nil, this is a unique identifier for the node in an external database, eg. cloudprovider
    providerID string

    // clock is an interface that provides time related functionality in a way that makes it
    // easy to test the code.
    clock clock.Clock

    // handlers called during the tryUpdateNodeStatus cycle
    setNodeStatusFuncs []func(*v1.Node) error

    // TODO: think about moving this to be centralized in PodWorkers in follow-on.
    // the list of handlers to call during pod admission.
    admitHandlers lifecycle.PodAdmitHandlers

    // softAdmithandlers are applied to the pod after it is admitted by the Kubelet, but before it is
    // run. A pod rejected by a softAdmitHandler will be left in a Pending state indefinitely. If a
    // rejected pod should not be recreated, or the scheduler is not aware of the rejection rule, the
    // admission rule should be applied by a softAdmitHandler.
    softAdmitHandlers lifecycle.PodAdmitHandlers

    // the list of handlers to call during pod sync loop.
    lifecycle.PodSyncLoopHandlers

    // the list of handlers to call during pod sync.
    lifecycle.PodSyncHandlers

    // the number of allowed pods per core
    podsPerCore int

    // enableControllerAttachDetach indicates the Attach/Detach controller
    // should manage attachment/detachment of volumes scheduled to this node,
    // and disable kubelet from executing any attach/detach operations
    enableControllerAttachDetach bool

    // trigger deleting containers in a pod
    containerDeletor *podContainerDeletor

    // config iptables util rules
    makeIPTablesUtilChains bool

    // The bit of the fwmark space to mark packets for SNAT.
    iptablesMasqueradeBit int

    // The bit of the fwmark space to mark packets for dropping.
    iptablesDropBit int

    // The AppArmor validator for checking whether AppArmor is supported.
    appArmorValidator apparmor.Validator

    // The handler serving CRI streaming calls (exec/attach/port-forward).
    criHandler http.Handler

    // experimentalHostUserNamespaceDefaulting sets userns=true when users request host namespaces (pid, ipc, net),
    // are using non-namespaced capabilities (mknod, sys_time, sys_module), the pod contains a privileged container,
    // or using host path volumes.
    // This should only be enabled when the container runtime is performing user remapping AND if the
    // experimental behavior is desired.
    experimentalHostUserNamespaceDefaulting bool

    // GPU Manager
    gpuManager gpu.GPUManager

    // dockerLegacyService contains some legacy methods for backward compatibility.
    // It should be set only when docker is using non json-file logging driver.
    dockerLegacyService dockershim.DockerLegacyService

    // StatsProvider provides the node and the container stats.
    *stats.StatsProvider

    // containerized should be set to true if the kubelet is running in a container
    containerized bool

    // This flag, if set, instructs the kubelet to keep volumes from terminated pods mounted to the node.
    // This can be useful for debugging volume related issues.
    keepTerminatedPodVolumes bool // DEPRECATED
}

 



 

posted @ 2022-05-20 16:36  jinzi  阅读(11)  评论(0)  编辑  收藏  举报