线程的创建方式

方式一：继承Thread类，作为线程对象

                                      

方式二：实现runnable接口，作为线程任务存在

                                     

 

方式三：匿名内部类创建线程对象

            其中，创建带线程任务并且重写run方法的线程对象，只执行了Thread的run方法。看源码可知，

                                       

                                     Thread实现了Runnable接口，而Runnable接口里有一个run方法。所以，最终调用的重写的方法应该

                                    是Thread类的run方法，而不是Runnable接口的run方法。

public class Main {
    public static void main(String[] args) {
        //无参线程对象
        new Thread(){
            @Override
            public void run() {
                System.out.println("无参线程对象执行了...");
            }
        }.start();
        //带线程任务的线程对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("带线程任务的线程对象执行了...");
            }
        }).start();
        //创建带线程任务并且重写run方法的线程对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable run 线程执行了...");
            }
        }){
            @Override
            public void run() {
                System.out.println("重写run方法的线程执行了...");
            }
        }.start();
    }

}

方式四：创建带返回值的线程

                                        

                                       Callable接口，返回指定泛型的call方法；

　　　　　　　　　　　 调用FutureTask对象的get方法得道call方法的返回值。FutureTask最终实现的是Runnable和Future接口。

                                        

                                        

方式五：定时器Timer  （点击）

方式六：线程池创建线程（末尾有补充）

                        Executors提供了四种方法来创建线程池：

                              ① newFixedThreadPool() : 创建固定大小的线程池

                              ② newCachedThreadPool() : 创建无限大小的线程池，线程池中线程数量不固定

                              ③newSingleThreadExecutor() : 创建单个线程池，线程池中只有一个线程

                              ④newScheduledThreadPool() : 创建固定大小的线程池，可以延迟或定时的执行任务

                                          

方式七：实现ThreadFactory接口

              ①创建一个继承Thread的MyThread类，重写run()方法：

public class MyThread extends Thread {
    private Date creationDate;
    private Date startDate;
    private Date finishDate;

    public MyThread(Runnable target, String name ){
        super(target,name);
        setCreationDate();
    }
    @Override
    public void run() {
        setStartDate();
        super.run();
        setFinishDate();
    }
    public void setCreationDate() {
        creationDate=new Date();
    }
    public void setStartDate() {
        startDate=new Date();
    }
    public void setFinishDate() {
        finishDate=new Date();
    }
    public long getExecutionTime() {
        return finishDate.getTime()-startDate.getTime();
    }
    @Override
    public String toString(){
        StringBuilder buffer=new StringBuilder();
        buffer.append(getName()+"信息");
        buffer.append(": ");
        buffer.append(" 创建日期:");
        buffer.append(creationDate);
        buffer.append(" ---- 执行时间: ");
        buffer.append(getExecutionTime());
        buffer.append(" Milliseconds.");
        return buffer.toString();
    }
}

                ②创建一个实现ThreadFactory接口的MyThreadFactory类，重写newThread(Runnable r)方法：

public class MyThreadFactory implements ThreadFactory {


    @Override
    public Thread newThread(Runnable r) {
        MyThread myThread = new MyThread(r, "自定义线程");
        return myThread;
    }


}

               ③创建一个实现Runnable接口的MyTask类，重写run()方法，完成指定任务：

public class MyTask implements Runnable {
    private static final Logger logger = Logger.getLogger(NewTest.class);
    private int a;
    public MyTask(int a){
        this.a=a;
    }
    @Override
    public void run() {
        try {
            logger.info("Task开始执行····");
            Thread.sleep(5000);
            logger.info("购买"+a+"瓶可乐最终可获得"+getSum(a,a,a)+"瓶可乐！");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    /**
     * 3个可乐瓶盖可换1瓶可乐、2个瓶身可换1瓶可乐，购买n瓶可乐，最终总共获得几瓶？
     */
    public static int getSum(int s,int i, int j){
        if(i<3&&j<2){
            return s;
        }else{
            return i/3+j/2+getSum(s,i%3+i/3+j/2,j%2+i/3+j/2);
        }
    }
}

               ④进行测试：

public class Main  {
    private static final Logger logger = Logger.getLogger(NewTest.class);
    public static void main(String[] args) throws InterruptedException{
        MyThreadFactory myFactory=new MyThreadFactory();
        MyTask task=new MyTask(10);
        Thread thread=myFactory.newThread(task);
        logger.info("Start of the example");
        thread.start();
        thread.join();
        logger.info(thread);
        logger.info("End of the example");
    }
}

 

 

 

 

关于方式六补充-------