Java:使用synchronized和Lock对象获取对象锁

1. 
   
2.   
3. 在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。   
4. 1.对象的锁   
5. 所有对象都自动含有单一的锁。   
6. JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。   
7. 只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。   
8. 每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。   
9. 2.synchronized同步块   
10. 2.1同步到单一对象锁   
11. 当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。   
12. Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象 synchronized (this)），所以对它们的方法依然是互斥的。   
13. Resource1.java   
14. package com.zj.lock;   
15. import java.util.concurrent.TimeUnit;   
16.     
17. public class Resource1 {   
18.     public void f() {   
19.        // other operations should not be locked...   
20.        System.out.println(Thread.currentThread().getName()   
21.               + ":not synchronized in f()");   
22.        synchronized (this) {   
23.            for (int i = 0; i < 5; i++) {   
24.               System.out.println(Thread.currentThread().getName()   
25.                      + ":synchronized in f()");   
26.               try {   
27.                   TimeUnit.SECONDS.sleep(3);   
28.               } catch (InterruptedException e) {   
29.                   e.printStackTrace();   
30.               }   
31.            }   
32.        }   
33.     }   
34.     
35.     public void g() {   
36.        // other operations should not be locked...   
37.        System.out.println(Thread.currentThread().getName()   
38.               + ":not synchronized in g()");   
39.        synchronized (this) {   
40.            for (int i = 0; i < 5; i++) {   
41.               System.out.println(Thread.currentThread().getName()   
42.                      + ":synchronized in g()");   
43.               try {   
44.                   TimeUnit.SECONDS.sleep(3);   
45.               } catch (InterruptedException e) {   
46.                   e.printStackTrace();   
47.               }   
48.            }   
49.        }   
50.     }   
51.     
52.     public void h() {   
53.        // other operations should not be locked...   
54.        System.out.println(Thread.currentThread().getName()   
55.               + ":not synchronized in h()");   
56.        synchronized (this) {   
57.            for (int i = 0; i < 5; i++) {   
58.               System.out.println(Thread.currentThread().getName()   
59.                      + ":synchronized in h()");   
60.               try {   
61.                   TimeUnit.SECONDS.sleep(3);   
62.               } catch (InterruptedException e) {   
63.                   e.printStackTrace();   
64.               }   
65.            }   
66.        }   
67.     }   
68.     
69.     public static void main(String[] args) {   
70.        final Resource1 rs = new Resource1();   
71.     
72.        new Thread() {   
73.            public void run() {   
74.               rs.f();   
75.            }   
76.        }.start();   
77.     
78.        new Thread() {   
79.            public void run() {   
80.               rs.g();   
81.            }   
82.        }.start();   
83.     
84.        rs.h();   
85.     }   
86. }   
87. 结果：   
88. Thread-0:not synchronized in f()   
89. Thread-0:synchronized in f()   
90. main:not synchronized in h()   
91. Thread-1:not synchronized in g()   
92. Thread-0:synchronized in f()   
93. Thread-0:synchronized in f()   
94. Thread-0:synchronized in f()   
95. Thread-0:synchronized in f()   
96. Thread-1:synchronized in g()   
97. Thread-1:synchronized in g()   
98. Thread-1:synchronized in g()   
99. Thread-1:synchronized in g()   
100. Thread-1:synchronized in g()   
101. main:synchronized in h()   
102. main:synchronized in h()   
103. main:synchronized in h()   
104. main:synchronized in h()   
105. main:synchronized in h()   
106. 2.2 同步到多个对象锁   
107. Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（synchronized (this)，synchronized (syncObject1)，synchronized (syncObject2)），所以对它们的方法中的临界资源访问是独立的。   
108. Resource2.java   
109. package com.zj.lock;   
110. import java.util.concurrent.TimeUnit;   
111.     
112. public class Resource2 {   
113.     private Object syncObject1 = new Object();   
114.     private Object syncObject2 = new Object();   
115.     
116.     public void f() {   
117.        // other operations should not be locked...   
118.        System.out.println(Thread.currentThread().getName()   
119.               + ":not synchronized in f()");   
120.        synchronized (this) {   
121.            for (int i = 0; i < 5; i++) {   
122.               System.out.println(Thread.currentThread().getName()   
123.                      + ":synchronized in f()");   
124.               try {   
125.                   TimeUnit.SECONDS.sleep(3);   
126.               } catch (InterruptedException e) {   
127.                   e.printStackTrace();   
128.               }   
129.            }   
130.        }   
131.     }   
132.     
133.     public void g() {   
134.        // other operations should not be locked...   
135.        System.out.println(Thread.currentThread().getName()   
136.               + ":not synchronized in g()");   
137.        synchronized (syncObject1) {   
138.            for (int i = 0; i < 5; i++) {   
139.               System.out.println(Thread.currentThread().getName()   
140.                      + ":synchronized in g()");   
141.               try {   
142.                   TimeUnit.SECONDS.sleep(3);   
143.               } catch (InterruptedException e) {   
144.                   e.printStackTrace();   
145.               }   
146.            }   
147.        }   
148.     }   
149.     
150.     public void h() {   
151.        // other operations should not be locked...   
152.        System.out.println(Thread.currentThread().getName()   
153.               + ":not synchronized in h()");   
154.        synchronized (syncObject2) {   
155.            for (int i = 0; i < 5; i++) {   
156.               System.out.println(Thread.currentThread().getName()   
157.                      + ":synchronized in h()");   
158.               try {   
159.                   TimeUnit.SECONDS.sleep(3);   
160.               } catch (InterruptedException e) {   
161.                   e.printStackTrace();   
162.               }   
163.            }   
164.        }   
165.     }   
166.     
167.     public static void main(String[] args) {   
168.        final Resource2 rs = new Resource2();   
169.     
170.        new Thread() {   
171.            public void run() {   
172.               rs.f();   
173.            }   
174.        }.start();   
175.     
176.        new Thread() {   
177.            public void run() {   
178.               rs.g();   
179.            }   
180.        }.start();   
181.     
182.        rs.h();   
183.     }   
184. }   
185. 结果：   
186. Thread-0:not synchronized in f()   
187. Thread-0:synchronized in f()   
188. main:not synchronized in h()   
189. main:synchronized in h()   
190. Thread-1:not synchronized in g()   
191. Thread-1:synchronized in g()   
192. Thread-0:synchronized in f()   
193. main:synchronized in h()   
194. Thread-1:synchronized in g()   
195. Thread-0:synchronized in f()   
196. main:synchronized in h()   
197. Thread-1:synchronized in g()   
198. Thread-0:synchronized in f()   
199. main:synchronized in h()   
200. Thread-1:synchronized in g()   
201. Thread-0:synchronized in f()   
202. main:synchronized in h()   
203. Thread-1:synchronized in g()   
204. 3.Lock对象锁   
205. 除了使用synchronized外，还可以使用Lock对象来创建临界区。Resource3.java的演示效果同Resource1.java；Resource4.java的演示效果同Resource2.java。   
206. Resource3.java   
207. package com.zj.lock;   
208. import java.util.concurrent.TimeUnit;   
209. import java.util.concurrent.locks.Lock;   
210. import java.util.concurrent.locks.ReentrantLock;   
211.     
212. public class Resource3 {   
213.     private Lock lock = new ReentrantLock();   
214.     
215.     public void f() {   
216.        // other operations should not be locked...   
217.        System.out.println(Thread.currentThread().getName()   
218.               + ":not synchronized in f()");   
219.        lock.lock();   
220.        try {   
221.            for (int i = 0; i < 5; i++) {   
222.               System.out.println(Thread.currentThread().getName()   
223.                      + ":synchronized in f()");   
224.               try {   
225.                   TimeUnit.SECONDS.sleep(3);   
226.               } catch (InterruptedException e) {   
227.                   e.printStackTrace();   
228.               }   
229.            }   
230.        } finally {   
231.            lock.unlock();   
232.        }   
233.     }   
234.     
235.     public void g() {   
236.        // other operations should not be locked...   
237.        System.out.println(Thread.currentThread().getName()   
238.               + ":not synchronized in g()");   
239.        lock.lock();   
240.        try {   
241.            for (int i = 0; i < 5; i++) {   
242.               System.out.println(Thread.currentThread().getName()   
243.                      + ":synchronized in g()");   
244.               try {   
245.                   TimeUnit.SECONDS.sleep(3);   
246.               } catch (InterruptedException e) {   
247.                   e.printStackTrace();   
248.               }   
249.            }   
250.        } finally {   
251.            lock.unlock();   
252.        }   
253.     }   
254.     
255.     public void h() {   
256.        // other operations should not be locked...   
257.        System.out.println(Thread.currentThread().getName()   
258.               + ":not synchronized in h()");   
259.        lock.lock();   
260.        try {   
261.            for (int i = 0; i < 5; i++) {   
262.               System.out.println(Thread.currentThread().getName()   
263.                      + ":synchronized in h()");   
264.               try {   
265.                   TimeUnit.SECONDS.sleep(3);   
266.               } catch (InterruptedException e) {   
267.                   e.printStackTrace();   
268.               }   
269.            }   
270.        } finally {   
271.            lock.unlock();   
272.        }   
273.     }   
274.     
275.     public static void main(String[] args) {   
276.        final Resource3 rs = new Resource3();   
277.     
278.        new Thread() {   
279.            public void run() {   
280.               rs.f();   
281.            }   
282.        }.start();   
283.     
284.        new Thread() {   
285.            public void run() {   
286.               rs.g();   
287.            }   
288.        }.start();   
289.     
290.        rs.h();   
291.     }   
292. }   
293. 结果：   
294. Thread-0:not synchronized in f()   
295. Thread-0:synchronized in f()   
296. main:not synchronized in h()   
297. Thread-1:not synchronized in g()   
298. Thread-0:synchronized in f()   
299. Thread-0:synchronized in f()   
300. Thread-0:synchronized in f()   
301. Thread-0:synchronized in f()   
302. main:synchronized in h()   
303. main:synchronized in h()   
304. main:synchronized in h()   
305. main:synchronized in h()   
306. main:synchronized in h()   
307. Thread-1:synchronized in g()   
308. Thread-1:synchronized in g()   
309. Thread-1:synchronized in g()   
310. Thread-1:synchronized in g()   
311. Thread-1:synchronized in g()   
312. Resource4.java   
313. package com.zj.lock;   
314. import java.util.concurrent.TimeUnit;   
315. import java.util.concurrent.locks.Lock;   
316. import java.util.concurrent.locks.ReentrantLock;   
317.     
318. public class Resource4 {   
319.     private Lock lock1 = new ReentrantLock();   
320.     private Lock lock2 = new ReentrantLock();   
321.     private Lock lock3 = new ReentrantLock();   
322.     
323.     public void f() {   
324.        // other operations should not be locked...   
325.        System.out.println(Thread.currentThread().getName()   
326.               + ":not synchronized in f()");   
327.        lock1.lock();   
328.        try {   
329.            for (int i = 0; i < 5; i++) {   
330.               System.out.println(Thread.currentThread().getName()   
331.                      + ":synchronized in f()");   
332.               try {   
333.                   TimeUnit.SECONDS.sleep(3);   
334.               } catch (InterruptedException e) {   
335.                   e.printStackTrace();   
336.               }   
337.            }   
338.        } finally {   
339.            lock1.unlock();   
340.        }   
341.     }   
342.     
343.     public void g() {   
344.        // other operations should not be locked...   
345.        System.out.println(Thread.currentThread().getName()   
346.               + ":not synchronized in g()");   
347.        lock2.lock();   
348.        try {   
349.            for (int i = 0; i < 5; i++) {   
350.               System.out.println(Thread.currentThread().getName()   
351.                      + ":synchronized in g()");   
352.               try {   
353.                   TimeUnit.SECONDS.sleep(3);   
354.               } catch (InterruptedException e) {   
355.                   e.printStackTrace();   
356.               }   
357.            }   
358.        } finally {   
359.            lock2.unlock();   
360.        }   
361.     }   
362.     
363.     public void h() {   
364.        // other operations should not be locked...   
365.        System.out.println(Thread.currentThread().getName()   
366.               + ":not synchronized in h()");   
367.        lock3.lock();   
368.        try {   
369.            for (int i = 0; i < 5; i++) {   
370.               System.out.println(Thread.currentThread().getName()   
371.                      + ":synchronized in h()");   
372.               try {   
373.                   TimeUnit.SECONDS.sleep(3);   
374.               } catch (InterruptedException e) {   
375.                   e.printStackTrace();   
376.               }   
377.            }   
378.        } finally {   
379.            lock3.unlock();   
380.        }   
381.     }   
382.     
383.     public static void main(String[] args) {   
384.        final Resource4 rs = new Resource4();   
385.     
386.        new Thread() {   
387.            public void run() {   
388.               rs.f();   
389.            }   
390.        }.start();   
391.     
392.        new Thread() {   
393.            public void run() {   
394.               rs.g();   
395.            }   
396.        }.start();   
397.     
398.        rs.h();   
399.     }   
400. }   
401. 结果：   
402. Thread-0:not synchronized in f()   
403. Thread-0:synchronized in f()   
404. main:not synchronized in h()   
405. main:synchronized in h()   
406. Thread-1:not synchronized in g()   
407. Thread-1:synchronized in g()   
408. Thread-0:synchronized in f()   
409. main:synchronized in h()   
410. Thread-1:synchronized in g()   
411. Thread-0:synchronized in f()   
412. main:synchronized in h()   
413. Thread-1:synchronized in g()   
414. Thread-0:synchronized in f()   
415. main:synchronized in h()   
416. Thread-1:synchronized in g()   
417. Thread-0:synchronized in f()   
418. main:synchronized in h()   
419. Thread-1:synchronized in g()