多线程（续）

最新推荐文章于 2024-09-13 17:30:19 发布
最新推荐文章于 2024-09-13 17:30:19 发布
阅读量75 收藏
点赞数
文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45710673/article/details/114809300
版权

大家好，今天继续多线程！这期是和上一期连接起来的，大家可以连着看！

  • 方法三：实现Callable接口（目前了解即可）
  1. 实现Callable接口，需要返回值类型。
  2. 重写call方法，需要抛出异常。
  3. 创建目标对象。
  4. 创建执行服务：ExecutorService service = Executors.newFixedThreadPool(1);
  5. 提交执行：Future result = service.submit(t1);
  6. 获取结果：boolean r1 = result.get();
  7. 关闭服务：service.shutdownNow();
public class CallableProject implements Callable<Boolean> {
	private String urlString;
	private String nameString;
	public CallableProject(String urlString, String nameString) {
		super();
		this.urlString = urlString;
		this.nameString = nameString;
	}
	@Override
	public Boolean call() throws Exception {
		PictureLoader1 pictureLoader = new PictureLoader1();
		pictureLoader.load(urlString, nameString);
		System.out.println("已下载图片到文件:"+nameString);
		return true;
	}
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CallableProject picturesLoad1 = new CallableProject("https://img-blog.csdn.net/20180531234717825?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjM4MDYx/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70", "p1.jpg");
		CallableProject picturesLoad2 = new CallableProject("https://img-blog.csdn.net/20180531234216145?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjM4MDYx/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70", "p2.jpg");
		CallableProject picturesLoad3 = new CallableProject("https://img-blog.csdn.net/20180531234329372?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjM4MDYx/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70", "p3.jpg");
		CallableProject picturesLoad4 = new CallableProject("https://img-blog.csdn.net/20180531234601650?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjM4MDYx/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70", "p4.jpg");
		ExecutorService service = Executors.newFixedThreadPool(4);
		Future<Boolean> result1 = service.submit(picturesLoad1);
		Future<Boolean> result2 = service.submit(picturesLoad2);
		Future<Boolean> result3 = service.submit(picturesLoad3);
		Future<Boolean> result4 = service.submit(picturesLoad4);
		boolean r1 = result1.get();
		boolean r2 = result2.get();
		boolean r3 = result3.get();
		boolean r4 = result4.get();
		service.shutdownNow();
	}
}
//下载器
class PictureLoader1 {
	//下载方法
	public void load(String purl, String fname) {
		try {
			FileUtils.copyURLToFile(new URL(purl), new File(fname));
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("图片下载异常");
		}
	}
}
三、静态代理模式
  • 你：真实角色
  • 婚庆公司：代理你，帮你处理结婚的事
  • 都实现结婚借口即可
  • 好处：代理对象可以做真实对象做不了的事情；真实对象只需要做好自己的事情就好。
public class Marry {
	public static void main(String[] args) {
		new weddingCompany(new newPerson()).marry();
	}
}
interface marry {
	void marry();
}
class newPerson implements marry {
	public void marry() {
		System.out.println("我要结婚了！！！");
	}
}
class weddingCompany implements marry {
	private newPerson person;
	public weddingCompany(newPerson nPerson) {
		this.person = nPerson;
	}
	public void marry() {
		befor();
		person.marry();
		after();
	}
	void befor() {
		System.out.println("结婚之前要布置现场");
	}
	void after() {
		System.out.println("结婚之后要收尾款");
	}
}
三、Lamda表达式(函数式编程)
  • 避免匿名内部类太多
  • 可以让你的代码看起很简洁
  • 去掉没用的代码，只留下核心逻辑
  1. 函数式接口
    • 只有一个抽象方法的接口，叫做函数式接口。
public interface Runnable {
	public abstract void run();
}
  • 我们可以通过Lamda表达式来创建该函数式接口的对象。
  1. 案例（通过各种内部类）
先写一个接口，再写一个实现该接口的类，然后调用他们
public class LamdaExpression {
	public static void main(String[] args) {
		imLam im = new imLamd();
		im.speak();
	}
}
interface imLam {
	void speak();
}
class imLamd implements imLam {
	@Override
	public void speak() {
		System.out.println("我不想说话");
	}
}
觉得很麻烦，就改装成为静态内部类，写在类里面的静态类
public class LamdaExpression {
	public static void main(String[] args) {
		imLam im = new imLamd();
		im.speak();
	}
	static class imLamd implements imLam {
		@Override
		public void speak() {
			System.out.println("我不想说话");
		}
	}
}
interface imLam {
	void speak();
}
还是觉得很麻烦，就改成了局部内部类，写在方法里的类
public class LamdaExpression {
	public static void main(String[] args) {
		class imLamd implements imLam {
			@Override
			public void speak() {
				System.out.println("我不想说话");
			}
		}
		imLam im = new imLamd();
		im.speak();
	}
}
interface imLam {
	void speak();
}
依然觉得很麻烦，再次改成匿名内部类，｛｝，没有类名，必须借助接口或者父类
public class LamdaExpression {
	public static void main(String[] args) {
		imLam i = new imLam() {
			@Override
			public void speak() {
				System.out.println("我不想说话");
			}
		};
		i.speak();
	}
}
interface imLam {
	void speak();
}
还是觉得很麻烦，于是，就演变成为了使用Lamda表达式来表示
public class LamdaExpression {
	public static void main(String[] args) {
		imLam i = ()->{
			System.out.println("我不想说话");
		};
		i.speak();
	}
}
interface imLam {
	void speak();
}
  • 接口对象 = 参数值【值，不加类型】->函数主体；
  • 一个参数和多个函数代码行，就需要加括号和花括号；
四、线程状态

在这里插入图片描述
在这里插入图片描述

  1. 线程方法
  • setPriority(int newPriority) 更改线程先级
  • static void sleep(long millis) 在指定的毫秒数内让正在执行的线程休眠
  • void join() 等待线程终止
  • static void yield() 暂停当前执行的线程，并执行其他线程
  • void interrupt() 中断线程，别用这个方式
  • boolean isAlive() 测试线程是否处于活跃状态
  1. 停止线程
  • 不推荐使用JDK提供的stop()、destory()方法。他们已经废弃
  • 推荐让线程自己停下来。
  • 建议使用一个标志位终止变量。
    在这里插入图片描述
  1. 线程休眠sleep
  • sleep指定当前线程堵塞的毫秒数
  • sleep存在异常InterruptedException
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延迟，倒计时
  • 每个对象都有一个锁，sleep不会释放锁
倒计时每秒
public class daoTime {
	public static void main(String[] args) {
		run();
	}
	public static void tenTime() {
		int num=10;
		while(true) {
			new Thread().sleep(1000);
			System.out.println(num--);
			if(num<=0) {
				break;
			}
		
		}
	
	}
}
按秒输出时间
public class TimeProject {
	public static void main(String[] args) {
		Date s = new Date(System.currentTimeMillis());
		while(true) {
			Thread.sleep(1000);
			System.out.println(new SimpleDateFormate("HH:mm:ss").format(s);
			s = new Date(System.currentTimeMillis());
		}
	}
}
  1. 线程礼让yield
  • 礼让线程，让当前正在执行的线程暂停，但不堵塞
  • 将线程从运行状态转为就绪状态
  • *让CPU重新调度，礼让不一定成功，看CPU心情！！
public class TestYield {
	public static void main(String[] args) {
		myYield m = new myYield();
		new Thread(m,"a").start();
		new Thread(m,"b").start();
	}
}
class myYield {
	@Override
	public void run() {
		System.out.println(Thread.currentThread() + "线程开始执行");
		Thread.yield();
		System.out.println(Thread.currentThread() + "线程结束");
	}
}

public class MyYieldTest extends Thread {
	public static void main(String[] args) {
		MyYieldTest myYieldTest = new MyYieldTest();
		new Thread(myYieldTest,"a").start();
		new Thread(myYieldTest,"b").start();
	}
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"线程开始执行");
		Thread.yield();
		System.out.println(Thread.currentThread().getName()+"线程已经结束");
	}
}
  1. 线程强制执行join（join合并线程，待此线程执行完成后，再执行其他线程，其他线程堵塞！）
public class TestJoin implements Runnable {
	@Override
	public void run() {
		for(int i=0; i<1000; i++) {
			System.out.println("vip来了" + i);
		}
	}
	public static void main(String[] args) throws InterruptedException {
		Thread thread = new Thread(new TestJoin());
		thread.start();
		for(int j=0; j<100; j++) {
			if(j==30) {
				thread.join();
			}
			System.out.println("main方法"+j);
		}
	}
}
  1. 线程状态观测
    新生 就绪 运行 阻塞/死亡
public class ThState {
	public static void main(String[] args) throws InterruptedException {
		Thread thread = new Thread(()->{
			for(int i=0; i<5; i++) {
				try {
					Thread.sleep(19);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("^^^^^^^^");
		});
		//观察状态
		Thread.State state = thread.getState();
		System.out.println(state);
		//观察启动后
		thread.start();
		state = thread.getState();
		System.out.println(state);//Run
		//只要线程不终止，就一直输出状态
		while(state != thread.getState().TERMINATED) {
			Thread.sleep(100);
			state = thread.getState();//更新线程状态
			System.out.println(state);
		}
	}
}
  1. 线程优先级(控制CPU）
    getPriority()
    setPriority(int xxx)
    优先级默认是5，最高是10
    优先级高可能先跑，但不是一定的，这都是看CPU的心情
public class ThPropertiesTest implements Runnable {
	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
		ThPropertiesTest t = new ThPropertiesTest();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.setPriority(4);
		t2.start();
		t3.setPriority(8);
		t3.start();
		t4.setPriority(2);
		t4.start();
	}
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
	}
}
  1. 守护线程（daemon）
  • 用户线程和守护线程
  • 虚拟机必须保护用户线程执行完毕main
  • 虚拟机不用等待守护线程执行完毕gc
  • 如：后台记录操作日志、监控内存、垃圾回收…
  • deamon=false。示为用户线程；true为守护线程；一般都为用户线程。
上帝守护着你
public class TsetDeamon {
	public static void main(String[] args) {
		god g = new god();
		You y = new You();
		Thread thread = new Thread(g);
		thread.setDaemon(true);
		thread.start();
		new Thread(y).start();
	}
}
//上帝
class god implements Runnable {
	@Override
	public void run() {
		while(true) {
			System.out.println("上帝会永远守护着你");
		}
	}
}
//你
class You implements Runnable {
	@Override
	public void run() {
		for(int year=0; year<50; year++) {
			System.out.println("我今年" + year + "岁");
		}
		System.out.println("拜拜了您嘞");
	}
}
Angle.code
关注
Java多线程面试题之如何让主线程等子线程执行完之后再执行
b521626的博客
11-06 9514
问题描述 现在有一个主线程X，和两个子线程A和B，A和B之间没有依赖关系且两者的执行时间不确定，现在要求如下： 1：不限制A和B执行顺序的 2：主线程X需要在子线程A和B执行完成之后再执行 方案1 1）思路 使用join()方法实现 2）代码实现 先定义一个线程A，代码如下： public class ThreadA implements Runnable {` public void r...
五线舵机驱动程序_16路舵机驱动板程序使用说明
weixin_34931370的博客
01-14 4829
用Arduino类库驱动舵机并不是一件难事，如果需要驱动很多电机，就需要要占用更多的引脚，也会影响到Arduino的处理能力。专门的舵机驱动板很好的解决了这个问题。此舵机驱动板使用PCA9685芯片，是16通道12bi tPWM舵机驱动，用12个弓|脚通过I2C就可以驱动16个舵机。不仅如此，你还可以通过级联的方式最多级联62个驱动板，总共可以驱动992个舵机！供电部分大多数的舵机设计电压都是在5...
多线程执行完后主程序再执行（包括需要子线程返回结果）
博“文”强识
05-23 1127
1.这是中间变量c，a线程向容器中添加数据，b线程执行其他，在主线程判断c是否为空 //判断是否读取完毕  while(true){   if(ShareData.isFinish()) {    break ;   }  } 注：此方法，需要知道a线程执行的速度与c线程执行的速度快慢，必须是a的速度大于b的速度   2.使用线程阻塞方法join  public static void ...
【多线程】学习记录七种主线程等待子线程结束之后在执行的方法
Wan_Yuan的博客
10-19 1363
最近遇到一个问题需要主线程等待所有的子线程结束，才能开始执行，统计所有的子线程执行结果，返回，网上翻阅各种资料，最后记录一下，找到七种方案 第一种：while循环 对于“等待所有的子线程结束”的问题，最开始想到的是使用while循环进行轮询： //开始计时 String start = getTheTimeInMilliseconds(); System.out.println("start = " + start); Thread t = n
多线程-线程池执行多线程，如何保证线程执行完成后再执行下面的业务逻辑
天道酬勤
04-19 4496
public static void main(String[] args) throws ExecutionException, InterruptedException { ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 3, 60L, TimeUnit.SECONDS, new LinkedBlockingDeque&...
java如何在多线程执行完成后再执行某个方法
whj826069748的博客
06-29 1万+
package com.whj.feign.client; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicInteger; public class Test1 { public s...
微信小程序开发流程
我的博客简介
07-20 2万+
新建项目选择小程序项目，选择代码存放的硬盘路径，填入刚刚申请到的小程序的AppID，给你的项目起一个好听的名字，勾选“不使用云服务”（注意你要选择一个空的目录才可以创建项目），点击新建，你就得到了你的第一个小程序了，点击顶部菜单编译就可以在微信开发者工具中预览你的第一个小程序。用户只需要点击一键登录，就可以做到登录，无需另外多出弹框，提示用户授权，之所以弹出框是为了获取更多的用户信息，如想获取手机号，一个用户手机号可以存在多个，但是用户openid是唯一的，参考线上小程序。.........
天气微信小程序源码，附上线教程
李勇康的博客
04-13 3692
博主之前发布过一篇文章，微信小程序源码合集500套。不少友友反馈很多都用不了，这里博主给大家道个歉，因为博主也是花钱网上收集到的源码，来给大家免费下载，内容之多也不可能一个个去测试它的可用性。而且博主发现很多对小程序感兴趣的朋友连怎么发布代码都不知道，下面博主就呕心沥血写下这篇博文，从入门到上线，抛砖引玉，讲述这款天气查询小程序的发布过程。 首先看看真机调试效果吧 PS：文尾附有源码安装包 上线过程 注册微信小程序 前往“微信公众平台”，按照步骤注册微信小程序账号即可，注册完之后会有一个app
零基础入门微信小程序开发
热门推荐
GitChat
07-03 34万+
本课程是一个系列入门教程，目标是从 0 开始带领读者上手实战，课程以微信小程序的核心概念作为主线，介绍配置文件、页面样式文件、JavaScript 的基本知识并以指南针为例对基本知识进行扩展，另外加上开发工具的安装、小程序发布等内容，共 9 篇文章。
微信小程序 | 小程序开发
CoderHing的博客~
11-22 1万+
事实上,目前小程序在我们生活中已经随处可见（特别是这次疫情的推动，不管是什么岗位、什么年龄阶段的人，到哪都需要打开健康码）WePY是由腾讯开源的，一款让小程序支持组件化开发的框架，通过预编译的手段让开发者可以选择自己喜欢的开发风格去开发小程序。Mpvue是一个使用Vue开发小程序的前端框架，也是 支持 微信小程序、百度智能小程序，头条小程序 和 支付宝小程序；微信小程序、支付宝小程序、淘宝小程序、抖音小程序、头条小程序、QQ小程序、美团小程序等。，其他平台的小程序往往是平台本身的一些公司或者顺手开发的。
多段线合并程序
11-20
解决autcad 中多条多段线合并问题
西门子1500汽车生产线程序以及说明
12-30
西门子1500汽车生产线程序是一套基于西门子SIMATIC S7-1500 PLC（可编程逻辑控制器）的自动化解决方案，用于控制和优化汽车制造过程中的生产线。该程序集成了先进的控制算法和高效的数据管理，旨在提高生产效率、...
小程序多业务线融合【完整分包业务接入】
03-29
这些小程序，由一个主小程序和后来新建的多条业务线构成（每条业务线拥有独立的小程序） 各业务线的小程序需要挂载到主程序下面，因为需要主程序导流 同时各业务线自己的小程序也照常发布更新 ==一套代码，通过打包...
python实现车道线识别程序
11-22
5. **线段合并**：检测到的可能是多段线，需要根据车道线的预期特性（如连续性、平行性）进行合并，得到完整的车道线。 6. **结果叠加**：最后，将识别出的车道线以彩色形式叠加回原图像上，以便于可视化和理解。 ...
spring事务详细讲解-深入浅出
小电玩
09-08 507
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1491
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
最新发布
ClaireCheney的博客
09-13 89
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 559
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 591
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
C语言实现的变幻线程序示例
“变幻线程序是使用C语言在VC6+EasyX图形库环境下实现的一种动态图形效果。程序通过定义结构体和类来管理线条的移动和变化，创建出视觉上不断变化的效果。” 在这个程序中，核心概念是“变幻线”，它涉及到C语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值