Thread多线程基础01

1、多线程

核心概念

说起进程，就不得不说一下程序。程序的指令和数据的有序集合，其本身都没有任何运行的含义，是一个静态的概念
而进程则是执行程序的一次执行过程，他是一个动态的概念，是系统资源分配的单位
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位
- 注意：很多多线程是模拟出来的，正在的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉
线程就是独立的执行路径
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如cpu调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

2、Thread

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

注意：线程不一样立即执行，CPU安排调度

package com.demo01;

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

//总结：注意，线程开启不一定立即执行，由CPU调度
public class TextThread01 extends Thread{

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

    public static void main(String[] args) {
        //main线程    主线程
        
        //创建一个线程对象
        TextThread01 textThread01 = new TextThread01();
        //调用start()方法开启线程
        textThread01.start();

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

补充：网图下载

图片链接不能是本地电脑里面文件的链接

package com.demo01;

import org.apache.commons.io.FileUtils;

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

//练习Thread，实现多线程同步下载图片
public class TextThread02 extends Thread{
    private String url; //网络照片地址
    private String name;    //保存的文件名

    public TextThread02(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) {
        TextThread02 textThread01 = new TextThread02("https://img.zcool.cn/community/01e0645db982f8a801209e1ff801d3.jpg?x-oss-process=image/auto-orient,1/resize,m_lfit,w_1280,limit_1/sharpen,100","1.jpg");
        textThread01.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方法出现问题");
        }
    }
}

3、Runnable

package com.demo01;

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

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

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

        new Thread(textThread03).start();

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

小结：

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

初识并发问题：

package com.demo01;

//多个线程同时操作一个对象
//买火车票

//发现问题：多个线程同时操作一个资源的情况下，线程不安全，数据紊乱
public class TextThread04 implements Runnable{

    private int ticketNums = 1;
    @Override
    public void run() {
        while (true){
            if (ticketNums > 100) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "--> 正在售卖第 " + ticketNums++ + "张票");
        }
    }

    public static void main(String[] args) {
        TextThread04 textThread04 = new TextThread04();
        new Thread(textThread04,"窗口1").start();
        new Thread(textThread04,"窗口2").start();
        new Thread(textThread04,"黄牛").start();
    }
}

但是并没有出现线程重复的问题？

案例：龟兔赛跑

package com.demo01;

public class TextRace 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(10);
                } 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("The Winner is " + winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        TextRace textRace = new TextRace();

        new Thread(textRace,"兔子").start();
        new Thread(textRace,"乌龟").start();

    }
}

4、实现Callable接口

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

package com.demo02;


import com.L.OOP.demo10.Text;
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 TextCallable implements Callable<Boolean> {

    private String url;
    private String name;

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

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

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TextCallable textCallable01 = new TextCallable("https://p2.ssl.img.360kuai.com/t01daff7de15d101ad0.jpg","tw01.jpg");
        TextCallable textCallable02 = new TextCallable("https://c-ssl.duitang.com/uploads/item/202003/02/20200302221741_rispl.jpeg","tw02.jpg");
        TextCallable textCallable03 = new TextCallable("https://ts1.cn.mm.bing.net/th/id/R-C.443ecfa611bca21986df8ff485ad2f3f?rik=iIjw6o6Ehu4Odw&riu=http%3a%2f%2fattach.hunantv.com%2fuploads%2fimages%2fcms_img%2f201111%2f24%2f10%2f5780486696986371858.jpg&ehk=0xuVP55K0U77h4UArHx4YqHRJhyxS3p6wMFcz5XDkJc%3d&risl=&pid=ImgRaw&r=0","tw03.jpg");

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

        //提交执行
        Future<Boolean> result01 = executorService.submit(textCallable01);
        Future<Boolean> result02 = executorService.submit(textCallable02);
        Future<Boolean> result03 = executorService.submit(textCallable03);

        //获取结果
        boolean returnResourceResult01 = result01.get();
        boolean returnResourceResult02 = result02.get();
        boolean returnResourceResult03 = result03.get();

        System.out.println(returnResourceResult01);
        System.out.println(returnResourceResult02);
        System.out.println(returnResourceResult03);

        //关闭服务
        executorService.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方法可能出现了异常");
        }
    }
}

5、静态代理模式

package com.demo03;

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

//好处：
    //代理对象可以做很多真实对象做不了的事情
    //真实对象就专注做自己的事情

public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();    //你要结婚
        WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.HappyMarry();
    }
}

interface Marry {
    void HappyMarry();
}

//真实角色：是你去结婚
class You implements Marry {

    @Override
    public void HappyMarry() {
        System.out.println("小刘正在学习Java-->");
    }
}

//代理角色：帮助你结婚
class WeddingCompany implements Marry {

    //代理谁--> 真实目标角色
    private Marry marryTarget;

    public WeddingCompany(Marry marryTarget) {
        this.marryTarget = marryTarget;
    }

    @Override
    public void HappyMarry() {
        before();
        this.marryTarget.HappyMarry();  //这就是真实对象
        after();
    }

    private void before() {
        System.out.println("在学习Java之前需要交钱");
    }

    private void after() {
        System.out.println("在学习Java之后可以挣钱");
    }

}

6、Lambda表达式

为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来更简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑
理解Functional interface（函数式接口）
函数式接口的定义：
- 任何接口，如果包含唯一一个抽象方法，那么它就是一个函数式接口

public interface Runnable {
    public abstract void run();
}

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

1、简化过程集合

package com.lambda;

public class TextLambda {

    //静态内部类
    static class Like01 implements ILike {

        @Override
        public void lambda() {
            System.out.println("The people which I like number01");
        }
    }



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

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

        //局部内部类 把类放在方法里面
        class Like02 implements ILike {

            @Override
            public void lambda() {
                System.out.println("The people which I like number02");
            }
        }

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

        //匿名内部类 没有类的名称，必须接住接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("The people which I like number03");
            }
        };
        like.lambda();

        //用lambda简化
        like = () ->{
            System.out.println("The people which I like number04");
        };
        like.lambda();

    }
}

interface ILike {
    void lambda();
}

class Like implements ILike {

    @Override
    public void lambda() {
        System.out.println("The people which I like number00");
    }
}

2、拆解理解

1. 最开始的方法：外部类实现接口，实例化

package com.lambda;

public class TextLambda02 {
    public static void main(String[] args) {
        ILove01 iLove = new Love();
        iLove.love01("XXX");
    }
}

interface ILove01{
    void love01(String a);
}

class Love implements ILove01 {

    @Override
    public void love01(String a) {
        System.out.println("I love you," + a);
    }
}

2. 静态内部类

package com.lambda;

public class TextLambda03 {

    //静态内部类
    static class Love02 implements  ILove02 {

        @Override
        public void love02(String name) {
            System.out.println("I love you," + name);
        }
    }

    public static void main(String[] args) {
        ILove02 iLove02 = new Love02();
        iLove02.love02("XX");
    }
}

interface ILove02 {
    void love02(String name);
}

3. 局部内部类

package com.lambda;

public class TextLambda04 {

    public static void main(String[] args) {

        class Love04 implements ILove04 {

            @Override
            public void love04(String name) {
                System.out.println("I love you," + name);
            }
        }

        ILove04 iLove04 = new Love04();
        iLove04.love04("X");
    }
}

interface ILove04 {
    void love04(String name);
}

4. 匿名内部类

package com.lambda;

public class TextLambda05 {

    public static void main(String[] args) {

        ILove05 iLove05 = new ILove05() {
            @Override
            public void love05(String name) {
                System.out.println("I love you," + name);
            }
        };

        iLove05.love05("2333");
    }

}

interface ILove05 {
    void love05(String name);
}

5. lambda表达式

package com.lambda;

public class TextLambda06 {
    public static void main(String[] args) {

//        //lambda表达式简化
//        ILove06 iLove06 = (String name) ->{
//            System.out.println("I love you," + name);
//        };

        //简化1：参数类型(形参参数类型的简化)

//        ILove06 iLove06 = (name) ->{
//            System.out.println("I love you," + name);
//        }

//        //简化2：简化括号
//        ILove06 iLove06 = name -> {
//            System.out.println("I love you," + name);
//        };

        //简化3：去掉花括号
        ILove06 iLove06 = name -> System.out.println("I love you," + name);
        iLove06.love06("23333");

        //总结：
            //lambda表达式只能在有一行代码的情况下简化为一行，其他情况需要使用代码块{}包裹
            //前提是接口为函数式接口(只有一个方法的接口)
            //多个参数也可以去掉参数类型，要去掉就都去掉，但是多个参数的情况下必须加上括号()
    }
}

interface ILove06 {
    void love06(String name);
}

posted @ 2025-02-26 16:51 LYQ学Java 阅读(19) 评论(0) 收藏举报

刷新页面返回顶部

LyqStudyJava

Thread多线程基础01

1、多线程

核心概念

2、Thread

补充：网图下载

3、Runnable

小结：

初识并发问题：

案例：龟兔赛跑

4、实现Callable接口

5、静态代理模式

6、Lambda表达式

1、简化过程集合

2、拆解理解

1. 最开始的方法：外部类实现接口，实例化

2. 静态内部类

3. 局部内部类

4. 匿名内部类

5. lambda表达式

公告