synchronized和java.util.concurrent.locks.Lock的异同

相同点

主要相同点：Lock能完成synchronized所实现的所有功能

不同点

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，
而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，
例如，它的tryLock方法可以非阻塞方式去拿锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadTest {
     /**
      * @param args
      */
     private int j;
     private Lock lock = new ReentrantLock();
     public static void main(String[] args) {
          // TODO Auto-generated method stub
          ThreadTest tt = new ThreadTest();
          for(int i=0;i<2;i++)
          {
              new Thread(tt.new Adder()).start();
              new Thread(tt.new Subtractor()).start();
          }
     }
     private class Subtractor implements Runnable
     {
          @Override
          public void run() {
              // TODO Auto-generated method stub
              while(true)
              {
                   /*synchronized (ThreadTest.this) {              
                        System.out.println("j--=" + j--);
                        //这里抛异常了，锁能释放吗？
                   }*/
                   lock.lock();
                   try
                   {
                        System.out.println("j--=" + j--);
                   }finally
                   {
                        lock.unlock();
                   }
              }
          }
     }
     private class Adder implements Runnable
     {
          @Override
          public void run() {
              // TODO Auto-generated method stub
              while(true)
              {
                   /*synchronized (ThreadTest.this) {
                   System.out.println("j++=" + j++);
                   }*/
                   lock.lock();
                   try
                   {
                        System.out.println("j++=" + j++);
                   }finally
                   {
                        lock.unlock();
                   }                  
              }             
          }
     }
}

使用synchronized实现同步的过程中更多的是取决于机器给予的结果，而使用lock()能够更好的去管理线程，显式地调用线程去完成不一样的同步，这样能够提高和工作效率，当然还有其他方面的知识点，这是我关于线程的初步了解，还可以使用线程框架更加简洁的去封装和实现同样的功能，这都是关于线程安全方面的问题了，在就是我对这两个词的了解和使用

本文标题:synchronized和java.util.concurrent.locks.Lock的异同

文章作者:Xhong

发布时间:2016年11月08日 - 21时59分

最后更新:2016年11月08日 - 22时14分

原始链接:http://lxh5431.github.io/2016/11/08/synchronized和java-util-concurrent-locks-Lock的异同/

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 相同点
  2. 2. 不同点
,