同步锁对象为什么不能定义在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. }

复制代码

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

不知道解释的对不对，坐等大神

1. class A implements Runnable{
   
2. 
   
3. int i=10;
   
4. 
   
5. Object obj=new Object();//必须要放在run() 方法外面，是为了确保的锁的唯一性。你创建了4个线程，如果Object obj=new Object()这句代码放在run()方法里面，每次启动一个线程的时候实际上都是创建了一个新new出来的 Object对象，每个obj的内存地址是不同的。锁的唯一性是synchronized代码块应用的前提。希望能够帮你解答疑惑
   
6. public void run() {
   
7. 
   
8. synchronized (obj) {
   
9. 
   
10. 
    
11. 
    
12. while(true){
    
13. 
    
14. if(i>0){
    
15. 
    
16. try {
    
17. 
    
18. Thread.sleep(10);
    
19. 
    
20. } catch (InterruptedException e) {
    
21. 
    
22. e.printStackTrace();
    
23. 
    
24. }
    
25. 
    
26. System.out.println(Thread.currentThread().getName()+":"+i--);
    
27. 
    
28. }
    
29. 
    
30. 
    
31. 
    
32. }
    
33. 
    
34. }
    
35. 
    
36. }
    
37. 
    
38. }
    
39. 
    
40. public class Test{
    
41. 
    
42. public static void main(String[] args){
    
43. 
    
44. 
    
45. 
    
46. A a=new A();
    
47. 
    
48. Thread t=new Thread(a);
    
49. 
    
50. Thread t1=new Thread(a);
    
51. 
    
52. Thread t2=new Thread(a);
    
53. 
    
54. Thread t3=new Thread(a);
    
55. 
    
56. 
    
57. 
    
58. t.start();
    
59. 
    
60. t1.start();
    
61. 
    
62. t2.start();
    
63. 
    
64. t3.start();
    
65. 
    
66. }
    
67. 
    
68. }
    

复制代码

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