Java多线程探究【一线程简介、实现】

前言

本文是学自狂神说java整理的笔记，并非里面的内容都有认真的整理、代码也有认真的练习
本文仅供学习和交流之用，禁止非商业用途

一线程简介

程序：指令和数据的有序集合，其本身没有任何运行和含义，是一个静态的概念。
进程(Process)：执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
线程(THread)：cpu调度和执行的单位。
通常在一个进程中可以包含若干个线程。当然一个进程中至少有一个线程，不然没有存在的意义。

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

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

二线程实现（重点）

2.1 线程创建

三种创建方式

2.2 方式一：继承Thread类

在这里插入图片描述

自定义线程类继承Thread类。
重写run0方法，编写线程执行体。
创建线程对象，调用start0方法启动线程。

2.3 run开启线程

package 多线程.Day01;

/**
 * @author 缘友一世
 * date 2022/11/1-22:09
 */
//创建线程方式一：继承Thread类,重写run()方法，调用start开启线程
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i=0;i<10;i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start方法开启线程
        testThread1.run();
        for(int i=0;i<10;i++) {
            System.out.println("我在主线程"+i);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

在这里插入图片描述

2.4 start开启线程

package 多线程.Day01;

/**
 * @author 缘友一世
 * date 2022/11/1-22:09
 */
//创建线程方式一：继承Thread类,重写run()方法，调用start开启线程
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i=0;i<10;i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start方法开启线程
        testThread1.start();
        for(int i=0;i<10;i++) {
            System.out.println("我在主线程"+i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这里插入图片描述

2.5 结论

线程不一定立即执行，CPU安排调度。

2.6 网络图片下载案例【Thread】

package 多线程.Day01;

import org.apache.commons.io.FileUtils;

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

/**
 * @author 缘友一世
 * date 2022/11/1-22:28
 */
//练习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();
        try {
            webDownloader.downloader(url,name);
            System.out.println("成功下载文件"+name);
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10240.jpg");
        TestThread2 t2 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10241.jpg");
        TestThread2 t3 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10242.jpg");
        t1.start();
        t2.start();
        t3.start();

    }
}
class WebDownloader{
    public void downloader(String url,String name) throws MalformedURLException {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

在这里插入图片描述

start并行执行，它的顺序并不固定。谁先执行完，谁就是第一名。

2.7 方式二：实现Runnable接口【推荐】

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

package 多线程.Day01;

/**
 * @author 缘友一世
 * date 2022/11/1-22:53
 */
//创建线程的方式二：实现runnable接口，重写run方法，执行线程需要放入到runnable接口实现类，调用start方法
public class TestThread3 implements Runnable{

    @Override
    public void run() {
        //线程体
        for(int i=0;i<10;i++) {
            System.out.print("我数数"+i+" ");
        }
    }

    public static void main(String[] args) {
        //创建runnable接口实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        // Thread thread = new Thread(testThread3);
        // //启动
        // thread.start();
        new Thread(testThread3).start();
        for(int i=0;i<10;i++) {
            System.out.print("我看书"+i+" ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在这里插入图片描述

推荐使用Runnable对象,因为Java单继承的局限性。

2.8 网络图片下载案例【Runnable】

package 多线程.Day01;

import org.apache.commons.io.FileUtils;

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

/**
 * @author 缘友一世
 * date 2022/11/1-22:28
 */
//练习Thread，实现多线程同步下载图片
public class TestThread4 implements Runnable{

    private String url;//网络图片地址
    private String name;//保存的文件名

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

    //下载文件的执行体
    @Override
    public void run() {
        WebDownloader2 webDownloader = new WebDownloader2();
        try {
            webDownloader.downloader(url,name);
            System.out.println("成功下载文件"+name);
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10240.jpg");
        TestThread2 t2 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10241.jpg");
        TestThread2 t3 = new TestThread2("https://img-home.csdnimg.cn/images/20221101051344.jpg","10242.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();

    }
}
class WebDownloader2{
    public void downloader(String url,String name) throws MalformedURLException {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

在这里插入图片描述

2.9 小结

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

//一份资源
StartThread station=newStartThread();
//多个代理
newThread(station，name:小明”).start();
newThread(station，name:“老师”).start();
newThread(station，name:小红”).start();
1
2
3
4
5
6

2.10 初识并发问题

2.10.1 案例：抢票

package 多线程.Day01;

/**
 * @author 缘友一世
 * date 2022/11/2-9:11
 */
//多个线程同时操作同一个对象
//买票问题
//问题：多个线程操作同一个资源的情况下，线程不安全，数据絮乱
public class TestThread5 implements Runnable{

    /**票数*/
    private int ticketNums=10;
    @Override
    public void run() {
        while(ticketNums>=0) {
            if(ticketNums==0) {
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
        TestThread5 ticket = new TestThread5();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小亮").start();
        new Thread(ticket,"小光").start();
        new Thread(ticket,"小红").start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

在这里插入图片描述

2.10.2 龟兔赛跑【Race】

首先来个赛道距离,然后要离终点越来越近
判断比赛是否结束
打印出胜利老
龟免赛跑开始
故事中是乌龟赢的，兔子需要睡觉，所以我们来模拟免子睡觉
最终，乌龟赢得比赛

package 多线程.Day01;

/**
 * @author 缘友一世
 * date 2022/11/2-9:40
 */
public class TestThread6 implements Runnable{
    /**胜利者*/
    private static String winner;
    @Override
    public void run() {
        for(int i=1;i<=100;i++) {
            //兔子每20步要休息一下
            if(Thread.currentThread().getName().equals("兔子") && i%20==0) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
            //判断比赛是否结束，结束就终止程序
            if(gameOver(i)) {
                break;
            }
        }
    }
    //判断比赛是否结束
    private boolean gameOver(int steps) {
        //判断是否有胜利者
        if(winner!=null) {//已经存在胜利者了
            return true;
        }{
           if(steps>=100) {
               winner=Thread.currentThread().getName();
               System.out.println("胜利者是"+winner);
               return true;
           }
        }
        return false;
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

在这里插入图片描述

2.11 方式三：实现Callable接口【拓展、了解】

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

2.11.1 图片下载

package 多线程.Day01;

import org.apache.commons.io.FileUtils;

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

/**
 * @author 缘友一世
 * date 2022/11/2-17:11
 */
//创建线程方式三：实现callable接口
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();
        try {
            webDownloader.downloader(url,name);
            System.out.println("成功下载文件"+name);
            return true;
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://img0.baidu.com/it/u=1348230343,3476037199&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500","sky1.jpg");
        TestCallable t2 = new TestCallable("https://img0.baidu.com/it/u=1348230343,3476037199&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500","sky2.jpg");
        TestCallable t3 = new TestCallable("https://img0.baidu.com/it/u=1348230343,3476037199&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500","sky3.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 res1 = r1.get();
        Boolean res2 = r2.get();
        Boolean res3 = r3.get();
        //关闭服务
        ser.shutdownNow();
    }
}
class WebDownloader3{
    public void downloader(String url,String name) throws MalformedURLException {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

在这里插入图片描述

2.12 静态代理：Thread

在这里插入图片描述

你：真实角色
婚庆公司：代理你，帮你处理结婚的事情
结婚：实现结婚接口即可

2.12.1 结婚案例

package 多线程.Day01;

/**
 * @author 缘友一世
 * date 2022/11/2-18:13
 */

//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//该对象要代理真实角色
    //好处
    //代理象可以做很多真实对象做不了的事情
    //真实对象专注做自己的事情。
public class StaticProxy {
    public static void main(String[] args) {
        /*
        new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();
        */
        new Thread(()-> System.out.println("我爱你")).start();

        //WeddingCompany weddingCompany = new WeddingCompany(new You());
        //weddingCompany.HappyMary();
        new WeddingCompany(new You()).HappyMary();
    }
}
interface Marry{
    void HappyMary();
}
//真实角色
class You implements Marry {
    @Override
    public void HappyMary() {
        System.out.println("小王子结婚了！");
    }
}
//代理角色，帮助结婚
class WeddingCompany implements Marry{
    //真实目标角色
    private Marry target;

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

    @Override
    public void HappyMary() {
        before();
        this.target.HappyMary();
        after();
    }
    private void before() {
        System.out.println("结婚之前的事情处理");
    }
    private void after() {
        System.out.println("结婚之后的事情处理");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

在这里插入图片描述

2.12.2 提升理解：Thread&Runnable

两者就是代理的关系，Thread代理Runnable并实现其run方法，然后再本类中使用start方法调用

三 Lambda表达式

3.1 前提·热身

在这里插入图片描述

再有些时候，我们遇到某些类只是使用一次，刚开始我们定义在外部【外部类】，然后改进到内部类【匿名内部类】，这样就会造成匿名内部类定义过多。

使用lambda表达式的原因
- 避免著名内部类定义过多
- 可以使代码简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑

3.2 函数式接口

Functional Interface(函数式接口)是学习Java 8 Lamda表达式的关键所在。
函数式接口的定义
- 任何接口如果只包含唯1个抽象方法，那么它就是一个函数式接口。
- 对于函数式接口，就可以使用Lambda表达式来创建该接口的对象。

3.3 简化之路——lambda

有关于java内部类、静态内部类、局部内部类、匿名内部类的内容请参看详细的介绍java内部类精讲

3.4 无参案例

package 多线程.Lambda;

/**
 * @author 缘友一世
 * date 2022/11/2-19:06
 */
/*
推到lambda表达式
 */
public class TestLambda1 {
    //3 静态内部类
    static class Like2 implements ILike {
        @Override
        public void Lambda() {
            System.out.println("2 静态内部类的lambda");
        }
    }
    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("3 局部内部类lambda");
            }
        }
        like=new Like3();
        like.Lambda();

        //5 匿名内部类
        like=new ILike() {
            @Override
            public void Lambda() {
                System.out.println("4 匿名内部类的lambda");
            }
        };
        like.Lambda();

        //6 用lambda简化 舍弃接口和方法
        ILike like2=()->{
            System.out.println("5 用lambda简化的lambda");
        };
        like2.Lambda();
    }
}
//1 定义一个函数式接口
interface ILike{
    void Lambda();
}
//2 实现类
class Like implements ILike {
    @Override
    public void Lambda() {
        System.out.println("1 外部实现类的lambda");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

在这里插入图片描述

3.5 有参案例

package 多线程.Lambda;

/**
 * @author 缘友一世
 * date 2022/11/2-19:52
 */
//1 定义函数式接口
interface ILove{
    void love(String name1,String name2,String name3);
}
public class TestLambda2 {

    public static void main(String[] args) {
        ILove iLove=null;
        //1 匿名内部类
        iLove = new ILove() {
            @Override
            public void love(String name1, String name2, String name3) {
                System.out.println("匿名内部类-->" + name1 + "和" + name2 + "爱上了" + name3);
            }
        };
        iLove.love("小黄","小黑","小花");


        //前提是接口为函数式接口。
        //1 lambda简化
        //Book参数也可以去掉参数类型。 要去掉，必须都去掉
        iLove=(String name1,String name2,String name3) -> {
            System.out.println("lambda简化1-->"+name1+"和"+name2+"爱上了"+name3);
        };
        iLove.love("小黄","小黑","小花");
        //2 简化括号
        iLove=(name1,name2,name3)->{
            System.out.println("lambda简化2-->"+name1+"和"+name2+"爱上了"+name3);
        };
        iLove.love("小黄","小黑","小花");
        //3 去掉花括号【代码只有一行的情况下】
        iLove=(name1,name2,name3)->System.out.println("lambda简化3-->"+name1+"和"+name2+"爱上了"+name3);
        iLove.love("小黄","小黑","小花");
        //如果有多行，那么就用代码块包裹。
        iLove=(name1,name2,name3)->{
            System.out.println("lambda简化4-->"+name1+"和"+name2+"爱上了"+name3);
            System.out.println("lambda简化4-->"+name1+"和"+name2+"抛弃了"+name3);
        };
        iLove.love("小黄","小黑","小花");

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

在这里插入图片描述

相关阅读:
Docker 的使用
 搭建搜题公众号【最新】
二叉树题目：二叉树剪枝
 MySQL 中读写分离数据延迟
 Docker Nginx容器部署vue项目
 【R语言】【3】apply,tapply,lapply,sapply,mapply与par函数相关参数
 用3D扫描生成合成数据
 K8s里Spring 微服务项目，Pod 关闭对用户的影响比较大！
找出你的高价值潜在用户 - 通过归因分析实现用户画像和精准营销
 如何使用 CSS 定位 HTML 元素
原文地址：https://blog.csdn.net/yang2330648064/article/details/127639947

Java多线程探究【一线程简介、实现】

前言

文章目录

一 线程简介

二 线程实现（重点）

2.1 线程创建

2.2 方式一：继承Thread类

2.3 run开启线程

2.4 start开启线程

2.5 结论

2.6 网络图片下载案例【Thread】

2.7 方式二：实现Runnable接口【推荐】

2.8 网络图片下载案例【Runnable】

2.9 小结

2.10 初识并发问题

2.10.1 案例：抢票

2.10.2 龟兔赛跑【Race】

2.11 方式三：实现Callable接口【拓展、了解】

2.11.1 图片下载

2.12 静态代理：Thread

2.12.1 结婚案例

2.12.2 提升理解：Thread&Runnable

三 Lambda表达式

3.1 前提·热身

3.2 函数式接口

3.3 简化之路——lambda

3.4 无参案例

3.5 有参案例

一线程简介

二线程实现（重点）