synchronized 解析使用

最新推荐文章于 2023-09-22 22:45:17 发布
最新推荐文章于 2023-09-22 22:45:17 发布
阅读量703 收藏 1
点赞数
分类专栏： java学习之路 文章标签： java 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a13164815445/article/details/78292889
版权

java锁分为对象锁，类锁，

synchronized就是熟知的代码同步块。

加锁一个方法块，根据锁的机制上锁的只是这个对象，

package hw.lock;

/**
 * 
 * 
 * @author huangwei
 *	2017 10 20 
 */
public class Producer extends Thread{
	  int num=1;
	public synchronized int count() {
		
			while(num<10) {
			System.out.println(Thread.currentThread() +"   "+num++);//输出当前线程
			}
			
			
			try {
			Thread.sleep(500);
			}catch (Exception e) {
				// TODO: handle exception
			}
		
		return num;
		
	}
	
	public void run() {
		count();
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Producer aProducer=new Producer();
		Producer bProducer=new Producer();
		aProducer.start();
		bProducer.start();
	}

}

输出为这样

Thread[Thread-1,5,main]   1
Thread[Thread-0,5,main]   1
Thread[Thread-0,5,main]   2
Thread[Thread-0,5,main]   3
Thread[Thread-0,5,main]   4
Thread[Thread-0,5,main]   5
Thread[Thread-0,5,main]   6
Thread[Thread-0,5,main]   7
Thread[Thread-0,5,main]   8
Thread[Thread-0,5,main]   9
Thread[Thread-1,5,main]   2
Thread[Thread-1,5,main]   3
Thread[Thread-1,5,main]   4
Thread[Thread-1,5,main]   5
Thread[Thread-1,5,main]   6
Thread[Thread-1,5,main]   7
Thread[Thread-1,5,main]   8
Thread[Thread-1,5,main]   9


说明如果只是对方法上锁的话，那么实际上会对当前的对象上锁，而我们实现了两个对象，所以并没有实现同步。


package hw.lock;

/**
 * 
 * 
 * @author huangwei
 *	2017 10 20 
 */
public class Producer extends Thread{
	  int num=1;
	public  int count() {
		synchronized (this) {
			while(num<10) {
			System.out.println(Thread.currentThread() +"   "+num++);//输出当前线程
			}
			
			
			try {
			Thread.sleep(500);
			}catch (Exception e) {
				// TODO: handle exception
			}
		}
		
		return num;
		
	}
	
	public void run() {
		count();
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Producer aProducer=new Producer();
		Producer bProducer=new Producer();
		aProducer.start();
		bProducer.start();
	}

}

对当前对象进行上锁  输出结果依旧为没有上锁的样子 

Thread[Thread-0,5,main]   1
Thread[Thread-1,5,main]   1
Thread[Thread-0,5,main]   2
Thread[Thread-1,5,main]   2
Thread[Thread-0,5,main]   3
Thread[Thread-0,5,main]   4
Thread[Thread-0,5,main]   5
Thread[Thread-0,5,main]   6
Thread[Thread-0,5,main]   7
Thread[Thread-0,5,main]   8
Thread[Thread-0,5,main]   9
Thread[Thread-1,5,main]   3
Thread[Thread-1,5,main]   4
Thread[Thread-1,5,main]   5
Thread[Thread-1,5,main]   6
Thread[Thread-1,5,main]   7
Thread[Thread-1,5,main]   8
Thread[Thread-1,5,main]   9

那对于两个不同的线程对象 我们要上锁的其实就是公有的属性，或者说就是静态属性。 

package hw.lock;

/**
 * 
 * 
 * @author huangwei
 *	2017 10 20 
 */
public class Producer extends Thread{
	 static int num=1;
	public  int count() {
		synchronized (Producer.class) {
			while(num<10) {
			System.out.println(Thread.currentThread() +"   "+num++);//输出当前线程
			}
			
			
			try {
			Thread.sleep(500);
			}catch (Exception e) {
				// TODO: handle exception
			}
		}
		
		return num;
		
	}
	
	public void run() {
		count();
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Producer aProducer=new Producer();
		Producer bProducer=new Producer();
		aProducer.start();
		bProducer.start();
	}

}



Thread[Thread-1,5,main]   1
Thread[Thread-1,5,main]   2
Thread[Thread-1,5,main]   3
Thread[Thread-1,5,main]   4
Thread[Thread-1,5,main]   5
Thread[Thread-1,5,main]   6
Thread[Thread-1,5,main]   7
Thread[Thread-1,5,main]   8
Thread[Thread-1,5,main]   9

如果是两个对象操作静态变量，对XX.class进行上锁就可以实现，对类上锁同步静态变量方法以及常量。


对于静态方法的synchronized就相当于给这个方法所在的这个内存块添加了一个监视器，


在类加载的时候，类的基本信息和一些常量和今天变量都保存在jvm内存的方法区，


对synchronized（XX.class）  就等于对这个类的所有信息加上 监视器，一个线程进行访问计数+1，释放-1，不为0就一直阻塞其他线程访问。


而类初始化的实例对象则放在了jvm内存的堆区

而对实例对象的上锁就相当于监视这个实例对象，而不同的对象在不同块  并不能实现同步。



对于同一个对象实例

未上锁时

package hw.lock;

/**
 * 
 * 
 * @author huangwei
 *	2017 10 20 
 */
public class Producer {
	 int num=1;
	public  int count() {
		
			while(num<10) {
			System.out.println(Thread.currentThread().getName() +"   "+num++);//输出当前线程
			}
			
			
			try {
			Thread.sleep(1000);
			}catch (Exception e) {
				// TODO: handle exception
			}
		
	
		return num;
		
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		final Producer aProducer=new Producer();
		//Producer bProducer=new Producer();
		Thread test1=new Thread(new Runnable() {
			
			@Override
			public void run() {
				aProducer.count();
				
			}
		});
		Thread test2=new Thread(new Runnable() {
			
			@Override
			public void run() {
				aProducer.count();
				
			}
		});
		test1.start();
		
		test2.start();
		//bProducer.start();
	}

}



Thread-0   1
Thread-1   1
Thread-0   2
Thread-1   3
Thread-0   4
Thread-1   5
Thread-0   6
Thread-1   7
Thread-0   8
Thread-1   9

对其当前对象上锁 
package hw.lock;

/**
 * 
 * 
 * @author huangwei
 *	2017 10 20 
 */
public class Producer {
	 int num=1;
	public  int count() {
		synchronized (this) {		
			while(num<10) {
			System.out.println(Thread.currentThread().getName() +"   "+num++);//输出当前线程
			}
			
			
			try {
			Thread.sleep(1000);
			}catch (Exception e) {
				// TODO: handle exception
			}
		
		}
		return num;
		
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		final Producer aProducer=new Producer();
		//Producer bProducer=new Producer();
		Thread test1=new Thread(new Runnable() {
			
			@Override
			public void run() {
				aProducer.count();
				
			}
		});
		Thread test2=new Thread(new Runnable() {
			
			@Override
			public void run() {
				aProducer.count();
				
			}
		});
		test1.start();
		
		test2.start();
		//bProducer.start();
	}

}


Thread-0   1
Thread-0   2
Thread-0   3
Thread-0   4
Thread-0   5
Thread-0   6
Thread-0   7
Thread-0   8
Thread-0   9

由于num一直由第一个线程执行没有释放，所以第二个线程由于大于10直接结束。

直观一点 

num声明在方法内

package hw.lock;

/**
 * 
 * 
 * @author huangwei
 *	2017 10 20 
 */
public class Producer {
	
	public  int count() {
		 int num=1;
		synchronized (this) {		
			while(num<10) {
			System.out.println(Thread.currentThread().getName() +"   "+num++);//输出当前线程
			}
			
			
			try {
			Thread.sleep(1000);
			}catch (Exception e) {
				// TODO: handle exception
			}
		
		}
		return num;
		
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		 final Producer aProducer=new Producer();
		//Producer bProducer=new Producer();
		Thread test1=new Thread(new Runnable() {
			
			@Override
			public void run() {
				aProducer.count();
				
			}
		},"test1");
		Thread test2=new Thread(new Runnable() {
			
			@Override
			public void run() {
				aProducer.count();
				
			}
		},"test2");
		test1.start();
		
		test2.start();
		//bProducer.start();
	}

}


输出就为这样

test2   1
test2   2
test2   3
test2   4
test2   5
test2   6
test2   7
test2   8
test2   9
test1   1
test1   2
test1   3
test1   4
test1   5
test1   6
test1   7
test1   8
test1   9


简单的生产者消费者模型

package hw.lock;

/**
 * 
 * 
 * @author huangwei
 *	2017 10 20 
 */
public class Producer {
	int pnum=0;
	public  int count() {
		 int num=1;
		synchronized (this) {		
			while(num<10) {
			System.out.println(Thread.currentThread().getName() +"   "+num++);//输出当前线程
			}
			
			
			try {
			Thread.sleep(5000);
			}catch (Exception e) {
				// TODO: handle exception
			}
		
		}
		return num;
		
	}

	
	public void produce() {//生产者
		synchronized (this) {
			try {
			if(pnum>10) {
				this.wait();//数量上限等待
			}
			this.notify();//唤醒进程
			pnum++;
			System.out.println("生产者生产：1，还剩下："+this.pnum);
			
				Thread.sleep(1000);
			}catch (Exception e) {
				// TODO: handle exception
			}
		}
		
		
	}
	
	public void customer() {//消费者
		synchronized (this) {
			try {
			if(pnum>0) {
				this.notify();//可以取  唤醒
				pnum--;
				System.out.println("消费者消费：1，还剩下："+this.pnum);
				}else{
					System.out.println("消费者消费：0，储量不足");
					this.wait();//否则等待
				}
			
				Thread.sleep(1000);
			}catch (Exception e) {
				// TODO: handle exception
			}
		
		}
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		 final Producer aProducer=new Producer();
		//Producer bProducer=new Producer();
		Thread test1=new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
				aProducer.produce();
				}
			}
		},"test1");
		Thread test2=new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
				aProducer.customer();
				}
			}
		},"test2");
		test1.start();
		
		test2.start();
		
		//bProducer.start();
	}

}


生产者生产：1，还剩下：1
消费者消费：1，还剩下：0
消费者消费：0，储量不足
生产者生产：1，还剩下：1
生产者生产：1，还剩下：2
生产者生产：1，还剩下：3
生产者生产：1，还剩下：4
消费者消费：1，还剩下：3
生产者生产：1，还剩下：4
生产者生产：1，还剩下：5
生产者生产：1，还剩下：6
消费者消费：1，还剩下：5
消费者消费：1，还剩下：4
消费者消费：1，还剩下：3
生产者生产：1，还剩下：4
生产者生产：1，还剩下：5
生产者生产：1，还剩下：6
生产者生产：1，还剩下：7



_少年锦时
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
Java synchronized关键字使用方式及特性解析
08-25
Javaynchronized关键字使用方式及特性解析 Java中的synchronized关键字是一种实现锁的方式，它是在JVM层面实现的非公平锁。synchronized关键字可以用于实现线程同步，以下是使用synchronized的四种方式： 1. 作用...
synchronized原理
纯洁的小魔鬼
05-11 4349
一.synchronized简介 1.java中的关键字，在JVM层面，Java利用锁机制实现线程同步的一种方式。 2.synchronized属于隐式锁，相比于显示锁如ReentrantLock不需要自己写代码去获取锁和释放锁。 3.synchronized属于可重入锁，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。即 synchronized块中的synchronized还是能马上获得该锁。 4.synchronized为非公平锁，即多个线程去获取锁...
一文彻底理解synchronized（通俗易懂的synchronized）
最新发布
fu_bobo
09-22 4077
一文搞懂synchronized
Synchronized Integer问题
小石潭记丶
02-23 855
首先为了方便你看文章的时候复现问题，我给你一份直接拿出来就能跑的代码，希望你有时间的话也把代码拿出来跑一下： public class SynchronizedTest { public static void main(String[] args) { Thread why = new Thread(new TicketConsumer(10), "why"); Thread mx = new Thread(new TicketConsumer(10), "m
synchronized详解
Linging_24的博客
12-03 1805
1、并发编程会出现原子性、可见性、有序性问题。 原子性：在一次或多次操作中，要么所有的操作都执行并且不会受其它因素干扰而中断，要么所有的操作都不执行。在多线程环境下，线程对共享变量的操作，要么成功，要么失败，不会受其它线程的干扰。 可见性：在多线程环境下，某个线程对共享变量的修改，其它的线程可以知道并获取最新修改的值。 有序性：指程序中代码的执行顺序，java在编译时和运行时对代码进行优化，会导致程序的最终执行顺序不一定是我们Java代码编写时的顺序。 2、JVM内存模型 Java内存模型，是Java虚拟机
synchronized总结
奔波儿东
03-01 1510
查看synchronized修饰过的代码块编译后的字节码，会发现被synchronized修饰过的代码块前后会生成两个字节码指令：monitorenter、monitorexit； 这两个字节码指令的含义：当JVM执行到monitorenter和monitorexit两个指令实现同步。 monitorenter ： 每个对象都与一个监视器锁（monitor）相关联，monitor才会被锁定。线程执行monitorenter指令时会尝试获取monitor的所有权。 每个对象维护者一个记录着被锁定次数的计数
详细解读java同步之synchronized解析
08-26
【Java同步之synchronized解析】 Java中的`synchronized`关键字是实现多线程同步的重要机制，它确保了在并发环境中对共享资源的访问是线程安全的。以下是对`synchronized`的详细解读： ### 1. synchronized的特性 ...
解析Java线程编程中的线程安全与synchronized的使用
09-03
总的来说，理解和正确使用`synchronized`关键字是Java多线程编程的基础，它可以帮助我们构建线程安全的代码，防止因并发访问导致的错误。在实际开发中，应根据具体需求选择合适的方法来解决线程安全问题，以实现高效...
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析 Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前...
volatile和synchronized关键字的区别
namezsw的专栏
02-14 442
1.无关键字 int i1; int geti1() {return i1;} 　　geti1()得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改 变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程 可以有它自己的变量拷贝，而
synchronized用法初体验
ting2909的博客
05-26 86
一、从场景中体验synchronized 是谁击败了主宰 在峡谷中，击败主宰可以获得高额的经济收益。因此，在条件允许的情况下，大家都会争相击败主宰。于是，哪吒和敌方的兰陵王开始争夺主宰。按规矩，谁是击败主宰的最后一击，谁便是胜利的一方。 假设主宰的初始血量是100，我们通过代码来模拟下： public class Master { //主宰的初始血量 private int blood = 100; //每次被击打后血量减5 public int decreaseBlood() { blood =
Java同步锁何时释放？
CJaver的专栏
01-31 4821
任何线程进入同步代码块、同步方法之前，必须获得同步监视器的锁定，那么何时会释放这个锁定呢？在程序中，是无法显式释放对同步监视器的锁的，而会在如下几个情况下释放锁。 1、当前线程的同步方法、代码块执行结束的时候释放 2、当前线程在同步方法、同步代码块中遇到break 、 return 终于该代码块或者方法的时候释放。 3、。。。。出现未处理的error或者exception导致异常结束的时候释
彻底理解synchronized
weixin_34411563的博客
04-30 341
1. synchronized简介 在学习知识前，我们先来看一个现象： public class SynchronizedDemo implements Runnable { private static int count = 0; public static void main(String[] args) { for (int i = 0; i &lt; ...
synchronized解析
WangYangXiang的博客
08-16 106
synchronized synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态
全面理解Java内存模型
weixin_33895516的博客
09-21 3239
Java内存模型即Java Memory Model，简称JMM。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。 如果我们要想深入了解Java并发编程，就要先理解好Java内存模型。Java内存模型定义了多线程之间共享变量的可见性以及如何在需要的时候对...
【Java笔记】synchronized详解
vacherf的博客
06-06 1428
synchronized 同步原语 在多线程环境中，存在着共同操作访问一个对象类数据的情况，难免有数据不同步的情况出现。synchronized就是java内置修饰符专门来处理同步的。 对一个类、实例加锁，所有操作必须获取到锁才能进行。保证数据的同步。 使用场景大概分为四个：静态代码块、静态方法、非静态代码块、非静态方法。 其中，非静态方法锁定的是实例对象，在synchronized修...
【多线程与高并发原理篇：4_深入理解synchronized】.doc
07-09
在实际项目设计中，合理运用`synchronized`可以保证线程安全，但也要注意避免过度使用，以免增加不必要的性能开销。理解并发编程的精髓，结合适当的并发工具和设计模式，才能写出高效且健壮的多线程代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值