package com.ct.collection;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
private static AtomicInteger count = new AtomicInteger();
private static ReentrantLock write = new ReentrantLock();
private static ReentrantLock read = new ReentrantLock();
private static Condition condition = read.newCondition();
private static Condition writeCondition = write.newCondition();
//控制每次读写线程操纵数字范围
private static volatile int capacity = 2;
static class read implements Runnable {
@Override
public void run() {
try {
read.lock();
while (count.get() == 0) {
signalWrite();
}
Thread.sleep(2000);
System.out.println("read " + count.getAndDecrement());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
read.unlock();
}
}
private static void signalWrite() {
final ReentrantLock putLock = write;
putLock.lock();
try {
writeCondition.signal();
} finally {
putLock.unlock();
}
}
}
static class write implements Runnable {
@Override
public void run() {
try {
write.lock();
while (count.get() == capacity) {
writeCondition.await();
}
System.out.println("write " + count.incrementAndGet());
Thread.sleep(1000);
if (count.get() > capacity)
signalRead();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
write.unlock();
}
}
}
private static void signalRead() {
final ReentrantLock takeLock = read;
takeLock.lock();
try {
condition.signal();
} finally {
takeLock.unlock();
}
}
}
package com.ct.collection;
import java.util.concurrent.*;
public class Main {
public static void main(String[] args) {
//控制线程数量
int capacity = 10;
ExecutorService service = Executors.newFixedThreadPool(capacity);
for(int i=0;i<capacity ;i++){
service.execute(new ReentrantLockDemo.read());
service.execute(new ReentrantLockDemo.write());
}
service.shutdown();
}
}