Java多线程篇二

这是一个系列文章：

  1. Java多线程篇1
  2. Java多线程篇3

本篇主要的内容是：

  1. volatile关键字
  2. LockSupport类使用
  3. Lock类使用

volatile关键字

要动volatile关键字的使用，需要对java的内存模型&共享变量的可见性有一定的了解。在JVM中，共享变量存储在主内存中，每个线程都有一个私有的本地内存，本地内存保存了该线程使用到的主内存的副本拷贝，线程对该变量的所有操作都必须在私有存中进行，而不能直接读写主内存中的变量。

20180613171711160.png

在线程A中将共享变量修改为了某个值，这时候还没有同步到主内存中，然后线程B中保留了共享内存的旧值，就会导致共享变量值不一致，要解决这种方式最简单的就是加锁，但是使用synchronized或者是Lock等的方式会太重量了，比较合理的方式就是实用volatile。

volatile的特性：

  1. 保证可见性，不保证原子性。当些一个volatile变量的时候，JVM会把线程本地内存也同步到主内存中，这个写操作会导致其他线程中的volatile变量缓存无效。
  2. 禁止指令重排

一个简单的例子，我们可以不使用synchronized那么重量级的来实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
static class JmmDemo implements Runnable {
    //不加入 volatile，不会打印子线程结束。。。
    public  boolean flag = true;
    public void run() {
        System.out.println("子线程执行。。。");
        while (flag) { // 如果flag为true就会一直循环，不会结束
        }
        System.out.println("子线程结束。。。");
    }
}
public static void main(String[] args) throws InterruptedException {
    JmmDemo demo = new JmmDemo();
    Thread t = new Thread(demo);
    t.start();
    Thread.sleep(100);
    demo.flag = false;
    System.out.println("已经修改为false");
    System.out.println(demo.flag);
}

我们就可以不用synchronized去实现这样的一个功能，同时synchronized也无法避免指令的重排，它能做的是原子性，可见性和有序性。
参考文章：

  1. Java volatile关键字最全总结：原理剖析与实例讲解(简单易懂)
  2. 内存可见性以及synchronized实现可见性和Volatile实现可见性

LockSupport

LockSupport是java.util.concurrent.locks包下的一个类，可以用于暂停线程和恢复线程，它是使用Unsafe实现的，它的方法如下：

  1. park() : 暂停某个线程
  2. LockSupport.unpark(t1) :唤起某个线程

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
// 打印的时间会>=2000
 Thread t1 = new Thread() {
            @Override
            public void run() {
                super.run();
                long start = System.currentTimeMillis();
                LockSupport.park();
                System.out.println(System.currentTimeMillis() - start);
            }
        };
        t1.start();
        Thread.sleep(2000);
        LockSupport.unpark(t1);

参考文章：LockSupport详解

Lock

Lock与synchronized是租用是比较类似的，但是它的使用范围会更广更优雅，Lock可以手动的释放锁，获取锁，可中断的获取锁，超时获取锁，相对而言会更加的灵活，同时它也可以用于替换wait/notify的那一套，避免可能出现的死锁(没有唤起wait())，比如多个生产者1个消费者的这种情况。

Lock是一个接口，定义如下

1
2
3
4
5
6
7
8
public interface Lock {
    void lock(); //获得锁
    void lockInterruptibly() throws InterruptedException; //获得锁，可中断，比如当两个线程通知通过该方法想获取锁的时候，假如线程A获取到了，而线程B只在等待，那么对现场B调用threadB.interrupt()则能够中断线程B的等待过程。
    boolean tryLock(); //锁在空闲的时候才能获取(未获取到不会等待)，比如两个线程都调用该方法，线程A获取到了，线程B则不会等待直接放弃获取
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException; //如果锁可用则返回true，如果锁不可用，则当前线程
    void unlock(); //释放锁
    Condition newCondition();
}

Lock的实现代表类是ReentrantLock(可重入锁)，我们先看下ReentrantLock，它是依靠CAS和LockSupport实现的，先看下面一个简单的例子(用于替换synchronized)：

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
// lock()方法会阻塞住，直到能获取锁
    private static int x = 0;
    private static void add() {
        x++;
    }
    private static void reduce() {
        x--;
    }
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                lock.t2.interrupt();();
                try {
                    for (int i = 0; i < 100000; i++) {
                        add();
                    }
                    System.out.println(x);
                } finally {
                    lock.unlock();
                }

            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                lock.lock();
                try {
                    for (int i = 0; i < 100000; i++) {
                        reduce();
                    }
                    System.out.println(x);
                } finally {
                    lock.unlock();
                }
            }
        };
        t1.start();
        t2.start();
    }

只会打印100000,0或者是-100000,0，作用是与synchronized类似，需要注意的是我们都需要在finally中调用unlock()方法，避免程序运行出现了异常没有释放锁。
它的构造函数：

1
2
3
4
5
6
7
8
//  非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}
//  true为公平，false为不公平
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

非公平与公平锁的不同

  1. 非公平锁在调用lock之后，首先会调用CAS进行一次抢夺，假如锁没有被占用，就直接获取锁返回
  2. 非公平锁在CSA失败后，和公平锁一样进入tryAcquire，假如发现这时候锁被释放了，非公平锁就会直接CAS枪锁，但是公平锁会判断等待队列是由有线程处于等待状态，有就不会去抢夺，乖乖排在后面。
  3. 假如在tryAcquire抢夺失败，则线程进入阻塞状态。

相对而言，非公平锁性能更好，当然非公平锁让获取锁的时间变得更加不确定，可能导致阻塞队列中的线程长期处于饥饿状态。文章来源：理解ReentrantLock的公平锁和非公平锁
使用了更多API的例子：

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
// trylock() 例子，返回false的时候不阻塞，可以向下继续运行
ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                super.run();
                boolean flag = lock.tryLock();
                if (flag) {
                    try {
                        System.out.println("t1 true");
                    } finally {
                        lock.unlock();
                    }
                } else {
                    System.out.println("t1 false");
                }

            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                super.run();
                boolean flag = lock.tryLock();
                if (flag) {
                    try {
                        System.out.println("t2 true");
                    } finally {
                        lock.unlock();
                    }
                } else {
                    System.out.println("t2 false");
                }
            }
        };
        t1.start();
        t2.start();
        
//tryLock(long time, TimeUnit unit) 的例子
// 假如能够获得锁，它会立即执行，假如无法获得锁，他的会等待time，等待之后到时之后假如获得锁了就返回true继续执行，否则就跳出。假如在等待的过程中所在线程被中断了，则会收到中断抛出InterruptedException
Thread t1 = new Thread() {
            @Override
            public void run() {
                super.run();
                boolean flag;
                try {
                    flag = lock.tryLock(2, TimeUnit.SECONDS);
                    if (flag) {
                        try {
                            System.out.println("t1 true");
                            Thread.sleep(3000);
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        System.out.println("t1 false");
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                super.run();
                boolean flag = false;
                try {
                    flag = lock.tryLock(2, TimeUnit.SECONDS);
                    if (flag) {
                        try {
                            System.out.println("t2 true");
                            Thread.sleep(3000);
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        System.out.println("t2 false");
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        t1.start();
        t2.start();

// 通过lockInterruptibly()获取锁的时候，没有获取到的会阻塞住。没有获取到锁的时候，假如线程中断了则会抛出异常。
 static Thread t1, t2;

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        t1 = new Thread() {
            @Override
            public void run() {
                super.run();
                try {
                    lock.lockInterruptibly();
                    try {
                        System.out.println("t1 true");
                    } finally {
                        System.out.println("t1 unlock");
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };

        t2 = new Thread() {
            @Override
            public void run() {
                super.run();
                try {
                    lock.lockInterruptibly();
                    try {
                        System.out.println("t2 true");

                    } finally {
                        System.out.println("t2 unlock");
                        lock.unlock();
                    }

                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        t1.start();
        t2.start();
        t1.interrupt();
        t2.interrupt();
    }

synchronized与ReentrantLock的比较

  1. synchronized是独占锁，加锁和解锁过程自动进行，易于操作。ReentrantLock也是独占锁，加锁和解锁需要手动，不易操作，但是非常灵活
  2. synchronized可重入，因为加锁和解锁自动运行，不必担心最后锁是否释放。ReentrantLock也可以重入，但是加锁和解锁需要手动进行，而且次数需要一样。
  3. synchronized不可响应中断，一个线程获取不到锁就只能一直等待，ReentrantLock可以响应中断。

ReentrantLock的lock方法调用需要再try块之外，假如是获取锁成功了的，则需要再finally中释放锁。

ReentrantLock还有一个Condition newCondition()方法，可以用于平替wait/notify。Condition是一个接口，它的定义是：

1
2
3
4
5
6
7
8
9
public interface Condition {
    void await() throws InterruptedException; // 释放当前线程并阻塞，可以被中断
    void awaitUninterruptibly(); //
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    boolean awaitUntil(Date deadline) throws InterruptedException;
    void signal();
    void signalAll();
}

它大体与Object的wait/notify机制差不多,其中await()对应的wait()，signal()对应的notify()。Condition的await()与signal()都必须在lock()和unlock()之间才能使用。

我们使用wait/notify在设计生产者与消费者的时候，假如是一对多的情况下，则可能会有死锁或者是多活的情况，就要么就完全的阻塞住了，不能做到一个时刻只有一个线程执行。我们每一个ReentrantLock可以有多个Condition，它们可以共用一个锁，但是可以自己去调用await()/signal()而不影响别的Condition，但是wait/notify是只能同一个锁对象，都得调用这个锁的wait/notify。例如一对多的生产-消费者，例子如下:

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
private static List<String> data = new ArrayList<>();

    public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException, InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Condition c1 = lock.newCondition();
        Condition c2 = lock.newCondition();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                super.run();
                lock.lock();
                System.out.println("t1");
                try {
                    while (true) {
                        // 只能用while
                        while (!data.isEmpty()) {
                            try {
                                System.out.println("生产者->1->wait");
                                c1.await();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        System.out.println("生产者->1");
                        data.add("生产者1");
                        Thread.sleep(1000);
                        c2.signal();
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    lock.unlock();
                }

            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                super.run();
                lock.lock();
                System.out.println("t2");
                try {
                    while (true) {
                        // 只能用while
                        while (!data.isEmpty()) {
                            try {
                                System.out.println("生产者->2->wait");
                                c1.await();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        System.out.println("生产者->2");
                        data.add("生产者2");
                        Thread.sleep(1000);
                        c2.signal();
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    lock.unlock();
                }
            }
        };

        Thread t3 = new Thread() {
            @Override
            public void run() {
                super.run();
                lock.lock();
                System.out.println("t3");
                try {
                    while (true) {
                        // 只能用while
                        while (data.isEmpty()) {
                            try {
                                System.out.println("消费者->wait");
                                c2.await();
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                        }
                        System.out.println("消费来自:" + data.remove(0));
                        Thread.sleep(1000);
                        c1.signal();
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    lock.unlock();
                }
            }
        };
        t1.start();
        t3.start();
        t2.start();
    }

参考文章：

  1. 求求你，别再用wait和notify了！
  2. java-锁的应用之绑定多个条件Condition

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>Skill：Java,Kotlin,RN,Flutter<br>