多线程实现的三种方式

一、继承实现多线程

小兔子示例

Rabit.java

package cn.thread;
/*
 * 模拟龟兔赛跑
 * 1.创建多线程 继承Thread   +重run（线程体）
 */
public class Rabit extends Thread {

    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            System.out.println("兔子跑了"+i+"步");
        }
    }
    
}
class Tortoise extends Thread {

    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            System.out.println("乌龟跑了"+i+"步");
        }
    }
    
}

RabitApp.java

package cn.thread;

public class RabitApp {
    public static void main(String[] args) {
        //1.创建子类对象
        Rabit rab=new Rabit();
        Tortoise tor=new Tortoise();
        //2.调用start()方法
        rab.start();
        tor.start();
        
        
        for(int i=0;i<1000;i++) {
            System.out.println("main--"+i);
        }
        
    }
}

效果

二、静态代理实现多线程

 与继承方式比较：

 

   1.静态代理(StaticProxy)

StaticProxy.java

package cn.thread;
/*
 * 静态代理 设计模式
 * 1、真实角色
 * 2、代理角色    持有真实角色的引用
 * 3、二者实现相同的接口
 */
public class StaticProxy {
    public static void main(String[] args) {
        //创建真实角色
        you y=new you();
        //创建代理角色
        WeddingCompany Company=new WeddingCompany(y);
        Company.marry();
    }
}
//接口
interface Marry{
    public abstract void marry();
}
//真实角色
class you implements Marry{

    @Override
    public void marry() {
        System.out.println("结婚了");
        
    }
    
}
//代理角色
class WeddingCompany implements Marry{
    private Marry you;
    
    public WeddingCompany() {

    }

    public WeddingCompany(Marry you) {
        this.you = you;
    }
    private void before() {
        System.out.println("布置猪窝。。。");
    }
    private void after() {
        System.out.println("收拾猪窝.。。。");
    }
    @Override
    public void marry() {
        before();
        you.marry();
        after();
        
    }
    
}

效果：

 三、Runnable接口 实现多线程

 推荐 Runnable 创建线程
  1）、避免单继承的局限性
  2）、便于共享资源
  使用Runnable 创建线程
  1.类 实现Runnable接口 +重写run()  ---》真实角色类
  2.启动多线程 使用静态代理
      1）、创建真实角色
      2）、创建代理角色+真实角色引用
      3）、调用 start() 启动线程
 

Programmer.java

package cn.thread;
/*
 * 推荐 Runnable 创建线程
 * 1）、避免单继承的局限性
 * 2）、便于共享资源
 * 使用Runnable 创建线程
 * 1.类 实现Runnable接口 +重写run()  ---》真实角色类
 * 2.启动多线程 使用静态代理
 *     1）、创建真实角色
 *     2）、创建代理角色+真实角色引用
 *     3）、调用 start() 启动线程
 */
public class Programmer implements Runnable {

    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            System.out.println("一边玩儿");
        }
        
    }

}

ProgrammerApp.java

package cn.thread;

public class ProgrammerApp {
    public static void main(String[] args) {
        //1）、创建真实角色
        Programmer pro =new Programmer();
        //2）、创建代理角色+真实角色引用
        Thread proxy=new Thread(pro);
        //3）、调用 start() 启动线程
        proxy.start();
        for(int i=0;i<100;i++) {
            System.out.println("一边学");
        }
    }
}

效果：

四、抢票小示例

Web12306.java

package cn.thread;
/*
 * 方便共享资源
 */
public class Web12306 implements Runnable {
    private int num=50;
    @Override
    public void run() {
        while(true) {
            if(num<=0) {
                break; //跳出循环
            }
            System.out.println(Thread.currentThread().getName()+"抢着票了"+num--);
        }
        
    }
    public static void main(String[] args) {
        //真实角色
        Web12306 web=new Web12306();
        //
        Thread th1=new Thread(web,"甲");
        Thread th2=new Thread(web,"乙");
        Thread th3=new Thread(web,"丙");
        th1.start();
        th2.start();
        th3.start();
    }
    
}

效果展示：

 

小结：

一、继承Thread +run()

启动：创建子类对象 + 对象.start()

二、实现Runnable +run()

启动：使用静态代理

　　1、创建真实角色

　　2、创建代理角色 Thread+引用

　　3、代理角色.start()

推荐使用接口：

　　1、避免单继承局限性

　　2、便于共享资源