java创建线程的4种方式

 转自：http://blog.csdn.net/win7system/article/details/52807277

http://blog.csdn.net/win7system/article/details/52807277

1、继承Thread类+重写run()方法

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

缺点： Java只支持单继承，如果我们的类已经从一个类继承，则无法再继承Thread类。

    /**  
     * 模拟龟兔赛跑  
     * 1、创建多线程（方式一）：继承 Thread + 重写run方法（线程体）  
     * 2、使用线程：创建子类对象  + 对象.start()方法  线程启动  
     */  
       
    public class Demo01 {  
       
        public static void main(String[] args) {  
            //创建子类对象  
            Rabbit rab = new Rabbit();  
            Tortoise tor = new Tortoise();    
            //调用start方法 ，启动线程。 内部由CPU管控  
            rab.start(); //不要调用run方法，由内部自己调用。  
            tor.start();          
            for(int i=0;i<30;i++)  
            {  
                System.out.println("main-->"+i);                  
            }  
        }  
    }  
       
    class Rabbit extends Thread{  
        //线程体  一切从run开始  
        @Override  
        public void run() {  
            //线程体  
            for(int i=0;i<30;i++)  
            {  
                    System.out.println("兔子跑了"+i+"步");                 
            }  
        }  
       
    }  
       
    class Tortoise extends Thread  
    {  
        @Override  
        public void run() {  
            //线程体  
            for(int i=0;i<30;i++)  
            {  
                    System.out.println("乌龟跑了"+i+"步");                 
            }  
        }  
    }  

2、实现Runnable接口+重写run方法 （常用）

启动：使用静态代理

1)、创建真实角色

2)、创建代理角色

3)、调用start()方法 启动线程

优点：可以同时实现继承，Runnable接口方式更加通用一些。

1、避免单继承的局限性

2、便于共享资源

通过实现Runnable接口实现多线程。（用到了静态代理设计模式）

    /**  
     * 推荐使用Runnable创建线程  
     * 1、避免单继承的局限性  
     * 2、便于共享资源  
     */  
    public class Demo03 {  
        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("一边聊QQ");  
            }  
        }  
    }  
       
    /**  
     * 使用Runnable 创建进程  
     * 1、类实现Runable接口+重写run()方法  
     * 2、启动多线程 使用静态代理  
     *      1)、创建真实角色  
     *      2)、创建代理角色  
     *      3)、调用start()方法 启动线程  
     */  
    class Programmer implements Runnable{  
        @Override  
        public void run() {  
            for(int i=0;i<100;i++){  
                System.out.println("一边敲代码");  
            }  
        }  
    }  

    /**  
     * 抢票系统  
     * 方便共享资源  
     */  
    public class Demo04 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) {  
            //真实角色  
            Demo04 web = new Demo04();  
            //代理  
            Thread t1 = new Thread(web,"德玛西亚");  
            Thread t2 = new Thread(web,"卡特琳娜");  
            Thread t3 = new Thread(web,"德邦总管");  
       
            //启动线程  
            t1.start();  
            t2.start();  
            t3.start();  
        }  
    }  

3、使用Callable接口创建多线程

Callable 和 Future接口（从jdk1.5开始有）

Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。

优点：可以返回值，可以抛异常。

缺点：实现繁琐。

    import java.util.concurrent.Callable;  
    import java.util.concurrent.ExecutionException;  
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
    import java.util.concurrent.Future;  
       
    /**  
     * 使用Callable接口方式创建多线程   
     */  
    public class Demo05 {  
        public static void main(String[] args) throws InterruptedException, ExecutionException {  
            //1、创建线程  
            ExecutorService ser = Executors.newFixedThreadPool(2);//开两个线程  
       
            Race tortoise = new Race("老乌龟",1000);  
            Race rabbit = new Race("小兔子",500);  
       
            //2、获取Future对象  
            Future<integer> result1 = ser.submit(tortoise);  
            Future<integer> result2 = ser.submit(rabbit);  
       
            Thread.sleep(2000);//2秒  
            tortoise.setFlag(false);//停止线程体循环 设置flag = false;  
            rabbit.setFlag(false);  
            //3、获取值  
            int num1 = result1.get();  
            int num2 = result2.get();  
       
            System.out.println("乌龟跑了-->"+num1+"步");  
            System.out.println("兔子跑了-->"+num2+"步");  
            //4、停止服务  
            ser.shutdownNow();  
        }  
    }  
       
    class Race implements Callable<integer>  
    {  
        private String name;//名称  
        private long time;//延时时间  
        private boolean flag = true;  
        private int step = 0;//步  
       
        public Race() {  
        }     
        public Race(String name) {  
            super();  
            this.name = name;  
        }  
        public Race(String name, int time) {  
            super();  
            this.name = name;  
            this.time = time;  
        }  
       
        //有返回值了  
        @Override  
        public Integer call() throws Exception {  
            while(flag){  
                Thread.sleep(time);//延时  
                step++;  
            }  
            return step;  
        }  
       
        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;  
        }  
    }  

4、应用程序可以使用Executor框架来创建线程池

    import Java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
      
    public class ThreadPool {  
        private  static int POOL_NUM = 10;  
        public static void main(String[] agrs){  
            ExecutorService executorService = Executors.newFixedThreadPool(5);  
            for (int i = 0; i < POOL_NUM; i++) {  
                RunnableThread thread = new RunnableThread();  
                executorService.execute(thread);  
            }  
        }  
    }  
    class RunnableThread implements  Runnable{  
        private   int THREAD_NUM = 10;  
        public void run() {  
            for (int i = 0; i <THREAD_NUM; i++) {  
                System.out.println("线程"+Thread.currentThread()+i);  
            }  
              
        }  
    }  

几种方式的比较：

Callable和Runnable有几点不同：

（1）Callable规定的方法是call()，而Runnable规定的方法是run().

（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。

（3）call()方法可抛出异常，而run()方法是不能抛出异常的。

（4）运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。

实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。