AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

涨姿势了！原来这才是多线程正确实现方式

2022-10-13 60
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 线程同步机制是一套适用于协调线程之间的数据访问机制，该机制可以保障线程安全java平台提供的线程同步机制包括：锁、volatile关键字、final关键字，static关键字、以及相关API如object.wait/object.notify

Java内存模型

网络异常，图片无法展示
|

网络异常，图片无法展示
|

线程同步

线程同步机制是一套适用于协调线程之间的数据访问机制，该机制可以保障线程安全

java平台提供的线程同步机制包括：锁、volatile关键字、final关键字，static关键字、以及相关API如object.wait/object.notify

锁概述

线程安全问题的产生前提是多个线程并发访问共享数据，将多个数据对共享数据的并发访问，转化为串行访问，即共享数据只能被一个线程访问，锁就是这种思路。

线程访问数据时必须先获得锁，获得锁的线程称为锁的持有线程，一个锁一次只能被一个线程持有，持有线程在获得锁之后和释放锁之前锁执行的代码称之为临界区。

锁具有排它性（Exclisive），即一个锁只能被一个线程持有，这种锁称为排它锁或者互斥锁。

网络异常，图片无法展示
|

JVM部分把锁分为内部锁和显示锁，内部锁通过Synchronized关键字实现，显示锁通过
java.concurrent.locks.Lock接口实现类实现的。

锁的作用

锁能够实现对共享数据的安全，保障线程的原子性，可见性与有序性。

锁是通过互斥保障原子性，一个锁只能被一个线程持有，这就保证了临界区的代码一次只能被一个线程执行，使得临界区代码所执行的的操作自然而然的具有不可分割的特性，既具备了原子性。

好比一条路段所有车辆都在跑，并发执行，在经过某一个路段的时候，多车道变为一车道，一次只能通过一辆车，由并发执行改为串行执行。

可见性是通过写线程冲刷处理器的缓存和读线程刷新处理器缓存这两个动作，锁的获得隐含着刷新处理器缓存的动作，锁的释放隐含着冲刷处理器缓存的动作。

锁能够保障有序性，写线程在临界区所执行的临界区看来像是完全按照源码顺序执行的。

锁的相关概念

可重入性:一个线程持有该锁的时候能够再次/多次申请该锁

如果一个线程持有一个锁的时候，还没有释放，但还能够继续成功申请该锁，称该锁可重入，反之。

锁的争用与调度

java中内部锁属于非公平锁，显示锁支持非公平锁和公平锁

锁的粒度

一个所可以保护的共享数据的数量大小称为锁的粒度。

锁保护共享数据量大，称为锁粒度粗，否则称为粒度细。

锁的粒度过粗会导致线程在申请锁时会进行不必要的等待，锁粒度过细会增加锁调度的开销。

比如银行有一个柜台一个员工可以办理开卡、销户、取现、贷款那么所有人都只能去这个柜台办理业务，会需要很长的等待时间。但是如果把业务细分，一个业务一个柜台，这时候增加了银行的开销，需要三个员工。

内部锁：Synchronized

Java中每一个对象都有一个与之关联的内部锁，这种锁也叫监视器，是一种排它锁，可以保障原子性、可见性、排它性。

Synchronized(对象锁)
{
  同步代码块，可以在同步代码块中访问共享数据
}

修饰实例方法称为同步实例方法，修饰静态方法称为同步静态方法。

Synchronized同步代码块

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        for (int i = 0; i <2 ; i++) {
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();
                }
            }.start();
        }
    }
    public  void  mm()
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

两个线程的代码都在并发执行

网络异常，图片无法展示
|

现在要打印的时候进行同步，同步的原理线程在执行的时候要先要获得锁

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        for (int i = 0; i <2 ; i++) {
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();//使用锁的对象是synchronizedLock对象
                }
            }.start();
        }
    }
    public  void  mm()
    {
        synchronized (this)//this作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

网络异常，图片无法展示
|

因为Synchronized内部锁是排它锁，一次只能被一个线程持有，现在是Thread-0先取得锁对象，Thread-1在等待区等待Thread-0执行完毕释放锁，Thread-1获得锁再执行。

锁对象不同不能实现同步

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        SynchronizedLock synchronizedLock2=new SynchronizedLock();
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();//使用锁的对象是synchronizedLock对象
                }
            }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock2.mm();//使用锁的对象是synchronizedLock对象
            }
        }.start();
    }
    public  void  mm()
    {
        synchronized (this)//this作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

网络异常，图片无法展示
|

因此想要同步必须使用同一个锁对象

使用常量作为锁对象

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        SynchronizedLock synchronizedLock2=new SynchronizedLock();
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();//使用锁的对象是synchronizedLock对象
                }
            }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();//使用锁的对象是synchronizedLock对象
            }
        }.start();
    }
    public  static  final  Object obj=new Object();
    public  void  mm()
    {
        synchronized (obj)//常量作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

同步实例方法

使用synchronized修饰实例方法，同步实例方法，默认使用this作为锁对象

public class SynchronizedLock {
   public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();
                }
            }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() { 
                synchronizedLock.mm2();
            }
        }.start();
    }
    //同步实例方法
    public  synchronized void  mm()
    {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
    }
    public  void  mm2()
    {
        synchronized (this)//常量作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

同步静态方法

使用synchronized修饰静态方法，同步静态方法，默认运行时使用SynchronizedLock class作为锁对象

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm2();
            }
        }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                SynchronizedLock.mm();//使用锁的对象是SynchronizedLock.class
            }
        }.start();
    }
    //同步静态方法
    public  synchronized static void  mm()
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
    public  void  mm2()
    {
        synchronized (SynchronizedLock.class)//常量作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

同步代码块和同步方法如何选择

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                try {
                    synchronizedLock.mm2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                try {
                    synchronizedLock.mm2();//使用锁的对象是SynchronizedLock.class
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
    //同步实例方法 锁的粒度粗 执行效率低
    public  synchronized  void  mm() throws InterruptedException {
        long starttime= System.currentTimeMillis();
        System.out.println("start");
        Thread.sleep(3000);
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
        System.out.println("end");
        long Endtime= System.currentTimeMillis();
        System.out.println(Endtime-starttime);
    }
    //同步代码块 锁的粒度细 并发效率高
    public  void  mm2() throws InterruptedException {
        System.out.println("start");
        Thread.sleep(3000);
        synchronized (this)//常量作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
        System.out.println("end");
    }
}

在执行同步方法的时候，两次线程调用每次都需要休眠三秒，而同步代码块同时启动线程都先准备三秒，效率比较高

脏读

public class Test06 {
    public static void main(String[] args) throws InterruptedException {
        User user=new User();
        SubThread subThread=new SubThread(user);
        subThread.start();
        user.GetName();
    }
    static  class SubThread extends Thread
    {
        public User user;
        public SubThread(User user)
        {
            this.user=user;
        }
        @Override
        public void run() {
            user.SetValue("ww","456");
        }
    }
    static  class  User
    {
        private  String name="ylc";
        private  String pwd="123";
        public  void  GetName()
        {
            System.out.println(Thread.currentThread().getName()+"==>"+name+"密码"+pwd);
        }
        public  void  SetValue(String name,String pwd)
        {
            System.out.println("原来为为name="+this.name+",pwd="+this.pwd);
            this.name=name;
            this.pwd=pwd;
            System.out.println("更新为name="+name+",pwd="+pwd);
        }
    }
}

网络异常，图片无法展示
|

在修改数据还没有完成的时候，就读取到了原来的数据，而不是修改之后的

出现脏读的原因是对共享数据的修改和读取不同步引起的

解决办法是对修改和读取的方法进行同步方法上加上synchronized关键字

网络异常，图片无法展示
|

线程出现异常释放锁

假如在同步方法中，一个线程出现了异常，会不会没有释放锁，其他在等待的线程就在一直等待，论证：

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();
            }
        }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm2();
            }
        }.start();
    }
    //同步实例方法
    public  synchronized void  mm()
    {
        for (int i = 0; i <100 ; i++) {
            if(i==50)
            {
                Integer.parseInt("abc");//异常设置
            }
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
    public  void  mm2()
    {
        synchronized (this)
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

网络异常，图片无法展示
|

同步过程中线程出现异常，会自动释放锁对象，以供下一个线程继续执行

死锁

多线程中可能需要使用多个锁，如果获取锁的顺序不一致，可能导致死锁。

public class Text06_5 {
    public static void main(String[] args) {
        SubThread subThread=new SubThread();
        SubThread subThread2=new SubThread();
        subThread.setName("a"); subThread2.setName("b");
        subThread.start();subThread2.start();
    }
    static  class SubThread  extends  Thread
    {
        private  static  final Object lock1=new Object();
        private  static  final Object lock2=new Object();
        @Override
        public void run() {
            if("a".equals(Thread.currentThread().getName()))
            {
                synchronized (lock1)
                {
                    System.out.println("a 线程 lock1获得了锁,再需要获得lock2");
                    synchronized (lock2)
                    {
                        System.out.println("a 线程 lock2获得了锁");
                    }
                }
            }
            if("b".equals(Thread.currentThread().getName()))
            {
                synchronized (lock2)
                {
                    System.out.println("b 线程 lock2获得了锁,再需要获得lock1");
                    synchronized (lock1)
                    {
                        System.out.println(" b 线程 lock1获得了锁");
                    }
                }
            }
        }
    }
}

网络异常，图片无法展示
|

程序还在运行，却进入了卡死状态，a线程得到了lock1，要想把该线程释放的执行下面的代码获取lock2，而lock2被b线程获取无法释放，出现了鹬蚌相争的情况。

避免死锁：当需要获得锁时，所有线程获得锁的顺序一致，a线程先锁lock1，再锁lock2，b线程同理，就不会出现死锁了。

文章标签：
Java
安全
API
调度
缓存
愿天堂没有BUG（公众号同名）
目录
相关文章
土木林森
|
3月前
|
缓存 Java
Java内存管理秘籍：掌握强软弱幻四大引用，让代码效率翻倍！
【8月更文挑战第29天】在Java中，引用是连接对象与内存的桥梁，主要分为强引用、软引用、弱引用和幻象引用。强引用确保对象生命周期由引用控制，适用于普通对象；软引用在内存不足时可被回收，适合用于内存敏感的缓存；弱引用在无强引用时即可被回收，适用于弱关联如监听器列表；幻象引用需与引用队列配合使用，用于跟踪对象回收状态，适用于执行清理工作。合理使用不同类型的引用车可以提升程序性能和资源管理效率。
土木林森
46 4
会敲代码的_TT
|
6月前
|
设计模式 前端开发 JavaScript
一秒开挂！工厂模式让你告别重复代码！
欢迎来到前端入门之旅！这个专栏是为那些对Web开发感兴趣、刚刚开始学习前端的读者们打造的。无论你是初学者还是有一些基础的开发者，我们都会在这里为你提供一个系统而又亲切的学习平台。我们以问答形式更新，为大家呈现精选的前端知识点和最佳实践。通过深入浅出的解释概念，并提供实际案例和练习，让你逐步建立起一个扎实的基础。无论是HTML、CSS、JavaScript还是最新的前端框架和工具，我们都将为你提供丰富的内容和实用技巧，帮助你更好地理解并运用前端开发中的各种技术。
会敲代码的_TT
48 0
愿天堂没有BUG（公众号同名）
|
6月前
|
安全 Java 程序员
牛皮了！八年美团大佬耗时3月竟在写《java虚拟机并发编程》
除了咖啡因，我想没有什么能比写出一段执行速度飞快的代码更能令程序员们兴奋了。然而我们如何才能满足这种对计算速度的渴求呢?诚然，摩尔定律可以帮我们解决部分问题，但多核处理器才代表了未来真正的发展方向。
愿天堂没有BUG（公众号同名）
65 0
愿天堂没有BUG（公众号同名）
|
缓存 安全 Java
涨姿势了！原来这才是多线程正确实现方式
线程同步机制是一套适用于协调线程之间的数据访问机制，该机制可以保障线程安全 java平台提供的线程同步机制包括：锁、volatile关键字、final关键字，static关键字、以及相关API如object.wait/object.notify
愿天堂没有BUG（公众号同名）
88 0
-编程工程师-
|
消息中间件 JavaScript 小程序
麻了，代码改成多线程，竟有9大问题 上
麻了，代码改成多线程，竟有9大问题 上
-编程工程师-
144 0
-编程工程师-
|
安全 Java 数据库连接
麻了，代码改成多线程，竟有9大问题 下
麻了，代码改成多线程，竟有9大问题 下
-编程工程师-
153 0
-编程工程师-
|
SQL 存储 监控
程序员新人频繁使用count(*)，被组长批评后怒怼：性能并不拉垮！
程序员新人频繁使用count(*)，被组长批评后怒怼：性能并不拉垮！
-编程工程师-
169 0
Jack魏
|
算法 Java Linux
工作这么久了，还不懂多线程吗？
浩哥Java多线程整理学习系列之01基础知识整理
Jack魏
107 0
工作这么久了，还不懂多线程吗？
开发工程师
|
索引
面试官：为什么要尽量避免使用 IN 和 NOT IN？大部分人都会答错...
面试官：为什么要尽量避免使用 IN 和 NOT IN？大部分人都会答错...
开发工程师
124 0
面试官：为什么要尽量避免使用 IN 和 NOT IN？大部分人都会答错...
寒凝雪
|
调度 Linux 并行计算
多线程的那点儿事（基础篇）
寒凝雪
1006 0

热门文章

最新文章

  • 1
    SpringBoot开发案例之整合Dubbo提供者(一)
  • 2
    阿里AI上岗双11服装车间，能识别头发丝直径十分之一的瑕疵
  • 3
    Webpack构建library时的踩坑经历
  • 4
    安装nginx：src/os/unix/ngx_user.c:26:7: error: ‘struct crypt_data’ has no member named ‘curren
  • 5
    字节流套接口的读写
  • 6
    【转】类别catagory的用法
  • 7
    lsof 命令
  • 8
    TeamCity : 自动触发 Build
  • 9
    建站篇-用户认证系统-管理员登陆后台
  • 10
    asp.net学习之ado.net(无连接模式中的DataAdapter)
  • 1
    VideoChat：高效学习新神器！一键解读音视频内容，结合 AI 生成总结内容、思维导图和智能问答
    32
  • 2
    《C++巧筑智能框架根基：开启 AI 开发新航道》
    27
  • 3
    《跨越语言壁垒：Python 人工智能原型到 C++可执行程序的转型之路》
    22
  • 4
    Go语言中json序列化的一个小坑，建议多留意一下
    25
  • 5
    JVM常见面试题（四）：垃圾回收
    24
  • 6
    C语言物联网开发之设备安全与代码可靠性隐患
    21
  • 7
    C语言物联网开发之设备安全与代码可靠性隐患
    19
  • 8
    C 语言物联网开发之网络通信与数据传输难题
    18
  • 9
    Linux服务器安全
    15
  • 10
    Web应用防火墙（WAF）与数据库应用防火墙有什么区别？
    16

    • 相关课程

    更多
  • 【新人赛】工业蒸汽量预测建模算法代码开源分享合集

    • 相关电子书

    更多
  • Android插件化-从入门到"放弃"
  • 属兔的处子——Clojure太灵活，臣妾驾驭不住啊
  • Java应用提速（速度与激情）

    • 相关实验场景

    更多
  • 代码质量提升小妙招
    • 下一篇
    无影云桌面