再谈线程synchronized同步

发表于   |   分类于   |  

synchronized是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

先摆结论

  1. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

  2. 然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

  3. 尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

  4. 第三个例子同样适用其它同步方法。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步方法的访问都被暂时阻塞。

  5. 以上规则对其它对象锁同样适用。

再来举例

代码示例1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Thread1 implements Runnable {
	public void run() {
		synchronized (this) {
			for (int i = 0; i < 5; i++) {
				System.out.println(Thread.currentThread().getName()
						+ " synchronized loop " + i);
			}
		}
	}

	public static void main(String[] args) {
		Thread1 t1 = new Thread1();
		Thread ta = new Thread(t1, "A");
		Thread tb = new Thread(t1, "B");
		ta.start();
		tb.start();
	}
}

运行结果：

A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4

当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

代码示例2

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
34
35
36
37
38
39
40
41
42
public class Thread2 {
	public void m4t1() {
		synchronized (this) {
			int i = 5;
			while (i-- > 0) {
				System.out.println(Thread.currentThread().getName()
				+ " : " + i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException ie) {
				}
			}
		}
	}

	public void m4t2() {
		int i = 5;
		while (i-- > 0) {
			System.out.println(Thread.currentThread().getName() + " : " + i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException ie) {
			}
		}
	}

	public static void main(String[] args) {
		final Thread2 myt2 = new Thread2();
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				myt2.m4t1();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				myt2.m4t2();
			}
		}, "t2");
		t1.start();
		t2.start();
	}
}

运行结果：

t1 : 4
t2 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t1 : 0
t2 : 0

t1线程访问Thread2的一个synchronized(this)同步代码块m4t1时，t2线程仍然可以访问该Thread2中的非synchronized(this)同步代码块m4t2。

代码示例3

1
2
3
4
5
6
7
8
9
10
11
12
13
//修改代码示例2中Thread2.m4t2()方法：  
public void m4t2() {
	synchronized (this) {
		int i = 5;
		while (i-- > 0) {
			System.out.println(Thread.currentThread().getName() + " : " + i);
			try {
				Thread.sleep(500);
			} catch (InterruptedException ie) {
			}
		}
	}
}

运行结果：

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

t1线程访问Thread2的一个synchronized(this)同步代码块m4t1时，t2线程对Thread2中所有其它synchronized(this)同步代码块m4t2的访问被阻塞。

代码示例4

1
2
3
4
5
6
7
8
9
10
11
//修改Thread2.m4t2()方法如下：
public synchronized void m4t2() {
	int i = 5;
	while (i-- > 0) {
		System.out.println(Thread.currentThread().getName() + " : " + i);
		try {
			Thread.sleep(500);
		} catch (InterruptedException ie) {
		}
	}
}

运行结果：

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

t1线程访问Thread2的一个synchronized(this)同步代码块m4t1时，它就获得了这个Thread2的对象锁。结果，t2线程对该Thread2对象所有同步方法的访问都被暂时阻塞,即3的规则对同步方法也适用。

代码示例5

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class Thread3 {
	class Inner {
		private void m4t1() {
			int i = 5;
			while (i-- > 0) {
				System.out.println(Thread.currentThread().getName()
						+ " : Inner.m4t1()=" + i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException ie) {
				}
			}
		}

		private void m4t2() {
			int i = 5;
			while (i-- > 0) {
				System.out.println(Thread.currentThread().getName()
						+ " : Inner.m4t2()=" + i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException ie) {
				}
			}
		}
	}

	private void m4t1(Inner inner) { 
          synchronized(inner) { //使用对象锁 
        	  inner.m4t1(); 
          }
	}
	
    private void m4t2(Inner inner) {
        inner.m4t2();
	}

	public static void main(String[] args) {
		final Thread3 myt3 = new Thread3();
		final Inner inner = myt3.new Inner();
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				myt3.m4t1(inner);
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				myt3.m4t2(inner);
			}
		}, "t2");
		t1.start();
		t2.start();
	}
}

运行结果：

t1 : Inner.m4t1()=4
t2 : Inner.m4t2()=4
t1 : Inner.m4t1()=3
t2 : Inner.m4t2()=3
t1 : Inner.m4t1()=2
t2 : Inner.m4t2()=2
t1 : Inner.m4t1()=1
t2 : Inner.m4t2()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=0

尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。

现在在Inner.m4t2()前面加上synchronized：

1
2
3
4
5
6
7
8
9
10
11
12
//修改Inner.m4t2()方法如下：
private synchronized void m4t2() {
	int i = 5;
	while (i-- > 0) {
		System.out.println(Thread.currentThread().getName()
				+ " : Inner.m4t2()=" + i);
		try {
			Thread.sleep(500);
		} catch (InterruptedException ie) {
		}
	}
}

运行结果：

t1 : Inner.m4t1()=4
t1 : Inner.m4t1()=3
t1 : Inner.m4t1()=2
t1 : Inner.m4t1()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=4
t2 : Inner.m4t2()=3
t2 : Inner.m4t2()=2
t2 : Inner.m4t2()=1
t2 : Inner.m4t2()=0

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法。