Java 线程的互斥机制

「爱情、让人受尽委屈。」 2022-12-22 15:30 173阅读 0赞

*  为什么要有互斥机制  
    假设当多个线程对统一数据并发进行读写操作（即竞争），会导致数据的不确定性。
 *  怎样实现互斥  
    用锁机制，用**synchronized**关键字来标记必须**原子执行的代码段**，让多个线程有一共享对象，该对象有互斥锁，只有拿到，才能执行临界区；并且，临界区要么不执行，若执行，必须一次执行完。`synchronized(D) { S; } //D是临界资源；S是临界区；`

**例**

1.  /\*模拟银行存取钱，假定张三的银行帐户中有余额1000元，对银行账户的处理需要经历三次函数调用：  
    显示余额、修改余额（存钱或取钱）、显示修改后的余额。  
    这三次调用的输出信息分别是：  
    XX帐户余额为……元\\n  
    向……帐户存入（或者取出）……元\\n  
    XX帐户余额为……元\\n  
    请构造3个线程来同时操纵上述帐户，并输出结果。如张三向其中存5000元，老婆取2000，儿子取4000  
    \*/

class Account{
        
    	private String name;
    	private int val;
    	public String getName() {
        
    		return name;
    	}
    	Account(String s,int x){
        
    		name = s;
    		val = x;
    	}
    	public int getVal() {
         //查
    		return val;
    	}
    	public void setVal(int x) {
         //改
    		val = x;
    	}
    }
    class Saver extends Thread{
         //查-改-查
    	private Account a;
    	private String name;
    	private int cm;
    	Saver(Account x,String y,int z){
        
    		a = x;
    		name = y;
    		cm = z;
    	}
    	public void run() {
        
    		synchronized(a) {
        
    			System.out.println(a.getName()+"账户余额为"+a.getVal()+"元");		
    			System.out.println(name+"向"+a.getName()+"账户存入"+cm+"元");
    			int x = a.getVal()+cm;
    			a.setVal(x);
    			System.out.println(a.getName()+"账户余额为"+x+"元\n");
    		}
    	}
    }
    class Fetcher extends Thread{
         //查-改-查
    	private Account a;
    	private String name;
    	private int qm;
    	Fetcher(Account x,String y,int z){
        
    		a = x;
    		name = y;
    		qm = z;
    	}
    	public void run() {
        
    		synchronized(a) {
        
    			System.out.println(a.getName()+"账户余额为"+a.getVal()+"元");		
    			System.out.println(name+"向"+a.getName()+"账户取出"+qm+"元");		
    			int x = a.getVal()-qm;
    			a.setVal(x);
    			System.out.println(a.getName()+"账户余额为"+x+"元\n");
    		}
    	}
    }
    class app{
        
    	public static void main(String [] args) {
        
    		Account a = new Account("张三",1000);
    		Saver s1 = new Saver(a,"张三",5000);
    		Fetcher f1 = new Fetcher(a,"老婆",2000);
    		Fetcher f2 = new Fetcher(a,"儿子",4000);
    		s1.start(); f1.start(); f2.start();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTI3NTAz_size_16_color_FFFFFF_t_70_pic_center]  
此例中：  
临界区为查-改-查，此处必须原子执行，即一次执行完。  
**注：**  
**不能**在Account类中`synchronized(a){ public int getVal() { return val; } }//查` `synchronized(a){ public void setVal(int x) { val = x; } } //改`，这样只能保证**查**和**改**操作是原子执行，而需求是**查-改-查**三步原子执行。

1.  /\*线程类T定义方式为：class T implements Runnable\{ int data; …\}  
    线程体实现依次输出data的1~10倍数据。  
    在main中，构造和启动线程的方式形如： T t=new T(2); t.start();  
    构造data分别为2、3、5的线程，线程名分别为t2、t3、t5，要求：t2、t3、t5分3行输出，且输出结果不得交叉。  
    \*/

class T implements Runnable{
        
    	private int data;
    	Thread t;
    	public void start() {
         t.start();}
    	String flag;
    	T(String x,int y){
        
    		flag = x;
    		data = y;
    		t = new Thread(this);
    	}
    	public void run() {
        
    		synchronized(flag) {
         //注意这里共享资源，也可以直接填"a"，但不安全！此处涉及到常量池的概念
    			System.out.print("开始");
    			for(int i=1;i<=10;i++)
    				System.out.print(data*i+" ");
    			System.out.println("结束");
    		}
    	}
    }
    class app{
        
    	public static void main(String [] args) {
        
    		String s = "a";
    		T t2 = new T(s,2);
    		T t3 = new T(s,3);
    		T t5 = new T(s,5);
    		t2.start(); t3.start(); t5.start();
    	}
    }

![在这里插入图片描述][20201120213407742.png_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTI3NTAz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/719c23e006ad4a4990f537efeba512d9.png
[20201120213407742.png_pic_center]: /images/20221120/9b69cda8f3cb43ee90ce80e39349536f.png