Java中synchronized实现对象锁的两种方式及原理解析_synchronized的两种实现方法

简介

本文将介绍Java中两种对象锁及其实现方式。分别是同步代码块锁和方法锁。我们将解决上一篇文章《Java中线程安全和线程不安全解析和示例》中提到的线程不安全问题，看看通过synchronized的对象锁，怎样轻松解决该问题。

一.同步代码块锁

案例：通过同步代码块锁，实现两个线程对同一个全局变量count,各自执行1万次count++,验证结果是否等于2万，而不会出现小于2万的情况。

完整代码实现:

public class SynchronizeCodeBlockLock implements Runnable {
	private static SynchronizeCodeBlockLock instance = new SynchronizeCodeBlockLock();
	private static int count = 0;

	@Override
	public void run() {
		method();
	}

	private void method() {
		// 关键：同步代码块的方式，操作同一变量，达到线程安全的效果
		synchronized (this) {
			System.out.println("线程名：" + Thread.currentThread().getName() + "，运行开始");
			for (int i = 0; i < 10000; i++) {
				count++;
			}
			System.out.println("线程：" + Thread.currentThread().getName() + "，运行结束");
		}
	}

	public static void main(String[] args) {
		Thread thread1 = new Thread(instance);
		Thread thread2 = new Thread(instance);
		thread1.start();
		thread2.start();
		while (thread1.isAlive() || thread2.isAlive()) {
			// 若有线程如果还在活动，则不执行下一步（等同于thread.join()方法）
		}
		System.out.println("期待结果：20000，实际结果：" + count);
	}


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

运行结果：

线程名：Thread-0，运行开始
线程：Thread-0，运行结束
线程名：Thread-1，运行开始
线程：Thread-1，运行结束
期待结果：20000，实际结果：20000
1
2
3
4
5

分析运行结果：

我们发现使用了synchronized关键字后，线程Thread-0先执行，等到其结束后，Thread-1才开始执行。如果不使用synchronized关键字，执行结果可能会是Thread-0和Thread-1几乎同时执行，几乎同时运行结束。这就说明使用了synchronized关键字后，将多个线程的并行，变为了串行。

二.方法锁

本例仅展示方法锁，在控制线程串行执行的示例。方法锁保证线程安全的效果，跟同步代码块是一致的。

public class MethodLock implements Runnable {

	private static MethodLock instance = new MethodLock();

	@Override
	public void run() {
		method();
	}

	//关键：synchronized可以保证此方法被顺序执行，线程1执行完4秒钟后，线程2再执行4秒。不加synchronized，线程1和线程2将同时执行
	private synchronized void method() {
		System.out.println("线程：" + Thread.currentThread().getName() + "，运行开始");
		try {
			//模拟执行一段操作，耗时4秒钟
			Thread.sleep(4000);
			System.out.println("线程：" + Thread.currentThread().getName() + "，运行结束");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		// 模拟：同一个对象下，两个线程，同步执行一个方法（串行执行则为线程安全，并行执行，则为线程不安全，）
		Thread thread1 = new Thread(instance);
		Thread thread2 = new Thread(instance);
		thread1.start();
		thread2.start();
		while (thread1.isAlive() || thread2.isAlive()) {

		}
		System.out.println("测试结束");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

运行结果：

线程：Thread-0，运行开始
线程：Thread-0，运行结束
线程：Thread-1，运行开始
线程：Thread-1，运行结束
测试结束
1
2
3
4
5

发现运行结果中，多个线程也是串行执行的，效果跟同步代码块锁是一致的。

三.synchronized关键字，是怎么保证线程安全的呢？

在Java中所有的对象，都会有一把锁，叫做内置锁，也称作监视器锁。这是种排他锁。

排他锁：一个线程获取后，其他线程只能等待其释放后，才有机会获得该锁。
1

Java中每个对象，都可以把内置锁，当做一个同步锁来使用。当一个线程在进入到synchronized代码块前时，会自动获取到监视器锁，此时其他线程在访问synchronized代码块时，就会被堵塞挂起（被拒之门外的意思）。拿到锁的线程会在执行完成、或者抛出异常、或者调用wait系列方法时释放该锁。其他线程只能等待锁被释放后才能获取该锁。

通俗的讲，synchronized关键字将代码块中代码由并行转变成了串行，这样就保证了代码被顺序执行。

四.synchronized在内存层面，是如何实现加锁和释放锁的？

• 进入synchronized代码块时，会将代码块内用到的变量从该线程的工作内存中清除，转而从主内存中获取。
• 退出synchronized代码块时，会将代码块内用到的变量的修改，刷新到主内存中。

这其实就是synchronized解决共享变量内存可见性的原理。关于synchronized的性质（可见性、可重入性），我会在后续其他文章中详细解释。

五.synchronized将线程的并行处理转为串行处理，有什么缺点？

synchronized将并行改为串行，当然会影响程序的执行效率，执行速度会受到影响。其次，synchronized操作线程的堵塞，也就是由操作系统控制CPU的内核进行上下文的切换，这个切换本身也是耗时的。所以使用synchronized关键字会降低程序的运行效率。

六. 使用Synchronized关键字需要注意什么？

1.Synchronized使用时需要注意的地方锁对象不能为空。

锁对象的信息是保留在对象头中的，如果对象为空，则锁的信息也就不存在了。

2.作用域不宜过大

synchronized代码块的代码量不宜过多，如果把过多的代码放在其中，程序的运行会变为串行，速度会下降。各个线程并行可以提高效率，我们应该仅把那些影响线程安全的代码，放入synchronized代码块中，串行执行；不需要考虑线程安全的代码，并行执行，达到效率最高。

3.避免死锁

避免让线程对锁持有并等待的情况出现（后续文章将讲解死锁的相关知识）。

七.总结

本文讲解了Java中的对象锁的两种实现方式，分别是以下两种实现形式：

方式一：同步代码块锁：

synchronized (共享变量) {
    //需要同步的代码
}
1
2
3

方式二：方法锁：

	private synchronized void method() {
	    //需要同步的代码
	}
1
2
3

无论你使用哪一种形式，都应该在保证同步的情况下，尽量减少同步代码的内容，这样可以提高程序的运行效率，还能保证线程的安全。喜欢本文请点赞和收藏，也欢迎继续阅读本专栏多线程的其他文章。