2021-02-10

多线程

普通方法与多线程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UMSxwnka-1612944592639)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20210205135334492.png)]

Process（进程）与Thread（线程）

• 程序是指令和数据的有序集合，其本身没有说任何运行的含义，是一个静态的概念
• 进程则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的单位。

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

main 为主线程

核心概念

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VzgHHBWO-1612944592641)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20210205135435502.png)]

进程的创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6fuzaAFf-1612944592644)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20210205135715118.png)]

Thread

创建线程，继承Thread类。重写run()方法，调用start开启线程

package com.chen.first;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;

public class Demo4 extends Thread{  //实现多线程下载图片

    private  String url;
    private  String name;
    public Demo4(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){
        Demo4 t1=new Demo4("图片地址","1.jpg//图片名字");
        Demo4 t2=new Demo4("图片地址","2.jpg");
        Demo4 t3=new Demo4("图片地址","3.jpg");
        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){
            System.out.println("下载失败"+e);
        }
    }
}

Runnable

• 定义类实现Runnable接口
• 实现run()方法，编写线程体
• 创建线程对象，调用start()方法启动线程

小结

继承Thread类

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

实现Runnable接口

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

线程不安全

多个线程操作同一个资源的情况下，线程不安全，数据紊乱

实现Callable接口

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务：ExecutorService ser =Executors.newFixedThreadPool(1);
5. 提交执行：Futureresult1=ser.submit(t1);
6. 获取结果：boolean r1 =result.get()
7. 关闭服务 ser.shutdownNow();

静态代理模式

• 真实对象/目标对象和代理对象都要实现同一个接口
• 代理对象需要代理真实角色
• 好处 ：代理对象可以作真实对象做不了的事，真实对象专注做自己的事情

Lamda表达式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j5tG8m4d-1612944592648)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20210210145835571.png)]

• 避免匿名内部类定义太多
• 其实质属于函数式编程的概念
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rR8INxCX-1612944592651)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20210210145920901.png)]

package com.chen.first;

public class TestLamda {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lamda() {
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lamda();

        like =new Like2();
        like.lamda();
        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lamda() {
                System.out.println("I like lambda3");
            }
        }
        like =new Like3();
        like.lamda();
        //5.匿名内部类
        like =new ILike() {
            public void lamda() {
                System.out.println("i like lamda4");
            }
        };
        like.lamda();
        //6.用lamda简化
        like = ()->{System.out.println("i like lambda 5");};
        like.lamda();
    }
}
//1.定义一个函数式接口
interface ILike{
    void lamda();
}
//2.实现类
class Like implements ILike{

    @Override
    public void lamda() {
        System.out.println("i like lamda");
    }
}