当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法? 为什么？

不可以 ,但是在synchronized方法引用了一个全局的变量,synchronized方法

还没有运行完成的期间,在另外的一个方法中就可以修改synchronized方法的这

个变量

例如:A和B 一起去吃饭,在进一个大门,A站在门口不进去,B就不能进去,
     但是现在有个专门的老师通道,C老师和B玩得好,C就可以把B带从老师通道进去

1. /*对象的synchronized方法不能进入了，其他线程还是可以进入此对象的非同步方法的
   
2. */
   
3. public class ThreadTest {
   
4. int i = 0;
   
5. int j = 0;
   
6. 
   
7. public static void main(String[] args) {
   
8.         final ThreadTest threadTest = new ThreadTest();
   
9.         new Thread() {
   
10.                 public void run() {
    
11.                 threadTest.printI();
    
12.                 }
    
13.         }.start();
    
14. 
    
15. 
    
16. 
    
17.         new Thread() {
    
18.                 public void run() {
    
19.                 threadTest.printJ();
    
20.                 }
    
21.         }.start();
    
22. }
    
23. 
    
24.         public synchronized void printI() {
    
25.                 while (i < 100)
    
26.                 System.out.println("i==" + i++);
    
27.         }
    
28. 
    
29.         public void printJ() {
    
30.                 while (j < 50)
    
31.                 System.out.println("j==" + j++);
    
32.         }
    
33. }

复制代码

一个线程进入一个对象的一个synchronized方法后,其他线程也进入不了其对象的其他方法,因为在同一个时间内,只有一个线程有CPU执行权,而同步synchronized之后的方法,是为了让CPU执行完被同步的方法之后,释放执行权,然后再和其他线程一起竞争CPU执行权,谁拿到执行权,谁才再有执行的权利. synchronized的可以加在方法上，也可以用synchronized代码块。。。

当一个线程进入一个对象的一个synchronized方法后,其他线程也无法进入其对象的其他方法(根本进入不了任何方法),因为在同一个时间内,只有一个线程有CPU执行权,而同步synchronized之后的方法,是为了让CPU执行完被同步的方法之后,释放执行权,然后再和其他线程一起竞争CPU执行权,谁拿到执行权,谁才再有执行的权利.
如果不加同步修饰,那么当执行到某个方法的一部分语句之后,就有可能被其他CPU抢到执行权,那么容易出现错误(在操作共享数据时).
可以参考生产者和消费者代码:

1. 
   
2. class ProducerConsumerDemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 Resource r = new Resource();
   
7. 
   
8.                 Producer pro = new Producer(r);
   
9.                 Consumer con = new Consumer(r);
   
10. 
    
11.                 Thread t1 = new Thread(pro);
    
12.                 Thread t2 = new Thread(pro);
    
13.                 Thread t3 = new Thread(con);
    
14.                 Thread t4 = new Thread(con);
    
15. 
    
16.                 t1.start();
    
17.                 t2.start();
    
18.                 t3.start();
    
19.                 t4.start();
    
20. 
    
21.         }
    
22. }
    
23. 
    
24. /*
    
25. 对于多个生产者和消费者。
    
26. 为什么要定义while判断标记。
    
27. 原因：让被唤醒的线程再一次判断标记。
    
28. 
    
29. 
    
30. 为什么定义notifyAll，
    
31. 因为需要唤醒对方线程。
    
32. 因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
    
33. 
    
34. */
    
35. 
    
36. 
    
37. class Resource
    
38. {
    
39.         private String name;
    
40.         private int count = 1;
    
41.         private boolean flag = false;
    
42.                         //  t1    t2
    
43.         public synchronized void set(String name)
    
44.         {
    
45.                 while(flag)
    
46.                         try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
    
47.                 this.name = name+"--"+count++;
    
48. 
    
49.                 System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    
50.                 flag = true;
    
51.                 this.notifyAll();
    
52.         }
    
53. 
    
54. 
    
55.         //  t3   t4  
    
56.         public synchronized void out()
    
57.         {
    
58.                 while(!flag)
    
59.                         try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
    
60.                 System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
    
61.                 flag = false;
    
62.                 this.notifyAll();
    
63.         }
    
64. }
    
65. 
    
66. class Producer implements Runnable
    
67. {
    
68.         private Resource res;
    
69. 
    
70.         Producer(Resource res)
    
71.         {
    
72.                 this.res = res;
    
73.         }
    
74.         public void run()
    
75.         {
    
76.                 while(true)
    
77.                 {
    
78.                         res.set("+商品+");
    
79.                 }
    
80.         }
    
81. }
    
82. 
    
83. class Consumer implements Runnable
    
84. {
    
85.         private Resource res;
    
86. 
    
87.         Consumer(Resource res)
    
88.         {
    
89.                 this.res = res;
    
90.         }
    
91.         public void run()
    
92.         {
    
93.                 while(true)
    
94.                 {
    
95.                         res.out();
    
96.                 }
    
97.         }
    
98. }
    

复制代码