黑马程序员技术交流社区

标题: 关于同步锁问题 [打印本页]
作者: quan23355    时间: 2013-11-27 13:10
标题: 关于同步锁问题
本帖最后由 quan23355 于 2013-11-27 21:25 编辑

同步锁对象为什么不能定义在run方法里面呢？
  1. class A implements Runnable{
  2.         int i=10;
  3.         Object obj=new Object();
  4.         public void run() {
  5.                 synchronized (obj) {
  6.                
  7.                         while(true){
  8.                                 if(i>0){
  9.                                         try {
  10.                                                 Thread.sleep(10);
  11.                                         } catch (InterruptedException e) {
  12.                                                 e.printStackTrace();
  13.                                         }
  14.                                         System.out.println(Thread.currentThread().getName()+":"+i--);
  15.                                 }
  16.                                 
  17.                         }
  18.                 }
  19.         }        
  20. }
  21. public class Test{
  22.    public static void main(String[] args){
  23.            
  24.              A a=new A();
  25.              Thread t=new Thread(a);
  26.              Thread t1=new Thread(a);
  27.              Thread t2=new Thread(a);
  28.              Thread t3=new Thread(a);
  29.             
  30.              t.start();
  31.              t1.start();
  32.              t2.start();
  33.              t3.start();         
  34.    }
  35. }
复制代码



作者: Rockray    时间: 2013-11-27 15:14
本帖最后由 Rockray 于 2013-11-27 15:16 编辑

线程读锁进入被锁住的部分，在这里面运行run方法，
如果都运行run方法了，就没有再锁起来的必要了，合乎逻辑。

不知道解释的对不对，坐等大神
作者: 还不到时候    时间: 2013-11-27 15:44
  1. class A implements Runnable{

  3. int i=10;

  5. Object obj=new Object();//必须要放在run() 方法外面，是为了确保的锁的唯一性。你创建了4个线程，如果Object obj=new Object()这句代码放在run()方法里面，每次启动一个线程的时候实际上都是创建了一个新new出来的 Object对象，每个obj的内存地址是不同的。锁的唯一性是synchronized代码块应用的前提。希望能够帮你解答疑惑
  6. public void run() {

  8. synchronized (obj) {



  12. while(true){

  14. if(i>0){

  16. try {

  18. Thread.sleep(10);

  20. } catch (InterruptedException e) {

  22. e.printStackTrace();

  24. }

  26. System.out.println(Thread.currentThread().getName()+":"+i--);

  28. }



  32. }

  34. }

  36. }

  38. }

  40. public class Test{

  42. public static void main(String[] args){



  46. A a=new A();

  48. Thread t=new Thread(a);

  50. Thread t1=new Thread(a);

  52. Thread t2=new Thread(a);

  54. Thread t3=new Thread(a);



  58. t.start();

  60. t1.start();

  62. t2.start();

  64. t3.start();

  66. }

  68. }
复制代码

作者: 胡陈思    时间: 2013-11-27 18:38
同步锁对象定义在run方法外。我们考虑一下定义在方法里，会出现什么情况：
每个线程t、t1、t2、t3启动的时候，都会调用run方法，这样等于每次都创建了一个锁对象，必然会出现多个不同锁对象。
那么想一下，不同的线程启动具有自己的锁对象，那么这些线程完全可以无视锁的存在，因为自己的锁必然可以通过。那么还要锁有什么意思呢。
所以同步锁对象要定义在run方法外。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2