本来我是要预期得到这样的结果的：
main() count=200
count=100
当时程序执行后 得到这样结果：
main() count=100
count=100
两个方法都是同步的，
下面是代码，请大侠分析下程序执行的路径

1. package javatext;
   
2. 
   
3. public class Demo{
   
4.         public static int count = 0;
   
5.         public static synchronized void method1(){
   
6.                 count=100;
   
7.                 try {
   
8.                         Thread.sleep(3000);
   
9.                 } catch (InterruptedException e) {
   
10.                         e.printStackTrace();
    
11.                 }
    
12.                 System.out.println("count="+count);
    
13.         }
    
14.         
    
15.         //public static void method2(){
    
16.         public static synchronized void method2(){
    
17.                 count=200;
    
18.                 try {
    
19.                         Thread.sleep(1000);
    
20.                 } catch (InterruptedException e) {
    
21.                         e.printStackTrace();
    
22.                 }
    
23.                
    
24.         }
    
25. 
    
26.         
    
27.         public static void main(String[] args){
    
28.                 Thread myThread = new Thread(new MyRunnable());
    
29.                 myThread.start();
    
30.                
    
31.                
    
32.                 Demo.method2();
    
33.                 System.out.println("main() count="+count);
    
34.                 //如果后调用的是method2() 则打印出的是 main() count=200
    
35.                 //说明先执行了method2()方法，主线程休眠之后执行了 method1()方法，使count=100 MyThread线程休眠三秒，主线程
    
36.                 //执行，打印main() count=100,然后3秒后执行MyThread 打印count=100
    
37.                
    
38.                  
    
39.         }
    
40. }
    
41. 
    
42. class MyRunnable implements Runnable{
    
43.         public void run(){
    
44.                 Demo.method1();
    
45.         }
    
46. }

复制代码

楼主的执行结果是正确的，首先先明确synchronized锁的是谁，你就明白了。
如果某个synchronized方法时static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的对象所对应的Class对象，因为java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个static，synchronized方法时，他们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始执行。

楼主我刚开始也没弄明白是怎么回事但是我在两个地方加了一下System.out.println(count);
我貌似明白了主函数的运行顺序.
第一个是在method2()方法里count=200;下面加的.
第二个是在主函数最后加的.具体代码你可以自己试试.

1. 
   
2. 
   
3. public class Demo{
   
4.         public static int count = 0;
   
5.         public static synchronized void method1(){
   
6.                 count=100;
   
7.                 try {
   
8.                         Thread.sleep(3000);
   
9.                 } catch (InterruptedException e) {
   
10.                         e.printStackTrace();
    
11.                 }
    
12.                 System.out.println("count="+count);
    
13.         }
    
14.         
    
15.         //public static void method2(){
    
16.         public static synchronized void method2(){
    
17.                 count=200;
    
18.                                 System.out.println(count);
    
19.                 try {
    
20.                         Thread.sleep(1000);
    
21.                 } catch (InterruptedException e) {
    
22.                         e.printStackTrace();
    
23.                 }
    
24.                
    
25.         }
    
26. 
    
27.         
    
28.         public static void main(String[] args){
    
29.                 Thread myThread = new Thread(new MyRunnable());
    
30.                 myThread.start();
    
31.                
    
32.                
    
33.                 Demo.method2();
    
34.                 System.out.println("main() count="+count);
    
35.                 //如果后调用的是method2() 则打印出的是 main() count=200
    
36.                 //说明先执行了method2()方法，主线程休眠之后执行了 method1()方法，使count=100 MyThread线程休眠三秒，主线程
    
37.                 //执行，打印main() count=100,然后3秒后执行MyThread 打印count=100
    
38.                
    
39.                                 System.out.println(count);
    
40.                  
    
41.         }
    
42. }
    
43. 
    
44. class MyRunnable implements Runnable{
    
45.         public void run(){
    
46.                 Demo.method1();
    
47.         }
    
48. }

复制代码

运行结果是这个
这就说明在主函数运行时,开启线程语句和Demo.method2()应该是是在method1()之前运行的,
我已经反复试验多次,每次都是先打印出200,也许这就是多线程的作用.主函数是一个线程你自己
又建立了一个线程,这个都是同时在执行的,但是你的线程由于休眠,所以当主函数已经运行三个除了
你自己建立的线程以外,还等了三秒才输出count=100的.

龙秋地 发表于 2012-6-20 20:55
楼主我刚开始也没弄明白是怎么回事但是我在两个地方加了一下System.out.println(count);
我貌似明白了主函 ...

我仔细分析了下原来程序时这样执行的，程序先执行的是主线程的method2() 把count设成了200没错，确实这样，我debug 了一下是这样的，并且myThread线程已经锁住了method1()和methos2()方法，所以即使myThread 睡眠了1秒，主线程依然无法执行method1()方法，当myThread线程醒来时，他并不是立即去执行System.out.println("main() count="+count);如果是这样的话，那结果就是

Main() count=200了，说明程序这时执行了主线程的method1(),这样b又被设为100，当前线程睡眠3秒，这时候才来执行

System.out.println("main() count="+count)，3秒后主线程醒来，执行

System.out.println("count="+count);

这样打印的结果就为：

main() count=100

count=100

当我把System.out.println("main() count="+count); 这句放在method2()方法里时理所当然的程序结果就为：

main() count=200

count=100

李元峰 发表于 2012-6-20 21:25
我仔细分析了下原来程序时这样执行的，程序先执行的是主线程的method2() 把count设成了200没错，确实这样 ...

我已经完全迷糊了,我想知道的是myThread()线程是怎么锁住两个method()方法的.
过程能详细说明一下不?是不是锁住的意思是就是睡眠了.
怎么线程醒来后就解锁了吗?就可以执行method1()方法了?
怎么解的锁?

龙秋地 发表于 2012-6-20 21:48
我已经完全迷糊了,我想知道的是myThread()线程是怎么锁住两个method()方法的.
过程能详细说明一下不?是不 ...

是这样的，如果都是同步的方法，只要有一个线程进入了一个同步方法，那么这个对象的所有同步的方法都会被当前线程锁定，当其他线程再来访问这个对象的同步方法时，他也想锁定该对象的所有的同步方法，当时发现他的所有的同步方法已经被别的线程锁住了，只有当之前的那个线程访问完之后，就交出锁，这样，后来的那个线程才能再去锁定这个对象的同步方法

李元峰 发表于 2012-6-20 21:56
是这样的，如果都是同步的方法，只要有一个线程进入了一个同步方法，那么这个对象的所有同步的方法都会被 ...

恩 明白了.
谢谢.
:L太不好意思了 明明是你问题,结果变成我问你回答了.

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class,Demo类有两个静态同步方法，那么其中的一个方法被调用时，Demo.class对象的锁被锁住。因此，没有其他线程可以条用统一各类的其他的的同步静态方法。
我调试了一下，得到的结果是：
main() count=100
count=100
我感觉原因是你只启动了Demo.method1()的线程，而没有启动Demo.method2()的线程。所以method2（）不会和method1（）形成 同步竞争，如果想实现你想要的答案
，可以把method2（）加到run方法里。

孙胜录 发表于 2012-6-20 23:06
静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class,Demo类有两个静态同步方法，那么其 ...

有竞争的，你可以到 分别到method1() 和method2() 方法里面去打印信息，看看有没有竞争