是否可以在没有线程的情况下使用异步回调

Javascript是解释语言，可以执行异步非阻塞回调，例如：

Javascript is interpreted language and can do asynchronous non-blocking callbacks like:

/* --- in a script tag --- */
function hello9000(msg, callback)
{
        console.log("hello9000 started");
        setTimeout(function()
        {
                callback(msg);
        }, 9000);
        console.log("hello9000 loading");
}

function hello6000(msg, callback)
{
        console.log("hello6000 started");
        setTimeout(function()
        {
                callback(msg);
        }, 6000);
        console.log("hello6000 loading");
}

function hello3000(msg, callback)
{
        console.log("hello3000 started");
        setTimeout(function()
        {
                callback(msg);
        }, 3000);
        console.log("hello3000 loading");
}

hello9000("hello9000 ended", function(msg)
{
        console.log(msg);
});

hello6000("hello6000 ended", function(msg)
{
        console.log(msg);
});

hello3000("hello3000 ended", function(msg)
{
        console.log(msg);
});

C＃是用时间语言编译的，你也可以进行异步非阻塞回调。但是有一个问题 - 当我不使用线程时它会阻塞整个代码。我只能手动为每个包含回调的函数创建新线程。



我的代码等效（虽然不是真正等效），但上面是：

C# is compiled just in time language and you can do asynchronous non-blocking callbacks too. But there is one problem - When I do not use threads it's blocking the whole code. I can do it only with manually making new threads for each function containing callback.

My code "equivalent" (although not really equivalent) for the above is:

/* --- in the class --- */
public static void hello9000(string message)
{
        Console.WriteLine("hello9000 loading");
        //this throttling isn't correct
        Stopwatch timer = new Stopwatch();
        timer.Start();
        while (timer.ElapsedMilliseconds < 9000){}
        timer.Stop();
        Console.WriteLine(message);
}
        
public static void hello6000(string message)
{
        Console.WriteLine("hello6000 loading");
        //this throttling isn't correct
        Stopwatch timer = new Stopwatch();
        timer.Start();
        while (timer.ElapsedMilliseconds < 6000){}
        timer.Stop();
        Console.WriteLine(message);
}
        
public static void hello3000(string message)
{
        Console.WriteLine("hello3000 loading");
        //this throttling isn't correct
        Stopwatch timer = new Stopwatch();
        timer.Start();
        while (timer.ElapsedMilliseconds < 3000){}
        timer.Stop();
        Console.WriteLine(message);
}
        
public static void printName(string message, Action<string> callback)
{
        callback(message);
}

/* --- in the main function --- */
/* 
this for instance is blocking
printName("hello9000 ended", hello9000);
printName("hello6000 ended", hello6000);
printName("hello3000 ended", hello3000);
*/
Thread thread9000 = new Thread(new ThreadStart(delegate()
{
        printName("hello9000 ended", hello9000);
}));
Thread thread6000 = new Thread(new ThreadStart(delegate()
{
        printName("hello6000 ended", hello6000);
}));
Thread thread3000 = new Thread(new ThreadStart(delegate()
{
        printName("hello3000 ended", hello3000);
}));

thread9000.Start();
thread6000.Start();
thread3000.Start();

有没有办法做这种类型的回调调用非阻塞而不需要手动制作线程？这是否意味着Javascript在检测到这种模式时会自动创建线程？怎么样的Java - 它的行为就像C＃（或C＃就像Java一样）：

Is there a way of doing this type callback calling non-blocking without the need of making threads manually? Does that mean that Javascript is making threads automatically when detect such pattern? What about Java - it's acting like C# (or C# acts like Java):

//only the threads
Thread hello9000 = new Thread(new Runnable()
{
        public void run()
        {
                System.out.println("hello9000 started");
                try
                {
                        Thread.sleep(9000);
                }
                catch(InterruptedException exc){
                        System.out.println(exc);
                }
                System.out.println("hello9000 ended");
                return;
        }
});
Thread hello6000 = new Thread(new Runnable()
{
        public void run()
        {
                System.out.println("hello6000 started");
                try
                {
                    Thread.sleep(6000);
                }
                catch(InterruptedException exc)
                {
                    System.out.println(exc);
                }
                System.out.println("hello6000 ended");
                return;
        }
});
Thread hello3000 = new Thread(new Runnable()
{
        public void run()
        {
                System.out.println("hello3000 started");
                try
                {
                    Thread.sleep(3000);
                }
                catch(InterruptedException exc)
                {
                    System.out.println(exc);
                }
                System.out.println("hello3000 ended");
                return;
        }
});

hello9000.start();
hello6000.start();
hello3000.start();