Java线程深入学习(四)

最新推荐文章于 2024-08-09 09:30:00 发布

xxyneymar

最新推荐文章于 2024-08-09 09:30:00 发布

阅读量145

点赞数

分类专栏： java多线程文章标签： java 多线程

本文链接：https://blog.csdn.net/xxyneymar/article/details/120420394

版权

java多线程专栏收录该内容

7 篇文章 1 订阅

订阅专栏

第五章、Lock显示锁

5.1 锁的可重入性

5.2 ReentrantLock

5.2.1 ReentrantLock的基本使用

5.2.2 ReentrantLock锁的可重入性。

5.2.3 lockInterruptibly()方法

5.2.4 tryLock()方法

5.2.5 newCondition()方法

5.2.6 公平锁与非公平锁

5.2.7 ReentrantLock的常用方法

5.3 ReentrantReadWriteLock读写锁

5.3.1 读读共享

5.3.2 写写互斥

5.3.3 读写互斥

第五章、Lock显示锁

在JDK5中增加了Lock锁接口java.util.concurrent.locks.Lock。有实现类ReentrantLock，该锁称为可重入锁，它功能比synchronized多。

5.1 锁的可重入性

锁的可重入性是指当一个线程获得一个对象锁后，再次请求该对象锁时是可以获得该对象的锁的。

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test.sm1();
            }
        }).start();
    }

    private synchronized void sm1(){
        System.out.println("同步方法1");
        //线程执行sm1()方法，默认this作为锁对象，在sm1()方法中调用了sm2()方法，注意当前线程还是持有this锁对象的
        //sm2()同步方法默认的锁对象也是this对象，要执行sm2()方法必须先获得this锁对象
        //当前this对象被当前线程持有，可以再次获得this对象，这就是锁的可重入性
        //如果锁不可重入，在此处可能就会造成死锁
        sm2();
    }

    private synchronized void sm2(){
        System.out.println("同步方法1");
        sm3();
    }

    private synchronized void sm3(){
        System.out.println("同步方法3");
    }
}

5.2 ReentrantLock

5.2.1 ReentrantLock的基本使用

调用lock()方法获得锁，调用unlock()方法释放锁。这种功能与synchronized是相似的。

//使用Lock锁同步不同方法的中的同步代码块
//在该例中两个方法中的代码块使用了同一个锁对象
public class Test {
    //定义显示锁
    static Lock lock = new ReentrantLock();
    //定义方法
    public static void sm1(){
       //经常在try代码块中获得Lock锁，在finally子句中释放锁
        try{
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "--method1--" + System.currentTimeMillis());
            Thread.sleep(new Random().nextInt(1000));
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void sm2(){
        //经常在try代码块中获得Lock锁，在finally子句中释放锁
        try{
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "--method2--" + System.currentTimeMillis());
            Thread.sleep(new Random().nextInt(1000));
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                sm1();
            }
        };
        Runnable r2 = new Runnable() {
            @Override
            public void run() {
                sm2();
            }
        };

        new Thread(r1).start();
        new Thread(r1).start();
        new Thread(r1).start();
        new Thread(r2).start();
        new Thread(r2).start();
        new Thread(r2).start();
    }
}

5.2.2 ReentrantLock锁的可重入性。

//ReentrantLock锁的可重入性
public class Test {
    public static void main(String[] args) throws InterruptedException {
        SubThread t1 = new SubThread();
        SubThread t2 = new SubThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(SubThread.num);
    }
}

class SubThread extends Thread{
    private static Lock lock = new ReentrantLock();//定义一个锁对象
    public static int num = 0;//定义变量

    @Override
    public void run() {
        for(int i = 0;i < 10000;i++){
            try{
                //可重入锁指可以反复获得该锁
                lock.lock();
                lock.lock();
                num++;
            }finally {
                lock.unlock();
                lock.unlock();
            }
        }
    }
}

5.2.3 lockInterruptibly()方法

lockInterruptibly()方法的作用：如果当前线程未被中断则获得锁，如果当前线程被中断则出现异常。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Service s = new Service();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                s.serviceMethod();
            }
        };
        Thread t1 = new Thread(r);
        t1.start();
        Thread.sleep(50);
        t1.interrupt();//注意：interrupt()不能中断在运行中的线程，它只能改变中断状态而已。
        //此时t1已经获得锁，再被设置为中断状态，因此会继续执行完

        Thread t2 = new Thread(r);
        t2.start();
        Thread.sleep(50);
        t2.interrupt(); //中断t2线程，但是实际输出中发现t2没有被中断
        //线程2处于中断状态后，再遇到lock.lockInterruptibly()就会抛出异常。
    }
}

class Service{
    private Lock lock = new ReentrantLock();//定义一个锁对象
    public void serviceMethod(){
        try{
            //lock.lock();//获得锁，此时即使调用线程的interrupt()方法，也没有真正地中断线程
            lock.lockInterruptibly();//调用了这个方法，如果线程被中断了，不会获得锁，会产生异常
            System.out.println(Thread.currentThread().getName() + "--begin lock");
            for (int i = 0;i < Integer.MAX_VALUE;i++){
                new StringBuilder();
            }
            System.out.println(Thread.currentThread().getName() + "-- end lock");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "*****释放锁");
            lock.unlock();//释放锁
        }
    }
}

对于synchronized内部锁来说，如果一个线程在等待锁，只有两个结果：要么该线程获得锁继续执行；要么就保持等待。

对于ReentrantLock可重入锁来说，提供了另外一种可能：在等待锁的过程中，程序可以根据需要取消对锁的请求。利用 lockInterruptibly()方法可以解决死锁，但是中间要等待多少秒，哪个线程被中断在实际应用中也是一个问题。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        IntLock lock1 = new IntLock(1);
        IntLock lock2 = new IntLock(2);

        Thread t1 = new Thread(lock1);
        Thread t2 = new Thread(lock2);

        t1.start();
        t2.start();

        //在main线程中，等待一会，如果还没有线程结束就中断该线程
        Thread.sleep(3000);

//        if(t1.isAlive()){
//            t1.interrupt();
//        }
        //可以通过中断任意一个线程来解决死锁
        //t2线程会放弃对锁1的申请，同时释放锁2，锁2被t1线程占有后，t1线程就会完成它的任务
        if(t2.isAlive()){
            t2.interrupt();
        }
    }
}

class IntLock implements Runnable{
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lockNum; //定义一个整数变量，来决定使用哪个锁

    public IntLock(int lockNum){
        this.lockNum = lockNum;
    }

    @Override
    public void run() {
        try {
            //此时可能出现死锁
            if(lockNum % 2 == 1){
                lock1.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + "获得锁1，还需要获得锁2");
                Thread.sleep(new Random().nextInt(500));
                lock2.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2...");
            }else{
                lock2.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + "获得锁2，还需要获得锁1");
                Thread.sleep(new Random().nextInt(500));
                lock1.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2...");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(lock1.isHeldByCurrentThread()){//如果这个锁被当前线程所占用，就释放该锁，这个方法是类ReentrantLock的方法
                lock1.unlock();
            }
            if(lock2.isHeldByCurrentThread()){
                lock2.unlock();
            }
            System.out.println(Thread.currentThread().getName() + "线程退出了");
        }
    }
}

5.2.4 tryLock()方法

tryLock(long time,TimeUnit unit)的作用是在给定等待时长内锁没有被另外的线程持有，并且当前线程也没有被中断，则获得该锁。通过该方法可以实现锁对象的限时等待。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        TimeLock timeLock = new TimeLock();

        Thread t1= new Thread(timeLock);
        Thread t2= new Thread(timeLock);

        t1.start();
        t2.start();//t1线程获得锁执行3秒后，t2线程经过了3s的等待时间，自己主动放弃申请锁，不再等待
    }
}

class TimeLock implements Runnable{
    private static ReentrantLock lock = new ReentrantLock();//定义锁对象

    @Override
    public void run() {
        try {
            if(lock.tryLock(3, TimeUnit.SECONDS)){ //获得锁返回true
                System.out.println(Thread.currentThread().getName() + "获得锁，执行耗时任务");
                Thread.sleep(4000);//4秒的耗时
            }else{//没有获得锁
                System.out.println(Thread.currentThread().getName() + "没有获得锁");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}

还有一个重载方法tryLock()，仅在调用时锁定未被其他线程持有的锁，如果调用方法时，锁对象被其他线程持有，则放弃。调用方法尝试获得锁，如果该锁没有被其他线程占用则返回true表示锁定成功；如果锁被其他线程占用则返回false，不等待。

使用tryLock()可以避免死锁。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        IntLock lock1 = new IntLock(1);
        IntLock lock2 = new IntLock(2);
        Thread t1 = new Thread(lock1);
        Thread t2 = new Thread(lock2);

        t1.start();
        t2.start();
        //运行后，使用tryLock()尝试获得锁，不会等待，通过循环不停的再次尝试，如果申请的次数足够多，线程总是会获得想要的资源
    }
}

class IntLock implements Runnable{
    private static ReentrantLock lock1 = new ReentrantLock();//定义锁对象
    private static ReentrantLock lock2 = new ReentrantLock();
    private int lockNum;//用于控制锁的顺序

    public IntLock(int lockNum){
        this.lockNum = lockNum;
    }


    @Override
    public void run() {
        if(lockNum % 2 == 0){//偶数先锁1，再锁2
            while(true){//需要不断地尝试去获得锁
                try {
                    if(lock1.tryLock()){
                        System.out.println(Thread.currentThread().getName() + "获得锁1，还想获得锁2");
                        try {
                            if(lock2.tryLock()){
                                System.out.println(Thread.currentThread().getName() + "同时获得锁1和锁2");
                                return;
                            }
                        } finally {
                            if(lock2.isHeldByCurrentThread()){
                                lock2.unlock();
                            }
                        }
                    }
                } finally {
                    if(lock1.isHeldByCurrentThread()){
                        lock1.unlock();
                    }
                }
            }
        }else{//奇数先锁2，再锁1
            while(true){//需要不断地尝试去获得锁
                try {
                    if(lock2.tryLock()){
                        System.out.println(Thread.currentThread().getName() + "获得锁2，还想获得锁1");
                        try {
                            if(lock1.tryLock()){
                                System.out.println(Thread.currentThread().getName() + "同时获得锁1和锁2");
                                return;
                            }
                        } finally {
                            if(lock1.isHeldByCurrentThread()){
                                lock1.unlock();
                            }
                        }
                    }
                }finally {
                    if(lock2.isHeldByCurrentThread()){
                        lock2.unlock();
                    }
                }
            }
        }
    }
}

5.2.5 newCondition()方法

关键字synchronized与wait()/notify()这两个方法一起使用可以实现等待/通知模式。Lock锁的newCondition方法返回Condition对象，Condition类也可以实现等待/通知模式。

使用notify()通知时，JVM会随机唤醒某个等待的线程，使用Condition类可以进行选择性通知。Condition比较常用的两个方法：

①await()：会使当前线程等待，同时会释放锁，当其他线程调用signal()时，线程会被唤醒，

可以重新获得锁并继续执行。

②signal()：用于唤醒一个等待的线程。

注意：在调用Condition的await()/signal()方法前，也需要线程持有相关的Lock锁。调用await

后线程会释放这个锁，在signal调用后会从当前Condition对象的等待队列中，唤醒一个线程，

唤醒的线程尝试获得锁，一旦获得锁成功就继续执行。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        SubThread t1 = new SubThread();
        t1.start();
        //子线程启动后，会转入等待状态

        Thread.sleep(3000);
        //主线程在睡眠3秒后，唤醒子线程的等待
        try {
            SubThread.lock.lock();//执行唤醒操作前要先获得锁
            SubThread.condition.signal();//由主线程来唤醒子线程
        } finally {
            SubThread.lock.unlock();
        }
    }
}

class SubThread extends Thread{
    //定义锁
    static Lock lock = new ReentrantLock();
    //获得Condition对象
    static Condition condition = lock.newCondition();
    @Override
    public void run() {
        try {
            lock.lock();//在调用await前必须先获得锁
            System.out.println("method begin");
            condition.await();
            System.out.println("method await");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//释放锁
            System.out.println("method unlock");
        }
    }
}

多个Condition实现通知部分线程，相较于notify()使用更灵活。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();

        new Thread(new Runnable() {
            @Override
            public void run() {
                service.waitMethodA();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                service.waitMethodB();
            }
        }).start();

        Thread.sleep(3000);
        service.signalA();//唤醒conditionA对象上的等待，conditionB对象上的线程依然继续等待
        //即可以指定部分线程进行唤醒


    }
}

class Service{
    //定义锁
    static Lock lock = new ReentrantLock();
    //获得Condition对象
    static Condition conditionA = lock.newCondition();
    static Condition conditionB = lock.newCondition();

    //定义方法，使用conditionA等待
    public void waitMethodA(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "begin wait: " + System.currentTimeMillis());
            conditionA.await();
            System.out.println(Thread.currentThread().getName() + "end wait: " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //定义方法，使用conditionB等待
    public void waitMethodB(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "begin wait: " + System.currentTimeMillis());
            conditionB.await();
            System.out.println(Thread.currentThread().getName() + "end wait: " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //定义方法唤醒ConditionA对象上的等待
    public void signalA(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "signal A time = " + System.currentTimeMillis());
            conditionA.signal();
            System.out.println(Thread.currentThread().getName() + "signal A time = " + System.currentTimeMillis());
        } finally {
            lock.unlock();
        }
    }

    //定义方法唤醒ConditionA对象上的等待
    public void signalB(){
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "signal B time = " + System.currentTimeMillis());
            conditionB.signal();
            System.out.println(Thread.currentThread().getName() + "signal B time = " + System.currentTimeMillis());
        } finally {
            lock.unlock();
        }
    }
}

使用Condition实现生产者/消费者设计模式，即两个线程交替打印。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 100;i++){
                    myService.printOne();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i = 0;i < 100;i++){
                    myService.printTwo();
                }
            }
        }).start();
    }
}

class MyService{
    //定义锁
    private Lock lock = new ReentrantLock();
    //获得Condition对象
    private Condition condition = lock.newCondition();
    private boolean flag = true;//定义交替打印标志

    //定义方法只打印-----横线
    public void printOne(){
        try {
            lock.lock();
            while(flag){
                System.out.println(Thread.currentThread().getName() + "waiting-----");
                condition.await();//flag为true时，使当前线程等待
            }
            //flag为false时打印
            System.out.println(Thread.currentThread().getName() + "-----");
            flag = true;//修改交替打印标志
            condition.signal();//通知其他线程打印
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //定义方法只打印*****横线
    public void printTwo(){
        try {
            lock.lock();
            while(!flag){
                System.out.println(Thread.currentThread().getName() + "waiting*****");
                condition.await();//flag为false时，使当前线程等待
            }
            //flag为true时打印
            System.out.println(Thread.currentThread().getName() + "*****");
            flag = false;//修改交替打印标志
            condition.signal();//通知其他线程打印
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

把上述代码的signal()改为signalAll()就可以实现多线程之间的交替打印，否则会处于假死状态。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();
        
        for(int i = 0;i < 10;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 100;i++){
                        myService.printOne();
                    }
                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 100;i++){
                        myService.printTwo();
                    }
                }
            }).start();
        }
    }
}

class MyService{
    //定义锁
    private Lock lock = new ReentrantLock();
    //获得Condition对象
    private Condition condition = lock.newCondition();
    private boolean flag = true;//定义交替打印标志

    //定义方法只打印-----横线
    public void printOne(){
        try {
            lock.lock();
            while(flag){
                System.out.println(Thread.currentThread().getName() + "waiting-----");
                condition.await();//flag为true时，使当前线程等待
            }
            //flag为false时打印
            System.out.println(Thread.currentThread().getName() + "-----");
            flag = true;//修改交替打印标志
            condition.signalAll();//通知其他线程打印
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //定义方法只打印*****横线
    public void printTwo(){
        try {
            lock.lock();
            while(!flag){
                System.out.println(Thread.currentThread().getName() + "waiting*****");
                condition.await();//flag为false时，使当前线程等待
            }
            //flag为true时打印
            System.out.println(Thread.currentThread().getName() + "*****");
            flag = false;//修改交替打印标志
            condition.signalAll();//通知其他线程打印
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

5.2.6 公平锁与非公平锁

大多数情况下，锁的申请都是非公平的。如果线程1与线程2都在请求锁A，当锁A可用时，系统只是会从阻塞队列中随机的选择一个线程，不能保证其公平性。如果是非公平锁，系统倾向于让一个线程再次获得已经持有的锁，这种分配策略是高效的，非公平的。

公平的锁会按照时间先后顺序，保证先到先得，公平锁的这一特点不会出现线程饥饿现象。如果是公平锁，多个线程不会发生同一个线程连续多次获得锁的可能，保证了公平性。公平锁看起来很公平，但是要实现公平锁必须要求维护一个有序队列，公平锁的实现成本比较高，性能也低。因此默认情况下锁是非公平的，不是特别的需求，一般不使用公平锁。

synchronized内部锁就是非公平的。

ReentrantLock重入锁提供了一个构造方法：

ReentrantLock(boolean fair) 当在创建锁对象时实参传递true可以把锁设置为公平锁。

5.2.7 ReentrantLock的常用方法

①int getHoldCount(); 返回当前线程调用lock()方法的次数

②int getQueueLength(); 返回正等待获得锁的线程预估数

③int getWaitQueueLength(Condition condition); 返回与Condition条件相关的等待的线程预估数

④boolean hasQueuedThread(Thread thread); 查询参数指定的线程是否在等待获得锁

⑤boolean hasQueuedThreads(); 查询是否还有线程在等待获得该锁

⑥boolean hasWaiters(Condition condition); 查询是否有线程正在等待指定的Condition条件

⑦boolean isFair(); 判断是否为公平锁

⑧boolean isHeldByCurrentThread(); 判断当前线程是否持有该锁

⑨boolean isLocked(); 查询当前锁是否被线程持有

5.3 ReentrantReadWriteLock读写锁

synchronized内部锁与ReentrantLock锁都是独占锁(排他锁)，同一时间只允许一个线程执行同步代码块，可以保证线程的安全性，但是执行效率低。

ReentrantReadWriteLock读写锁是一种改进的排他锁，也可以称作共享/排他锁，允许多个线程同时读取共享数据，但是一次只允许一个线程对共享数据进行更新。

读写锁通过读锁与写锁来完成读写操作。线程在读取共享数据前必须先持有读锁，该读锁可以被多个线程同时持有，即它是共享的；线程在修改共享数据前必须先持有写锁，写锁是排他的，一个线程持有写锁时其他线程无法获得相应的锁(无论是读锁还是写锁都不能获得)。

读锁只是在读线程之间共享，任何一个线程持有读锁的时候，其他线程都无法获得写锁，保证线程在读取数据期间没有其他线程对数据进行更新，使得读线程能够读到数据的最新值，保证在读数据期间共享变量不被修改。

	获得条件	排他性	作用
读锁	写锁未被任意线程持有	对读线程是共享的，对写线程是排他的	允许多个线程可以同时读取共享数据，保证在读共享数据时，没有其他线程对共享数据进行修改
写锁	该写锁未被其他线程持有，并且相应的读锁也未被其他线程持有	对读线程或者写线程都是排他的	保证写线程以独占的方式修改共享数据

读写锁允许读读共享，读写互斥，写写互斥。

接口java.util.concurrent.locks.ReadWriteLock.该接口中定义了readLock()方法返回读锁，定义了writeLock()方法返回写锁。该接口的实现类是ReentrantReadWriteLock。

注意readLock()与writeLock()方法返回的锁对象是同一个锁的两个不同的角色，不是分别获得两个不同的锁。ReadWriteLock接口的实例对象可以充当两个角色。

读写锁的基本使用方法：

//定义读写锁
ReadWriteLock rwLock = new ReentrantReadWriteLock();
//获得读锁
Lock readLock = rwLock.readLock();
//获得写锁
Lock writeLock = rwLock.writeLock();
//读数据
readLock.lock();//申请读锁
try{
    读取共享数据
}finally{
    readLock.unlock();//总是在finally子句中释放锁
}
//写数据
writeLock.lock();//申请写锁
try{
    更新修改共享数据
}finally{
    writeLock.unlock();//总是在finally子句中释放锁
}

5.3.1 读读共享

ReadWriteLock读写锁可以实现多个线程同时读取共享数据，即读读共享，可以提高程序的读取数据的效率。

//ReadWriteLock读写锁可以实现读读共享，允许多个线程同时获得读锁
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        //创建5个线程
        for(int i = 0;i < 5;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    service.read();
                }
            }).start();
        }
        //运行程序后，这5个线程几乎可以同时获得读锁，执行lock()后面的代码
    }
}

class Service{
    //定义读写锁
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //定义方法读取数据
    public void read(){
        try {
            readWriteLock.readLock().lock();//获得读锁
            System.out.println(Thread.currentThread().getName() + "获得读锁，开始读取数据的时间--" + System.currentTimeMillis());
            TimeUnit.SECONDS.sleep(3);//模拟读取数据的时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();//释放读锁
        }

    }
}

5.3.2 写写互斥

通过ReadWriteLock读写锁中的写锁，只允许有一个线程执行lock()后面的代码。

//ReadWriteLock读写锁可以写写互斥，只允许一个线程持有写锁
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        //创建5个线程
        for(int i = 0;i < 5;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    service.write();
                }
            }).start();
        }
        //运行程序后，同一时间只有一个线程获得写锁，因此只能一个一个线程获得锁，然后排队执行
    }
}

class Service{
    //定义读写锁
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //定义方法更新数据
    public void write(){
        try {
            readWriteLock.writeLock().lock();//获得写锁
            System.out.println(Thread.currentThread().getName() + "获得写锁，开始更新数据的时间--" + System.currentTimeMillis());
            TimeUnit.SECONDS.sleep(3);//模拟更新数据的时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();//释放写锁
        }

    }
}

5.3.3 读写互斥

写锁是独占的，是排他锁，因此读线程与写线程也是互斥的。

一个线程获得读锁时，写线程等待；一个线程获得写锁时，其他线程(包括读线程和其余写线程)等待。

PS：根据动力节点课程整理，如有侵权，联系删除。

xxyneymar

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java线程深入学习(四)

第五章、Lock显示锁在JDK5中增加了Lock锁接口java.util.concurrent.locks.Lock。有实现类ReentrantLock，该锁称为可重入锁，它功能比synchronized多。5.1 锁的可重入性锁的可重入性是指当一个线程获得一个对象锁后，再次请求该对象锁时是可以获得该对象的锁的。public class Test { public static void main(String[] args) { Test test ...
复制链接

扫一扫

专栏目录