线程学习之读写锁

读写锁是指多个线程读锁不互斥，读锁和写锁互斥，写锁和写锁互斥

不多说了，看代码

package com.lyj;

import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadAndWriterLockDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        final Share s = new Share();

        // 10个读线程和10个写线程
        for (int i = 1; i <= 10; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    s.readData();
                }
            }).start();

            new Thread(new Runnable() {

                @Override
                public void run() {
                    s.writeData();
                }
            }).start();
        }
    }

}

/**
 * 加读锁：多个线程可以同时读，读的过程中不能被写线程打断 加写锁：只能同时一个写线程写，不能被读线程打断
 * 
 * @author lyj
 * 
 */
class Share {
    private Integer data = null;
    private ReadWriteLock wrl = new ReentrantReadWriteLock();

    // 读数据
    public void readData() {
        wrl.readLock().lock();
        try {
            System.out.println("开始读数据");
            Thread.sleep(1000);
            System.out.println("data= " + data);
            System.out.println("读完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            wrl.readLock().unlock();
        }

    }

    // 写数据
    public void writeData() {
        wrl.writeLock().lock();
        try {
            System.out.println("开始写数据");
            Thread.sleep(1000);
            data = new Random().nextInt();
            System.out.println("写完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            wrl.writeLock().unlock();
        }
    }
}

结果：

从结果可以看出，多个线程可以同时进入读的方法，只有他们都释放读锁后才有可能执行写的方法，只有释放了写锁后才能继续执行写方法或读方法