多线程

最新推荐文章于 2023-07-17 18:14:22 发布
最新推荐文章于 2023-07-17 18:14:22 发布
阅读量206 收藏
点赞数
分类专栏： Java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z981891/article/details/115057316
版权

进程与线程

  • 进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空 间。（现在一个应用程序（软件）中通常也有多个进程，但也可以把进程近似看成软件）（进程之间互不影响）
  • 线程是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程。
  • 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。
  • 每个线程都有自己的栈空间，共用一份堆内存。哪个线程调用的方法，此方法也会执行在此线程中。

线程调度

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

  • 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
  • CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。

同步与异步

同步：排队执行 , 效率低但是安全。
异步：同时执行 , 效率高但是数据不安全。

并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

实现多线程

继承Thread

这里的锄禾日当午，汗滴禾下土并发执行
在这里插入图片描述
在这里插入图片描述
匿名内部类可直接创建一个多线程分支
在这里插入图片描述
实现Runnable（比上面那个继承Thread在多线程中用的多）

在这里插入图片描述
在这里插入图片描述
实现Runnable与继承Thread对比

在这里插入图片描述

Thread类

  • Java虚拟机允许应用程序同时运行多个执行线程。
  • 每个线程都有优先权。 具有较高优先级的线程优先于具有较低优先级的线程执行。 每个线程可能也可能不会被标记为守护进程。 当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护进程线程。
  • start()方法：导致此线程执行，Java虚拟机调用此线程的run()方法。
  • run()方法：如果此线程是使用单独的Runnable运行对象构造的，则调用该Runnable对象的run()方法；否则，此方法不执行任何操作并返回。

设置和获取线程名称

此时输出了main和锄禾日当午，如果不给分支线程设置名称，系统会自动生成。
在这里插入图片描述

线程休眠sleep

该方法可以使当前正在执行的线程休眠（暂时停止执行）指定的毫秒数（或加上指定的纳秒数），具体取决于系统计时器和调度程序的精度和准确性。
在这里插入图片描述
使得该循环每隔一秒执行一次

线程阻塞

线程阻塞：又称为耗时操作，常指用时很久的操作。

线程中断

一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定。
线程中断需要添加一个中断标记即可。调用interrupt（）方法。
在这里插入图片描述
在这里插入图片描述

守护线程

  • 线程：分为守护线程和用户线程。
  • 用户线程：当一个进程不包含任何的存活的用户线程时，进行结束。
  • 守护线程：守护用户线程的，当最后一个用户线程死结束时，所有守护线程自动死亡。
    守护线程只需要在其启动前，对象调用设置setDaemon（true）方法即可。
    在这里插入图片描述

线程安全问题

解决方法1：同步代码块
在这里插入图片描述
在这里插入图片描述
解决方法2：同步方法
在这里插入图片描述
在这里插入图片描述
解决方法3：显式锁
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

公平锁与不公平锁

公平锁：排队使用。
不公平锁：抢占，上面三种解决方法都是不公平锁。
在这里插入图片描述

多线程通信问题

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo4  {

    /**
     * 多线程通信问题, 生产者与消费者问题
     * @param args
     */
    public static void main(String[] args) {
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }

    //厨师
    static class Cook extends Thread{
        private Food f;
        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for(int i=0;i<100;i++){
                if(i%2==0){
                    f.setNameAndSaste("老干妈小米粥","香辣味");
                }else{
                    f.setNameAndSaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务生
    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f) {
            this.f = f;
        }
        @Override
        public void run() {
            for(int i=0;i<100;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;

        //true 表示可以生产
        private boolean flag = true;

        public synchronized void setNameAndSaste(String name,String taste){
            if(flag) {
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            if(!flag) {
                System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

线程的六种状态

Enum Thread.State

线程状态。 线程可以处于以下状态之一：

  • NEW：尚未启动的线程处于此状态。
  • RUNNABLE：在Java虚拟机中执行的线程处于此状态。
  • BLOCKED：被阻塞等待监视器锁定的线程处于此状态。
  • WAITING：无限期等待另一个线程执行特定操作的线程处于此状态。
  • TIMED_WAITING：正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
  • TERMINATED：已退出的线程处于此状态。

线程在给定时间点只能处于一种状态。 这些状态是虚拟机状态，不反映任何操作系统线程状态。

带返回值的线程Callable（实现多线程的第三种方式，了解）

Interface Callable可以给main（主）线程一个返回值

Runnable 与 Callable

接口定义
//Callable接口
public interface Callable<V> {
 V call() throws Exception;
}
//Runnable接口
public interface Runnable {
 public abstract void run();
}

Callable使用步骤

 - 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
@Override
     public <T> call() throws Exception {
       return T;
     }
}
 - 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);
 - 通过Thread,启动线程
new Thread(future).start();

Runnable 与 Callable的相同点

  • 都是接口
  • 都可以编写多线程程序
  • 都采用Thread.start()启动线程

Runnable 与 Callable的不同点

  • Runnable没有返回值；Callable可以返回执行结果
  • Callable接口的call()允许抛出异常；Runnable的run()不能抛出

Callable获取返回值

Callalble接口支持返回执行结

线程池 Executors（后续使用也较少）

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

  • 降低资源消耗。
  • 提高响应速度。
  • 提高线程的可管理性。

Java中的四种线程池 . ExecutorService

  1. 缓存线程池
/**
  * 缓存线程池.
  * (长度无限制)
  * 执行流程:
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在,则创建线程 并放入线程池, 然后使用
  */
 ExecutorService service = Executors.newCachedThreadPool();
 //向线程池中 加入 新的任务
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
  1. 定长线程池
/**
  * 定长线程池.
  * (长度是指定的数值)
  * 执行流程:
3. 单线程线程池
4. 周期性任务定长线程池
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
  *   4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
  */
 ExecutorService service = Executors.newFixedThreadPool(2);
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
  1. 单线程线程池
效果与定长线程池 创建时传入数值1 效果一致.
 /**
  * 单线程线程池.
  * 执行流程:
  *   1. 判断线程池 的那个线程 是否空闲
  *   2. 空闲则使用
  *   4. 不空闲,则等待 池中的单个线程空闲后 使用
  */
 ExecutorService service = Executors.newSingleThreadExecutor();
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
 service.execute(new Runnable() {
   @Override
   public void run() {
     System.out.println("线程的名称:"+Thread.currentThread().getName());
   }
 });
  1. 周期性任务定长线程池
public static void main(String[] args) {
 /**
  * 周期任务 定长线程池.
  * 执行流程:
  *   1. 判断线程池是否存在空闲线程
  *   2. 存在则使用
  *   3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
  *   4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
  *
  * 周期性任务执行时:
  *   定时执行, 当某个时机触发时, 自动执行某任务 .
   */
 ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
 /**
  * 定时执行
  * 参数1.  runnable类型的任务
  * 参数2.  时长数字
  * 参数3.  时长数字的单位
  */
 /*service.schedule(new Runnable() {
   @Override
   public void run() {
     System.out.println("俩人相视一笑~ 嘿嘿嘿");
   }
 },5,TimeUnit.SECONDS);
 */
 /**
  * 周期执行
  * 参数1.  runnable类型的任务
  * 参数2.  时长数字(延迟执行的时长)
  * 参数3.  周期时长(每次执行的间隔时间)
  * 参数4.  时长数字的单位
  */
 service.scheduleAtFixedRate(new Runnable() {
   @Override
   public void run() {
     System.out.println("俩人相视一笑~ 嘿嘿嘿");
   }
 },5,2,TimeUnit.SECONDS);
}
跨越时空的记忆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c# window服务多线程实例
08-10
c# window服务多线程实例
安卓多线程
04-16
安卓多线程，安卓高级开发中，必备技能，项目开发中都要使用
编程必备：JAVA多线程详解
拾一二的博客
06-14 7780
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
超详细JAVA基础——多线程
热门推荐
qq_45781655的博客
04-12 2万+
学会Java多线程，只看一个博客就够了！
Java多线程学习（吐血超详细总结）
常思考->有目标->重实践->善反思
10-31 486
http://blog.csdn.net/evankaka/article/details/44153709          林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka         目录(?)[-] 一扩展javalangThread类二实现javalangRunnable接口三Thread和Runna
Java多线程的知识点
weixin_59796310的博客
05-28 4860
Java多线程的知识点
Java多线程学习（详细）
weixin_34370347的博客
06-07 66
一、进程与线程的区别 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位） 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位） 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 　　 多进程是指操作系...
stm32单片机多线程实例
12-03
stm32单片机多线程实例
Java多线程详解及示例
最新发布
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
arduino 多线程
09-29
arduino 多线程 内附说明，用于处理复杂的逻辑，多个线程同时使用
java多线程的学习
mmc_may的专栏
08-07 596
java多线程的实现的两种方法： 第一种方法：继承Thread类 package Thread; public class ThreadTest01 { public static void main(String[] args) { Thread01 th = new Thread01(); th.start(); // th.run();//属于方法的调
Java学习之多线程
yaopan1989的专栏
07-27 319
进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。  在java中要想实现多线程，有两种手段，一种是继承Thread类，另外一种是实现Runable接口。Thread类实际上也
Java-多线程技术学习线路
fdg277137601的专栏
09-03 408
前言今日整理多线程学习的路线，供想学习多线程的同学参考，可以沿着这个线路由浅入深对多线程技术做全面了解，篇幅较长，耐心点看完，上菜咯。
Java中线程的学习
qq_47387991的博客
05-26 228
一、线程的概述 1、线程： a.线程（Thread）是一个程序内部的一条执行路径 b.在启动程序执行后，main方法的执行就是一条单独的执行路径 c.程序中如果只有一条执行路径，那麽这个程序就是单线程的程序 2、多线程 是指从软硬件上实现多条执行流程技术 二、线程创建的三种方式 1、线程创建方式一 注意事项： 实现代码： package thread.app.d1_create; /** * 目标：多线程创建方式一：继承Thread类实现 */ public class
Java线程基础知识汇总（超详细版）
HSQdePYZ的博客
07-17 560
进程是指在计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。一个进程可以包含多个线程，每个线程都共享该进程的资源，如内存、文件和打开的网络连接等。每个进程都有自己的地址空间，即独立的内存区域。线程是进程内的执行单元，也是CPU的最小执行单元。一个进程可以包含多个线程，每个线程执行不同的任务。线程共享进程的资源，包括内存、文件和打开的网络连接等。线程之间通过共享内存进行通信，因此比进程间通信更高效。由于线程共享同一进程的地址空间，所以多线程之间的切换更快。
java多线程学习
weixin_43852750的博客
03-19 181
Java多线程学习（一）一.进程与线程二.并发与并行1、线程安全问题：2、共享内存不可见性问题三.java锁机制一.单例模式设计二.线程重入问题 进程与线程 并发与并行 守护线程与用户线程 Java锁机制 一.进程与线程 进程：是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。 线程：是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的 资源。 虽然系...
40个Java多线程问题总结（优就业JAVA分享）
HZC的专栏
12-22 865
前言 java多线程分类中写了21篇多线程的文章，21篇文章的内容很多，个人认为，学习，内容越多、越杂的知识，越需要进行深刻的总结，这样才能记忆深刻，将知识变成自己的。这篇文章主要是对多线程的问题进行总结的，因此罗列了40个多线程的问题。 这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作
JAVA线程学习
yxjh21312的博客
11-14 250
java线程基础知识点
[Linux/C++] 多线程实例：十字路口车辆调度
weixin_33910385的博客
11-26 1851
实例要求： 有两条道路双向两个车道，即每条路每个方向只有一个车道，两条道路十字交叉。假设车辆只能向前直行，而不允许转弯和后退。如果有4辆车几乎同时到达这个十字路口，如图（a）所示；相互交叉地停下来，如图（b），此时4辆车都将不能继续向前，这是一个典型的死锁问题。从操作系统原理的资源分配观点，如果4辆车都想驶过十字路口，那么对资源的要求如下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值