java读书笔记-对象的锁

package thread;

class Testsyn extends Thread
{

      Private static volatile int i = 0;

       public Testsyn(String str)
       ...{
             super(str);
       }

       public synchronized void sleepen()
       ...{
             try
             ...{
                  System.out.println(Thread.currentThread().getName()
                                         +" want to sleep sometimes " + ++i);
                  sleep(1000);

                  System.out.println(Thread.currentThread().getName()
                                         +" wake up");

                  System.out.println(Thread.currentThread().getName()
                                         +" want to sleep again");

                  sleep(2000);

                  System.out.println(Thread.currentThread().getName()
                                         + " wake up again");

             }catch(InterruptedException e)
             ...{
                   e.printStackTrace();
             }
       }

       public void run()
       ...{
             while(true)
             ...{
               sleepen();
             }
       }
}
 
public class Testsynchronized
{
   public static void main(String[] abc) throws Exception
   ...{
          System.out.println("this is the main Thread");

          Testsyn

          sy = new Testsyn("t1"),  //生成t1线程.

          syn = new Testsyn("t2"); //生成t2线程.

          sy.start();

          Thread.sleep(2000);//sy线程启动后2秒在启动syn线程.

          syn.start();

          new Timeout(5000,"timeout");//5秒之后结束所有线程,Timeout是TIJ里面的一个类.
   }
}
... ...

Result:

this   is  the main Thread

t1 want to sleep sometimes  1

t1 wake up

t1 want to sleep again

t2 want to sleep sometimes  2

t2 wake up

t2 want to sleep again

t1 wake up again

t1 want to sleep sometimes  3

t1 wake up

t1 want to sleep again

t2 wake up again

t2 want to sleep sometimes  4

t2 wake up

t2 want to sleep again

t1 wake up again

t1 want to sleep sometimes  5

timeout

t1 wake up

t1 want to sleep again

   分析:

       类Testsyn的sleepen函数实现了同步,从运行结果来看,可以得出结论,就是每一个对象都有一把锁,

且只有一把,设任一Testsyn对象A的某一个线程占用了这把锁,A的其他线程就只能等待锁的释放.然而A

某 个线程占用了自身对象的锁,并使用某个资源p,但并不能阻止Testsyn另外一个对象B的某个线程也同时

访 问该资源p,对象B自身也有唯一的一把锁,当B的某个线程占用了锁,B的其他线程就必须等待.那么对象

A 和对象B都能同时访问加了同步控制的sleepen()函数,并对资源p进行操作.