Java高阶私房菜：并发编程原理深度剖析

敲键盘的小夜猫

已于 2024-04-21 12:22:53 修改

阅读量1.1k

点赞数 50

分类专栏： java 文章标签： java

于 2024-04-13 23:33:30 首次发布

本文链接：https://blog.csdn.net/qq_30294911/article/details/137719472

版权

java 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

Synchronized对象锁和类锁性能差异分析

什么是对象锁（synchronized method{}）

什么是类锁（static sychronized method{}）

"Java并发编程"一直以来熟悉又陌生，还记得从刚接触时总能听到java的高级能力，也憧憬着自己有那么天能够写出优雅又实用代码来应对海量并发场景，但一路走下来，实际业务能使用上高并发场景的也比较少，对这块的理解就更少了。接下来，本文将带你逐步理解并发编程的核心要素，以及Java开发中常见的各种锁类型设计和性能分析，温故而知新，希望能给予新的启发。

并发编程三要素

        1）原子性：一个不可再被分割的颗粒，原子性指的是一个或多个操作要么全部执行成功要么全部执行失败吗，期间不能被中断，也不存在上下文切换，线程切换会带来原子性的问题。
        2）有序性：程序执行的顺序按照代码的先后顺序执行，因为处理器可能会对指令进行重排序
        3）可见性：一个线程A对共享变量的修改,另一个线程B能够立刻看到

Java开发里面常见的锁种类

1）悲观锁和乐观锁

悲观锁：当线程去操作数据的时候，总认为别的线程会去修改数据，所以它每次拿数据的时候都会上锁，别的线程去拿数据的时候就会阻塞，比如synchronized、ReentrantLock；

乐观锁：每次去拿数据的时候都认为别人不会修改，更新的时候会判断是别人是否回去更新数据，通过版本来判断。如果数据被修改了就拒绝更新，比如CAS是乐观锁，但严格来说并不是锁，通过原子性来保证数据的同步。比如说数据库的乐观锁，通过版本控制来实现，乐观的认为在数据更新期间没有其他线程影响；

对于悲观锁适合写操作多的场景，乐观锁适合读操作多的场景，乐观锁的吞吐量会比悲观锁多

2）公平锁和非公平锁

公平锁：指多个线程按照申请锁的顺序来获取锁，简单来说如果一个线程组里，能保证每个线程都能拿到锁。比如ReentrantLock (底层是同步队列FIFO:First Input First Output来实现)；

非公平锁：获取锁的方式是随机获取的，保证不了每个线程都能拿到锁，也就是存在有线程饿死,一直拿不到锁。比如synchronized、ReentrantLock；

3）独享锁和共享锁

独享锁：也叫排它锁/写锁/独占锁/独享锁/ 该锁每一次只能被一个线程所持有,加锁后任何线程试图再次加锁的线程会被阻塞，直到当前线程解锁。例如：如果线程A 对data1加上排他锁后，则其他线程不能再对 data1 加任何类型的锁，那么获得了互斥锁的线程即能读数据又能修改数据。

共享锁：也叫S锁/读锁，能查看但无法修改和删除的一种数据锁，加锁后其它用户可以并发读取、查询数据，但不能修改、增加或删除数据，该锁可被多个线程所持有，用于资源数据共享。

4）可重入锁和不可重入锁

可重入锁：也叫递归锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁；

不可重入锁：若当前线程执行某个方法已经获取了该锁，那么在方法中尝试再次获取锁时，就会获取不到被阻塞；

小结：可重入锁能一定程度的避免死锁， synchronized、ReentrantLock 重入锁。

5）自旋锁、分段锁和死锁

自旋锁：一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环,任何时刻最多只能有一个执行单元获得锁。该方式不会产生线程状态的切换，一直处于用户态，减少了线程上下文切换的消耗，缺点是循环会消耗CPU。

分段锁：并不是具体的一种锁，只是一种锁的设计，将数据分段上锁，把锁进一步细粒度化，可以提升并发量。当操作不需要更新整个数组的时候，就仅针对数组中的一项进行加锁操作。例如CurrentHashMap底层就用了分段锁。

死锁：两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法让程序进行下去

公平锁和非公平锁设计剖析

Synchronized对象锁和类锁性能差异分析

什么是对象锁（synchronized method{}）

也叫实例锁，对应synchronized关键字，当多个线程访问多个实例时，它们互不干扰，每个对象都拥有自己的锁，但如果是多个线程访问同个对象的sychronized块，是同步的加锁，访问不同对象的话就是不同步的，synchronized(object){}的效果和在实例方法上加锁一样，不同的是可以在（）里添加不同的对象。

阿里巴巴开发手册（并发处理章节第6条）：高并发时，同步调用应该去考量锁的性能损耗。能用无锁结构，就不要用锁：能锁区块，就不要锁整个方法体：能用对象锁，就不要用类锁。尽可能使加锁的代码块工作量尽可能的小，避免在锁代码中调用RPC方法

应用实例

例如一台电脑它只有一个屏幕，它在播放电影时就不能打游戏，在打游戏时不能播放电影，但是它可以在做两者的同时可以播放音乐，针对该场景设计对象锁。


import java.util.concurrent.TimeUnit;

public class Computer {

    //此处独占，锁的是当前对象
    public  synchronized void watchMovie(){

        //如果两个线程互不影响，则不用等待3秒钟,另外一个watch也可以马上打印
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        String name = Thread.currentThread().getName();
        System.out.println(name + "看电影");
    }

    public  synchronized void playGame(){
        String name = Thread.currentThread().getName();
        System.out.println(name + "打游戏");

    }

    public void listenMusic(){
        String name = Thread.currentThread().getName();
        System.out.println(name + "听音乐");
    }

}


import java.util.concurrent.TimeUnit;

public class Computer {

    //此处独占，锁的是当前对象
    public  synchronized void watchMovie(){

        //如果两个线程互不影响，则不用等待3秒钟,另外一个watch也可以马上打印
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        String name = Thread.currentThread().getName();
        System.out.println(name + "看电影");
    }

    public  synchronized void playGame(){
        String name = Thread.currentThread().getName();
        System.out.println(name + "打游戏");

    }

    public void listenMusic(){
        String name = Thread.currentThread().getName();
        System.out.println(name + "听音乐");
    }

}


===========================
李四1打游戏
王五听音乐
张三看电影
李四打游戏

在一个对象中，调用方法使用了synchronized修饰时，将会根据线程获取锁的优先级来执行，会等待对象锁释放后再进入到另一方法。倘若在另外一个对象中则不受锁限制。

什么是类锁（static sychronized method{}）

一种全局锁，不管创建多少个对象都共享同一个锁，保障了同一个时刻多个线程同时访问同一个synchronized块，当一个线程在访问时，其他的线程等待。静态方法使用synchronized关键字后，无论是多线程访问单个对象还是多个对象的sychronized块，都是同步。synchronized(xxx.class){}的效果和在静态方法方法上加锁一样，不同的是可以在（）里添加不同的类对象

代码实例：


import java.util.concurrent.TimeUnit;

public class Computer {
    public static void watchMovie(){

        synchronized (Computer.class){
            //如果两个线程互不影响，则不用等待3秒钟,另外一个watchMovie也可以马上打印
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            String name = Thread.currentThread().getName();
            System.out.println(name + "看电影");
        }

    }

    public static void playGame(){
        synchronized (Computer.class){
            String name = Thread.currentThread().getName();
            System.out.println(name + "打游戏");
        }
    }

    public static void listenMusic(){
        String name = Thread.currentThread().getName();
        System.out.println(name + "听音乐");
    }


}


public class SyncLockTest {
    public static void main(String[] args) {

        Computer computer1 = new Computer();
        Computer computer2 = new Computer();

        new Thread(() -> {
            Computer.watchMovie();
        }, "张三").start();

        new Thread(() -> {
            Computer.playGame();
        }, "李四").start();

        new Thread(() -> {
            Computer.playGame();
        }, "李四2").start();

        new Thread(() -> {
            Computer.listenMusic();
        }, "王五").start();
    }
}

=================
王五听音乐
张三看电影
李四2打游戏
李四打游戏

Synchronized底层锁原理分析

synchronized是解决线程安全的问题，常用在同步普通方法、静态方法、代码块中，每个对象有一个锁和一个等待队列，锁只能被一个线程持有，其他需要锁的线程需要阻塞等待。锁被释放后，对象会从队列中取出一个并唤醒，唤醒哪个线程是不确定的，不保证公平性，基于以上特点所以是非公平、可重入的悲观锁。

两种形式：

1）同步方法：生成的字节码文件中会多一个 ACC_SYNCHRONIZED 标志位，当一个线程访问方法时，会去检查是否存在ACC_SYNCHRONIZED标识。如果存在，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象，也叫隐式同步。

2）同步代码块：加了 synchronized 关键字的代码段，生成的字节码文件会多出 monitorenter 和 monitorexit 两条指令，每个monitor维护着一个记录着拥有次数的计数器, 未被拥有的monitor的该计数器为0。当一个线程获执行monitorenter后，该计数器自增1；当同一个线程执行monitorexit指令的时候，计数器再自减1。当计数器为0的时候,monitor将被释放.也叫显式同步。

两种本质上没有区别，底层都是通过monitor来实现同步, 只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。

死锁案例和排查过程分析

什么是死锁

两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法让程序进行下去。

具体代码

public class DeadLockDemo {

    private static Object locka = new Object();

    private static Object lockb = new Object();

    public void methodA(){
        synchronized (locka){
            System.out.println("我是A方法中获得了锁A "+Thread.currentThread().getName() );
            //让出CPU执行权，不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(lockb){
                System.out.println("我是A方法中获得了锁B "+Thread.currentThread().getName() );
            }
        }
    }

    public void methodB(){
        synchronized (lockb){
            System.out.println("我是B方法中获得了锁B "+Thread.currentThread().getName() );
            //让出CPU执行权，不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(locka){
                System.out.println("我是B方法中获得了锁A "+Thread.currentThread().getName() );
            }
        }
    }

    public static void main(String [] args){
        System.out.println("主线程运行开始运行："+Thread.currentThread().getName());
        DeadLockDemo deadLockDemo = new DeadLockDemo();
        new Thread(()->{
            deadLockDemo.methodA();
        }).start();
        new Thread(()->{
            deadLockDemo.methodB();
        }).start();
        System.out.println("主线程运行结束："+Thread.currentThread().getName());
    }
}

死锁的4个必要条件

1）互斥条件：资源不能共享，只能由一个线程使用；
2）请求与保持条件：线程已经获得一些资源，但因请求其他资源发生阻塞，对已经获得的资源保持不释放；
3）不可抢占：有些资源是不可强占的，当某个线程获得这个资源后，系统不能强行回收，只能由线程使用完自己释放；
4）循环等待条件：多个线程形成环形链，每个都占用对方申请的下个资源；

排查方式

1）Jps + jstack

2）jconsole

敲键盘的小夜猫

关注

50
点赞
踩
37

收藏

觉得还不错? 一键收藏
0
评论
Java高阶私房菜：并发编程原理深度剖析

"Java并发编程"一直以来熟悉又陌生，还记得从刚接触时总能听到java的高级能力，也憧憬着自己有那么天能够写出优雅又实用代码来应对海量并发场景，但一路走下来，实际业务能使用上高并发场景的也比较少，对这块的理解就更少了。接下来，本文将带你逐步理解并发编程的核心要素，以及Java开发中常见的各种锁类型设计和性能分析，温故而知新，希望能给予新的启发。
复制链接

扫一扫

专栏目录