JavaSE笔记7.3-多线程-多线程的安全问题

最新推荐文章于 2020-12-09 16:57:49 发布
最新推荐文章于 2020-12-09 16:57:49 发布
阅读量162 收藏
点赞数
分类专栏： JavaSE 文章标签： javase 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38503984/article/details/104341236
版权

一. 引入

class Ticket implements Runnable
{
    private int num=100;
    public void run()
    {
        while(true)
        {
            if(num>0)
            {
                try{
                    Thread.sleep(10);
                }
                catch (Exception e){}
                System.out.println(Thread.currentThread().getName()+"...sale："+num--);
            }
        }
    }
}
class TicketDemo
{
    public static void main(String[] args)
    {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行结果是：
在这里插入图片描述
发现：多线程的运行出现了安全问题，打印出0、-1、-2等错票。

二. 问题总结

多线程的运行出现了安全问题

1. 问题的原因

当多条语句在操作同一个线程共享数据时（写操作），一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致了共享数据的错误。

2. 解决方法

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中其它线程不可以参与执行。
（即使其它线程拿到了执行权，也不能进行操作）

3. Java的解决方法

同步代码块

synchronized(对象)
{
    需要被同步的代码//与操作共享数据相关的代码
}

class Ticket implements Runnable
{
    private int num=100;
    Object obj=new Object();
    public void run()
    {
        while(true)
        {
            synchronized(obj)
            {
                if(num>0)
                {
                    try{Thread.sleep(10);}
                    catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"...sale："+num--);
                }
            }
        }
    }
}
class TicketDemo2
{
    public static void main(String[] args)
    {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

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

三. 同步代码块

对象如同锁
持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取了CPU的执行权也进不去，因为没有锁。

1. 同步的前提

（1）必须要有2个或者2个以上的线程
（2）必须是多个线程使用同一个锁
（3）必须保证同步中只能有一个线程在运行

2. 好处

解决了多线程的安全问题

3. 弊端

多个线程需要判断锁，较为消耗资源

4. 练习

需求：银行有一个金库，有两个储户分别存300元，每次存100元，存3次
目的：该程序是否有安全问题，如果有如何解决
如何找问题：
（1）明确哪些代码是多线程运行的代码
（2）明确共享数据
（3）明确多线程运行代码中哪些语句是操作共享数据的
问题：

class Bank{
    private int sum;
    public void add(int n){
        sum=sum+n;
        try{Thread.sleep(10);}
        catch(Exception e){}
        System.out.println("sum= "+sum);
    }
}
class Cus implements Runnable{
    private Bank b=new Bank();
    public void run(){
        for(int x=0;x<3;x++){
            b.add(100);
        }
    }
}
class BankDemo{
    public static void main(String[] args){
        Cus c=new Cus();
        Thread t1=new Thread(c);
        Thread t2=new Thread(c);
        t1.start();
        t2.start();
    }
}

运行结果是：
在这里插入图片描述
解决问题：

class Bank{
    private int sum;
    Object obj=new Object();
    public void add(int n){
        //同步代码块
        synchronized (obj){
            sum=sum+n;
            try{Thread.sleep(10);}
            catch(Exception e){}
            System.out.println("sum= "+sum);
        }
    }
}
class Cus implements Runnable{
    private Bank b=new Bank();
    public void run(){
        for(int x=0;x<3;x++){
            b.add(100);
        }
    }
}
class BankDemo{
    public static void main(String[] args){
        Cus c=new Cus();
        Thread t1=new Thread(c);
        Thread t2=new Thread(c);
        t1.start();
        t2.start();
    }
}

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

四. 同步函数

1. 例子
class Bank{
    private int sum;
 
    //同步函数
    public synchronized void add(int n){
            sum=sum+n;
            try{Thread.sleep(10);}
            catch(Exception e){}
            System.out.println("sum= "+sum);
    }
}
class Cus implements Runnable{
    private Bank b=new Bank();
    public void run(){
        for(int x=0;x<3;x++){
            b.add(100);
        }
    }
}
class BankDemo{
    public static void main(String[] args){
        Cus c=new Cus();
        Thread t1=new Thread(c);
        Thread t2=new Thread(c);
        t1.start();
        t2.start();
    }
}

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

class Ticket implements Runnable
{
    private int num=100;
    Object obj=new Object();
    public void run()
    {
        while(true)
        {
               show();
        }
    }
    public synchronized void show(){
        if(num>0)
        {
            try{Thread.sleep(10);}
            catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"...sale："+num--);
        }
    }
}
class TicketDemo2
{
    public static void main(String[] args)
    {
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

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

2. 同步函数的锁是this

函数需要被对象调用，那么函数都有一个所属对象的引用，就是this
所以同步函数使用的锁是this

（1）同步函数的锁不是Object类对象

使用2个线程来卖票
一个线程在同步代码块中，一个线程在同步函数中
都在执行卖票动作

class Ticket implements Runnable{
    private int num=500;
    Object obj=new Object();
    boolean flag=true;
    public void run(){
        if(flag){
            while(true){
                //同步代码块
                synchronized (obj){
                    if(num>0){
                        try{Thread.sleep(10);}
                        catch (Exception e){}
                        System.out.println(Thread.currentThread().getName()+"...code: "+num--);
                    }
                }
            }
        }
        else{
            while (true){
                //同步函数
                show();
            }
        }
    }
    public synchronized void show() {
        if (num > 0) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "...show: " + num--);
        }
    }
}
class ThisLockDemo{
    public static void main(String[] args){
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        t1.start();
        //在主线程加入sleep函数，使得线程1和线程2可以分别执行同步代码块和同步函数
        try{Thread.sleep(10);}
        catch(Exception e){}

        t.flag=false;
        t2.start();
    }
}

运行结果是：出现了错票0
在这里插入图片描述
原因：
同步的前提出问题了；
两个线程不是使用同一个锁，因此同步函数的锁不是Object类对象

（2）同步函数的锁是this

将同步代码块的对象换成this进行验证

class Ticket implements Runnable{
    private int num=500;
    Object obj=new Object();
    boolean flag=true;
    public void run(){
        if(flag){
            while(true){
                //同步代码块
                //将同步代码块的对象换成this
                synchronized (this){
                    if(num>0){
                        try{Thread.sleep(10);}
                        catch (Exception e){}
                        System.out.println(Thread.currentThread().getName()+"...code: "+num--);
                    }
                }
            }
        }
        else{
            while (true){
                //同步函数
                show();
            }
        }
    }
    public synchronized void show() {
        if (num > 0) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "...show: " + num--);
        }
    }
}
class ThisLockDemo{
    public static void main(String[] args){
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        t1.start();
        //在主线程加入sleep函数，使得线程1和线程2可以分别执行同步代码块和同步函数
        try{Thread.sleep(10);}
        catch(Exception e){}

        t.flag=false;
        t2.start();
    }
}

运行结果是：没有出现错票
在这里插入图片描述
结论：同步函数的锁是this

五. 静态同步函数的锁是class对象

1. 静态同步函数的锁不是this
class Ticket implements Runnable{
    private static int num=500;
    Object obj=new Object();
    boolean flag=true;
    public void run(){
        if(flag){
            while(true){
                //同步代码块
                //将同步代码块的对象换成this
                synchronized (this){
                    if(num>0){
                        try{Thread.sleep(10);}
                        catch (Exception e){}
                        System.out.println(Thread.currentThread().getName()+"...code: "+num--);
                    }
                }
            }
        }
        else{
            while (true){
                //静态同步函数
                show();
            }
        }
    }

    //静态同步函数
    public static synchronized void show() {
        if (num > 0) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "...show: " + num--);
        }
    }
}
class StaticMethodDemo{
    public static void main(String[] args){
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        t1.start();
        //在主线程加入sleep函数，使得线程1和线程2可以分别执行同步代码块和同步函数
        try{Thread.sleep(10);}
        catch(Exception e){}

        t.flag=false;
        t2.start();
    }
}

运行结果是：出现了错票0
在这里插入图片描述
原因：
同步的前提出问题了；两个线程不是使用同一个锁，因此静态同步函数的锁不是this
（因为静态方法中不可以定义this）

2. 静态同步函数的锁是class对象

猜想：
静态方法进内存的时候没有对象，是由类调用的。
类进内存有对象，类要先封装成class类对象（字节码类对象）；
验证：将同步代码块的对象换成Ticket.class

class Ticket implements Runnable{
    private static int num=500;
    Object obj=new Object();
    boolean flag=true;
    public void run(){
        if(flag){
            while(true){
                //同步代码块
                //将同步代码块的对象换成Ticket.class
                synchronized (Ticket.class){
                    if(num>0){
                        try{Thread.sleep(10);}
                        catch (Exception e){}
                        System.out.println(Thread.currentThread().getName()+"...code: "+num--);
                    }
                }
            }
        }
        else{
            while (true){
                //静态同步函数
                show();
            }
        }
    }

    //静态同步函数
    public static synchronized void show() {
        if (num > 0) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + "...show: " + num--);
        }
    }
}
class StaticMethodDemo{
    public static void main(String[] args){
        Ticket t=new Ticket();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        t1.start();
        //在主线程加入sleep函数，使得线程1和线程2可以分别执行同步代码块和同步函数
        try{Thread.sleep(10);}
        catch(Exception e){}

        t.flag=false;
        t2.start();
    }
}

运行结果是：没有出现错票
在这里插入图片描述
结论：
静态同步函数使用的锁是该方法所在类的字节码文件对象，类名.class

又困了天哪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
7-3 试试多线程 (10 分)
qq_36291502的博客
12-07 956
编写4个线程，第一个线程从1加到25，第二个线程从26加到50,第三个线程从51加到75，第四个线程从76加到100，最后再把四个线程计算的结果相加。 输入格式: 无 输出格式: 最终结果 输入样例: 结尾无空行 输出样例: 5050 结尾无空行 import java.util.*; public class Main{ public static void main(String[] args){ Scanner in=new Scanner(System.in);
Java多线程之线程安全问题
weixin_43265151的博客
02-25 304
1.线程安全问题产生的原因 在使用多线程解决问题的时候，因为多个线程对同一共享数据的操作破坏了数据的原子性，而导致产生了线程安全问题。（原子性：从字面意思来看是指不可分割的，那么原子性则是，当一个线程对一个多个线程共享的数据进行操作时，是不可分割的。通俗来讲是指，当一个线程对共享数据操作时，其他线程不能对该共享数据进行操作） 举个例子：两个人共同使用一张银行卡，这个银行卡里有1000元存款，两个人...
试试多线程（java）
weixin_45850801的博客
12-09 2167
7-3 试试多线程 (10分) 题干： 编写4个线程，第一个线程从1加到25，第二个线程从26加到50,第三个线程从51加到75，第四个线程从76加到100，最后再把四个线程计算的结果相加。 输入样例： 无 输出样例： 5050 呈上我粗糙但是过了代码： import java.util.*; public class mine { public static void main(String[] args) { int sum=0; for(int i=1;i<=4;
7-1 试试多线程 (20分)
Cai_zi_heng的博客
11-18 3496
编写4个线程，第一个线程从1加到25，第二个线程从26加到50,第三个线程从51加到75，第四个线程从76加到100，最后再把四个线程计算的结果相加。 输入格式: 无 输出格式: 最终结果 输入样例: 输出样例: 5050 public class Main { public static void main(String [] args) { A a = new A(); B b = new B(); C c = new C();
7.3.2 - 并发多线程 开启的两种方式
weixin_30877755的博客
03-06 76
一 threading模块介绍 multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性 二 开启线程的两种方式 方式一 from threading import Thread import time import random def running(name): print("%s is running" % nam...
7.3.1 - 并发多线程 线程
weixin_30552811的博客
03-06 136
一 什么是线程 在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程 线程顾名思义，就是一条流水线工作的过程（流水线的工作需要电源，电源就相当于cpu），而一条流水线必须属于一个车间，一个车间的工作过程是一个进程，车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一条流水线。 所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu...
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
JavaSe知识总结：多线程.xmind
10-19
思维导图：含括多线程概念，线程创建开启方式，线程安全，线程状态及常见问题
马士兵多线程笔记.zip
02-21
以下是对马士兵多线程笔记的详细解析。 1. **多线程基础**：多线程是指一个应用程序中同时执行多个线程（即任务）的能力。这种并发执行可以提高系统资源的利用率，提升程序的响应速度和执行效率，特别是在多核...
javase之多线程技术
最新发布
10-16
- 在Java中，线程安全问题主要由于共享数据和并发访问导致的。从字节码角度分析，需要理解指令重排序和内存模型对多线程的影响。CPU上下文切换时，需确保数据的一致性，避免数据竞争和死锁。 3. **Callable与...
JavaSE多线程编程专题.pptx
06-08
JavaSE多线程编程专题
JavaSE笔记7.1-多线程-概述
qq_38503984的博客
02-04 1164
一. 进程和线程 进程：是一个正在执行中的程序。 每一个进程执行都有一个执行的顺序，该顺序就是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。 线程在控制着进程的执行。 一个进程中至少有一个线程。 二. Java的运行进程 javac.exe：Java的编译进程 java.exe：Java的运行进程 Java JVM启动的时候会有一个进程java.exe 该进程中至少有...
JavaSE笔记12-System类
qq_38503984的博客
08-18 911
JavaSE笔记12-System类1. 概述2. 系统属性信息 1. 概述 public final class System extends Object System类没有构造方法，不能被实例化 System类提供标准输入流System.in、标准输出流System.out、错误输出流System.err System类包含很多系统级的属性和控制方法，类中的方法都是静态的 2. 系统属性信息 （1）方法 //获取所有属性信息 public static Properties getProper
JavaSE笔记10.8-集合-Map
qq_38503984的博客
04-06 444
一. Map概述 1. 定义 Map是一种键-值对（key-value）集合，Map集合中的每一个元素都包含一个键（key）对象和一个值（value）对象，用于保存具有映射关系的数据。 Collection是单列集合，Map是双列集合 2. Map的特点 key和value都可以是任意引用类型的数据 key不允许重复，value可以重复 每个key可以映射到最多一个value 3. Map的常...
JavaSE笔记10.5-集合-HashSet
qq_38503984的博客
03-21 340
一. Set概述 1. Set的特点 元素是无序的；元素不可以重复。因为该集合体系无索引。 （无序：存入和取出的顺序不一定一致） 2. Set的功能 Set集合的功能和Collection是一致的 3. Set的子类 常见子类 （1）HashSet 底层数据结构是哈希表； （2）TreeSet 底层数据结构是二叉树； 二. HashSet底层数据结构 https://blog.csdn.net/w...
JavaSE笔记6.11-面向对象-多态
qq_38503984的博客
01-07 272
一. 概念 1. 引入 可以理解为事物存在的多种体现形态。 人：男人、女人 动物：猫、狗 猫 x=new 猫(); 动物 x=new 猫(); abstract class Animal { abstract void eat(); } class Cat extends Animal { public void eat() { System.out.println("吃鱼"); }...
JavaSE笔记15.16-IO流-字符编码
qq_38503984的博客
09-12 250
JavaSE笔记15.16-IO流-字符编码1. 字符编码解码（1）通过转换流（2）通过字符串对象2. 常见的编码表3. 例子（1）通过转换流（2）通过字符串对象 1. 字符编码解码 （1）通过转换流 通过转换流InputStreamReader和OutputStreamWriter来完成，在两个对象进行构造时可加入字符集。 //创建使用给定字符集的InpuStreamReader InputStreamReader(InputStream in,Charset cs); //创建使用给定字符集的Outpu
JavaSE笔记10.6-集合-TreeSet
qq_38503984的博客
03-21 242
https://www.jianshu.com/p/263a40a5a90e?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值