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

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类测试代码

   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. 测试代码

   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.测试代码

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. 测试

   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时我们就必须禁止其他人进入这个区域，我们也会上锁（这就是我们要讲的多线程）