了解Synchronized与Lock的区别_synchronized lock-CSDN博客

前言：

在多线程编程中，保证线程安全是至关重要的。Java提供了两种主要的同步机制：synchronized关键字和Lock接口。尽管它们都是为了解决多线程并发访问共享资源的问题，但在使用方式和特性上存在一些显著的差异。

synchronized：

synchronized是Java中的一个关键字，用于实现多线程同步。synchronized块是Java提供的一种原子性内置锁，Java中的每个对象都可以把它当作一个同步锁来使用，这些Java内置的使用者看不到的锁被称为内部锁，也叫作监视器锁。线程的执行代码在进入synchronized代码块前会自动获取内部锁，这时候其他线程访问该同步代码块时会被阻塞挂起。拿到内部锁的线程会在正常退出同步代码块或者抛出异常后或者在同步块内调用了该内置锁资源的wit系列方法时释放该内置锁。内置锁是排它锁，也就是当一个线程获取这个锁后，其他线程必须等待该线程释放锁后才能获取该锁。另外，由于Java中的线程是与操作系统的原生线程一一对应的，所以当阻塞一个线
程时，需要从用户态切换到内核态执行阻塞操作，这是很耗时的操作，而synchronized的
使用就会导致上下文切换。

用途：

对象级别的同步：通过synchronized修饰实例方法或代码块，使得同一对象的其他线程在进入该方法或代码块前需要获取该对象的锁。这种同步机制可以避免多个线程同时对同一个对象进行修改而导致的数据不一致或错误。

代码块：

多个线程使用同一个对象案例：（串行）

@Slf4j
public class SynchronizedTest {
    

     //修饰代码块:作用范围是大括号，作用对象是调用代码块的对象。
    public void test(String name) {
        synchronized (this) {
            for (int i = 1; i <= 10; i++) {
                log.info("test1 - {} - {}", name, i);
            }
        }
    }

    //修饰方法：作用范围是整个方法，作用对象是调用对象
    public synchronized void test2(String name) {
        for (int i = 1; i <= 5; i++) {
            log.info("test2 - {} - {}", name, i);
        }
    }


    public static void main(String[] args) {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        executorService.execute(() -> {
            synchronizedTest.test("线程1");
        });
        executorService.execute(() -> {
            synchronizedTest.test("线程2");
        });
    }
}

执行结果：串行执行。

多个线程使用不同对象：（交替执行）


@Slf4j
public class SynchronizedTest {
    int count = 0;

    //修饰代码块:作用范围是大括号，作用对象是调用代码块的对象。
    public void test(String name) {
        synchronized (this) {
            for (int i = 1; i <= 5; i++) {
                try{
                    Thread.sleep(3000);
                }catch (Exception e){}
                count++;
                log.info("test - {} - count的值{}",name, count);
            }

        }
    }


    public static void main(String[] args) {
        SynchronizedTest synchronizedTest1 = new SynchronizedTest();
        SynchronizedTest synchronizedTest2 = new SynchronizedTest();
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        executorService.execute(() -> {
            synchronizedTest1.test("线程1");
        });
        executorService.execute(() -> {
            synchronizedTest2.test("线程2");
        });
    }
}

执行结果：交替执行。

类级别的同步：使用synchronized修饰静态方法或代码块，使得同一类的其他线程在进入该方法或代码块前需要获取该类的Class对象的锁。这种同步机制可以避免多个线程同时对该类的静态成员进行修改而导致的数据不一致或错误。

@Slf4j
public class SynchronizedTest {


    //修饰静态方法：作用范围是整个方法，作用于所有对象。
    public static synchronized void test3(String name) {
        for (int i = 1; i <= 5; i++) {
            log.info("test3 - {} - {}", name, i);
        }
    }


    //修饰类：作用范围是synchronized后面括号括起来的部分，作用于所有对象。
    public static void test4(String name) {
        synchronized (SynchronizedTest.class) {
            for (int i = 1; i <= 5; i++) {
                log.info("test4 - {} - {}", name, i);
            }
        }
    }


    public static void main(String[] args) {
        SynchronizedTest synchronizedTest1 = new SynchronizedTest();
        SynchronizedTest synchronizedTest2 = new SynchronizedTest();
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        executorService.execute(() -> {
            synchronizedTest1.test3("线程1");
        });
        executorService.execute(() -> {
            synchronizedTest2.test3("线程2");
        });
    }
}

线程之间的同步：通过synchronized的wait()、notify()、notifyAll()方法实现线程之间的等待和通知机制，以实现多个线程之间的协调与同步。

特点：

隐式加锁：synchronized是隐式的，不需要显式地获取和释放锁。
阻塞式加锁：线程在无法获取锁时会一直等待，直到锁被释放。
异常时自动释放锁：当线程在同步代码块中发生异常时，JVM会自动释放锁，避免死锁。

扩展：

共享变量内存可见性问题主要是由于线程的工作内存导致的，下面我们来讲解synchronized的一个内存语义，这个内存语义就可以解决共享变量内存可见性问题。synchronized块的内存语义是把在synchronized块内使用到的变量从线程的工作内存中清除，这样在synchronized块内使用到该变量时就不会从线程的工作内存中获取，而是直接从主内存中获取。退出synchronized块的内存语义是把在synchronized块内对共享变量的修改刷新到主内存。

其实这也是加锁和释放锁的语义，当获取锁后会清空锁块内本地内存中将会被用到的共享变量，在使用这些共享变量时从主内存进行加载，在释放锁时将本地内存中修改的共享变量刷新到主内存。

除可以解决共享变量内存可见性问题外，synchronized经常被用来实现原子性操作。另外请注意，synchronized关键字会引起线程上下文切换并带来线程调度开销。

volatile:

上面介绍了使用锁的方式可以解决共享变量内存可见性问题，但是使用锁太笨重，因
为它会带来线程上下文的切换开销。对于解决内存可见性问题，Java还提供了一种弱形式
的同步，也就是使用volatile关键字。该关键字可以确保对一个变量的更新对其他线程马
上可见。当一个变量被声明为volatile时，线程在写入变量时不会把值缓存在寄存器或者
其他地方，而是会把值刷新回主内存。当其他线程读取该共享变量时，会从主内存重新获
取最新值，而不是使用当前线程的工作内存中的值。volatile的内存语义和synchronized有
相似之处，具体来说就是，当线程写入了volatile变量值时就等价于线程退出synchronized
同步块（把写入工作内存的变量值同步到主内存），读取volatile变量值时就相当于进入同
步块（先清空本地内存变量值，再从主内存获取最新值）。

public class VolatileTest {

    private int value;

    public synchronized void synchronizedIncr(){
        value2++;
    }

    public synchronized void synchronizedDecr(){
        value2--;
    }

    //----------------------

    private volatile int value2;

    public void incr(){
        value2++;
    }

    public void decr(){
        value2--;
    }
}

使用synchronized和使用volatile是等价的，都解决了共享变量value的内存可见性问题，但是前者是独占锁，同时只能有一个线程调用incr0方法，其他调用线程会被阻塞，同时会存在线程上下文切换和线程重新调度的开销，这也是使用锁方式不好的地方。而后者是非阻塞算法，不会造成线程上下文切换的开销。

Lock：

Lock是Java提供的另一种同步机制，它是一个接口，定义了更灵活和高级的同步控制方法。ReentrantLock是Lock接口的唯一实现类。

特点：

显式加锁：Lock需要显式地获取和释放锁，通过lock()和unlock()方法实现。
可中断加锁：Lock支持可中断的加锁，通过lockInterruptibly()方法，线程在等待锁的过程中可以被中断。
支持超时时间的加锁：Lock的tryLock(long time, TimeUnit unit)方法允许线程在指定的时间内尝试获取锁，如果超时未获取到锁，则返回失败。
可判断的锁：Lock提供了lock.tryLock()方法，允许线程在获取锁之前判断锁是否可用。
支持公平锁：ReentrantLock的构造函数可以传入一个布尔值，设置为true时表示创建公平锁，线程将按照申请锁的先后顺序获取锁。
Condition接口：Lock提供了Condition接口，可以替代Object的wait()、notify()、notifyAll()方法，实现更灵活的线程间通信。

测试：

public class LockTest {
    Lock lock = new ReentrantLock();
    
    public void test(String name) {
        lock.lock();
        for (int i = 0; i < 5; i++) {
            System.out.println(name + ": ");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lock.unlock();
    }

    public void test1(String name) {
        try {
            if (lock.tryLock()) {
                for (int i = 0; i < 5; i++) {
                    System.out.println(name + ": ");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.unlock();
            } else {
                System.out.println(Thread.currentThread().getName() + "未获取锁");
            }
        } catch (Exception e) {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        executorService.execute(() -> {
            lockTest.test1("线程1");
        });
        executorService.execute(() -> {
            lockTest.test1("线程2");
        });
    }
}

执行结果：