第一个例子是同一实例方法加锁和不加锁在多线程情况下的访问情况，代码如下：
package test.caipiao.log;
/**
* 一个类的同一个实例，方法加锁和不加锁情况下的访问情况.
* @author lfl
*
*/
public class Test {
public static void main(String[] args) {
final TT tt = new TT();
Thread t1 = new Thread() {
public void run() {
tt.test(); //调用加锁的test()
}
};
Thread t2 = new Thread() {
public void run() {
tt.test2(); //调用加锁的test2()
}
};
Thread t3 = new Thread() {
public void run() {
tt.test3(); //调用不加锁的test3()
}
};
/**
* t1 t2 t3 三个线程依次启动运行.
*/
t1.start();
t2.start();
t3.start();
System.out.println("over");
}
}
class TT {
public synchronized void test() {
for (int i = 0; i < 10000000; i++) {
if (i % 10000 == 0) {
System.out.println(i +"---");
}
}
}
public synchronized void test2() {
System.out.println("test2");
}
public void test3() {
System.out.println("test3");
}
}
输出如下（多次运行和不同计算机上运行输出结果可能不一样）：
over 0 --- test3 10000 --- 20000 --- 30000 --- 40000 --- 50000 --- 60000 ---
......
9910000 --- 9920000 --- 9930000 --- 9940000 --- 9950000 --- 9960000 --- 9970000 --- 9980000 --- 9990000 --- test2
说明：
主线程先输出 over,主线程没有持有tt上的锁，这里就不关心了。
t1线程输出0，此时还在持有tt上的锁，t3线程就输出test3，说明线程t1持有tt上的锁，而不影响t3线程调用test3()方法，即允许其它线程方法访问该实例的非加锁方法。而最后输出test2，是在线程t1释放了tt上的锁后
线程t3获得tt上的锁才能调用test2()方法，即一个线程持有当前实例的锁，其它线程不能访问该实例的加锁方法。
-------------------------------分割线-------------------------------------------------
第二个例子是静态方法加锁和不加锁在多线程情况下的访问情况，代码如下：
package test.caipiao.log;
/**
* 一个类的同一个实例，方法加锁和不加锁情况下的访问情况.
* @author lfl
*
*/
public class TestStatic {
public static void main(String[] args) {
final TTStatic tt = new TTStatic();
Thread t1 = new Thread() {
public void run() {
TTStatic.test(); //调用加锁的test()
}
};
Thread t2 = new Thread() {
public void run() {
TTStatic.test2(); //或者
tt.test2(); //调用加锁的test2()
}
};
Thread t3 = new Thread() {
public void run() {
TTStatic.test3(); //调用不加锁的test3()
}
};
/**
* t1 t2 t3 三个线程依次启动运行.
*/
t1.start();
t2.start();
t3.start();
System.out.println("over");
}
}
class TTStatic {
public static synchronized void test() {
for (int i = 0; i < 10000000; i++) {
if (i % 10000 == 0) {
System.out.println(i +"---");
}
}
}
public static synchronized void test2() {
System.out.println("test2");
}
public static void test3() {
System.out.println("test3");
}
}
输出如下（多次运行和不同计算机上运行输出结果可能不一样）：
0 ---
10000 ---
20000 ---
30000 ---
40000 ---
50000 ---
60000 ---
70000 ---
80000 ---
90000 ---
test3
over
100000 ---
110000 ---
120000 ---
130000 ---
......
9920000 ---
9930000 ---
9940000 ---
9950000 ---
9960000 ---
9970000 ---
9980000 ---
9990000 ---
test2
test2
说明：
基本同第一个例子的分析一样，只不过这里线程持有的是TTStatic class对象上的锁，而TTStatic class对象只有一个。需要说明的是最后输出的两个test2，这个说明调用静态的加锁方法，不论是用类名调用还是实例调用，都需要获得该类的class对象上的锁。
-------------------------------------------分割线------------------------------------------------------
第三个例子是同一实例方法加锁和不加锁在多线程情况下和静态方法加锁和不加锁在多线程情况下的访问情况，代码如下：
package test.caipiao.log;
/**
* 一个类的同一个实例，方法加锁和不加锁情况下的访问情况.
* @author lfl
*
*/
public class TestHybrid {
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
TTHybrid.test(); //调用加锁的test()
}
};
Thread t2 = new Thread() {
public void run() {
TTHybrid.test2(); //调用加锁的test2()
}
};
Thread t3 = new Thread() {
public void run() {
TTHybrid.test3(); //调用不加锁的test3()
}
};
//下面是非静态方法调用
final TTHybrid tt = new TTHybrid();
Thread t4 = new Thread() {
public void run() {
tt.test4(); //调用加锁的test4()
}
};
Thread t5 = new Thread() {
public void run() {
tt.test5(); //调用加锁的test5()
}
};
Thread t6 = new Thread() {
public void run() {
tt.test6(); //调用不加锁的test6()
}
};
/**
* t1 t2 t3 三个线程依次启动运行.
*/
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
System.out.println("over");
}
}
class TTHybrid {
public static synchronized void test() {
for (int i = 0; i < 10000000; i++) {
if (i % 10000 == 0) {
System.out.println(i +"--- static");
}
}
}
public static synchronized void test2() {
System.out.println("test2");
}
public static void test3() {
System.out.println("test3");
}
public synchronized void test4() {
for (int i = 0; i < 10000000; i++) {
if (i % 10000 == 0) {
System.out.println(i +"--- instance");
}
}
}
public synchronized void test5() {
System.out.println("test5");
}
public void test6() {
System.out.println("test6");
}
}
输出如下（多次运行和不同计算机上运行输出结果可能不一样）：
0 --- static
over
test3
0 --- instance
10000 --- static
10000 --- instance
20000 --- instance
30000 --- instance
20000 --- static
40000 --- instance
50000 --- instance
30000 --- static
60000 --- instance
40000 --- static
50000 --- static
60000 --- static
70000 --- instance
test6
90000 --- static
100000 --- instance
100000 --- static
110000 --- static
120000 --- static
110000 --- instance
130000 --- static
120000 --- instance
140000 --- static
130000 --- instance
150000 --- static
......
9960000 --- instance
9370000 --- static
9970000 --- instance
9380000 --- static
9980000 --- instance
9390000 --- static
9990000 --- instance
9400000 --- static
9410000 --- static
test5
9420000 --- static
9430000 --- static
......
9970000 --- static
9980000 --- static
9990000 --- static
test2
说明：
主线程输出的over，t3线程输出的test3和t6线程输出的test6，可以看到无论是否是静态的，持有相应的锁对该类方法的访问没有影响。接着可以看到test()和test4()方法，基本是交替调用输出的，这说明持有TTHybrid class 对象上的锁和持有tt上的锁是没有直接关系的，即持有TTHybrid class 对象上的锁访问静态方法不会影响持有tt上的锁访问非静态方法。test4()输出完毕后释放tt上的锁 后，test5()方法开始输出。test()输出完毕后释放TTHybrid class 对象上的锁 后，test2()方法开始输出。
通过这三个小例子应该对Java中实例方法和静态方法在多线程下加锁和不加锁的访问情况有了一定的了解。关于synchronized关键字的具体含义请参看其它相关资料。
