JAVA---Lock接口实现类ReentrantLock的五种锁,读写锁,volatile关键字

JAVA—Lock接口实现类ReentrantLock的五种锁,读写锁,volatile关键字

Lock接口实现类ReentrantLock的五种锁

//有公平锁 非公平锁  默认创建的是非公平锁
Lock l = new ReentrantLock();
//拿不到锁就一直等
l.lock();
//拿到锁返回true 没拿到锁返回false,不再等待
l.tryLock();

//拿到锁返回true ,拿不到锁在等待10秒，拿不到再返回false
try {
    l.tryLock(10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
    e.printStackTrace();
}

//拿不到锁就一直等，但是可以有其他线程中断等待
try {
    l.lockInterruptibly();
} catch (InterruptedException e) {
    e.printStackTrace();
}

//释放锁
l.unlock();

读写锁：

读锁：多个线程一起读

写锁：排他锁，一个线程得到了写锁后，其他线程不可以写，只有一个线程能够写

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

//测试读写锁，对读操作使用读锁（共享锁，多个线程读），对写操作使用写锁（排他锁，一个线程得到了写锁后，其他线程不可以写）
public class Test {
    public static void main(String[] args) {
        final Operator operator = new Operator();
        //创建5个读线程
        for (int i = 0; i < 5; i++) {
            new Thread("读线程" + i) {
                @Override
                public void run() {
                    while (true) {
                        operator.read();
                    }
                }
            }.start();
        }

        //创建5个写线程
        for (int i = 0; i < 5; i++) {
            new Thread("写线程" + i) {
                @Override
                public void run() {
                    while (true) {
                        operator.write();
                    }
                }
            }.start();
        }
    }

    static class Operator {

        private ReadWriteLock rwl = new ReentrantReadWriteLock();
        //private Lock l = new ReentrantLock();

        //读操作，使用读锁
        public void read() {
            rwl.readLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + "开始读取数据");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "读取数据完毕");
            } finally {
                rwl.readLock().unlock();
            }

        }

        //写操作，使用写锁
        public void write() {
            rwl.writeLock().lock();

            try {
                System.out.println(Thread.currentThread().getName() + "开始写数据");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "写数据完毕");
            } finally {
                rwl.writeLock().unlock();
            }

        }
    }
}

volatile关键字：一个线程修改的状态 对另一个线程是可见的（synchronized,final也可以）

//volatile 一个线程修改的状态 对另一个线程是可见的（synchronized,final也可以）
    private static volatile boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag){
//                    System.out.println("---------------");
                }
            }
        }).start();

        Thread.sleep(1000);
        flag = false;                  //不添加volatile关键字程序不会终止，因为子线程不知道主线改变了flag
    }