assertFalse(completed);
    thread.start();
    thread.join();
    assertTrue(completed);

    // Creating a new thread from the same ThreadFactory will have the same
    // pool ID but a thread ID of 2.
    Thread thread2 = threadFactory.newThread(monitoredRunnable);
    checkThreadPoolName(thread2, 2);
    assertEquals(

    assertFalse(completed);
    thread.start();
    thread.join();
    assertTrue(completed);

    // Creating a new thread from the same ThreadFactory will have the same
    // pool ID but a thread ID of 2.
    Thread thread2 = threadFactory.newThread(monitoredRunnable);
    checkThreadPoolName(thread2, 2);
    assertEquals(

Yan Zhulanow <******@****.***> 1633428486 +0900

	started    = atomic.Uint32{}
)

// same as CTHREADS in C, make sure all the C threads are actually started.
const cThreadNum = 2

func init() {
	register("EnsureBindM", EnsureBindM)
}

//export GoCheckBindM
func GoCheckBindM(thread uintptr) {
	// Wait all threads start
	if started.Load() != cThreadNum {
		// Only once for each thread, since it will wait all threads start.
		started.Add(1)

	for(i=0; i<nthread; i++)
		pthread_join(thread_id[i], 0);		
}

static void*
goDummyCallbackThread(void* p)
{
	int i, max;

	max = *(int*)p;
	for(i=0; i<max; i++)
		goDummy();
	return NULL;
}

int
callGoInCThread(int max)
{
	pthread_t thread;

	if (pthread_create(&thread, NULL, goDummyCallbackThread, (void*)(&max)) != 0)
		return -1;
	if (pthread_join(thread, NULL) != 0)
		return -1;

//
// cgocallback on a new thread calls into runtime.needm -> _cgo_getstackbound
// to update gp.stack.lo with the stack bounds. If the G itself is passed to
// _cgo_getstackbound, then writes to the same G can be seen on multiple
// threads (when the G is reused after thread exit). This would trigger TSAN.

/*
#include <pthread.h>

void go_callback();

static void *thr(void *arg) {

                logger.log "timeout waiting for ${threads.size()} threads to complete"
                threads.each { thread ->
                    IllegalStateException e = new IllegalStateException("Timeout waiting for ${thread.name} to complete.")
                    e.stackTrace = thread.stackTrace
                    if (failure == null) {
                        failure = e
                    } else {

    // Thread#setPriority() already checks for validity. These error messages
    // are nicer though and will fail-fast.
    checkArgument(
        priority >= Thread.MIN_PRIORITY,
        "Thread priority (%s) must be >= %s",
        priority,
        Thread.MIN_PRIORITY);
    checkArgument(
        priority <= Thread.MAX_PRIORITY,
        "Thread priority (%s) must be <= %s",
        priority,
        Thread.MAX_PRIORITY);

 * <p>
 * This builder uses a number of threads equal to the minimum of the degree of concurrency (which is the thread count
 * set with <code>-T</code> on the command-line) and the number of projects to build. As such, building a single project
 * will always result in a sequential build, regardless of the thread count.
 * </p>

    // Thread#setPriority() already checks for validity. These error messages
    // are nicer though and will fail-fast.
    checkArgument(
        priority >= Thread.MIN_PRIORITY,
        "Thread priority (%s) must be >= %s",
        priority,
        Thread.MIN_PRIORITY);
    checkArgument(
        priority <= Thread.MAX_PRIORITY,
        "Thread priority (%s) must be <= %s",
        priority,
        Thread.MAX_PRIORITY);