16-案例实现

案例实现

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

1．创建一个名为 Operations 的类：

public class Operations {

2．实现一个名为 readData() 的 public static 方法，让当前线程休眠500ms：

public static void readData(){
  try {
    TimeUnit.MILLISECONDS.sleep(500);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}

3．实现一个名为 writeData() 的 public static 方法，让当前线程休眠500ms：

public static void writeData(){
  try {
    TimeUnit.MILLISECONDS.sleep(500);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}

4．实现一个名为 processData() 的 public static 方法，让当前线程休眠2000ms：

public static void processData(){
  try {
    TimeUnit.SECONDS.sleep(2);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}

5．创建一个实现 Runnable 接口的 Task1 类：

public class Task1 implements Runnable {

6．声明一个私有的 Lock 属性，将其命名为 lock ：

private final Lock lock;

7．实现该类的构造器并初始化属性：

public Task1 (Lock lock) {
  this.lock=lock;
}

8．实现 run() 方法。获取锁，调用 Operations 类的3个操作，最后释放锁：

@Override
public void run() {
  lock.lock();
  Operations.readData();
  Operations.processData();
  Operations.writeData();
  lock.unlock();
}

9．实现一个名为 Task2 的类并实现 Runnable 接口：

public class Task2 implements Runnable {

10．声明一个私有的 Lock 属性，并将其命名为 lock ：

private final Lock lock;

11．实现该类的构造器并初始化属性：

public Task2 (Lock lock) {
  this.lock=lock;
}

12．实现 run() 方法。获取锁，调用 readData() ，然后释放锁，接着调用 processData() 方法，然后获取锁，调用 writeData() 操作，最后再释放锁：

@Override
public void run() {
  lock.lock();
  Operations.readData();
  lock.unlock();
  Operations.processData();
  lock.lock();
  Operations.writeData();
  lock.unlock();
}

13．实现本案例的主类，创建 Main 并添加 main() 方法：

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

14．创建一个 Lock 对象并命名为 lock 、一个 Task1 对象并命名为 task1 、一个 Task2 对象并命名为 task2 ，最后创建一个10个线程的数组：

Lock lock=new ReentrantLock();
Task1 task1=new Task1(lock);
Task2 task2=new Task2(lock);
Thread threads[]=new Thread[10];

15．启动10个线程执行第一个任务，打印执行时间：

Date begin, end;
begin=new Date();
for (int i=0; i<threads.length; i++) {
  threads[i]=new Thread(task1);
  threads[i].start();
}
for (int i=0; i<threads.length; i++) {
  try {
    threads[i].join();
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}
end=new Date();
System.out.printf("Main: First Approach: %d\n",
                  (end.getTime()-begin.getTime()));

16．启动10个线程执行第二个任务，打印执行时间：

begin=new Date();
for (int i=0; i<threads.length; i++) {
  threads[i]=new Thread(task2);
  threads[i].start();
}
for (int i=0; i<threads.length; i++) {
  try {
    threads[i].join();
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}
end=new Date();
System.out.printf("Main: Second Approach: %d\n",
                  (end.getTime()-begin.getTime()));