多线程

一个进程可以有很多个线程，比如视频中同时听声音，看图像，看弹幕等等。

进程和线程

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

而进程则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。

通常一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是Cpu调度和执行的单位。

注：很多多线程是模拟出来的，真正的多线程是指多个Cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个Cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

线程就是独立的执行路径
在程序运行时，即使没有自己创建线程，后台也有多个线程，如主线程，gc线程；
main（）称之为主线程，为系统的入口，用于执行整个程序；
在一个进程中如果开辟了多个线程，线程的运行由调度器（cpu）安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
线程会带来额外的开销，如cpu调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程的创建

线程创建的三种创建方式：

1、继承Thread

2、实现Runnable接口

3、实现Callable接口

继承Thread类

查看jdk1.8中有关于Thread说明：

总结一下，继承Thread类创建线程的方法

自定义线程类继承Thread类
重写run（）方法，编写线程执行体
创建线程对象，调用Start（）方法启动线程

/**
 * 创建线程的方式一：继承Thread类，重写run方法,调用start开启线程
 * 总结：注意线程开启不一定立即执行，由CPU调度执行
 */
public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 =new TestThread1();
        //调用start方法开启线程，run线程和main线程进行交替执行
        testThread1.start();
//        testThread1.run();
        //如果调用run方法则必须等run输出完成在进行main线程
        for (int i = 0; i < 100; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

练习Thread：实现多线程同步下载图片

准备工作：使用common.io工具包导入项目

commons-io是一款处理io流的工具，封装了很多处理io流和文件的方法，可以大大简化我们处理io流和操作文件的代码。从common-io的官方使用文档可以看出，它主要分为工具类、尾端类、行迭代器、文件过滤器、文件比较器和扩展流。

官网地址：http://commons.apache.org/proper/commons-io/

下载：http://commons.apache.org/proper/commons-io/download_io.cgi

代码实现：

public class TestThread2 extends Thread{
    private String url;//网络图片的地址
    private String name;//保存的文件名
    public TestThread2(String url,String name){
        this.url=url;
        this.name=name;
    }
    @Override
    //下载图片线程的执行体
    public void run() {
        WebDownloader webDownloader=new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为："+name);
    }
    public static void main(String[] args) {
        TestThread2 t1=new TestThread2("https://gitee.com/iamning/img/raw/master/blog/202204032208600.png","1.jpg");
        TestThread2 t2=new TestThread2("https://gitee.com/iamning/img/raw/master/blog/202204081250649.png","2.jpg");
        TestThread2 t3=new TestThread2("https://gitee.com/iamning/img/raw/master/blog/202204041559233.png","3.jpg");
        //理想情况下是1,2，3逐个下载
        //但是实际是没有按照顺序，每次执行顺序都不一致
        t1.start();
        t2.start();
        t3.start();
    }
}
//下载器
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方法出现问题");
        }

实现runnable接口

JDK1.8中的说明：

定义类实现Runnable接口
重写run（）方法，编写线程执行体
创建线程对象，调用start（）方法启动线程

代码实现

//创建线程的方式2：实现runnable接口，重写run方法，执行线程需要的丢入runnable接口的实现类，调用start方法
public class TestThread3 implements Runnable{
//更推荐使用这个Runnable接口，因为接口可以多继承
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在看代码--"+i);
        }
    }
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        TestThread3 testThread3=new TestThread3();

        //创建线程对象，通过线程对象来开启我们的线程代理
//        Thread thread=new Thread(testThread3);
//        thread.start();
        new Thread(testThread3).start();//可以直接简单写
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

实现Callable接口

1.Callable接口介绍：

（1）java.util.concurrent.Callable是一个泛型接口，只有一个call()方法

（2）call()方法抛出异常Exception异常，且返回一个指定的泛型类对象

2.Callable接口实现多线程的应用场景

当父线程想要获取子线程的运行结果时

3.Callable接口实现方法一

1、实现Callable接口，需要返回值类型

2、重写call方法，需要抛出异常

3、创建目标对象

4、创建执行服务

? 创建一个可重用固定线程数的线程池

ExecutorService ser= Executors.newFixedThreadPool(3);

5、提交执行：

Future接口是用来获取异步计算结果的，说白了就是对具体的Runnable或者Callable对象任务执行的结果进行获取(get()),取消(cancel()),判断是否完成等操作。

Future result1= ser.submit(t1);

6、获取结果

boolean rs1=result1.get();

7、关闭服务

ser.shutdownNow();

//线程创建方式三：实现Callable接口
/*
callable的好处
1、可以定义返回值
2、可以抛出异常
 */
public class TestCallable implements Callable{
        private String url;//网络图片的地址
        private String name;//保存的文件名
        //构造器
        public TestCallable(String url,String name){
            this.url=url;
            this.name=name;
        }
        @Override
        //下载图片线程的执行体
        public Boolean call() {
            WebDownloader1 webDownloader=new WebDownloader1();
            webDownloader.downloader(url,name);
            System.out.println("下载的文件名为："+name);
            return true;
        }
        //主线程
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            TestCallable t1=new TestCallable("https://gitee.com/iamning/img/raw/master/blog/202204032208600.png","1.jpg");
            TestCallable t2=new TestCallable("https://gitee.com/iamning/img/raw/master/blog/202204081250649.png","2.jpg");
            TestCallable t3=new TestCallable("https://gitee.com/iamning/img/raw/master/blog/202204041559233.png","3.jpg");
            //创建执行服务：
            ExecutorService ser= Executors.newFixedThreadPool(3);
            //提交执行
            Future result1= ser.submit(t1);
            Future result2= ser.submit(t2);
            Future result3= ser.submit(t3);
            //获取结果
            boolean rs1=result1.get();
            boolean rs2=result2.get();
            boolean rs3=result3.get();
            System.out.println(rs1);
            System.out.println(rs2);
            System.out.println(rs3);
            //关闭服务
            ser.shutdownNow();
        }
    }
    //下载器
    class WebDownloader1{
        //下载方法
        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方法出现问题");
            }

        }
    }

小结

继承Thread类

子类继承Thread类具备多线程能力
启动线程：子类对象.start（）
不建议使用：避免OOP单继承局限性

实现Runnable接口

实现接口Runnable具有多线程能力
启动线程：传入目标对象+Thread对象.start（）
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多线程使用

实现Callable接口

实现Callable和实现Runnable类似，但是功能更强大，具体表现在

可以在任务结束后提供一个返回值，Runnable不行
call方法可以抛出异常，Runnable的run方法不行
可以通过运行Callable得到的Fulture对象监听目标线程调用call方法的结果，得到返回值，（fulture.get(),调用后会阻塞，直到获取到返回值）

线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理(....)
  - ucorePoolSize：核心池的大小
  - umaximumPoolSize：最大线程数
  - ukeepAliveTime：线程没有任务时最多保持多长时间后会终止
JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
- Future submit(Callable task)：执行任务，有返回值，一般又来执行 Callable
- void shutdown() ：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建线程池，创建线程池
        //newFixedThreadPool(10);参数为线程池大小
        ExecutorService service= Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdown();
    }
}
class  MyThread implements Runnable{
    @Override
    public void run() {
    //打印线程名称
            System.out.println(Thread.currentThread().getName());

    }

JavaSE学习笔记

多线程

多线程