继承Thread类

1.  自定义线程类，继承Thread类
2.  重写run方法，编写线程执行体
3. 创建自定义线程类对象，该对象调用start()方法开启线程

public class TestThread1 extends Thread{
    @Override
    public void run() {
        //线程执行体
        for(int i = 0; i <10;i++){
            System.out.println("线程正在执行********"+i);
        }
    }
    //主线程
    public static void main(String[] args){
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        /**
         *  1.调用start()方法通知"线程规划器"此线程已经准备就绪，等待调用线程对象的run()方法，
         *  这个过程其实就是让系统安排一个时间来调度Thread.run()方法，也就是使线程得到运行，启动线程，具有异步执行的效果
         *  2.调用run()方法就不是异步执行了，而是同步，此线程对象并不交给"线程规划器"来进行处理，而是由main()线程来调用run()方法，
         *  也就是必须等run()方法中的代码执行完之后才可以执行后面的代码
         *  3.多线程是异步的；单任务的特点就是排队执行，也就是同步
         */
        //1.调用start方法，主线程与线程执行体交替执行
        testThread1.start();
        //2.只有主线程一条执行路径
//        testThread1.run();
        for(int i=0;i<5;i++){
            System.out.println("主线程------"+i);
        }
    }
}

实现Runnable接口

1. 自定义线程类，实现Runnable接口
2. 实现run()方法，编写线程执行体
3. 创建自定义线程对象（作为参数去创建Thread对象），创建Thread对象，thread对象调用start()方法启动线程

public class TestTheard3 implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i <20;i++)
        {
            System.out.println("敲代码----"+i);
        }
    }

    public static void main(String[] args) {
        //1.创建runnable接口的实现类对象
        TestTheard3 testTheard3= new TestTheard3();
        //2.创建线程对象，通过线程对象开启线程，代理
        Thread thread = new Thread(testTheard3);
        //3.启动线程
        thread.start();
        for (int i = 0; i < 10;i++) {
            System.out.println("学习*********"+i);
        }
    }
}

实现Callable接口

1. 自定义线程类，实现Callable接口，需要返回值类型
2. 重写call方法，需抛出异常
3. 创建目标对象（自定义线程类对象）
4. 创建线程池
```
ExecutorService service = Executors.newFixedThreadPool(3);
```
5. 提交执行
6. 获取结果
7. 关闭服务

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
public class TestCallable implements Callable<Boolean> {
    private String url; //网络图片地址
    private String fileName;    //保存的文件名

    public TestCallable(String url,String fileName){
        this.url = url;
        this.fileName = fileName;
    }

    /**
     * 下载图片线程的执行体
     * @return
     */
    @Override
    public Boolean call() {
        WebDownloader webDownloader=new WebDownloader();
        webDownloader.downloader(url,fileName);
        System.out.println("下载的文件名为："+fileName);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.创建目标对象
        TestCallable t1 = new TestCallable("https://i0.hdslb.com/bfs/sycp/creative_img/202109/e62f6d7e9a434f562afb67765b975f01.jpg","漫画1.jpg");
        TestCallable t2 = new TestCallable("https://i0.hdslb.com/bfs/sycp/creative_img/202109/e62f6d7e9a434f562afb67765b975f01.jpg","漫画2.jpg");
        TestCallable t3 = new TestCallable("https://i0.hdslb.com/bfs/sycp/creative_img/202109/e62f6d7e9a434f562afb67765b975f01.jpg","漫画3.jpg");

        //2.创建线程池
        ExecutorService service = Executors.newFixedThreadPool(3);
        //3.提交执行
        Future<Boolean> r1 = service.submit(t1);
        Future<Boolean> r2 = service.submit(t2);
        Future<Boolean> r3 = service.submit(t3);
        //4.获取结果
        Boolean b1 = r1.get();
        Boolean b2 = r2.get();
        Boolean b3 = r3.get();
        System.out.println(b1); //打印结果
        System.out.println(b2);
        System.out.println(b3);
        //5.关闭服务
        service.shutdown();
    }
}
class WebDownloader{
    //下载方法
    public void downloader(String url,String fileName){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(fileName));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • ⚠️ 线程开启后进入就绪状态，不一定立即执行，完全取决于cpu调度
  • ⚠️线程的启动顺序与start()执行顺序无关