多线程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，一经查实，立即删除！

相关文章

程序的预处理

程序的预处理

为了方便编程&#xff0c;编译器一般为开发人员提供一些预处理命令&#xff0c;使用&#xff03;标识。我们常见的预处理命令如下。 头文件的包含:#include.定义一些宏#define件编译&#xff1a;&#xff03;if、&#xff03;else、&#xff03;endif。编译控制&#xff1a;&a…
阅读更多...
阿里云服务器公网带宽费用全解析（不同计费模式）

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

阿里云服务器公网带宽怎么收费&#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蓝桥杯省赛保奖突击班-单调栈、模拟、简单dp_练习题解

2024蓝桥杯省赛保奖突击班-单调栈、模拟、简单dp_练习题解

P1449 后缀表达式 题目链接: P1449 参考思路&#xff1a; 如果遇到的字符是数字&#xff0c;则将连续的数字转成整数&#xff0c;并把操作数后面的"."过滤掉&#xff1b;如果遇到是字符是运算符&#xff0c;则取出操作数栈栈顶的两个元素进行计算&#xff0c;并把…
阅读更多...
分享2024高校专业建设思路及建设效果

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

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

Unity3D 打空包与远程资源更新详解

前言 在游戏开发过程中&#xff0c;打包和远程资源更新是非常重要的步骤&#xff0c;本文将详细介绍Unity3D中如何进行打空包和远程资源更新。 对惹&#xff0c;这里有一个游戏开发交流小组&#xff0c;希望大家可以点击进来一起交流一下开发经验呀&#xff01; 一、打空包 …
阅读更多...
蓝桥杯（填空题）

蓝桥杯（填空题）

十四届 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…
阅读更多...
深入理解Linux网络工具：netstat命令的高级应用

深入理解Linux网络工具：netstat命令的高级应用

在Linux系统中&#xff0c;网络管理员经常需要监控和诊断网络连接问题。netstat命令是一个非常强大的工具&#xff0c;它可以显示系统上的网络连接、路由表、接口统计等信息。本文将深入探讨netstat命令的两个常用选项组合&#xff1a;-tlnp和-tnp&#xff0c;并解释它们的区别…
阅读更多...
力扣 | 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;//…
阅读更多...
构建第一个ArkTS之声明式UI描述

构建第一个ArkTS之声明式UI描述

ArkTS以声明方式组合和扩展组件来描述应用程序的UI&#xff0c;同时还提供了基本的属性、事件和子组件配置方法&#xff0c;帮助开发者实现应用交互逻辑。 创建组件 根据组件构造方法的不同&#xff0c;创建组件包含有参数和无参数两种方式。 说明 创建组件时不需要new运算…
阅读更多...
【4】c++多线程技术之高级线程同步技术

【4】c++多线程技术之高级线程同步技术

1、读写锁&#xff08;std::shared_mutex&#xff09;&#xff08;C17&#xff09; 读写锁&#xff08;std::shared_mutex&#xff09;是C17中引入的一种同步原语&#xff0c;用于允许多个线程同时读取共享数据&#xff0c;但在写入数据时只允许一个线程进行操作。这种锁可以提…
阅读更多...
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…
阅读更多...
队列.....

队列.....

假设以带头结点的循环链表表示队列&#xff0c;并且只设一个指针指向队尾结点&#xff0c;但不设头指针。试设计相应的入队和出队算法。 #include <stdio.h> #include <stdlib.h>#define ERROR -1 #define OK 0typedef int QElemType; // 假设队列中元素类型为 in…
阅读更多...
WordPress JS Support Ticket插件 RCE漏洞复现

WordPress JS Support Ticket插件 RCE漏洞复现

0x01 产品简介 WordPress和WordPress plugin都是WordPress基金会的产品。JS Support Ticket是使用在其中的一套开源票务系统插件。 0x02 漏洞概述 WordPress中的JS Support Ticket插件存在未经上传漏洞，未经身份验证的攻击者可以上传恶意脚本的服务器，执行任意指令，从而获…
阅读更多...
【chatGPT】我：在Cadence Genus软件中，出现如下问题：......【4】

【chatGPT】我：在Cadence Genus软件中，出现如下问题：......【4】

我 在Cadence Genus中&#xff0c;tcl代码为&#xff1a;foreach clk $clk_list{ set clkName [lindex $clk_list 0] set targetFreq [lindex $clk_list 1] set uncSynth [lindex $clk_list 4] set clkPeriod [lindex “%.3f” [expr 1 / $targetFreq]] … } 以上代码出现如下…
阅读更多...
【JavaEE初阶系列】——网络编程 TCP客户端/服务器 程序实现

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

目录 &#x1f6a9;TCP流套接字编程 &#x1f36d;ServerSocket API &#x1f36d;Socket API &#x1f36d;TCP服务器 &#x1f36d;TCP客户端 &#x1f6a9;TCP流套接字编程 俩个关键的类 ServerSocket (给服务器使用的类&#xff0c;使用这个类来绑定端口号&#xff0…
阅读更多...
设计模式：命令模式

设计模式：命令模式

命令模式&#xff08;Command Pattern&#xff09;是一种行为设计模式&#xff0c;它将一个请求封装为一个对象&#xff0c;从而使你可用不同的请求对客户进行参数化&#xff1b;对请求排队或记录请求日志&#xff0c;以及支持可撤销的操作。 定义 命令模式包括以下主要角色&…
阅读更多...
C语言程序与设计——工程项目开发

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

之前我们已经了解了C语言的基础知识部分&#xff0c;掌握这些之后&#xff0c;基本就可以开发一些小程序了。在开发时&#xff0c;就会出现合作的情况&#xff0c;C语言是如何协作开发的呢&#xff0c;将在这一篇文章进行演示。 工程项目开发 在开发过程中&#xff0c;你接到…
阅读更多...
最新文章

Copyright @ 2022~2023