java第二十天

最新推荐文章于 2024-08-22 22:18:22 发布
最新推荐文章于 2024-08-22 22:18:22 发布
阅读量151 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChenMH1112/article/details/108932155
版权

线程间的通信方法

在这里插入图片描述

1. 线程通信简介

一般而言，在一个应用程序（即进程）中，一个线程往往不是孤立存在的，常常需要和其它线程通信，以执行特定的任务。如主线程和次线程，次线程与次线程，工作线程和用户界面线程等。这样，线程与线程间必定有一个信息传递的渠道。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的。线程间的通信涉及到4个问题：

  1. 线程间如何传递信息；
  2. 线程之间如何同步，以使一个线程的活动不会破坏另一个线程的活动，以保证计算结果的正确合理；
  3. 当线程间具有依赖关系时，如何调度多个线程的处理顺序；
  4. 如何避免死锁问题。

在windows系统中，线程间的通信一般采用四种方式：全局变量方式、消息传递方式、参数传递方式和线程同步法。

2. 全局变量方式

由于属于同一个进程的各个线程共享操作系统分配该进程的资源，故解决线程间通信最简单的一种方法是使用全局变量。对于标准类型的全局变量，我们建议使用volatile修饰符，它告诉编译器无需对该变量作任何的优化，即无需将它放到一个寄存器中，并且该值可被外部改变。

实例演示：该实例采用全局变量来控制时间显示线程的显示格式，比较简单。

3. 参数传递方式

该方式是线程通信的官方标准方法，多数情况下，主线程创建子线程并让其子线程为其完成特定的任务，主线程在创建子线程时，可以通过传给线程函数的参数和其通信，三类创建线程的函数都支持参数的传递（哪三类？看前面的介绍吧!）。所传递的参数是一个32位的指针，该指针不但可以指向简单的数据，而且可以指向结构体或类等复杂的抽象数据类型。

4. 消息传递方式

在Windows程序设计中，应用程序的每一个线程都拥有自己的消息队列，甚至工作线程也不例外，这样一来，就使得线程之间利用消息来传递信息变的非常简单。我们可以在一个线程的执行函数中向另一个线程发送自定义的消息来达到通信的目的。一个线程向另外一个线程发送消息是通过操作系统实现的。利用Windows操作系统的消息驱动机制，当一个线程发出一条消息时，操作系统首先接收到该消息，然后把该消息转发给目标线程，接收消息的线程必须已经建立了消息循环。该方式可以实现任意线程间的通信，所以是比较常见和通用的方式。

5. 线程同步法

还可以通过线程同步来实现线程间通信。例如有两个线程，线程A写入数据，线程B读出线程A准备好的数据并进行一些操作。这种情况下，只有当线程A写好数据后线程B才能读出，只有线程B读出数据后线程A才能继续写入数据，这两个线程之间需要同步进行通信。关于线程同步的方法和控制是编写多线程的核心和难点，方法也比较多。

方式一：使用 volatile 关键字

基于 volatile关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式

方式二：使用Object类的wait() 和 notify() 方法

众所周知，Object类提供了线程间通信的方法：wait()、notify()、notifyaAl()，它们是多线程通信的基础，而这种实现方式的思想自然是线程间通信。

注意： wait和 notify必须配合synchronized使用，wait方法释放锁，notify方法不释放锁

方式三：使用JUC工具类 CountDownLatch
方式四：使用 ReentrantLock 结合 Condition
方式五：基本LockSupport实现线程间的阻塞和唤醒

LockSupport 是一种非常灵活的实现线程间阻塞和唤醒的工具，使用它不用关注是等待线程先进行还是唤醒线程先运行，但是得知道线程的名字。

1.通过实现了 创建接口对象 ReentrantLock

2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁

3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

public class RunnableImpl1 implements Runnable {

	//总票数
	private static int ticket=10;
	Object Obj=new Object();
	Lock l=new ReentrantLock();
	//设置线程任务 买票
	@Override
	public void run() {
		// TODO Auto-generated method stub
		//使用无限循环 让买票操作重复执行
		
		//1.创建lock接口的对象
		
		
		
		while (true) {
			//锁对象 任意
			//synchronized (Obj) {
				
				//extracted();
				
			//}
			
			//加锁
			l.lock();
			
			if (ticket>0) {
				try {
					Thread.sleep(10);//模拟出票的过程
					System.out.println(Thread.currentThread().getName()+"正在买第---->"+ticket+"张票");
					
					ticket--;
				} catch (Exception e) {
					// TODO: handle exception
				}
				finally {
					
					//释放锁/释放资源
					l.unlock();
				}
			}
			
		}
	}
	//非静态方法 锁的是this
	private  synchronized void extracted() {
		synchronized(this){
			
			if (ticket>0) {
				try {
					Thread.sleep(10);//模拟出票的过程
				} catch (Exception e) {
					// TODO: handle exception
				}
				System.out.println(Thread.currentThread().getName()+"正在买第---->"+ticket+"张票");
				
				ticket--;
			}
		}
	}
	
	//静态的同步方法   了解
	//锁对象的问题  this是创建对象之后产生的   静态方法属于类 优先于this 所以静态没有this
	
	//静态方法的锁对象是本类class属性  --->class文件对象(反射)
	private static  synchronized void extracted1() {
		synchronized(RunnableImpl1.class){
			
			
			if (ticket>0) {
				try {
					Thread.sleep(10);//模拟出票的过程
				} catch (Exception e) {
					// TODO: handle exception
				}
				System.out.println(Thread.currentThread().getName()+"正在买第---->"+ticket+"张票");
				
				ticket--;
			}
		}
	}
	
}

线程之间的通信：

strat之前

running 运行状态

synchronized 锁阻塞状态 排队

sleep 秒表

wait() 等待 对应的方法 notify/notifayall

线程之间的通信:

创建一个顾客线程(消费者) 告知老板要的包子的种类和数量 调用wait方法 放弃cpu执行,进入到waiting的状态

创建一个老板线程(生成者) 花了5秒钟做包子 做好包子之后 调用notify方法 唤醒顾客包子做好了

注意:

  • 顾客和老板线程必须使用同步代码块包裹起来 保证等待和唤醒只能有一个在执行(包子是一个共享资源)
  • 同步使用的锁对象必须保证唯一

方法的调用 wait和notify 都是属于Object的方法

只有锁对象才能调用 wait和notify/notifyAll

public class Test {

	static Object obj=new Object();//成员变量  对象唯一
	public static void main01(String[] args) {
		
		//消费者线程1
		new Thread(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				while (true) {
					synchronized (obj) {
						System.out.println("老板,来一个包子");
						
						try {
							obj.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						
						System.out.println("顾客1:包子已经做好了，开吃");//被通知之后执行的
						System.out.println("----------------");
					}
				}
			}
		}.start();
		
		new Thread(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				while (true) {
					synchronized (obj) {
						System.out.println("老板,来一个包子");
						
						try {
							obj.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						
						System.out.println("顾客2:包子已经做好了，开吃");//被通知之后执行的
						System.out.println("----------------");
					}
				}
			}
		}.start();
		
		//商家线程
		new Thread(){
			@Override
			public void run() {
				
				while (true) {
					try {
						Thread.sleep(5000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}//花了五秒钟做包子
					
					
					
					synchronized(obj){
						System.out.println("老板:包子做好了，来取餐");
						
						//obj.notify();//通知正在等待线程
						obj.notifyAll();
					}
					
					
				}
			};
		}.start();
		
		
	}
    	public static void main02(String[] args) {
		//等待唤醒机制
		Baozi b=new Baozi();
		
		Baozifu bzf=new Baozifu(b);
		bzf.start();
		Programmer pro=new Programmer(b);
		pro.start();
	}

等待唤醒机制:

点餐(进入等待)—>做餐(需要时间，通知顾客，等待)—>吃餐(需要 时间，吃完之后)—>点餐—>做餐

public class Baozifu extends Thread {

	//前提  保证锁对象是唯一的
	private Baozi  baozi;
	
	public Baozifu(Baozi zi){
		this.baozi=zi;
	}
	
	
	@Override
	public void run() {//生成
		int count=0;
		// TODO Auto-generated method stub
		//包子铺一致做包子
		while (true) {
			
			
			synchronized(baozi){
				if (baozi.flag==true) {
					//包子铺进入等待
					try {
						baozi.wait();//等待
					} catch (Exception e) {
						// TODO: handle exception
					}
				}
				
				//如果没有包子  被唤醒之后执行的脚本 生产包子
				if (count%2==0) {
					baozi.pi="白面皮";
					baozi.xian="猪肉";
				}
				else {
					baozi.pi="黑面皮";
					baozi.xian="牛肉";
				}
				
				count++;
				System.out.println("包子铺正在生产:"+baozi.pi+baozi.xian);
				
				
				
				try {
			         Thread.sleep(3000);
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				}
				
				
				//包子铺修改包子状态
				baozi.flag=true;
				
				baozi.notify();
				
				System.out.println("包子铺生产好了:"+baozi.pi+baozi.xian);
			}
		}
	}
}
public class Baozi {

	String pi;
	
	String xian;
	
	boolean flag=false;
	//包子的状态  如果有true  如果没有false
	
}
public class Programmer extends Thread {

	private Baozi bz;
	
	public Programmer(Baozi baozi) {
		// TODO Auto-generated constructor stub
		this.bz=baozi;
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true){
			synchronized(bz){
				if (bz.flag==false) {
					try {
						bz.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					
				}
				
				//被唤醒之后执行的脚本
				System.out.println("程序员正在吃:"+bz.pi+bz.xian);
				//吃完了
				
				bz.flag=false;
				bz.notify();//通知商家接着做
				System.out.println("程序员已经吃完了"+bz.pi+bz.xian);
				
				System.out.println("------------------");
				
				
				
			}
		}
	}
}
public static void main(String[] args) {
		//等待唤醒机制
		Baozi b=new Baozi();
		
		Baozifu bzf=new Baozifu(b);
		bzf.start();
		Programmer pro=new Programmer(b);
		pro.start();
	}

线程池 常量池

我们使用线程的时候 每次都是创建线程 频繁创建对象/线程 开销 性能消耗
好处

1.降低资源消耗 减少创建 线程和销毁线程的次数 每个工作线程可以重复利用 可以执行多个任务

2.提高相应速度 当任务多的时候 可以、不用等待立即执行

3.提高线程的可管理性 可以根据系统的承受能力 调整池的数量

Java1.5之后提供 线程池
Java.util.concurrent.excutors 线程池的工厂类 用来生产线程池

Excutors类中的方法

static ExecutorService newFixedThreadPool(int nThreads)

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。

返回值 ExecutorService接口 返回的是接口的实现类对象 接口接收这个对象

接口中的方法

submit 提交 提交一个任务 直接使用线程池中的线程 执行任务

shutdown 关闭线程

实现步骤:

1.使用线程池工厂类 创建对象

2.创建一个类 实现runnable接口 重写run方法 设置任务

3.调用ExecutorService中submit方法 传递线程任务 开启线程 执行run方法

4.调用ExecutorService 中shutdown方法 销毁线程(不建议执行)

public static void main(String[] args) {
		//1
		ExecutorService serv= Executors.newFixedThreadPool(3);//创建包含3个线程的线程池
	
		//2-3.task  任务
		serv.submit(new RunnableImp());
		serv.submit(new RunnableImp());
		serv.submit(new RunnableImp());
		serv.submit(new RunnableImp());
		serv.submit(new RunnableImp());
		serv.submit(new RunnableImp());
		serv.submit(new RunnableImp());
		
		//3.销毁
	    serv.shutdown();
	
	} 
public class RunnableImp implements Runnable {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"创建了一个新的线程执行");
	}

}

Lambda表达式

Java 8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口。

下面这个例子就是使用Lambda语法来代替匿名的内部类，代码不仅简洁，而且还可读。

public class RunnableImpl implements  Runnable {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("哈哈哈 美滋滋");
	}

}

使用匿名内部类的问题

Thread类 需要runnable接口作为参数 其中的抽象run方法 是用来指定线程的任务的核心

为了指定run的方法体 不得不 需要runnable接口的实现类

为了省去定义一个runnable 实现了 不得不使用匿名内部类

必须覆盖重写 抽象方法run 所以方法名 返回值卡 参数列表 必须重写一遍 而且不能写错

而实际上 只有run方法的方法体才是我们关心的

lambda表达式替换匿名内部类

lambda表达式 ()->{}

由三部分组成:
a.一些参数 ()
b.一个箭头->
c.一段代码

格式说明:

(参数列表)->{一些重写方法的代码}
():接口中抽象方法的参数列表 没有参数 空着，有参数就写对应的参数 参数数量和顺序不能错
->传递的意思 把参数传递给方法体
{} 重写接口的抽象方法的方法体

函数式编程:(C#委托类型) 把一个方法 直接作为另外一个方法的参数

ublic class Test {

	public static void main(String[] args) {
		//-------------第一种写法--------------------
		RunnableImpl  ru=new RunnableImpl();
		Thread td=new Thread(ru);
		td.start();
		//------------第二种 匿名内部类-----------------------------
		Runnable r=new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("美滋滋1");
			}
		};
		new Thread(r).start();
		
		//-----------第三种-------------------------------
		new Thread(new  Runnable() {
			@Override
			public void run() {
				System.out.println("美滋滋2");
			}
		}).start();
		
		//----------------------------------------
		new Thread(()->{}).start();
		
	}

1

要开心。
关注
专栏目录
Java基础学习第二天
03-13
在Java基础学习的第二天，主要涵盖了以下几个重要知识点：计算机组成原理，DOS命令，进制转换，Java的发展历程，Java的三大平台，Java运行核心机制，JDK的安装与环境变量配置，以及Java的基本语法。 首先，计算机...
线程通信的四种方式
热门推荐
weixin_43786099的博客
11-10 2万+
多个线程在并发执行的时候，他们在CPU中是随机切换执行的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式： 通过 volatile 关键字 通过 Object类的 wait/notify 方法 通过 condition 的 await/signal 方法 通过 join 的方式 现在有一个问题，两个线程分别打印字符串，但是当线程A每输出两次的时候，线程B就输出一次，如此反复10次。 通过 volatile 关键字 通过
线程间的通信方法
《好好先生》专栏
08-22 1万+
线程间的通信方法 1. 线程通信简介 一般而言，在一个应用程序（即进程）中，一个线程往往不是孤立存在的，常常需要和其它线程通信，以执行特定的任务。如主线程和次线程，次线程与次线程，工作线程和用户界面线程等。这样，线程与线程间必定有一个信息传递的渠道。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的。线程间的通信涉及到4个问题： 线程间如何传递信息； 线程之间如何同步，以...
线程间通讯（几种常见的通讯机制，以及实例）
bigger_belief的博客
07-18 9704
介绍线程间通讯的几种方式，以及一些实例
看了这篇文章，就别担心线程间的通信了！
Simon郎的博客
05-07 3110
线程间的通信 1、为什么需要线程通信 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程的通信可以被定义为： 线程通信就是当多个线程共同操作共享的资源时，互相告知自己的状态以避免资源争夺。 ...
基于Java语言的第十二天学习作业设计源码
最新发布
09-30
本项目为基于Java语言的第十二天学习作业设计，包含20个文件，其中包括16个Java源代码文件、2个Markdown文档、1个Xmind思维导图文件以及1个IntelliJ IDEA项目配置文件（.iml）。这些文件共同构成了一个用于巩固和...
JAVA学习笔记第十四天
08-15
在JAVA学习的第十四天，我们将会探讨几个关键的概念，这些概念对于任何Java开发者来说都是至关重要的。首先，让我们深入理解字符集编码解码。在计算机科学中，字符集编码是将字符转换为数字（二进制）表示的过程，而...
第二十三天，对java中接口的学习
11-10
第二十三天，对java中接口的学习
深入JAVA虚拟机第二版.7z
05-28
《深入JAVA虚拟机第二版》是一本专注于Java虚拟机（JVM）的权威指南，针对JVM的深入了解和优化提供了详尽的解析。这本书对于Java开发者、系统管理员以及对Java性能调优感兴趣的读者来说，是不可或缺的参考资料。下面...
线程之间通信的方法
if_i_were_a的博客
03-28 2086
线程之间通信的方法有四种: 1. 共享内存的方法 该方法有两种实现形式: synchronized和volatile 使用synchronized，多线程环境下会造成阻塞，如果有多个线程同时要对内存中的一个数据进行操作，那么他们都把内存中的值读到自己的工作内存中。使用synchronized修饰的haul同一时间只能有一个线程进行操作，对数据更新完之后重新刷新会主存，自动释放锁，然后下一个...
线程之间的几种通信方式
qq_44688861的博客
03-02 1万+
一、线程之间的几种通信方式 1、管道，是一种半双工方式，数据单方向流动，而且只能在有亲缘关系的线程之间使用。他是基于内核的，可以把它当作是内核缓冲区，在内核和用户空间交换数据需要进行四次的数据拷贝，因为他是把用户空间的数据拷贝到内核，然后从内核拷贝到内存，然后从内存再拷贝到内核，最后拷贝到用户空间，至于为什么要拷贝到内核，是因为数据最重都是在内存中执行的。接收的时候要按照次序，按照先进先出的原则，在管道中的数据只能被读取1次，读出之后缓冲区就不存在了。它只能承载没有格式的字节流 。 2、命名管道，和管道差不
线程之间的通信方式
weixin_41979002的博客
08-02 6745
前言 我只是个搬运工，尊重原作者的劳动成果，本文来源下列文章链接： https://zhuanlan.zhihu.com/p/129374075 https://blog.csdn.net/jisuanji12306/article/details/86363390 线程之间为什么要通信？ 通信的目的是为了更好的协作，线程无论是交替式执行，还是接力式执行，都需要进行通信告知。首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目
线程是如何通讯的？
m0_71777195的博客
05-27 1685
线程通讯指的是多个线程之间通过共享内存或消息传递等方式来协调和同步它们的执行。在多线程编程中，通常会出现多个线程需要共同完成某个任务的情况，这时就需要线程之间进行通讯，以保证任务能够顺利地执行。线程通讯的实现方式主要有以下两种：共享内存：多个线程可以访问同一个共享内存区域，通过读取和写入内存中的数据来进行通讯和同步。消息传递：多个线程之间通过消息队列、管道、信号量等机制来传递信息和同步状态。
线程通讯的三种方法
YIYIYI
01-16 1476
线程通讯的三种方法
线程之间是如何通信的？
NZC2237的博客
01-12 3834
CountDownLatch`和`CyclicBarrier`是Java中的两个同步工具，它们可以用于线程之间的协调。在Java中，通过`Object`类的`wait()`和`notify()`方法，以及`notifyAll()`方法，可以实现线程之间的等待和唤醒操作。Java中的`ReentrantLock`和`Condition`接口提供了条件变量的实现。在Java中，`PipedInputStream`和`PipedOutputStream`提供了管道的实现。
线程间实现通信的几种方式
weixin_54046648的博客
12-04 3929
线程间通信的模型有两种：共享内存和消息传递，下面介绍的都是围绕这两个来实现有两个线程A和B，B线程向一个集合里面依次添加元素“abc”字符串，一共添加10次，当添加到第五次的时候，希望线程A能够收到线程B的通知，然后B线程执行相关的业务操作Object类提供了线程间通信的方法：wait()、notify()、notifyAll()，它们是多线程通信的基础，而这种实现方式的思想自然是线程间通信。 线程A要等待某个条件满足时(list.size()==5)，才执行操作。线程B则向list中添加元素，改变list
线程通信的几种方式
ChineseSoftware的博客
07-01 2万+
一、问题 有两个线程，A 线程向一个集合里面依次添加元素“abc”字符串，一共添加十次，当添加到第五次的时候，希望 B 线程能够收到 A 线程的通知，然后 B 线程执行相关的业务操作。线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。 二、使用 volatile 关键字 基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想。大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式 public
线程间的通信
m0_68082638的博客
08-22 1215
当多个线程共同操作共享资源时,线程间通过某种方式互相告知自己的状态,以免无效的资源争夺.
Java编程：第二十一讲精华整理 - 命令行操作与编译执行
"Java第二十一讲总结文档涵盖了Java开发中常用的CMD命令，包括对系统、文件和目录的操作，以及Java编程相关的编译和执行步骤。这份文档是小贝程序员生活中的课件，提供了深入理解CMD命令和Java开发基础的宝贵资料。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值