Lock

Posted 2020-09-24

synchronized缺陷

前面我们说过synchronized的线程释放锁的情况有两种:

1. 代码块或者同步方法执行完毕

2. 代码块或者同步方法出现异常有jvm自动释放锁

从上面的synchronized释放锁可以看出，只有synchronized代码块执行完毕或者异常才会释放，如果代码块中的程序因为IO原因阻塞了，那么线程将永远不会释放锁，但是此时另外的线程还要执行其他的程序，极大的影响了程序的执行效率，现在我们需要一种机制能够让线程不会一直无限的等待下去，能够响应中断，这个通过lock就可以办到

另外如果有一个程序，包含多个读线程和一个写线程，我们可以知道synchronized只能一个一个线程的执行，但是我们需要多个读线程同时进行读，那么使用synchronized肯定是不行的，但是我们使用lock同样可以办到

Lock

查看API可知，Lock是一个接口，因此是不可以直接创建对象的，但是我们可以利用其实现的类来创建对象，这个先不着急，我们先看看Lock类到底实现了什么方法,具体的实现我们将会在介绍其实现的类的时候再详细的讲解

方法

• lock() 获取锁，如果没有获得就会一直等待

• unlock() 释放锁

• tryLock() 尝试获得锁，如果成功获得锁就执行，如果没有成功获得锁，那么就不会等待了

• lockInterruptibly() 如果当前线程未被中断，则获取锁。

ReentrantLock

ReentrantLock是可重入锁，是实现Lock接口的一个类，可重入是一种线程的分配机制，可重入的意思就是总是分配给最近获得锁的线程，这是一种不公平的分配机制，将会出现饥饿现象，当然为了解决这种现象，ReentrantLock的构造方法还提供了一个fair参数，如果fair为true表示使用公平分配机制，将会有等待时间最长的线程获得锁

构造方法

• ReentrantLock() 创建一个对象，默认使用的时可重入的机制

• ReentrantLock(boolean fair) 如果fair为true那么使用的是公平分配机制

常用方法

• lock() 获取锁，如果没有获取到将会一直阻塞

下面使用一段程序演示以下lock方法的使用，代码如下:

//实现接口的线程类public class MyThread implements Runnable {    public ReentrantLock rLock = null;  //注意这里的锁一定要是全局变量，否则每一个线程都创建一把锁，那么将会毫无意义
 
    public MyThread() {        this.rLock = new ReentrantLock(); // 创建默认的可重入锁
    }    // 将unlock方法放在finally中确保执行中代码出现异常仍然能够释放锁，否则将会造成其它的线程阻塞
    public void display() {        this.rLock.lock(); // 获取锁
        try {            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "正在输出"
                        + i);
            }
        } finally {            this.rLock.unlock(); // 释放锁，注意这步是一定需要的
        }

    }    @Override
    public void run() {        this.display(); // 调用display方法

    }

}//线程的测试类，主要是创建对象启动线程public class Test {    public static void main(String[] args) {        final MyThread thread = new MyThread(); // 创建对象

        // 下面创建两个线程,并且直接启动，
        new Thread(thread).start();        new Thread(thread).start();

    }
}

执行上面的代码得到下图的结果:

从上面的结果看出，线程是一个一个输出的，并且只有等待一个线程输出完毕才能执行下一个线程，这里的仅仅是针对lock和unlock之间的代码，之外的代码并不是受到控制

注意： 这里的创建的可重入锁的对象必须对于每一个线程来说是全局的变量，是可以共享的一个对象，如果你在display方法中创建这个对象，那么是毫无意义的，因为每一个线程用的根本不是同一把锁

• boolean tryLock() 首先尝试获取锁，如果获取锁了就执行，否则就不会一直等待

下面使用一段代码尝试以下这个方法，代码如下:

//实现接口的线程类public class MyThread implements Runnable {    public ReentrantLock rLock = null; // 注意这里的锁一定要是全局变量，否则每一个线程都创建一把锁，那么将会毫无意义

    public MyThread() {        this.rLock = new ReentrantLock(); // 创建默认的可重入锁
    }    // 将unlock方法放在finally中确保执行中代码出现异常仍然能够释放锁，否则将会造成其它的线程阻塞
    public void display() {        if (this.rLock.tryLock()) // 如果获取了锁
        {            try {                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()
                            + "正在输出" + i);
                }
            } finally {                this.rLock.unlock(); // 释放锁，注意这步是一定需要的
            }

        } else {
            System.out.println(Thread.currentThread().getName()
                    + "获取锁失败，我将不会一直等待........");
        }

    }    @Override
    public void run() {        this.display(); // 调用display方法

    }

}//线程的测试类，主要是创建对象启动线程public class Test {    public static void main(String[] args) {        final MyThread thread = new MyThread(); // 创建对象

        // 下面创建两个线程,并且直接启动，
        new Thread(thread).start();        new Thread(thread).start();

    }
}

执行后的结果如下图:

从上面的结果我们知道线程0获取了锁开始执行，但是线程1并没有获取锁，但是使用的是tryLock并不是lock,因此不会一直等待下去，所以直接程序向下运行，直接跳过上锁的代码段，因此就输出了上面的那句话后直接结

ReadWriteLock

从API中可以知道，这个也是一个接口，用于实现读写线程，他有两个方法：Lock readLock(),Lock writeLock() 分别用于获得读锁和写锁，指定特定的锁可以实现特定的功能，比如读锁可以在写线程在执行的情况下可以实现多个读线程进行操作，下面我们来介绍它的具体的实现的类ReentrantReadWriteLock

ReentrantReadWriteLock

这个类也是一个可重入分配的类，当然前面已经说过了什么是可重入，现在我们来说说说这个类的详细的用法

构造方法

• ReentrantReadWriteLock() 使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock。

• ReentrantReadWriteLock(boolean fair) 使用给定的公平策略创建一个新的ReentrantReadWriteLock。

常用的方法

• ReentrantReadWriteLock.ReadLock readLock() 用于返回读取操作的锁

前面已经说过读取操作的锁是用来实现多个线程共同执行的，代码如下:

//实现接口的线程类public class MyThread implements Runnable {    public ReentrantReadWriteLock rwlock = null;    public Lock rLock = null;    public MyThread() {        this.rwlock = new ReentrantReadWriteLock(); // 创建对象，使用的是非公平的
        this.rLock = this.rwlock.readLock(); // 获取读取锁对象
    }    // 将unlock方法放在finally中确保执行中代码出现异常仍然能够释放锁，否则将会造成其它的线程阻塞
    public void display() {        this.rLock.lock(); // 获取读取锁

        try {            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "正在输出"
                        + i);
            }
        } finally {            this.rLock.unlock(); // 释放锁，注意这步是一定需要的
        }

    }    @Override
    public void run() {        this.display(); // 调用display方法

    }

}//线程的测试类，主要是创建对象启动线程public class Test {    public static void main(String[] args) {        final MyThread thread = new MyThread(); // 创建对象

        // 下面创建两个线程,并且直接启动，
        
        for(int i=0;i<5;i++)
        {            new Thread(thread).start();
        }
        


    }
}

执行上面的程序结果如下:

从上面的结果可以知道，其实使用读取操作是多个线程同时进行读取的操作，因此一定要小心谨慎的使用，根据自己的需求，一般不能在里面进行修改了，因为出现结果不准确的结果，这个就不多说了，相信大家都明白，总之要小心使用

• ReentrantReadWriteLock.WriteLock writeLock() 返回用于写入操作的锁

写入操作的锁和读取操作的锁不一样了，因为一次只能允许一个线程执行写入操作。

并且如果一个线程已经占用了读锁，另外一个线程申请写锁将会一直等待线程释放读锁。

如果一个线程已经占用了写锁，另外一个线程申请读锁，那么这个线程将会一直等待线程释放写锁才能执行。

总之意思就是写线程和读线程不能同时执行，但是多个读线程可以同时执行

下面将使用一个程序详细的体会以下读写锁的综合使用，代码如下：

//实现接口的线程类public class MyThread {    public ReentrantReadWriteLock rwlock = null;    public Lock rLock = null;    public Lock wLock = null;    public ArrayList<Integer> arrayList = null;    public MyThread() {        this.rwlock = new ReentrantReadWriteLock(); // 创建对象，使用的是非公平的
        this.rLock = this.rwlock.readLock(); // 获取读取锁对象
        arrayList = new ArrayList<>(); // 实例化
        this.wLock = this.rwlock.writeLock(); // 获取写入锁对象
    }    // 将unlock方法放在finally中确保执行中代码出现异常仍然能够释放锁，否则将会造成其它的线程阻塞

    // //向arraylist中写入数据
    public void put() {        this.wLock.lock(); // 获取写入锁
        try {            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()
                        + "正在执行写入操作，写入" + i);                this.arrayList.add(i);
            }
        } finally {            this.wLock.unlock();
        }

    }    // 从arraylist中读取数据，这里只是随机读取使用的是get，并没有做什么修改，因为这仅仅是读取操作，如果进行了修改必须实现同步
    public void get() {        this.rLock.lock(); // 获取读取操作的锁
        Random random = new Random();        if (!arrayList.isEmpty()) {            try {                for (int i = 0; i < 10; i++) {                    int index = random.nextInt(this.arrayList.size() - 1);                    int data = this.arrayList.get(index);
                    System.out.println(Thread.currentThread().getName()
                            + "正在读取数据     " + data);
                }
            } finally {                this.rLock.unlock();

            }
        } else {
            System.out.println("ArrayList为空");
        }

    }

}//线程的测试类，主要是创建对象启动线程public class Test {    public static void main(String[] args) {        final MyThread thread = new MyThread(); // 创建对象

        ArrayList<Thread> arrayList = new ArrayList<>();        /*         * 创建8个读线程，2个写线程         */
    
        for (int i = 0; i < 2; i++) {
            arrayList.add(new Thread() {                @Override
                public void run() {
                    thread.put();
                }
            });

        }        
        for(int i=0;i<8;i++)
        {
            arrayList.add(new Thread(){                @Override
                public void run() {
                    thread.get();
                }
            });
        }        
        
        
        

        for (Thread t : arrayList) {
            t.start();
        }

    }
}

结果如下图:

从上面可以看出写入线程都是一个一个执行的，读取线程是一起执行的

a