同步代码块、同步方法、锁总结

最新推荐文章于 2023-03-27 23:15:02 发布
最新推荐文章于 2023-03-27 23:15:02 发布
阅读量127 收藏
点赞数
文章标签： javascript java ViewUI

同步代码块

1.为了解决并发操作可能造成的异常，java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块，其语法如下：

synchronized（obj）{

//同步代码块

}

其中obj就是同步监视器，它的含义是：线程开始执行同步代码块之前，必须先获得对同步代码块的锁定。任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对该同步监视器的锁定。虽然java程序允许使用任何对象作为同步监视器，但是同步监视器的目的就是为了阻止两个线程对同一个共享资源进行并发访问，因此通常推荐使用可能被并发访问的共享资源充当同步监视器。

2.小例子

Account.java

public class Account {
private String accountNo ;
private double balance;
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public Account(String accountNo, double balance)
{
super();
this.accountNo = accountNo;
this.balance = balance;
}
}

DrawThread.java

public class DrawThread extends Thread {
private Account account;
private double drawAmount;
public DrawThread(String name , Account account, double drawAmount)
{
super(name);
this.account = account;
this.drawAmount = drawAmount;
}
@Override
public void run() {
synchronized (account)
{
if(account.getBalance() >= drawAmount){
System.out.println(getName()+"取钱成功，吐出钞票："+ drawAmount);
try
{
Thread.sleep(1);
} catch (InterruptedException e)
{
e.printStackTrace();
}
account.setBalance(account.getBalance()-drawAmount);
System.out.println("\t余额为："+account.getBalance());
}else{
System.out.println(getName()+"取钱失败，余额不足");
}
}
}
}
DrawTest.java

public class DrawTest {
public static void main(String[] args) {
Account acct = new Account("12345",1000);
new DrawThread("甲", acct, 600).start();
new DrawThread("乙", acct, 600).start();;
}
}
运行出现的结果：

甲取钱成功，吐出钞票：600.0

余额为：400.0

乙取钱失败，余额不足

3.如果将DrawThread的同步去掉：

public void run() {
// synchronized (account)
// {
if(account.getBalance() >= drawAmount){
System.out.println(getName()+"取钱成功，吐出钞票："+ drawAmount);
try
{
Thread.sleep(1);
} catch (InterruptedException e)
{
e.printStackTrace();
}
account.setBalance(account.getBalance()-drawAmount);
System.out.println("\t余额为："+account.getBalance());
}else{
System.out.println(getName()+"取钱失败，余额不足");
}
// }
}
会出现的情况有三种：

第一种：

甲取钱成功，吐出钞票：600.0

乙取钱成功，吐出钞票：600.0

余额为：-200.0

余额为：-200.0

第二种：

乙取钱成功，吐出钞票：600.0

甲取钱成功，吐出钞票：600.0

余额为：400.0

余额为：-200.0

第三种：

甲取钱成功，吐出钞票：600.0

乙取钱成功，吐出钞票：600.0

余额为：400.0

余额为：400.0

程序使用synchronized将run（）方法里的方法修改成同步代码块，同步监视器就是account对象，这样的做法符合“加锁-修改-释放锁”的逻辑，这样就可以保证并发线程在任一时刻只有一个线程进入修改共享资源的代码区。多次运行，结果只有一个。



同步 方法
1.同步方法就是使用synchronized关键字修饰某个方法，这个方法就是同步方法，这个同步方法（非static方法）无须显示指定同步监视器，同步方法的同步监视器就是this，也就是调用该方法的对象。通过同步方法可以非常方便的实现线程安全的类，线程安全的类有如下特征：

该类的对象可以方便被多个线程安全的访问；

每个线程调用该对象的任意方法之后都得到正确的结果；

每个线程调用该对象的任意方法之后；该对象状态依然能保持合理状态。

2.不可变类总是线程安全的，因为它的对象状态不可改变可变类需要额外的方法来保证其线程安全，在Account类中我们只需要balance的方法变成同步方法即可。

Account.java

public class Account {
private String accountNo ;
private double balance;
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public Account(String accountNo, double balance)
{
super();
this.accountNo = accountNo;
this.balance = balance;
}
//提供一个线程安全的draw（）方法完成取钱的操作
public synchronized void draw(double drawAmount)
{
if(balance>=drawAmount){
System.out.println(Thread.currentThread().getName()+"取钱成功！吐出钞票："+drawAmount);
try{
Thread.sleep(1);
}catch (InterruptedException ex){
ex.printStackTrace();
}
balance-=drawAmount;
System.out.println("\t余额为："+balance);
}else{
System.out.println(Thread.currentThread().getName()+"取钱失败，余额不足");
}
}
}

DrawThread.java

public class DrawThread extends Thread {
private Account account;
private double drawAmount;
public DrawThread(String name , Account account, double drawAmount)
{
super(name);
this.account = account;
this.drawAmount = drawAmount;
}
@Override
public void run() {
account.draw(drawAmount);
}
}

DrawTest.java

public class DrawTest {
public static void main(String[] args) {
Account acct = new Account("12345",1000);
new DrawThread("甲", acct, 600).start();
new DrawThread("乙", acct, 600).start();;
}
}

注意，synchronized可以修饰方法，修饰代码块，但是不能修饰构造器、成员变量等。在Account类中定义draw（）方法，而不是直接在run（）方法中实现取钱逻辑，这种做法更符合面向对象规则。DDD设计方式，即Domain Driven Design(领域驱动设计)，认为每个类都应该是完备的领域对象，Account代表用户账户，就应该提供用户的相关方法，通过draw()方法执行取钱操作，而不是直接将setBalance方法暴露出来任人操作。

但是可变类的线程安全是以减低程序的运行效率为代价，不要对线程安全类的所有方法都进行同步，只对那些会改变竞争资源（共享资源）的方法进行同步。同时可变类有两种运行环境：单线程环境和多线程环境，则应该为可变类提供两个版本，即线程安全版本和线程不安全版本。如jdk提供的StringBuilder在单线程环境下保证更好的性能，StringBuffer可以保证多线程安全。


释放同步监视器的锁定

1.任何线程进入同步代码块，同步方法之前，必须先获得对同步监视器的锁定，那么如何释放对同步监视器的锁定呢，线程会在以下几种情况下释放同步监视器：

1）当前线程的同步方法、同步代码块执行结束，当前线程即释放同步监视器；

2）当前线程在同步代码块、同步方法中遇到break，return终止了该代码块、方法的继续执行；

3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致了该代码块、方法的异常结束；

4）当前线程执行同步代码块或同步方法时，程序执行了同步监视器对象的wait（）方法，则当前线程暂停，并释放同步监视器。

2.以下几种情况，线程不会释放同步监视器：

1）线程执行同步代码块或同步方法时，程序调用Thread.sleep()，Thread.yield()方法来暂停当前线程的执行，当前线程不会释放同步监视器；

2）线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放同步监视器，当然，程序应尽量避免使用suspend（）和resume（）方法来控制线程。


同步锁

1.java提供了一种功能更为强大的线程同步机制，通过显示定义同步锁对象来实现同步，这里的同步锁由Lock对象充当。

Lock对象提供了比synchronized方法和synchronized代码块更广泛的锁定操作，Lock是控制多个线程对资源共享进行访问的工具，通常，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象。

某些锁可能允许对共享资源并发访问，如ReadWriteLock（读写锁），Lock，ReadWriteLock是Java5提供的两个接口，并为Lock提供了Reentrant实现类，为ReadWriteLock提供了ReentrantReadWriteLock实现类。在Java8中提供了新型的StampLock类，在大多数场景下它可以代替传统的ReentrantReadWriteLock。ReentrantReadWriteLock为读写操作提供了三种锁模式：Writing,ReadingOptimistic,Reading.

2.在实现线程安全的控制中，比较常用的是ReentrantLock（可重入锁）。主要的代码格式如下：

public class X {
//定义锁对象
private final ReentrantLock lock = new ReentrantLock();
//定义需要保护线程安全的方法
public void m(){
//加锁
lock.lock();
try
{
//method body
} catch (Exception e)
{
e.getStackTrace();
}
finally {
lock.unlock();
}
}
}
将Account.java修改为：

public class Account {
private final ReentrantLock lock = new ReentrantLock();
private String accountNo ;
private double balance;
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public Account(String accountNo, double balance)
{
super();
this.accountNo = accountNo;
this.balance = balance;
}
public void draw(double drawAmount)
{
lock.lock();
try
{
if(balance>=drawAmount){
System.out.println(Thread.currentThread().getName()+"取钱成功！吐出钞票："+drawAmount);
try{
Thread.sleep(1);
}catch (InterruptedException ex){
ex.printStackTrace();
}
balance-=drawAmount;
System.out.println("\t余额为："+balance);
}else{
System.out.println(Thread.currentThread().getName()+"取钱失败，余额不足");
}
} finally {
lock.unlock();
}
}
}
使用Lock与使用同步代码块有点类似，只是使用Lock时可以显示使用Lock对象作为同步锁，而使用同步方法时系统隐式使用当前对象作为同步监视器。使用Lock时每个Lock对象对应一个Account对象，一样可以保证对于同一个Account对象，同一时刻只能有一个线程进入临界区。Lock提供了同步方法和同步代码块所没有的其他功能，包括使用非块状结构的tryLock（）方法，以及试图获得可中断锁的lockInterruptibly（）方法，还有获取超时失效锁的tryLock（long，TimeUnit）方法。
ReentrantLock可重入锁的意思是，一个线程可以对已被加锁的ReentrantLock锁再次加锁，ReentrantLock对象会维持一个计数器来追踪lock()方法的嵌套调用，线程在每次调用lock()加锁后，必须显示调用unlock()来释放锁，所以一段被锁保护的代码可以调用另一个被相同锁保护的方法。


死锁

当两个线程互相等待对方释放同步监视器就会发生死锁，Java虚拟机没有检测，也没有采取措施来处理死锁的情况，所以多线程程序应该采取措施避免死锁出现，一旦出现死锁，程序既不会发生任何异常，也不会给出任何提示，只是所有线程都处于阻塞状态，无法继续。

如DeadLock.java所示：

A.java

public class A {
public synchronized void foo(B b){
System.out.println("当前线程名为："+Thread.currentThread().getName()+"进入了A实例的foo()方法");
try{
Thread.sleep(200);
}catch(InterruptedException ex){
ex.printStackTrace();
}
System.out.println("当前线程名为："+Thread.currentThread().getName()+"试图调用B实例的last()方法");
b.last();
}
public synchronized void last(){
System.out.println("进入了A类的last()方法内部");
}
}
B.java

public class B {
public synchronized void bar(A a){
System.out.println("当前线程名为："+Thread.currentThread().getName()+"进入了B实例的bar()方法");
try{
Thread.sleep(200);
}catch(InterruptedException ex){
ex.printStackTrace();
}
System.out.println("当前线程名为："+Thread.currentThread().getName()+"试图调用A实例的last()方法");
a.last();
}
public synchronized void last(){
System.out.println("进入了B类的last()方法内部");
}
}
DeadLock.java

public class DeadLock implements Runnable {
A a = new A();
B b = new B();
public static void main(String[] args) {
DeadLock dLock = new DeadLock();
new Thread(dLock).start();
dLock.init();
}
public void init(){
Thread.currentThread().setName("主线程");
a.foo(b);
System.out.println("进入了主线程之后...");
}
public void run() {
Thread.currentThread().setName("副线程");
b.bar(a);
System.out.println("进入了副线程之后...");
}
}

结果有：（四种情况之一）

当前线程名为：副线程进入了B实例的bar()方法

当前线程名为：主线程进入了A实例的foo()方法

当前线程名为：主线程试图调用B实例的last()方法

当前线程名为：副线程试图调用A实例的last()方法

 
  
 
  
 
  
 
  
 
  
 
 
 


                

        

        




    

  


            

                    
            

    

      

        

            

              
                
                  weixin_33743703
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
多线程并发、线程池、同步方法、同步代码块（锁）

				
			

			

				

					Ethanhuangjiawei的博客
				

				

					12-06
					
					474
					
				

			

		

		

			
				
多线程并发、线程池、同步方法、同步代码块（锁）

			
		

	



                

              
                



	

		

			

				
					
6.线程的同步代码块&&同步方法

				
			

			

				

					qq_67192586的博客
				

				

					03-17
					
					176
					
				

			

		

		

			
				
线程的同步





问题2:出现错误票数,如:0,-1,-2等





原因:多个线程,在争抢资源的过程中,导致共享的资源出现问题,一个线程还没执行完,另一个线程就参与进来了,开始争抢



解决:在我的程序中,加入"锁"-->加同步-->同步监视器



方法1.同步代码块


public class BuyTicketThread implements Runnable{
    int ticketNum=10;..

			
		

	



                


  
              

                


	

		

			

				
					
同步锁代码块

				
			

			

				

					
				

				

					07-23
					
					255
					
				

			

		

		

			
				
package com.itheima.demo07.Synchronized;/* 卖票案例出现了线程安全问题 卖出了不存在的票和重复的票 解决线程安全问题的一种方案:使用同步代码块 格式: synchronized(锁对象){ 可能会出现线程安全问题的代码(访问了共享数据的代码) } 注意:...

			
		

	





	

		

			

				
					
java同步方法 的锁_Java同步方法：synchronized到底锁住了谁？

				
			

			

				

					weixin_42109178的博客
				

				

					02-20
					
					411
					
				

			

		

		

			
				
前言相信不少同学在上完Java课后，对于线程同步部分的实战，都会感到不知其然。比如上课做实验的时候，按着老师的实验指导书中的描述完成了多线程的同步操作，就感觉自己已经掌握这个知识点了，实际运用中再次手足无措，就像我一样。 这里提问一下：synchronized对方法修饰，在别处调用这个方法时，谁被锁定了呢？另外，在新建线程中使用synchronized(this){ }结构时，如：void met...

			
		

	



		

			
		



	

		

			

				
					
同步锁同步代码块同步_同步不是敌人

				
			

			

				

					cusi77914的博客
				

				

					06-29
					
					312
					
				

			

		

		

			
				
对于大多数编程语言，语言规范对线程和并发这一主题没有任何评论。 这些主题历来由平台或操作系统指定。 相反，Java语言规范（JLS）明确包含线程模型，并为开发人员提供了几种语言元素，可用于使他们的程序呈现线程安全性。 
 明确支持线程既是福也是祸。 虽然这使我们更容易编写利用线程功能和便利的程序，但这也意味着我们必须注意所编写类的线程安全性，因为任何给定的类都更有可能在多线程环境中使用。 
 ...

			
		

	





	

		

			

				
					
Java多线程-同步机制解决线程安全问题方式一：同步代码块

					
最新发布

				
			

			

				

					01-29
				

			

		

		

			
				
总结来说，Java中的同步代码块是一种有效的解决线程安全问题的手段，通过限制对共享资源的并发访问，可以保证数据的一致性和线程的安全性。然而，过度使用同步可能会降低程序的性能，因此需要合理设计同步范围，确保...

			
		

	





	

		

			

				
					
【IT十八掌徐培成】Java基础第08天-03.多线程-同步代码块-同步方法.zip

				
			

			

				

					08-07
				

			

		

		

			
				
本教程将深入讲解Java中的多线程以及同步控制机制，特别是同步代码块和同步方法。  首先，我们要理解什么是线程。线程是程序执行的最小单位，一个进程中可以有多个线程并发执行。在Java中，可以通过实现`Runnable`...

			
		

	





	

		

			

				
					
Java学习----同步代码块

				
			

			

				

					hanxuya的博客
				

				

					08-19
					
					920
					
				

			

		

		

			
				
对于synchronized语句当Java源代码被javac编译成bytecode的时候，会在同步代码块的入口位置和退出位置分别插入monitorenter和monitorexit(2个)字节码指令。

			
		

	





	

		

			

				
					
C#线程同步的几种方法总结

				
			

			

				

					12-20
				

			

		

		

			
				
 lock语句提供了一种基于监视器锁（Monitor）的同步机制，可以保证在同一时刻，只有一个线程能够执行特定的代码块。lock的语法是围绕一个对象实例进行，这个实例称为锁对象。当一个线程进入lock代码块，其他试图进入...

			
		

	





	

		

			

				
					
线程同步；同步方法、同步块（synchronized）

				
			

			

				

					Hgg657046415的博客
				

				

					04-04
					
					253
					
				

			

		

		

			
				
通过三个案例讲解了多线程执行可能存在的问题；初步认识了线程同步以及实现线程同步的同步方法和同步块

			
		

	





	

		

			

				
					
同步代码块的锁及同步方法应用和锁的问题

				
			

			

				

					kaszxc的博客
				

				

					10-05
					
					774
					
				

			

		

		

			
				
/同步代码块用obj做锁 //public class MyRunnable implements Runnable { // // //定义100章票 //	private static int ticked = 100;// //	//创建锁对象 //	private Object obj = new Object();

			
		

	





	

		

			

				
					
线程安全、线程同步机制(同步代码块、同步方法、同步锁)

				
			

			

				

					weixin_53622554的博客
				

				

					03-27
					
					1436
					
				

			

		

		

			
				
多个线程同时修改同一共享资源的时候，会出现线程安全问题。读数据是绝对不会出现线程安全问题的，它一定是因为同时在修改。一旦线程同步了，就是解决了安全问题了。CPU负责调度线程执行的，它是控制中心。线程安全问题出现的原因？存在多线程并发同时访问并存在修改同一共享资源。

			
		

	





	

		

			

				
					
synchronized同步锁详解

				
			

			

				

					枫柳蝶韵
				

				

					01-07
					
					4814
					
				

			

		

		

			
				
<br /><br />1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如： <br />
　　public synchronized void accessVal(int newVal); <br />
　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能<br />执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从

			
		

	





	

		

			

				
					
Java 同步函数和同步代码块锁

				
			

			

				

					china_demon的专栏
				

				

					01-28
					
					1815
					
				

			

		

		

			
				
/*
 * 同步函数的使用的锁是this
 * 
 * 同步函数和同步代码块的区别：
 * 同步函数的锁是固定的this。
 * 
 * 同步代码块的锁是任意的对象
 * 
 * 建议使用同步代码块
 */
class Ticket_1 implements Runnable{
private int num = 400;
Object obj = new Object()

			
		

	





	

		

			

				
					
synchronized同步方法和锁对象、脏读、可重入锁（二）

				
			

			

				

					飞少fly的博客
				

				

					05-21
					
					1061
					
				

			

		

		

			
				
当多个线程调用同一个资源类中的同步方法和非同步方法，它们的执行顺序是什么？看如下代码public class MyObject {

	synchronized public void methodA() {
		try {
			System.out.println("begin methodA threadName="
					+ Thread.currentThread().getName...

			
		

	





	

		

			

				
					
并发、同步方法、同步块、锁容器

				
			

			

				

					qq_32486015的博客
				

				

					03-18
					
					187
					
				

			

		

		

			
				
什么是并发？怎么解决？


并发：会导致线程不安全，数据混乱，比如负数。
 * 当多个线程同时操作一个对象就会出现并发问题。
 * 怎么解决：现实生活中，当多个人买一样东西或者结账的时候，我们都是排队，
 *   可以用这个思维。但我们怎么知道上一个线程使用完没，这个可以用一个锁来表示；
 *   就好像我们住宾馆的时候，我们住的时候会得到一张卡，凭卡进，退房的时候就把卡
 *   还给宾馆，这个...

			
		

	





	

		

			

				
					
synchronized同步锁原理详解

				
			

			

				

					qq_43648299的博客
				

				

					12-16
					
					2016
					
				

			

		

		

			
				
当对象获取到锁之后，由于某些资源并未准备完成，需要等待其他线程去准备资源，此时线程会通过wait()/notify()等方法进入等待/通知模式，在这种情况下线程释放锁之后会进入WaitSet，当其他线程准备好资源之后会通知WaitSet中等待的线程，WaitSet中的线程会进入到EntryList中，重新参与锁竞争。锁的状态总共有四种：无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁，但是锁的升级是单向的，只能从低到高升级，不会出现锁的降级。

			
		

	





	

		

			

				
					
同步锁-线程安全及三种解法

				
			

			

				

					Java-面试
				

				

					03-24
					
					701
					
				

			

		

		

			
				
线程安全：如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
例如：通过一个案例，演示线程的安全问题：电影院要卖票，我们模拟电影院的卖票过程。本次电影的座位共100个(本场电影只能卖.

			
		

	





	

		

			

				
					
同步方法和同步代码块区别

				
			

			

				

					07-28
				

			

		

		

			
				
同步方法和同步代码块都是为了解决多线程并发访问共享资源时可能...总结来说，同步方法适用于对整个方法体进行加锁的情况，而同步代码块适用于只对部分代码进行加锁的情况。选择使用哪种方式取决于具体的需求和场景。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值