多线程学习第二篇

wangshow / 2023-09-03 / 原文

2、线程创建

2.1、继承 Thread 类(重点)

自定义线程类，继承Thread类
重写run()方法，编写线程执行体
在主函数中创建一个线程对象，调用start()方法开启线程。

//案例：

package com.thread.thread01;
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程方法体
        for (int i = 0; i < 1000; i++) {
            System.out.println("代码" + i);
        }
}

    public static void main(String[] args) {

        //创建一个线程对象
        TestThread1 testThread = new TestThread1();

        //start开启线程
        testThread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("多线程" + i);
        }
    }
}

总结：线程开启不一定立即执行，由CPU调度执行。

案例：//多线程图片下载

package com.thread.thread01;

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;
    }

    //重写run()
    @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://img2.baidu.com/it/u=2537370952,3446004972&fm=253&fmt=auto&app=138&f=JPEG?w=800&h=500", "1.jpg");
        TestThread2 t2 = new TestThread2("https://lmg.jj20.com/up/allimg/tp01/1ZZH3141IS9-0-lp.jpg", "2.jpg");
        TestThread2 t3 = new TestThread2("https://img0.baidu.com/it/u=1435639120,2241364006&fm=253&fmt=auto&app=138&f=JPEG?w=800&h=500", "3.jpg");
        TestThread2 t4 = new TestThread2("https://img0.baidu.com/it/u=1604010673,2427861166&fm=253&fmt=auto&app=138&f=JPEG?w=500&h=889", "4.jpg");
        t1.start();
        t2.start();
        t3.start();
        t4.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方法出现问题");
        }

    }

}

2.2、实现Runnable接口(重点)

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

//案例：

package com.thread.thread01;

//创建线程方式2
// 实现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 testThread03 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程    也叫代理
        new Thread(testThread03).start();

        //调用start开启线程

        //主线程
        for (int i = 0; i < 20; i++) {
            System.out.println("多线程" + i);
        }
    }
}

//将上面图片加载的案例改为Runnabale创建

package com.thread.thread01;

import org.apache.commons.io.FileUtils;

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


//实现多线程同步下载图片
public class TestThread2 implements Runnable {
    private String url;//网络图片地址
    private String name;//保存的文件名

    //构造器
    public TestThread2(String url, String name) {
        this.url = url;
        this.name = name;
    }

    //重写run()
    @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://img2.baidu.com/it/u=2537370952,3446004972&fm=253&fmt=auto&app=138&f=JPEG?w=800&h=500", "5.jpg");
        TestThread2 t2 = new TestThread2("https://lmg.jj20.com/up/allimg/tp01/1ZZH3141IS9-0-lp.jpg", "6.jpg");
        TestThread2 t3 = new TestThread2("https://img0.baidu.com/it/u=1435639120,2241364006&fm=253&fmt=auto&app=138&f=JPEG?w=800&h=500", "7.jpg");
        TestThread2 t4 = new TestThread2("https://img0.baidu.com/it/u=1604010673,2427861166&fm=253&fmt=auto&app=138&f=JPEG?w=500&h=889", "8.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
        new Thread(t4).start();
//        t1.start();
//        t2.start();
//        t3.start();
//        t4.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方法出现问题");
        }

    }

}
//改动 1.将extends Thread 改动成 implements Runnable
//    2.main中调用从子类对象.start()改成 Thread(传入对象).start

比较两个方式：

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

案例：

购买火车票

package com.thread.thread01;

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

    @Override
    public void run() {
        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();
    }
}

//通过本例子发现并发问题

龟兔赛跑

package com.thread.thread01;

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 % 30 == 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;
        }
        {
            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();
    }
}

2.3、实现Callable接口(了解)

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

package com.thread.thread01.thread02;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * 线程创建方式3：实现Callable
 * 好处：
 * 1.可以定义返回值
 * 2.可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {

    private String url;  //网络历经
    private String name;  // 保存的文件名


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


    //下载图片线程的执行体
    @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 testThread1 = new TestCallable("https://img-blog.csdnimg.cn/20210531145950543.png", "2.png");
        TestCallable testThread2 = new TestCallable("https://img-blog.csdnimg.cn/20210531145950543.png", "3.png");
        TestCallable testThread3 = new TestCallable("https://img-blog.csdnimg.cn/20210531145950543.png", "4.png");
        TestCallable testThread4 = new TestCallable("https://img-blog.csdnimg.cn/20210531145950543.png", "5.png");


        //创建执行服务:
        ExecutorService service = Executors.newFixedThreadPool(4);
        //提交执行:
        Future<Boolean> r1 = service.submit(testThread1);
        Future<Boolean> r2 = service.submit(testThread2);
        Future<Boolean> r3 = service.submit(testThread3);
        Future<Boolean> r4 = service.submit(testThread4);
        // 获取结果:
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        boolean rs4 = r4.get();
        //关闭服务:
        service.shutdownNow();

    }

    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异常，downler方法出现问题");
            }
        }
    }
}

2.4、Lambda表达式

Lambda 表达式属于函数式编程的概念

避免匿名内部类定义过多
其实质属于函数式编程的概念
去掉了一堆没有意义的代码,只留下核心逻辑

基本语法为：

(paraems) -> expressionp[表达式]
(params) -> statement[语句]
(params) -> {statements}
a->System.out.println("i like lamda-->"+a);

new Thread(()->System.out.println("多线程学习...")).start();

理解 Functional Interface（函数式接口）是学习 Java 8 Lambda 表达式的关键所在

函数式接口定义：

任何接口，如果只包含唯一一个抽象方法，那么它就是函数式接口
```
public interface Runnable{
    public abstract void run();
}
```

对于函数式接口，可以通过 Lambda 表达式来创建该接口的对象

//1.定义一个函数式接口
interface ILike{
    void like();
}
//用lambda简化，-->函数式接口
like = ()->{
System.out.println("i like lambda");
};

整个代码简化过程如下：

package com.thread.Lambda;

public class TestLambda {
    //2.简化为静态内部类
    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();
        //调用静态内部类
        new Like2().lambda();

        //3.简化为局部内部类
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("I like Lambda3!");
            }
        }
        //调用局部内部类
        new Like3().lambda();

        //4.简化为匿名内部类,没有类的名称,必须借助接口或者父类
        //我这边直接在后面.lambda()进行调用也是可以的
        new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda4!");
            }
        }.lambda();


        //5.进行lambda简化
        like = () -> {
            System.out.println("I like Lambda5!");
        };
        //调用lambda简化 （这里不能同时进行）
        like.lambda();
    }
}

//定义一个函数式接口，这是前提！！
interface ILike {
    void lambda();
}

//1.最初实现类方法
class Like implements ILike {
    @Override
    public void lambda() {
        System.out.println("I like Lambda!");
    }
}

2.5、静态代理

package com.thread.staticproxy;

import com.sun.org.apache.bcel.internal.generic.NEW;

/**
 * 静态代理总结：
 * 真实对象和代理对象都要实现一个接口
 * 代理对象要代理真实对象
 * 好处：
 * 代理对象可以做很多真实对象做不了的事情
 * 真实对象可以专注做自己的事情
 */
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();//你要结婚
        new Thread(() -> System.out.println("我爱你")).start();//Lamda表达式
        new WeddingCompany(new You()).HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}
//You是真实角色
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();
    }
    public void before(){
        System.out.println("结婚之前布置现场");
    }
    public void after(){
        System.out.println("结婚之后收尾款");
    }
}

结果是: