Java 多线程

敲代码的小李同学吖

已于 2022-10-04 22:09:44 修改

阅读量560

点赞数

分类专栏： Java 文章标签： java jvm 开发语言

于 2022-10-01 21:30:25 首次发布

本文链接：https://blog.csdn.net/qq_46201146/article/details/127135036

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Java 多线程

文章目录

一、并发、并行、串行概念

并发：允许两个线程彼此干扰，但同一时间点只有一个任务运行，按时间片交替执行（单CPU）。
并行：多个线程在同一时刻互不干扰的同时执行（多CPU）。
串行：在时间上不可能重叠，等前一个彻底走完，才能走下一个。

在这里插入图片描述

对于主线程中若调用子线程的run()方法，会按顺序先执行子线程的run()，run执行完以后，再执行主线程内其它的。即主线程调用子线程run()，只能先执行完子线程后再去执行主线程——串行。

若主线程中调用子线程的start()方法，会将子线程中start()方法与主线程内的并行交替执行。即主线程调用子线程start()，主线程与子线程并行交替执行——并发。

二、线程的创建

线程三种实现方式：

1、Thread class —— 继承Thread类（重点、就是实现的Runnable接口）
2、Runnable 接口 —— 实现Runnable接口（重点）
3、Callable 接口 —— 实现Callable接口（了解）

1、Thread class —— 继承 Thread 类

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

代码如下：

// 创建线程方式一：
// 1、继承Thread类
public class TestThread1 extends Thread{
  	
    @Override
    // 2. 重写 run() 方法线程体
    public void run() {
        
        for (int i = 0; i < 20; i++) {
            System.out.println("run()方法--"+i);
        }
    }

    public static void main(String[] args) {
        // main线程，主线程

        // 3. 创建一个线程对象，调用start()方法开启线程
        TestThread1 testThread1 = new TestThread1();
        testThread1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main()方法中"+i);
        }
    }
}

执行结果：

在这里插入图片描述

如果调用run方法会等子线程全部执行完再执行主线程：

在这里插入图片描述
注意：线程开启不一定立即执行，由CPU调度安排执行。

1.1 Thread class 实例

package com.lj;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

// 练习Thread，实现多线程同步下载图片
// 1、继承Thread
public class TestThread2 extends Thread{

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

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

    // 2、重写run()方法,线程执行体
     @Override
    public void run(){
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
         System.out.println("下载了文件名为："+name);
    }

    public static void main(String[] args) {
        // 3、实例化线程，调用start()
        TestThread2 t1 = new TestThread2("https://profile.csdnimg.cn/2/7/D/0_qq_46201146","1.jpg");
        TestThread2 t2 = new TestThread2("https://profile.csdnimg.cn/2/7/D/0_qq_46201146","2.jpg");
        TestThread2 t3 = new TestThread2("https://profile.csdnimg.cn/2/7/D/0_qq_46201146","3.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方法出现异常");
        }
    }
}

执行结果：

在这里插入图片描述

2、Runnable 接口 —— 实现 Runnable 接口

（1）自定义MyRunnable类实现类Runnable接口。（同法一）
（2）实现run()方法，编写线程执行体。（同法一）
（3）创建线程对象，调用start()方法启动线程。（区别在于使用了代理）

即分配类的实例。在创建Thread时将该实例作为参数传递，并启动。
MyRunnable t = new MyRunnable();
new Thread(t).start();

Thread类中有个丢入Runnable的构造器：
在这里插入图片描述
代码实现如下：

// 创建线程方式 2
// 实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类。|
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        // run方法线程体（重写）
        for (int i = 0; i < 20; i++) {
            System.out.println("run()方法--"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        // 创建一个线程对象，实例化一个
        TestThread3 testThread3 = new TestThread3();

        // 创建线程对象，通过线程对象来开启我们的线程，代理
        // Thread thread = new Thread(testThread3);
        // thread.start();
        // 可以直接简写为：
        new Thread(testThread3).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main()方法中"+i);
        }
    }
}

结果如下：
在这里插入图片描述

注：Thread 本身也是实现了 Runnable 接口。推荐使用实现Runnable接口：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

Thread也是实现Runnable：
在这里插入图片描述
以下展示三个线程都同时跑一个Runnable对象：

2.1 Runnable 接口实例

买火车票，代码如下：

// 多个线程同时操作同一个对象
// 买火车票例子
// 发现问题: 多个线程操作同一资源时,容易数据紊乱,线程不安全
public class TestThread4 implements Runnable{

    // 票数
    int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums<=0) break;
            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();
        System.out.println(ticket.ticketNums);
    }
}

在这里插入图片描述

龟兔赛跑（模拟兔子休息），代码如下：
首先来个赛道（线程类）距离，然后兔子和乌龟是两个线程对象，要离终点越来越近判断比赛是否结束，打印出胜利者。故事中是乌龟赢的，兔子需要睡觉，所以我们来模拟兔子睡觉，乌龟赢得比赛

// 模拟龟兔赛跑,兔子睡眠
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) {
                    throw new RuntimeException(e);
                }
            }
            // 判断比赛是否结束
            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();
    }
}

在这里插入图片描述

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

（1）实现Callable接口，需要返回值类型
（2）重写call()方法,类似run()，有返回值，且返回类型于在接口实现限定类型相同。需要抛异常。
（3）实例化线程，创建目标对象。
（4）创建执行服务(开启服务，后面线程池中讲，new一个池子，里面有三个线程)
ExecutorService ser = Executors.newFixedThreadPool(3);
（5）提交执行，可以返回一个result结果。
Future<Boolean> result1 = ser.submit(t1);
（6）获取结果： boolean r1 = result1.get();
（7）关闭结果：ser.shutdown();

代码如下：

// 线程实现方式三: 实现 Callable 接口
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

// 1、实现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;
    }
    
    // 2、重写call()方法,类似run(),有返回值。线程执行体
    @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 {
        // 3、实例化线程，调用start()
        TestCallable t1 = new TestCallable("https://profile.csdnimg.cn/2/7/D/0_qq_46201146","1.jpg");
        TestCallable t2 = new TestCallable("https://profile.csdnimg.cn/2/7/D/0_qq_46201146","2.jpg");
        TestCallable t3 = new TestCallable("https://profile.csdnimg.cn/2/7/D/0_qq_46201146","3.jpg");
        // 4、创建执行服务(开启服务，后面线程池中讲，new一个池子，里面有三个线程)
        ExecutorService ser = Executors.newFixedThreadPool(3);

        // 5、提交执行,返回一个result结果，（上面call中写死了返回true）
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);

        // 6、获取结果
        boolean r1 = result1.get();
        boolean r2 = result2.get();
        boolean r3 = result3.get();
	    System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);
        // 7、关闭结果
        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方法出现异常");
        }
    }
}

结果：
在这里插入图片描述

使用Callable好处：
1、可以定义返回值。
2、可以抛出异常。

三、静态代理

例如婚庆公司代理你帮助你结婚，代码如下。

public class StaticProxy {
    public static void main(String[] args) {
        // 不使用代理对象的写法
        //You you = new You();
        //you.HappyMarry();

        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

// 真实对象与代理对象需要实现的统一接口
interface Marry{
    void HappyMarry();
}

// 真实对象
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();
    }

    private void after() {
        System.out.println("结婚之后收尾款");
    }

    private void before() {
        System.out.println("结婚之前布置现场");
    }
}

静态代理步骤总结
1、代理对象与真实对象都要实现同一接口，接口中有真实对象需要实现的方法名。
2、代理对象的建立：能通过接口放入真实对象，有具体的实现方法，代理真实对象实现。
优点：代理对象可以做真实对象做不了的，真实对象可以专注做自己的事情

注意静态代理中：

// 静态代理实现：
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.HappyMarry();
// 可以简化为：
new WeddingCompany(new You()).HappyMarry();

而线程实现中，利用Runnable接口实现：

// 实现Runnable接口的线程：
new Thread(new Runnable() {
    @Override
    public void run() {
          System.out.println("哈哈");
    }
}).start();

// 可以简化为
new Thread(()-> System.out.println("呵呵")).start();

两者类似：

new Thread(()-> System.out.println("呵呵")).start();
new WeddingCompany(new You()).HappyMarry();

其实在这里Thread类相当于代理对象，代理的是我们自己建立的实现Runnable的线程这个真实对象。（首先Thread类本身实现了Runnable接口，然后我们自己写的线程也实现了Runnable接口，然后Thread中对start具体描写了实现方法。）

四、Lambda 表达式

对于函数式接口，接口中只有一个类，类中只有一个方法。可去掉实例化new，去掉类名，去掉方法名，通过lambda表达式中直接写方法体来创建该接口的对象。
函数式接口：接口中仅有一个抽象方法。
简化过程：外部类——静态内部类——局部内部类——匿名内部类——Lambda简化
简化过程如下：

普通外部类：

// 推导Lambda表达式
public class TestLambda {
    public static void main(String[] args) {
        // 3、main中写实例对象。
        ILike like = new Like(); // 接口去new了一个实现类
        like.lambda();
    }
}

// 1、定义一个函数式接口
//  函数式接口：接口中仅有一个抽象方法。
//  对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
interface ILike{
    void lambda();
}

// 2、实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("普通外部类");
    }
}

静态内部类：

public class TestLambda {
    // 2、静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("静态内部类");
        }
    }

    public static void main(String[] args) {
        // 3、main中写实例对象。
        ILike like2 = new Like2();
        like2.lambda();
    }
}

// 1、定义一个函数式接口
interface ILike{
    void lambda();
}

局部内部类：

public class TestLambda {
    public static void main(String[] args) {
        // 2、局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("局部内部类");
            }
        }
        // 3、实例化
        ILike like3 = new Like3();
        like3.lambda();
    }
}

// 1、定义一个函数式接口
interface ILike{
    void lambda();
}

匿名内部类：

public class TestLambda {
    public static void main(String[] args) {
        // 2、匿名内部类直接实例化,去掉类的名称，必须借助接口或者父类
        ILike like4 = new ILike() {
            @Override
            public void lambda() {
                System.out.println("匿名内部类");
            }
        };
        like4.lambda();
    }
}

// 1、定义一个函数式接口
interface ILike{
    void lambda();
}

Lambda简化：

public class TestLambda {
    public static void main(String[] args) {
        // 2、去掉实例化,去掉类名，去掉方法名，直接写方法体
        ILike like5 = ()-> {
            System.out.println("Lambda表达式");
        };
        like5.lambda();
    }
}

// 1、定义一个函数式接口
interface ILike{
    void lambda();
}