Java高级：线程创建的四种方式

Java高级：线程创建的四种方式

方式一：继承Thread类

1. 创建一个子类继承Thread类；
2. 重写Thread类中的run()方法（将线程需要执行操作声明在run()方法中）；
3. 在main函数中创建Thread类的子类对象；
4. 通过函数调用start()方法。

//1.创建一个myThread子类继承Thread类
class myThread extends Thread{
    //2.重写 Thread类中run()方法：输出100以内的偶数
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {

        //3.创建Thread类的子类myThread对象
        myThread mythread = new myThread();
        mythread.start();

    }
}

注意：

1. 我们不能通过直接调用run()方法启动线程。
2. 不能让已经start()的mythread线程再次进行start()操作，会产生illegalThreadStateException异常。

方式二：实现Runnable接口

1. 创建一个实现了Runnable接口的实现类；
2. 实现类去实现Runnable接口中的抽象方法，run()方法（将需要线程执行的操作声明在run()方法中）；
3. 在main函数中创建实现类的对象；
4. 将实现类的对象作为参数传递到Thread类的构造器中，创建Thread类的对象；
5. 通过Thread类的对象调用start()方法。

//1.创建myThread1类实现Runnable接口
class myThread1 implements Runnable{
    //2.实现Runnable接口中的抽象方法，run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100 ; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类myThread1的对象
        myThread1 mythread1 = new myThread1();
        //4.将对象mythread1作为参数传递到Thread类的构造器中
        Thread thread = new Thread(mythread1);
        //5.通过Thread类的对象调用start()方法
        thread.start();
    }
}

两种方式对比：

开发中：优先选择Runnable接口的方式。
原因：

1. 实现的方式没有java类的单继承的局限性。
2. 实现的方式更适合处理多个线程共享数据的情况。

联系：两种方式都需要重写run()方法。

方式三：实现Callable接口

1. 创建一个实现了Callable接口的实现类；
2. 实现类去实现Callable接口中的抽象方法，call()方法（将需要线程执行的操作声明在call()方法中）；
3. 在main函数中创建实现类的对象；
4. 将实现类的对象作为参数传递到FutureTask类的构造器中，创建FutureTask类的对象；
5. 将FutureTask类的对象作为参数传递到Thread类的构造器中，创建Thread类的对象；
6. 通过Thread类的对象调用start()方法。

//1.创建myThread2类实现Callable接口
class myThread2 implements Callable{
    //2.实现Callable接口的抽象方法：call()方法
    //输出100以内的偶数，返回100以内偶数的累加值
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if(i % 2 ==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}
public class ThreadTest2 {
    public static void main(String[] args) {
        //3.创建实现类myThread2的对象
        myThread2 mythread = new myThread2();
        //4.将实现类的对象作为参数传递到FutureTask构造器中
        FutureTask futureTask = new FutureTask(mythread);
        //5.将FutureTask类的对象作为参数传递到Thread类的构造器中
        Thread thread = new Thread(futureTask);
        //6.通过Thread类的对象调用start()方法
        thread.start();
    }
}

注意：

1. call()方法有返回值，使用FutureTask类的对象调用get()方法获取返回值。
2. FutureTask类的对象调用get()方法需要抛出两个异常：InterruptedException，ExecutionException。

//注意：获取call()方法返回值，FutureTask类的对象调用get()方法
//调用get()方法需要抛出两种异常：InterruptedException，ExecutionException
        try {
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

如何理解实现Callable接口的方式创建多线程比实现Runnable接口的方式更强大？

1. call()方法有返回值。
2. call()方法可以抛出异常，被外面操作捕获，获取异常信息。
3. Callable支持泛型。

方式四：使用线程池

1. 提供指定线程数量的线程池。
2. 执行指定的线程操作，需要提供实现Runnable接口或Callable接口的对象。
3. 关闭连接池。

//实现Runnable接口
class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100 ; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
//实现Callable接口
class NumberThread1 implements Callable{
    @Override
    public Object call() throws Exception {
        for (int i = 0; i <= 100 ; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
        return null;
    }
}
public class ThreadTest3 {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.执行指定的线程的操作，需要提供实现Runnable接口或
        //Callable接口实现类的对象
        service.execute(new NumberThread());//适合用于Runnable接口
        service.submit(new NumberThread1());//适合用于Callable接口
        //3.关闭连接池
        service.shutdown();
    }
}