total.get() == 123 * concurrency * 2
    }

    def "atomic lazy can handle concurrent threads"() {
        def mutableValueSource = new AtomicInteger()
        Lazy<Integer> lazy = Lazy.atomic().of(mutableValueSource::incrementAndGet)

        when: 'multiple threads access a lazy built from a supplier that can return different values'
        int concurrency = 20

	gogc := debug.SetGCPercent(100)
	debug.SetGCPercent(gogc)
}

// Regression test for https://go.dev/issue/62440. It should be possible for C
// threads to call into Go from different stacks without crashing due to g0
// stack bounds checks.
//
// N.B. This is only OK for threads created in C. Threads with Go frames up the
// stack must not change the stack out from under us.
func StackSwitchCallback() {
	C.callStackSwitchCallbackFromThread()

            threads[i].setDaemon(daemon);
            threads[i].setPriority(threadPriority);
        }

        // run
        crawlerContext.setStatus(CrawlerStatus.RUNNING);
        for (int i = 0; i < crawlerContext.numOfThread; i++) {
            threads[i].start();
        }

        // join

        }
        def threads = [new Thread(work1), new Thread(work2)]

        when:
        def failure = null
        threads.forEach { it.uncaughtExceptionHandler = new Thread.UncaughtExceptionHandler() {
            @Override
            void uncaughtException(Thread t, Throwable e) {
                failure = e
            }
        }}
        threads.forEach { it.start() }

        }
    }

    /**
     * Waits for all threads to complete. Asserts that the threads complete in a 'short' time. Rethrows any exceptions thrown by test threads.
     */
    void finished() {
        Date timeout = shortTimeout()
        lock.lock()
        try {
            LOG.info("Waiting for test threads to complete.")
            while (!threads.isEmpty()) {

  bool AllRunnersStopped();

  /// Requests all running threads to stop.
  Status RequestStop();

  /// Returns true if its RequestStop() has been called.
  bool ShouldStop();

  /// Joins all threads, returns OK or the first reported and unexpected status.
  Status Join();

  /// Reports status to the coordinator. This is usually called by threads.
  void ReportStatus(const Status& status);

            });
        }

        for (Thread th : threads) {
            th.start();
        }
        for (Thread th : threads) {
            th.join();
        }
        assertEquals(num, count.get());
        assertEquals(num, valueSet.size());

        Set<String> valueSet2 = Collections.synchronizedSet(new HashSet<>());
        threads = new Thread[threadNum];

        failure.assertHasCause("Invalid number of threads '-1'.  Number should not be negative.")
        // pmdMain and pmdTest
        failure.assertHasFailures(2)
    }

    def "gets reasonable message when number of threads is negative from task"() {
        goodCode()
        buildFile << """
            pmdMain {
                threads = -1
            }
        """

        expect:

                    def threadGroup = Thread.currentThread().threadGroup
                    def threads = new Thread[threadGroup.activeCount()]
                    threadGroup.enumerate(threads)
                    return threads.findAll { it?.name?.startsWith("${WorkerExecutionQueueFactory.QUEUE_DISPLAY_NAME}") }
                }
            }

            task runInWorker(type: NestingWorkerTask) {

name: 'Lock Threads'

on:
  schedule:
    - cron: '0 0 * * *'
  workflow_dispatch:

permissions:
  issues: write

concurrency:
  group: lock

jobs:
  action:
    runs-on: ubuntu-latest
    steps:
      - uses: dessant/lock-threads@v3
        with:
          github-token: ${{ github.token }}
          issue-inactive-days: '365'
          exclude-any-issue-labels: 'do-not-close'