传统线程互斥技术

最新推荐文章于 2024-06-16 09:46:44 发布
最新推荐文章于 2024-06-16 09:46:44 发布
阅读量56 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/Howard2016/blog/1607884
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

使用synchronized代码块及其原理？

使用synchronized方法？

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

 一、代码实现

    1、同一对象锁

/** 
* @Title: TraditionalThreadSynchronized.java 
* @Package com.lh.threadtest 
* @Description: TODO
* @author Liu 
* @date 2018年1月15日 下午6:38:24 
* @version V1.0 
*/
package com.lh.threadtest.t3;

import java.util.concurrent.TimeUnit;

/** 
* @ClassName: TraditionalThreadSynchronized 
* @Description: 传统线程互斥技术
* @author Liu
* @date 2018年1月15日 下午6:38:24 
*  
*/
public class TraditionalThreadSynchronized {

	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		new TraditionalThreadSynchronized().init();
	}
	
	private void init(){
		final Outputer outputer = new Outputer();
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
		
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("lisi");
				}
			}
		}).start();
	}
	
	class Outputer{
		public void output(String name){
			String xxx = "xxx";
			//不行，可以认为是不同的钥匙，不能起到互斥的效果
//			synchronized (name) {
//				for(int i = 0; i< name.length(); i++){
//					System.out.print(name.charAt(i));
//				}
//				System.out.println();
//			}
//			synchronized (this) {
				synchronized (xxx) {
				for(int i = 0; i< name.length(); i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}
	}

}

    2、外部调用对象(锁)不同

/** 
* @Title: TraditionalThreadSynchronized.java 
* @Package com.lh.threadtest 
* @Description: TODO
* @author Liu 
* @date 2018年1月15日 下午6:38:24 
* @version V1.0 
*/
package com.lh.threadtest.t3;

import java.util.concurrent.TimeUnit;

/** 
* @ClassName: TraditionalThreadSynchronized 
* @Description: 传统线程互斥技术
* @author Liu
* @date 2018年1月15日 下午6:38:24 
*  
*/
public class TraditionalThreadSynchronized2 {

	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		new TraditionalThreadSynchronized2().init();
	}
	
	private void init(){
		final Outputer outputer = new Outputer();
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
		
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
//					outputer.output("lisi");
					//改成下面这种方式也是不行的(外部调用的对象不是同一个)！！！
					new Outputer().output("lisi");
				}
			}
		}).start();
	}
	
	class Outputer{
		public void output(String name){
			String xxx = "xxx";
			//不行，可以认为是不同的钥匙，不能起到互斥的效果
//			synchronized (name) {
//				for(int i = 0; i< name.length(); i++){
//					System.out.print(name.charAt(i));
//				}
//				System.out.println();
//			}
//			synchronized (this) {
				synchronized (xxx) {
				for(int i = 0; i< name.length(); i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}
	}

}

    3、方法加synchronized关键字

/** 
* @Title: TraditionalThreadSynchronized.java 
* @Package com.lh.threadtest 
* @Description: TODO
* @author Liu 
* @date 2018年1月15日 下午6:38:24 
* @version V1.0 
*/
package com.lh.threadtest.t3;

import java.util.concurrent.TimeUnit;

/** 
* @ClassName: TraditionalThreadSynchronized 
* @Description: 传统线程互斥技术
* @author Liu
* @date 2018年1月15日 下午6:38:24 
*  
*/
public class TraditionalThreadSynchronized3 {

	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		new TraditionalThreadSynchronized3().init();
	}
	
	private void init(){
		final Outputer outputer = new Outputer();
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
		
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("lisi");
				}
			}
		}).start();
	}
	
	class Outputer{
		//方法名前加synchronized关键字！对整个方法体加锁！
		public synchronized void output(String name){
			//线程间是互斥的！！
			for(int i = 0; i< name.length(); i++){
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}

}

    4、代码块synchronized修饰(与3所加的锁都是this(外部调用对象))

/** 
* @Title: TraditionalThreadSynchronized.java 
* @Package com.lh.threadtest 
* @Description: TODO
* @author Liu 
* @date 2018年1月15日 下午6:38:24 
* @version V1.0 
*/
package com.lh.threadtest.t3;

import java.util.concurrent.TimeUnit;

/** 
* @ClassName: TraditionalThreadSynchronized 
* @Description: 传统线程互斥技术 (对象锁必须保证唯一性，即保证线程互斥性)
* @author Liu
* @date 2018年1月15日 下午6:38:24 
*  
*/
public class TraditionalThreadSynchronized4 {

	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		new TraditionalThreadSynchronized4().init();
	}
	
	private void init(){
		final Outputer outputer = new Outputer();
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
		
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output2("lisi");
				}
			}
		}).start();
	}
	
	class Outputer{
		//方法名前加synchronized关键字！对整个方法体加锁！
		public void output(String name){
			synchronized (this) {
				for(int i = 0; i< name.length(); i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}
		
		//方法名前的synchronized使用的锁默认是当前对象！
		public synchronized void output2(String name){
			//线程间是互斥的！！
			for(int i = 0; i< name.length(); i++){
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}

}

    5、静态方法static加synchronized关键字(锁必须是Outputer.class)

/** 
* @Title: TraditionalThreadSynchronized.java 
* @Package com.lh.threadtest 
* @Description: TODO
* @author Liu 
* @date 2018年1月15日 下午6:38:24 
* @version V1.0 
*/
package com.lh.threadtest.t3;

import java.util.concurrent.TimeUnit;

/** 
* @ClassName: TraditionalThreadSynchronized 
* @Description: 传统线程互斥技术 (对象锁必须保证唯一性，即保证线程互斥性)
* @author Liu
* @date 2018年1月15日 下午6:38:24 
*  
*/
public class TraditionalThreadSynchronized5 {

	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		new TraditionalThreadSynchronized5().init();
	}
	
	private void init(){
		final Outputer outputer = new Outputer();
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output("zhangsan");
				}
			}
		}).start();
		
		new Thread(new Runnable() {
			
			public void run() {
				while(true){
					try {
						TimeUnit.MILLISECONDS.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					outputer.output3("lisi");
				}
			}
		}).start();
	}
	
	static class Outputer{
		//方法名前加synchronized关键字！对整个方法体加锁！
		public void output(String name){
			synchronized (Outputer.class) {
				for(int i = 0; i< name.length(); i++){
					System.out.print(name.charAt(i));
				}
				System.out.println();
			}
		}
		
		//方法名前的synchronized使用的锁默认是当前对象！
		public synchronized void output2(String name){
			//线程间是互斥的！！
			for(int i = 0; i< name.length(); i++){
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
		
		//静态方法名前的synchronized使用的是class对象！
		public static synchronized void output3(String name){
			//线程间是互斥的！！
			for(int i = 0; i< name.length(); i++){
				System.out.print(name.charAt(i));
			}
			System.out.println();
		}
	}

}

二、注意点

    1、内部类的作用：可以访问外部类的成员属性

转载于:https://my.oschina.net/Howard2016/blog/1607884

weixin_33713503
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LINUX互斥技术
happyAnger6的专栏
06-26 228
http://www.anger6.com/?p=709 在内核中，可能出现多个进程（通过系统调用进入内核模式）访问同一个对象，进程和硬中断访问同一个对象，进程和软中断访问同一个对象，多个处理访问同一个对象，此时需要使用互斥技术，确保在给定的时刻只有一个主体可以进入临界区访问对象。 如果临界区执行的时间比较长或者可能睡眠，可以使用下面这些互斥技术: 信号量，大多数情况下使用互斥信号量 ...
Java传统线程互斥技术
小猪奋斗
02-01 189
Java多线程基础（三）Java传统线程互斥技术 java的线程互斥主要通过synchronized关键字实现。下面的示例代码展示了几种使用synchronized关键字的基本用法。 package com.ming.thread; public class TestThread { public static void main(String[] args) {
传统线程互斥技术（传统的sychronized）
豆豆
08-05 274
在Java中，synchronized关键字是用来控制线程同步的，就是在多线程的环境下，控制synchronized代码段不被多个线程同时执行。如果想让同一对象的不同方法互斥，不仅仅要加synchronized，而且锁必须一样： synchronized(锁){ 同步的代码 }package cn.liuyuan.thread;public class TraditionalThrea
内核互斥技术
qq_35003588的博客
08-12 184
在Linux系统中，可能出现多个进程（通过系统调用激怒内核模式）访问同一个对象，继承和硬中断访问同一个对象，进程和软中断访问同一个对象等。 如果临界区的执行时间比较长或者需要进入睡眠，可以使用如下技术： （1） 信号量。 （2）读写信号量。 （3）互斥锁。 （4）实时互斥锁 如果临界区执行时间很短，并且不能睡眠，可以用如下技术：...
Java多线程与并发库高级应用视频教程22集
07-22
资源名称：Java多线程与并发库高级应用视频教程22集资源目录：【】01传统线程技术回顾【】02传统定时器技术回顾【】03传统线程互斥技术【】04传统线程同步通信技术【】04传统线程同步通信技术_分割纪录【】05线程...
UNIX 高级教程系统技术内幕
11-12
7.5.1 提供互斥访问的信号灯 7.5.2 使用的信号灯的事件等待 7.5.3 用于控制可计数资源的信号灯 7.5.4 信号灯的缺点 7.5.5 护卫 7.6 自旋锁 7.6.1 自旋锁的使用 7.7 条件变量 7.7.1 实现问题 7.7.2 事件 7.7.3 阻塞锁...
C++Helper–使用C++11实现半同步半异步线程池
01-06
　在处理大量并发任务的时候，如果按照传统的方式，一个请求一个线程来处理请求任务，大量的线程创建和销毁，将消耗过多的系统资源，还增加了线程上下文切换的开销，而通过线程池技术，就可以很好
计算机面试问题.pdf
02-06
产生死锁的原因包括竞争资源、进程间的推进顺序非法、互斥、请求和保持、不剥夺、环路等待等。死锁的处理方法有预防死锁、避免死锁、检测死锁、解除死锁等。 二、银行家算法 银行家算法是一种避免死锁的算法，由 ...
并行计算导论（原书第2版）.[美]Ananth Grama(带详细书签).pdf
04-24
覆盖了并行计算领域的传统问题，并且尽可能地采用与底层平台无关的体系结构和针对抽象模型来设计算法。书中选择MPI(Message Passing Interface)、POSIX线程和OpenMP这三个应用最广泛的编写可移植并行程序的标准作为...
Java并发库（三）：传统线程互斥技术
熊诗言的博客
12-25 522
03. 传统线程互斥技术        线程安全问题例子：银行转账        同一个账户一边进行出账操作（自己交学费），另一边进行入账操作（别人给自己付款），线程不同步带来的安全问题 示例：逐个字符的方式打印字符串 class Outputer {        public void output(String name)        {        int len =n
分布式互斥算法解析
李兆龙的博客
04-09 2683
文章目录引言集中式算法分布式算法基于请求的算法基于令牌的算法总结 引言 分布式系统中可能会出现多个节点访问一个资源或者同时执行一个给定的函数,这些资源或者函数一般成为临界资源(Critical Resource),有时这些 临界资源需要在同一时刻只有一个进程执行,这就是分布式互斥.保证任何给定时刻只允许一个进程或者给定的进程去执行临界区的算法称为互斥算法. 传统的单机达到互斥的方法有互斥锁,条件变...
Java中多个线程如何对共享资源互斥的访问
zhangvalue的博客
09-23 1263
Java提供了两种锁机制来控制多个线程对共享资源的互斥访问： 一个是JVM实现的synchronized 二个是JDK实现的ReentrantLock 一、把代码块声明为synchronized，那么该代码具有原子性（atomicity）和可见性（visibility），原子性意味着一个线程一次只能执行由一个指定监控对象（lock）保护的代码，从而防止多个线程在更新共享状态时相互冲突，可见...
Windows线程同步与互斥技术总结
benjiamen的专栏
06-19 6140
Windows线程同步与互斥技术总结2007年06月18日 星期一 12:481.1    线程同步概述如果没有同步对象和操作系统对特殊事件监视的能力，线程可能被迫使用有副作用的技术使自己与特殊事件同步。不使用操作系统支持的线程同步技术，会产生许多问题，比如：分配不必要的CPU时间，浪费；在高低优先级线程间，若低线程负责信号重置任务，则可能永远无法执行重置。 1.2   
互斥方法
yinyang_ddl的博客
04-23 1338
1.禁用中断： 无中断则无切换 屏蔽中断后，硬件事件无法得到及时的响应 针对于临界区很小的情况是有效的 多CPU并行执行时，只屏蔽一个CPU是无用的，无法解决互斥问题 2.软件方法 必须交替运行 临界区三大属性：progress、互斥，不会无限等待 无互斥性 反证法 dex算法： N进程解决方法1： N进程解决方法2： 共...
基于springboot的青年公寓服务平台源码数据库
最新发布
s123456sj的博客
06-16 547
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 568
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 344
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
LInux多线程互斥
09-16
Linux多线程互斥是为了避免多个线程同时对共享资源进行访问而引起的线程安全问题。互斥锁是一种常用的线程同步机制，用于保护共享资源免受并发访问的影响。在Linux中，使用pthread库提供的互斥锁(pthread_mutex_t)来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值