4.2 使用ReentrantReadWriteLock类

 

4.2.1　　类ReentrantReadWriterLock的使用：读读共享

package ReentrantLock;
import java.util.Calendar;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class t2 {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        
        Thread thread = new MyThread(service);
        thread.setName("A");
        
        Thread thread1 = new MyThread(service);
        thread1.setName("B");
        
        thread.start();
        thread1.start();
    }
}

class Service {
    //创建读写锁对象
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void read() {
        try {
            try {
                //读锁
                lock.readLock().lock();
                System.out.println("获得读锁 " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
                System.out.println("释放读锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }finally {
                lock.readLock().unlock();
            }
        }catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }    
    }
    
    
    
}

class MyThread extends Thread    {
    private Service service;
    
    public MyThread(Service service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.read();
    }
}

获得读锁 B 1604395552657
获得读锁 A 1604395552657
释放读锁A 1604395562663
释放读锁B 1604395562663

　从打印结果看，两个线程几乎同时进入lock()方法否面的代码，同时释放读锁。说明在此使用了lock.readLock()读锁可以提高程序运行效率，允许多个线程同时执行lock()方法后面的代码。

 

4.2.3　　类ReentrantReadWriteLock的使用：写写互斥

package ReentrantLock;
import java.util.Calendar;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class t2 {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        
        Thread thread = new MyThread(service);
        thread.setName("A");
        
        Thread thread1 = new MyThread(service);
        thread1.setName("B");
        
        thread.start();
        thread1.start();
    }
}

class Service {
    //创建读写锁对象
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void read() {
        try {
            try {
                //读锁
                lock.readLock().lock();
                System.out.println("获得读锁 " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
                System.out.println("释放读锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }finally {
                lock.readLock().unlock();
            }
        }catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }    
    }
    
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("获得写锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                System.out.println("释放写锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                lock.writeLock().unlock();
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThread extends Thread    {
    private Service service;
    
    public MyThread(Service service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        //service.read();
        service.write();
    }
}

获得写锁A 1604399442365
释放写锁A 1604399452371
获得写锁B 1604399452371
释放写锁B 1604399462376

打印结果说明，”写写“操作时互斥的，效果是同一个时间只允许一个线程执行lock()方法后面的代码。持有写锁的线程释放后，另一个线程才能持有。

 

4.2.3　　类ReentrantReadWriteLock的使用：读写互斥

package ReentrantLock;
import java.util.Calendar;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class t2 {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        
        Thread thread = new MyThread(service);
        thread.setName("A");
        thread.start();        
        
        Thread.sleep(1000);
        
        Thread thread1 = new MyThreadw(service);
        thread1.setName("B");
        thread1.start();
    }
}

class Service {
    //创建读写锁对象
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void read() {
        try {
            try {
                //读锁
                lock.readLock().lock();
                System.out.println("获得读锁 " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
                System.out.println("释放读锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }finally {
                lock.readLock().unlock();
            }
        }catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }    
    }
    
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("获得写锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                System.out.println("释放写锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                lock.writeLock().unlock();
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThread extends Thread    {
    private Service service;
    
    public MyThread(Service service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.read();
    }
}

class MyThreadw extends Thread    {
    private Service service;
    
    public MyThreadw(Service service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.write();
    }
}

获得读锁 A 1604399867367
释放读锁A 1604399877382
获得写锁B 1604399877382
释放写锁B 1604399887387

　

4.2.3　　类ReentrantReadWriteLock的使用：写读互斥

package ReentrantLock;
import java.util.Calendar;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class t2 {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        Thread thread1 = new MyThreadw(service);
        thread1.setName("B");
        thread1.start();            

        
        Thread.sleep(1000);
        
        Thread thread = new MyThread(service);
        thread.setName("A");
        thread.start();        
    }
}

class Service {
    //创建读写锁对象
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void read() {
        try {
            try {
                //读锁
                lock.readLock().lock();
                System.out.println("获得读锁 " + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
                System.out.println("释放读锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            }finally {
                lock.readLock().unlock();
            }
        }catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }    
    }
    
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("获得写锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                System.out.println("释放写锁" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
                lock.writeLock().unlock();
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThread extends Thread    {
    private Service service;
    
    public MyThread(Service service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.read();
    }
}

class MyThreadw extends Thread    {
    private Service service;
    
    public MyThreadw(Service service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.write();
    }
}

获得写锁B 1604400003110
释放写锁B 1604400013122
获得读锁 A 1604400013122
释放读锁A 1604400023124