Java多线程介绍及使用指南

“多线程”：并发

要介绍线程，首先要区分开程序、进程和线程这三者的区别。

程序：具有一定功能的代码的集合，但是是静态的，没有启动运行
进程：启动运行的程序【资源的分配单位】
线程：进程中的每一条执行路径，就是线程。

概念：
并行：多个CPU同时执行多个任务
并发：一个CPU“同时”执行多个任务（采用时间片切换）

将1分钟---分成10000份=6毫秒

5.1使用线程的3种方式：

第一种方式：继承父类

1.创建线程类：
public class NumberThread extends Thread
2.创建线程对象：【新生状态】
NumberThread num=new NumberThread();
3.【就绪状态】--->cpu给资源--->运行状态
num.start();
如果调用run()，则不是多线程的了，会直接执行完

例子：售票窗口
有10张车票，3个窗口，同时售票，显示售票结果。

package thread;  public class WindowThread extends Thread {  static int ticket=10;  public WindowThread() {  }  public WindowThread(String name) {  super(name);  }  @Override  public void run() {  while (ticket >= 1) {  System.out.println(getName()+"窗口，卖出第"+ticket+"票");  ticket--;  }  }  
}

package thread;  public class TestMain {  public static void main(String[] args) {  WindowThread w1=new WindowThread("第1");  w1.start();  WindowThread w2=new WindowThread("第2");  w2.start();  WindowThread w3=new WindowThread("第3");  w3.start();  }
}

在这里插入图片描述

优点：启动线程对象高效率
缺点：占用了父类位置

第二种方式：实现接口

public class Window implements Runnable {  int ticket=10;  @Override  public void run() {  while (ticket >= 1) {  System.out.println(Thread.currentThread().getName()+"窗口卖出第"+ticket+"张票");  ticket--;  }  }  
}

public class Test {  public static void main(String[] args) {  Window w1=new Window();  Thread t1 = new Thread(w1,"第1");  t1.start();  Thread t2 = new Thread(w1, "第2");  t2.start();  Thread t3 = new Thread(w1, "第3");  t3.start();  }  
}

优点：没有占用父类位置,共享资源能力强，资源不用加static
缺点：启动线程对象 效率低

第三种方式：实现接口

对比第一种和第二种创建线程的方式发现，无论第一种继承Thread类的方式还是第二种实现Runnable接口的方式，都需要有一个run方法
但是这个run方法有不足：

在这里插入图片描述

1）没有返回值
2）不能抛出异常

基于上面的两个不足，在JDK1.5以后出现了第三种创建线程的方式：实现Callable接口：

实现Callable接口好处：（1）有返回值 （2）能抛出异常
缺点：线程创建比较麻烦

package com.msb.test05;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/*** @author : msb-zhaoss*/
public class TestRandomNum implements Callable<Integer> {/*1.实现Callable接口，可以不带泛型，如果不带泛型，那么call方式的返回值就是Object类型2.如果带泛型，那么call的返回值就是泛型对应的类型3.从call方法看到：方法有返回值，可以跑出异常*/@Overridepublic Integer call() throws Exception {return new Random().nextInt(10);//返回10以内的随机数}
}
class Test{//这是main方法，程序的入口public static void main(String[] args) throws ExecutionException, InterruptedException {//定义一个线程对象：TestRandomNum trn = new TestRandomNum();FutureTask ft = new FutureTask(trn);Thread t = new Thread(ft);t.start();//获取线程得到的返回值：Object obj = ft.get();System.out.println(obj);}
}

FutureTask 是Runnable接口的一个实现类，因此它可以作为参数传给Tread
用线程任务对象来接返回值（这里用的是ft）
注意：get方法的使用位置必须在start之后
创建几个线程对象，就要创建几个FutreTask，而不能new两个Thread，因为这样是一个对象的内容接了两遍

5.2线程对象的常用方法：

  • a.getName()获得当前线程对象的名字：
    ---线程名 如果开发者使用了无参构造器，程序自动设置线程名Thread-0++(主线程除外)
    ---开发者使用有参构造器，参数的值就是线程的名字。
public class NumberThread extends Thread{  public NumberThread() {  }  public NumberThread(String name) {  super(name);  }  @Override  public void run() {    //第二条执行路线的内容  for (int i = 1; i < 100; i++) {  System.out.println(super.getName()+"i="+i);   //获得当前线程名  }  }  
}

---借助num.setName("线程1")，为线程名赋值

public class TestMain {  //main()方法所在的线程叫主线程  public static void main(String[] args) {  NumberThread num=new NumberThread("窗口1");  //此时程序开启第二条路  num.start();  NumberThread num2=new NumberThread("窗口2");  //此时程序开启第二条路  num2.start();  for (int i = 1; i < 100; i++) {  System.out.println(Thread.currentThread().getName()+"i="+i);  }  }  
}
  • b.currentThread()获得当前正在运行的线程对象
    针对实现接口的情况，由于没有再继承Thread类，因此也无法直接使用其中的方法getName(),但Thread类中有静态方法currentThread()，因此可以通过这种方法获得当前运行的线程对象的信息。
  • c.setPriority()设置线程的优先级，1-10之间，默认是5
Thread t2 = new Thread(w1, "第2");  
t2.setPriority(1);  //设置线程的优先级，1-10之间，默认是5  
t2.start();
  • d.Thread.currentThread().stop() 过期方法，不建议执行
  • e.强行占用。当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程。
public static void main(String[] args) throws InterruptedException {  NumberThread num=new NumberThread("窗口1");  //此时程序开启第二条路  num.start();  for (int i = 1; i < 100; i++) {  System.out.println(Thread.currentThread().getName()+"i="+i);  if (i == 50) {  num.join();  //强势加入（num运行完了后，其余的才能执行）System.out.println("maini=50");  }  }  
}
  • f.setDaemon(true);伴随线程
    tt.setDaemon(true);//设置伴随线程
    主线程死亡，伴随线程也会跟着一起死亡。
public class TestThread extends Thread {@Overridepublic void run() {for (int i = 1; i <= 1000 ; i++) {System.out.println("子线程----"+i);}}
}
class Test{//这是main方法，程序的入口public static void main(String[] args) {//创建并启动子线程：TestThread tt = new TestThread();tt.setDaemon(true);//设置伴随线程  注意：先设置，再启动tt.start();//主线程中还要输出1-10的数字：for (int i = 1; i <= 10 ; i++) {System.out.println("main---"+i);}}
}
  • g.sleep(毫秒)：设置线程休眠
public static void main(String[] args) throws InterruptedException {  System.out.println("1111");  Thread.sleep(1000);  //休眠的例子System.out.println("222");  
}

5.3线程的生命周期：

使用线程构造器---创建线程对象--->线程新生状态
创建线程对象.start()--->进入到就绪状态【有资格，没资源】
线程对象.run()--->进入到运行状态【有资格，有资源】

在时间片段内，执行完--->死亡状态
在时间片段内，没执行完--->重回就绪状态
在时间片段内，出现突发事件--->阻塞状态--->就绪状态

在这里插入图片描述

5.4解决线程安全问题：

【第一种：同步代码块】

public void run() {  while (true) {  synchronized (WindowThread.class){ //WindowThread.class是监视器对象  if(ticket >= 1) {  System.out.println(getName() + "窗口，卖出第" + ticket + "票");  ticket--;  }  }  }  
}

总结：
同步监视器总结：
1：认识同步监视器（锁子） ----- synchronized(同步监视器){ }
1)必须是引用数据类型，不能是基本数据类型
2)也可以创建一个专门的同步监视器，没有任何业务含义
3)一般使用共享资源做同步监视器即可
4)在同步代码块中不能改变同步监视器对象的引用
5)尽量不要String和包装类Integer做同步监视器
6)建议使用final修饰同步监视器

2：同步代码块的执行过程
1)第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码
2)第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去了cpu，但是没有开锁open
3)第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态
4)第一个线程再次获取CPU,接着执行后续的代码；同步代码块执行完毕，释放锁open
5)第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，拿到锁并且上锁，由阻塞状态进入就绪状态，再进入运行状态，重复第一个线程的处理过程（加锁）
强调：同步代码块中能发生CPU的切换吗？能！！！ 但是后续的被执行的线程也无法执行同步代码块（因为锁仍旧close）

3：其他
1)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块
2)多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块

【第二种：同步方法】

public class WindowThread extends Thread {  static int ticket = 300;  public WindowThread() {  }  public WindowThread(String name) {  super(name);  }
@Override  
public void run() {  while (true) {  if (ticket == 0) {  break;  } else {  buyTicket();  }   }  
}  public static synchronized void buyTicket(){   
//如果只有synchronized，锁住的只是当前this对象（相当于每一个都有300张票）
//如果加了static，锁住的就是方法。if(ticket >= 1) {  System.out.println(Thread.currentThread().getName() + "窗口，卖出第" + ticket + "票");  ticket--;  }  }
}

总结：
1：
多线程在争抢资源，就要实现线程的同步（就要进行加锁，并且这个锁必须是共享的，必须是唯一的。
咱们的锁一般都是引用数据类型的。
目的：解决了线程安全问题。

2：关于同步方法

  1. 不要将run()定义为同步方法
  2. 非静态同步方法的同步监视器是this
    静态同步方法的同步监视器是 类名.class 字节码信息对象
  3. 同步代码块的效率要高于同步方法
    原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部
  4. 同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块
    【第三种方式：Lock锁】
@Override  //Lock锁  
public void run() {  Lock lock = new ReentrantLock();  //创建Lock锁对象  while (true) {  lock.lock();//上锁  if (ticket >= 1) {  System.out.println(getName() + "窗口，卖出第" + ticket + "票");  ticket--;  }  lock.unlock();  //解锁  if (ticket == 0) {  break;  }  }  
}

5.5线程通信：

在这里插入图片描述

package com.msb.test11;
/*** @author : msb-zhaoss*/
public class Product {//商品类//品牌private String brand;//名字private String name;//引入一个灯：true:红色  false 绿色boolean flag = false;//默认情况下没有商品 让生产者先生产  然后消费者再消费//setter,getter方法；public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public String getName() {return name;}public void setName(String name) {this.name = name;}//生产商品public synchronized void setProduct(String brand,String name){if(flag == true){//灯是红色，证明有商品，生产者不生产，等着消费者消费try {wait();} catch (InterruptedException e) {e.printStackTrace();}}//灯是绿色的，就生产：this.setBrand(brand);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}this.setName(name);//将生产信息做一个打印：System.out.println("生产者生产了：" + this.getBrand() + "---" + this.getName());//生产完以后，灯变色：变成红色：flag = true;//告诉消费者赶紧来消费：notify();}//消费商品：public synchronized void getProduct(){if(!flag){//flag == false没有商品，等待生产者生产：try {wait();} catch (InterruptedException e) {e.printStackTrace();}}//有商品，消费：System.out.println("消费者消费了：" + this.getBrand() + "---" + this.getName());//消费完：灯变色：flag = false;//通知生产者生产：notify();}
}

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

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

相关文章

独家｜京东调整职级序列体系

独家｜京东调整职级序列体系

原有的M、P、T、S主序列将正式合并为新的专业主序列P。 作者|文昌龙 编辑|杨舟 据「市象」独家获悉&#xff0c;京东已在近日在内部宣布对职级序列体系进行调整&#xff0c;将原有的M、P、T、S主序列正式合并为新的专业主序列P&#xff0c;合并后的职级体系将沿用原有专业序…
阅读更多...
mysql 存储结构的进化之路

mysql 存储结构的进化之路

文章目录 前言一、线性结构二、二叉树&#xff08;BST&#xff09;三、平衡二叉树&#xff08;AVL&#xff09;四、多路平衡查找树&#xff08;B Tree&#xff09;五、加强版多路平衡查找树&#xff08;B Tree&#xff09;总结 前言 树形结构是一种具有层次关系的数据结构&…
阅读更多...
unity3d———xml 存储数据例子

unity3d———xml 存储数据例子

1.代码示例&#xff1a; public void SaveData(string fileName){//决定存储路径string path Application.persistentDataPath "/" fileName ".xml";Debug.Log(Application.persistentDataPath);//5个步骤//1.创建我们的Xml文本 XmlDocument xml new…
阅读更多...
用户该怎么管理维护自己的服务器？

用户该怎么管理维护自己的服务器？

管理和维护自己的服务器是确保其长期稳定、高效和安全运行的重要任务。以下是一些关键的服务器管理和维护的步骤和建议&#xff0c;适用于Linux或Windows服务器。 1.定期备份数据 定期备份是防止数据丢失和恢复故障的关键步骤。备份策略应包括&#xff1a; 全量备份&#xff1a…
阅读更多...
RHCE作业五-shell脚本

RHCE作业五-shell脚本

一要求&#xff1a; 通过shell脚本分析部署nginx网络服务 1.接收用户部署的服务名称 2.判断服务是否安装 ​ 已安装&#xff1b;自定义网站配置路径为/www&#xff1b;并创建共享目录和网页文件&#xff1b;重启服务 ​ 没有安装&#xff1b;安装对应的软件包 3.测试 判断服务…
阅读更多...
Java基础之控制语句：开启编程逻辑之门

Java基础之控制语句：开启编程逻辑之门

一、Java控制语句概述 Java 中的控制语句主要分为选择结构、循环结构和跳转语句三大类&#xff0c;它们在程序中起着至关重要的作用&#xff0c;能够决定程序的执行流程。 选择结构用于根据不同的条件执行不同的代码路径&#xff0c;主要包括 if 语句和 switch 语句。if 语句有…
阅读更多...
CSS新特性（11）

CSS新特性（11）

一.计算盒子宽度calc函数&#xff0c;可以用加减乘除来计算 -*/ 让父盒子永远比子盒子小30像素 二.CSS3过渡transition搭配hover一起使用 该盒子宽度可以从200px到400px,谁做变化给谁加 不仅要写宽还要写高利用逗号&#xff0c;多个属性一起写都用逗号 既想要宽度变又想要高度…
阅读更多...
linuxmysqliptablesfirewalldtcpdump备份恢复常用命令

linuxmysqliptablesfirewalldtcpdump备份恢复常用命令

目录 使用 tar 命令进行备份和恢复 备份 恢复 使用 rsync 命令进行备份和恢复 备份 恢复 使用 cp 命令进行简单的文件备份 备份 恢复 使用 tar 和 cron 定期备份 使用 cloud backup 工具&#xff08;如 rclone&#xff09; 备份到云存储 恢复从云存储 mysql备份恢复…
阅读更多...
MacOS 配置github密钥

MacOS 配置github密钥

MacOS 配置github密钥 1. 生成GitHub的SSH密钥对 ssh-keygen -t ed25519 -C "xxxxxxx.com" -f ~/.ssh/id_ed25519_github 其中 xxxxxxxxxxx.com 是注册github、gitee和gitlab的绑定账号的邮箱 -t ed25519:生成密钥的算法为ed25519&#xff08;ed25519比rsa速度快&…
阅读更多...
React 前端框架深度剖析

React 前端框架深度剖析

摘要&#xff1a; 本文旨在对 React 前端框架进行全面且深入的分析。首先介绍了 React 的起源与发展历程&#xff0c;阐述其核心概念如虚拟 DOM、组件化思想等&#xff0c;详细探讨了 React 的工作原理&#xff0c;包括组件生命周期、数据流动机制等方面。接着对 React 的生态系…
阅读更多...
linux cenos redis 单机部署

linux cenos redis 单机部署

编译安装redis&#xff08;Centos&#xff09; 编译安装前先安装编译基础环境&#xff1a; yum install -y gcc gcc-c yum install -y readline-devel yum install -y zlib-devel yum -y install pcre yum -y install pcre-devel yum -y install openssl yum -y instal…
阅读更多...
Luma AI技术浅析（五）：GAN 改进技术

Luma AI技术浅析（五）：GAN 改进技术

生成对抗网络&#xff08;Generative Adversarial Networks, GAN&#xff09; 是 Luma AI 用于生成高质量 3D 模型和动画的核心技术之一。GAN 由生成器&#xff08;Generator&#xff09;和判别器&#xff08;Discriminator&#xff09;组成&#xff0c;生成器生成数据&#xf…
阅读更多...
TI毫米波雷达（七）——high accurary示例分析（二）

TI毫米波雷达（七）——high accurary示例分析（二）

概述 之前分析了IWR6843上的高精度测距程序框架&#xff0c;虽然可以看到大致的系统运行过程&#xff0c;但是总有一种“混乱”的感觉。TI为了展现ARM与DSP协作能力将如此“简单”的一个功能分布在多处理器上&#xff0c;结合BIOS以及semaphore、event、mailbox等机制&#xff…
阅读更多...
鸿蒙修饰符

鸿蒙修饰符

文章目录 一、引言1.1 什么是修饰符1.2 修饰符在鸿蒙开发中的重要性1.3 修饰符的作用机制 二、UI装饰类修饰符2.1 Styles修饰符2.1.1 基本概念和使用场景2.1.2 使用示例2.1.3 最佳实践 2.2 Extend修饰符2.2.1 基本概念2.2.2 使用示例2.2.3 Extend vs Styles 对比2.2.4 使用建议…
阅读更多...
架构-微服务-服务配置

架构-微服务-服务配置

文章目录 前言一、配置中心介绍1. 什么是配置中心2. 解决方案 二、Nacos Config入门三、Nacos Config深入1. 配置动态刷新2. 配置共享 四、nacos服务配置的核心概念 前言 服务配置--Nacos Config‌ 微服务架构下关于配置文件的一些问题&#xff1a; 配置文件相对分散。在一个…
阅读更多...
大米中的虫子检测-检测储藏的大米中是否有虫子 支持YOLO，VOC，COCO格式标注，4070张图片的数据集

大米中的虫子检测-检测储藏的大米中是否有虫子 支持YOLO，VOC，COCO格式标注，4070张图片的数据集

大米中的虫子检测-检测储藏的大米中是否有虫子 支持YOLO&#xff0c;VOC&#xff0c;COCO格式标注&#xff0c;4070张图片的数据集 数据集分割 4070总图像数 训练组 87&#xff05; 3551图片 有效集 9&#xff05; 362图片 测试集 4% 157图片 预处理 自动定向…
阅读更多...
golang通用后台管理系统11(代码生成工具01)

golang通用后台管理系统11(代码生成工具01)

golang代码生成 1.效果 2.代码
阅读更多...
Flink随笔 20241129 流数据处理：以生产线烤鸡为例理解 Flink

Flink随笔 20241129 流数据处理：以生产线烤鸡为例理解 Flink

流数据&#xff08;streaming data&#xff09;就像是一条永不停歇的生产线&#xff0c;源源不断地向前推进&#xff0c;带来新的数据。而 Apache Flink 就是这条生产线的核心&#xff0c;它负责对数据进行处理、分类、聚合和存储。为了更好地理解 Flink 的流处理&#xff0c;我…
阅读更多...
Langchain 实现 RAG

Langchain 实现 RAG

RAG 实现包括三部分，文档向量化、相似度搜索和大模型回答，本文将使用 LangChain 进行 RAG 的实现。RAG 中最重要的是向量，向量模型的好坏直接反映到最终结果的好坏，如果不能搜索到相对准确的文档，RAG 就没有起到该有的效果。文章将分为两部分，首先是向量索引以及搜索，然…
阅读更多...
Next.js -服务端组件如何渲染

Next.js -服务端组件如何渲染

#题引&#xff1a;我认为跟着官方文档学习不会走歪路 服务器组件渲染到客户端发生了什么&#xff1f; 请求到达服务器 用户在浏览器中请求一个页面。 Next.js 服务器接收到这个请求&#xff0c;并根据路由找到相应的页面组件。服务器组件的渲染 Next.js 识别出请求的页面包含…
阅读更多...
最新文章

Copyright @ 2022~2023