多线程

最新推荐文章于 2024-12-01 23:53:39 发布
最新推荐文章于 2024-12-01 23:53:39 发布
阅读量91 收藏
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/houhaopi8740/article/details/116903896
版权

线程与进程

进程

  • 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

  • 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程至少有一个线程
  • 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

区别：

  • 线程：

    1）进程中负责程序执行的执行单元

    2）依靠程序执行的顺序控制流，只能使用程序的资源和环境，共享进程的全部资源

    3）有自己的堆栈和局部变量，没有单独的地址空间

    4）CPU调度和分派的基本单位，持有程序计数器，寄存器，堆栈

    进程：

    1）系统资源分配和调度的独立单位

    2）至少包含一个线程

    3）拥有自己的资源

同步与异步&并发与并行

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

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

继承Thread

public class MyThread extends Thread{
//run方法就是要线程要执行的任务方法
    @Override
    public void run(){
    //这里的代码就是一条新的执行路径
    //这个执行路径的处罚方式，不是调用run方法，而是通过Thread对象的start()来启动任务
    System.out.println();
    }
}

实现Runnable

步骤：

//1.创建一个任务对象
MyRunnable r=new MyRunnable();
//2.创建一个线程，并为其分配一个任务
Thread t=new Thread(r);
//3.执行这个线程
t.start();

与继承Thread相比的好处：

  1. 通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况
  2. 可以避免单继承所带来的局限性
  3. 任务与线程本身的分离的，提高了程序的健壮性
  4. 后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

Thread类

设置和获取线程名称

Thread.currentThread().getName();

线程休眠sleep

Thread.sleep(1000);//1000为毫秒

线程的中断

一个线程是一个独立的执行路径，它是否应该结束应该由其自身决定

Thread t1=new Thread();
t1.interrupt();
//catch块中决定是否死亡

守护线程

线程：分为守护线程和用户线程
用户线程：当一个进程不包含任何的存活的用户线程结束时，进行结束。
守护线程：守护用户线程的，当最后一个用户线程结束时，所有的守护线程自动死亡

Thread t1=new Thread();
t1.setDaemon(true);

线程安全问题

解决方案1.同步代码块

//线程同步：synchronized
//格式：synchronized（锁对象）｛
//           ｝
Object o=new Object();
synchronized(o){
   XXXXX;
}

解决方案2.同步方法
synchronized修饰方法

解决方案3.显示锁Lock

Lock lock=new ReentranLock();
lock.lock();
//结束之后放开锁
//lock.unlock;

公平锁与非公平锁

//显示锁：fair参数为true表示公平锁
Lock l=new ReentrantLock(true);

线程死锁

在这里插入代码片

线程的六种状态

在这里插入图片描述
1. 初始状态(NEW)

  • 实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

2.1. 就绪状态(RUNNABLE之READY)

  • 就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。
  • 调用线程的start()方法，此线程进入就绪状态。
  • 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
  • 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
  • 锁池里的线程拿到对象锁后，进入就绪状态。

2.2. 运行中状态(RUNNABLE之RUNNING)

  • 线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式。

3. 阻塞状态(BLOCKED)

  • 阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

4. 等待(WAITING)

  • 处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

5. 超时等待(TIMED_WAITING)

  • 处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

6. 终止状态(TERMINATED)

  • 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
    在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

带返回值的线程Callable

Callable使用步骤

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

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

Runnable 与 Callable

接口定义

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

Runnable 与 Callable的相同点

  • 都是接口

  • 都可以编写多线程程序

  • 都采用Thread.start()启动线程

Runnable 与 Callable的不同点

  • Runnable没有返回值；Callable可以返回执行结果

  • Callable接口的call()允许抛出异常；Runnable的run()不能抛出

线程池概述

线程池Executors

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

好处

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

缓存线程池

/*** 缓存线程池. 
* (长度无限制) * 
* 执行流程: 
* * 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. 判断线程池是否存在空闲线程 
* 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. 判断线程池 的那个线程 是否空闲 
 * 2. 空闲则使用
 * 3. 不空闲,则等待 池中的单个线程空闲后 使用 
 */
 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. 判断线程池是否存在空闲线程 
* 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);

Lambda表达式

无参

new Thread(() -> {
				System.out.println("锄禾日当午");
		}).start();

带参

new Thread((String name) -> {
				System.out.println("锄禾日当午"+name);
		}).start();
python3多线程实战（python3经典编程案例）
数据知道的博客
08-25 8万+
总结： python多线程适用在I/O密集型的任务中。对于I/O密集型任务来说，较少的时间用在cpu计算上，较多的时间用在I/O上，如文件读写，web请求，数据库请求等； 对于计算密集型任务，应该使用多进程。 一. 多线程任务对比 线程也是轻量级进程，是操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程的实际运作单位 一个线程可以创建和撤销另一个线程，同一进程的多个线程之间可以并发执行。 线程有就绪，阻塞，运行3中基本状态。 计算密集型任务-多进程 from multiprocessing i
线程状态图
03-15
此图展示了线程状态变化，可以说是线程的生命周期，有助于对多线程理解
Java线程的6种状态及切换(透彻讲解)
热门推荐
潘建南的博客
12-24 26万+
Java中线程的状态分为6种。 1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。 2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状...
Java多线程:线程状态
清风小阁
03-04 4万+
一. 线程状态类型 1. 新建状态（New）：新创建了一个线程对象。 2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。 4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂
Java多线程
ldsfsm的博客
05-08 229
了解进程和线程: 几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程（Process）。当一个程序 进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是 系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。 独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有 的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空 间。 动态性：进程与程序的区别在于，程序只是一个静态的指
Java中线程的状态
m0_72466001的博客
10-08 427
Java中线程的状态
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
最新发布
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Java线程状态
枣面包的博客
05-31 529
Java的线程状态定义在Thread.State枚举里，源码如下： public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } 源码显示总共有六种线程状态： 状态 解释 NEW 新建状态 RUNNABLE 可运行状...
Java 线程的状态
柚咖小窝
03-24 504
线程状态   Java 中我们说的线程状态在代码中的实现其实就是一个变量的值，这个变量是 Thread 类中的变量——threadStatus。 /* Java thread status for tools, * initialized to indicate thread 'not yet started' */ private volatile int threadStatus = 0;   因为 threadStatus 是个整型数据，不形象，因此 Thread 将 threadStatus.
JAVA之线程状态
a279534269的博客
02-28 163
上次进行了JAVA程序运行的原理分析，通过【JVM指令代码表】可以一步步，了解栈本地变量表和操作数栈，在栈线程中程序是如何运行的，这次咱们一起梳理下JAVA的线程状态。 （一）线程几种状态 线程的状态在java中有明确的定义，在java.lang.Thread.State中有6种。 ① New 线程被创建，未执行和运行的时候 ② Runnable 不代表线程在跑，两种：被cpu执行的线程，随时可以被cpu执行的状态。 ③ Blocked 线程阻塞，处于synchronized同步代码块或方法中被阻塞。 ④
java线程状态
inspiredbh的博客
02-09 429
线程一般具有五中状态：新建，就绪，运行，阻塞，死亡 新建状态(new)： 在程序中创建了一个线程对象之后，线程便处于新建状态，已经分配了相应内存空间和其他资源，但是处于不可运行的状态 就绪状态(Runnable)： 线程对象调用了start()方法后，便启动了线程，线程启动后由创建状态转为就绪状态，j就绪状态相当于等待执行，进入线程队列排队，等待cpu执行，已经具备了执行资格 运行sta
如何在 Java 中正确使用 wait, notify 和 notifyAll
极北三少
08-05 2812
wait, notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。 在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子，如果你的Java程序中有两个线程——即生产者和消费者，那么生产者可以通知消费者，让消费者开始消耗数据，因为队列缓冲区中有内
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值