线程相关的基础问题

最新推荐文章于 2023-07-22 11:40:16 发布
最新推荐文章于 2023-07-22 11:40:16 发布
阅读量535 收藏
点赞数
文章标签： 多线程 java 并发编程 thread 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38032942/article/details/111158569
版权

mark

本文主要讲述了进程和线程发展简史，对于JVM来讲的进程和线程又是什么，Thread的start()方法的原生调用发生了什么，从而理解start()方法和run()方法有什么不同，另外，还介绍了三种处理线程执行完成后的返回值的方法，其实FutureTask和线程池获取线程执行结束的返回值更加常用。另外，介绍了线程的六种状态，还有sleep和wait的区别，notify和notifyAll的区别，yield函数的作用，以及如何优雅的中断线程等问题。

关于进程和线程

  • 串行：初期的计算机只能串行执行任务，并且需要长时间等待用户输入
  • 批处理：预先将用户的指令集中成清单，批量串行处理用户指令，仍然无法并发执行
  • 进程：进程独占内存空间，保存各自运行状态，相互间不干扰且可以互相切换，为并发处理任务提供了可能
  • 线程：共享进程的内存资源，相互间切换更快速，支持更细粒度的任务控制，使进程内的子任务得以并发执行

进程是资源分配的最小单位，线程是CPU调度的最小单位
所有与进程相关的资源，都被记录在PCB中，进程是抢占处理机的调度单位；线程属于某个进程，共享其资源。线程只由堆栈寄存器、程序计数器和TCB组成。

线程不能看做独立应用，而进程可看做独立应用；进程有独立的地址空间，相互不影响，线程只是进程的不同执行路径；线程没有独立的地址空间，多进程的程序比多线程程序健壮。进程的切换比线程的切换开销大。

Java进程和线程的关系

Java对操作系统提供的功能进行封装，包括进程和线程。运行一个程序会产生一个进程，进程包含至少一个线程。每个进程对应一个JVM实例，多个线程共享JVM里的堆，Java采用单线程编程模型，程序会自动创建主线程，主线程可以创建子线程，原则上要后于子线程完成执行。

Thread中的start和run方法的区别

调用start()方法会创建一个新的子线程并启动，run()方法只是Thread的一个普通方法的调用。

public class ThreadTest {
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()); //main
        }).run(); 

        new Thread(()->{
            System.out.println(Thread.currentThread().getName()); //Thread-1
        }).start();
    }
}

start()点进去其实调用了start0()，而start0()是一个native方法，通过查看源码我们得知：

mark

其实调用start0()，在底层就是创建了一个线程并且让新的线程执行这个run方法

处理线程返回值

1、主线程等待法

这个方法比较简单，但是需要自己实现循环等待的逻辑：

package thread_study;

import java.util.concurrent.TimeUnit;

public class CycleWait implements Runnable {
    private String value;
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.value = "Hello Thread";
    }

    public static void main(String[] args) throws InterruptedException {
        CycleWait cycleWait = new CycleWait();
        Thread thread = new Thread(cycleWait);
        thread.start();
        while(cycleWait.value == null){
            TimeUnit.SECONDS.sleep(1);
        }
        System.out.println(cycleWait.value);
    }
}

2、使用Thread类的join()阻塞当前线程以等待子线程处理完毕，能够实现比我们自己循环等到更为精细的控制

package thread_study;

import java.util.concurrent.TimeUnit;

public class JoinWait implements Runnable {
    private String value;
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.value = "Hello Thread";
    }

    public static void main(String[] args) throws InterruptedException {
        JoinWait cycleWait = new JoinWait();
        Thread thread = new Thread(cycleWait);
        thread.start();
        thread.join();
        System.out.println(cycleWait.value);
    }
}

3、通过Callable接口实现：通过FutureTask Or 线程池获取
在JDK5之前，线程是没有返回值的，通常为了能够获取线程的返回值而颇费周折

1、通过FutureTask来完成

MyCallable.java

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        String value = "test";
        System.out.println("Ready to work");
        Thread.sleep(5000);
        System.out.println("Task done");
        return value;
    }
}

FutureTaskDemo.java

package thread_study;

import java.util.concurrent.FutureTask;

public class FutureTaskDemo {
    public static void main(String[] args) throws Exception {
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
        if(!futureTask.isDone()){
            System.out.println("Task is not finished, please wait!");
        }
        System.out.println("task return: " + futureTask.get());
    }
}

2、通过线程池来完成

还是依旧沿用MyCallable.java的代码，下面是ThreePoolDemo.java

package thread_study;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreePoolDemo {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        Future<String> futureTask = cachedThreadPool.submit(new MyCallable());
        if(!futureTask.isDone()){
            System.out.println("Task is not finished, please wait!");
        }
        try {
            System.out.println(futureTask.get());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            cachedThreadPool.shutdown();
        }
    }
}

线程的六种状态

  • 新建(New)：创建后尚未启动的线程的状态。
  • 运行(Runnable)：包含Running和Ready。
  • 无限期等待(Waiting)：不会被分配CPU执行时间，需要显式被唤醒
    • 没有设置Timeout参数的0bject.wait()方法。
    • 没有设置Timeout参数的Thread.join()方法。
    • LockSupport.park()方法。
  • 限期等待(Timed Waiting)：在一定时间后会由系统自动唤醒
    • Thread.sleep()方法。
    • 设置了Timeout参数的0bject.wait()方法。
    • 设置了Timeout参数的Thread.join()方法。
    • LockSupport.parkNanos()方法。
    • LockSupport.parkUntil()方法。
  • 阻塞(Blocked)：等待获取排它锁
  • 结束(Terminated)：已终止线程的状态，线程已经结束执行

那么等待和阻塞式什么关系呢？不都是停下来吗？其实两者都表示线程当前暂停执行的状态，而两者的区别，基本可以理解为：进入 waiting 状态是线程主动的，而进入 blocked 状态是被动的。更进一步的说，进入 blocked 状态是在同步(synchronized)代码之外，而进入 waiting 状态是在同步代码之内(然后马上退出同步)。

mark

sleep与wait

sleep和wait最主要的本质区别：Thread.sleep只会让出CPU，不会导致锁行为的改变；Object.wait不仅让出CPU，还会释放已经占有的同步资源锁。这也就是wait必须写在synchronized里面的原因，因为我只有获取到锁了，我才可能释放锁嘛。

notify与notifyAll

锁池EntryList：

假设线程A已经拥有了某个对象(不是类)的锁，而其它线程B、C想要调用这个对象的某个synchronized方法(或者块)，由于B、C线程在进入对象的synchronized方法(或者块)之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池

等待池WaitSet：

假设线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程，不会去竞争该对象的锁。

notify和notifyAll的区别：

  • notifyAll 会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会
  • notify只会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会。

yield的使用

public class YieldDemo {
    public static void main(String[] args) {
        Runnable runnable = () -> {
            for (int i = 0; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
                if(i == 5){
                    Thread.yield();
                }
            }
        };
        new Thread(runnable, "A").start();
        new Thread(runnable, "B").start();
    }
}

mark

从运行结果来看，yield会让当前线程放弃CPU执行权，让给其他的线程，但是这也是不可控的，调用此方法可能没效果，比如下面这样：

mark

需要注意的是yield不会使当前线程放弃持有的锁

优雅地中断线程 interrupt

已经被弃用的方法：stop()，这个方法不仅暴力，而且不安全， 可能使一些清理性的工作得不到完成。还可能对锁定的内容进行解锁，容易造成数据不同步的问题。

使用interrupt方法中断线程：调用interrupt()，即是通知线程应该中断了
①如果线程处于被阻塞状态，那么线程将立即退出被阻塞状态，并抛出一个InterruptedException异常。
②如果线程处于正常活动状态，那么会将该线程的中断标志设置为true。被设置中断标志的线程将继续正常运行,不受影响。

需要被调用的线程配合中断
①在正常运行任务时，经常检查本线程的中断标志位，如果被设置了中断标志就自行停止线程。
②如果线程处于正常活动状态，那么会将该线程的中断标志设置为true。被设置中断标志的线程将继续正常运行,不受影响。

package thread_study;

public class InterruptDemo {
    public static void main(String[] args) throws InterruptedException {
        Runnable task = ()->{
            int i = 0;
            try{
                while (!Thread.currentThread().isInterrupted()){
                    Thread.sleep(100);
                    i++;
                    System.out.println(Thread.currentThread().getName() + " (" +
                            Thread.currentThread().getState()+") loop " + i);
                }
            }catch (InterruptedException e){
                System.out.println(Thread.currentThread().getName() + " (" +
                        Thread.currentThread().getState()+") catch InterruptedException");
            }
        };

        Thread t1 = new Thread(task, "T1");
        System.out.println(t1.getName() + " (" + t1.getState() + ") is new.");

        t1.start();
        System.out.println(t1.getName() + " (" + t1.getState() + ") is started.");

        Thread.sleep(300);
        t1.interrupt();
        System.out.println(t1.getName() + " (" + t1.getState() + ") is interrupted.");

        Thread.sleep(300);
        System.out.println(t1.getName() + " (" + t1.getState() + ") is interrupted now.");
    }
}

mark
赏

谢谢你请我喝咖啡

支付宝
微信
「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#多线程基础知识汇总
08-18
主要介绍了C#多线程基础知识的相关资料，文中示例代码非常详细，帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Java多线程与并发
xiaoxin0630的博客
08-06 253
线程和进程的由来 串行：初期的计算机智能串行任务，需要长时间等待用户输入 批处理：预先将用户的指令集中成清单，批量串行处理用户指令，仍然无法并发执行 进程：进程读占内存空间，保存各自运行状态，互相间不干扰且互相切换，为并发处理任务提供了可能 线程：共享进程的内存资源，相互间切换更快捷，支持更细粒度的任务控制，使进程的子任务得以并发执行 进程是资源分配的最小单位，线程是CPU调度...
java多线程请求同一接口，模拟高并发
renkai721的专栏
10-15 8262
1、多线程工具TreadTestHttp package com; import java.util.concurrent.CountDownLatch; public class TreadTestHttp { public static void main(String[] args) throws InterruptedException { Runn...
java中两个线程互不干扰_java 多线程并发问题总结
weixin_39959126的博客
02-26 1503
java 多线程并发主要通过关键字synchronized实现Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。二、然而，同一对象中的线程...
狂神说多线程学习笔记
qq_40492693的博客
04-13 575
很多多线程都是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一行代码，因为切换的很快，所以就有同时执行的错局。
Java多线程机制中使用Runnable接口以及线程的常用方法//设备管理概述
想带狗熊去吹风
06-05 3006
使用Runnable接口 首先我们要知道使用Thread创建的子类可以添加新的成员变量,以及添加方法,使用线程中的功能,但是Java不允许将子类再往后继承,也就是不能再扩展后代. 那么这时候就出现了使用Runnable接口 如果用Thread类直接创建对象通常使用以下的构造方法 Thread(Runnable taget) // 这个构造方法中就是接口Runnable变量,也就是说可以是实现接口中的类,当实例线程调用 CET4P196 clear-cut madden blog paddy coinag
多线程基础总结.xmind
12-02
多线程基础理论, 多线程中常用API,多线程的实现方式, 线程池以及创建线程池相关API, 常见的设计模式等内容
说说C#多线程那些事-线程基础
12-22
这一次是系列文章，比较完整的展示与线程相关的基本概念。希望对初学者有所帮助。 　如果你是高手，请你别继续看，会浪费你宝贵的时间。 　一、基本概念 　什么是进程？ 　当一个程序开始运行时，它是一个进程，...
C++线程安全问题及解决方法，C++智能指针
11-30
内容概要：文章内容从原子性、可见性、有序性三个方面介绍C++线程安全问题的原因。通过原子操作、线程同步如互斥锁、读写锁、条件变量、信号量等方法解决C++线程安全问题。同时介绍了线程安全的单例，饿汉模式和懒汉...
C语言实现用户态线程库案例
12-26
（线程无非就是多了个抢占功能，由定时器触发，而非自愿让出运行权限） 因为我写的时候还没看到其他帖子，如果看到了，铁定会用最直观的ucontext接口写的（注意，在macOSX中已经标注为废除，头文件得换做sys/...
java中既要处理异步方法的返回值,又不影响主线程运行的流程
weixin_42591413的博客
12-21 1342
在Java中，如果希望在不影响主线程运行的情况下处理异步方法的返回值，则可以使用以下方法之一： 使用Executor和Future：可以使用Executor框架中的ExecutorService来创建一个线程池，然后使用submit方法提交一个异步任务，该方法将返回一个Future对象，可以使用get方法获取异步任务的返回值。例如： ExecutorService executor = Exe...
一文搞懂Java多线程，讲的很详细，收藏起来慢慢看
BASK2312的博客
07-06 3132
多线程是指在一个程序中同时执行多个线程，每个线程都有自己独立的执行路径。在多线程中，程序的执行可以同时进行多个任务，从而提高系统的资源利用率和响应性能。在传统的单线程编程模型中，程序按照顺序执行，一次只处理一个任务。这种方式在某些情况下可能会导致效率低下或者无法满足需求。而多线程通过将任务拆分为多个子任务，并且在不同的线程上同时执行，从而实现并发处理。
java多线程（超详细）
热门推荐
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程三种实现方法
Iurzy的博客
05-22 1571
多线程指单个进程（程序）可以并行执行多个线程，在同一时间执行多个线程以提高程序的处理能力和运行效率，并有利于更好地运用系统资源。提示：以下是本篇文章正文内容，下面案例可供参考。
一篇搞懂Java多线程（全网最细）
最新发布
让优秀成为一种习惯！
07-22 7354
Java多线程是一种强大而有趣的编程概念。它允许程序同时执行多个任务，就像一个宏大的交响乐团。每个线程都是一个独立的执行路径，有自己的速度和优先级。那么，我们期待多线程能给我们带来什么呢？
Java多线程详解，非常详细
Ifeng_iPhone的博客
09-17 435
进程就是电脑中一个运行的软件，一个正在运行的程序在做的一件事情就是一个进程。而进程又是由多个线程组成的。
编程必备：JAVA多线程详解
拾一二的博客
06-14 6954
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程（吐血超详细整理）
♚焕蓝·未来的博客
04-01 2029
这一篇看完多线程还不明白？我不信！
Java 实现多线程的四种方式 超详细
PassionAnytime的博客
08-03 1万+
java线程池
嵌入式线程相关的基础知识点，
05-19
以下是嵌入式线程相关的基础知识点： 1. 线程：线程是一组在同一进程中运行的执行流。在嵌入式系统中，线程可以轮流使用CPU时间片，从而实现并发处理。 2. 进程：进程是程序的执行实例。每个进程都有自己的地址...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值