0

该类X有两种方法：test和test1。

我创建了两个线程：t1和t2. 线程t1正在访问test方法并且t2正在访问test1同一对象的方法。何时t1访问test同步的方法获取对象锁定。

将t2能够访问test1同一对象上的方法吗？t1如果有锁，为什么它能够访问这个方法？

如果我正在执行以下代码

            X x = new X();
           new MyThread(x).start(); // It execute test() method
       new MyThread1(x).start();// It execute test1() method





class X 
{
    String a  = "varsha";
    public synchronized void test ()
    {
        try 
        {
            Thread.sleep (6000);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace ();
        }
    } 
    public void test1 ()
    {
        synchronized (a)
        {
        }
    } 
}
4

5 回答 5

3

你有两个不同的锁：

  • test()锁this；
  • test1()锁this.a。

这两个锁是完全独立的，因此可以同时调用这两个方法。

于 2013-03-14T07:16:06.243 回答
1

您的代码等效于以下内容：

class X 
{
    String a  = "varsha";
    public void test ()
    {
        synchronized (this)
        {
            try
            {
                Thread.sleep (6000);
            }
            catch (InterruptedException e) 
            {
                e.printStackTrace();
            }
        }
    } 

    public void test1 ()
    {
        synchronized(a)
        {
        }
    } 
}

因此，这些方法在不同的对象（thisvs a）上同步，因此可以同时执行而不会相互锁定。

请注意，我替换Thread.currentThread ().sleep (6000)为Thread.sleep (6000)因为方法sleep是静态的，因此您不需要任何实例Thread来使用它。

于 2013-03-14T07:17:00.450 回答
0 
class X {

  String a  = "varsha";

   public synchronized void test(){

   try {             
                  //if you are modifying the instance variable here
                  // then the test1() synchronized block will 
                 //not be given lock permission to t2 thread
                 // synchronization is for thread safety.

                 // In your example you are not modifying the instance variable.

   } catch (InterruptedException e) {
    e.printStackTrace();
   }
 } 
 public  void test1(){
   synchronized(a){
   }
 } 
}
于 2013-03-14T07:29:48.737 回答
0

这是实际发生的事情。
Java 中的每个对象都有一个“监视器锁”，在本例中是对象“x”。

有两个线程（MyThread 和 MyThread1）试图按以下顺序获取此锁 -

想象有一个队列——MyThread 在这个队列中位于 MyThread1 的前面，因为您首先启动了 MyThread，然后是 MyThread1。

MyThread 首先获取锁并开始执行，您已经在其上调用了 sleep() 方法。这会将 MyThread 的状态从“执行状态”更改为“等待状态”，然后再更改为“就绪状态”，此时它会释放锁，因为它不处于执行状态。此时 MyThread1 在队列中处于领先地位，它获取锁并开始执行。

这在某种程度上类似于“上下文切换”的概念。参考书 - 操作系统内部和设计。

于 2016-07-20T01:48:24.927 回答
-1

当您将方法标记为同步时，它会锁定该方法的对象；这意味着没有其他线程可以访问该对象的特定方法。在您的情况下，没有其他线程可以访问测试方法；但当然可以访问 test1 方法。

于 2013-03-14T07:21:28.930 回答