Java——线程简介&实现

没bug怎么跑

已于 2024-04-02 16:30:27 修改

阅读量899

点赞数 20

文章标签： java 开发语言

于 2024-03-21 18:07:56 首次发布

本文链接：https://blog.csdn.net/qq_63141861/article/details/136916371

版权

线程

学习视频地址：狂神说Java

一、多任务

1、普通方法调用和多线程

在这里插入图片描述

2、进程（Process）与线程（Thread）

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

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

二、核心概念

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

三、创建方式

1、Thread class ——> 继承Thread类（重点）

Thread

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

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

//总结：注意线程开启不一定立即执行，由cpu调度执行

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

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

        //开启线程,调用start方法
        testThread1.start();

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

        }

    }

}

2、Runnable接口 ——> 实现Runnable接口（重点）

实现Runnable

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

//创建线程方式二：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestRunnable3 implements Runnable{
    @Override
    public void run(){
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---" + i);

        }

    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestRunnable3 runnable3 = new TestRunnable3();

        //创建线程对象，通过线程对象来开启我们的线程，代理
        //Thread thread = new Thread(runnable3);
        //thread.start();

        new Thread(runnable3).start();

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

        }

    }

}

3、Callable接口 ——> 实现Callable接口（了解）

实现Callable接口

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

import org.apache.commons.io.FileUtils;

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

//线程创建方式三：实现Callable接口
/*
callable的好处
1、可以定义返回值
2、可以抛出异常
 */
public class TestCallable1 implements Callable<Boolean> {
    private String url;//网络图片地址
    private String name;//保存的文件名

    public TestCallable1(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 {
        TestCallable1 t1 = new TestCallable1("https://img-blog.csdnimg.cn/direct/b30a87bb2ead40259865a5d8d92c34fc.png#pic_center", "1.jpg");
        TestCallable1 t2 = new TestCallable1("https://img-blog.csdnimg.cn/direct/750effe4588744f2a2f7d9a58f159ab8.png#pic_center", "2.jpg");
        TestCallable1 t3 = new TestCallable1("https://img-blog.csdnimg.cn/direct/63a3c2f547e3435dafc252733805978f.png#pic_center", "3.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();

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

    }

}

//下载器
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方法出现问题");
        }
    }

}

4、小结

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

四、静态代理

//静态代理模式总结
//真实对象和代理对象都要实现一个接口
//代理对象要代理真实角色

//好处：
    //代理对象可以做很多真实对象做不了的事情
    //真实对象专注做自己的对象
public class StaticProxy {
    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("Tom要结婚了，非常开心！");

    }

}

//代理角色，帮助你去结婚
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("结婚之后收尾款");

    }

}

五、Lambda表达式

希腊字母表中排序第十一的字母，英语名称为Lambda
避免匿名内部类定义过多

其实质属于函数编程的概念

(params) -> expression[表达式]
(params) -> statement[语句]
(params) -> {statements}

a -> System.out.println("I like lambda-->" + a);

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

为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来很简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑
理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在。
函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口。
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

lambda推导

/*
推到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) {
        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!");

    }

}

lambda表达式简化

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love = null;

        //1、lambda表达式
//        ILove love = (int a) ->{
//            System.out.println("I love you -->" + a);
//        };

        //2、简化参数类型
//        love = (a) ->{
//            System.out.println("I love you -->" + a);
//        };

        //3、简化括号
//        love = a ->{
//            System.out.println("I love you -->" + a);
//        };

        //4、简化花括号
        love = a -> System.out.println("I love you -->" + a);
        
        love.love(520);

    }

}

interface ILove{
    void love(int a);

}

总结：
- lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹
- 前提是接口为函数式接口
- 多个参数也可以去掉参数类型，要去掉都去掉,必须加上括号

六、练习

龟兔赛跑——Race

1、首先来个赛道距离，然后要离终点越来越近

2、判断比赛是否结束

3、打印出胜利者

4、龟兔赛跑开始

5、故事中是乌龟胜利，兔子需要睡觉，所以需要模拟兔子睡觉

6、最终乌龟赢得比赛

//模拟龟兔赛跑
public class Race implements Runnable{
    //胜利者
    private static String winner;

    @Override
    public void run(){
        for (int i = 0; i <= 10000; i++) {
            //模拟兔子休息,定义每跑多远睡觉（i%10 == 0），睡多长时间Thread.sleep(1);
            if (Thread.currentThread().getName().equals("兔子") && i%10 == 0){
                try {
                    Thread.sleep(1);

                } catch (InterruptedException e) {
                    e.fillInStackTrace();
                }

            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag) {
                break;
            }
			//Thread.currentThread().getName()的返回值是在代码实际运行时候的线程（即当前线程）对象的名称。
            System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步");

        }

    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
        if(winner != null){
            return true;

        }else {
            if(steps >= 10000){
                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, "name").start();中的name定义线程名称，race代表赛道，因为是同一条赛道，所以都是race。
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();

    }

}