多线程的三种创建方式(案例)

125 阅读1分钟

方案一

1、定义一个子类MyThread继承线程类java.lang.Thread,重写run()方法

2、创建MyThread类的对象

3、调用线程对象的start()方法启动线程(启动之后还是执行run方法的)

public class FileDemo {
    public static void main(String[] args) {
        Thread t = new MyThread();//
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出");
        }
    }
}
class MyThread extends Thread{//
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出");
        }

    }
}

方案一优缺点

优点、代码简单

缺点、线程类已经继承Thread,无法继承其他类,不利于扩展,如果线程有执行结果不可以直接返回

方案二

1、定义一个线程任务类MyRunnable实现Runnable接口,重写run()方法

2、创建MyRunnable任务对象

3、把MyRunnable任务对象交给Thread处理

4、调用线程对象的start()方法启动线程

public class FileDemo {
    public static void main(String[] args) {
        Runnable runnable = new MyThread();//
        new Thread(runnable).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出");
        }
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程输出");
        }

    }
}

方案二还有一种优化写法(匿名内部类)

public class FileDemo {
    public static void main(String[] args) {
        new Thread(()-> {
            for (int i = 0; i < 5; i++) {System.out.println("子线程输出");}
        }).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程输出");
        }
    }
}

方案二优缺点

优点、线程任务类只是实现接口,可以继续继承类或者实现接口,扩展性强

缺点、编程多了一层对象包装,如果线程有执行结果是不可以直接返回的

方案三

JDK5提供类Callable和FutureTask来解决不能返回线程执行结果的问题

1、得到任务对象

01、定义类实现Callable接口,重写call方法,封装需要做的事情

02、用FutureTask把Callable对象封装成线程任务对象

2、把线程任务对象交给Thread来处理

3、调用Thread的start方法启动线程,执行任务

4、线程执行完毕后通过FutureTask的get方法获取任务执行的结果,get方法会等线程执行完毕后获取结果

public class FileDemo {
    public static String SR;
    public static void main(String[] args) {
        Callable<String> call = new MyThread();
        FutureTask<String> future = new FutureTask<>(call);//FutureTask也是泛型类
        new Thread(future).start();
        try {
            SR = future.get();//获取返回值
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(SR);
        System.out.println("主线程执行输出");


    }
}
class MyThread implements Callable<String>{  //Callable是泛型接口应该指定返回类型 默认类型是Object
    @Override
    public String call() throws Exception {
        return "Give me 100 yuan";
    }
}

方案三优缺点

优点、线程任务类只是实现接口,可继续继承和实现接口,可扩展性强

可在线程执行完毕后去获取线程的执行结果

缺点、代码复杂一点~~