跟着实例学习java多线程3-synchronized的多种写法有何区别?

并发编程 专栏收录该内容
10 篇文章 0 订阅

同步代码块是一种有效实现操作原子性的方法,上一章我们讲了一些同步的原子操作的基础。

现在我们回忆一下上一章的两个问题。

1:不同的synchronized的写法有什么区别,又该怎么写创建线程的代码呢?

以class实例对象作为锁的写法

写法1

package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class SafeThread {
	@safe
	public  void testPrint(){
		 synchronized(SafeThread.class){
			System.out.println("Enter testPrint method !");
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
		
				e.printStackTrace();
			}	
			System.out.println("Exit testPrint method !");
		}
	}
	
}


写法2

package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class SafeThread {
		
	public static   synchronized  void testPrint(){
			System.out.println("Enter testPrint method !");
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
		
				e.printStackTrace();
			}	
			System.out.println("Exit testPrint method !");
	}
	
}

以上两种写法是以class实例对象为锁的写法,这两种写法的调用线程该怎么写呢?让我们来看下面的例子

写法1,创建当前对象实例,并使用对象实例初始化线程。

package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class ThreadStart {
	
	public static void main(String[] para){
		SafeThread safe = new SafeThread();
		for(int i=0;i<3;i++){
			ThreadRead1 t1 = new ThreadRead1(safe);
			t1.start();
		}
	}
}
 

package com.home.thread;

/**
 * @author gaoxu
 *
 */
public class ThreadRead1 extends Thread{
	SafeThread safe = null;
	public ThreadRead1(){
	}
	public ThreadRead1(SafeThread o){
		safe = o;
	}

	public void run()
	{
		safe.testPrint();
	}

}


写法2,可以在线程中创建类实例。

package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class ThreadStart {
	
	public static void main(String[] para){
		for(int i=0;i<3;i++){
			ThreadRead1 t1 = new ThreadRead1();
			t1.start();
		}
	}
}</span>


<span style="font-size:14px;">package com.home.thread;

/**
 * @author gaoxu
 *
 */
public class ThreadRead1 extends Thread{
	SafeThread safe = null;
	public ThreadRead1(){
	}
	
	public void run()
	{
		safe = new SafeThread();
		safe.testPrint();
	}

}


这两总写法可以起到相同的作用,都可以实现原子的操作,实现同步互斥的调用。


创建内部同步代码块,以当前实例对象作为锁的对象。

写法1

package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class SafeThread {
		public   synchronized  void testPrint(){
			System.out.println("Enter testPrint method !");
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
		
				e.printStackTrace();
			}	
			System.out.println("Exit testPrint method !");
	}
	
}


package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class SafeThread {
		public  void testPrint(){
		synchronized(this){
			System.out.println("Enter testPrint method !");
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
		
				e.printStackTrace();
			}	
			System.out.println("Exit testPrint method !");
		}

	
}
	
}<span style="font-size:14px;">
</span>
package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class SafeThread {
		Object a = new Object();

		
	public   void testPrint(){
		synchronized(a){
			System.out.println("Enter testPrint method !");
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
		
				e.printStackTrace();
			}	
			System.out.println("Exit testPrint method !");
		}

	
}
	
}

这三种写法都是以类的当前实例对象作为锁对象,所以线程调用写法如下;

package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class ThreadStart {
	
	public static void main(String[] para){
		SafeThread safe = new SafeThread();//当前实例对象
		for(int i=0;i<3;i++){
			ThreadRead1 t1 = new ThreadRead1(safe);
			t1.start();
		}
	}
}
package com.home.thread;

/**
 * @author gaoxu
 *
 */
public class ThreadRead1 extends Thread{
	SafeThread safe = null;
	public ThreadRead1(){
	}
	public ThreadRead1(SafeThread o){
		safe = o;
	}

	public void run()
	{
		safe.testPrint();
	}

}

下面让我们来看一下以class对象和当前对象的区别:

    类.class和static synchronized是对该类所有实例对象枷锁。

    synchronized(this),synchronized,synchronized(object)都是对类的当前实例对象加锁。

具体说明:

      synchronized是对类的当前实例进行加锁,防止其他线程同时访问该类的当前实例的所有synchronized块。static synchronized是控制类的所有实例的访问了,static synchronized是限制线程同时访问jvm中该类的所有实例对应的代码快。在类中某方法或某代码块中有 synchronized,那么在生成一个该类实例后,该类也就有一个监视块,放置线程并发访问该实例synchronized保护块,这个保护块只对当前实例有效,而static synchronized则是所有该类的实例公用一个监视块,放置线程并发访问该类所有实例的保护块,synchronized相当于 this.synchronized,而
static synchronized相当于Something.synchronized。

2:死锁、活跃性问题都是怎么产生的。

后续章节我们重点讨论。

今天的问题是:

1:线程安全除了原子操作还有什么需要注意的。

2:如何确定自己需要实现一个线程安全类。


  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页

打赏作者

沉默andy

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值