【Java并发编程】线程的同步

已于 2023-03-23 18:51:41 修改
阅读量712 收藏
点赞数 1
分类专栏： Java 文章标签： java jvm 开发语言
于 2023-02-03 19:18:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuwanqing233333/article/details/128849870
版权

一、基础概念

1. 并发

多个线程访问同一个对象，并且某些线程还想修改这些对象

2. 线程同步

线程同步是一种等待机制， 通过在访问时加入锁机制 synchronized 来实现，线程同步会导致一些性能问题（性能倒置等）

3. 队列和锁

线程同步需要队列和锁，每个对象都有自己的锁

二、案例

1. 多线程买票问题

线程不安全代码，会出现超卖现象

/**
 * @description: 使用多线程，模拟三个窗口同时售票
 * @author: Liuwanqing
 * @date: 2022-10-14 16:42
 */
public class  SellTicket {
    public static void main(String[] args) {
        SellTickets02 sellTickets02 = new SellTickets02();

//        SellTickets01 sellTickets01 = new SellTickets02();
//        SellTickets01 sellTickets02 = new SellTickets02();
//        SellTickets01 sellTickets03 = new SellTickets02();

//        sellTickets01.start();
//        sellTickets02.start();
//        sellTickets03.start();

        // 创建 3 个线程进行买票
        Thread thread1 = new Thread(sellTickets02);
        Thread thread2 = new Thread(sellTickets02);
        Thread thread3 = new Thread(sellTickets02);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

// 使用 Thread 方式
class SellTickets01 extends Thread {
    private static int tikectNum = 100; // 多线程共享的 num

    @Override
    public void run() {
        while (true) {
            if (tikectNum <= 0) {
                System.out.println("票卖完了~~~");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出了一张票，还剩的票数为" + (--tikectNum) );
        }
    }
}
// 使用实现 Runnable 接口的方式
class SellTickets02 implements Runnable {
    private static int tikectNum = 100; // 多线程共享的 num

    @Override
    public void run() {
        while (true) {
            if (tikectNum <= 0) {
                System.out.println("票卖完了~~~");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出了一张票，还剩的票数为" + (--tikectNum) );
        }
    }
}

2. 银行取钱问题

/**
 * @Author: WanqingLiu
 * @Date: 2023/02/02/15:03
 * 银行取钱问题
 */
public class Draw {
    public static void main(String[] args) {
        Account account = new Account("晚晴", 100);
        DrawThread wanqing = new DrawThread(account, 10);
        DrawThread xinyu = new DrawThread(account, 10);
        wanqing.start();
        xinyu.start();
    }
}

// 银行账户类
class Account {
    String name; // 账户名
    int nowNum; // 账户余额

    public Account(String name, int nowNum) {
        this.name = name;
        this.nowNum = nowNum;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNowNum() {
        return nowNum;
    }

    public void setNowNum(int nowNum) {
        this.nowNum = nowNum;
    }
}



// 取钱线程
class DrawThread extends Thread {
    Account account; // 取钱的账户
    int drawNum; // 取走的钱
    public DrawThread(Account account, int drawNum){
        this.account = account;
        this.drawNum = drawNum;
    }
    @Override
    public void run() {
        if ((account.getNowNum() - drawNum) < 0) {
            System.out.println("余额不足");
            return;
        }
        try { // 放大问题的发生性 *
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        account.setNowNum(account.getNowNum() - drawNum);
        System.out.println("当前余额为 ：" + account.getNowNum());
    }
}

3. 线程不安全的集合

ArrayList - 线程不安全

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // 开启 10000 个线程，向 list 中加入 10000 个数据
        for (int i=0; i<10000; i++){
            // 两个线程覆盖了同一个位置
            new Thread(() ->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        // 输出并不为 10000 ， 因为两个线程同时加入时，加入的元素覆盖了同一个位置
        System.out.println(list.size());
    }

三、同步方法

1. synchronized

synchronized 默认锁的是对象本身（this），我们可以通过同步块锁任何对象，锁的对象应该是多线程操作的那个变化的量，如在银行取钱中，我们要锁的是要变化的账户对象

- （1）同步方法

同步方法实现线程安全的买票

package concurrency;

/**
 * @description: 使用多线程，模拟三个窗口同时售票
 * @author: Liuwanqing
 * @date: 2022-10-14 16:42
 */
public class  SellTicket {
    public static void main(String[] args) {
        SellTickets02 sellTickets02 = new SellTickets02();
        // 创建 3 个线程进行买票
        Thread thread1 = new Thread(sellTickets02);
        Thread thread2 = new Thread(sellTickets02);
        Thread thread3 = new Thread(sellTickets02);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

// 使用 Thread 方式
class SellTickets01 extends Thread {
    private static int tikectNum = 100; // 多线程共享的 num

    @Override
    public synchronized void run() {
        while (true) {
            if (tikectNum <= 0) {
                System.out.println("票卖完了~~~");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出了一张票，还剩的票数为" + (--tikectNum) );
        }
    }
}
// 使用实现 Runnable 接口的方式
class SellTickets02 implements Runnable {
    private static int tikectNum = 100; // 多线程共享的 num

    @Override
    public synchronized void run() {
        while (true) {
            if (tikectNum <= 0) {
                System.out.println("票卖完了~~~");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出了一张票，还剩的票数为" + (--tikectNum) );
        }
    }
}

- （2）同步块

- 同步块解决银行取钱问题
/**
 * @Author: WanqingLiu
 * @Date: 2023/02/02/15:03
 * 银行取钱问题
 */
public class Draw {
    public static void main(String[] args) {
        Account account = new Account("晚晴", 100);
        DrawThread wanqing = new DrawThread(account, 10);
        DrawThread xinyu = new DrawThread(account, 10);
        wanqing.start();
        xinyu.start();
    }
}

// 银行账户类
class Account {
    String name; // 账户名
    int nowNum; // 账户余额

    public Account(String name, int nowNum) {
        this.name = name;
        this.nowNum = nowNum;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNowNum() {
        return nowNum;
    }

    public void setNowNum(int nowNum) {
        this.nowNum = nowNum;
    }
}

// 取钱线程
class DrawThread extends Thread {
    Account account; // 取钱的账户
    int drawNum; // 取走的钱
    public DrawThread(Account account, int drawNum){
        this.account = account;
        this.drawNum = drawNum;
    }
    @Override
    public void run() {
        // 锁住我们要操作的 account
        synchronized (account) {
            if ((account.getNowNum() - drawNum) < 0) {
                System.out.println("余额不足");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            account.setNowNum(account.getNowNum() - drawNum);
            System.out.println("当前余额为 ：" + account.getNowNum());
        }
    }
}
- 同步块解决 List 不安全问题
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i=0; i<10000; i++){
            // 两个线程覆盖了同一个位置
            new Thread(() ->{
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(1000); // 让主线程睡一会，保证能执行完
        System.out.println(list.size());
    }

CopyOnWriteArrayList 是 JUC 包提供的线程安全集合

    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        for (int i=0; i<10000; i++){
            // 两个线程覆盖了同一个位置
            new Thread(() ->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(1000); // 让主线程睡一会，保证能执行完
        System.out.println(list.size());
    }

四、死锁

死锁描述的是一种多个进程被无限期阻塞，它们中的一个或者多个都在等待某一资源被释放，导致程序不能正常终止的情况 —— 就是线程相互等待对方的资源

/**
 * @Author: WanqingLiu
 * @Date: 2023/02/02/15:51
 * 化妆模拟死锁
 */
public class DeadLock {

    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0, "晚晴");
        Makeup girl2 = new Makeup(1, "婉晴");
        girl2.start();
        girl1.start();
    }
}
// 口红类
class LipStick{

}
// 镜子
class Mirror{

}
// 化妆线程
class Makeup extends Thread {
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;
    String girlName;

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

    @Override
    public void run() {
        // 化妆操作
        try {
            makeup();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    private void makeup() throws InterruptedException {
        if(choice == 0){ // 口红
            synchronized (lipStick) {
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000); // 一秒钟之后，她想获得镜子的锁
                synchronized (mirror) {
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }
        } else { // 镜子
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(1000); // 一秒钟之后，她想获得口红的锁
                synchronized (lipStick) {
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

五、 Lock 锁

1. 基础概念

Lock 锁是 JDK 5.0 开始提供的更加强大的同步机制，其是一个显式同步锁，同步锁通过 Lock 对象充当（ java.util.concurrent.locks ）

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

2. 使用 ReentrantLock 可重入锁解决买票问题

从下面的代码中，我们也可以看出 Lock 锁是显式的加锁，显式的释放锁 。

import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: WanqingLiu
 * @Date: 2023/02/04/10:18
 * 测试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 {
    private static int tikectNum = 100; // 多线程共享的 num

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

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (tikectNum <= 0) {
                    System.out.println("票卖完了~~~");
                    break;
                }
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("窗口 " + Thread.currentThread().getName() + " 售出了一张票，还剩的票数为" + (--tikectNum));
            } finally {
                lock.unlock();
            }
        }
    }
}

3. synchronized 与 Lock 对比

  • Lock 是显式锁，即需要手动开关锁；synchronized 是隐式锁，即出了作用域锁自动释放
  • Lock 只具有代码块锁，而 synchronized 还具有方法锁
  • 使用 Lock 锁，JVM 花费更少的时间调度线程，性能更好，并且具有更好的扩展性（子类）
刘婉晴
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程同步的四种方式详解(建议收藏)
mikechen的互联网架构
09-28 1701
Java线程同步属于Java多线程与并发编程的核心点，需要重点掌握，下面我就来详解Java线程同步的4种主要的实现方式@mikechen
Java并发编程线程间通讯实现过程详解
08-19
Java并发编程线程间通讯实现过程详解是Java编程中非常重要的一部分，涉及到多线程之间的数据共享、同步和通信。在Java中，线程间通讯可以通过多种方式实现，本文将通过示例代码详细介绍一些常用的线程间通讯方式。 ...
Java线程同步
weixin_44824428的博客
01-05 511
Java线程同步
JAVA--线程同步的三种方法
weixin_65282950的博客
10-15 850
【代码】JAVA--线程同步的三种方法。
Java多线程——线程同步
u010759175的专栏
12-28 2892
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
java并发编程：线程基础
08-09
Java并发编程中的线程基础是理解多线程编程的关键，它涵盖了从线程的创建到管理，再到线程间通信的全过程。多线程编程在处理高性能和高响应性的应用程序时至关重要，因为它允许程序在单个进程中同时执行多个任务，...
Java并发编程之创建线程
09-02
在Java并发编程中，创建线程是实现多任务并行执行的关键。线程允许程序中的不同部分同时运行，提高应用程序的响应速度和效率。本文将深入探讨Java中创建线程的两种主要方法：继承`Thread`类和实现`Runnable`接口。 ...
JAVA并发编程艺术pdf版
08-08
通过深入学习《JAVA并发编程艺术》，开发者能更好地理解并发编程的原理，熟练运用Java提供的并发工具和API，解决实际开发中的多线程问题，提高软件的性能和稳定性。这是一本值得每一位Java开发者研读的书。
Java并发编程：同步容器
12-22
为了方便编写出线程安全的程序，Java里面提供了一些线程安全类和并发工具，比如：同步容器、并发容器、阻塞队列、Synchronizer（比如CountDownLatch）。我们来讨论下同步容器。 　一.为什么会出现同步容器？ 　在...
第九篇、线程同步（解决并发问题）
weixin_45796249的博客
09-19 513
通过synchronize修饰解决并发问题。
【java多线程】线程同步问题：用同步代码块、同步方法和重入锁实现线程同步
最新发布
m0_65277261的博客
03-26 1232
同步是执行或调用一个方法时，每次都需要拿到对应的结果才会继续往后执行；异步与同步相反，它会在执行或调用一个方法后就继续往后执行，不会等待获取执行结果。二者的区别就是处理请求发出后，是否需要等待请求结果，再去继续执行其他操作。
Java-基础篇-17-【线程-同步】
Alan0517
03-07 444
【线程、同步】
Java线程同步synchronized
ximen250的专栏
07-26 689
三个窗口卖票的程序。 多线程共同操作一个对象的变量。锁是对象级别的，一个被synchronized修饰的代码块或方法一个时刻只能被一个线程执行。 package fire; public class Seller1 extends Thread{ Ticket t = null; public Seller1(Ticket t){ this.t=t; } public voi
Java实现线程同步的五种方法
芒果就是没有盲的博客
03-08 4566
一.使用synchronized关键字 由于每个java对象都有一个内置锁，用synchronized修饰方法或者代码块时，内置锁会保护整个方法或代码块，要想执行这个方法或者代码块必须获得其内置锁，运行时会加上内置锁，当运行结束时，内置锁会打开。由于同步是一种高开销的工作，所以尽量减少同步的内容，只需同步代码块就可以。 1.修饰方法 public class Test implements Run...
Java中实现线程同步的三种方法
永远是死循环
09-28 325
实现同步的三种方法 多线程共享数据时，会发生线程不安全的情况，多线程共享数据必须同步。 实现同步的三种方法： 1.使用同步代码块 2.使用同步方法 3.使用互斥锁ReetrantLock（更灵活的代码控制） 代码示例： package com.company; import java.util.concurrent.locks.ReentrantLock; /** * @Function: * @author: ????????ℕ????????????????????????ℕ * @cre
java多线程同步5种方法
热门推荐
weixin_39214481的博客
05-28 4万+
一、引言前几天面试，被大师虐残了，好多基础知识必须得重新拿起来啊。闲话不多说，进入正题。二、为什么要线程同步因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不...
Java并发编程 之 同步队列与等待队列
没有进步就是退步
09-29 1万+
在上一篇博客中，我简单的介绍了对Condition和ReentrantLock的使用，但是想要更好的掌握多线程编程，单单会用是不够的。 这篇我会针对Condition方法中的await和signal的实现原理来梳理一下我的理解。首先我们需要了解同步队列和等待队列的概念。简单的理解是同步队列存放着竞争同步资源的线程的引用（不是存放线程），而等待队列存放着待唤醒的线程的引用。同步队列中存放着一个个节点，当
Java线程同步实现方法
此博客不再更新，请访问： http://blog.csdn.net/qq_29078329
10-26 753
1        synchronized关键字 (1)    synchronized修饰代码块，一个线程访问一个对象的synchronized同步代码块时，其它试图访问该对象的线程将被阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块，但是另一个线程仍然可以访问该对象中的非synchronized同步代码块。一个线程在访问一个对象的synchronizedmethod1，其他的线
Java并发编程：线程与进程详解
Java并发编程是Java开发中的关键领域，它涉及多线程、进程、线程安全以及内存模型等多个方面。在Java中，进程和线程是两个核心概念。 **进程**是计算机程序的一个实例，包含运行时所需的指令、独立的地址空间以及...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值