Java : 子线程是否锁定了主线程？

Question

我是Java的新手，我想启动02线程来增加一个对象的属性，我想打印出这个属性的值，直到它达到某个值。我使用 increaseByThread() 方法中启动的 02 个线程。

我使用如下两个代码片段，但它们的行为不同。第一个我在主线程中使用 while 循环来检查值的变化，但它只在两个子线程完成后打印出最后一个值运行和 return 40.

第二个我使用 while 循环但在另一个子线程中检查值并打印出每个值，这意味着 03 个子线程是运行并行（请参阅下面的第二个片段)

我的问题是，为什么在第一个片段中，while 循环块仅在 test.increaseByThread() 完成执行后调用？

public class ThreadIncrease {
    public volatile int[] count={0};
     public void increaseByThread(){
         Runnable first= () -> {
             for(int i=0;i<20;i++) {
                 count[0] = count[0] + 1;
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
//                 System.out.println(count[0]);
             }

         };

         Runnable second= () -> {
             for(int i=0;i<20;i++) {
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 count[0] = count[0] + 1;
//                 System.out.println(count[0]);
             }

         };
         Thread firstThread=new Thread(first);
         Thread secondThread=new Thread(second);
         firstThread.run();
         secondThread.run();
     }

    public static void main(String[] args) {
        ThreadIncrease test=new ThreadIncrease();
        Runnable check=()->{
            while(true){
                System.out.println(test.count[0]);
                if(test.count[0]<10){
                    System.out.println("count is: "+test.count[0]);
                }
                else{
                    System.out.println("Break");
                    break;
                }
            }
        };
//        Thread checkThread=new Thread(check);
//        checkThread.start();

        test.increaseByThread();
        while(true){
            System.out.println(test.count[0]);
            if(test.count[0]<10){
                System.out.println("count is: "+test.count[0]);
            }
            else{
                System.out.println("Break");
                break;
            }
        }

    }

}

第二个我使用 while 循环但在另一个子线程中检查值并打印出每个值，这意味着 03 个子线程是运行并行的：

    public class ThreadIncrease {
    public volatile int[] count={0};
     public void increaseByThread(){
         Runnable first= () -> {
             for(int i=0;i<20;i++) {
                 count[0] = count[0] + 1;
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
//                 System.out.println(count[0]);
             }

         };

         Runnable second= () -> {
             for(int i=0;i<20;i++) {
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 count[0] = count[0] + 1;
//                 System.out.println(count[0]);
             }

         };
         Thread firstThread=new Thread(first);
         Thread secondThread=new Thread(second);
         firstThread.run();
         secondThread.run();
     }

    public static void main(String[] args) {
        ThreadIncrease test=new ThreadIncrease();
        Runnable check=()->{
            while(true){
                System.out.println(test.count[0]);
                if(test.count[0]<10){
                    System.out.println("count is: "+test.count[0]);
                }
                else{
                    System.out.println("Break");
                    break;
                }
            }
        };
        Thread checkThread=new Thread(check);
        checkThread.start();

        test.increaseByThread();
//        while(true){
//            System.out.println(test.count[0]);
//            if(test.count[0]<10){
//                System.out.println("count is: "+test.count[0]);
//            }
//            else{
//                System.out.println("Break");
//                break;
//            }
//        }

    }

}

Answer 1

Thread.run()，您在 increaseByThread() 运行中调用当前线程 Runnable 中的线程 。我认为您将它与 Thread.start() 混淆了，它会启动一个新线程运行 the Runnable.

见What's the difference between Thread start() and Runnable run() and When would you call java's thread.run() instead of thread.start()?

Answer 2

您还没有开始任何新话题。

每个线程都需要运行一些东西。那就是它的运行方法。但是通过调用 thread.run，您只需在调用线程（即您的主线程）上执行该代码。

相反，您需要使用 thread.start() 启动新线程。这个函数会立即return，新创建的线程会并行执行运行()

由于您运行将所有内容都放在主线程上，所以主线程被阻塞直到所有运行完成。

的看法是正确的。

Java : 子线程是否锁定了主线程？

Java : Are sub threads lock the main thread?

java

multithreading