【本人秃顶程序员】synchronized锁住的是代码还是对象

╰半橙微兮° 2022-04-24 03:40 232阅读 0赞

←←←←←←←←←←←← 快！点关注

![1240][]

# 不同的对象 #

public class Sync {
    	public synchronized void test() {
    		System.out.println("test start");
    		try {
    			Thread.sleep(5000);
    		}
    		catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("test end");
    	}
    }

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

执行结果

test start
    test start
    test start
    test end
    test end
    test end

现象

在MyThread中，每次都new一个新的Sync对象，可以看到代码块test虽然被加了synchonized但是还是并行执行的，初步结论：锁住的不是代码块

# 同一个对象 #

public class MyThread2 extends Thread{
    	public Sync sync;
    	MyThread2(Sync sync) {
    		this.sync = sync;
    	}
    	public void run() {
    		System.out.println("hi....");
    		sync.test();
    	}
    	public static void main(String[] args) {
    		Sync sync = new Sync();
    		for (int i = 0; i < 3; ++i) {
    			Thread thread = new MyThread2(sync);
    			thread.start();
    		}
    	}

执行结果

hi....
    test start
    hi....
    hi....
    test end
    test start
    test end
    test start
    test end

现象

可以看到当他们共用一个对象的时候，synchonized起了作用，这块代码是串行执行的

## 结论 ##

锁住的是对象

# 如何在多对象的时候任然锁住代码？ #

解决也很简单，只要锁住同一个对象就行了。例如:synchronized后的括号中锁同一个固定对象，这样就行了。

这样是没问题，但是，比较多的做法是让synchronized锁这个类对应的Class对象。

public class Sync2 {
    	public void test() {
    		synchronized (Sync2.class) {
    			System.out.println("test start");
    			try {
    				Thread.sleep(2000);
    			}
    			catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			System.out.println("test end");
    		}
    	}
    }

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

执行结果

test start
    test end
    test start
    test end
    test start
    test end

# synchronized的两大不足 #

*  由于我们没办法设置synchronized关键字在获取锁的时候等待时间，所以synchronized可能会导致线程为了加锁而无限期地处于阻塞状态
 *  使用synchronized关键字等同于使用了互斥锁，即其他线程都无法获得锁对象的访问权。这种策略对于读多写少的应用而言是很不利的，因为即使多个读者看似可以并发运行，但他们实际上还是串行的，并将最终导致并发性能的下降。

虽然synchronized已经作为一个关键字被固化在Java语言中了，但它只提供了一种相当保守的线程安全策略，且该策略开放给程序员的控制能力极弱

# 读者福利： #

**分享免费学习资料**

**针对于Java程序员，我这边准备免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）**

**为什么某些人会一直比你优秀，是因为他本身就很优秀还一直在持续努力变得更优秀，而你是不是还在满足于现状内心在窃喜！希望读到这的您能点个小赞和关注下我，以后还会更新技术干货，谢谢您的支持！**

**资料领取方式：加入Java技术交流群`963944895`，私信管理员即可免费领取**

[1240]: /images/20220220/96cbba7cbd77400eab64e406d7024545.png