func Run(c *config.CompletedConfig, stopCh <-chan struct{}) error {
  ...

  // Start the main lock
  go leaderElectAndRun(c, id, electionChecker,
    c.ComponentConfig.Generic.LeaderElection.ResourceLock,
    c.ComponentConfig.Generic.LeaderElection.ResourceName,
    leaderelection.LeaderCallbacks{
      // 成为leader后的执行逻辑：
      OnStartedLeading: func(ctx context.Context) {
        initializersFunc := NewControllerInitializers
        if leaderMigrator != nil {
          // If leader migration is enabled, we should start only non-migrated controllers
          //  for the main lock.
          initializersFunc = createInitializersFunc(leaderMigrator.FilterFunc, leadermigration.ControllerNonMigrated)
          klog.Info("leader migration: starting main controllers.")
        }
        run(ctx, startSATokenController, initializersFunc)
      },
      // 失去leader地位后的执行逻辑：
      OnStoppedLeading: func() {
        klog.Fatalf("leaderelection lost")
      },
    })

  ...
}

func leaderElectAndRun(c *config.CompletedConfig, lockIdentity string, electionChecker *leaderelection.HealthzAdaptor, resourceLock string, leaseName string, callbacks leaderelection.LeaderCallbacks) {
  ...

  leaderelection.RunOrDie(context.TODO(), leaderelection.LeaderElectionConfig{
    // Lock:          资源锁对象
    // LeaseDuration: 租约时长，非leader的副本用来判断资源锁是否过期
    // RenewDeadline: leader获取资源锁的超时时间，超过这个时间将放弃资源锁
    // RetryPeriod:   重试间隔，俩次尝试获取锁之间应该等待的时间
    // Callbacks:     回调函数，由leadereletion的事件触发对应的逻辑，如上面Run代码所示
    // WatchDog:      用于健康检查，非必须
    // Name:          资源锁的名字，用于debug打印
    Lock:          rl,
    LeaseDuration: c.ComponentConfig.Generic.LeaderElection.LeaseDuration.Duration,
    RenewDeadline: c.ComponentConfig.Generic.LeaderElection.RenewDeadline.Duration,
    RetryPeriod:   c.ComponentConfig.Generic.LeaderElection.RetryPeriod.Duration,
    Callbacks:     callbacks,
    WatchDog:      electionChecker,
    Name:          leaseName,
  })

  panic("unreachable")
}

func (le *LeaderElector) Run(ctx context.Context) {
  defer runtime.HandleCrash()
  defer func() {
    le.config.Callbacks.OnStoppedLeading()
  }()

  // 尝试获取锁，失败即退出
  if !le.acquire(ctx) {
    return // ctx signalled done
  }
  // 获取锁后，执行OnStartedLeading回调函数，通过renew中的代码持续刷新锁状态
  ctx, cancel := context.WithCancel(ctx)
  defer cancel()
  go le.config.Callbacks.OnStartedLeading(ctx)
  le.renew(ctx)
  // renew刷新锁失败后退出循环，此时Run函数结束，执行defer中的OnStoppedLeading回调函数
}

func (le *LeaderElector) tryAcquireOrRenew(ctx context.Context) bool {
  ...
  // 1. obtain or create the ElectionRecord
  // 1. 第一步，获取一个锁信息的记录，若不存在记录，则创建一个。
  oldLeaderElectionRecord, oldLeaderElectionRawRecord, err := le.config.Lock.Get(ctx)
  if err != nil {
    if !errors.IsNotFound(err) {
      klog.Errorf("error retrieving resource lock %v: %v", le.config.Lock.Describe(), err)
      return false
    }
    if err = le.config.Lock.Create(ctx, leaderElectionRecord); err != nil {
      klog.Errorf("error initially creating leader election record: %v", err)
      return false
    }

    le.setObservedRecord(&leaderElectionRecord)

    return true
  }

  // 2. Record obtained, check the Identity & Time
  // 2. 将刚获取的锁信息记录下来（加一层byte Equal为了减少更新记录的次数）；非leader检查锁信息后，发现锁未过期，则打印日志后退出
  if !bytes.Equal(le.observedRawRecord, oldLeaderElectionRawRecord) {
    le.setObservedRecord(oldLeaderElectionRecord)

    le.observedRawRecord = oldLeaderElectionRawRecord // 单纯为了比较动作快一点，这里同时会把byte流保存下来，然后通过byte流比较
  }
  if len(oldLeaderElectionRecord.HolderIdentity) > 0 &&
    le.observedTime.Add(le.config.LeaseDuration).After(now.Time) &&
    !le.IsLeader() {
    klog.V(4).Infof("lock is held by %v and has not yet expired", oldLeaderElectionRecord.HolderIdentity)
    return false
  }

  // 3. We're going to try to update. The leaderElectionRecord is set to it's default
  // here. Let's correct it before updating.
  // 3. 如果是leader，则尝试刷新锁；如果是非leader，则尝试抢占锁。刷新和抢占锁是通过将自己的信息更新到锁上实现的。
  if le.IsLeader() {
    leaderElectionRecord.AcquireTime = oldLeaderElectionRecord.AcquireTime
    leaderElectionRecord.LeaderTransitions = oldLeaderElectionRecord.LeaderTransitions
  } else {
    leaderElectionRecord.LeaderTransitions = oldLeaderElectionRecord.LeaderTransitions + 1
  }

  // update the lock itself 
  if err = le.config.Lock.Update(ctx, leaderElectionRecord); err != nil {
    klog.Errorf("Failed to update lock: %v", err)
    return false
  }

  le.setObservedRecord(&leaderElectionRecord)
  return true
}