Является ли это хорошим дизайном для реализации ключевого слова java synchronized в качестве объекта?

Question

Просто для практики я хотел реализовать Java-синхронизированное ключевое слово как объект java. Не могли бы вы сказать, что код ниже - хороший дизайн для этого? Я предполагаю, что AtomicReference будет иметь аналогичную производительность AtomicBoolean?

Обновленный код после предложений:

public class SynchronizedBlock implements Runnable{ 

private final Lock lock; 
private final Runnable runnable; 

public SynchronizedBlock(Runnable r, Lock l){ 
    runnable = r; 
    lock = l; 
} 

public void run() { 
    try { 
     while(!lock.compareAndSet(false, true)){ 
      Thread.sleep(100); 
     } 
     runnable.run(); 
    } catch (InterruptedException e) { 
     e.printStackTrace(); 
    } finally { 
     lock.unlock(); 
    } 


} 

} 

public class Lock { 
private final AtomicReference<Boolean> locked = new AtomicReference<Boolean>(false); 

public boolean compareAndSet(boolean expected, boolean update){ 
    return locked.compareAndSet(expected, update); 
} 

public boolean isLocked(){ 
    return locked.get(); 
} 

public void unlock(){ 
    locked.set(false); 
} 
} 

@Test 
public void test() { 



    final SynchronizedBlock sb = new SynchronizedBlock(new Runnable(){ 

     public void run() { 
      x++; 
      System.out.println(x); 
     } 

    }, new Lock()); 

    Runnable r1 = new Runnable(){ 

     int c = 0; 
     public void run() { 
      while(c<10){ 
       sb.run(); 
       c++; 
      } 
     } 

    }; 

    Runnable r2 = new Runnable(){ 

     int c = 0; 
     public void run() { 
      while(c<10){ 
       sb.run(); 
       c++; 
      } 
     } 

    }; 

    Thread t1 = new Thread(r1); 
    Thread t2 = new Thread(r2); 

    t1.start(); 
    t2.start(); 

    while (t1.isAlive() && t2.isAlive()){ 

    } 

    assertEquals(20,x); 

} 

Answer 1

Вы должны добавить метод инкапсуляции сравнение с обменом, и нет никакого смысла зацикливание на замок, чтобы быть свободным, прежде чем пытаться его получить. Зачем становиться в ситуации, когда вы видите, что замок свободен, но к тому времени, когда вы попытаетесь его принять, он исчез.

Я бы удалил метод блокировки и поместил разблокировку в конце блокировки, чтобы исключение/ошибка не приводило к блокировке, которая никогда не разблокируется.

Кроме того, я хотел бы использовать AtomicBoolean, который является более естественным, чем AtomicReference

Answer 2

Во-первых, и самое главное, вы должны удалить Thread.sleep(100). Это приведет к задержке не менее 100 мс даже в случае только двухпотоковых конфликтов.

Чтобы упростить код, вы можете просто использовать AtomicBoolean вместо AtomicReference. Также, если вы действительно обеспокоены параллелизмом в ситуации с высоким уровнем конкуренции, вы можете изменить свой код, чтобы проверить, заблокирован ли он перед выполнением CAS.

while (true) { 
    if (lock.isLocked()) continue; // or get() == true if you use AtomicBoolean 
    if (lock.compareAndSet(false, true)) 
    break; 
} 

Это является примером TTAS (Test-Test-And-Set) запирающим который использует местное формование, чтобы уменьшить доступ основной памяти во время цикла. См. http://en.wikipedia.org/wiki/Test_and_Test-and-set