// A RWMutex is a reader/writer mutual exclusion lock.
// The lock can be held by an arbitrary number of readers or a single writer.
// The zero value for a RWMutex is an unlocked mutex.
//
// A RWMutex must not be copied after first use.
//
// If any goroutine calls [RWMutex.Lock] while the lock is already held by
// one or more readers, concurrent calls to [RWMutex.RLock] will block until

	trace.cpuLogWrite[1].Store(trace.cpuLogRead[1])
}

// traceStartReadCPU creates a goroutine to start reading CPU profile
// data into an active trace.
//
// traceAdvanceSema must be held.
func traceStartReadCPU() {
	if !traceEnabled() {
		throw("traceStartReadCPU called with trace disabled")
	}
	// Spin up the logger goroutine.
	trace.cpuSleep = newWakeableSleep()
	done := make(chan struct{}, 1)

--------

```kotlin
implementation("com.squareup.okhttp3:okhttp-tls:4.12.0")
```

 [held_certificate]: https://square.github.io/okhttp/4.x/okhttp-tls/okhttp3.tls/-held-certificate/
 [held_certificate_builder]: https://square.github.io/okhttp/4.x/okhttp-tls/okhttp3.tls/-held-certificate/-builder/
 [handshake_certificates]: https://square.github.io/okhttp/4.x/okhttp-tls/okhttp3.tls/-handshake-certificates/

interface TrackingHttpHandler {
    /**
     * Selects a response producer to handle the given request.
     *
     * This method is called under the state lock. The handler is _not_ called under the state lock. That is, the lock is held only while selecting how to handle the request.
     *
     * This method may block until the request is ready to be handled, but must do so using a condition created from the state lock.
     *

// TF_Buffer holds a pointer to a block of data and its associated length.
// Typically, the data consists of a serialized protocol buffer, but other data
// may also be held in a buffer.
//
// By default, TF_Buffer itself does not do any memory management of the
// pointed-to block.  If need be, users of this struct should specify how to

	}
	return sb.buf.Write(p)
}

// Reset resets the buffer to be empty.
func (sb *spliceBuffer) Reset() {
	if sb.buf != nil {
		sb.buf.Reset()
	}
	sb.raw = nil
}

// Bytes returns the data held by the buffer.
func (sb *spliceBuffer) Bytes() []byte {
	if sb.buf != nil && len(sb.buf.Bytes()) > 0 {
		return sb.buf.Bytes()
	}
	if sb.raw != nil {
		return sb.raw
	}
	return []byte{}

type traceBufQueue struct {
	head, tail *traceBuf
}

// push queues buf into queue of buffers.
func (q *traceBufQueue) push(buf *traceBuf) {
	buf.link = nil
	if q.head == nil {
		q.head = buf
	} else {
		q.tail.link = buf
	}
	q.tail = buf
}

// pop dequeues from the queue of buffers.
func (q *traceBufQueue) pop() *traceBuf {
	buf := q.head
	if buf == nil {
		return nil
	}

 * that they own the hostnames that they represent. Server authentication is required.
 *
 * To perform server authentication:
 *
 *  * The server's handshake certificates must have a [held certificate][HeldCertificate] (a
 *    certificate and its private key). The certificate's subject alternative names must match the
 *    server's hostname. The server must also have is a (possibly-empty) chain of intermediate

     * Attempt to lock this resource, if not already.  Does not block.
     *
     * @return true if resource is now locked, false otherwise.
     */
    boolean tryLock();

    /**
     * Unlock this resource if it's held by the calling thread.
     */
    void unlock();

	get(key interface{}) flowcontrol.RateLimiter
}

// singleCache is a cache that only stores a single, constant item
type singleCache struct {
	// the single rate limiter held by the cache
	rateLimiter flowcontrol.RateLimiter
}

func (c *singleCache) get(key interface{}) flowcontrol.RateLimiter {
	return c.rateLimiter
}

// lruCache is a least-recently-used cache