创建线程的三种方式

创建线程的方式1：继承thread类，重写run方法，调用start开启线程

package com.thread.demo01;
//创建线程的方式一：继承thread类，重写run方法，调用start开启线程
public class TestThread1 extends Thread {
    public void run() {
        for (int i = 0; i < 20; i++) {
            //run方法线程体
            System.out.println("我在看代码---" + i);
        }
    }
    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start（）方法开启线程
        testThread1.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程---" + i);
        }
    }
}
/*
1.线程开启不一定立即执行，由cpu 调用执行
 */

创建线程方式2： 实现runnable接口，重写run方法，执行线程需要丢入runnable接口的实现类，调用start方法（推荐）

package com.thread.demo01;
//创建线程方式2：  实现runnable接口，重写run方法，执行线程需要丢入runnable接口的实现类，调用start方法
public class TestThread3 implements Runnable {
    @Override
    public void run() {

        for (int i = 0; i < 20; i++) {
            //run方法线程体
            System.out.println("我在看代码---" + i);
        }
    }
    public static void main(String[] args) {
        //main线程，主线程
        //创建一个runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        new Thread(testThread3).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程---" + i);
        }
    }
}

线程的创建方式3 ：实现callable接口

package com.thread.demo02;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
//线程的创建方式3 ：实现callable接口
/*
callable的好处
1.可以定义返回值
2.可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {
    private String name;
    private String url;
    public TestCallable(String url, String name) {
        this.name = name;
        this.url = url;
    }
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("图片的名字为：" + name);
        return true;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("http://bpic.588ku.com/element_origin_min_pic/16/10/29/2ac8e99273bc079e40a8dc079ca11b1f.jpg", "1.jpg");
        TestCallable t2 = new TestCallable("http://nimg.ws.126.net/?url=http%3A%2F%2Fdingyue.ws.126.net%2F2021%2F0524%2F23d33360j00qtkixi0065c000qo0140c.jpg&thumbnail=650x2147483647&quality=80&type=jpg", "2.jpg");
        TestCallable t3 = new TestCallable("http://img-arch.pconline.com.cn/images/upload/upc/tx/photoblog/1309/25/c49/26316176_26316176_1380092693834_mthumb.jpg", "3.jpg");
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果
        Boolean rs1 = r1.get();
        Boolean rs2 = r2.get();
        Boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        ser.shutdown();
    }
}
//下载器
class WebDownloader {
    //下载方法
    public void downloader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

小结

1. 继承Thread类

• 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
• 创建Thread子类的实例，即创建了线程对象。
• 调用线程对象的start()方法来启动该线程。

2. 实现Runnable接口

• 定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
• 创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
• 调用线程对象的start()方法来启动该线程。

3. 实现Callable接口

• 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
• 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
• 使用FutureTask对象作为Thread对象的target创建并启动新线程。
• 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值