synchronized锁

系统管理员 2024-03-17 23:52 84阅读 0赞

synchronized是Java的一个关键字。来自官方的解释：Synchronized方法支持一种简单的策略，用于防止线程干扰和内存一致性错误：如果一个对象对多个线程可见，则对该对象变量的所有读或写操作都通过Synchronized方法完成。

**Synchronized保证同一时刻有且只有一条线程在操作共享数据，其他线程必须等待该线程处理完数据后再对共享数据进行操作。此时便产生了互斥锁，互斥锁的特性如下：**

*  互斥性：即在同一时刻只允许一个线程持有某个对象锁，通过这种特性来实现多线程协调机制，这样在同一时刻只有一个线程对所需要的同步的代码块（复合操作）进行访问。互斥性也成为了操作的原子性。
 *  可见性：必须确保在锁释放之前，对共享变量所做的修改，对于随后获得该锁的另一个线程可见（即在获得锁时应获得最新共享变量的值），否则另一个线程可能是在本地缓存的某个副本上继续操作，从而引起数据不一致。

Synchronized是最基本的互斥手段，保证**同一时刻最多只有1个线程执行被Synchronized修饰的方法 / 代码**，其他线程 必须等待当前线程执行完该方法 / 代码块后才能执行该方法 / 代码块。

synchronized有三种应用场景

![eaacc4c54b374d7fab2f8a2a1f7831c1.png][]

###  ###

### 1.synchronized方法用作对象锁时： ###

下面看一段测试用例，一共创建了三个类

Person类（初始状态下都不加锁）

package bingfa;
    
    public class Person {
    	public volatile int age;
    	public String name;
    
    	public void m1() {
    		System.out.println("m1方法开始");
    		try {
    			Thread.sleep(2000);
    		} catch (Exception e) {}
    		System.out.println("m1方法结束");
    	}
    	public void m2() {
    		System.out.println("m2方法开始");
    		try {
    			Thread.sleep(2000);
    		} catch (Exception e) {}
    		System.out.println("m2方法结束");
    	}
    	public static void m3() {
    		System.out.println("m3方法开始");
    		try {
    			Thread.sleep(2000);
    		} catch (Exception e) {}
    		System.out.println("m3方法结束");
    	}
    
    	public static void m4() {
    		System.out.println("m4方法开始");
    		try {
    			Thread.sleep(2000);
    		} catch (Exception e) {}
    		System.out.println("m4方法结束");
    	}
    }

ThreadTest类

package bingfa;
    
    public class ThreadPlus extends Thread{
        private   Person  m;
        private int flag;
        public ThreadPlus(Person x, int w) {
            m = x;
            flag = w;
        }
        @Override
        public  void run() {
            if(flag == 1) {
                m.m1();
            }else {
                m.m2();
            }
        }
    }

主方法类

package bingfa;
    public class Test {
    	public static void main(String[] args) throws Exception{
    		Person x1 = new Person();
    		Person x2 = new Person();
    //====================================================
    		ThreadPlus t1 = new ThreadPlus(x1,1);
    		ThreadPlus t2 = new ThreadPlus(x1,2);
    
    		t1.start();
    		t2.start();
    		//=======
    		t1.join();
    		t2.join();
    	}
    }

#### 然后我们使用synchronized关键字分别进行测试 ####

### 注意：两个线程操作的是同一个对象！ ###

### m1,m2方法都不加锁 ###

这时m1，m2两个线程可以同时执行

![cfaf9302c97941b89499aee03e45ae0a.png][]

### m1加锁 ###

只有一个方法加锁，不构成互斥条件，因此m1，m2两个方法也互不影响，自由执行，以下三种情况都有可能。

![7e57e2317b4f465c86e3b50562b24cc1.png][]

![66ef9297608c4a93b52ad1dbbd9a3d67.png][]

![0f673470248145458734787067927f31.png][]

### m1，m2同时加锁 ###

这是构成了互斥条件，同一时刻，m1和m2只能有一个正在执行

![0f479c166297422b916de08e815e3508.png][]

### 2.synchronized方法用作类锁时： ###

修饰的static静态方法，与上面作为对象锁时类似，只有两个静态方法同时加锁，才构成互斥条件，二者不能同时执行，其余互不干扰

也就是说只有类型相同时互斥，静态和非静态之间互不干扰

### 3.修饰代码块 ###

![9c437f1462ae4be49390875fd37d90e6.png][]

需要注意的是，synchronized只能锁引用类型，而不能锁基本类型

[eaacc4c54b374d7fab2f8a2a1f7831c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/89ff58a4aeae4f288442311f27af64a1.png
[cfaf9302c97941b89499aee03e45ae0a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/177309375c964a3cb191dd41a725eee4.png
[7e57e2317b4f465c86e3b50562b24cc1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1e960bad7eb54e72b33bd3b5ff7091d4.png
[66ef9297608c4a93b52ad1dbbd9a3d67.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/616a0752f412497985ebe5a7521fc5bb.png
[0f673470248145458734787067927f31.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a8b34591a7304f7b91b9bdf124d9adc7.png
[0f479c166297422b916de08e815e3508.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ea4b52d3c06645ecbbcf364fdba14b71.png
[9c437f1462ae4be49390875fd37d90e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/86816d8dcaeb441b949fab06431b76f5.png