synchronized(2)修饰方法之：普通方法

[同一个对象的该方法一次只有一个线程可以访问,该对象的其它同步方法也被阻塞]

 

　　方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.

　　如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法.

　　例如:

 1 public class Thread6 {
 2     /*
 3      * 同一个对象的该方法一次只有一个线程可以访问,该对象的其它同步方法也被阻塞
 4      */
 5     public synchronized void f1() {
 6         int i = 5;
 7         while (i-- > 0) {
 8             System.out.println(Thread.currentThread().getName() + " : " + i);
 9             try {
10                 Thread.sleep(500);
11             } catch (InterruptedException ie) {
12             }
13         }
14     }
15 
16     /*
17      * 同一个对象的该方法一次只有一个线程可以访问,该对象的其它同步方法也被阻塞
18      */
19     public synchronized void f2() {//
20         int i = 5;
21         while (i-- > 0) {
22             System.out.println(Thread.currentThread().getName() + " : " + i);
23             try {
24                 Thread.sleep(500);
25             } catch (InterruptedException ie) {
26             }
27         }
28     }
29 
30     public void f3() {
31         int i = 5;
32         while (i-- > 0) {
33             System.out.println(Thread.currentThread().getName() + " : " + i);
34             try {
35                 Thread.sleep(500);
36             } catch (InterruptedException ie) {
37             }
38         }
39     }
40 
41     public static void main(String[] args) {
42         final Thread6 t6 = new Thread6();
43         Thread t1 = new Thread(new Runnable() {
44             @Override
45             public void run() {
46                 t6.f1();
47             }
48         }, "t1");
49         Thread t2 = new Thread(new Runnable() {
50             @Override
51             public void run() {
52                 t6.f2();
53             }
54         }, "t2");
55         Thread t3 = new Thread(new Runnable() {
56             @Override
57             public void run() {
58                 t6.f3();
59             }
60         }, "t3");
61         t1.start();
62         t2.start();
63         t3.start();
64 
65     }
66 }

　　结果:

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