JAVA线程同步

1. public static void main(String[] args) {
2.         ThreadGroup g=new ThreadGroup("test");
3.         Thread t=null;
4.         for(int i=0;i<1000;i++)
5.         {
6.             t=new Thread(g,new R_impl(),i+"");
7.             t.start();
8.         }
9.     }
10. class R_impl implements Runnable
11. {
12.     public static int count=1;
13. //public volatile int count=1;
14.     public static Lock myLock=new ReentrantLock();
15.     public static Condition cond=myLock.newCondition();
16.     public static Object obj=new Object();
17.   
18. 1. public void run() // public volatile int count=1;
    2.     {
    3.         try
    4.         { 
    5.                 count--;
    6.                 System.out.println(count);
    7.                 count++;
    8.                 System.out.println(count);
    9.         }catch(Exception ex)
    10.         {
    11.             ex.printStackTrace();
    12.         }
    13.     }
        public void run()
19.     {
20.         try
21.         {
22.             synchronized (obj) {
23.                 count--;
24.                 System.out.println(count);
25.                 count++;
26.                 System.out.println(count);
27.             }   
28.         }catch(Exception ex)
29.         {
30.             ex.printStackTrace();
31.         }
32.     }
33.     public synchronized void run()
34.     {
35.         try
36.         {
37.         if(count<=0)
38.             this.wait();
39.         count--;
40.         System.out.println(count);
41.         count++;
42.         this.notifyAll();
43.         System.out.println(count);
44.         }catch(Exception ex)
45.         {
46.             ex.printStackTrace();
47.         }
48.     }
49.     public  void run()
50.     {
51.         try
52.         {
53.         myLock.lock();
54.         count--;
55.         System.out.println(count);
56.         count++;
57.         System.out.println(count);
58.         myLock.unlock();
59.         }catch(Exception ex)
60.         {
61.             ex.printStackTrace();
62.         }
63.     }
64.     public  void run()
65.     {
66.         myLock.lock();
67.         try
68.         {
69.         if(count<=0)
70.             cond.await();
71.         count--;
72.         System.out.println(count);
73.         count++;
74.         System.out.println(count);
75.             cond.signalAll();
76.         }catch(Exception ex)
77.         {
78.             ex.printStackTrace();
79.         }finally
80.         {
81.             myLock.unlock();
82.         }
83.     }
85. }