线程的创建方式

佚名 6年前 (2019-05-14) 随笔 766人围观抢沙发百度已收录

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

SRE实战互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

方式二：实现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");
    }
}