public class T implements Runnable {
        int a=0;
       
        @Override
        public void run()
        {
                m1();
        }

        //方法m1
        public synchronized void m1()
        {
                a=1;
                try {
                        Thread.sleep(6000);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
                System.out.println("m1:a="+a);
        }
       
        //方法m2
        public void m2()
        {
                System.out.println("m2:a="+a);
        }

        //main方法
        public static void main(String[] args) throws Exception
        {
                T r1=new T();
                Thread t=new Thread(r1);
                t.start();
               
                Thread.sleep(2000);//保证线程t的run()方法执行
                r1.m2();
        }
       
        问题如下：
        当执行完t.start();后   对象r1被锁定，为什么还能调用对象r1的m2()方法？
       
        最终执行结果如下：
        m2:a=1
        m1:a=1

这个是因为你m2方法没有加锁

public class T implements Runnable {
         int a=0;
         
        @Override
         public void run()
         {
                 m1();
         }

        //方法m1
         public synchronized void m1()
         {
                 a=1;
                 try {
                         Thread.sleep(6000);
                 } catch (InterruptedException e) {
                         e.printStackTrace();
                 }
                 System.out.println("m1:a="+a);
         }
         
        //方法m2
         public synchronized void m2()　　　//这里需要加个锁；加锁表示执行前需要看下this对象是否已经被锁，如果被锁不能执行；你没有加锁，执行他之前也就不需要查看对象是否被锁，也就是说，你不加synchronized的话，就算this对象锁了，方法也可以执行
         {
                 System.out.println("m2:a="+a);
         }

        //main方法
         public static void main(String[] args) throws Exception
         {
                 T r1=new T();
                 Thread t=new Thread(r1);
                 t.start();
                 
                Thread.sleep(2000);//保证线程t的run()方法执行
                 r1.m2();
         }
}

楼主你试下，加个synchronized以的，就是先执行m1,后执行m2了

楼上正解
如果锁对象拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。

public class T implements Runnable {
        int a=0;
        
        @Override
        public void run()
        {
                m1();
        }

        //方法m1
        public synchronized void m1()
        {
                a=1;
                try {
                        Thread.sleep(6000);
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
                System.out.println("m1:a="+a);
        }
        
        //方法m2
        public void m2()
        {
                System.out.println("m2:a="+a);
        }

        //main方法
        public static void main(String[] args) throws Exception
        {
                T r1=new T();
                Thread t=new Thread(r1);
                t.start();
               
                Thread.sleep(2000);//保证线程t的run()方法执行
                r1.m2();
        }
        
        问题如下：
        当执行完t.start();后   对象r1被锁定，为什么还能调用对象r1的m2()方法？
        解答：这里涉及到多线程知识，r1是一个线程，没有对象去和他竞争资源所以并不妨碍r1.m2()的方法！
线程锁的总结：
        1.当两个以上的线程同时访问同一个对象object中的这个synchronized(this)同步代码块时，这段代码这段时间只能有一个线程访问。其他线程必须等待当前线程执行完这段代码块后才能执行该代码块
        2.当一个线程访问object的一个synchronized(this)代码块时，其他线程仍可以访问object中的非同步代码块

嗯,看来大家对多线程的理解都蛮透彻的,都是正确答案.