* synchronized方法控制对类成员变量的访问：每个类实例对应一把锁，每个被synchronized的方法都必须获得

　　* 调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释

　　* 放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声

　　* 明为 synchronized 的成员函数中至多只有一个处于可执行状态(因为至多只有一个能够获得该类实例对应的锁)，

　　* 从而有效避免了类成员变量的访问冲突(只要所有可能访问类成员变量的方法均被声明为synchronized)。

　　* 也可以将类的静态成员函数声明为synchronized ，以控制其对类的静态成员变量的访问。

　　* synchronized方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类

　　* 的方法run()声明为synchronized，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何synchronized

　　* 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为synchronized，

　　* 并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是synchronized块。

　　*

　　* synchronized是对同一个对象而言的，即一个对象在执行被synchronized锁定的方法或者代码块时是同步的(不会被打断)

　　*

　　*/

　　public class ThreadTest {
　　private void method(Object o) throws InterruptedException{
　　Thread t=Thread.currentThread();
　　synchronized(t){
　　for(int i=0;i<10;i++){
　　System.out.print(t.getName()+" ");
　　Thread.sleep(100);
　　}
　　}
　　/*

　　* 把synchronized(t)换成synchronized(o)，比较运行结果

　　* synchronized(o)要求共用一把"锁",所以要求要用同一个对象

　　* synchronized(o)起到同步效果，synchronized(t)则没同步效果

　　* 还有：用synchronized修饰method(Object o)，看效果

　*/
　　}
　　public static void main(String args[]){
　　final ThreadTest th=new ThreadTest();
　　final Object o=new Object();
　　Thread t0=new Thread( new Runnable(){
　　public void run(){
　　System.out.println("\nT0 Start");
　　try {
　　th.method(o);
　　} catch (InterruptedException e){
　　e.printStackTrace();
　　}
　　System.out.println("\nT0 End");
　　}
　　});
　　Thread t1=new Thread( new Runnable(){
　　public void run(){
　　System.out.println("\nT1 Start");
　　try {
　　th.method(o);
　　} catch (InterruptedException e){
　　e.printStackTrace();
　　}
　　System.out.println("\nT1 End");
　　}
　　});
　　t0.start();
　　t1.start();
　　}
　　}