Java中最简单的Lock实现[重复]

Question

可能重复：
Peterson algorithm in Java?

我正在尝试在 petersen 方法的行中实现 Java 中的锁（锁接口）。保证互斥的最简单的不可重入实现是什么。

flag[0]   = 0;
flag[1]   = 0;
turn;

P0: flag[0] = 1;                            P1: flag[1] = 1;
    turn = 1;                                   turn = 0;
    while (flag[1] == 1 && turn == 1)           while (flag[0] == 1 && turn == 0)
    {                                           {
           // busy wait                                  // busy wait
    }                                           }                                 
    // critical section                         // critical section 
       ...                                        ...
    // end of critical section                  // end of critical section
    flag[0] = 0;                                flag[1] = 0;

我正在使用上述算法（来自 wiki）。尽管使用了 volatile 标志和 turn 变量，但它似乎不起作用，因为我得到了许多数据竞争。需要注意哪些事项？

代码如下：

public class TestLock implements Lock {

    private final long thread1ID;
    private final long thread2ID;
    private volatile AtomicIntegerArray flagArr = new AtomicIntegerArray(50);
    private volatile long turn = 0;
    private volatile long currentThreadID = 0;

    public TestLock(Thread thread1, Thread thread2) {       
        thread1ID = t0.getId();
        thread2ID = t1.getId();         
        flagArr.set((int)thread1ID, 0);
        flagArr.set((int)thread2ID, 0);     
    }
    public void lock() {        
        currentThreadID = Thread.currentThread().getId();
        flagArr.set((int)Thread.currentThread().getId(), 1);            
        turn = next();          
        while(turn == next() && flagArr.get((int)next()) == 1)
        {
            System.out.println(Thread.currentThread().getId()+" waiting");              
        }
        //critical section
        System.out.println(Thread.currentThread().getId()+" executing");
        }

    private long next() {
        return Thread.currentThread().getId() == thread1ID ? thread2ID : thread1ID;     
    }

    public void unlock() {      
        flagArr.set((int)Thread.currentThread().getId(), 0);    
    }
}

Answer 1

好吧，根据接受的this SO question 答案中的 cmets，一个问题是您不能使用 boolean [] 并期望单元格具有 volatile 语义。

如果您发布了代码，我们或许可以提供更多建议。