多线程01-一键三连，NICE

1.概念

程序：
指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
进程：
执行程序的一次执行过程，它是动态的概念，是系统资源分配的单位。
一个进程中可以包括多个线程，但是一个进程至少有一个线程，不然没有存在的意义，线程是cpu调度和执行的单位。
注意：很多多线程都是模拟的，真正的多线程有多核，即多个cpu,如果在一个cpu的情况下，模拟多线程，在同一个时间点cpu只能执行一个代码，因为切换的很快，所有就有，同时执行的错觉，就好像一边吃饭，一遍打游戏。

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

2.Thread

• 自定义线程类继承Thread
• 重写run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

package com.luo.demo01;
//创建线程方式一：继承Thread类，重写run方法，调用start开启线程
//总结：注意，线程开启不一定立即执行，由cpu调度执行
public class TextThread1 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线程，主线程
        //创建一个线程对象
        TextThread1 testThread1=new TextThread1();
        //调用start方法，开启线程
        testThread1.start();
        for(int i=0;i<20;i++)
        {
            System.out.println("我在学习多线程----"+i);
        }
    }
}

我在看代码----0
我在看代码----1
我在看代码----2
我在看代码----3
我在看代码----4
我在看代码----5
我在看代码----6
我在看代码----7
我在学习多线程----0
我在学习多线程----1
我在学习多线程----2
我在学习多线程----3
我在学习多线程----4
我在学习多线程----5
我在学习多线程----6
我在学习多线程----7
我在看代码----8
我在看代码----9
我在看代码----10
我在看代码----11
我在看代码----12
我在学习多线程----8
我在学习多线程----9
我在学习多线程----10
我在学习多线程----11
我在学习多线程----12
我在看代码----13
我在看代码----14
我在看代码----15
我在看代码----16
我在看代码----17
我在看代码----18
我在学习多线程----13
我在看代码----19
我在学习多线程----14
我在学习多线程----15
我在学习多线程----16
我在学习多线程----17
我在学习多线程----18
我在学习多线程----19

Process finished with exit code 0

3.下载图片-案例

IDEA 引入jar包 以及 commons-io-2.6.jar包的使用

package com.luo.demo01;
import com.exception.Test;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
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);
    }
    //主线程，main，针对TestThread2,对象实例化
    public static void main(String[] args) {
        TestThread2 t1=new TestThread2("https://www.kuangstudy.com/assert/course/c1/01.jpg","1.jpg");
        TestThread2 t2=new TestThread2("https://www.kuangstudy.com/assert/course/c1/02.jpg","2.jpg");
        TestThread2 t3=new TestThread2("https://www.kuangstudy.com/assert/course/c1/03.jpg","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));
            System.out.println("下载成功！");
        }
        catch (IOException e){
            System.out.println("下载失败！出现IO异常：" + e.getMessage());
        }
    }
}

4.创建线程方式2

实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法

package com.luo.demo01;

public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for(int i=1;i<=20;i++) {
            System.out.println("我正在看代码----" + i);
        }
    }

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

5.小结

继承Thread类

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

实现Runnable接口

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

6.案例-买车票

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

package com.luo.demo01;

import java.util.TreeMap;

public class TestThread4 implements Runnable{
    //票数
    private int ticketNums=20;

    @Override
    public void run() {
        //while死循环，直到票数<=0时，跳出循环
        while(true)
        {
            if(ticketNums<=0)
            {
                break;
            }
            //模拟延时
            try{
                Thread.sleep(200);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--拿到了第"+ticketNums--+"--票");
        }
    }

    public static void main(String[] args) {
        TestThread4 ticket=new TestThread4();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }
}

7.案例：龟兔赛跑

1.先来个赛道距离，然后离终点越来越近
2.判断比赛是否结束
3.打印出胜利者
4.龟兔赛跑开始
5.模拟兔子睡觉

package com.luo.demo01;

import java.util.TreeMap;

public class Race implements Runnable{
    //胜利者
    private static String winner;
    @Override
    public void run() {
        //线程体，模拟跑步，共100 步
        for(int i=1;i<=100;i++)
        {
            //模拟兔子睡大觉哦
            if(Thread.currentThread().getName().equals("兔子")&&i%10==0)
            {
                try {
                    Thread.sleep(5);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            //判断是否比赛结束
            boolean flag=gameOver(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps)
    {
        //已经存在胜利者
        if(winner!=null)
        {
            return true;
        }
        //步数最先达到100
        if(steps==100)
        {
            winner=Thread.currentThread().getName();
            System.out.println("Winner is"+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) throws InterruptedException {
        Race race=new Race();
        new Thread(race,"兔子").start();
        Thread.sleep(10);
        new Thread(race,"乌龟").start();
    }
}

8.了解实现callble接口-线程创建方式之三

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

package com.luo.demo02;

import com.luo.demo01.TestThread2;
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 {
    private String url; //网络图片地址
    private String name;
    public TestCallable(String url,String name)
    {
        this.url=url;
        this.name=name;
    }

    @Override
    public Boolean call()  {
        WebDownloader webDoenloader=new WebDownloader();
        webDoenloader.downloader(url,name);
        System.out.println("下载啦文件名为："+name);
        return true;
    }
    //主线程，main，针对TestThread2,对象实例化
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1=new TestCallable("https://www.kuangstudy.com/assert/course/c1/01.jpg","1.jpg");
        TestCallable t2=new TestCallable("https://www.kuangstudy.com/assert/course/c1/02.jpg","2.jpg");
        TestCallable t3=new TestCallable("https://www.kuangstudy.com/assert/course/c1/03.jpg","3.jpg");
//        TestCallable t4=new TestCallable("https://sv.baidu.com/v?vid=13312106516227044527&tab=recommend","4.mp4");
       //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1=ser.submit(t1);
        Future<Boolean> r2=ser.submit(t2);
        Future<Boolean> r3=ser.submit(t3);
//        Future<Boolean> r4=ser.submit(t4);
        //获取结果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();
//        boolean rs4=r4.get();
        //关闭服务
        ser.shutdown();
    }
}
//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url, String name){
        try{
            FileUtils.copyURLToFile(new URL(url), new File(name));
            System.out.println("下载成功！");
        }
        catch (IOException e){
            System.out.println("下载失败！出现IO异常：" + e.getMessage());
        }
    }
}

callable的好处
1.可以定义返回值
2.可以抛出异常

9.静态代理

真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色

package com.luo.demo03;

public class Stacticproxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany=new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
interface Marry
{
void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("罗老师要结婚了，好开心");
    }
}
//代理角色，帮助你结婚
class WeddingCompany implements Marry{
    private Marry target;
    public WeddingCompany(Marry target)
    {
        this.target=target;
    }
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry(); //这就是真实对象
        after();
    }
    private void before(){
        System.out.println("结婚之前，布置现场");
    }
    private  void after(){
        System.out.println("结婚之后，收尾款");
    }
}

好处：

• 代理对象可以做很多真实对象做不了的事情
• 真实对象专注做自己的事

10.Lamda表达式

避免匿名内部类定义过多
实质属于函数式编程的概念
去掉无意义代码，留下核心逻辑
函式式接口：任何接口，如果只包含唯一的抽象方法，那么·他就是一个函数式接口。对于函数式接口我们可以通过Lambad表达式来创建该接口的对象。

package com.luo.lambda;

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

        like=new Like2();
        like.lambda();

        //4.局部内部类
        class Like3  implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like=new Like3();
        like.lambda();

        //5.匿名内部类，没有类的名称，必须借助接口或者父类
        like=new ILike(){
            @Override
            public void lambda() {
                System.out.println("i like lambda5");
            }
        };
        like.lambda();
        //6.用lambda简化
        like=()->{
            System.out.println("I like lambda6");
        };
        like.lambda();

    }
}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

package com.luo.lambda;

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love=new ILove() {
            @Override
            public void love(int a) {
                System.out.println("I love you-->"+a);
            }
        };
        love.love(2);
    }
}
interface ILove{
    void love(int a);
}

简化写法：

package com.luo.lambda;

public class TestLambda2 {
    public static void main(String[] args) {
//        ILove love=new ILove() {
//            @Override
//            public void love(int a) {
//                System.out.println("I love you-->"+a);
//            }
//        };
        ILove love=(int a)-> {
            System.out.println("I love you="+a);
        };
        love.love(520);
    }
}
interface ILove{
    void love(int a);
}