29-案例实现

案例实现

根据如下步骤来实现本案例。

1．创建一个 MyAbstractQueuedSynchronizer 类来扩展 AbstractQueued-Synchronizer 类：

public class MyAbstractQueuedSynchronizer extends
                                AbstractQueuedSynchronizer {

2．声明一个 AtomicInteger 类型的 state 私有字段：

private final AtomicInteger state;

3．实现该类的构造方法以初始化其字段：

public MyAbstractQueuedSynchronizer() {
  state=new AtomicInteger(0);
}

4．实现 tryAcquire() 方法。该方法试图将状态变量的值从0改为1。如果可以，则它会返回 true ；否则，它返回 false ：

@Override
protected boolean tryAcquire(int arg) {
  return state.compareAndSet(0, 1);
}

5．实现 tryRelease() 方法。该方法试图将状态变量的值从1改为0。如果可以，则它会返回 true ；否则，它返回 false ：

@Override
protected boolean tryRelease(int arg) {
  return state.compareAndSet(1, 0);
}

6．创建一个 MyLock 类并指定它实现 Lock 接口：

public class MyLock implements Lock{

7．声明一个 AbstractQueuedSynchronizer 类型的 sync 私有字段：

private final AbstractQueuedSynchronizer sync;

8．实现类的构造方法，从而可以用新的 MyAbstractQueuedSynchronizer 对象来初始化 sync 属性：

public MyLock() {
  sync=new MyAbstractQueuedSynchronizer();
}

9．实现 lock() 方法。调用同步对象的 acquire() 方法：

@Override
public void lock() {
  sync.acquire(1);
}

10．实现 lockInterruptibly() 方法。调用同步对象的 acquireInterruptibly() 方法：

@Override
public void lockInterruptibly() throws InterruptedException {
  sync.acquireInterruptibly(1);
}

11．实现 tryLock() 方法。调用同步对象的 tryAcquireNanos() 方法：

@Override
public boolean tryLock() {
  try {
    return sync.tryAcquireNanos(1, 1000);
  } catch (InterruptedException e) {
    e.printStackTrace();
    Thread.currentThread().interrupt();
    return false;
  }
}

12．用两个参数实现 tryLock() 方法的另一个版本：一个 long 类型的 time 参数和一个 TimeUnit 类型的 unit 参数。调用同步对象的 tryAcquireNanos() 方法：

@Override
public boolean tryLock(long time, TimeUnit unit) throws
                                 InterruptedException {
    return sync.tryAcquireNanos(1, TimeUnit.NANOSECONDS
                                       .convert(time, unit));
}

13．实现 unlock() 方法。调用同步对象的 release() 方法：

@Override
public void unlock() {
    sync.release(1);
}

14．实现 newCondition() 方法。创建同步对象内部类的新对象，即 ConditionObject ：

@Override
public Condition newCondition() {
  return sync.new ConditionObject();
}

15．创建一个 Task 类并指定它实现 Runnable 接口：

public class Task implements Runnable {

16．声明一个 MyLock 类型的 lock 私有字段：

private final MyLock lock;

17．声明一个 String 类型的 name 私有字段：

private final String name;

18．实现该类的构造方法以初始化其字段：

public Task(String name, MyLock lock){
  this.lock=lock;
  this.name=name;
}

19．实现类的 run() 方法。获取锁，使线程休眠2s，然后释放锁对象：

@Override
public void run() {
  lock.lock();
  System.out.printf("Task: %s: Take the lock\n",name);
  try {
    TimeUnit.SECONDS.sleep(2);
    System.out.printf("Task: %s: Free the lock\n",name);
  } catch (InterruptedException e) {
    e.printStackTrace();
  } finally {
    lock.unlock();
  }
}

20．创建一个 Main 类和一个 main() 方法来实现本案例的主类：

public class Main {
  public static void main(String[] args) {

21．创建一个名为 lock 的 MyLock 对象：

MyLock lock=new MyLock();

22．创建并执行10个 Task 任务：

for (int i=0; i<10; i++){
  Task task=new Task("Task-"+i,lock);
  Thread thread=new Thread(task);
  thread.start();
}

23．尝试用 tryLock() 方法获取锁。等待1s，如果没有得到锁，则打印一条消息，然后再试一次：

boolean value;
do {
  try {
    value=lock.tryLock(1,TimeUnit.SECONDS);
    if (!value) {
      System.out.printf("Main: Trying to get the Lock\n");
    }
  } catch (InterruptedException e) {
    e.printStackTrace();
    value=false;
  }
} while (!value);

24．打印一条消息，表明已经获得了锁并释放它：

System.out.printf("Main: Got the lock\n");
lock.unlock();

25．写一条表示程序结束的消息：

System.out.printf("Main: End of the program\n");