Java基础--多线程【Lock接口】

字数统计: 1.5k字   |   阅读时长: 6分

一、前言

在Java基础–多线程【同步机制】中，我们已经学会了使用synchronized关键字通过加锁来实现线程的同步，但通过使用我们可能会发现，这样的方式对于在哪里加了锁，哪里解开的锁不怎么好理解。

所以，在JDK5之后引入Lock接口，能够让我们显示的加锁与解锁。

二、Lock接口的基本介绍

通过Lock接口来实现线程同步，能够使程序结构更为灵活。
并且其提供了很多实用的方法，功能更强大、性能更优越。
其常用的方法如下：

void lock()：获取锁，如果锁被占用，则等待

boolean tryLock()：尝试获取锁（成功返回true、失败返回false，不阻塞）

void unlock()：释放锁

三、Lock的实现类

Lock的实现类还是有很多的(可查看Java的Lock实现类介绍)，但是最常用的两个如下：

ReentrantLock：与synchronized关键字一样具有互斥功能

ReentrantReadWriteLock：一种支持一写多读的同步锁

四、重入锁

（一）什么是可重入锁

可重入锁与不可重入锁
接下来让我们通过两个案例来进一步了解重入锁：

（二）案例
案例一

需求：有一共享资源（数组），现希望通过使用重入锁来保证往数组中添加数据是线程安全的。
代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class MyList {
    private String[] strs = {"aaa", "bbb", "", "", ""};
    private int count = 2;

    //创建锁
    Lock lock = new ReentrantLock();

    public void add(String value){
        lock.lock();
        try{
            strs[count] = value;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "添加了" + value);
            count++;
        }finally {
            lock.unlock();
        }
    }

    public String[] getStrs(){
        return this.strs;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class TestMyList {
    public static void main(String[] args) throws InterruptedException {
        test01();
    }

    private static void test01() throws InterruptedException {
        MyList list = new MyList();

        //创建任务
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                list.add("hello");
            }
        };
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                list.add("world");
            }
        };

        //创建并启动线程
        Thread t1 = new Thread(runnable1);
        Thread t2 = new Thread(runnable2);

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

        //在线程都执行完之后，才执行main中的输出语句
        t1.join();
        t2.join();
        System.out.println(Arrays.toString(list.getStrs()));
    }
}
案例二

需求：利用重入锁来实现买票程序的线程安全
代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Ticket implements Runnable{
    private int tickets = 100;

    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            lock.lock();
            try{
                if(tickets <= 0){
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖了第" + tickets + "张票");
                tickets--;
            }finally {
                lock.unlock();
            }

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class TestTicket {
    public static void main(String[] args) {
        //创建任务
        Ticket ticket = new Ticket();

        //创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(4);

        //提交任务
        for (int i = 0; i < 4; i++) {
            pool.submit(ticket);
        }

        //关闭线程池
        pool.shutdown();
    }
}

五、读写锁

（一）读写锁的基本介绍

ReentrantReadWriteLock：

一种支持一写多读的同步锁，读写分离，可分别分配读锁和写锁；

支持多次分配读锁，使多个读操作可以并发执行。
其互斥规则如下：
写-写：互斥，阻塞

读-写：互斥，读阻塞写，写阻塞读

读-读：不互斥，不阻塞

在读操作远高于写操作的环境中，可在保障线程安全的前提下，提高运行效率。

（二）案例

需求：

假设有一数据，对它的读操作多于写操作。

此处设置为，18次读操作，2次写操作，请分别通过普通锁和读写锁来测试完成这些操作的总用时。

1、普通锁方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class MyClass01 {
    //创建读写锁对象
    private Lock lock = new ReentrantLock();

    private String value;

    public String getValue(){
        lock.lock();
        try{
            Thread.sleep(1000);
            System.out.println("读取数据：" + this.value);
            return this.value;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return null;
        } finally {
            lock.unlock();
        }
    }

    public void setValue(String value){
        lock.lock();
        try{
            Thread.sleep(1000);
            this.value = value;
            System.out.println("写入数据：" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class TestMyClass {
    public static void main(String[] args) {
        test01();
    }

    private static void test01() {
        //创建资源
        MyClass01 myClass = new MyClass01();

        //创建读任务
        Runnable read = new Runnable() {
            @Override
            public void run() {
                myClass.getValue();
            }
        };
        //创建写任务
        Runnable write = new Runnable() {
            @Override
            public void run() {
                myClass.setValue("Hello World");
            }
        };

        //创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(20);

        Long startTime = System.currentTimeMillis();

        //提交18个读任务、2个写任务
        for (int i = 0; i < 2; i++) {
            pool.submit(write);
        }
        for (int i = 0; i < 18; i++) {
            pool.submit(read);
        }

        //关闭线程池
        pool.shutdown();

        //利用空循环等待线程执行完毕
        while (!pool.isTerminated()){}
        //线程全部执行完毕后，计算总共用时
        System.out.println(System.currentTimeMillis() - startTime);
    }
}

测试结果：

1
2
3
4
5
写入数据：Hello World
写入数据：Hello World
读取数据：Hello World
...
20070

即：总共耗时 20070 ms（不管是读还是写的线程都需要1s执行时间）

2、读写锁方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class MyClass {
    //创建读写锁对象
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    //获取读锁
    private ReentrantReadWriteLock.ReadLock readLock = rwl.readLock();
    //获取写锁
    private ReentrantReadWriteLock.WriteLock writeLock = rwl.writeLock();

    private String value;

    public String getValue(){
        //开启读锁
        readLock.lock();
        try{
            Thread.sleep(1000);
            System.out.println("读取数据：" + this.value);
            return this.value;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return null;
        } finally {
            //释放读锁
            readLock.unlock();
        }
    }

    public void setValue(String value){
        //开启写锁
        writeLock.lock();
        try{
            Thread.sleep(1000);
            this.value = value;
            System.out.println("写入数据：" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //关闭写锁
            writeLock.unlock();
        }
    }
}

测试代码：
和普通锁的方式一样，只不过在第7行中的创建资源时，创建的对象为MyClass02即可。

1
2
3
4
5
6
7
8
9
10
11
public class TestMyClass {
    public static void main(String[] args) {
        test01();
    }

    private static void test01() {
        //创建资源
        MyClass02 myClass = new MyClass02();
        ...
    }
}

测试结果：

1
2
3
4
写入数据：Hello World
写入数据：Hello World
...
3126

即：总共耗时 3126 ms（2次写操作各占1s，18次读操作共占1s）

六、总结

关于synchronized实现同步的介绍请查看：Java并发编程：Lock
关于Lock和synchronized的区别请查看：Lock和synchronized的区别和使用
本文只是大概总结了Lock的使用，对于Lock的原理请查看：一文带你理解Java中Lock的实现原理

Java新手，若有错误，欢迎指正！

赏

都是码农，别客气了
| 阅读量次

扫一扫，分享到微信

微信分享二维码
本站总访问量: 本站总访客:

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

天下事有难易乎<br><br>为之，则难者亦易<br><br>不为，则易者亦难