多线程java

多线程的创建

前两种方法无法返回直接结果,而有的线程执行完毕后需要返回结果

方式一:java是通过java.lang.Thread类的对象来代表线程的
  • 启动线程必须调用strat方法,不是调用run方法
  • 不要把主线程任务放在启动子线程之前
//1.让子类继承Thread线程类
public class MyThread extends Thread{//2.必须重写Thread类的run方法@Overridepublic void run(){for (int i = 0; i < 5; i++) {System.out.println("MyThread线程输出:"+i);}}
}

public class ThreadTest1 {//mainpublic static void main(String[] args) {//3.创建MyThread线程类的对象代表一个线程Thread t = new MyThread();//4.启动线程t.start();}
}
方式二:实现Runnable接口
  • 优点:任务类只是实现接口,可以继续继承其他类,实现其它接口,扩展性强
//1.实现Runnable接口
public class MyRunnable implements Runnable{//2.重写run方法@Overridepublic void run() {//3.线程要执行的任务for (int i = 0; i < 5; i++) {System.out.println("子线程输出:"+i);}}
}
public class ThreadTest2 {public static void main(String[] args) {//4.创建任务对象Runnable target = new MyRunnable();//5.把任务对象交给一个线程处理new Thread(target).start();for (int i = 0; i < 5; i++) {System.out.println("主线程输出:"+i);}}
}
线程创建方式二的匿名内部类写法
  1. 可以创建Runable的匿名内部类对象
  2. 再交给Thread线程对象
  3. 在调用线程对象的Strat()启动线程
public class ThreadTest2_2 {public static void main(String[] args) {//1.直接创建Runnable接口的匿名内部类形式(任务对象)Runnable target = new Runnable() {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("子线程1输出:"+i);}}};new Thread(target).start();//简化形式new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("子线程2输出:"+i);}}}).start();//再次简化new Thread(() -> {for (int i = 0; i < 5; i++) {System.out.println("子线程3输出:"+i);}}).start();for (int i = 0; i < 5; i++) {System.out.println("主线程输出:"+i);}}
}
方式三:实现Callable接口
  • JDK5.0提供了Cabble接口和FutureTask类来实现
  • 可以返回线程执行完毕后的结果

过程

  1. 定义一个类实现Callable接口,重写Call方法,封装要做的事,和要返回的数据结果
  2. 把Callable类型的对象封装成FutureTask(线程任务对象)
  3. 把线程任务对象交给Thread对象
  4. 调用start方法启动线程
  5. 线程执行完毕后,通过FutureTask对象的get方法去获取线程任务执行的结果
public class ThreadTest3 {public static void main(String[] args) throws Exception {//3.创建一个Callable对象Callable<String> callable  = new MyCallable(100);//4.把Callable对象封装成一个FutureTask对象//未来任务对象//1.是一个任务对象,实现了Runnable接口//2.可以在线程执行完毕之后,用未来任务对象调用get方法获取线程完毕后的结果FutureTask<String> futureTask = new FutureTask(callable);new Thread(futureTask).start();//6.获取线程执行完毕后的结果System.out.println(futureTask.get());}
}

//1.让这个类实现Callable接口
public class MyCallable implements Callable {private int n;public MyCallable(int n) {this.n = n;}//2.重写call方法//求1-n的和int sum = 0;@Overridepublic String call() throws Exception {for (int i = 1; i <=n; i++) {sum=sum+i;}return "线程求出了1-n的和是:"+sum;}
}

线程的方法

public class MyThread extends Thread{public MyThread(String name) {super(name);}@Overridepublic void run(){Thread m = Thread.currentThread();for (int i = 0; i < 3; i++) {System.out.println(m.getName()+"子线程输出:"+i);}}
}

public class ThreadTest1 {public static void main(String[] args) {Thread t1 = new MyThread("一号线程");//设置名字
//        t1.setName("一号线程");t1.start();System.out.println(t1.getName());//构造器设置名字Thread t2 = new MyThread("二号线程");t2.start();System.out.println(t2.getName());//主线程对象的名字Thread m = Thread.currentThread();//那个线程执型它,他就会得到哪个对象System.out.println(m.getName());for (int i = 0; i < 4; i++) {System.out.println("main线程输出:"+i);}}
}

//sleep  join   的作用
public class ThreadTest2 {public static void main(String[] args) throws Exception {for (int i = 0; i < 5; i++) {//到3的时候休眠五秒if(i==3){Thread.sleep(5000);}System.out.println(i);}//join方法的作用:让调用这个方法的线程先执行完Thread t1 = new MyThread("1号线程");t1.start();t1.join();Thread t2 = new MyThread("2号线程");t2.start();t2.join();Thread t3 = new MyThread("3号线程");t3.start();Thread t4 = new MyThread("4号线程");t4.start();}
}

线程安全问题

加锁:每次只允许一个线程加锁,加锁后才能访问进入,访问完毕后自动解锁,然受其他线程才能在加锁进来

同步代码块
synchronized (同步锁){访问共享资源的核心代码
}
同步锁的注意事项
  • 对于当前同时执行的线程来说,同步锁必须是同一把(同一个对象),否则会出bug
  • 建议使用共享资源作为锁对象,对于实例方法建议使用this作为锁对象
  • 对于静态方法使用字节码(类名.class)对象作为锁对象
public class Account {private String id;//卡号private double money;//余额public Account() {}public Account(String id, double money) {this.id = id;this.money = money;}public String getId() {return id;}public void setId(String id) {this.id = id;}public double getMoney() {return money;}public void setMoney(double money) {this.money = money;}public void drawMoney(int i) {//先搞清楚是谁来取钱String name = Thread.currentThread().getName();//1判断余额是否足够//this 正好可以代表共享资源synchronized (this) {if(this.money>=i){System.out.println(name+"来取钱"+i+"成功");this.money-=i;System.out.println(name+"取钱后,余额是"+this.money);}else{System.out.println(name+"来取钱:余额不足");}}}
}

public class DrawThread extends Thread{private Account acc;public  DrawThread(Account acc, String name){super(name);this.acc = acc;}@Overridepublic void run(){//取钱acc.drawMoney(100000);}
}
public class ThreadTest {public static void main(String[] args) {//创建一个账户对象Account acc = new Account("123456",100000);//2.创建两个线程分别代表小明小红,再去同一个账户中取钱new DrawThread(acc,"小明").start();//小明new DrawThread(acc,"小红").start();//小红}
}
同步方法

作用:把访问共享核心资源的核心方法给上锁,以此保证线程安全

  • 如果是实例方法,同步方法默认使用this作为所得对象
  • 如果方法是静态方法,同步方法默认使用类名.class作为所得对象
修饰符 synchronized 返回值类型 方法名称(形参列表){
操作共享资源的代码
}
 public synchronized void drawMoney(int i) {//先搞清楚是谁来取钱String name = Thread.currentThread().getName();//1判断余额是否足够if(this.money>=i){System.out.println(name+"来取钱"+i+"成功");this.money-=i;System.out.println(name+"取钱后,余额是"+this.money);}else{System.out.println(name+"来取钱:余额不足");}}
lock锁
package d4_thread_synchronized;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Account {private String id;//卡号private double money;//余额//创建了一个锁对象private final Lock lk = new ReentrantLock();public Account() {}public Account(String id, double money) {this.id = id;this.money = money;}public String getId() {return id;}public void setId(String id) {this.id = id;}public double getMoney() {return money;}public void setMoney(double money) {this.money = money;}public void drawMoney(int i) {//先搞清楚是谁来取钱String name = Thread.currentThread().getName();lk.lock();try {//1判断余额是否足够if(this.money>=i){System.out.println(name+"来取钱"+i+"成功");this.money-=i;System.out.println(name+"取钱后,余额是"+this.money);}else{System.out.println(name+"来取钱:余额不足");}} catch (Exception e) {throw new RuntimeException(e);} finally {lk.unlock();}}
}

线程池

计算密集型的任务:核心线程数量 = CPU的核数 + 1

IO密集型的任务: 核心线程数量 = CPU的核数 * 2

创建线程池对象
1. 方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

临时线程什么时候创建

  • 新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程

什么时候开始拒绝新任务

  • 核心线程和临时线程都在忙,任务队列也满了,新的任务过来时才会开始拒绝任务
public ThreadPoolExecutor(int corePoolSize,  //指定线程池的核心线程数量int maximumPoolSize,  //指定线程池的最大线程数量long keepAliveTime,  //制定临时线程的存活时间TimeUnit unit,  //指定临时线程的存活的时间单位(秒,分,时,天)BlockingQueue<Runnable> workQueue,  //指定线程池的任务队列ThreadFactory threadFactory,  //指定线程池的线程工厂RejectedExecutionHandler handler  //指定线程池的任务拒绝策略(线程都在忙,任务队列也满了的时候,新任务来了该怎么处理)) {}
ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
2. 方式二:使用Executors(线程池的工具类)调用方法返回特点的线程池对象
package d6_threadPoolExecutor;import d1_create_thread.MyCallable;import java.util.concurrent.*;public class ThreadPoolTest3 {public static void main(String[] args) throws Exception {//通过Executors创建一个线程池对象ExecutorService pool = Executors.newFixedThreadPool(3);//使用线程处理Callable任务Future<String> f1 = pool.submit(new d1_create_thread.MyCallable(100));Future f2 = pool.submit(new d1_create_thread.MyCallable(200));Future f3 = pool.submit(new d1_create_thread.MyCallable(300));Future f4 = pool.submit(new d1_create_thread.MyCallable(400));Future f5 = pool.submit(new MyCallable(500));System.out.println(f1.get());System.out.println(f2.get());System.out.println(f3.get());}
}
线程池处理Runnable任务
package d6_threadPoolExecutor;import java.util.concurrent.*;public class ExecutorTest1 {public static void main(String[] args) {ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());MyRunnable target = new MyRunnable();pool.execute(target); //线程池会自动创建一个新线程,自动处理这个任务,自动执行pool.execute(target);//线程池会自动创建一个新线程,自动处理这个任务,自动执行pool.execute(target);//线程池会自动创建一个新线程,自动处理这个任务,自动执行pool.execute(target);//复用前面的线程pool.execute(target);//复用前面的线程pool.shutdown();//等待线程池的任务全部执行完毕后,关闭线程池pool.shutdownNow();//立即关闭线程池,不管任务是否执行完毕}
}

package d6_threadPoolExecutor;public class MyRunnable implements Runnable{@Overridepublic void run() {//描述人物任务System.out.println(Thread.currentThread().getName()+"输出666--");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}
}
线程池处理Callable任务
package d6_threadPoolExecutor;import java.util.concurrent.Callable;//1.让这个类实现Callable接口
public class MyCallable implements Callable {private int n;public MyCallable(int n) {this.n = n;}//2.重写call方法//求1-n的和int sum = 0;@Overridepublic String call() throws Exception {for (int i = 1; i <=n; i++) {sum=sum+i;}return Thread.currentThread().getName()+"线程求出了1-n的和是:"+sum;}
}

package d6_threadPoolExecutor;import d1_create_thread.MyCallable;import java.util.concurrent.*;public class ThreadPoolTest2 {public static void main(String[] args) throws Exception {ExecutorService pool = new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());//使用线程处理Callable任务Future<String> f1 = pool.submit(new MyCallable(100));Future f2 = pool.submit(new MyCallable(200));Future f3 = pool.submit(new MyCallable(300));Future f4 = pool.submit(new MyCallable(400));Future f5 = pool.submit(new MyCallable(500));System.out.println(f1.get());System.out.println(f2.get());System.out.println(f3.get());}
}
线程的生命周期

乐观锁
package d7_tx;import java.util.concurrent.atomic.AtomicInteger;public class MyRunnable2 implements Runnable{//整数修改的乐观锁:原子类实现的private AtomicInteger number = new AtomicInteger();@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(number.incrementAndGet());}}
}

package d7_tx;public class Test2 {public static void main(String[] args) {//悲观锁,乐观锁原理//悲观锁:一上来就加锁,没有安全感,每次只能一个线程进入访问完毕后,在解锁 .线程安全,性能较差//乐观锁:一开始不上锁,认为是没有问题的,大家一起跑,要等出现线程安全问题才开始控制,线程安全,性能较好//需求:一个静态变量,100个线程,每个线程对其加100次Runnable target = new MyRunnable2();for (int i = 1; i <= 100; i++) {new Thread(target).start();}}}
悲观锁
package d7_tx;public class MyRunnable implements Runnable{private int number ;//记录浏览人次@Overridepublic void run() {for (int i = 0; i < 100; i++) {//悲观锁synchronized(this) {System.out.println(++number);}}}
}

package d7_tx;import d7_tx.MyRunnable;public class Test {public static void main(String[] args) {//悲观锁,乐观锁原理//悲观锁:一上来就加锁,没有安全感,每次只能一个线程进入访问完毕后,在解锁 .线程安全,性能较差//乐观锁:一开始不上锁,认为是没有问题的,大家一起跑,要等出现线程安全问题才开始控制,线程安全,性能较好//需求:一个静态变量,100个线程,每个线程对其加100次Runnable target = new MyRunnable();for (int i = 1; i <= 100; i++) {new Thread(target).start();}}
}

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

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

相关文章

阿里云服务器公网带宽费用全解析（不同计费模式）

阿里云服务器公网带宽费用全解析（不同计费模式）

阿里云服务器公网带宽怎么收费&#xff1f;北京地域服务器按固定带宽计费一个月23元/M&#xff0c;按使用流量计费0.8元/GB&#xff0c;云服务器地域不同实际带宽价格也不同&#xff0c;阿里云服务器网aliyunfuwuqi.com分享不同带宽计费模式下带宽收费价格表&#xff1a; 公网…
阅读更多...
集群监控原理

集群监控原理

3.1.2.集群监控原理 Sentinel基于心跳机制监测服务状态&#xff0c;每隔1秒向集群的每个实例发送ping命令&#xff1a; •主观下线&#xff1a;如果某sentinel节点发现某实例未在规定时间响应&#xff0c;则认为该实例主观下线。 •客观下线&#xff1a;若超过指定数量&…
阅读更多...
Qt 中的项目文件解析和命名规范

Qt 中的项目文件解析和命名规范

&#x1f40c;博主主页&#xff1a;&#x1f40c;​倔强的大蜗牛&#x1f40c;​ &#x1f4da;专栏分类&#xff1a;QT❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ 目录 一、Qt项目文件解析 1、.pro 文件解析 2、widget.h 文件解析 3、main.cpp 文件解析 4、widget.cpp…
阅读更多...
分享2024高校专业建设思路及建设效果

分享2024高校专业建设思路及建设效果

广东泰迪智能科技股份有限公司成立于2013年&#xff0c;是一家专业从事大数据、人工智能等数据智能技术研发、咨询和培训的高科技企业&#xff0c;公司基于十余年的数据智能产业实践经验&#xff0c;构建“产、岗、课、赛、证、文”融通的特色应用型人才培养模式&#xff0c;助…
阅读更多...
蓝桥杯（填空题）

蓝桥杯（填空题）

十四届 B组 日期统计&#xff08;暴力枚举&#xff09; 数据 5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2 7 0 5 8 8 5 7 0 9 9 1 9 4 4 6 8 6 3 3 8 5 1 6 3 4 6 7 0 7 8 2 7 6 8 9 5 6 5 6 1 4 0 1 0 0 9 4 8 0 9 1 2 8 5 0 2 5 3…
阅读更多...
力扣 | 54. 螺旋矩阵

力扣 | 54. 螺旋矩阵

注意按照顺时针方向进行访问元素&#xff0c;以及每次触发的条件只会满足一个&#xff01; public List<Integer> spiralOrder(int [][] matrix){List<Integer> result new ArrayList<>();int m matrix.length;int n matrix[0].length;int row0,col 0;//…
阅读更多...
python毕业设计django游泳馆管理系统-flask

python毕业设计django游泳馆管理系统-flask

游泳馆管理系统具有信息管理功能的选择。游泳馆管理系统采用python技术&#xff0c;基于mysql开发&#xff0c;实现了首页&#xff0c;教练信息&#xff0c;培训信息&#xff0c;交流版块&#xff0c;活动公告&#xff0c;个人中心&#xff0c;后台管理等内容进行管理&#xff…
阅读更多...
计算机毕业设计 工厂车间设备管理系统php+vue.js

计算机毕业设计 工厂车间设备管理系统php+vue.js

该系统是以PHP为主要开发语言&#xff0c;集合MySQL数据库技术构建基于Web的以信息为目标的&#xff0c;动态的交互平台 PHP与Apache&#xff0c;MySQL的组合虽然有着诸多优势&#xff0c;但三种出自不同作者的开源软件要能很好的配合工作&#xff0c;需要很多手工配置&#x…
阅读更多...
WordPress JS Support Ticket插件 RCE漏洞复现

WordPress JS Support Ticket插件 RCE漏洞复现

0x01 产品简介 WordPress和WordPress plugin都是WordPress基金会的产品。JS Support Ticket是使用在其中的一套开源票务系统插件。 0x02 漏洞概述 WordPress中的JS Support Ticket插件存在未经上传漏洞，未经身份验证的攻击者可以上传恶意脚本的服务器，执行任意指令，从而获…
阅读更多...
【JavaEE初阶系列】——网络编程 TCP客户端/服务器 程序实现

【JavaEE初阶系列】——网络编程 TCP客户端/服务器 程序实现

目录 &#x1f6a9;TCP流套接字编程 &#x1f36d;ServerSocket API &#x1f36d;Socket API &#x1f36d;TCP服务器 &#x1f36d;TCP客户端 &#x1f6a9;TCP流套接字编程 俩个关键的类 ServerSocket (给服务器使用的类&#xff0c;使用这个类来绑定端口号&#xff0…
阅读更多...
C语言程序与设计——工程项目开发

C语言程序与设计——工程项目开发

之前我们已经了解了C语言的基础知识部分&#xff0c;掌握这些之后&#xff0c;基本就可以开发一些小程序了。在开发时&#xff0c;就会出现合作的情况&#xff0c;C语言是如何协作开发的呢&#xff0c;将在这一篇文章进行演示。 工程项目开发 在开发过程中&#xff0c;你接到…
阅读更多...
【算法每日一练]-图论(lca) 最近公共祖先LCA，货车运输

【算法每日一练]-图论(lca) 最近公共祖先LCA，货车运输

目录 P3379&#xff1a;最近公共祖先LCA 思路&#xff1a; 货车运输 P3379&#xff1a;最近公共祖先LCA 思路&#xff1a; 首先进行的预处理&#xff0c;将所有点的深度和p数组求出来 设置&#xff1a;p[i][j]存的从i向上走2的j次方那么长的路径到的父节点 更深的点走到和…
阅读更多...
PostgreSQL入门到实战-第二十二弹

PostgreSQL入门到实战-第二十二弹

PostgreSQL入门到实战 PostgreSQL中表连接操作(六)官网地址PostgreSQL概述PostgreSQL中self-join命令理论PostgreSQL中self-join命令实战更新计划 PostgreSQL中表连接操作(六) 使用PostgreSQL自联接技术来比较同一表中的行 官网地址 声明: 由于操作系统, 版本更新等原因, 文…
阅读更多...
内存函数memcpy、mommove、memset、memcmp

内存函数memcpy、mommove、memset、memcmp

1、memcpy函数 描述&#xff1a; C 库函数 void *memcpy(void *str1, const void *str2, size_t n) 从存储区 str2 复制 n 个字节到存储区 str1。 声明&#xff1a; void *memcpy(void *str1, const void *str2, size_t n)参数&#xff1a; str1 -- 指向用于存储复制内容的目标…
阅读更多...
【电控笔记0】稳定度判断

【电控笔记0】稳定度判断

简要概括 现控：原理虚轴，稳定度越高 自控：相位裕度PM 增益裕度GM 开环传函 不稳定条件判断
阅读更多...
期望阻抗（Zd/s或Yd*s）的nyquist、bode与rlocus

期望阻抗（Zd/s或Yd*s）的nyquist、bode与rlocus

在机器人控制领域中&#xff0c;针对具体的阻抗参数特性&#xff08;如质量、阻尼和刚度&#xff09;&#xff0c;Nyquist图、Bode图和根轨迹&#xff08;rlocus&#xff09;可以提供深入的分析和设计工具。 Nyquist图&#xff1a; 应用于阻抗参数&#xff1a;在机器人控制中&…
阅读更多...
docker pull镜像的时候指定arm平台

docker pull镜像的时候指定arm平台

指定arm平台 x86平台下载arm平台的镜像包 以mysql镜像为例 docker pull --platform linux/arm64 mysqldocker images查看镜像信息 要查看Docker镜像的信息&#xff0c;可以使用docker inspect命令。这个命令会返回镜像的详细信息&#xff0c;包括其元数据和配置。 docker i…
阅读更多...
Fast-lio2运行时如何显示轨迹线

Fast-lio2运行时如何显示轨迹线

修改对应设备的.yaml文件&#xff0c;以velodyne为例&#xff1a; 将 path_en参数改为true即可&#xff0c;运行其他设备&#xff0c;修改对应的参数
阅读更多...
四、SpringBoot3 整合 Druid 数据源

四、SpringBoot3 整合 Druid 数据源

本章概要 创建程序引入依赖启动类配置文件编写编写 Controller启动测试问题解决 4.1 创建程序 4.2 引入依赖 <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0"xmlns:xsi"http://ww…
阅读更多...
【C++ STL序列容器】deque 双端队列

【C++ STL序列容器】deque 双端队列

文章目录 【 1. 基本原理 】【 1. deque 的创建 】1.1 创建一个空的 deque1.2 创建一个 n 个默认值的 deque1.3 创建一个 n 个指定值的 deque1.4 通过一个 deque 初始化另一个 deque1.5 通过基础容器来初始化 queue 容器适配器 【 3. deque 支持的成员函数 】 【 1. 基本原理 】…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023