多线程（一）

 

  

 

 

package com.company;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习Thread，实现多线程同步下载图片
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://profile.csdnimg.cn/4/3/B/1_qq_43444666","1.jpg");
        TestThread2 t2 = new TestThread2("https://profile.csdnimg.cn/4/3/B/1_qq_43444666","2.jpg");
        TestThread2 t3 = new TestThread2("https://profile.csdnimg.cn/4/3/B/1_qq_43444666","3.jpg");

        //代码顺序为1,2,3，但是实际下载顺序随机可能1,2,3也可能3,1,2等
        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方法出现问题！");
        }
    }
}

package com.company;

//创建线程方式二：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start()方法
public class TestThread3 implements Runnable{

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

    public static void main(String[] args) {
        //main线程，主线程

        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程,代理
//        Thread thread = new Thread(testThread3);
//        thread.start();
        //上面两行简写如下
        new Thread(testThread3).start();

        for(int j=0;j<2000;j++){
            System.out.println("我在学习多线程---"+j);
        }
    }
}

 

 

 

 runnable案例：

package com.company;

//模拟龟兔赛跑
public class Race implements Runnable{

    //胜利者
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {
            //模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {
                    Thread.sleep(2);
                } 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;
        if(steps>=100){
           winner = Thread.currentThread().getName();
            System.out.println("winner is"+winner);
            return true;
        }
        return false;
    }

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

}

 静态代理模式：

package com.company.proxystatic;

//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//好处：
// 代理对象可以做很多真实对象做不了的事情
// 真实对象专注做自己的事情
public class StaticProxy {

    public static void main(String[] args) {
        You you = new You();//你要结婚

        //Thread相当于静态代理，代理（）->函数（lambda表达式） 这个真实对象，即runnable接口
        new Thread( ()-> System.out.println("I Love You") ).start();

        new WeddingCompany(new You()).HappyMarry();

//        WeddingCompany weddingCompany = new WeddingCompany(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 after() {
        System.out.println("婚后");
    }

    private void before() {
        System.out.println("婚前");
    }
}

Lamda表达式： 

 

 

lambda表达式代码演示： 

1.无参数

package com.company;
/*
指导lambda表达式
 */
public class TestLambda1 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }


    public static void main(String[] args) {
        Like ll = new Like();
        ll.lambda();

        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 lambda4");
            }
        };
        like.lambda();


        //6.用lambda简化 只重写接口的方法就行，不用写类了
        like = ()->{
            System.out.println("i like lambda5");
        };
        like.lambda();

    }
}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

 2.有参数

package com.company;

/**
 * 总结：
 *   1.lambda表达式只能有一行代码的情况下才能简化成为一行（下例简化lambda3），如果有多行，必须用代码块（花括号）包裹
 *   2.使用lambda的前提是接口为函数式接口
 *   3.多个参数也可以去掉参数类型，要去掉就都去掉，但多参数必须加括号
 */
public class TestLambda2 {

    static class Love2 implements ILove{
        @Override
        public void love(int a) {
            System.out.println("I Love You-->"+a);
        }
    }

    public static void main(String[] args) {
        ILove l = new Love();//实现ILove接口
        l.love(1);

        l=new Love2();
        l.love(2);

        class Love3 implements ILove{
            @Override
            public void love(int a) {
                System.out.println("I Love You-->"+a);
            }
        }
        l=new Love3();
        l.love(3);

        //匿名内部类
        l=new ILove() {
            @Override
            public void love(int a) {
                System.out.println("I Love You-->"+a);
            }
        };
        l.love(4);

        //lambda表达式
        l = (int a)->{
            System.out.println("I Love You-->"+a);
        };
        l.love(5);

        //简化lambda1：参数类型
        l = (a)->{
            System.out.println("I Love You-->"+a);
        };
        l.love(6);

        //简化lambda2：简化括号
        l = a-> {
            System.out.println("I Love You-->"+a);
        };
        l.love(7);

        //简化lambda3：去掉花括号
        l = a->System.out.println("I Love You-->"+a);
        l.love(8);
    }
}

interface ILove{
    void love(int a);
}

class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("I Love You-->"+a);
    }
}