Java-Java基础学习（3）-多线程（1）

JasonHuan11232024-03-21 16:40

Java-Java基础学习（4）-多线程（1）

3.多线程

在Java中，多线程主要的实现方式有四种：继承Thread类、实现Runnable接口、实现Callable接口经过FutureTask包装器来建立Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。

3.1. 四种创建方式

  • Thread class ==> 继承Thread类
  • Runnable接口 ==> 实现Runnable接口
  • Callable接口 ==> 实现Callable接口
  • 使用ExecutorService、Callable、Future实现有返回结果的线程（线程池方式）

3.2. Thread类

  1. 步骤

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

  2. Thread类测试代码

    java 复制代码 
    package com.hzs.basic.multithread;

/**
 * @author Cherist Huan
 * @version 1.0
 */

// 创建线程一：继承Thread类；实现run方法；start开启
public class TestThread01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("子线程体："+i);
        }
    }

    public static void main(String[] args) {
        TestThread01 testThread01 = new TestThread01();
        testThread01.start();
        //testThread01.run();

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

    }

    输出：随机交替出现

    主线程main：101

    主线程main：102

    子线程体：0

    ...

  3. 注意

    • 线程start开启，不一定立即执行，由CPU调度执行

3.3. Runnable接口

  1. 步骤

    • 实现Runnabel接口，重写run方法；
    • new一个对象；
    • 丢入Thread对象中

  2. 测试代码

    java 复制代码 
    package com.hzs.basic.multithread;

/**
 * @author Cherist Huan
 * @version 1.0
 */

// 创建线程方式二：实现Runnable接口，重写run方法；new一个对象；丢入 Thread对象中；
public class TestRunnable01 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("子线程体："+i);
        }
    }

    public static void main(String[] args) {
        TestRunnable01 testRunnable01 = new TestRunnable01();
        new Thread(testRunnable01).start();

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

结果：同上

3.4. Callable接口

  1. 步骤

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

  2. 测试代码

    import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;

    public class CreateThreadDemo3 {

     public static void main(String[] args) throws Exception {
     // 建立线程任务，lambada方式实现接口并实现call方法
     Callable<Integer> callable = () -> {
         System.out.println("线程任务开始执行了...");
         Thread.sleep(2000);
         return 1;
     };

     // 将任务封装为FutureTask
     FutureTask<Integer> task = new FutureTask<>(callable);

     // 开启线程，执行线程任务
     new Thread(task).start();

     // ====================
     // 这里是在线程启动以后，线程结果返回以前
     System.out.println("线程启动以后，线程结果返回以前...");
     // ====================

     // 随心所欲完毕以后，拿到线程的执行结果
     Integer result = task.get();
     System.out.println("主线程中拿到异步任务执行的结果为：" + result);

 }

    }

输出：

线程启动以后，线程结果返回以前...
线程任务开始执行了...
主线程中拿到异步任务执行的结果为：1

3.5 使用ExecutorService、Callable、Future实现有返回结果的线程（线程池方式）

  1. ExecutorService、Callable、Future三个接口都是属于Executor框架。可返回值的任务必须实现Callable接口。经过ExecutorService执行Callable任务后，能够获取到一个Future的对象，在该对象上调用get()就能够获取到Callable任务返回的结果了。

注意：Future的get方法是阻塞的，即：线程无返回结果，get方法会一直等待。

2.测试代码

java 复制代码 
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CreateThreadDemo4 {
    
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("---- 主程序开始运行 ----");
        Date startTime = new Date();
        
        int taskSize = 5;
        // 建立一个线程池,Executors提供了建立各类类型线程池的方法，具体详情请自行查阅
        ExecutorService executorService = Executors.newFixedThreadPool(taskSize);
        
        // 建立多个有返回值的任务
        List<Future> futureList = new ArrayList<Future>();
        for (int i = 0; i < taskSize; i++) {
            Callable callable = new MyCallable(i);
            // 执行任务并获取Future对象
            Future future = executorService.submit(callable);
            futureList.add(future);
        }
        
        // 关闭线程池
        executorService.shutdown();

        // 获取全部并发任务的运行结果
        for (Future future : futureList) {
            // 从Future对象上获取任务的返回值，并输出到控制台
            System.out.println(">>> " + future.get().toString());
        }

        Date endTime = new Date();
        System.out.println("---- 主程序结束运行 ----，程序运行耗时【" + (endTime.getTime() - startTime.getTime()) + "毫秒】");
    }
}

class MyCallable implements Callable<Object> {
    private int taskNum;

    MyCallable(int taskNum) {
        this.taskNum = taskNum;
    }

    public Object call() throws Exception {
        System.out.println(">>> " + taskNum + " 线程任务启动");
        Date startTime = new Date();
        Thread.sleep(1000);
        Date endTime = new Date();
        long time = endTime.getTime() - startTime.getTime();
        System.out.println(">>> " + taskNum + " 线程任务终止");
        return taskNum + "线程任务返回运行结果, 当前任务耗时【" + time + "毫秒】";
    }
}

输出结果：

---- 主程序开始运行 ----
>>> 0 线程任务启动
>>> 1 线程任务启动
>>> 2 线程任务启动
>>> 3 线程任务启动
>>> 4 线程任务启动
>>> 0 线程任务终止
>>> 1 线程任务终止
>>> 0线程任务返回运行结果, 当前任务耗时【1001毫秒】
>>> 1线程任务返回运行结果, 当前任务耗时【1001毫秒】
>>> 4 线程任务终止
>>> 3 线程任务终止
>>> 2 线程任务终止
>>> 2线程任务返回运行结果, 当前任务耗时【1001毫秒】
>>> 3线程任务返回运行结果, 当前任务耗时【1001毫秒】
>>> 4线程任务返回运行结果, 当前任务耗时【1001毫秒】
---- 主程序结束运行 ----，程序运行耗时【1009毫秒】

3.6. 静态代理

  1. 静态代理：代理对象和真实对象都要实现同一个接口；

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

  3. 测试

    java 复制代码 
    package com.hzs.basic.multithread;
/**
 * @author Cherist Huan
 * @version 1.0
 */

// 静态代理：代理对象和真实对象都要实现同一个接口
// 好处：代理对象可以做很多真实对象做不了的事情；真实对象专注做自己的事情
public class StaticProxy {
    public static void main(String[] args) {

        new ProxyCompany(new You()).HappyMerry();
        new Thread(()-> System.out.println("I love you")).start();
    }

}

interface  Merry{
    void  HappyMerry();
}

class  You implements  Merry{
    @Override
    public void HappyMerry() {
        System.out.println("You Merry");
    }
}

class ProxyCompany implements Merry{

    private Merry target;

    public  ProxyCompany(Merry target){
        this.target = target;
    }

    @Override
    public void HappyMerry() {
        before();
        //System.out.println("ProxyCompany 代理结婚，结婚对象是You");
        this.target.HappyMerry();
        after();
    }

    public void before()
    {
        System.out.println("Before");
    }

    public  void after(){
        System.out.println("After");
    }
}

输出：
Before
You Merry
After
I love you

  4. 静态代理应用场景

​ Java静态代理的应用场景主要出现在需要对目标对象的功能进行扩展，但又不想直接修改目标对象的源代码时。

​ 静态代理要求目标对象和代理对象实现同一个业务接口，这样代理对象就可以作为目标对象的一个代理，在不改变目标对象源代码的情况下，通过代理对象添加一些额外的操作，以实现特定的功能。这种代理方式在编译期间就已经确定了代理类的代码，因此编写简单，易于理解和维护。

​ 然而，静态代理的一个主要缺陷是，如果需要代理多个类，那么就需要针对每个实际对象编写一个代理类，这会导致代理类的数量增加，并且在代理类和被代理类的方法增加时需要手动维护代理类的代码，因此代理过程可能会变得复杂且难以管理。

​ 尽管如此，静态代理在某些特定场景下仍然非常有用。例如，当需要对某个对象的访问进行控制，或者需要在调用对象的方法前后添加一些额外的逻辑（如日志记录、性能监控、事务管理等）时，可以使用静态代理。在这些场景下，静态代理可以通过在代理对象中添加额外的逻辑，实现对目标对象功能的增强和扩展，同时保持目标对象代码的稳定性和不变性。

​ 请注意，虽然静态代理有其特定的应用场景，但在需要代理的类数量较多或代理逻辑较复杂的情况下，动态代理可能是一个更好的选择。动态代理可以在运行时动态生成代理类，使得客户端代码更加简洁和易于维护。

3.7 线程和进程区别总结

首先看一下线程与进程的区别总结和理解（在java面试或者android面试中经常会问到这些问题，搜集整理供学习使用）：

1.CPU负责整个计算机的处理工作（它就像一个工厂）；

2.一个CPU一次只能运行一个任务（当我们这个工厂的电或者原料不充足时，只能供一厂房运行），而进程代表该工厂的一个厂房，代表CPU所能运行的单个任务（CPU在任何时刻都只运行一个进程）；

3.一个进程包含很多线程 （就像一个车间里有很多工人一样，而进程就是车间的工人）；

4.线程共享车间的空间（就像我们在工作时，在这个车间我们可以来回走动，也可以更换我们的工作地点）；

5.而在我们使用某些存储空间时，其他工人就得等我们使用完（比如我们在卫生间时，其他人必须等我们使用完他们才可以用）

6.为了防止其他人使用我们一般都会上锁（在火车上我们一般都会上锁，使用完后会给别人一个信号灯提示），这就是"锁"，防止多个线程公用同一个存储区域

7.有的房间也可以让多个人同时操作假如人数为M，但是当人数大于M时我们就必须禁止其他人进入这个区域，我们也会上锁（这就是我们要讲的多线程）

相关推荐
生命几十年3万天1 分钟前
java的threadlocal为何内存泄漏
java
caridle13 分钟前
教程：使用 InterBase Express 访问数据库（五）：TIBTransaction
java·数据库·express
^velpro^18 分钟前
数据库连接池的创建
java·开发语言·数据库
苹果醋322 分钟前
Java8-＞Java19的初步探索
java·运维·spring boot·mysql·nginx
秋の花26 分钟前
【JAVA基础】Java集合基础
java·开发语言·windows
小松学前端29 分钟前
第六章 7.0 LinkList
java·开发语言·网络
Wx-bishekaifayuan36 分钟前
django电商易购系统-计算机设计毕业源码61059
java·spring boot·spring·spring cloud·django·sqlite·guava
customer0840 分钟前
【开源免费】基于SpringBoot+Vue.JS周边产品销售网站（JAVA毕业设计）
java·vue.js·spring boot·后端·spring cloud·java-ee·开源
全栈开发圈42 分钟前
新书速览|Java网络爬虫精解与实践
java·开发语言·爬虫
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解