ReentrantReadWriteLock读写锁
2017-08-26 11:06
459 查看
合理使用ReentrantReadWriteLock能相对于ReentrantLock提高不少效率,ReentrantReadWriteLock有两种锁一种是读操作相关的锁称为“”共享锁“” ,另外一种是与写相关的锁称为“”排他锁“”。使用ReentrantReadWriteLock很好地将读写分离,使得读读可以共享(不需要同步),读写互斥,写读互斥,写写互斥。下面写测试下 读读共享,读写互斥,写读互斥,写写互斥。
1 新建一个service类:
public class MyService {
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private int number = 100;
public void readService1(){//读服务1
lock.readLock().lock();
System.out.println(number);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.readLock().unlock();
}
public void readService2(){//读服务2
lock.readLock().lock();
System.out.println(number);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.readLock().unlock();
}
public void writeService1(){//写服务1
lock.writeLock().lock();
number++;
System.out.println("number+1:"+number);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.writeLock().unlock();
}
public void writeService2(){//写服务2
lock.writeLock().lock();
number--;
System.out.println("number-1:"+number);try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.writeLock().unlock();
}
}
2 新建一个测试了:
public class Test {
public static void main(String[] args) {
MyService service = new MyService();
Thread readThread1 = new Thread(new Runnable() {
@Override
public void run() {
service.readService1();
}
});
Thread readThread2 = new Thread(new Runnable() {
@Override
public void run() {
service.readService2();
}
});
Thread writeThread1 = new Thread(new Runnable() {
@Override
public void run() {
service.writeService1();
}
});
Thread writeThread2 = new Thread(new Runnable() {
@Override
public void run() {
service.writeService2();
}
});
// 下面四行代码两两组合运行验证读写锁,读读共享,读写互斥,写读互斥,写写互斥
readThread1.start();//读线程1
readThread2.start();//读线程2
// writeThread1.start();//写线程1
// writeThread2.start();//写线程2
}
}
下面我说明下每种组合测试的实验结果:
readThread1.start();
readThread2.start();
说明:读读线程将不会同步执行,因为他们之间锁共享。控制台会很快打印出两个 100 不会看到延迟效果
readThread1.start();
writeThread1.start();
说明:读写线程将会同步执行,因为他们之间锁排斥。控制台会先打印 100 然后 等待两秒 打印出:number+1:101
writeThread1.start();
writeThread2.start();
说明:写写线程将会同步执行,因为他们之间锁排斥。控制台会先打印 number+1:101 然后 等待两秒 打印出:number-1:100
:
1 新建一个service类:
public class MyService {
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private int number = 100;
public void readService1(){//读服务1
lock.readLock().lock();
System.out.println(number);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.readLock().unlock();
}
public void readService2(){//读服务2
lock.readLock().lock();
System.out.println(number);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.readLock().unlock();
}
public void writeService1(){//写服务1
lock.writeLock().lock();
number++;
System.out.println("number+1:"+number);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.writeLock().unlock();
}
public void writeService2(){//写服务2
lock.writeLock().lock();
number--;
System.out.println("number-1:"+number);try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.writeLock().unlock();
}
}
2 新建一个测试了:
public class Test {
public static void main(String[] args) {
MyService service = new MyService();
Thread readThread1 = new Thread(new Runnable() {
@Override
public void run() {
service.readService1();
}
});
Thread readThread2 = new Thread(new Runnable() {
@Override
public void run() {
service.readService2();
}
});
Thread writeThread1 = new Thread(new Runnable() {
@Override
public void run() {
service.writeService1();
}
});
Thread writeThread2 = new Thread(new Runnable() {
@Override
public void run() {
service.writeService2();
}
});
// 下面四行代码两两组合运行验证读写锁,读读共享,读写互斥,写读互斥,写写互斥
readThread1.start();//读线程1
readThread2.start();//读线程2
// writeThread1.start();//写线程1
// writeThread2.start();//写线程2
}
}
下面我说明下每种组合测试的实验结果:
readThread1.start();
readThread2.start();
说明:读读线程将不会同步执行,因为他们之间锁共享。控制台会很快打印出两个 100 不会看到延迟效果
readThread1.start();
writeThread1.start();
说明:读写线程将会同步执行,因为他们之间锁排斥。控制台会先打印 100 然后 等待两秒 打印出:number+1:101
writeThread1.start();
writeThread2.start();
说明:写写线程将会同步执行,因为他们之间锁排斥。控制台会先打印 number+1:101 然后 等待两秒 打印出:number-1:100
:
相关文章推荐
- ReentrantReadWriteLock读写锁的使用
- JAVA多线程之——读写锁 ReentrantReadWriteLock
- ReentrantReadWriteLock读写锁的使用
- 读写锁 ReentrantReadWriteLock
- JAVA多线程之——读写锁 ReentrantReadWriteLock
- 13、java锁之读写锁ReentrantReadWriteLock.ReadLock与ReentrantReadWriteLock.WriteLock
- JAVA多线程之——读写锁 ReentrantReadWriteLock
- java 读写锁 , 官方自带示例读解,ReentrantReadWriteLock
- ReentrantReadWriteLock读写锁的使用
- JAVA多线程之——读写锁 ReentrantReadWriteLock
- 多线程编程入门(13):读写锁的使用(ReentrantReadWriteLock)
- JAVA多线程之——读写锁 ReentrantReadWriteLock
- ReentrantReadWriteLock读写锁的使用2
- 架构师养成记--14.重入锁ReentrantLock 和 读写锁 ReentrantReadWriteLock
- JAVA多线程之——读写锁 ReentrantReadWriteLock
- ReentrantReadWriteLock读写锁的使用
- ReentrantReadWriteLock读写锁的使用2
- ReentrantReadWriteLock读写锁的使用
- 多线程读写文件利器-ReentrantReadWriteLock
- ReentrantReadWriteLock读写锁详解