Java多线程 Thread：线程创建三种方法、静态代理模式、lambda表达式

开启掘金成长之旅！这是我参与「掘金日新计划 · 2 月更文挑战」的第 7 天，点击查看活动详情 

推荐根据目录选择学习！

1、线程Thread、进程Process

• 进程：正在进行中的程序，一个程序的执行过程
• 线程：属于进程，指的是一个可以独立运行的代码片段（执行单元、执行路径）
• 程序是指令和数据的有序集合
• 一个进程可以有多个线程（至少有一个线程），线程是CPU调用和执行的单位
• main()主线程，是系统的入口，用于执行整个程序

2、线程创建

法一：继承Thread类

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

public class ThreadDemo1 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主线程

        // 创建一个线程对象
        ThreadDemo1 threadDemo1 = new ThreadDemo1();
        // 调用start()方法开启线程
        threadDemo1.start();

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

案例：下载图片

1.写一个下载方法类 2.写一个线程类（继承Thread），重写run()方法（线程执行体） 3.主线程中，start()

import org.apache.commons.io.FileUtils;

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

// 实现多线程同步下载图片
public class TestThread1 extends Thread {
    private String url;
    private String name;

    public TestThread1(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) {
        TestThread1 t1 = new TestThread1("https://scpic.chinaz.net/files/pic/pic9/202009/apic27858.jpg", "冬季唯美山水风景图片.jpg");
        TestThread1 t2 = new TestThread1("https://ts1.cn.mm.bing.net/th/id/R-C.df4462fabf18edd07195679a5f8a37e5?rik=FnNvr9jWWjHCVQ&riu=http%3a%2f%2fseopic.699pic.com%2fphoto%2f50059%2f8720.jpg_wh1200.jpg&ehk=ofb4q76uCls2S07aIlc8%2bab3H5zwrmj%2bhqiZ%2fyw3Ghw%3d&risl=&pid=ImgRaw&r=0", "九寨沟山水自然美景.jpg");
        TestThread1 t3 = new TestThread1("https://desk-fd.zol-img.com.cn/t_s960x600c5/g1/M0B/03/06/ChMljl402K6IOTZbAARWayFg6S4AAQJPwFhuRIABFaD752.jpg", "美丽迷人的山水风景图片.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) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

法二：实现Runnable接口

• 实现Runnable接口
• 重写run()方法，编写线程执行体

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

    public static void main(String[] args) {
        // 创建runnable接口的实现类对象
        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        // 创建线程对象，通过线程对象来开启线程
        new Thread(threadDemo2).start();

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

继承Thread类 vs 实现Runnable接口

• 继承Thread类：

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

• 实现Runnable接口：

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

并发案例---龟兔赛跑

并发是指在一个时间段内有多个进程在执行

// 龟兔赛跑
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(1);
                }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;
        }else {
            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();
    }
}

法三：实现callable接口 【了解】

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

public class TestCallable implements Callable<Boolean> {
    private String url;
    private String name;

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

    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://scpic.chinaz.net/files/pic/pic9/202009/apic27858.jpg", "冬季唯美山水风景图片.jpg");
        TestCallable t2 = new TestCallable("https://ts1.cn.mm.bing.net/th/id/R-C.df4462fabf18edd07195679a5f8a37e5?rik=FnNvr9jWWjHCVQ&riu=http%3a%2f%2fseopic.699pic.com%2fphoto%2f50059%2f8720.jpg_wh1200.jpg&ehk=ofb4q76uCls2S07aIlc8%2bab3H5zwrmj%2bhqiZ%2fyw3Ghw%3d&risl=&pid=ImgRaw&r=0", "九寨沟山水自然美景.jpg");
        TestCallable t3 = new TestCallable("https://desk-fd.zol-img.com.cn/t_s960x600c5/g1/M0B/03/06/ChMljl402K6IOTZbAARWayFg6S4AAQJPwFhuRIABFaD752.jpg", "美丽迷人的山水风景图片.jpg");

        // 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

        // 提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);

        // 获取结果
        Boolean rs1 = r1.get();
        Boolean rs2 = r2.get();
        Boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        // 关闭服务
        ser.shutdown();
    }
}

3、静态代理模式

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

案例：

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new Person("小码"));
        weddingCompany.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

// 真实角色
class Person implements Marry{
    private String name;
    public Person(String name){
        this.name = name;
    }

    @Override
    public void HappyMarry() {
        System.out.println(this.name + "要结婚了");
    }

}

// 代理角色
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("婚庆公司---结婚之后，收尾款");
    }
}

4、lambda表达式

了解各类

public class LambdaDemo {
    // 3.静态内部类
    static class Like2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }

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

        new Like2().lambda();

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

        new Like3().lambda();

        // 5.匿名内部类，没有类的名称，必须借助接口或者父类
        ILike 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 lambda1");
    }
}