static std::unordered_map<std::string, void*>* loaded_libs =
      new std::unordered_map<std::string, void*>();
  tensorflow::Env* env = tensorflow::Env::Default();
  {
    tensorflow::mutex_lock lock(mu);
    auto it = loaded_libs->find(library_filename);
    if (it != loaded_libs->end()) {
      lib_handle->lib_handle = it->second;
    } else {
      status->status =

```

1. 这是第一阶段，称为`requirements-stage`。

2. 将 `/tmp` 设置为当前工作目录。

     这是我们生成文件`requirements.txt`的地方

3. 在此阶段安装Poetry。

4. 将`pyproject.toml`和`poetry.lock`文件复制到`/tmp`目录。

     因为它使用 `./poetry.lock*` （以 `*` 结尾），所以如果该文件尚不可用，它不会崩溃。

5. 生成`requirements.txt`文件。

6. 这是最后阶段，这里的任何内容都将保留在最终的容器镜像中。

7. 将当前工作目录设置为`/code`。

8. 将 `requirements.txt` 文件复制到 `/code` 目录。

	quarkus/extensions/vertx/deployment/pom.xml
	quarkus/extensions/jackson/deployment/pom.xml
	quarkus/test-framework/junit5-internal/pom.xml
	quarkus/core/junit4-mock/pom.xml
	quarkus/extensions/resteasy-classic/resteasy/deployment/pom.xml
	quarkus/extensions/devservices/deployment/pom.xml
quarkus/extensions/resteasy-reactive/quarkus-resteasy-reactive-jackson/deployment/pom.xml

      "norwegian_stop": {
        "type":       "stop",
        "stopwords":  "_norwegian_"
      },
      "norwegian_keywords": {
        "type":       "keyword_marker",
        "keywords": ["Hallo", "verden", "Søk"]
      },
      "norwegian_stemmer": {
        "type":       "stemmer",
        "language":   "norwegian"
      },
      "persian_stop": {
        "type":       "stop",

			newAcc := &AccElem{}
			old := e.cached.Swap(newAcc)
			var a AccElem
			a.Size = atomic.LoadInt64(&old.Size)
			a.Total = atomic.LoadInt64(&old.Total)
			a.N = atomic.LoadInt64(&old.N)
			e.mu.Lock()
			e.lastMinuteLatency.addAll(t-1, a)
			e.mu.Unlock()
			acc = newAcc
		} else {
			// We may be able to grab the new accumulator by yielding.
			runtime.Gosched()
			acc = e.cached.Load()
		}
	}

// a goroutine that will attempt to reconnect if HealthCheckFn is set.
// returns true if the node changed state from online to offline
func (c *Client) MarkOffline(err error) bool {
	c.Lock()
	c.lastErr = err
	c.lastErrTime = time.Now()
	atomic.StoreInt64(&c.lastConn, time.Now().UnixNano())
	c.Unlock()

	return c.runHealthCheck()

	<-reqStarted

	// Block until we have exceeded the deadline several times over.
	nowBlocking := make(chan struct{})
	var mu sync.Mutex
	time.AfterFunc(time.Second, func() {
		mu.Lock()
		cancel()
		close(nowBlocking)
		mu.Unlock()
	})
	if inCap > 0 {
		go func() {
			defer close(st.Requests)
			if !blockReq {
				<-nowBlocking
				return
			}
			for {

#### PushContext

`PushContext` is an immutable snapshot of the current state of the world. It is regenerated (usually partially) on each configuration push (more on this below). Due to being a snapshot, most lookups are lock-free.

        Exception ex0 = null;

        try {
            /*
             * We cannot synchronize (run_thread) here or the caller's
             * thread.wait( timeout ) cannot reaquire the lock and
             * return which would render the timeout effectively useless.
             */
            if ( this.state != 5 && this.state != 6 ) {
                doConnect();
            }
        }

	}
}

// LockAndSetBuckets - locks the buckets and sets the given buckets. It returns
// a function to unlock the buckets.
func (mg *MetricsGroup) LockAndSetBuckets(buckets []string) func() {
	mg.bucketsLock.Lock()
	mg.buckets = buckets
	return func() {
		mg.bucketsLock.Unlock()
	}
}

// MetricFQN - returns the fully qualified name for the given metric name.