Java线程：请澄清这种理解

问题：

如果理解正确，请澄清以下内容

调用

john.sayHi（）

时，线程

thread1

已获取内部 锁定

john

对象，以访问

john

对象的

sayHi（）

方法

线程

thread1

在JVM中独立运行

public class Qn {

    static class Friend {
        private final String name;

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        // recipient - the person who greets
        public synchronized void sayHi(Friend recipient) {
            System.out.format("%s" + " said hi to %s %n",
                      this.name, recipient.getName());
        }
    }

    public static void main(String[] args) {
        final Friend john = new Friend("John");
        final Friend peter = new Friend("Peter");

        new Thread(new Runnable() {
            public void run() {
                john.sayHi(peter);
            }
        }, "thread1").start();
    }
}

我在网上读到这些声明，不知道它们是什么意思！[线程如何在对象上运行！！！事实线程执行代码，对吗？]

线程

thread1

未在JVM内的任何其他对象上运行

线程从不在任何对象上运行。线程永远不会由对象执行。 线程从不在任何其他线程上运行。线程总是直接在JVM中运行

public class Qn {

    static class Friend {
        private final String name;

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        // recipient - the person who greets
        public synchronized void sayHi(Friend recipient) {
            System.out.format("%s" + " said hi to %s %n",
                      this.name, recipient.getName());
        }
    }

    public static void main(String[] args) {
        final Friend john = new Friend("John");
        final Friend peter = new Friend("Peter");

        new Thread(new Runnable() {
            public void run() {
                john.sayHi(peter);
            }
        }, "thread1").start();
    }
}

差不多。我会用“将尝试获得”替换“已获得”

不知道。请解释你所说的“独立运行”是什么意思

与2相同，但我将尝试猜测-不，除了相关的

线程
对象之外，线程没有绑定到任何对象

同样，如果我理解正确的话，所有部分的答案都是肯定的，除了关于

Thread

object的注释

在获得锁之前，它不会运行

它是一个独立于主线程的执行线程，因此它是“独立”的，因为它不受约束

线程由堆栈和指令指针表示。有一个线程对象，线程不是“在其上运行”。对象仅仅是它的“持有状态”

对

调用

john.sayHi（）

时，线程

thread1

获取了

john

对象的内在锁，以便访问john对象的

sayHi（）

方法

更准确地说：

调用

john.sayHi（）

时，线程

thread1

将等待它在执行

sayHi

之前获得对

john

的锁定。一旦获得锁，它将执行

sayHi

。当方法退出时，它将释放锁

线程

thread1

在JVM中独立运行

public class Qn {

    static class Friend {
        private final String name;

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        // recipient - the person who greets
        public synchronized void sayHi(Friend recipient) {
            System.out.format("%s" + " said hi to %s %n",
                      this.name, recipient.getName());
        }
    }

    public static void main(String[] args) {
        final Friend john = new Friend("John");
        final Friend peter = new Friend("Peter");

        new Thread(new Runnable() {
            public void run() {
                john.sayHi(peter);
            }
        }, "thread1").start();
    }
}

独立于什么？其他线程？是的，直到它试图获得锁为止。在这一点上，它可能会受到其他线程的阻碍。当它具有锁时，它会阻止其他线程

线程

thread1

未在JVM内的任何其他对象上运行

线程在CPU上运行，而不是在对象上运行

您是否在询问一个线程是否可以并行执行多个方法？如果是，答案是否定的

线程从不在任何对象上运行

线程在CPU上运行，而不是在对象上运行

线程永远不会由对象执行

线程不会被任何东西执行。线程执行代码

线程从不在任何其他线程上运行

线程在CPU上运行，而不是在线程上运行

线程总是直接在JVM中运行

public class Qn {

    static class Friend {
        private final String name;

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        // recipient - the person who greets
        public synchronized void sayHi(Friend recipient) {
            System.out.format("%s" + " said hi to %s %n",
                      this.name, recipient.getName());
        }
    }

    public static void main(String[] args) {
        final Friend john = new Friend("John");
        final Friend peter = new Friend("Peter");

        new Thread(new Runnable() {
            public void run() {
                john.sayHi(peter);
            }
        }, "thread1").start();
    }
}

JVM有一个虚拟CPU，线程在其上运行。

请参见下文

调用john.sayHi（）时，线程thread1获取了john对象的内在锁，以便访问john对象的sayHi（）方法

Ans->任何线程如果必须执行任何同步方法，那么它将获得锁。 对象锁还是类锁？ 根据静态或非静态同步方法确定。 如果它是静态的，那么它接受类锁；如果是非静态的，那么接受对象锁

线程thread1在JVM中独立运行

public class Qn {

    static class Friend {
        private final String name;

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        // recipient - the person who greets
        public synchronized void sayHi(Friend recipient) {
            System.out.format("%s" + " said hi to %s %n",
                      this.name, recipient.getName());
        }
    }

    public static void main(String[] args) {
        final Friend john = new Friend("John");
        final Friend peter = new Friend("Peter");

        new Thread(new Runnable() {
            public void run() {
                john.sayHi(peter);
            }
        }, "thread1").start();
    }
}

Ans-> 如果线程不是deamon，那么它将独立运行。但是如果线程是守护进程，那么它依赖于它的父线程，如果父线程死亡，它也将被终止

线程thread1未在JVM内的任何其他对象上运行

Ans-> 线程不会在任何对象上运行，事实上没有代码在任何对象上运行。毕竟，对象持有它的执行状态

线程从不在任何对象上运行。线程永远不会由对象执行。线程从不在任何其他线程上运行。线程总是直接在JVM中运行

public class Qn {

    static class Friend {
        private final String name;

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        // recipient - the person who greets
        public synchronized void sayHi(Friend recipient) {
            System.out.format("%s" + " said hi to %s %n",
                      this.name, recipient.getName());
        }
    }

    public static void main(String[] args) {
        final Friend john = new Friend("John");
        final Friend peter = new Friend("Peter");

        new Thread(new Runnable() {
            public void run() {
                john.sayHi(peter);
            }
        }, "thread1").start();
    }
}

---

让我知道任何其他疑问

静态类朋友{，类不能是静态的。@Mr.Pandey internal classes can's staticRe“在JVM中独立运行。”独立于什么？@Mr.Pandey你为什么这么认为？你听说过吗？@user3580294:哦！是的。非常感谢你付出这么多的努力。我感谢你花时间让我理解。几乎所有的问题都得到了澄清。我有一个问题——“直接在JVM中运行”。我认为线程是在JVM中运行的。我理解的是线程是在CPU中运行的，操作系统是调度程序。但是JVM对这些线程有一些控制吗？你说的是什么样的控制？对线程的唯一真正控制形式是何时调度，这是调度程序完成的。这是一个操作系统功能（在本例中，这将由主机操作系统执行）。一台机器有内存并执行指令，就是这样。（在协作多任务系统中，调度也可以在用户区完成，但Java使用抢占式多任务系统。）好的，很清楚。事实上，当你提到线程在CPU上运行时。我很困惑JVM在Java线程上做什么，因为我认为线程在JVM中运行。好的，所以Java线程在JVM上运行[准确地说，它们在JVM中的虚拟CPU上运行]2.“独立运行”。我的意思是说它在JVM中运行。但我现在知道这是一个不正确的说法。谢谢你+1所有Java线程都在JVM中运行，但都是由OS调度器和JVM内部机制一起调度的。不客气，很高兴提供帮助。谢谢你Alexey Malev的最后评论。更准确地说，让我用@ikegami的话来说“JVM有一个虚拟CPU，线程在其上运行。”我接受@ikegami的回答，因为它更具描述性，并且澄清了我所有的问题。我感谢您的努力，并认识到您是第一个