比较synchronized与lock

发表于 | 分类于

共享资源竞争问题

在Java语言的并发编程中，由于我们不知道线程实际上在何时运行，所以在实际多线程编程中，如果两个线程访问相同的资源，那么由于线程运行的不确定性便会在这种多线程中产生访问错误。所以为了避免这一情况的发生，我们在编程的时候需要把并发执行的线程中用于访问这一共享资源的方法进行同步处理，以避免并发对于共享资源产生的影响。

并发模式在解决线程冲突的问题时，基本上都是采用序列化访问共享资源的方案。这在我的理解中，就是我们要控制同一时刻只能让一个线程对这一共享资源进行访问。

synchronized关键字的使用

synchronized对于类普通成员方法的修饰

Java语言中，每一个对象都含有单一的锁（监视器）。而synchronized的作用之一就是修饰使用了共享资源的成员方法，这样在线程通过对象调用该方法时，该对象都会被加锁。这时候如果需要调用该对象的另一个synchronized方法，则需要在第一个方法调用完毕后再进行，这就实现了最基本的同步。

例1：使用synchronized修饰方法和未修饰方法的区别
（1）使用synchronized修饰过的方法，在多线程执行的过程中，程序依次输出递增3的数字

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
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Synchronization implements Runnable {
    private static int currentCount = 0;
    synchronized void printAdd() {
        currentCount++;
        Thread.yield();
        currentCount++;
        Thread.yield();
        currentCount++;
        System.out.println(currentCount);
    }
    @Override
    public void run() {
        printAdd();
    }
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        Synchronization test = new Synchronization();
        for(int i = 0; i < 100; i++) {
            exec.execute(test);
        }
        exec.shutdown();
    }
}

（2）与之相对应的未用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
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Synchronization implements Runnable {
    private static int currentCount = 0;
    void printAdd() {
        currentCount++;
        Thread.yield();
        currentCount++;
        Thread.yield();
        currentCount++;
        System.out.println(currentCount);
    }
    @Override
    public void run() {
        printAdd();
    }
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        Synchronization test = new Synchronization();
        for(int i = 0; i < 100; i++) {
            exec.execute(test);
        }
        exec.shutdown();
    }
}

synchronized对于类静态成员方法的修饰

与对象相同，Java的每个类也有一个锁，所以我们可以通过将静态方法用synchronized修饰来控制其对于静态共享资源的访问。

Lock的使用

在上面的利用synchronized进行同步的描述中，我们都是利用方法所在对象自身的锁来进行同步。除了这种方法之外，我们还可以用Java语言中内置的锁对象来进行显式的加锁。
Lock接口，便是Java语言在java.util.concurrent.locks包中为我们提供的显式锁。目前在该包中有三个Lock的实现（基于JDK 1.7），分别为ReentrantLock,ReentrantReadWriteLock.ReadLock,ReentrantReadWriteLock.WriteLock。
Lock对象必须在程序中被显式的创建、锁定和释放。
例3：使用Lock实现多线程之间的同步

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
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest implements Runnable {
    
    private static int currentCount = 0;
    Lock lock = new ReentrantLock();
    void addCount() {
        lock.lock();
        try {
            currentCount++;
            Thread.yield();
            currentCount++;
            Thread.yield();
            currentCount++;
            System.out.println(currentCount);
        } finally {
            lock.unlock();
        }
    }
    @Override
    public void run() {
        addCount();
    }
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        LockTest test = new LockTest();
        for(int i = 0; i < 100; i++) {
            exec.execute(test);
        }
        exec.shutdown();
    }
}

synchronized与Lock的对比

在我的理解中，synchronized修饰的方法，在检查到对象已经被加锁的情况后，会等待到该对象锁被释放；之后对对象进行加锁，进行自身方法的执行。
但是Lock则不是如此，Lock可以尝试获取锁一段时间，或者尝试获取锁最后失败，而synchronized方式则不可以。综合来说，采用Lock显式锁可以完成更多并发控制功能，但是其较synchronized麻烦许多，所以根据自身程序的需要可以视情况选择这两种同步方法。