11-案例实现

案例实现

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

1．创建 MyThread 类，扩展 Thread 类：

public class MyThread extends Thread {

2．声明3个 Date 类型的私有字段，它们分别为 creationDate 、 startDate 以及 finishDate ：

private final Date creationDate;
private Date startDate;
private Date finishDate;

3．实现一个该类的构造方法。它以一个 name 字符串和一个可执行的 Runnable 对象作为参数。初始化该线程的创建日期：

public MyThread(Runnable target, String name ){
  super(target,name);
  creationDate = new Date();
}

4．实现 run() 方法。存储该线程的开始日期，调用父类的 run() 方法，然后存储本次执行的完成日期：

@Override
public void run() {
  setStartDate();
  super.run();
  setFinishDate();
}

5．实现一个刷新 startDate 字段值的方法：

public synchronized void setStartDate() {
  startDate=new Date();
}

6．实现一个刷新 finishDate 字段值的方法：

public synchronized void setFinishDate() {
  finishDate=new Date();
}

7．实现一个 getExecutionTime() 方法，通过计算开始日期与完成日期的时间差来获得线程的执行时间：

public synchronized long getExecutionTime() {
  return finishDate.getTime()-startDate.getTime();
}

8．重写 toString() 方法，返回该线程的创建日期和执行时间：

@Override
public synchronized String toString(){
  StringBuilder buffer=new StringBuilder();
  buffer.append(getName());
  buffer.append(": ");
  buffer.append(" Creation Date: ");
  buffer.append(creationDate);
  buffer.append(" : Running time: ");
  buffer.append(getExecutionTime());
  buffer.append(" Milliseconds.");
  return buffer.toString();
}

9．新建一个 MyThreadFactory 类，实现 ThreadFactory 接口：

public class MyThreadFactory implements ThreadFactory {

10．声明一个 AtomicInteger 类型的 counter 私有字段：

private AtomicInteger counter;

11．声明一个 String 类型的 prefix 私有字段：

private String prefix;

12．实现一个构造方法来初始化该类的字段：

public MyThreadFactory (String prefix) {
  this.prefix=prefix;
  counter=new AtomicInteger(1);
}

13．实现一个 newThread() 方法。创建一个 MyThread 对象，并增加 counter 字段值：

@Override
public Thread newThread(Runnable r) {
  MyThread myThread=new MyThread(r,prefix+"-"+counter
                                          .getAndIncrement());
  return myThread;
}

14．新建一个 MyTask 类，实现 Runnable 接口。实现 run() 方法，使当前线程休眠2s：

public class MyTask implements Runnable {
  @Override
  public void run() {
    try {
      TimeUnit.SECONDS.sleep(2);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

15．实现本案例 Main 类的一个 main() 方法：

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

16．创建一个 MyThreadFactory 对象：

MyThreadFactory myFactory=new MyThreadFactory
                                       ("MyThreadFactory");

17．创建一个 Task 对象：

MyTask task=new MyTask();

18．用该工厂类的 newThread() 方法创建一个用来执行该任务的 MyThread 对象：

Thread thread=myFactory.newThread(task);

19．启动该线程并等待它的完成：

thread.start();
thread.join();

20．用 toString() 方法来打印该线程的信息：

System.out.printf("Main: Thread information.\n");
System.out.printf("%s\n",thread);
System.out.printf("Main: End of the example.\n");