多线程之-synchronized

╰+攻爆jí腚メ 2022-11-16 10:37 183阅读 0赞

## 1. 概念性知识 ##

**1. synchronized关键字**  
synchronized用于解决线程同步问题，当有多条线程同时访问共享数据时，如果不进行同步，就很可能会发生错误，java提供的解决方案是：只要将操作共享数据的代码在某一时间让一个线程执行完，在执行过程中，其他线程不能执行同步代码，这样就可以保护数据的正确性。

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

*  （1）修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号\{\}括起来的代码，作用的对象是调用这个代码块的对象；
 *  （2）修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
 *  （3）修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
 *  （4）修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

**注意点：synchronnized是用于对对象加锁，并且是一个对象一个锁的机制，具体使用银行取钱案例来体现。**

**（1）继承Thread类实现多线程**

class Account {
        //账户
    	int remain;//余额
    	Account(int remain){
        
    		this.remain=remain;
    	}
    }

class Client extends Thread{
        
    	int money;//取钱钱数
    	Account account;
    	
    	Client(int money,Account account){
        
    		this.money=money;
    		this.account=account;
    	}
    	
    	@Override
    	public void run() {
        //取钱操作
    		if(account.remain-money>=0) {
        
    			try {
        
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
        
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    			account.remain-=money;
    			System.out.println(this.getName()+"取钱成功"+money+"，余额："+account.remain);
    		}else {
        
    			System.out.println(this.currentThread().getName()+"余额不足");
    		}
    	}
    }

public class MulThread {
        
    	public static void main(String[] args) {
        
    		Account account=new Account(100);
    		Client client1=new Client(60, account);
    		Client client2=new Client(60, account);
    		client1.start();
    		client2.start();
    
    	}
    }

结果截图：  
![20210406211040125.png][]  
**分析：** 我们都可以知道，出现这种两者都取钱后，只扣了一者的钱的情况是由于第一个线程进入了判断条件下的休眠，使得另一个线程获得cpu，开始运行，直到也进入了判断条件下的休眠，此时使得可以出现对于两个用户而言，看到的对应的余额均为100，且所以都可以进行取钱的相应操作的现象。

那么，我们是否可以通过对run方法加上synchronized锁来实现同步，从而不出现这种现象呢？代码实现如下：

//仅在run方法上加上synchronized锁
    public synchronized void run() {
        //取钱操作
    		if(account.remain-money>=0) {
        
    			try {
        
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
        
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    			account.remain-=money;
    			System.out.println(this.getName()+"取钱成功"+money+"，余额："+account.remain);
    		}else {
        
    			System.out.println(this.currentThread().getName()+"余额不足");
    		}
    	}

结果截图：  
![在这里插入图片描述][2021040621172436.png]  
**分析：** 我们可以看到仅在run方法上加上synchronized锁是不可行的，而这其中的原因就是在于 **一个对象一个锁的机制** ，我们可以通过main函数看到，我们是有两个线程t1，t2，有两个对象，他们有着各自run方法，互不干扰，所以不会出现影响，所以在run方法上加上synchronized锁是不可行的，除非他们只有一个对象。那么我们可以怎么解决这个问题呢？两个解决方法如下：

1.  对共同使用的对象account进行加锁；
2.  实现Runnable接口，其中run方法加上synchronized锁，创建实现Runnable接口的对象，对该对象创建多线程；

**第一种方法实现：**

//修改run方法里的内容，对account进行加锁即可
    public void run() {
        //取钱操作
    		synchronized (account) {
        
    			if(account.remain-money>=0) {
        
    				try {
        
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
        
    					// TODO 自动生成的 catch 块
    					e.printStackTrace();
    				}
    				account.remain-=money;
    				System.out.println(this.getName()+"取钱成功"+money+"，余额："+account.remain);
    			}else {
        
    				System.out.println(this.currentThread().getName()+"余额不足");
    			}
    		}
    	}

结果截图：  
![在这里插入图片描述][20210406212410899.png]

**第二种方法实现：**

class Customer implements Runnable{
        
    	int money;
    	Account account;
    	public Customer(int money, hello1.Account account) {
        
    		super();
    		this.money = money;
    		this.account = account;
    	}	@Override
    	public synchronized void run() {
        
    		// TODO 自动生成的方法存根
    		if(account.remain-money>=0) {
        
    			try {
        
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
        
    				// TODO 自动生成的 catch 块
    				e.printStackTrace();
    			}
    			account.remain-=money;
    			System.out.println(Thread.currentThread().getName()+"取钱成功"+money+"，余额："+account.remain);
    		}else {
        
    			System.out.println(Thread.currentThread().getName()+"余额不足");
    		}
    	}
    }

public class MulThread {
        
    	public static void main(String[] args) {
        
    		Account account=new Account(100);
    		Customer customer=new Customer(60, account);
    		Thread t1=new Thread(customer,"custom1");
    		Thread t2=new Thread(customer,"custom2");
    		t1.start();
    		t2.start();
    
    	}
    }

**分析：** 此时由于线程只对custom一个对象进行操作，一个对象一个锁，当t1调用run方法时，此时run方法上锁，只能由t1使用完毕后，t2才可以进行相应的上锁调用，所以不会出现两个人曲线，只扣一个余额的情况。

[20210406211040125.png]: /images/20221022/705a05602b3641a09bb1f162c2778e2a.png
[2021040621172436.png]: /images/20221022/8ed40ccc87c640afb2c92c914735f476.png
[20210406212410899.png]: /images/20221022/9f9ad880e2f445a9b25b71f06a61f6eb.png