多线程与并发----线程互斥技术

最新推荐文章于 2025-05-30 09:48:31 发布
原创 最新推荐文章于 2025-05-30 09:48:31 发布 · 499 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了Java中线程同步的三种方式：使用synchronized代码块、synchronized方法及线程间如何通过wait与notify进行通信。通过示例代码详细展示了不同同步方式的具体应用，并演示了如何使两个线程交替执行。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、使用synchronized代码块

2、使用synchronized方法

3、分析静态方法锁使用的同步监视器对象是什么？

4、wait与notify实现线程间的通信


例一：使用内部类和两个线程交替不停的打印lisi和zhangsan两个名字

public class ThreadSynchronized {

	public static void main(String[] args) {
		
		new ThreadSynchronized().init();
	}
	
	public void init(){
		/*在静态方法中不能new内部类的实例对象，
		因为内部类的最重要的一个特点就是它可以直接访问它外部类的成员变量。成员变量是对象身上的。对象创建完成了,才会为成员变量分配空间。能调用成员变量,意味着一定有了实例对象.
		main方法是静态的，它执行的时候可以不用创建那个对象。这就矛盾了。 
		 */
		final Outputer outputer=new Outputer();//创建内部类
		new Thread(new Runnable() {//创建一个线程
			public void run() {
				while(true){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					outputer.output("lisi");
				}
				
			}
		}).start();
		
		new Thread(new Runnable() {//创建一个线程
			public void run() {
				while(true){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					outputer.output("zhangsan");
				}
				
			}
		}).start();
	}
		
	//内部类
	class Outputer{
		public void output(String name){
			int len=name.length();
			synchronized (name)
			{
				for(int i=0;i<len;i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}
	}
}

运行结果为：

lisi
zhangsan
zhangsan
lisi
lisi
zhangsan
lisi


使用synchronized代码块

public class ThreadSynchronized {

	public static void main(String[] args) {
		
		new ThreadSynchronized().init();
	}
	
	public void init(){
		/*在静态方法中不能new内部类的实例对象，
		因为内部类的最重要的一个特点就是它可以直接访问它外部类的成员变量。成员变量是对象身上的。对象创建完成了,才会为成员变量分配空间。能调用成员变量,意味着一定有了实例对象.
		main方法是静态的，它执行的时候可以不用创建那个对象。这就矛盾了。 
		 */
		final Outputer outputer=new Outputer();//创建内部类
		new Thread(new Runnable() {//创建一个线程
			public void run() {
				while(true){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					outputer.output("lisi");
				}
				
			}
		}).start();
		
		new Thread(new Runnable() {//创建一个线程
			public void run() {
				while(true){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					outputer.output("zhangsan");
				}
				
			}
		}).start();
	}
		
	//内部类
	class Outputer{
		public void output(String name){
			int len=name.length();
			synchronized (this)
			{
				for(int i=0;i<len;i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}
	}
}
使用synchronized方法

    

public class ThreadSynchronized {

	public static void main(String[] args) {
		
		new ThreadSynchronized().init();
	}
	
	public void init(){
		/*在静态方法中不能new内部类的实例对象，
		因为内部类的最重要的一个特点就是它可以直接访问它外部类的成员变量。成员变量是对象身上的。对象创建完成了,才会为成员变量分配空间。能调用成员变量,意味着一定有了实例对象.
		main方法是静态的，它执行的时候可以不用创建那个对象。这就矛盾了。 
		 */
		final Outputer outputer=new Outputer();//创建内部类
		new Thread(new Runnable() {//创建一个线程
			public void run() {
				while(true){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					outputer.output("lisi");
				}
				
			}
		}).start();
		
		new Thread(new Runnable() {//创建一个线程
			public void run() {
				while(true){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					outputer.output("zhangsan");
				}
				
			}
		}).start();
	}
		
	//内部类
	class Outputer{
		public synchronized void output(String name){
			int len=name.length();
				for(int i=0;i<len;i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
		}
	}
}


 例子：子线程循环10次和主线程循环10次，两者实现同步

public class ThreadCommunication {

	public static void main(String[] args) {
		
		final Business business=new Business();
		
		new Thread(new Runnable() {
			
			public void run() {
				for(int i=0;i<50;i++){	
						business.sub(i);
				}
				
			}
			
		}).start();
		
		for(int i=0;i<50;i++){
			business.main(i);
		}
	}
}

class Business{
	public synchronized void sub(int i){
		for(int j=0;j<10;j++){
			System.out.println("sub thread sequence of"+j+",loop of"+i);
		}
	}
	
	public synchronized void main(int i){
		for(int j=0;j<100;j++){
			System.out.println("main thread sequence of"+j+",loop of"+i);
		}
	}
}

 例子：子线程循环10次和主线程循环10次，两者交替运行50次的例子

public class ThreadCommunication {

	public static void main(String[] args) {
		
		final Business business=new Business();
		
		new Thread(new Runnable() {
			
			public void run() {
				for(int i=0;i<50;i++){	
						business.sub(i);
				}
				
			}
			
		}).start();
		
		for(int i=0;i<50;i++){
			business.main(i);
		}
	}
}

class Business{
	private boolean bSholdSub=true;
	public synchronized void sub(int i){
		if(!bSholdSub){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for(int j=0;j<10;j++){
			System.out.println("sub thread sequence of"+j+",loop of"+i);
		}
		bSholdSub=false;
		this.notify();
		
	}
	
	public synchronized void main(int i){
		if(bSholdSub){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for(int j=0;j<10;j++){
			System.out.println("main thread sequence of"+j+",loop of"+i);
		}
		bSholdSub=true;
		this.notify();
	}
}

运行结果为：

sub thread sequence of0,loop of0
sub thread sequence of1,loop of0
sub thread sequence of2,loop of0
sub thread sequence of3,loop of0
sub thread sequence of4,loop of0
sub thread sequence of5,loop of0
sub thread sequence of6,loop of0
sub thread sequence of7,loop of0
sub thread sequence of8,loop of0
sub thread sequence of9,loop of0
main thread sequence of0,loop of0
main thread sequence of1,loop of0
main thread sequence of2,loop of0
main thread sequence of3,loop of0
main thread sequence of4,loop of0
main thread sequence of5,loop of0
main thread sequence of6,loop of0
main thread sequence of7,loop of0
main thread sequence of8,loop of0

main thread sequence of9,loop of0

sub thread sequence of0,loop of0

为了观察程序的运行结果，可以在myeclipse中设置运行对话框，让结果重定向到一个文本文件，然后去查看该文本文件中的特殊行号是否正好对应了线程的切换点。

    RUN AS-->Run Configurations-->右边Common-->File前面打钩，--》输入路径，比如输入C:\Users\Administrator\Desktop\1.txt，最后点击run，就可在选择路径下看到运行程序的结果。



经验：要用到共同数据（包括同步锁）的若干个方法应该归在同一个类上，这个设计正好体现了高内聚和程序的健壮性。


线程的互斥
Yyhp3211的博客
04-22 343
实验3：线程的互斥 一、实验目的 （1）熟练掌握Windows系统环境下线程的创建与撤销。 （2）熟悉Windows系统提供的线程互斥API。 （3）使⽤Windows系统提供的线程互斥API解决实际问题。 二、实验准备 1、临界区对象 临界区对象(CriticalSectio)包括初始化临界区（InitializeCriticalSection())、进⼊临界区 ( EnterCrticalSe...
多线程并发技术
12-19
JVM优化 并发调试和JDK8新特性，并发调试和JDK8新特性
阿里面试官分享的Java面试中需要准备多线程并发的技术要点
javaxuexi123的博客
04-23 684
在任何Java面试当中多线程和并发方面的问题都是必不可少的一部分。所以你应该准备很多关于多线程的问题。在投资银行业务中多线程和并发是一个非常受欢迎的话题，特别是电子交易发展方面相关的。他们会问面试者很多令人混淆的Java线程问题。面试官只是想确信面试者有足够的Java线程与并发方面的知识，因为候选人中有很多只浮于表面。用于直接面向市场交易的高容量和低延时的电子交易系统在本质上是并发的。一、概念什么...
易语言WebSocket多线程并发稳定模块：专为易语言开发者打造的通信解决方案
最新发布
gitblog_06720的博客
05-30 498
易语言WebSocket多线程并发稳定模块：专为易语言开发者打造的通信解决方案 【下载地址】易语言WebSocket多线程并发稳定模块 易语言WebSocket多线程并发稳定模块专为易语言开发者打造，支持WebSocket、WS和WSS协议，内置多线程并发机制，确保高并发环境下的通信稳定与高效。模块经过严格测试，接口简单...
多线程并发
qq_43581919的博客
01-05 2909
多线程 Syn volatile syn与volatile区别 syn与lock区别 syn与ReenTruntLock区别
多线程互斥
weixin_44732049的博客
01-23 231
多线程实现互斥 //例如 洗碗刷碗操作 Message message = new Message(); new Thread(() -> { synchronized (message) { for (int i = 0; i < 10; i++) { System.err.println(Thread.currentThread() + "
多线程并发编程-同步与互斥-原⼦变量-并发和⽆锁 数据结构
12-30
多线程并发编程-同步与互斥-原子变量-并发和无锁数据结构 多线程并发编程是提高认程序性能的核心技术，但它也增加了编程的复杂性。因此，系统理解和掌握多线程并发编程的技巧变得尤为重要。本章将从多线程编程的...
Java多线程与并发-原理
12-21
Java多线程与并发是构建高性能、高可用系统的关键技术之一。在Java中，`synchronized`关键字用于实现线程间的同步，确保并发环境下的数据一致性。本文将深入探讨`synchronized`的工作原理、实现机制以及与其他并发...
vc++ multithread多线程教程---线程通信--利用事件对象,线程同步--使用信号量,线程同步--使用互斥量,线程同步--使用临界区
04-04
在VC++编程环境中，多线程技术是一种提升程序性能的重要手段。它允许程序同时执行多个任务，从而提高CPU利用率和程序响应速度。然而，多线程编程也带来了数据同步和线程通信的问题，以防止数据冲突和竞态条件。本...
多线程精品资源--多线程与高并发.zip
02-17
本文将深入探讨这两个主题，并结合资源包"多线程精品资源--多线程与高并发.zip"中的内容，提供相关知识点的详细说明。 首先，多线程是指在一个进程中同时执行多个线程，这使得程序可以并行处理任务，提高CPU资源的...
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
在这个名为"人工智能-项目实践-多线程-多线程与高并发.zip"的压缩包中，我们可以推测它可能包含了关于如何在AI项目中应用多线程技术以实现高效并发处理的资源，比如代码示例、教程或者研究报告。 多线程是指在一个...
多线程(线程互斥)
m0_72873854的博客
10-10 1080
多线程(线程互斥)
多线程 --- 线程互斥
m0_62229058的博客
02-16 1320
mutex：指向 pthread_mutex_t 类型的指针，用于指定待初始化的互斥锁对象。这个对象是由调用者分配的内存空间，函数会将该内存空间进行初始化以创建一个互斥锁。attr：指向 pthread_mutex_t 类型的指针，于指定互斥锁的属性。如果为 nullptr，则使用默认的属性，一般我们使用都是 nullptr，默认即可。因为是局部锁，因此，当生命周期结束时，需要我们手动销毁局部锁，以防止资源泄露。
多线程间的互斥
随心小记
08-29 683
临界资源 每次只允许一个线程进行访问（读/写）的资源 线程间的互斥（竞争） 多个线程在同一时刻都需要访问临界资源 QMutex类是一把线程锁，保证线程间的互斥 利用线程锁能够保证临界资源的安全性 小结 临界资源每次只允许一个线程进行访问（读/写） 线程锁（QMutex）用于保护临界资源 线程只有获取锁之后才能访问临界资源 锁被其他线程获取时，当前线程进入等待状态 线程锁的获取和释放必须在同一个线程中
多线程与并发
_山月见光的博客
08-01 3060
程序：是为了完成某个特定的任务，而用某种语言编写的一组指令的集合，即指的是一段静态的代码，静态对象。进程：是程序的一次执行过程，或是一个正在运行的程序。是一个动态的过程：有它自身的产生、存在、和消亡的过程——生命周期。线程：进程可进一步细化为线程，是一个程序内部的执行的路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。
多线程的互斥机制
Better_JH的博客
03-24 1577
虽然多个线程共享同一地址空间，使得多个线程之间可以很方便的进行通信，但是当多个线程访问同一临界资源时，很可能出现访问冲突的问题。所以此时就要引入同步与互斥机制。 来看下面的代码：#include<stdio.h> #include<pthread.h> int g_val = 0; void* thread(void* _val) { int val = 0; int count
多线程互斥简单实例
琅嬛福地
10-10 1189
// 多线程互斥简单实例 #include <iostream> #include <Windows.h>using namespace std;HANDLE hMutex; // 创建互斥句柄DWORD WINAPI Fun(LPVOID lpParamter) { while (1) { WaitForSingleObject(hMutex, INFINITE);
【Linux学习】多线程——互斥 | 线程安全
weixin_63726869的博客
05-08 1342
介绍了线程不安全的现象和原因，加锁解锁的操作，锁的本质，加锁的原理，线程安全和重入，以及死锁。
Cocos2d-x 多线程编程实践与指南
在Cocos2d-x中合理利用多线程可以显著提升游戏的性能，不过也要求开发者具备一定的并发编程知识。正确地处理线程间通信、同步以及共享资源访问，是多线程开发中的关键。始终牢记，多线程编程需要谨慎对待，以防止...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值