Java互斥同步(synchronized、ReentrantLock)

Java互斥同步

Java提供了两种锁机制来控制多个线程对共享支援的互斥访问，

第一个时JVM实现的synchronized，另一个时JDK实现的ReentrantLock。

synchronized

1. 同步一个代码块

   public void func(){
       synchronized(this){
           //具体实现
       }
   }
   

   他只作用于同一个对象，如果调用不同对象的同步代码块，就不会进行同步（或者说出现互斥）。

但是如果两个线程同时调用同一对象的同一个代码块则会发生同步，当一个线程进入同步语句块时，另一个线程必须等待：

public class SynchronizedExample {

    public void func1() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}

测试：

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e1.func1());
}

//输出结果如下：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e2.func1());
}
//输出结果如下：0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

2. 同步一个方法

public synchronized void func () {
    // ...
}

它和同步代码块一样，作用于同一个对象。

3. 同步一个类

public void func() {
    synchronized (SynchronizedExample.class) {
        // ...
    }
}

作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

4. 同步一个静态方法

public synchronized static void fun() {
    // ...
}

作用于整个类。

总结

给谁上锁？	锁了谁？	解释
锁方法：public synchronized void func1()	锁了对象	因为这个方法可能会对对象的变量做修改，所以必须把整个对象给锁住，防止方法运行过程中，对象的成员变量被修改。
锁代码块：synchronized (mutex) {}	mutex=this/object时锁对象，mutex=ClassName.class时锁类	synchronized (mutex) {}代码块可以锁具体的对象或者类，只需要把类或者对象当作参数传入即可。

ReentranLock

ReentranLock时java.util.concurrent包中的锁。

public  class LockExample{
    private Lock lock = new ReentrantLock();
    public void func(){
        lock.lock();
        try{
            for(int i = 1; i < 10; i++){
                System.out.print(i+" ");
            }
        }finally{
            lock.unlock();//必须手动释放锁，否则可能发生死锁
        }
    }
}

测试：

public static void mian(String[] args){
    LockExample lockExample = new LockExample();
    ExecutorService excutorService = Executors.newCachedThreadPool();
    excutorService.excute(() -> lockExample.func());
    excutorService.excute(() -> lockExample.func());
}
//输出结果：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

比较：

	synchronized	ReentrantLock
实现	JVM实现	JDK实现
性能	新版本对sychronized做了很多优化，性能与ReentrantLock相仿	和隔壁差不多
等待可中断	当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情	ReentrantLock可以中断，但是synchronized不行。
公平锁	synchronized是非公平锁	ReentrantLock默认是非公平锁，但是可以设置为公平锁

使用选择

除非需要使用ReentrantLock的高级功能，否则优先使用synchronized。因为synchronized时JVM实现，JVM原生支持他而ReentrantLock不是所有JDK版本都支持。并且使用synchronized不必担心因为忘记释放锁而导致死锁的问题。