java多线程的三种实现方式

第一种：单继承thread
/**
* java的单继承让写一个线程继承一次线程（这种写法）
*/
public class TestThread extends Thread {
    /**
     * 线程体
     */
    @Override
    public void run() {
        for(int i=0;i<=100;i++){
            System.out.println("兔子总共跑了"+i+"步");
        }
    }
    /**
     * main方法，程序测试入口,其实也是一个线程,这样目前该方法就实现了3个线程
     * @param args
     */
    public static void main(String[] args) {
        TestThread thr=new TestThread();//1.创建子类对象
        TestThread2 thr2=new TestThread2();`这里写代码片`
                   thr.start();//2.调用start方法,千万不要调用run()方法，不然就是调用普通方法，start方法是吧他加入线程组，然后相当于把方法放到起跑线上
                   thr2.start();//调用run方法则会跑一条线
        for(int i=0;i<=100;i++){
            System.out.println("main线程"+i);
        }
    }

}
/**
* java的单继承让写一个线程继承一次线程（这种写法）
*/
class TestThread2 extends Thread{
    /**
     * 线程体
     */
    @Override
    public void run() {
        for(int j=0;j<=100;j++){
            System.out.println("乌龟总共跑了"+j+"步");
        }
    }

}
第二种：静态代理方式
/**
 * 使用Rannable来创建线程
 * 类实现Runnable接口，重写run方法，--相当于真实角色
 * @author Administrator
 *
 */
public class Programmer implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println("手里敲着键盘。。。。"+i+"pi");
        }
    }

}
/**
 * 线程这个类已经做了代理的事情了
 * @author Administrator
 *
 */
public class ProgrammerApp {

    public static void main(String[] args) {
        Programmer grammer=new Programmer();      //创建一个真实角色
        Thread thr = new Thread(grammer);       //代理拿到真实角色的引用
               thr.start();                   //启动线程的方法
        for(int i=0;i<500;i++){//考虑主线程
            System.out.println("主线程在弄啥子哦"+i+"ci");
        }
    }
}
第二种方式的引用变化方法；
/**
 * 模拟12306抢票
 * @author Administrator
 *
 */
public class Web12306 implements Runnable{
    private int ticket=50;
    @Override
    public void run() {
        while(true){
            if(ticket<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"抢到了"+ticket--);
        }

    }

    /**
     * 调用的方法
     * @param args
     */
    public static void main(String[] args) {
        Web12306 w123 =new Web12306();//真实角色

        Thread t1 = new Thread(w123,"黄牛甲");//直接传递代理方法实体，给个引用“黄牛甲”就可以了
        Thread t2 = new Thread(w123,"黄牛乙");//直接传递代理方法实体，给个引用签名就可以了
        Thread t3 = new Thread(w123,"工程师");//直接传递代理方法实体，给个引用签名就可以了

        t1.start();
        t2.start();
        t3.start();
    }
}
第三种方式：callable
/**
 * 使用callanble创建线程，弥补run方法不抛出异常和返回值
 * java.util.concurrent
 * @author Administrator
 * 实例化参数一般使用构造方法初始化或者setget方法
 */
public class Call {
    /**
     * 方法使用线程
     * @param args
     */
    public static void main(String[] args) {
        //对象引用
        Race tortoise =new Race("乌龟",1000);
        Race rabbit =new Race("小白兔",100);
        //任务调度创建线程
        ExecutorService es =Executors.newFixedThreadPool(2);//开启线程数
        //获取值
        Future<Integer>result1 =es.submit(tortoise);
        Future<Integer>result2 =es.submit(rabbit);
        try {
            Thread.sleep(2000);
            tortoise.setFlag(false);
            rabbit.setFlag(false);
            int num1 = result1.get();
            int num2 = result2.get();
            System.out.println("乌龟跑了"+num1+"步");
            System.out.println("兔子跑了"+num2+"步");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //停止服务
        es.shutdownNow();
    }
}
/**
 * 真实对象
 * @author Administrator
 *
 */
class Race implements Callable<Integer>{
    private String name;
    private long time;//延时时间
    private boolean flag=true;
    private int step=0;
    @Override
    public Integer call() throws Exception {
        while(flag){
            Thread.sleep(time);
            step++;
        }
        return step;
    }
    //构造方法
    public Race() {
        super();
    }
    //姓名带参数的构造方法
    public Race(String name) {
        super();
        this.name = name;
    }
    //生成时间
    public Race(String name, long time) {
        super();
        this.name = name;
        this.time = time;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public long getTime() {
        return time;
    }
    public void setTime(long time) {
        this.time = time;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public int getStep() {
        return step;
    }
    public void setStep(int step) {
        this.step = step;
    }
}