synchronized对象锁和全局锁

川长思鸟来 2022-12-28 14:21 289阅读 0赞

[多线程同步锁synchronized（全局锁，对象锁）  
][synchronized_]

对象锁：只会锁住自己先线程new的对象

1.  锁普通方法

public synchronized void test() { }

1.  锁当前对象

synchronized (this) { }

全局锁：锁的是类

1.  锁静态方法

public static synchronized void test() { }

1.  锁类

synchronized (A.class) { }

# 对象锁的效果 #

1.  锁普通方法

public class A { 
    public synchronized void test() { 
    		System.out.println("test开始..");
    		try { 
    			Thread.sleep(1000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		System.out.println("test结束..");
    	}
    }

class MyThread extends Thread { 
     
    	public void run() { 
    		A a= new A();
    		a.test();
    	}
    }

public class Main { 
     
    	public static void main(String[] args) { 
    		for (int i = 0; i < 3; i++) { 
    			Thread thread = new MyThread();
    			thread.start();
    		}
    	}

运行结果： test开始.. test开始.. test开始.. test结束.. test结束.. test结束..

每个线程new一个A对象，test方法会同时被多线程执行。

上面的程序起了三个线程，同时运行Sync类中的test()方法，虽然test()方法加上了synchronized，但是还是同时运行起来，貌似synchronized没起作用。

1.  锁代码段  
    将test()方法上的synchronized去掉，在方法内部加上synchronized(this)：

public void test() { 
    		synchronized (this) { 
    			System.out.println("test开始..");
    			try { 
    				Thread.sleep(1000);
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    			System.out.println("test结束..");
    		}

运行结果一样： test开始.. test开始.. test开始.. test结束.. test结束.. test结束..

synchronized(this)以及非static的synchronized方法，只能防止多个线程同时执行同一个对象的同步代码段。

synchronized锁住的是代码还是对象。答案是：synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。

1.  多个线程共享一个对象

当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才达到线程同步的目的。即使两个不同的代码段，都要锁同一个对象，那么这两个代码段也不能在多线程环境下同时运行。

所以我们在用synchronized关键字的时候，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步。这叫减小锁的粒度，使代码更大程度的并发。原因是基于以上的思想，锁的代码段太长了，别的线程是不是要等很久，等的花儿都谢了。当然这段是题外话，与本文核心思想并无太大关联。

**再看上面的代码，每个线程中都new了一个Sync类的对象，也就是产生了三个Sync对象，由于不是同一个对象，所以可以多线程同时运行synchronized方法或代码段。  
修改代码，让三个线程使用同一个Sync的对象。**

class MyThread extends Thread { 
    
     
    	private Sync sync;
     
    	public MyThread(Sync sync) { 
    		this.sync = sync;
    	}
     
    	public void run() { 
    		sync.test();
    	}
    }
     
    public class Main { 
     
    	public static void main(String[] args) { 
    		Sync sync = new Sync();
    		for (int i = 0; i < 3; i++) { 
    			Thread thread = new MyThread(sync);
    			thread.start();
    		}
    	}
    }

运行结果： test开始… test结束… test开始… test结束… test开始… test结束…

可以看到，此时的synchronized就起了作用。

# 全局锁的效果: #

每个线程new一个A对象，怎么才能让test方法不会同时被多线程执行。

解决也很简单，只要锁住同一个对象不就行了。例如，synchronized后的括号中锁同一个固定对象，这样就行了。这样是没问题，但是，比较多的做法是让synchronized锁这个类对应的Class对象。

1.  锁类  
    synchronized(A.class)实现了全局锁的效果。

public void test() { 
    		synchronized (A.class) { 
    			System.out.println("test开始..");
    			try { 
    				Thread.sleep(1000);
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
    			System.out.println("test结束..");
    		}

运行结果： test开始.. test开始.. test开始.. test结束.. test结束.. test结束..

1.  锁静态方法  
    static synchronized方法，static方法可以直接类名加方法名调用，方法中无法使用this，所以它锁的不是this，而是类的Class对象，所以，static synchronized方法也相当于全局锁，相当于锁住了代码段。

public static synchronized void test() { 
    		System.out.println("test开始..");
    		try { 
    			Thread.sleep(1000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		System.out.println("test结束..");
    	}

运行结果： test开始.. test开始.. test开始.. test结束.. test结束.. test结束..

[synchronized_]: https://blog.csdn.net/jintiaozhuang/article/details/54927238