java多线程的3种实现方式

Wesley13
• 阅读 591

多线程相关的问题

1.什么是进程?

​ 正在执行的程序

2.什么是线程?

​ 进程的子单位,一个能够完成独立功能的执行路径

3.为什么需要开启多线程?

  • 当执行某些耗时操作的任务的时候需要开启多线程,防止线程阻塞
  • 能够让两个任务看起来像是在同时执行
  • 提高CPU的使用率,进而提高进程和内存的使用率

4.为什么开启多线程会同时执行?

​ 因为CPU切换执行的速度太快了,肉眼无法差距

5.开启多线程是不是越多越好,提高了效率还是降低了效率?

​ 不是,线程越多,效率越慢,但是太少,浪费CPU资源,所以,合理利用CPU

6.并发和并行的区别

  • 并发 --> 在同一个时间段下同时执行多个线程,看起来像同时执行
  • 并行 --> 在同一个时间刻度下(不能够在分割的时间单位)执行多个线程,本质就上就是同时执行

CPU在某一个最小的时间刻度单位下,执行的是一个进程的一个线程的一个不可再分割的原子性语句

线程开启方式

Java提供了三种创建线程方法:

​ 1.继承Thread类的方式

​ 2.实现Runnable的方式

​ 3.通过 Callable 和 Future 创建线程。

方式一:继承Thread类

​ 1.自定义类MyThread继承Thread类。3 ​ 2.MyThread类里面重写run()方法。 ​ 3.创建线程对象。 ​ 4.启动线程。 注意: ​ 1、启动线程使用的是start()方法而不是run()方法 ​ 2、线程能不能多次启动

线程对象调用 run方法和调用start方法区别?

  • 线程对象调用run方法不开启线程。仅是对象调用方法。
  • 线程对象调用start开启线程,并让jvm调用run方法在开启的线程中执行

代码演示使用方式一开启线程

// 方式二:实现Runnable接口
class CalculateRunnable implements Runnable {
    private int m;
    private int n;
    public CalculateRunnable(int m, int n) {
        super();
        this.m = m;
        this.n = n;
    }
    public CalculateRunnable() {
        super();
    }
    @Override
    public void run() {
        int sum = 0;
        for (int i = m; i <= n; i++) {
            sum += i;
            System.out.println("CalculateRunnable子线程: " + i);
        }
        System.out.println(m + "~" + n + "的和: " + sum);
    }
} 

方式二:实现Runnable接口

​ 1.自定义类MyRunnable实现Runnable接口 ​ 2.重写run()方法 ​ 3.创建MyRunnable类的对象 ​ 4.创建Thread类的对象,并把步骤3创建的对象作为构造参数传递 ​ 5.启动线程

实现接口方式的好处 可以避免由于Java单继承带来的局限性。 适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码,数据有效分离,较好的体现了面向对象的设计思想。

代码演示方式二开启线程

// 方式一:继承Thread类
class CopyThread extends Thread {
    private File srcFile;
    private File descFile;
    
    public CopyThread() {
        super();
    }

    public CopyThread(File srcFile, File descFile) {
        super();
        this.srcFile = srcFile;
        this.descFile = descFile;
    }

    @Override
    public void run() {
        // main方法怎么写,这里就怎么写
        copy(srcFile, descFile);
    }

    public void copy(File srcFile, File descFile) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(descFile))){
            byte[] bys = new byte[1024];
            int len = 0;
            while ((len = bis.read(bys)) != -1) {
                bos.write(bys, 0, len);
                bos.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
主方法调用
    public static void main(String[] args) {
        CopyThread ct = new CopyThread(new File("Test.java"), new File("Test.txt"));
        CalculateRunnable cr = new CalculateRunnable(1, 200);
        Thread t = new Thread(cr);
        ct.start();
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main线程: " + i);
        }
    }

方式三: Callable 和 Future 创建线程。

  • 创建 Callable 接口的实现类,并实现 call() 方法,该 call() 方法将作为线程执行体,并且有返回值。
  • 创建 Callable 实现类的实例,使用 FutureTask 类来包装 Callable 对象,该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
  • 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
  • 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

继承Thread和实现Runnable的方式的特点:

​ 1.没有返回结果

​ 2.没有异常

Callable和Runnable的区别:

​ 1.Runnable无返回值,没有异常抛出的

​ 2.Callable可以在启动线程中获取返回值, 以及接受子线程的异常

线程间的数据传递:线程通信

​ A线程中开启了B线程

​ A --> B 通过构造方法

​ B --> A 通过Callable方式

public class CallableDemo{
    public static void main(String[] args) {
        FutureTask<Integer> task = new FutureTask<>(new CalculateCallable(0,100));
        Thread t = new Thread(task);
        t.start();
        
        try {
            Integer i = task.get();
            System.out.println("计算结果: " + i);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        System.out.println("程序结束");
    }
}


class CalculateCallable implements Callable<Integer> {
    
    private int m;
    private int n;
    
    public CalculateCallable() {
        super();
    }
    
    public CalculateCallable(int m, int n) {
        super();
        this.m = m;
        this.n = n;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = m; i <= n; i++) {
            System.out.println("子线程: " + i);
            sum += i;
            throw new NullPointerException("空指针异常!");
        }
        return sum;
    }
}
点赞
收藏
评论区
推荐文章
blmius blmius
3年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时,报错:原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等,这样可以更容易地在不同的环境中使用MySQL。全局s
待兔 待兔
3个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
Wesley13 Wesley13
3年前
java多线程常见问题
Java多线程是什么Java提供的并发(同时、独立)处理多个任务的机制。多个线程共存于同一JVM进程里面,所以共用相同的内存空间,较之多进程,多线程之间的通信更轻量级。依我的理解,Java多线程完全就是为了提高CPU的利用率。Java的线程有4种状态,新建(New)、运行(Runnable)、阻塞(Blocked)、结束(Dead),关键就在于阻塞(Bl
Wesley13 Wesley13
3年前
java多线程面试题_线程并发面试题
1、什么是线程?线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。程序员可以通过它进行多处理器编程,你可以使用多线程对运算密集型任务提速。比如,如果一个线程完成一个任务要100毫秒,那么用十个线程完成改任务只需10毫秒。2、线程和进程有什么区别?线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不
Wesley13 Wesley13
3年前
Java高级教程02
\TOC\1.Java线程1.1.多线程和多进程多进程:操作系统能够同时进行多个任务:每个app(word,播放器,浏览器)可以同时运行多线程:同一应用程序中哟多个顺序流同时执行线程是进程中的一部分1.2.线程的执行过程:!(
Wesley13 Wesley13
3年前
Java总结:Java多线程
多线程作为Java中很重要的一个知识点,在此还是有必要总结一下的。Java给多线程编程提供了内置的支持。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。多线程是多任务的一种特别的形式,但多线程使用了更小的资源开销。这里定义和线程相关的另一个术语进程:一个进程包括由操作系统分配的内存空间,
Wesley13 Wesley13
3年前
Java面试官都爱问的多线程和并发面试题汇总,多刷一题,多份安心!
Java多线程面试问题1、进程和线程之间有什么不同?一个进程是一个独立(selfcontained)的运行环境,它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进
Wesley13 Wesley13
3年前
Java oop 第13章_多线程
第13章\_多线程一、多线程相关的概念:1.程序:由某种编程语言开发可执行某些功能的代码组合,它是静态的概念。2.进程:当程序被执行时的过程可以理解为讲程序从外存调入内存的过程,会为每一个程序至少开辟一个独立的内存空间,程序在内存中的状态称为一个进程。3.线程:一个进程至少会有一个独
Wesley13 Wesley13
3年前
Java线程与多线程
1线程与多线程1.1线程是什么?线程(Thread)是一个对象(Object)。用来干什么?Java线程(也称JVM线程)是Java进程内允许多个同时进行的任务。该进程内并发的任务成为线程(Thread),一个进程里至少一个线程。Java程序采用多线程方式来支持大量的并发请求处理,程序如果在
Wesley13 Wesley13
3年前
Java面试问题——线程全面详解总结
一、多线程是什么?为什么要用多线程?介绍多线程之前要介绍线程,介绍线程则离不开进程。首先进程 :是一个正在执行中的程序,每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元;线程:就是进程中的一个独立控制单元,线程在控制着进程的执行。一个进程中至少有一个进程。多线程:一个进程中不只有一