1. 
   
2. 
   
3. package ThreadTest;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. public class TicketTest {
   
8. 
   
9. public static void main(String[] args) {
   
10. TicketsThread tt = new TicketsThread();
    
11. Thread station1 = new Thread(tt, "售票点1");
    
12. Thread station2 = new Thread(tt, "售票点2");
    
13. Thread station3 = new Thread(tt, "售票点3");
    
14. station1.start();
    
15. station2.start();
    
16. station3.start();
    
17. }
    
18. }
    
19. 
    
20. class TicketsThread implements Runnable {
    
21. int tickets = 0;
    
22. 
    
23. public void run() {
    
24. 
    
25. Lock lock = new ReentrantLock();//注意在run方法中
    
26. while (true) {
    
27. lock.lock();
    
28. if (tickets < 100) {
    
29. tickets++;
    
30. System.out.println(Thread.currentThread().getName() + "售出第"
    
31. + tickets + "张票");
    
32. }
    
33. try {
    
34. Thread.sleep(50);
    
35. } catch (InterruptedException e) {
    
36. // TODO Auto-generated catch block
    
37. e.printStackTrace();
    
38. }
    
39. lock.unlock();
    
40. }
    
41. }
    
42. 
    
43. }

复制代码

多个线程分别创建了锁实例后对同一对象加锁，不能实现同步的原因。具体解释一下。谢了
现在我有个疑问是：“多个线程分别创建了锁实例后对同一对象加锁”，与“jvm为每个对象都关联了唯一的一把锁”。二者好像矛盾？

1. package thread;
   
2. 
   
3. import java.util.concurrent.locks.Lock;
   
4. import java.util.concurrent.locks.ReentrantLock;
   
5. 
   
6. public class TicketTest {
   
7. 
   
8.         public static void main(String[] args) {
   
9.                 TicketsThread tt = new TicketsThread();
   
10.                 Thread station1 = new Thread(tt, "售票点1");
    
11.                 Thread station2 = new Thread(tt, "售票点2");
    
12.                 Thread station3 = new Thread(tt, "售票点3");
    
13.                 station1.start();
    
14.                 station2.start();
    
15.                 station3.start();
    
16.         }
    
17. }
    
18. 
    
19. class TicketsThread implements Runnable {
    
20.         int tickets = 0;
    
21.         Lock lock = new ReentrantLock();//这儿，你把锁定义到了run()方法时，所有的线程都会运行run()方法，然后new了它们自己的lock对象，各自持有自己的锁
    
22.                                                            //所以没能实现同步
    
23.       public void run() {
    
24. 
    
25.                 // 注意在run方法中
    
26.                 while (true) {
    
27.                         lock.lock();
    
28.                         if (tickets < 100) {
    
29.                                 tickets++;
    
30.                                 System.out.println(Thread.currentThread().getName() + "售出第"
    
31.                                                 + tickets + "张票");
    
32.                         }
    
33.                         
    
34.                                 try {
    
35.                                         Thread.sleep(50);
    
36.                                 } catch (InterruptedException e) {
    
37.                                         // TODO Auto-generated catch block
    
38.                                         e.printStackTrace();
    
39.                                 }finally{
    
40.                                         lock.unlock();//这儿，你的代码中，没有把lock.unlock()用finally包起来，这儿是一定要用finally包起来的，
    
41.                                                             //保证它必须运行来释放锁，以使别的线程有机会获得锁
    
42.                                 }                                       
    
43.                 }
    
44.         }
    
45. 
    
46. }

复制代码

线程的同步是为了阻止在两个及两个以上的线程同时运行时，在对同一资源的访问时发生的冲突。对于你的这段程序来说，你声明的三个线程都应该遵循待前一个线程完全释放了资源之后，下一个线程才可以访问的。
具体应该这样加锁：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TicketTest {
       
        public static void main(String[] args) {
                TicketsThread tt = new TicketsThread();
                Thread station1 = new Thread(tt, "售票点1");
                Thread station2 = new Thread(tt, "售票点2");
                Thread station3 = new Thread(tt, "售票点3");
                station1.start();
                station2.start();
                station3.start();
        }
}

class TicketsThread implements Runnable {
        int tickets = 0;

        public void run() {

                Lock lock = new ReentrantLock();// 注意在run方法中

                while (true) {
                        lock.lock();
                        if (tickets < 100) {
                                tickets++;
                                System.out.println(Thread.currentThread().getName() + "售出第" + tickets + "张票");
                        }
                        try {
                                Thread.sleep(50);
                                lock.unlock();
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
        }

}
而你说的另一个问题：“多个线程分别创建了锁实例后对同一对象加锁”，与“jvm为每个对象都关联了唯一的一把锁”。二者好像矛盾？
以你的代码来看，这句话是矛盾的，因为你每个线程都是共享同一实例。