java中锁的工作原理

我正在编写一个程序来测试当另一个线程在同一个对象上获得锁时，线程如何保持等待，但在查看输出后，我不确定锁在java中是如何工作的。以下是我写的：

public class Locking {

synchronized void methodA() {
        System.out.println("inside A , " + Thread.currentThread().getName());
}

public static void main(String[] args) throws InterruptedException {
   new Locking().execute();
}

private void execute() throws InterruptedException {
    Thread t1 = new Thread(new MyThread());
    t1.setName("t1");
    Thread t2 = new Thread(new MyThread());
    t2.setName("t2");

    t1.start();
    Thread.sleep(5000);
    t2.start();
}

class MyThread implements Runnable {

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            methodA();
        }
    }
}

}

我预计线程t2将永远等待，程序将只打印

在A内，t1

但当我运行程序时，我得到以下输出：

在A内，t1

A区内，t2

---

有人能解释一下这里发生了什么吗？

这是我们想要的情况

t1线程正在另一个线程中等待，而不是主线程

在主线程中（生成线程并调用start（）），只需等待5秒钟，然后启动thread2

您的同步方法仅在线程1调用该方法时才进行同步，而不是永远进行同步

thread1调用Synchornized方法并返回后，thread1将停止5秒

---

此时，thread2可以使用该方法。

这是预期的情况

t1线程正在另一个线程中等待，而不是主线程

在主线程中（生成线程并调用start（）），只需等待5秒钟，然后启动thread2

您的同步方法仅在线程1调用该方法时才进行同步，而不是永远进行同步

thread1调用Synchornized方法并返回后，thread1将停止5秒

---

此时，thread2可以使用该方法。

方法前面的关键字

synchronized

意味着两个线程不能同时调用该方法

---

一旦某个线程调用了该方法，尝试调用该方法的其他线程就会被阻止，直到第一个线程从该方法返回。之后，调用同一方法的其他线程可以自动继续调用（一次一个）。

方法前面的关键字

synchronized

表示两个线程不能同时调用该方法

---

一旦某个线程调用了该方法，尝试调用该方法的其他线程就会被阻止，直到第一个线程从该方法返回。之后，调用同一方法的其他线程可以自动继续调用（一次一个）。

您使用

synchronized

的隐式锁在短时间内工作-即释放锁后的

println

。你的两个线程都在竞相获取那里的锁

将代码更改为此，您将看到所需的行为

class MyThread implements Runnable {

    @Override
    public void run() {
            methodA();
    }
}

synchronized void methodA() {
        while(true)
        System.out.println("inside A , " + Thread.currentThread().getName());
}

---

使用

synchronized

的隐式锁在一段短时间内工作-即释放锁后的

println

。你的两个线程都在竞相获取那里的锁

将代码更改为此，您将看到所需的行为

class MyThread implements Runnable {

    @Override
    public void run() {
            methodA();
    }
}

synchronized void methodA() {
        while(true)
        System.out.println("inside A , " + Thread.currentThread().getName());
}

我正在编写一个程序来测试线程如何在 另一个线程已获得同一对象上的锁

这里有一个锁：

synchronized void methodA() {
        System.out.println("inside A , " + Thread.currentThread().getName());
}

它接受当前实例上的锁，但代码中没有语句以线程可以永远等待锁的方式进行锁定。
请看我的评论：

@Override
public void run() {
    while (true) {
        try {
            Thread.sleep(5000); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // the lock is set here
        methodA();
       // and that is released here
    }
}

使synchronized方法永远不会释放锁，并且只有一个线程能够进入：

synchronized void methodA() {
    while (true) {
        System.out.println("inside A , " + Thread.currentThread()
                                                 .getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // handle it
        }
    }
}

印刷品：

在A内，t1

在A内，t1

在A内，t1

她还举了一些其他的例子

将

sleep（）

替换为

wait（）

，当前线程将释放锁：

synchronized void methodA() {
    while (true) {
        System.out.println("inside A , " + Thread.currentThread()
                                                 .getName());
        try {
            wait();
        } catch (InterruptedException e) {
            // handle it
        }
    }
}

印刷品：

在A内，t1

A区内，t2

使用

notify（）

（通知等待的线程）和

wait（）

（使当前线程等待并释放锁（如果有）使线程在它们之间协作：

synchronized void methodA() {
    while (true) {
        notify();
        System.out.println("inside A , " + Thread.currentThread()
                                                 .getName());
        try {
            wait();
        } catch (InterruptedException e) {
            // handle it
        }
    }
}

印刷品：

在A内，t1

A区内，t2

在A内，t1

A区内，t2

我正在编写一个程序来测试线程如何在 另一个线程已获得同一对象上的锁

这里有一个锁：

synchronized void methodA() {
        System.out.println("inside A , " + Thread.currentThread().getName());
}

它接受当前实例上的锁，但代码中没有语句以线程可以永远等待锁的方式进行锁定。
请看我的评论：

@Override
public void run() {
    while (true) {
        try {
            Thread.sleep(5000); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // the lock is set here
        methodA();
       // and that is released here
    }
}

使synchronized方法永远不会释放锁，并且只有一个线程能够进入：

synchronized void methodA() {
    while (true) {
        System.out.println("inside A , " + Thread.currentThread()
                                                 .getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // handle it
        }
    }
}

印刷品：

在A内，t1

在A内，t1

在A内，t1

她还举了一些其他的例子

将

sleep（）

替换为

wait（）

，当前线程将释放锁：

synchronized void methodA() {
    while (true) {
        System.out.println("inside A , " + Thread.currentThread()
                                                 .getName());
        try {
            wait();
        } catch (InterruptedException e) {
            // handle it
        }
    }
}

印刷品：

在A内，t1

A区内，t2

使用

notify（）

（通知等待的线程）和

wait（）

（使当前线程等待并释放锁（如果有）使线程在它们之间协作：

synchronized void methodA() {
    while (true) {
        notify();
        System.out.println("inside A , " + Thread.currentThread()
                                                 .getName());
        try {
            wait();
        } catch (InterruptedException e) {
            // handle it
        }
    }
}

印刷品：

在A内，t1

A区内，t2

在A内，t1

A区内，t2

---

您启动了两个单独的线程，每个线程调用methodA（），所以输出应该是第二个？为什么您期望第一个结果？了解为什么您期望只有t1运行methodA会很有趣。从我对代码的阅读来看，您观察到的行为是有意义的。请回答问题以添加此信息。好吧，您启动了两个单独的线程，每个线程调用methodA（），所以输出应该是第二个？为什么您期望第一个结果？了解为什么您期望只有t1运行methodA会很有趣。从我对代码的阅读来看，您观察到的行为是有意义的。请回答问题以添加此信息。