java同步

类X有两种方法：test和test1。java同步

我创建了两个线程：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) 
     { 
     } 
    } 
}

来源

2013-03-14 varsha

请格式化您的代码。这太可怕了！ – 2013-03-14 07:17:18

你有两个不同的锁：

test()锁this;
test1()锁this.a。

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

来源

2013-03-14 07:16:06 NPE

您的代码是等效于以下：

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

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

所以这些方法是在不同的对象（this与a）同步，从而可以在不锁定彼此并发地执行。

注意，我换成Thread.currentThread().sleep (6000)与Thread.sleep (6000)因为方法sleep是静态的，因此你不需要的Thread任何情况下，才能使用它。

来源

2013-03-14 07:17:00

-1

将方法标记为synchronized时，会锁定该方法的对象;意味着没有其他线程可以访问该对象的PARTICULAR方法。在你的情况下，没有其他线程可以访问测试方法;但是当然可以访问test1方法。

来源

2013-03-14 07:21:28 pravat

这根本不是真的。 – NPE 2013-03-14 07:24:39

我建议写一个简单的测试 – pravat 2013-03-18 03:36:07

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-14 07:29:48 VKPRO

以下是实际发生的情况。
Java中的每个对象都有一个“监视器锁”，在这种情况下，对象为“x”。

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

想象有一个队列 - MyThread的是MyThread1前在这个队列中，因为你刚开始MyThread的后面MyThread1。

MyThread首先获取锁并开始执行，您已经调用了sleep（）方法。这将使MyThread的状态从“执行状态”变为“等待状态”，然后变为“就绪状态”，此时它将释放锁，因为它不处于执行状态。此时，MyThread1在队列中领先，并获取锁并开始执行。

这与“上下文切换”的概念类似。请参阅本书 - 操作系统内部和设计。

来源

2016-07-20 01:48:24

回答

相关问题