多线程详解（三）

已于 2022-07-30 20:32:24 修改
阅读量376 收藏
点赞数
分类专栏： 多线程 文章标签： 线程同步 死锁 ReentrantLock synchronized Lock
于 2022-07-30 20:31:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61727355/article/details/126033544
版权

目录

一、线程同步

二、三大不安全案例

2.1 买票

2.2 取钱

2.3 线程不安全的集合

三、同步方法及同步块

3.1 同步方法

3.2  同步块

四、死锁 

4.1 什么是死锁

4.2 死锁避免方法 

五、Lock（锁）

一、线程同步

1）发生情景：多个线程操作同一个资源

2）并发：同一个对象被多个线程同时操作

        现实生活中，我们会遇到“同一个资源，多个人想使用”的问题，比如：食堂排队打饭，每个人都想吃饭，最天然的解决办法就是：排队，一个个来

        处理多线程问题时，多个线程访问同一个对象【并发】，并且某些线程还想修改这个对象。这是我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个 对象的等待池 形成队列，等待前面的线程使用完毕，下一个线程再使用。

3）如何解决线程的安全性： 队列 + 锁

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题。为了保证数据在方法中被访问时的正确性，在访问同时加入 锁机制 （synchronized），当一个线程获得对象的排他锁，独占资源时，其他线程必须等待，使用后释放锁即可，存在以下问题：

        a.一个线程持有锁会导致其他所需要此锁的线程挂起

        b.在多线程竞争下，加锁，释放锁，会导致比较多的 上下文切换 和 调度延迟，引起性能问题

        c.如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问

            题

二、三大不安全案例

2.1 买票

案例：模拟不安全的线程

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"A").start();
        new Thread(buyTicket,"B").start();
        new Thread(buyTicket,"C").start();
    }
}

class BuyTicket implements Runnable{
    //票
    private int ticketNums = 10;
    //借助外部标志位停止线程
    boolean flag=true;

    @Override
    public void run() {
        //买票
        while (flag){
            buy();
        }
    }

    private void buy(){
        //判断是否有票
        if(ticketNums<=0){
            flag=false;
            return;
        }
        //模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+" 拿到 "+ticketNums--);
    }
}

运行结果：不同的线程抢夺同一份资源

2.2 取钱

案例：模拟银行取钱

其中sleep可以放大问题的发生性

//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Accout accout = new Accout(100,"结婚基金");

        Drawing A = new Drawing(accout,50,"A");
        Drawing B = new Drawing(accout,100,"B");

        A.start();
        B.start();
    }
}

//账户
class Accout{
    //余额
    int money;
    //卡名字
    String name;

    public Accout(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    //有一个账户
    Accout accout;
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Accout accout,int drawingMoney,String name){
        super(name);
        this.accout=accout;
        this.drawingMoney=drawingMoney;
    }

    //取钱
    public void run(){
        //判断有没有钱
        if(accout.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }

        //模拟延时
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //卡内余额
        accout.money=accout.money-drawingMoney;
        //手里的钱
        nowMoney=nowMoney+drawingMoney;

        System.out.println(accout.name+" 余额为："+accout.money);
        //this.getName()=Thread.currentThread().getName()
        System.out.println(this.getName()+" 手里的钱："+nowMoney);
    }
}

运行结果：线程发生了不安全现象 

2.3 线程不安全的集合

案例：模拟ArrayList集合不安全情形

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 1000; i++) {
            //lambda表达式
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

运行结果：实际容量1000，最后结果为999

原因：两个线程同一瞬间操作相同的位置（把两个数组添加至同一位置，出现了覆盖）

三、同步方法及同步块

3.1 同步方法

 1）由于我们可以通过private关键字来保证数据对象只能被方法访问，所有我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：

        同步方法：public synchronized void method(int args){}

2）synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

        缺陷：若将一个大的方法声明为synchronized将会影响效率

 案例：对不安全的买票进行改进

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"A").start();
        new Thread(buyTicket,"B").start();
        new Thread(buyTicket,"C").start();
    }
}

class BuyTicket implements Runnable{
    //票
    private int ticketNums = 10;
    //借助外部标志位停止线程
    boolean flag=true;

    @Override
    public void run() {
        //买票
        while (flag){
            buy();
        }
    }

    //synchronized 同步方法，锁的是this，即这个类本身
    private synchronized void buy(){
        //判断是否有票
        if(ticketNums<=0){
            flag=false;
            return;
        }
        //模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+" 拿到 "+ticketNums--);
    }
}

 运行结果：解决了多个线程抢夺统一资源的问题

3.2  同步块

1)同步块：synchronized(Obj){}

2)Obj称为同步监视器

        a.Obj可以是任意对象，但是推荐使用共享资源作为同步监视器

        b.同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本                  身，或者是class【反射】

3）同步监视器的执行过程

        a.第一个线程访问，锁定同步监视器，执行其中代码

        b.第二个线程访问，发现同步监视器被锁定，无法访问

        c.第一个线程执行完毕，解锁同步监视器

        d.第二个线程访问，发现同步监视器没有锁，然后锁定并访问

4）锁的对象是变化的量（需要增删改）

案例：修改不安全的取钱

//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Accout accout = new Accout(100,"结婚基金");

        Drawing A = new Drawing(accout,50,"A");
        Drawing B = new Drawing(accout,100,"B");

        A.start();
        B.start();
    }
}

//账户
class Accout{
    //余额
    int money;
    //卡名字
    String name;

    public Accout(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    //有一个账户
    Accout accout;
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Accout accout,int drawingMoney,String name){
        super(name);
        this.accout=accout;
        this.drawingMoney=drawingMoney;
    }

    //取钱
    public void run(){
        synchronized (accout){
            //判断有没有钱
            if(accout.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }

            //模拟延时
            //sleep：可以放大问题的发生性质
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //卡内余额
            accout.money=accout.money-drawingMoney;
            //手里的钱
            nowMoney=nowMoney+drawingMoney;

            System.out.println(accout.name+" 余额为："+accout.money);
            //this.getName()=Thread.currentThread().getName()
            System.out.println(this.getName()+" 手里的钱："+nowMoney);
        }

    }
}

 运行结果：

同理：修改不安全的集合，只对发生变化的add方法进行同步代码块操作

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 1000; i++) {
            //lambda表达式
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

总结：

synchronized锁的是类本身

synchronized锁的是任何东西

补充：测试JUC安全类的集合，可实现和synchronized同步块一样的效果

public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

四、死锁 

4.1 什么是死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有 “两个以上对象的锁” 时，就有可能发生"死锁"的问题。

案例：模拟死锁的发生

//多个线程互相抱着对着需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2 = new Makeup(1,"白雪公主");

        g1.start();
        g2.start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

//化妆
class Makeup extends Thread{
    //需要的资源只有一份 --> 用static来保证只有一份
    static Lipstick lipstick=new Lipstick();
    static Mirror mirror=new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    Makeup(int choice,String girlName){
        this.choice=choice;
        this.girlName=girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆：互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if(choice==0){
            //获得口红的锁
            synchronized (lipstick){
                System.out.println(this.girlName+" 获得口红的锁");
                Thread.sleep(1000);

                //1秒钟后想获得镜子
                synchronized (mirror){
                    System.out.println(this.girlName+" 获得镜子的锁");
                }
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girlName+" 获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){
                    System.out.println(this.girlName+" 获得口红的锁");
                }
            }
        }
    }
}

运行结果：两个线程互相争夺对方的资源，形成僵持 

改进：不能同时持有对方的锁

//多个线程互相抱着对着需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2 = new Makeup(1,"白雪公主");

        g1.start();
        g2.start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

//化妆
class Makeup extends Thread{
    //需要的资源只有一份 --> 用static来保证只有一份
    static Lipstick lipstick=new Lipstick();
    static Mirror mirror=new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    Makeup(int choice,String girlName){
        this.choice=choice;
        this.girlName=girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆：互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if(choice==0){
            //获得口红的锁
            synchronized (lipstick){
                System.out.println(this.girlName+" 获得口红的锁");
                Thread.sleep(1000);
            }
            //1秒钟后想获得镜子
            synchronized (mirror){
                System.out.println(this.girlName+" 获得镜子的锁");
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girlName+" 获得镜子的锁");
                Thread.sleep(2000);
            }
            synchronized (lipstick){
                System.out.println(this.girlName+" 获得口红的锁");
            }
        }
    }
}

运行结果：

4.2 死锁避免方法 

产生死锁的四个必要条件：

1）互斥条件：一个资源每次只能被一个进程使用

2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放

3）不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺

4）循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

上面列出了死锁的四个必要条件，我们只要想办法破环其中的任意一个或多个条件就可以避免死锁发生

五、Lock（锁）

1）从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

2）java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源前应先获得Lock对象。

3）ReentrantLock（可重入锁）类实现了Lock，他拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

案例：测试lock锁（基于买票案例）

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{
    int ticketNums = 10;

    //定义Lock锁
    private final ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                //加锁
                lock.lock();
                if(ticketNums<=0){
                    break;
                }else{
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

运行结果：

 总结：

 synchronized与Lock的对比：

1）Lock是显式锁（手动开启和关闭，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放

2）Lock只有代码块锁，synchronized有代码块锁和方法锁

3）使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）

4）优先使用顺序：

        Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

1uuue
关注
专栏目录
Java多线程详解及示例
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
一文详解C++多线程
非晚非晚的博客
04-25 8万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
C#高级--多线程详解
李宥的博客
10-03 5万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Python多线程详解
ifhuke的博客
03-10 2万+
关于Python多线程的详细解读
QT多线程编程详解
coolboywjun的专栏
04-24 8万+
一、线程基础 1、GUI线程与工作线程 每个程序启动后拥有的第一个线程称为主线程，即GUI线程。QT中所有的组件类和几个相关的类只能工作在GUI线程，不能工作在次线程，次线程即工作线程，主要负责处理GUI线程卸下的工作。 2、数据的同步访问 每个线程都有自己的栈，因此每个线程都要自己的调用历史和本地变量。线程共享相同的地址空间。 二、QT多线程简介 QT通过三种形式提供了对线程...
Java多线程详解
坏蛋阿土的博客
11-06 6619
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
python多线程详解（超详细）
热门推荐
世俗的眼光
03-30 21万+
python中的多线程是一个非常重要的知识点，今天为大家对多线程进行详细的说明，代码中的注释有多线程的知识点还有测试用的实例。 import threading from threading import Lock,Thread import time,os ''' python多线程详解 什么是线程？ ...
多线程详解
weixin_48638578的博客
05-17 3263
文章目录多线程一、基本概念：程序、进程、线程线程二、并行与并发三、多线程优点四、创建多线程方式一：继承Thread五、线程常用方法六、创建多线程方式二：实现Runnable接口七、创建多线程方式三：实现Callable接口 jdk5.0八、线程的生命周期九、三种方法解决线程安全问题十、死锁问题十一、线程通信十二、线程通信的应用：生产者/消费者十三、sleep() 和 wait() 区别十四、线程池使用Executors创建线程池 例： (==不允许使用Executors创建线程池==)使用ThreadPo
编程必备：JAVA多线程详解
拾一二的博客
06-14 8588
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
python多线程详解_【python】多线程详解
weixin_29596051的博客
01-29 3365
一、进程与线程关系一个进程至少包含一个线程。二、线程基础1、线程的状态线程有5种状态，状态转换的过程如下图所示：2、线程同步(锁)多线程的优势在于可以同时运行多个任务(至少感觉起来是这样)。但是当线程需要共享数据时，可能存在数据不同步的问题。考虑这样一种情况：一个列表里所有元素都是0，线程”set”从后向前把所有元素改成1，而线程”print”负责从前往后读取列表并打印。那么，可能线程”set”开...
Delphi多线程详解_delphi_delphi多线程_多线程_
09-29
在编程领域，多线程是一种常见且强大的技术，它允许应用程序同时执行多个任务，从而提高程序的效率和响应性。Delphi，作为一个流行的Object Pascal开发环境，提供了丰富的工具和库来支持多线程编程。本篇文章将深入...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 949
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
最新发布
杨荧的CSDN博客
10-10 1014
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1284
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 379
JDK1.0主要特性。
Delphi多线程详解：创建与应用实践
Delphi多线程详解深入探讨了在Delphi编程中实现多线程的各个方面。章节11首先定义了线程的基本概念，指出在Win32操作系统中，线程是表示进程中执行路径的对象，每个应用程序至少有一个主线程，但可以通过创建额外...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值