Java 多线程理解

旭夕氵

已于 2022-12-23 16:22:14 修改

阅读量97

点赞数

分类专栏： java多线程文章标签： java

于 2022-12-23 16:19:54 首次发布

本文链接：https://blog.csdn.net/weixin_51147295/article/details/128043492

版权

java多线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

在学习多线程时，发现其中一些相关概念用法不熟，在看了其他关于多线程的文章后写下本篇，适合多线程初学者。

多线程理解

基础知识

线程和进程

进程：是系统进行资源分配基本单位。通俗来说，就是计算机运行的一个实例，一个应用程序，可以是单个进程实现也可以是由多个进程的合作完成。

如图任务管理器显示的就是进程程序，每一个都有PID号，例如：QQ就是有两个进程完成。进程线程解释
线程：是cpu调度的基本单位，是进程的执行单元，共同享用进程的分配资源。进程不能单独生存，必须生存在进程下。

主要区别：
1.在资源、和地址空间上，进程之间是独立的。而线程之间同时享用同一个进程的地址空间和资源。（例如：进程是火车，线程是车厢）
2.一个线程崩溃后，不影响其他进程。而线程崩溃可能使整个进程崩溃

参考资料：
进程是资源分配的最小单位，线程是CPU调度的最小单位
(吐槽一下百度百科：把进程写成了调度的基本单位，害我想了几个小时)

什么时候CPU同时运行多进程？

并行和并发：
并行：在同一时间段，同时异步执行多个任务，
并发：串行执行多个任务，在某个时间段内执行单个任务。在不同的时段，对不同的任务进行处理，由于cpu速度过快，导致视觉上，感觉不到差别。
详细:并发和并行的区别

cpu分为多核和单核：
对于单核，其只能进行并发并不能进行并行；
在多核 CPU 中，并发和并行一般都会同时存在

进程的状态

（1）运行(running)态：进程占有处理器正在运行。
（2）就绪(ready)态：进程具备运行条件，等待系统分配处理器以便运行。
（3）等待(wait)态：又称为阻塞(blocked)态或睡眠(sleep)态，指进程不具备运行条件，正在等待某个事件的完成。

状态变化：
（1）运行态一一等待态：等待使用资源或某事件发生，如等待外设传输;等待人工干预。
（2）等待态一一就绪态：资源得到满足或某事件己经发生，如外设传输结束；人工干预完成。
（3）运行态一一就绪态：运行时间片到，或出现有更高优先权进程。
（4）就绪态一一运行态：CPU空闲时被调度选中一个就绪进程执行。

假如现在有进程A，B在单核cpu上运行
在单核CPU中，将cpu资源分配给进程A使用时，B的数据暂存在寄存器中（内存），此时B进行就绪状态，A处于进行状态。此时A需要用户输入数据，A让出处理器，让B进行任务（因为I/O时间于Cpu处理时间相比慢的多，所有让出cpu），此时A进行等待态（又称阻塞态或者睡眠态，进程的阻塞和唤醒显然是由进程切换来完成）

来源百度百科

线程的状态

cpu调度的基本单位是线程，划分时间片给予线程使用，对线程的切换称为上下文切换（在windows中，才有线程的概念，linux中并没有线程的概念。）
对于单核cpu，进行多线程并不一定节约时间，因为其进行上下文切换时,消耗更多的资源。
多核cpu，并不是同时对一个进程的线程进行处理，同时处理的线程可以是同一进程或多个进程的。

在这，主要讨论线程的阻塞状态、休眠状态、等待状态。

按照菜鸟教程的说法：阻塞状态、休眠状态、等待状态应该都是阻塞状态。
阻塞状态：是阻塞状态中的同步阻塞（个人理解：A、B线程争取同一个对象或者A持有对象，B想去获取对象，此时A拥有对象，B未成功获得对象，B此时被阻塞了，对于同一个对象需要同步更新，所以称为同步阻塞。）
等待状态：是阻塞状态中的等待阻塞，例如：在线程A运行的情况下，另一个更高优先级的线程B需要运行（CPU资源或者A持有的对象），此时A进入等待同时会释放资源（锁等），直到下次被其他线程唤醒
休眠状态：是阻塞状态中的其他阻塞，例如：线程A正在运行，但是需要其他线程处理的结果，此时线程进行休眠
一段时间，当时间一定，就再次运行。A不会释放资源。

在查阅许多博客后：在面试中，常会把他们分为阻塞状态、休眠状态、等待状态，而不是统称为阻塞状态。

生动的举例
 状态详解

线程的生命周期

寂静岭
详细情况请到菜鸟教程查看：
线程的详细状态

Java中多线程实现

通过实现 Runnable 接口；
通过继承 Thread 类本身；
通过 Callable 和 Future 创建线程。

前两种，不可获取线程结束后的返回值，使用Callable，Future 可获取线程结束后的返回值。其中，第二种方法是继承Thread实例（该实例其实是实现了 Runnable 接口的实例）

Thread

建立新的线程，执行各自的任务，不共享直接的变量

仅重写run()

public class Mythread extends Thread {
    private String Thread_name = "";

    Mythread(String name) {
        this.setName(name);
        System.out.println("creating Thread" + name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println("running Thread " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
    public static void main(String[] args) {

        Mythread a = new Mythread("1");
        a.start();
        Mythread b = new Mythread("2");
        b.start();
    }
}

Thread 运行在主线程之下

 // 打印主线程和子线程
public class Mythread extends Thread {
    Mythread(String name)
    {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            printThreadInfo();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
    private static void printThreadInfo()
    {
        System.out.println("runing Thread"+currentThread().getName());
    }

    public static void main(String[] args) throws InterruptedException {
        for(int i=0;i<4;i++)
        {
            printThreadInfo();
            Mythread a = new Mythread("1");
            a.start();
        }
    }
}

重写start()方法, 将当前类作为Task 传入新的Thread类

public class Mythread extends Thread {
    // 2. 重写start()等方法   继承线程后，在本类中使用Thread创建线程对象
    // 可重写Thread中其他方面
    private String Thread_name = "";
    private Thread a;
    Mythread(String name)
    {
       Thread_name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            printThreadInfo();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("Thread is over");
    }
    @Override
    public void start()
    {
        System.out.println("Thread is start");
        a = new Thread(this,this.Thread_name); // Thread(Runnable target, String name)
        a.start();
    }
    private static void printThreadInfo()
    {
        System.out.println("runing Thread"+currentThread().getName());
    }

    public static void main(String[] args) throws InterruptedException {
            printThreadInfo();
            Mythread a = new Mythread("1");
            a.start();
    }
}

runnable 实现

通过实现Runnable 接口，相当于实现多线程的任务，相比于继承与Thread方式，降低了耦合性

/**
 * @Author Duanping
 * @Date 2022/12/2 20:10
 */

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i =0;i<4;i++)
        {
            printThreadInfo();
        }
        System.out.println(Thread.currentThread().getName()+"Thread over");
    }
    private static void printThreadInfo()
    {
        System.out.println("runing Thread"+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyRunnable task=new MyRunnable();
        Thread a=new Thread(task);
        a.start();
        a=new Thread(task);
        a.start();
    }
}

thread 和 Runnable 方法的区别

java只能单继承，因此如果是采用继承Thread的方法，那么在以后进行代码重构的时候可能会遇到问题，因为你无法继承别的类了。

其次，如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

举例详情

以上方法有两个问题，第一个是无法抛出更多的异常，第二个是线程执行完毕之后并无法获得线程的返回值。

Callable和Future

Callable接口类似Runnable接口，但比Runnable接口更加强大，增加了异常和返回值

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

Future接口 Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException;
}

Future提供了三种功能：

1）判断任务是否完成；

2）能够中断任务；

3）能够获取任务执行结果。

因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。

FutureTask 实现 Runableture 接口，Runableture 接口继承 Runable,Future 接口，

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

所以，FutureTask 可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

FutureTask 实现多线程

创建一个类实现Callable接口，实现call方法。这个接口类似于Runnable接口，但比Runnable接口更加强大，增加了异常和返回值。

创建一个FutureTask，指定Callable对象，做为线程任务。

创建线程，指定线程任务。

启动线程

import java.util.concurrent.*;

/**
 * @Author Duanping
 * @Date 2022/12/22 17:10
 */
public class mycallable {
    public static void main(String[] args) {

        FutureTask<Integer> task = new FutureTask<>(new Task()); // 任务交给FutureTask 便于任务控制
        new Thread(task).start(); //使用Thread 启动任务
        System.out.println("主线程在执行任务");
        try {
            System.out.println("task运行结果"+task.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("所有任务执行完毕");
    }
}
class Task implements Callable<Integer>{   //Callable 实现 任务的设置 类似于Runnable 中的Run
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

使用线程池实现多线程

线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建，不需要的时候销毁，是非常浪费资源的。那么我们就可以使用缓存的策略，也就是使用线程池。

使用线程池，代替使用Thread类使线程任务开始

线程池原理

使用线程池，并用Future 获得任务结果

public class Pool {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task1 task1 = new Task1();
        Future<Integer> result = executor.submit(task1);  // result 获取任务结果
        executor.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        System.out.println("主线程在执行任务");

        try {
            System.out.println("task运行结果"+result.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕");
    }
}
class Task1 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

ExecutorService 中submit 还支持Runnale

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

一般情况下我们使用第一个submit方法和第三个submit方法，第二个submit方法很少使用。

总结

java多线程，基于Thread类运行。Runnable和Callable都是为了创建任务，其中继承Thread类实现多线程也是实现了 Runnable 接口的一个实例。Future接口以及其衍生任务的执行结果进行取消、查询是否完成、获取结果。
故：

Thread和线程池，启动多线程
Runnable和Callable创建任务
Future接口以及其衍生控制获得任务结果的过程

旭夕氵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java 多线程理解

java多线程，基于Thread类运行。Runnable和Callable都是为了创建任务，其中继承Thread类实现多线程也是实现了 Runnable 接口的一个实例。Future接口以及其衍生任务的执行结果进行取消、查询是否完成、获取结果。Thread和线程池，启动多线程Runnable和Callable创建任务Future接口以及其衍生控制获得任务结果的过程线程的详细状态。
复制链接

扫一扫