线程同步 - 什么时候一个线程释放物体

Question

public class MyStack2 { 
    private int[] values = new int[10]; 
    private int index = 0; 

    public synchronized void push(int x) { 
     if (index <= 9) { 
      values[index] = x; 
      Thread.yield(); 
      index++; 
     } 
    } 

    public synchronized int pop() { 
     if (index > 0) { 
      index--; 
      return values[index]; 
     } else { 
      return -1; 
     } 
    } 

    public synchronized String toString() { 
     String reply = ""; 
     for (int i = 0; i < values.length; i++) { 
      reply += values[i] + " "; 
     } 
     return reply; 
    } 
} 

public class Pusher extends Thread { 
    private MyStack2 stack; 

    public Pusher(MyStack2 stack) { 
     this.stack = stack; 
    } 

    public void run() { 
     for (int i = 1; i <= 5; i++) { 
      stack.push(i); 
     } 
    } 
} 

public class Test { 
    public static void main(String args[]) { 
     MyStack2 stack = new MyStack2(); 
     Pusher one = new Pusher(stack); 
     Pusher two = new Pusher(stack); 
     one.start(); 
     two.start(); 
     try { 
      one.join(); 
      two.join(); 
     } catch (InterruptedException e) { 
     } 
     System.out.println(stack.toString()); 
    } 
} 

MyStack2由于类的方法在锁是同步的，我所期待的输出作为 1 2 3 4 5 1 2 3 4 5但输出不定。通常它给出：1 1 2 2 3 3 4 4 5 5

根据我的理解，当线程1开始时，它获取push方法的锁。内线push()线程一段时间产生。但是当调用yield()时它释放锁吗？现在当线程2启动时，线程2完成执行之前线程2是否会获得一个锁？有人能解释一下线程释放堆栈对象上的锁吗？

Answer 1

A​​方法只会阻止其他线程在执行时执行它。只要它返回其他线程可以（并且通常会立即）获得访问权限。

的情况下让你的1 1 2 2 ...可能是：

1. 线程1调用push(1)并且被允许在
2. 线程2调用push(1)同时线程1在使用它被阻止。
3. 线程1退出push(1)。
4. 线程2获得访问push并推1但同时线程1调用push(2)。

结果1 1 2 - 您可以清楚地看到它如何继续。

Answer 2

看起来你可能对于synchronized和yield关键词的含义有些混淆。

同步意味着一次只有一个线程可以输入该代码块。把它想象成一个大门，你需要一个钥匙才能通过。它进入的每个线程都只有一个密钥，并在完成后返回。这允许下一个线程获取密钥并执行其中的代码。无论它们在同步方法中多久都没关系，一次只能有一个线程进入。

产量向编译器提出建议（并且是唯一的建议），即当前线程可以放弃其分配的时间，并且另一个线程可以开始执行。然而，这并不总是以这种方式发生。

在你的代码中，即使当前线程向编译器提示它可以放弃它的执行时间，它仍然保持着同步方法的关键，因此新线程无法进入。

不可预知的行为来自收益率不会像你预测的那样放弃执行时间。

希望有帮助！

Answer 3

当你说：

按我的理解，当一个线程启动它获取的push方法的锁。

这是不完全正确的，因为锁不仅仅是推的方法。推送方法使用的锁定位于MyStack2的实例上，该实例被调用。方法pop和toString使用与push相同的锁。当一个线程在一个对象上调用这些方法时，它必须等到它可以获得该锁。调用推送过程中的线程将阻止另一个线程调用pop。线程正在调用不同的方法来访问相同的数据结构，对访问该结构的所有方法使用相同的锁来防止线程同时访问数据结构。

一旦线程放弃退出同步方法的锁，调度程序将决定哪个线程获得下一个锁。您的线程正在获取锁并让它们多次出现，每次发布锁时，都会对调度程序做出决定。你不能对任何将被选中的假设做出任何假设，它可以是任何假设。来自多个线程的输出通常是混乱的。