[JavaSE学习之旅]线程同步

最新推荐文章于 2024-07-20 23:55:03 发布
最新推荐文章于 2024-07-20 23:55:03 发布
阅读量95 收藏
点赞数
文章标签： java thread 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45951029/article/details/114377774
版权

线程同步

  • 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制 synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：
    • 一个线程持有锁会导致其他所有需要此锁的线程挂起；
    • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级导致，引起性能问题。

不安全的样例

  1. 不安全的买票
//不安全的买票
public class UnsafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();


        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼的你们").start();
        new Thread(station,"可恶的黄牛党").start();
    }
}

class BuyTicket implements Runnable{

    private int tickerNum = 10;
    private boolean flag = true;

    @Override
    public void run() {
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        //判断是否有票
        if(tickerNum<=0){
            flag = false;
            return;
        }

        //模拟延时
        Thread.sleep(100);

        System.out.println(Thread.currentThread().getName()+"拿到"+tickerNum--);
    }
}

结果：

在这里插入图片描述

  1. 不安全的取钱
//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {

    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");

        you.start();
        girlFriend.start();
    }
}

//账户
class Account{
    //余额
    int money;

    //卡号
    String name;

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

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

//银行：取钱
class Drawing extends Thread{
    //账户
    Account account;
    //取了多少钱
    int drawingMoney;

    //手里的钱
    int nowMoney;

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

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

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money -= drawingMoney;

        nowMoney += drawingMoney;

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

结果：

在这里插入图片描述

  1. 线程不安全的集合
import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

结果：

在这里插入图片描述

同步方法

  • 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。
同步方法：public synchronized void method(int args){}

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

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

  • 方法里需要修改的内容才需要锁，锁的东西太多，浪费资源

  1. 将不安全的买票修改为安全的买票
//不安全的买票
public class UnsafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();


        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼的你们").start();
        new Thread(station,"可恶的黄牛党").start();
    }
}

class BuyTicket implements Runnable{

    private int tickerNum = 10;
    private boolean flag = true;

    @Override
    public void run() {
        while(flag){
            try {
                buy();
                //模拟延时
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //synchronized 同步方法，锁的是this
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if(tickerNum<=0){
            flag = false;
            return;
        }



        System.out.println(Thread.currentThread().getName()+"拿到"+tickerNum--);
    }
}

结果：

在这里插入图片描述

修改了哪些：buy方法增加了synchronized关键字，sleep放在run方法中

同步块

  • 同步块：synchronized(Obj){}

  • Obj称之为同步监视器

    • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是对象本身，或者是class【反射中讲解】

  • 同步监视器的执行过程

    1. 第一个线程访问，锁定同步监视器，执行其中代码
    2. 第二个线程访问，发现同步监视器被锁定，无法访问
    3. 第一个线程访问完毕，解锁同步监视器
    4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
  1. 将不安全的取钱修改为安全的取钱
//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {

    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");

        you.start();
        girlFriend.start();
    }
}

//账户
class Account{
    //余额
    int money;

    //卡号
    String name;

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

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

//银行：取钱
class Drawing extends Thread{
    //账户
    Account account;
    //取了多少钱
    int drawingMoney;

    //手里的钱
    int nowMoney;

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

    //synchronized 默认锁的是this本身
    @Override
    public void run() {

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

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingMoney;

            nowMoney += drawingMoney;

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

    }
}

结果：

在这里插入图片描述

解答：为什么锁run方法没用而用同步代码块锁account对象？

因为同步方法默认锁的是this当前对象，这个样例中进入run方法的对象有you和girlFriend两个对象，you进入run方法锁住的是you这个对象，girlFriend进入run方法锁住的是girlFriend对象，并不能保证他们先后访问账户，我们不应该锁银行，应该锁的是账户，要锁的是变化的量

  1. 将线程不安全的集合修改为线程安全的集合
//线程不安全的集合
public class UnsafeList {
   public static void main(String[] args) {
       List<String> list = new ArrayList<>();
       for (int i = 0; i < 10000; i++) {
           new Thread(()->{
               synchronized (list){
                   list.add(Thread.currentThread().getName());
               }
           }).start();
       }
       try {
           Thread.sleep(10000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println(list.size());
   }
}

结果：

在这里插入图片描述

​ 将变化的量list锁住

CopyOnWriteArrayList

CopyOnWriteArrayList这个类是线程安全的类，可以实现集合自己同步

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class TestJUC {
    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(3000);

        System.out.println(list.size());
    }
}

结果：
在这里插入图片描述

让我们一起变得更强

别说以后_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
javase之多线程技术
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
非常详细javaSE学习笔记.rar
10-21
7. **多线程**：Java内置的Thread类，Runnable接口，同步机制（synchronized关键字，wait(), notify()方法），以及线程池的使用。 8. **反射**：动态获取类信息，实例化对象，调用方法，修改字段值等功能，是Java...
JavaSE进阶：多线程(二)
雙馬程序猿
08-23 203
JavaSE进阶：多线程(二)：3.线程状态、4.线程同步(重点)、
深入理解yield()和sleep()方法
tianmlin1的博客
02-07 585
全文概要 本文主要介绍Thread类中yield()方法和sleep()方法的使用。包括以下内容： 通过一个案例介绍yield()方法的使用；通过一个案例介绍sleep()方法的使用；通过以上案例比较yield()/sleep()/wait()三个方法的区别 yield()方法介绍 代码案例 package com.tml.javaCore.thread; /**
多线程补充 三种实现方式 及卖票系统和习题
Lovely-Zhang-1026的博客
12-21 109
多线程的三种实现方式 以及多线程卖票的实现和练习习题
多线程基础
CyrilのJava世界
04-30 141
线程简介 任务 多任务（现实中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。） 一边吃饭一边玩手机 开车+打电话 进程 多线程 原来是一条路，慢慢因为车太多了，道路堵塞，效率极低。为了提高使用的效率，能够充分利用道路，于是加了多个车道 普通方法调用和多线程 程序、进程、线程 在操作系统中运行的程序就是进程，比如QQ、播放器、游戏、IDE等等 一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等
[JavaSE学习之旅]线程通信
qq_45951029的博客
03-05 64
线程通信 Java提供了几个办法解决线程之间通信的问题 方法名 作用 wait() 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁 wait(long timeout) 指定等待的毫秒数 notify() 唤醒一个处于等待状态的线程 notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级较高的线程优先调度 注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则抛出异常IllegalMonitorStateExce
[JavaSE学习之旅]死锁
qq_45951029的博客
03-04 85
死锁 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”问题。 产生死锁的四个必要条件 互斥条件：一个资源每次只能被一个进程使用 请求和保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺 循环等待条件：若干进程之间形成一种头尾相接的循环资源等待关系 对于上面列出了死锁的四个必要
JavaSE 之旅09——线程
code小生
08-04 289
目录 目录 概念 什么是进程？ 什么是线程？ 并发与并行 创建线程的方式 优缺点对比 源码角度分析 线程的表现形式 休眠线程 守护线程 加入线程 优先级 同步代码块 面试题：sleep() 和 wait() 的区别 总结 概念 什么是进程？ 举例说明，比如 windows 下的任务管理器中的进程列表，每个都是一个进程。 什么是线程？ 线程是...
[JavaSE学习之旅]Lock(锁)
qq_45951029的博客
03-05 75
Lock(锁) 从JDK5.0开始，Java提供了更强大的线程同步机制----通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当 java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象 ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是Reentra
Java程序员发展前景怎么样及JavaSE面试题多线程[图]
minemi的博客
12-09 189
一、Java程序员发展前景怎么样难不难？ Java是一门面向对象编程语言，自1995年发布到现在已风靡全球20余年。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。 就目前的发展形势而言，Java软件工程师的发展前景还是较好的。 程序员是一个行业，无论是java程序员还是Python程序员等，在这里java和python只是一种开发工具。想要学好一门开发语言，最重要也最核心的是其编程思想，
JavaSE_JavaSE学习资料_
10-02
这个编程资料包涵盖了JavaSE的学习资源，旨在帮助开发者掌握Java的基础知识、集合框架、IO流等关键概念。 首先，Java基础知识是学习JavaSE的起点。这包括了Java语法、数据类型、控制结构（如if语句、for循环、while...
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
Java内存模型
weixin_44267758的博客
07-19 564
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 482
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 987
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 171
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
JavaSE编程：多线程泡茶实例解析
在这个JavaSE编程案例中，我们看到了如何使用多线程来模拟泡茶的过程。首先，我们有两个线程类：`BoilThread`（烧开水的线程）和`WashThread`（洗茶杯的线程）。这两个线程分别代表泡茶过程中的两个不同任务，烧开水...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值