`
beston
  • 浏览: 8079 次
  • 性别: Icon_minigender_2
  • 来自: 上海
社区版块
存档分类
最新评论

Java synchronized同步方法和同步块总结

Java 多线程 同步方法 同步块 synchronized static 
阅读更多
今天做了一些实验，把Java synchronized同步方法和同步块总结一下，欢迎拍砖！

Java synchronized同步方法和同步块总结：

1、非静态 同步方法：
synchronized method() {...} 锁对象的所有同步方法
一个进程进入某对象同步方法后，其它线程不能同时访问这个对象中任何一个同步方法 


/**************************************************************************************** 
 Copyright © 2014 Your Company/Org. All rights reserved.<br> 
 Reproduction or transmission in whole or in part, in any form or<br>
 by any means, electronic, mechanical or otherwise, is prohibited<br>
 without the prior written consent of the copyright owner. <br>
 ****************************************************************************************/
package com.beston.concurrency.synchronization;

/** 
 * @ClassName: SyncMethod 
 * @Description: 同步方法    synchronized syncMethod(){...}
 * 作用域：某个对象实例内，可以防止多个线程同时访问这个对象的synchronized方法
 * 如果一个对象有多个synchronized方法，只要一个线 程访问了其中的一个synchronized方法，
 * 其它线程不能同时访问这个对象中任何一个synchronized方法.这时，不同的对象实例的 synchronized方法是不相干扰的。
 * 也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；  
 * @author beston 
 * @date 2014年3月17日 下午4:19:32 
 * @version v1.0
 *  
 */
public class SyncMethod {
	
	public static void main(String[] args) {
		MethodObj obj = new MethodObj();
		//线程1执行  hello()和syncmethod1()方法 
		new Thread(new Runnable1(obj)).start();
		//线程2执行  hello()和syncmethod2()方法 
		new Thread(new Runnable2(obj)).start();
	}

}
/** 
 * @ClassName: Runnable1 
 * @Description: 执行  hello()和syncmethod1()方法 
 * @author beston 
 * @date 2014年3月17日 下午4:29:49 
 * @version v1.0
 *  
 */ 
class Runnable1 implements Runnable{
	private MethodObj obj;
	
	public Runnable1(MethodObj obj){
		this.obj= obj;
	}
	public  void run(){	
		obj.hello();
		obj.syncmethod1();
		
	}
}

/** 
 * @ClassName: Runnable2 
 * @Description: 执行  hello()和syncmethod2()方法
 * @author beston 
 * @date 2014年3月17日 下午4:29:07 
 * @version v1.0
 *  
 */ 
class Runnable2 implements Runnable{
	private MethodObj obj;
	
	public Runnable2(MethodObj obj){
		this.obj= obj;
	}
	public  void run(){
		obj.hello();
		obj.syncmethod2();
	}
}

class MethodObj{
	
	/** 
	 * @Title: hello 
	 * @Description: 非同步，不会被锁
	 */
	public void hello(){
		System.out.println(Thread.currentThread().getName()+" hello!");

	}
	
	/** 
	 * @Title: syncmethod1 
	 * @Description: 同步方法1，被第一个持有该对象的线程占用5秒
	 */
	public synchronized void syncmethod1(){
		System.out.println(Thread.currentThread().getName()+" 占用 syncmethod1() 5秒");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/** 
	 * @Title: syncmethod2 
	 * @Description: 同步方法2
	 */
	public synchronized void syncmethod2(){
		System.out.println(Thread.currentThread().getName()+" syncmethod2()");
	}
}

2、非静态 同步块：
2.1
method(){
    synchronized (this){..}  锁对象的所有同步方法
}
一个进程进入某对象同步方法后，其它线程不能同时访问这个对象中任何一个同步方法 
/**************************************************************************************** 
 Copyright © 2014 Your Company/Org. All rights reserved.<br> 
 Reproduction or transmission in whole or in part, in any form or<br>
 by any means, electronic, mechanical or otherwise, is prohibited<br>
 without the prior written consent of the copyright owner. <br>
 ****************************************************************************************/
package com.beston.concurrency.synchronization;

/** 
 * @ClassName: SyncMethod 
 * @Description: 同步块    synchronized(this){...}
 * 作用域： 锁定 当前对象this 
 * @author beston 
 * @date 2014年3月17日 下午4:19:32 
 * @version v1.0
 *  
 */
public class SyncThis {
	
	public static void main(String[] args) {
		ThisObj obj = new ThisObj();
		//线程1执行  hello()和syncthis1()方法 
		new Thread(new Runnable3(obj)).start();
		//线程2执行  hello()和syncthis2()方法 
		new Thread(new Runnable4(obj)).start();
	}

}
/** 
 * @ClassName: Runnable3 
 * @Description: 执行  hello()和syncthis1()方法 
 * @author beston 
 * @date 2014年3月17日 下午4:29:49 
 * @version v1.0
 *  
 */ 
class Runnable3 implements Runnable{
	private ThisObj obj;
	
	public Runnable3(ThisObj obj){
		this.obj= obj;
	}
	public  void run(){	
		obj.hello();
		obj.syncthis1();
		
	}
}

/** 
 * @ClassName: Runnable4 
 * @Description: 执行  hello()和syncthis2()方法
 * @author beston 
 * @date 2014年3月17日 下午4:29:07 
 * @version v1.0
 *  
 */ 
class Runnable4 implements Runnable{
	private ThisObj obj;
	
	public Runnable4(ThisObj obj){
		this.obj= obj;
	}
	public  void run(){
		obj.hello();
		obj.syncthis2();
	}
}

class ThisObj{
	/** 
	 * @Title: hello 
	 * @Description: 非同步，不会被锁
	 */
	public void hello(){
		System.out.println(Thread.currentThread().getName()+" hello!");

	}
	
	/** 
	 * @Title: syncthis1 
	 * @Description: 同步块1，被第一个持有该对象的线程占用5秒
	 */
	public void syncthis1(){
		synchronized(this){
			System.out.println(Thread.currentThread().getName()+" 占用 syncthis1() 5秒");
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	/** 
	 * @Title: syncthis2 
	 * @Description: 同步块2
	 */
	public void syncthis2(){
		synchronized(this){
			System.out.println(Thread.currentThread().getName()+" syncthis2()");
		}
		
	}
}

2.2
Object obj = new Object();
method(){
    synchronized (obj){..}  锁住该代码块
}
锁定非自身(this)的其他对象(如this的成员)，则只锁住该代码块，本类其他同步方法不受影响 
/**************************************************************************************** 
 Copyright © 2014 Your Company/Org. All rights reserved.<br> 
 Reproduction or transmission in whole or in part, in any form or<br>
 by any means, electronic, mechanical or otherwise, is prohibited<br>
 without the prior written consent of the copyright owner. <br>
 ****************************************************************************************/
package com.beston.concurrency.synchronization;

/** 
 * @ClassName: SyncBlock 
 * @Description: 同步块 synchronized(obj){...} 
 * 锁定非自身(this)的其他对象，则只锁住该代码块，其他同步方法不受影响
 * @author beston 
 * @date 2014年3月17日 下午5:02:16 
 * @version v1.0
 *  
 */
public class SyncBlock {
	public static void main(String[] args) {
		BlockObj obj = new BlockObj();
		//线程1执行  hello()和syncblock1()方法 
		new Thread(new Runnable5(obj)).start();
		//线程2执行  hello()和syncblock1(),syncblock2()方法 
		new Thread(new Runnable6(obj)).start();
	}

}
/** 
 * @ClassName: Runnable5 
 * @Description: 执行  hello()和syncblock1()方法 
 * @author beston 
 * @date 2014年3月17日 下午4:29:49 
 * @version v1.0
 *  
 */ 
class Runnable5 implements Runnable{
	private BlockObj obj;
	
	public Runnable5(BlockObj obj){
		this.obj= obj;
	}
	public  void run(){	
		obj.hello();
		obj.syncblock1();
		
	}
}

/** 
 * @ClassName: Runnable6 
 * @Description: 执行  hello()和syncblock1()，syncblock2()方法 
 * @author beston 
 * @date 2014年3月17日 下午4:29:07 
 * @version v1.0
 *  
 */ 
class Runnable6 implements Runnable{
	private BlockObj obj;
	
	public Runnable6(BlockObj obj){
		this.obj= obj;
	}
	public  void run(){
		obj.hello();
		obj.syncblock2(); 
		obj.syncblock1(); 
		
	}
}

class BlockObj{
	Byte[] b = new Byte[0];
	Object a = new Object();
	int i = 0;//非对象 不能放到synchronized()括号中
	/** 
	 * @Title: hello 
	 * @Description: 非同步，不会被锁
	 */
	public void hello(){
		System.out.println(Thread.currentThread().getName()+" hello!");

	}
	
	/** 
	 * @Title: syncblock1 
	 * @Description: 同步块，进入该方法线程占用5秒
	 */
	public void syncblock1(){
		synchronized(a){
			System.out.println(Thread.currentThread().getName()+" 占用 syncblock1() 5秒");
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	/** 
	 * @Title: syncblock2 
	 * @Description: 同步块
	 */
	public void syncblock2(){
		synchronized(b){
			System.out.println(Thread.currentThread().getName()+" syncblock2()");
		}
		
	}
}


3、静态 同步方法
static synchronized method() {...}
一个进程进入类静态同步方法后，其它线程不能同时访问这个类中静态同步方法和静态同步块，其他非静态同步方法和非静态同步块不受影响 
/**************************************************************************************** 
 Copyright © 2014 Your Company/Org. All rights reserved.<br> 
 Reproduction or transmission in whole or in part, in any form or<br>
 by any means, electronic, mechanical or otherwise, is prohibited<br>
 without the prior written consent of the copyright owner. <br>
 ****************************************************************************************/
package com.beston.concurrency.synchronization;

import java.util.logging.Logger;

/**
 * @ClassName: SynStaticMethod
 * @Description: 结论: 不同线程访问同一个类的静态同步方法时, 线程间是互斥的.其他非静态同步块和同步方法不受影响
 * @author beston
 * @date 2014年3月17日 下午6:02:41
 * @version v1.0
 * 
 */
public class SynStaticMethod {

	// 线程1
	static class T1 implements Runnable {
		SynStaticMethod s;

		public T1(SynStaticMethod sameObj) {
			this.s = sameObj;
		}

		// 线程1访问静态同步方法
		public void run() {
			SynStaticMethod.syn();
		}
	}

	// 线程2
	static class T2 implements Runnable {
		SynStaticMethod s;

		public T2(SynStaticMethod sameObj) {
			this.s = sameObj;
		}

		// 线程2访问静态同步方法
		public void run() {
			//SynStaticMethod.static2();不会阻塞
			//SynStaticMethod.syn2();
			//new SynStaticMethod().synInstance3();
			//new SynStaticMethod().syn();
			//SynStaticMethod.syn();
			
		}
	}

	// 对象的静态同步方法
	public static synchronized void syn() {
		String threadStr = Thread.currentThread().getName();
		
		try {
			System.out.println(threadStr + "正在静态访问同步方法syn()!!!");
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
	
	// 对象的静态同步方法
	public static synchronized void syn2() {
		String threadStr = Thread.currentThread().getName();
		
		try {
			System.out.println(threadStr + "正在静态访问同步方法syn2()!!!");
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
	
	// 对象的静态同步方法
	public synchronized void synInstance3() {
		String threadStr = Thread.currentThread().getName();
		
		try {
			System.out.println(threadStr + "正在静态访问同步方法synInstance3()!!!");
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}

	// 对象的静态方法2
	public static void static2() {
		String threadStr = Thread.currentThread().getName();
		
		try {
			System.out.println(threadStr + "正在静态访问方法static2()!!!");
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}

	public static void main(String[] args) {
		// 这是多线程要访问的同一个对象
		SynStaticMethod sameObj1 = new SynStaticMethod();
		SynStaticMethod sameObj2 = new SynStaticMethod();

		// 线程1,线程2访问静态同步方法
		Thread t1 = new Thread(new T1(sameObj1));
		Thread t2 = new Thread(new T2(sameObj2));

		t1.start();
		t2.start();
	}
}

4、静态 同步块
static method{
    synchronized (Xxx.class){..}
}
一个进程进入类静态同步块后，其它线程不能同时访问这个类中所有静态同步方法和静态同步块，其他非静态同步方法和非静态同步块不受影响 
/**************************************************************************************** 
 Copyright © 2014 Your Company/Org. All rights reserved.<br> 
 Reproduction or transmission in whole or in part, in any form or<br>
 by any means, electronic, mechanical or otherwise, is prohibited<br>
 without the prior written consent of the copyright owner. <br>
 ****************************************************************************************/
package com.beston.concurrency.synchronization;

import java.util.logging.Logger;

/**
 * @ClassName: SynStaticClass
 * @Description: 不同线程访问类的所有同步块静态方法和静态同步方法时, 线程间是互斥的.其他非静态同步块和同步方法不受影响
 * @author beston
 * @date 2014年3月17日 下午6:02:41
 * @version v1.0
 * 
 */
public class SynStaticClass {

	// 线程1
	static class T1 implements Runnable {
		SynStaticClass s;

		public T1(SynStaticClass sameObj) {
			this.s = sameObj;
		}

		// 线程1访问静态同步方法
		public void run() {
			SynStaticClass.syn();
		}
	}

	// 线程2
	static class T2 implements Runnable {
		SynStaticClass s;

		public T2(SynStaticClass sameObj) {
			this.s = sameObj;
		}

		// 线程2访问静态同步方法
		public void run() {
			new SynStaticClass().synInstance4();//不会被阻塞
			//new SynStaticClass().syn(); //会阻塞
			//new SynStaticClass().syn3(); //会阻塞
			//SynStaticClass.syn3(); //阻塞
			//SynStaticClass.syn2(); //阻塞
			//SynStaticClass.syn();  //阻塞
		}
	}

	// 对象的同步块静态方法
	public static void syn() {
		synchronized(SynStaticClass.class){
			String threadStr = Thread.currentThread().getName();
			try {
				System.out.println(threadStr + "正在静态访问同步方法syn()!!!");
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}	
	}

	// 对象的同步块静态方法2
	public static void syn2() {
		synchronized (SynStaticClass.class) {
			String threadStr = Thread.currentThread().getName();
			try {
				System.out.println(threadStr + "正在静态访问同步方法syn2()!!!");
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	// 对象的静态同步方法3
	public static synchronized void syn3() {
			String threadStr = Thread.currentThread().getName();
			try {
				System.out.println(threadStr + "正在静态访问同步方法syn3()!!!");
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
	}
	
	// 对象的同步方法3
	public synchronized void synInstance4() {
			String threadStr = Thread.currentThread().getName();
			try {
				System.out.println(threadStr + "正在访问实例同步方法synInstance4()!!!");
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
	}

	public static void main(String[] args) throws InterruptedException {
		// 这是多线程要访问的同一个类
		SynStaticClass sameObj1 = new SynStaticClass();
		SynStaticClass sameObj2 = new SynStaticClass();

		// 线程1,线程2访问静态同步方法
		Thread t1 = new Thread(new T1(sameObj1));
		Thread t2 = new Thread(new T2(sameObj2));

		t1.start();
		Thread.sleep(100);
		t2.start();
	}
}
分享到：
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java同步synchronized关键字用法示例

    Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源时的同步机制。在Java中，当多个线程试图同时访问和修改同一块代码或数据时，可能会导致数据不一致的问题。为了解决这个问题，...

    基于Java synchronized同步锁实现线程交互.pdf

    "基于Java synchronized同步锁实现线程交互" Java多线程能够提高CPU利用效率，但也容易造成线程不安全、线程死锁等问题。Java synchronized同步锁可以保证同一时刻只有一个线程操作同一资源，使用wait()、notify()...

    java中synchronized用法

    它可以作为函数的修饰符，也可以作为函数内的语句，用于实现同步方法和同步语句块。在 Java 中，synchronized 关键字可以作用于 instance 变量、object reference（对象引用）、static 函数和 class literals（类...

    java中synchronized（同步代码块和同步方法）详解及区别

    本篇文章将详细介绍`synchronized`的两种形式：同步代码块和同步方法，并分析它们的区别。 1. **同步代码块 (Synchronized Block)** 同步代码块的语法结构如下： ```java synchronized (object) { // 需要同步...

    Java synchronized详细解读.docx

    首先，`synchronized`可以应用于两种情况：同步方法和同步代码块。同步方法是通过在方法声明前加上`synchronized`关键字，例如`public synchronized void method() {...}`。同步代码块则是通过`synchronized`关键字...

    Java synchronized使用案例

    Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以保证数据的一致性和完整性。这个关键词提供了互斥锁机制，防止多个线程同时执行同一段代码，确保了线程安全。 一、`...

    java synchronized同步静态方法和同步非静态方法的异同

    本文将深入探讨`synchronized`关键字在同步静态方法和非静态方法上的异同。 首先，`synchronized`关键字有两种主要的使用方式：一是修饰方法，二是作为代码块。当`synchronized`修饰一个非静态方法时，锁住的是该...

    java锁机制Synchronizedjava锁机制Synchronized

    Synchronized 代码块是 Java 中的一种同步机制，它可以指定获取某个对象的钥匙，然后在该对象上的某个代码块中执行同步操作。Synchronized 代码块可以指定用哪一把钥匙才能开这个屏风的锁，可以用本房的钥匙，也可以...

    14.线程的同步机制-synchronized同步方法-局部变量为线程安全.mp4

    在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。

    java synchronized demo

    在Java编程语言中，`...总结，`java synchronized demo`是一个关于如何在Java中使用`synchronized`关键字进行线程同步的示例，通过理解和实践这个例子，开发者可以更好地掌握多线程环境下数据安全和同步的重要性。

    java 中同步方法和同步代码块的区别详解

    同步方法和同步代码块是Java中实现同步的主要方式，它们都用于解决线程安全问题，但有各自的特点和适用场景。 同步方法是通过在方法声明前加上`synchronized`关键字来实现的。例如： ```java public synchronized ...

    详细解读java同步之synchronized解析

    【Java同步之synchronized解析】 Java中的`synchronized`关键字是实现多线程同步的重要机制，它确保了在并发环境中对共享资源的访问是线程安全的。以下是对`synchronized`的详细解读： ### 1. synchronized的特性 ...

    java synchronized 学习

    Java 中的 synchronized 关键字是用来实现线程同步的，它可以用来修饰方法、代码块和静态方法，以确保在多线程环境下数据的一致性。 一、进程和线程的区别 在计算机中，每个运行着的 xxxx.exe 都是一个进程，而...

    Java 同步锁(synchronized)详解及实例

    同步锁主要有两种形式：同步方法和同步代码块。 1. **同步方法**： 将`synchronized`关键字放在方法声明之前，可以将整个方法标记为同步的。这意味着同一时间只有一个线程能够执行该方法。在售票示例中，如果我们...

    java的线程同步机制synchronized关键字的理解_.docx

    Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...

    Java使用synchronized修饰方法来同步线程的实例演示

    总结，synchronized是Java中实现线程同步的关键字，通过它我们可以确保对共享资源的访问是有序的，从而保证数据的一致性。然而，正确使用synchronized需要对多线程和并发有深入理解，以避免性能问题和设计上的陷阱。...

    Java synchronized关键_动力节点Java学院整理

    1. **对象锁**：每个Java对象都可以作为一个锁，当调用对象的`synchronized`方法或在代码块中使用`synchronized`关键字时，会获取到这个对象的锁。如果多个线程尝试访问同一个对象的同步代码，只有一个线程能够获得...

    21.线程的同步机制-synchronized同步方法-锁自动释放.mp4

    在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。

    java多线程编程之使用Synchronized块同步方法

    在Java中，`synchronized`有两种使用方式：同步方法和同步代码块。 1. 同步方法： 同步方法是指在方法声明前加上`synchronized`关键字，它会锁定该方法所在的对象。对于非静态方法，锁的是当前对象实例；对于静态...

Magicbox
Global site tag (gtag.js) - Google Analytics