线程（线程基本概念、java实现多线程、使用多线程、线程的生命周期、线程同步、线程死锁）

news2024/10/5 0:41:50

（一）线程基本概念


一、 程序, 进程, 线程的概念


程序: 使用某种语言编写一组指令(代码)的集合,静态的

进程: 运行的程序,表示程序一次完整的执行, 当程序运行完成, 进程也就结束了

个人电脑: CPU 单个, 双核, CPU的时间分片, 抢占式

每个独立执行的程序称为进程

每个进程都有自己独立的内存空间, 进制之间的通信很困难

在操作系统中进程是进行系统资源分配、调度和管理的最小单位，进程在执行过程中拥有独立的内存单元。比如：Windows采用进程作为最小隔离单位，每个进程都有自己的数据段、代码段，并且与别的进程没有任何关系。因此进程间进行信息交互比较麻烦

线程: 一个进程中,可以同时有多条执行链路, 这些执行链路称为线程, 线程是CPU的调度与分配最小单位, 同一个进程多个线程共享这个进程的内存资源: JVM内存模型

二、进程与线程区别:

进程包含线程, 一个进程包含多个线程, 一个进程最小必须包含一个线程(主线程,main线程), 运行main()方法的时候, 创建了一个main线程

一个进程死亡了, 这个进程中所有的线程死亡

线程销毁，进程未必会关闭

并行: 多CPU执行各种不同任务,

并发: 一个CPU执行不同的任务(多个线程)

多线程速度快吗? 看CPU的核数,个数

三、多线程

多线程是指一个进程在执行过程中可以产生多个线程，这些线程可以同时存在、同时运行，形成多条执行线

（二）java实现多线程


在jdk.1.5之前: 创建线程的方式: 两种:

  • 继承Thread类
  • 实现Runnable接口

在JDK1.5之后: 多加了两种:

  • 实现 Callable接口
  • 线程池

第一种方式: 继承Thread

  1. 编写一个类继承Thread,该类是线程类

  2. 重写run(), 编写该线程需要完成的任务

  3. 创建线程类对象

  4. 调用start()方法,启动线程

/**
 * 实现线程的第一种方式:
 * 继承Thread
 */
public class MyThread1 extends Thread{
​
    //private static Object o = new Object();
    public MyThread1(String name) {
        super(name);
    }
​
    //重写run()方法
    @Override
    public void run() {
        //线程完成的功能
        for (int i = 1; i <=10 ; i++) {
            //得到当前正在运行的线程
           //Thread.currentThread()
            //getName() 得到线程的名字
            System.out.println(Thread.currentThread().getName()+":输出"+i);
        }
    }
}

 注意事项:

  1. 线程启动,一定是调用start() , 不是调用run(), 如果直接调用run() ,只是方法的调用,没有创建线程
  2. 一个线程一旦启动,就不能重复启动

第二种方式: 实现Runnable接口

启动线程: 都必须借助Thread的start()

Runnable实现类: 就是一个线程的任务类

继承Thread与Runnable接口的区别:

  1. 继承Thread类, 这个线程类就不能再继承其他类, 实现Runnable接口, 可以再继承其他类
  2. 实现Runnable接口, 可以让多个线程共享这个Runnable的实现类对象
  3. 继承Thread类,启动简单, 实现Runnable接口, 必须依赖Thread类的start()方法

推荐 实现Runnable接口

/**
 * 线程的第二种实现方式: 实现Runnable接口
 */
public class MyRunnable implements  Runnable {
    @Override
    public void run(){
        //线程需要完成的任务
        for (int i = 1; i <=10 ; i++) {
     System.out.println(Thread.currentThread().getName()+":输出"+i);
        }
    }
}

实际开发中使用 

new Thread(new Runnable() {
        @Override
        public void run() { 
        }
    }).start();

 第三种方式: 实现Callable接口

  1. 第一步编写一个类实现Callable接口,重写call()方法
  2. 启动线程
  3. 创建Callable接口实现类对象
  4. 创建一个FutureTask对象, 传递Callable接口实现类对象, FutureTask异步得到Callable执行结果, 提供get() FutureTask 实现Future接口( get()) 实现Runnable接口
  5. 创建一个Thread对象, 把FutureTask对象传递给Thread, 调用start()启动线程
/**
 * 线程的第三种实现方式:
 *   实现Callable接口
 */
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        //线程睡眠 单位: 毫秒
        Thread.sleep(10000);                   System.out.println(Thread.currentThread().getName()
        +"执行完成");
        return "callable";
    }
}

 第四种方式: 使用线程池创建

1.FixedThreadPool：固定大小的线程池。
2.CachedThreadPool：缓存线程池。该线程池创建的线程数量不固定，当有新任务需要执行时，会创建新的线程来执行任务，如果有线程处于空闲状态，会优先使用空闲线程。适用于执行时间短的任务，如处理HTTP请求等。
3.SingleThreadExecutor：单线程线程池。该线程池只创建一个线程来执行任务，
4.ScheduledThreadPool：定时任务线程池。该线程池可以定时执行任务，可以设置任务执行的时间、执行周期等。适用于需要定时执行任务的场景，如定时备份数据等。

1、使用newCachedThreadPool

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

这种类型的线程池特点是：

  • 工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。

  • 如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

  • 在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

示例代码如下：

package test;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
   public class ThreadPoolExecutorTest {
   public static void main(String[] args) {
   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
   final int index = i;
    try {
    Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    cachedThreadPool.execute(new Runnable() {
     public void run() {
      System.out.println(index);
     }
    });
   }
  }
 }

 2、使用newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

示例代码如下：

package test;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 public class ThreadPoolExecutorTest {
  public static void main(String[] args) {
   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
   for (int i = 0; i < 10; i++) {
    final int index = i;
    try {
     Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    cachedThreadPool.execute(new Runnable() {
     public void run() {
      System.out.println(index);
     }
    });
   }
  }
 }

3、使用newSingleThreadExecutor

创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

示例代码如下：

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

4、使用newScheduledThreadPool

创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

延迟3秒执行，延迟执行示例代码如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

表示延迟1秒后每3秒执行一次，定期执行示例代码如下：

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}

（三）使用多线程

一、启动线程

1.实现线程的第一种方式:*继承Thread

抢占式执行，谁抢到就是谁的，main函数最先执行（多数情况下）

//启动线程
        //创建线程对象
        MyThread1 t1 =new MyThread1("t1");
        MyThread1 t2 =new MyThread1("t2");
        MyThread1 t3 =new MyThread1("t3");
        //调用start()启动线程, 线程与其他线程抢占cpu资源, 谁抢到,执行谁的run()中的代码
        t1.start();
        t1.start();
        t2.start();
        t3.start();
​
        System.out.println("main线程执行完成...");

2.线程的第二种实现方式: 实现Runnable接口

public static void main(String[] args) {        
//创建任务对象        
MyRunnable task = new MyRunnable();        
//创建线程: Thread        
Thread t1 = new Thread(task, "t1");       
Thread t2 = new Thread(task, "t2");        
//启动线程        
t1.start();        
t2.start();    
}

3.线程的第三种实现方式:实现Callable接口

get(); //阻塞的 main最后执行

MyCallable callable = new MyCallable();
        //再次封装 FutureTask
        FutureTask<String> task = new FutureTask<>(callable);
 
        Thread t1 = new Thread(task, "t1");
        //启动线程
        t1.start();
 
        //获取结果
       // String rs = task.get(); //阻塞的,  是main线程在执行
 
        //设置一个超时时间, 一旦到达超时时间, 停止执行,抛一个异常
        //String rs = task.get(1, TimeUnit.SECONDS);
 
        //取消执行
        task.cancel(true);
        //System.out.println(rs);
        System.out.println("main线程执行完成!!");

二,线程的生命周期

新生状态：调用start()方法之前都处于出生状态

就绪状态：调用start()方法后处于就绪状态（又称为可执行状态）

运行状态：得到系统资源后处于运行状态

阻塞状态：如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入输出结束时线程进入了就绪状态。

线程阻塞:

死亡状态：当线程run()方法执行完毕时线程进入死亡状态。

  1. 同步阻塞
  2. sleep() Thread的方法 时间到自动醒,释放cpu资源,不释放锁, join() 阻塞
  3. yield() 礼让, 释放cpu资源, 与其他线程抢CPU资源
  4. wait() 等待: Object类中的方法, 一定等待唤醒(notify() notifyAll()), 释放cpu资源,释放锁资源, 线程通信
  5. suspend（）和resume()，由jdk1.0提供，jdk1.2之后就被放弃了，它也是让线程暂停，但是它不释放资源,导致死锁出现

t1.yield(); //礼让
Thread.sleep(1000);
thread4.join();
//等方法会让线程进入阻塞状态 

三,线程同步

同步方法

在方法上添加一个synchronized修饰符, 往对象上加锁

非静态同步方法:锁加在 this(对象)

静态同步方法:锁加在类.class(对象)

锁的释放: 当把同步方法执行完之后,马上释放锁

同步方法: 锁住的代码范围整个方法, 锁的控制粒度太宽

public 返回值类型 方法名(){
  //...
  synchronized(锁对象){
      //锁住的代码
  }
  //...
}

四,线程死锁

多个线程,相互之间需要对方的锁, 但是又不释放自己的锁,造成程序卡住, 这些线程都在等待,等待对方的锁,

死锁形成的原因: 互斥锁,排他锁

1> 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2> 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3> 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占用。

4> 循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路

形成死锁的这4个条件缺一不可, 避免死锁: 打破4个条件 的一个就可以

项目一定避免出现死锁:

解决死锁:

使用完某个锁,马上释放

多个线程获取锁的顺序是一致, A线程获取锁: a-->b-->c

B线获取锁: a-->b-->v

模拟死锁:

A线程 先获取objA锁, 再获取objB锁, 在获取objB锁时,不释放objA锁

B线程 先获取objB锁, 再获取objA锁, 在获取objA锁时,不释放objB锁

（四）统计线程运行时间

1,java 统计线程运行时间

public class MyThread extends Thread {
    public void run() {
        // 线程相关的任务代码
        for (int i = 0; i < 1000000; i++) {
            // 模拟线程运行的任务
        }
    }

    public static void main(String[] args) {
        // 创建线程
        MyThread thread = new MyThread();
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        // 执行线程任务
        thread.start();
        // 等待线程执行完成
        thread.join();
        // 记录结束时间
        long endTime = System.currentTimeMillis();
        // 输出线程运行时间
        System.out.println("总耗时::"+(endTime-startTime)/1000+"秒");
    }
}

2,例如:一个任务需要2s执行,现在有十个任务,共需要多久时间?

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1234736.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【20年扬大真题】编写对数组求逆的递归算法

【20年扬大真题】编写对数组求逆的递归算法

【20年扬大真题】 编写对数组求逆的递归算法 void swap(int* a, int* b) {int tmp *b;*b *a;*a tmp; } void Ni(int arr[],int left,int right) {if (left > right) {return;}swap(&arr[left], &arr[right]);Ni(arr, left 1, right - 1); } int main() {int ar…
阅读更多...
威视佰科荣获：2023年“AI天马”高成长性企业

威视佰科荣获：2023年“AI天马”高成长性企业

11月14日下午&#xff0c;2023年度“AI天马”认定评审会顺利召开。落实《深圳经济人工智能产业促进条例》&#xff0c;加快推进智能机器人、智能传感器、智能网联汽车、智能终端、脑科学和类脑智能等人工智能相关产业发展&#xff0c;加速AI产业化和产业AI化进程&#xff0c;持…
阅读更多...
对象分配规则

对象分配规则

程序员的公众号&#xff1a;源1024&#xff0c;获取更多资料&#xff0c;无加密无套路&#xff01; 最近整理了一份大厂面试资料《史上最全大厂面试题》&#xff0c;Springboot、微服务、算法、数据结构、Zookeeper、Mybatis、Dubbo、linux、Kafka、Elasticsearch、数据库等等 …
阅读更多...
Python Opencv实践 - 二维码和条形码识别

Python Opencv实践 - 二维码和条形码识别

使用pyzbar模块来识别二维码和条形码。ZBar是一个开源软件&#xff0c;用来从图像中读取条形码&#xff0c;支持多种编码,比如EAN-13/UPC-A、UPC-E、EAN-8、代码128、代码39、交错2/5以及二维码。 pyzbar是python封装ZBar的模块&#xff0c;我们用它来做条形码和二维码的识别。…
阅读更多...
算法设计与分析复习--回溯法（二）

算法设计与分析复习--回溯法（二）

文章目录 上一篇0-1背包问题图着色问题n皇后问题下一篇 上一篇 算法设计与分析复习–回溯&#xff08;一&#xff09; 0-1背包问题 问题描述&#xff1a;给定n中物品和一个背包。物品 i i i 的重量是 w i w_i wi​ &#xff0c;其价格为 v i v_i vi​ , 背包容量为 c c …
阅读更多...
ChatGPT/GPT4科研实践应用与AI绘图技术及论文高效写作

ChatGPT/GPT4科研实践应用与AI绘图技术及论文高效写作

2023年随着OpenAI开发者大会的召开&#xff0c;最重磅更新当属GPTs&#xff0c;多模态API&#xff0c;未来自定义专属的GPT。微软创始人比尔盖茨称ChatGPT的出现有着重大历史意义&#xff0c;不亚于互联网和个人电脑的问世。360创始人周鸿祎认为未来各行各业如果不能搭上这班车…
阅读更多...
体感互动游戏VR游戏AR体感游戏软件开发

体感互动游戏VR游戏AR体感游戏软件开发

随着科技的不断发展&#xff0c;体感互动游戏正逐渐成为游戏行业的一个重要趋势。这类游戏通过利用传感器、摄像头和运动控制器等技术&#xff0c;使玩家能够通过身体动作与游戏进行实时互动&#xff0c;极大地提升了娱乐体验。 1. 游戏设计与互动元素 体感互动游戏的核心在于…
阅读更多...
六、流量监管、流量整形

六、流量监管、流量整形

流量监管、流量整形 流量监管、流量整形1.1.定义1.2.简单流分类应用场景举例1.3.简单流分类的配置1.4.复杂流分类1.5.复杂流分类在产品中的实现 ————————————————— 流量监管、流量整形 当报文的发送速率大于接收速率&#xff0c;或者下游设备的接口速率小于…
阅读更多...
代码随想录算法训练营|五十九～六十天

代码随想录算法训练营|五十九～六十天

下一个更大元素|| 503. 下一个更大元素 II - 力扣&#xff08;LeetCode&#xff09; 和每日温度一样的套路&#xff0c;就是这里可以循环数组&#xff0c;两个数组拼接&#xff0c;然后循环两遍就行。 public class Solution {public int[] NextGreaterElements(int[] nums)…
阅读更多...
UEC++ day7

UEC++ day7

敌人NPC机制 敌人机制分析与需求 新建一个character类来作为敌人&#xff0c;直接建蓝图设置骨骼网格&#xff0c;因为敌人可能多种就不规定死&#xff0c;然后这个敌人肯定需要两个触发器&#xff0c;一个用于大范围巡逻&#xff0c;一个用于是否达到主角近点进行攻击 注意我…
阅读更多...
matlab-BP神经网络的训练参数大全

matlab-BP神经网络的训练参数大全

本文部分图文来自《老饼讲解-BP神经网络》bp.bbbdata.com 本文列兴趣MATLAB神经网络工具箱中&#xff0c;训练参数trainParam的各个参数与意义 以方便在使用matlab工具箱时&#xff0c;用于查阅 一、matlab神经网络工具箱trainParam的参数列表 trainParam中的各个具体参数如下…
阅读更多...
函数有返回类型，但函数体未返回类型，程序崩溃问题记录

函数有返回类型，但函数体未返回类型，程序崩溃问题记录

问题 使用类指针调用函数时&#xff0c;程序崩溃。 问题定位&#xff1a; name new nameSetting;name->setName("helloworld");qDebug().noquote() << name->getName();原因 class nameSetting { public:nameSetting();QString setName(const QStri…
阅读更多...
【大数据开发】FineReport报表基础入门

【大数据开发】FineReport报表基础入门

博主&#xff1a;&#x1f44d;不许代码码上红 欢迎&#xff1a;&#x1f40b;点赞、收藏、关注、评论。 格言&#xff1a; 大鹏一日同风起&#xff0c;扶摇直上九万里。 文章目录 一 登录账号二 创建一个新的表格三 单元格扩展3.1 无扩展3.2 纵向扩展3.3 横向扩展 四 父子格…
阅读更多...
Redis事务+秒杀案例

Redis事务+秒杀案例

Redis事务是一个单独的隔离操作&#xff0c;是指将多条命令放在一个命令队列当中&#xff0c;按顺序执行&#xff0c;保证多个命令在同一个事务中执行而不受其他客户端的影响。 通俗来说就是&#xff1a;串联多个命令防止别的命令插队。 1.Multi、Exec、discard 在输入Multi命…
阅读更多...
最近带着江苏高校的学生做软件测试项目实战

最近带着江苏高校的学生做软件测试项目实战

阅读更多...
SSM框架（二）：AOP和事物

SSM框架（二）：AOP和事物

文章目录 一、AOP的介绍1.1 基本概念1.2 AOP入门1.3 AOP工作流程1.4 切入点表达式1.5 AOP的通知类型1.6 ProceedingJoinPoint1.7 AOP通知获取参数数据 二、事物2.1 基本介绍2.2 事物角色2.3 事物属性2.4 事物的传播行为 一、AOP的介绍 1.1 基本概念 1.2 AOP入门 导入坐标 <…
阅读更多...
【数值计算方法】矩阵特征值与特征向量的计算（一）：Jacobi 旋转法及其Python实现

【数值计算方法】矩阵特征值与特征向量的计算（一）：Jacobi 旋转法及其Python实现

文章目录 一、Jacobi 旋转法1. 基本思想2. 计算过程演示3. 注意事项 二、Python实现迭代过程&#xff08;调试&#xff09; 矩阵的特征值&#xff08;eigenvalue&#xff09;和特征向量&#xff08;eigenvector&#xff09;在很多应用中都具有重要的数学和物理意义。Jacobi 旋转…
阅读更多...
Linux 环境配置小白入门

Linux 环境配置小白入门

Linux从 全栈开发centOS 7 到 运维 一 Linux 入门概述1.1 操作系统1.2 Linux 简介1.3 Linux 系统组成1.4 Linux 发行版1.5 Linux 应用领域1.6 Linux vs Windows 二 虚拟机2.1 虚拟机介绍2.2 VMware WorkStation 安装2.3 VMware WorkStation 配置检查2.3 安装 CentOS 72.3.1 安装…
阅读更多...
Git 远程仓库(Github)

Git 远程仓库(Github)

目录 添加远程库 查看当前的远程库 提取远程仓库 推送到远程仓库 删除远程仓库 Git 并不像 SVN 那样有个中心服务器。 目前我们使用到的 Git 命令都是在本地执行&#xff0c;如果你想通过 Git 分享你的代码或者与其他开发人员合作。 你就需要将数据放到一台其他开发人员…
阅读更多...
2021年03月 Scratch（二级）真题解析#中国电子学会#全国青少年软件编程等级考试

2021年03月 Scratch（二级）真题解析#中国电子学会#全国青少年软件编程等级考试

Scratch等级考试（1~4级）全部真题・点这里 一、单选题（共25题，每题2分，共50分） 第1题 小猫在沙漠中旅行好不容易找到了一杯水，初始位置如下图所示，下面哪个程序可以帮助它成功喝到水？ A： B： C： D：
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023