线程并发不安全示例，线程如何外部停止，一个对象代理多个线程，模拟延时Thread.sleep,线程内存，Thread中的getname方法，sleep放大线程问题的发生性，Thread（）.start

最新推荐文章于 2023-02-26 15:58:52 发布
最新推荐文章于 2023-02-26 15:58:52 发布
阅读量173 收藏
点赞数
文章标签： java 多线程 多进程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43363066/article/details/113871802
版权

仔细查看第二个不安全示例中的线程是如何创建3个类，如何创建构造函数，如何控制你和女友两个线程同时操作结婚基金，以及run方法中对于剩余金额的判断不够直接输出金额不够return退出run方法，金额足够则

IDEA构造方法选中多个参数时alt+insert后选择constructor构造器，然后按住shift才能选择多个参数

线程的停止可以通过设置标志位来使线程满足一定的条件时，进行线程的终止，代码演示如下：

在这里插入图片描述

一个对象代理多个线程，代码举例如下：

在这里插入图片描述

模拟延时Thread.sleep

在这里插入图片描述

每个线程都有其自己的内存空间

不安全的买票问题：排队买票时，并没有排队买，所有线程都将对象的数据拷贝到自己的内存中进行操作，可能使最后总的票数呈现负数，可能有10张票卖出了11张。

package duoxiancheng;
//不安全的买票
//线程不安全，有负数
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 ticketNums=10;
    boolean flag=true;//外部停止方式
    @Override
    public void run() {
        //买票
        while(flag){
            buy();
        }
    }
    private void buy(){
        //判断是否有票
        if(ticketNums<=0){
            flag=false;
            return;//如果没票直接退出buy方法，return直接退出方法体
            //买票
        }
        System.out.println(Thread.currentThread().getName()+"拿到了--->第"+ticketNums--+"张票");
    }
}

结果如下图所示：
小红拿到了—>第10张票
小白拿到了—>第8张票
小白拿到了—>第6张票
小白拿到了—>第5张票
小明拿到了—>第9张票
小白拿到了—>第4张票
小白拿到了—>第2张票
小红拿到了—>第7张票
小白拿到了—>第1张票
小明拿到了—>第3张票

Process finished with exit code 0

该过程中可能会出现取票错误，可能两个人（进程）同时取到一张票，Thread中可以用sleep使进程延迟

package duoxiancheng;
//不安全的买票
//线程不安全，有负数
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 ticketNums=10;
    boolean flag=true;//外部停止方式
    @Override
    public void run() {
        //买票
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNums<=0){
            flag=false;
            return;
            //买票
        }
        Thread.sleep(100);//通过Thread中的sleep方法，使进程延迟
        System.out.println(Thread.currentThread().getName()+"拿到了--->第"+ticketNums--+"张票");
    }
}

延迟后的进程发生了取票错误，出现了两人抢到同一张票代码如下：
小明拿到了—>第9张票
小红拿到了—>第8张票
小白拿到了—>第10张票
小红拿到了—>第7张票
小明拿到了—>第7张票
小白拿到了—>第6张票
小红拿到了—>第5张票
小明拿到了—>第5张票
小白拿到了—>第5张票
小白拿到了—>第4张票
小红拿到了—>第4张票
小明拿到了—>第4张票
小白拿到了—>第3张票
小明拿到了—>第3张票
小红拿到了—>第3张票
小白拿到了—>第2张票
小明拿到了—>第2张票
小红拿到了—>第1张票

Process finished with exit code 0

以上出现了线程不安全的买票的例子，不排队每个线程都直接将数据放入自己的内存中进行处理，比如每个线程都将9张余票这个数据放入自己的内存，都减1，但实际剩余票数不是8

1.不安全的买票演示

注意Thread后面没有.直接是Thread().start();

package syn;
//不安全的买票
//线程不安全，账户余额可能变成负数
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket num=new BuyTicket();
        new Thread(num,"我").start();//注意Thread后面没有.
        new Thread(num,"你").start();//注意Thread后面没有.
        new Thread(num,"他").start();//注意Thread后面没有.
    }
}

class BuyTicket implements Runnable{
    //设置票数
    private int ticketNums=10;
    boolean flag=true;//线程外部停止方式
    @Override
    public void run() {
         while(flag){
             try {
                 buy();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
    }

    private void buy() throws InterruptedException {
        if(ticketNums<=0){
            flag=false;
            return;
        }
        //模拟延时，放大线程同步问题
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

代码输出结果如下：
你拿到10
我拿到10
他拿到10
你拿到9
他拿到9
我拿到9
他拿到7
我拿到6
你拿到8
你拿到5
我拿到5
他拿到5
你拿到4
他拿到4
我拿到4
你拿到3
他拿到3
我拿到3
你拿到1
我拿到2
他拿到1

Process finished with exit code 0

2.不安全的银行取钱演示

package syn;
//不安全的取钱
//两个人去银行取钱
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,"女友");
        you.start();//you继承了Thread类调用start方法后执行其下的run方法
        girlfriend.start();//girlfriend继承了Thread类调用start方法后执行其下的run方法
    }
}
//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//银行：模拟取款
//两个线程在交替执行可能执行到一半去执行另一个线程的一半再回来执行前一个线程的后一半，也可能执行一半后将另一个线程执行完再执行之前的那个线程。
//你和女友两个线程共同对结婚基金进行支出，进入run方法有2种可能，一个是判断钱不够了，直接输出当前进程钱不够取，
// 另一个是钱够了输出当前线程取出钱后账户剩余的金额，以及当前线程取了多少钱
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;
    }

    //取钱通过重写run方法来完成
    @Override
    public void run() {
        //判断有没有钱
        if (account.money - drawingMoney < 0) {
            System.out.println(Thread.currentThread().getName() + "线程的钱不够，取不了");
            return;//return后直接退出run方法，后面的代码都将不在执行
        }
        //卡内余额=余额-你取的钱
        account.money=account.money-drawingMoney;
        nowMoney=nowMoney+drawingMoney;
        //输出账户余额为多少
        System.out.println(account.name+"余额为："+account.money);
        //输出你手里的钱
        //注意此处Thread.currentThread().getName()=this.getName();
        System.out.println(Thread.currentThread().getName()+"手里的钱"+nowMoney);
    }
}

输出的可能结果有以下几种：
女友线程的钱不够，取不了
结婚基金余额为：50
你手里的钱50

Process finished with exit code 0

结婚基金余额为：50
女友线程的钱不够，取不了
你手里的钱50

Process finished with exit code 0

结婚基金余额为：0
你线程的钱不够，取不了
女友手里的钱100

Process finished with exit code 0
等等。。。。。
在加入sleep延时放大线程问题的发生性时，使两个线程都能取到钱
在这里插入图片描述
加入延时后代码输出结果为：
结婚基金余额为：-50
结婚基金余额为：-50
女友手里的钱100
你手里的钱50

Process finished with exit code 0

结婚基金余额为：50
结婚基金余额为：50
女友手里的钱100
你手里的钱50

Process finished with exit code 0

结婚基金余额为：50
结婚基金余额为：50
你手里的钱50
女友手里的钱100

Process finished with exit code 0

3.不安全的集合演示

由于可能两个线程可能同一时间抢占了同一个内存空间，两个数组添加到了同一个位置，就将前一个线程覆盖掉了，因此线程就会少，所以输出并不是10000个线程，

package syn;
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());
                System.out.println(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}

输出结果如下：
Thread-0
Thread-5
Thread-4
Thread-2
Thread-1
Thread-6
Thread-3
Thread-7
Thread-9
Thread-8
Thread-10
Thread-11
Thread-12
Thread-13
…
Thread-9979
9975
Thread-9981
Thread-9983
Thread-9984
Thread-9985
Thread-9967
Thread-9986
Thread-9972
Thread-9990
Thread-9987
Thread-9988
Thread-9991
Thread-9993
Thread-9994
Thread-9977
Thread-9998
Thread-9980
Thread-9999
Thread-9970
Thread-9992
Thread-9995
Thread-9997

Process finished with exit code 0

注意：
1，在java中int类型的变量默认赋值为0，string类型的变量默认赋值为null
2，IDEA构造方法选中多个参数时alt+insert后选择constructor构造器，然后按住shift才能选择多个参数

屿山海
关注
多线程之线程状态
qq_51993933的博客
06-24 3083
## 线程状态 五大状态 1.创建状态：Thread thread = new Thread(); 线程对象一旦创建就进入了新生状态。 2.就绪状态：当调用start()方法时，进入就绪状态，但不代表立即调度执行（等待cpu调度）。 3.运行状态或同态：进入运行状态，线程才真正执行线程体的代码块。 4. 阻塞状态：当调用sleep,wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞解除后进入就绪状态，等待cpu调度。 5.死亡状态：线程中断或者结束，进入死亡状态，不能再次启动。 停止线程
Android中的线程（二）线程安全 & 线程同步
川峰的博客
06-08 2679
文章目录线程安全synchronizedReentrantLockvolatile 线程安全 线程安全又叫线程同步，在Java中多个线程同时访问一个可共享的资源变量时，有可能会导致数据不准确，导致使用该变量的逻辑出现问题，因此使用同步锁来保证一个线程对该资源的操作完成之前，其他线程不会对其进行操作，即保证线程同步安全。 因此线程同步的本质就是线程排队，这可能跟它的字面意思相反，它的目的就是保证线程按照先后顺序一个一个的访问共享资源，为了避免同时操作同一个共享资源。 在Java中实现线程安全的主要手段有：
线程不安全
想吃一口西多
04-01 151
背景：线程不安全-sleep（模拟网络延迟）后多线程并发访问同一个资源方法1：同步代码块语法：synchronized(同步锁）{    需要同步操作的代码}同步锁：为了保证每个线程都能正常执行原子操作（吃苹果和数量减一为一体就叫原子操作），Java引入了线程同步机制同步监听对象/同步锁/同步监听器/互斥锁对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁Java程序允许使用任何对象作为同步...
java-线程Thread&线程不安全&线程生命周期&锁对象
weixin_52509741的博客
04-23 449
文章目录一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('igno
三大不安全线程案例
weixin_46751741的博客
02-18 2877
1. 不安全的买票 public class Tiket implements Runnable { static int tiket = 10; boolean flag = true; @Override public void run() { while(flag) buy(); } public void buy() { //模拟买票 if (tiket <= 0) {flag=fals
9三大线程不安全案例
yuan_boss的博客
07-14 702
线程不安全 案例一：线程不安全的ArrayList ArrayList集合是线程不安全的，因为多个线程添加元素的时候可能是在同一个瞬间，导致将多个元素添加至同一个位置，造成覆盖问题，例如代码: public class UnSafeList { public static void main(String[] args) throws InterruptedException { List<String> list = new ArrayList<>();
JavaThread 10 并发问题 → 三大不安全案例
小哞^同^学的技术博客
07-17 183
5.1 并发问题 → 三大不安全案例 5.1.1 三人共同买票（不安全买票） package www.muquanyu.syn; //不安全的买票 案例 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station,"黄牛").start(); new
多线程——三大不安全案例
beishanqiye的博客
09-18 381
买票 package thread; //不安全的买票 public class ThreeUnsafeCases { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"You").start(); new Thread(buyTicket,"I").start(); new Th
多线程爬取1000个网页_python爬虫_thread_
10-01
在Python中创建线程非常简单，只需要定义一个函数作为线程的目标，然后使用`Thread`类实例化一个线程对象，最后调用`start()`方法启动线程。例如： ```python import threading def crawl_url(url): # 在这里编写...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
最新发布
02-02
在多线程编程中，死锁是一种常见的问题，指的是两个或多个线程在执行过程中，因为竞争资源而造成的一种相互等待的现象。若线程A持有资源1，等待资源2；线程B持有资源2，等待资源1，则这两个线程就会陷入无限期的阻塞...
C++多线程并发（一）--- 线程创建与管理
热门推荐
流云
03-16 2万+
一、何为并发 简单来说，并发指的是两个或多个独立的活动在同一时段内交替发生。与并发相近的另一个概念是并行，并行则强调的是多个独立的活动在同一时刻点同时发生。 二、为什么使用并发 在应用程序中使用并发的原因主要有两个：关注点分离和性能。事实上，甚至可以说它们差不多是使用并发的唯一原因；当你观察的足够仔细时，一切其他因素都可以归结到这两者之一（或者可能是二者兼有）。
线程不安全的3大不安全案例及解决方法
weixin_53653788的博客
02-04 237
买票不安全 package Day8; public class Ticket { public static void main(String[] args) { Tickets tickets = new Tickets(); new Thread(tickets,“a”).start(); new Thread(tickets,“b”).start(); new Thread(tickets,“c”).start(); } } class Tickets implements Runnable{ pr
线程安全的三大不安全案例及解决方法
IAMZTDSF的博客
04-08 459
1.没有排队导致线程不安全 示例：不安全买票 原因：每个线程都有自己的工作内存，内存控制不当会造成数据不一致（最后一张票被多个线程同时载入内存） package syn; public class UnsafeBuyTicket { public static void main(String[] args) { BuyTickey station = new BuyTickey(); new Thread(station,"我").start();
进程的不安全问题与解决方案
来杯咖啡吗的博客
05-26 870
不安全的买票 sleep会放大问题的发生性噢！ package syn; /** * 不安全的买票 */ public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"你").start(); new Thread(buyTicket,"我"
线程(一)线程安全和不安全
lly576403061的博客
06-19 844
我们经常会听到有人数线程安全或者线程不安全之类的说法，但是到底什么是线程安全还是不安全呢，其实也没有什么神秘的，线程安全呢就是在我们的多线程开始执行我们代码的时候不管怎么执行都是获取到的结果是一样的，就是和单线程执行的结果一样，不过比单线程所使用的时间就是少（在多核CPU下）;那么对应的就是线程不安全,顾名思义就是线程执行的时候返回的结果部保证每一次都是一样的,这个是因为我们是采用的多线程,多线程
关于线程的几个简单案例
weixin_42209881的博客
01-24 1353
package com.zhang.test.thread; public class Test1 implements Runnable{ private static Test1 test1 = new Test1(); static int i = 0; public static void main(String[] args) throws InterruptedExcep...
玩转java多线程 之多线程基础 线程休眠 sleep
weixin_45806131的博客
10-04 136
线程休眠： sleep时间指定当前线程阻塞的毫秒数 sleep存在异常 InterruptedException sleep时间达到线程后线程进入就绪状态 sleep可以模拟网络延时，倒计时等 每一个对象都有一个锁，sleep不会释放锁 模拟网络延时，可以放大问题的发生性 比如之前买票的例子： package duoxiancheng; //模拟网络延时 public class TestSleep implements Runnable{ //票数 private int ticket
线程的状态及多线程带来的风险
dddddrrrzz的博客
04-07 1404
目录一、线程的状态1.1 NEW1.2 RUNNABLE1.3 BLOCKED1.4 WAITING1.5 TIMED_WAITING1.6 TERMINATED二、多线程带来的的风险-线程安全2.1 线程安全的概念2.2 线程不安全的典型案例2.3 线程不安全的原因synchronized 关键字-监视器锁monitor locksynchronized的使用方式总结 一、线程的状态 1.1 NEW NEW: 安排了工作, 还未开始行动； 把 Thread对象创建好了,但是还没有调用start 。
解决线程不安全的3种方法
CherryBlossom_的博客
02-26 540
java八股文解决线程不安全的方法
新年倒计时与Java多线程安全实践：Thread.sleep()理解与练习
代码中，`Thread.sleep(1000)`用于模拟一秒的暂停，但是需要注意的是，`Thread.sleep()`会抛出`InterruptedException`，这是一种编译时异常，因此我们需要用`try-catch`块来捕获并处理它，确保程序不会因异常而中断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值