synchronized和锁(ReentrantLock) 区别
java的两种同步方式， Synchronized与ReentrantLock的区别
可重入锁和不可重入锁 ReentrantLock & synchronize
1 package mianshi.test;
2
3 import java.util.concurrent.TimeUnit;
4 import java.util.concurrent.locks.ReentrantLock;
5
6 class ReentrantLockTest {
7 public static ReentrantLock reenT = new ReentrantLock();// 参数默认false，不公平锁
8 private ReentrantLock lock = new ReentrantLock(true); // 公平锁 速度慢与不公平锁
9
10 /**
11 * 使用场景:(1)比如一个定时任务,第一次定时任务未完成,重复发起了第二次,直接返回flase;
12 * (2)用在界面交互时点击执行较长时间请求操作时，防止多次点击导致后台重复执行
13 */
14 public static void tryLockTest() {
15 if (reenT.tryLock()) {
16 // 如果已经被lock，则立即返回false不会等待，
17 // 达到忽略操作的效果 ,当执行1000线程时，有些未获得对象锁的线程，会自动跳过
18 try {
19 // 操作
20 System.out.println("aaaa" + Thread.currentThread().getName());
21 } finally {
22 reenT.unlock();
23 }
24
25 }
26 }
27
28 /**
29 * 使用场景:(1)同步操作 类似于synchronized 如果被其它资源锁定，会在此等待锁释放，达到暂停的效果
30 * ReentrantLock存在公平锁与非公平锁 而且synchronized都是公平的
31 */
32 public static void lockTest() {
33 try {
34 reenT.lock(); // 如果被其它资源锁定，会在此等待锁释放，达到暂停的效果
35 // 操作
36 System.out.println("aaaa" + Thread.currentThread().getName());
37
38 } finally {
39 reenT.unlock();
40 }
41 }
42
43 /**
44 * 使用场景:(1)如果发现该操作正在执行,等待一段时间，如果规定时间未得到锁,放弃。防止资源处理不当，线程队列溢出,出现死锁
45 */
46 public static void trylockTimeTest() {
47 try {
48 if (reenT.tryLock(5, TimeUnit.SECONDS)) { // 如果已经被lock，尝试等待5s，看是否可以获得锁，如果5s后仍然无法获得锁则返回false继续执行
49 Thread.sleep(6000);
50 try {
51 // 操作
52 System.out.println("aaaa"
53 + Thread.currentThread().getName());
54 } finally {
55 reenT.unlock();
56 }
57 }
58 System.out
59 .println("如果发现该操作正在执行,等待一段时间，如果规定时间未得到锁,放弃。防止资源处理不当，线程队列溢出,出现死锁");
60 } catch (InterruptedException e) {
61 e.printStackTrace(); // 当前线程被中断时(interrupt)，会抛InterruptedException
62 }
63
64 }
65
66 /**
67 * 使用场景:(1)中断正在进行的操作立刻释放锁继续下一操作.比如 取消正在同步运行的操作，来防止不正常操作长时间占用造成的阻塞
68 */
69 public static void lockInterruptTest() {
70 try {
71 reenT.lockInterruptibly();
72 System.out.println("aaaa" + Thread.currentThread().getName());
73 } catch (InterruptedException e) {
74 e.printStackTrace();
75 } finally {
76 reenT.unlock();
77 }
78 System.out.println("(1)中断正在进行的操作立刻释放锁继续下一操作.比如 取消正在同步运行的操作，来防止不正常操作长时间占用造成的阻塞");
79 }
80
81 public void testlockInterruptTest() throws Exception {
82 final java.util.concurrent.locks.Lock lock = new ReentrantLock();
83 lock.lock();//长时间持有锁不释放，使用lockInterruptibly中断异常！！！
84 Thread.sleep(1000);
85 Thread t1 = new Thread(new Runnable() {
86 @Override
87 public void run() {
88 /*try{
89 lock.lock();
90 System.out.println("不会中断");
91 }finally{
92 lock.unlock();
93 }*/
94 try {
95 lock.lockInterruptibly();
96 } catch (InterruptedException e) {
97 e.printStackTrace();
98 }
99 System.out.println(Thread.currentThread().getName()
100 + " interrupted.");
101 }
102 });
103 t1.start();
104 Thread.sleep(1000);
105 t1.interrupt();
106 }
107
108 public static void main(String[] args) {
109
110 for (int i = 0; i < 1000; i++) {
111 new Thread(new Runnable() {
112 public void run() {
113 ReentrantLockTest.lockInterruptTest();
114 }
115 }).start();
116 }
117
118 /*try {
119 ReentrantLockTest t = new ReentrantLockTest();
120 t.testlockInterruptTest();
121 } catch (Exception e) {
122 e.printStackTrace();
123 }*/
124 }
125
126 }
来源：oschina
链接：https://my.oschina.net/u/4341165/blog/3851732