java同步

类

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)
        {
        }
    } 
}

---

您有两个不同的锁：

• test（）

  锁定

  此

• test1（）

  锁定

  这个.a

---

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

您有两个不同的锁：

• test（）

  锁定

  此

• test1（）

  锁定

  这个.a

---

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

您的代码相当于以下代码：

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

实例来使用它。

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

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

实例来使用它。

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

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

下面是实际发生的情况。

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){
   }
 } 
}

Java中的每个对象都有一个“监视器锁”，在本例中是对象“x”

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

假设有一个队列–MyThread位于该队列中MyThread1的前面，因为您首先启动了MyThread，然后是MyThread1

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

---

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

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

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

假设有一个队列–MyThread位于该队列中MyThread1的前面，因为您首先启动了MyThread，然后是MyThread1

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

---

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

请格式化您的代码。这太可怕了！！！请格式化你的代码。这太可怕了！！！我建议写一个简单的测试