Skip to content

Commit 4b6aac1

Browse files
brianwaybrianway
committed
java-multithread lock包更新至example10,lock包告一段落
1 parent cebf798 commit 4b6aac1

8 files changed

Lines changed: 371 additions & 0 deletions

File tree

‎java-base/src/main/java/com/brianway/learning/java/base/Boxing.java‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
*/
66

77
/**
8+
* TODO
89
* 待理解。
910
* 应该是考装箱和拆箱
1011
*/

‎java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin1.java‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
package com.brianway.learning.java.multithread.lock.example10;
2+
3+
/**
4+
* Created by Brian on 2016/4/15.
5+
*/
6+
7+
/**
8+
* P236
9+
* 类ReentrantReadWriteLock的使用：读读共享
10+
*/
11+
public class Run10_ReadWriteLockBegin1 {
12+
public static void main(String[] args) {
13+
final Service1 service = new Service1();
14+
Thread a = new Thread(){
15+
@Override
16+
public void run() {
17+
service.read();
18+
}
19+
};
20+
Thread b = new Thread(){
21+
@Override
22+
public void run() {
23+
service.read();
24+
}
25+
};
26+
a.setName("A");
27+
a.start();
28+
b.setName("B");
29+
b.start();
30+
}
31+
}
32+
33+
34+
/*
35+
输出：
36+
获得读锁A 1460726504907
37+
获得读锁B 1460726504908
38+
*/

‎java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin2.java‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
package com.brianway.learning.java.multithread.lock.example10;
2+
3+
/**
4+
* Created by Brian on 2016/4/15.
5+
*/
6+
7+
/**
8+
* P238
9+
* 类ReentrantReadWriteLock的使用：写写互斥
10+
*/
11+
public class Run10_ReadWriteLockBegin2 {
12+
public static void main(String[] args) {
13+
final Service2 service = new Service2();
14+
Thread a = new Thread(){
15+
@Override
16+
public void run() {
17+
service.write();
18+
}
19+
};
20+
Thread b = new Thread(){
21+
@Override
22+
public void run() {
23+
service.write();
24+
}
25+
};
26+
a.setName("A");
27+
a.start();
28+
b.setName("B");
29+
b.start();
30+
}
31+
}
32+
33+
34+
/*
35+
输出：
36+
获得写锁A 1460727106721
37+
获得写锁B 1460727116721
38+
*/

‎java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_ReadWriteLockBegin3.java‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
package com.brianway.learning.java.multithread.lock.example10;
2+
3+
/**
4+
* Created by Brian on 2016/4/15.
5+
*/
6+
7+
/**
8+
* P238
9+
* 类ReentrantReadWriteLock的使用：读写互斥
10+
*/
11+
public class Run10_ReadWriteLockBegin3 {
12+
public static void main(String[] args) {
13+
final Service3 service = new Service3();
14+
Thread a = new Thread(){
15+
@Override
16+
public void run() {
17+
service.read();
18+
}
19+
};
20+
Thread b = new Thread(){
21+
@Override
22+
public void run() {
23+
service.write();
24+
}
25+
};
26+
a.setName("A");
27+
a.start();
28+
b.setName("B");
29+
b.start();
30+
}
31+
}
32+
33+
34+
/*
35+
输出：
36+
获得读锁 A 1460727280066
37+
获得写锁 B 1460727290067
38+
*/

‎java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Run10_condition.java‎

Lines changed: 152 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,152 @@
1+
package com.brianway.learning.java.multithread.lock.example10;
2+
3+
/**
4+
* Created by Brian on 2016/4/15.
5+
*/
6+
7+
import java.util.concurrent.locks.Condition;
8+
import java.util.concurrent.locks.ReentrantLock;
9+
10+
/**
11+
* P234
12+
* Condition实现顺序打印
13+
* 这里nextPrintWho的volatile关键词去掉也没什么影响
14+
*/
15+
public class Run10_condition {
16+
volatile private static int nextPrintWho =1;
17+
private static ReentrantLock lock = new ReentrantLock();
18+
final private static Condition conditionA = lock.newCondition();
19+
final private static Condition conditionB = lock.newCondition();
20+
final private static Condition conditionC = lock.newCondition();
21+
public static void main(String[] args) {
22+
Thread a = new Thread(){
23+
@Override
24+
public void run() {
25+
try {
26+
lock.lock();
27+
while (nextPrintWho != 1){
28+
conditionA.await();
29+
}
30+
31+
for(int i=0;i<3;i++){
32+
System.out.println("ThreadA "+(i+1));
33+
}
34+
nextPrintWho =2;
35+
conditionB.signalAll();
36+
} catch (InterruptedException e) {
37+
e.printStackTrace();
38+
} finally {
39+
lock.unlock();
40+
}
41+
}
42+
};
43+
44+
Thread b = new Thread(){
45+
@Override
46+
public void run() {
47+
try {
48+
lock.lock();
49+
while (nextPrintWho != 2){
50+
conditionB.await();
51+
}
52+
for(int i=0;i<3;i++){
53+
System.out.println("ThreadB "+(i+1));
54+
}
55+
nextPrintWho =3;
56+
conditionC.signalAll();
57+
} catch (InterruptedException e) {
58+
e.printStackTrace();
59+
} finally {
60+
lock.unlock();
61+
}
62+
}
63+
};
64+
65+
Thread c = new Thread(){
66+
@Override
67+
public void run() {
68+
try {
69+
lock.lock();
70+
while (nextPrintWho != 3){
71+
conditionC.await();
72+
}
73+
for(int i=0;i<3;i++){
74+
System.out.println("ThreadC "+(i+1));
75+
}
76+
nextPrintWho = 1 ;
77+
conditionA.signalAll();
78+
} catch (InterruptedException e) {
79+
e.printStackTrace();
80+
} finally {
81+
lock.unlock();
82+
}
83+
}
84+
};
85+
86+
Thread[] aArray = new Thread[5];
87+
Thread[] bArray = new Thread[5];
88+
Thread[] cArray = new Thread[5];
89+
90+
for (int i = 0;i<5;i++){
91+
aArray[i] =new Thread(a);
92+
bArray[i] =new Thread(b);
93+
cArray[i] =new Thread(c);
94+
95+
aArray[i].start();
96+
bArray[i].start();
97+
cArray[i].start();
98+
}
99+
100+
101+
}
102+
}
103+
104+
/*
105+
输出：
106+
ThreadA 1
107+
ThreadA 2
108+
ThreadA 3
109+
ThreadB 1
110+
ThreadB 2
111+
ThreadB 3
112+
ThreadC 1
113+
ThreadC 2
114+
ThreadC 3
115+
ThreadA 1
116+
ThreadA 2
117+
ThreadA 3
118+
ThreadB 1
119+
ThreadB 2
120+
ThreadB 3
121+
ThreadC 1
122+
ThreadC 2
123+
ThreadC 3
124+
ThreadA 1
125+
ThreadA 2
126+
ThreadA 3
127+
ThreadB 1
128+
ThreadB 2
129+
ThreadB 3
130+
ThreadC 1
131+
ThreadC 2
132+
ThreadC 3
133+
ThreadA 1
134+
ThreadA 2
135+
ThreadA 3
136+
ThreadB 1
137+
ThreadB 2
138+
ThreadB 3
139+
ThreadC 1
140+
ThreadC 2
141+
ThreadC 3
142+
ThreadA 1
143+
ThreadA 2
144+
ThreadA 3
145+
ThreadB 1
146+
ThreadB 2
147+
ThreadB 3
148+
ThreadC 1
149+
ThreadC 2
150+
ThreadC 3
151+
152+
*/

‎java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service1.java‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
package com.brianway.learning.java.multithread.lock.example10;
2+
3+
import java.util.concurrent.locks.ReentrantReadWriteLock;
4+
5+
/**
6+
* Created by Brian on 2016/4/15.
7+
*/
8+
9+
/**
10+
* TODO
11+
* 这里为什么用双try?
12+
* 以前不都是直接try catch finally的吗？
13+
*/
14+
public class Service1 {
15+
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
16+
17+
public void read(){
18+
try {
19+
try {
20+
lock.readLock().lock();
21+
System.out.println("获得读锁"+ Thread.currentThread().getName()+" "+System.currentTimeMillis());
22+
Thread.sleep(10000);
23+
} finally {
24+
lock.readLock().unlock();
25+
}
26+
} catch (InterruptedException e) {
27+
e.printStackTrace();
28+
}
29+
}
30+
}

‎java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service2.java‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
package com.brianway.learning.java.multithread.lock.example10;
2+
3+
import java.util.concurrent.locks.ReentrantReadWriteLock;
4+
5+
/**
6+
* Created by Brian on 2016/4/15.
7+
*/
8+
9+
/**
10+
* TODO
11+
* 这里为什么用双try?
12+
* 以前不都是直接try catch finally的吗？
13+
*/
14+
public class Service2 {
15+
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
16+
17+
public void write(){
18+
try {
19+
try {
20+
lock.writeLock().lock();
21+
System.out.println("获得写锁"+ Thread.currentThread().getName()+" "+System.currentTimeMillis());
22+
Thread.sleep(10000);
23+
} finally {
24+
lock.writeLock().unlock();
25+
}
26+
} catch (InterruptedException e) {
27+
e.printStackTrace();
28+
}
29+
}
30+
}

‎java-multithread/src/main/java/com/brianway/learning/java/multithread/lock/example10/Service3.java‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
package com.brianway.learning.java.multithread.lock.example10;
2+
3+
import java.util.concurrent.locks.ReentrantReadWriteLock;
4+
5+
/**
6+
* Created by Brian on 2016/4/15.
7+
*/
8+
9+
/**
10+
* TODO
11+
* 这里为什么用双try?
12+
* 以前不都是直接try catch finally的吗？
13+
*/
14+
public class Service3 {
15+
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
16+
17+
public void read(){
18+
try {
19+
try {
20+
lock.readLock().lock();
21+
System.out.println("获得读锁 "+ Thread.currentThread().getName()+" "+System.currentTimeMillis());
22+
Thread.sleep(10000);
23+
} finally {
24+
lock.readLock().unlock();
25+
}
26+
} catch (InterruptedException e) {
27+
e.printStackTrace();
28+
}
29+
}
30+
31+
public void write(){
32+
try {
33+
try {
34+
lock.writeLock().lock();
35+
System.out.println("获得写锁 "+ Thread.currentThread().getName()+" "+System.currentTimeMillis());
36+
Thread.sleep(10000);
37+
} finally {
38+
lock.writeLock().unlock();
39+
}
40+
} catch (InterruptedException e) {
41+
e.printStackTrace();
42+
}
43+
}
44+
}

0 commit comments

Comments
 (0)