创建线程的两种方式及静态代理

创建线程有两种方式一种是继承Thread类另一种是继承Runnable接口实现静态代理。

1.继承Thread方式：

public class MyThread extends Thread {
    @Override
    public void run(){
        super.run();
        System.out.println("MyThread");
    }
}

public class Run {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("运行结束");
    }
}

1）创建一个类继承Thread类，
2）改写run（）方法，
3）再对象.start（）。

2.静态代理方法实现（实现Runnable接口）:由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

1）首先静态代理包含了两个角色：代理角色和真实（委托）角色，
2）上述两个角色必需实现同一个接口，
3）代理角色要持有真实角色的引用,代理角色中要有方法供代理角色中的的真实角色指向之后生成的实例对象。代理角色里还有一些方法是委托方法
4）创建一个真实对象和一个代理对象，将真实对象赋给代理对象进行操作，但是操作的还是真实对象自己。

推荐使用实现Runnable接口：避免单继承，方便共享资源。

1>代理接口

/**  
 * 代理接口。处理给定名字的任务。 
 */  
public interface Subject {  
  /** 
   * 执行给定名字的任务。 
    * @param taskName 任务名 
   */  
   public void dealTask(String taskName);   
}  

2>委托类，具体处理业务。

/** 
 * 真正执行任务的类，实现了代理接口。 
 */  
public class RealSubject implements Subject {  
  
 /** 
  * 执行给定名字的任务。这里打印出任务名，并休眠500ms模拟任务执行了很长时间 
  * @param taskName  
  */  
   @Override  
   public void dealTask(String taskName) {  
      System.out.println("正在执行任务："+taskName);  
      try {  
         Thread.sleep(500);  
      } catch (InterruptedException e) {  
         e.printStackTrace();  
      }  
   }  
}  

3>静态代理类

/** 
 *　代理类，实现了代理接口。 
 */  
public class ProxySubject implements Subject {  
 //代理类持有一个委托类的对象引用  
 private Subject delegate;  
   
 public ProxySubject(Subject delegate) {  
  this.delegate = delegate;  
 }  
  
 /** 
  * 将请求分派给委托类执行，记录任务执行前后的时间，时间差即为任务的处理时间 
  *  
  * @param taskName 
  */  
 @Override  
 public void dealTask(String taskName) {  
  long stime = System.currentTimeMillis();   
  //将请求分派给委托类处理  
  delegate.dealTask(taskName);  
  long ftime = System.currentTimeMillis();   
  System.out.println("执行任务耗时"+(ftime - stime)+"毫秒");    
 }  
}  

4>生成静态代理类工厂

public class SubjectStaticFactory {  
 //客户类调用此工厂方法获得代理对象。  
 //对客户类来说，其并不知道返回的是代理类对象还是委托类对象。  
 public static Subject getInstance(){   
  return new ProxySubject(new RealSubject());  
 }  
}  

5>客户类

public class Client1 {  
 public static void main(String[] args) {  
  Subject proxy = SubjectStaticFactory.getInstance();  
  proxy.dealTask("DBQueryTask");  
 }   
}  

3.通过过实现Runnable接口实现静态代理从而开启多线程：

把Thread当成代理类创建main和thread两个线程

public class Run {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.start();
        for (int i =0;i<10000;i++){
            System.out.println(i);
        }
    }
}

委托类实现接口

public class MyThread implements Runnable{
    public void run() {
        for (int i = 0;i<10000;i++){
            System.out.println("rua");
        }
    }
}