线程里边同步synchronized锁和lock锁有啥区别了，企业了开发怎么用要具体点用代码的形式展示出来？

Synchronized关键字定义的有同步代码块和同步函数

Synchronized(对象)

{

    需要被同步的代码(操作的是共享数据的代码);

}

对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取CPU的执行权，也进不去，因为没有获取锁。

任何对象都可作为锁，但只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。
同步函数的时候，非静态的函数的锁是this，静态的函数的锁是该类的字节码文件对象

当同步中嵌套同步,而锁却不同时，就会出现死锁。
具体的说：synchronized锁是隐式的锁，多线程时每次执行锁里的代码都要先进行判断锁是否释放，释放了才能持有锁，执行完代码后，就自动释放锁，加锁和释放锁都是隐式的
操作线程的wait()和notify()等方法都是继承的Object的，而且它要么用notify()唤醒线程池中的第一个被等待的线程，要么用notifyAll()唤醒所有被等待的线程，
它不能唤醒对方的线程：比如在多线程间通讯时，多个线程处理同一个资源，处理动作却不一样，要唤醒对方，可以创建多个Condition对象，用signal()方法来唤醒对方的等待线程。
JDK1.5中提供了多线程升级解决方案，将同步synchronized替换成显示lock操作（显示的锁机制）。将object中的wait,notify,notifyAll，替换成了Condition对象，
一个锁可以定义多个Condition对象，该对象可以Lock锁进行获取，可以实现本方只唤醒对方的等待线程。
下面用生产者和消费者的例子，分别用两种方式来体现，就可以看到区别了

1. class res
   
2. {
   
3.         private String name;
   
4.         private int count = 1;
   
5.         private boolean flag = false;
   
6.         public synchronized void set(String name)
   
7.         {
   
8.                 while(flag)
   
9.                         try
   
10.                         {
    
11.                                 wait();
    
12.                         }
    
13.                         catch (Exception e)
    
14.                         {
    
15.                         }
    
16.                 this.name=name+"=="+count++;
    
17.                 System.out.println(Thread.currentThread().getName()+"生产者..."+this.name);
    
18.                 flag = true;
    
19.                 this.notifyAll();
    
20.         }
    
21.         public synchronized void out()
    
22.         {
    
23.                 while(!flag)
    
24.                         try
    
25.                         {
    
26.                                 wait();
    
27.                         }
    
28.                         catch (Exception e)
    
29.                         {
    
30.                         }
    
31.                 System.out.println(Thread.currentThread().getName()+"消费者........"+this.name);
    
32.                 flag = false;
    
33.                 this.notifyAll();
    
34.         }
    
35. }
    
36. class Producer implements Runnable
    
37. {
    
38.         private res r;
    
39.         Producer(res r)
    
40.         {
    
41.                 this.r = r;
    
42.         }
    
43. 
    
44.         public void run()
    
45.         {
    
46.                 while (true)
    
47.                 {
    
48.                         r.set("商品");
    
49.                 }
    
50.         }
    
51. 
    
52. }
    
53. class Consumer implements Runnable
    
54. {
    
55.         private res r;
    
56.         Consumer(res r)
    
57.         {
    
58.                 this.r = r;
    
59.         }
    
60.         public void run()
    
61.         {
    
62.                 while (true)
    
63.                 {
    
64.                         r.out();
    
65.                 }
    
66.                
    
67.         }
    
68. 
    
69. 
    
70. }
    
71. class resDemo
    
72. {
    
73.         public static void main(String[] args)
    
74.         {
    
75.                 res r = new res();
    
76.                 Producer pro = new Producer(r);
    
77.                 Producer pro1 = new Producer(r);
    
78.                 Consumer con = new Consumer(r);
    
79.                 Consumer con1 = new Consumer(r);
    
80. 
    
81.                 Thread t1 = new Thread(pro);
    
82.                 Thread t2 = new Thread(con);
    
83.                 Thread t3 = new Thread(pro1);
    
84.                 Thread t4 = new Thread(con1);
    
85.                 t1.start();
    
86.                 t2.start();
    
87.                 t3.start();
    
88.                 t4.start();
    
89.         }
    
90. }
    

复制代码

分析：当出现多个线程同时生产和消费时，为了避免重复生产同一个商品的情况，要用while循环，让每个线程获取执行权后都要判断标记flag，
为了避免所有线程都是等待状态，只能用notifyAll()唤醒所有线程池中的等待线程,若用notify容易出现只唤醒本方线程的情况，这样的话，若唤醒了本方线程，会出现全部等待情况，
若都唤醒了，那在消费者还没消费完商品的时候，有可能生产者的线程唤醒了又去判断锁，但又不能执行里面的代码(因为要等消费者消费完),每次判断锁都很消耗资源。
换成显示的锁后，就可以只唤醒对方的线程，就可以解决以上问题。

1. import java.util.concurrent.locks.*;
   
2. class res
   
3. {
   
4.         private String name;
   
5.         private int count = 1;
   
6.         private boolean flag = false;
   
7. 
   
8.         private Lock lock = new ReentrantLock();
   
9.         private Condition condition_pro = lock.newCondition();
   
10.         private Condition condition_con = lock.newCondition();
    
11. 
    
12.         public  void set(String name)throws InterruptedException
    
13.         {
    
14.                 lock.lock();
    
15.                 try
    
16.                 {
    
17.                         while(flag)
    
18.                         condition_pro.await();
    
19.                         this.name=name+"=="+count++;
    
20.                         System.out.println(Thread.currentThread().getName()+"生产者..."+this.name);
    
21.                         flag = true;
    
22.                         condition_con.signal();        
    
23.                 }
    
24.                 finally
    
25.                 {
    
26.                         lock.unlock();
    
27.                 }
    
28.         }
    
29.         public  void out()throws InterruptedException
    
30.         {
    
31.                 lock.lock();
    
32.                 try
    
33.                 {
    
34.                         while(!flag)
    
35.                                 condition_con.await();
    
36.                         System.out.println(Thread.currentThread().getName()+"消费者........"+this.name);
    
37.                         flag = false;
    
38.                         condition_pro.signal();
    
39.                 }
    
40.                 finally
    
41.                 {
    
42.                         lock.unlock();
    
43.                 }
    
44.                
    
45.         }
    
46. }
    
47. class Producer implements Runnable
    
48. {
    
49.         private res r;
    
50.         Producer(res r)
    
51.         {
    
52.                 this.r = r;
    
53.         }
    
54. 
    
55.         public void run()
    
56.         {
    
57.                 while (true)
    
58.                 {
    
59.                         try
    
60.                         {
    
61.                                 r.set("商品");
    
62.                         }
    
63.                         catch (InterruptedException e)
    
64.                         {
    
65.                         }
    
66.                         
    
67.                 }
    
68.         }
    
69. 
    
70. }
    
71. class Consumer implements Runnable
    
72. {
    
73.         private res r;
    
74.         Consumer(res r)
    
75.         {
    
76.                 this.r = r;
    
77.         }
    
78.         public void run()
    
79.         {
    
80.                 while (true)
    
81.                 {
    
82.                         try
    
83.                         {
    
84.                                 r.out();
    
85.                         }
    
86.                         catch (InterruptedException e)
    
87.                         {
    
88.                         }
    
89.                         
    
90.                 }
    
91.                
    
92.         }
    
93. 
    
94. 
    
95. }
    
96. class resDemo1
    
97. {
    
98.         public static void main(String[] args)
    
99.         {
    
100.                 res r = new res();
     
101.                 Producer pro = new Producer(r);
     
102.                 Producer pro1 = new Producer(r);
     
103.                 Consumer con = new Consumer(r);
     
104.                 Consumer con1 = new Consumer(r);
     
105. 
     
106.                 Thread t1 = new Thread(pro);
     
107.                 Thread t2 = new Thread(con);
     
108.                 Thread t3 = new Thread(pro1);
     
109.                 Thread t4 = new Thread(con1);
     
110.                 t1.start();
     
111.                 t2.start();
     
112.                 t3.start();
     
113.                 t4.start();
     
114.         }
     
115. }
     

复制代码