JAVA 多线程同步 synchronized

最新推荐文章于 2021-02-25 01:36:38 发布
最新推荐文章于 2021-02-25 01:36:38 发布
阅读量248 收藏
点赞数
分类专栏： JAVA-线程
多线程的同步问题指的是多个线程同时修改一个数据的时候，可能导致的问题 

多线程的问题，又叫Concurrency 问题

  • 演示同步问题
    假设盖伦有10000滴血，并且在基地里，同时又被对方多个英雄攻击
    就是有多个线程在减少盖伦的hp
    同时又有多个线程在回复盖伦的hp
    假设线程的数量是一样的，并且每次改变的值都是1，那么所有线程结束后，盖伦应该还是10000滴血。
    但是。。。


    注意： 不是每一次运行都会看到错误的数据产生，多运行几次，或者增加运行的次数

    package charactor;
  
public class Hero{
    public String name;
    public float hp;
     
    public int damage;
     
    //回血
    public void recover(){
        hp=hp+1;
    }
     
    //掉血
    public void hurt(){
        hp=hp-1;
    }
     
    public void attackHero(Hero h) {
        h.hp-=damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);
        if(h.isDead())
            System.out.println(h.name +"死了！");
    }
  
    public boolean isDead() {
        return 0>=hp?true:false;
    }
  
}
    package multiplethread;
    
import charactor.Hero;
    
public class TestThread {
    
    public static void main(String[] args) {
            
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 10000;
           
        System.out.printf("盖伦的初始血量是 %.0f%n", gareen.hp);
           
        //多线程同步问题指的是多个线程同时修改一个数据的时候，导致的问题
           
        //假设盖伦有10000滴血，并且在基地里，同时又被对方多个英雄攻击
           
        //用JAVA代码来表示，就是有多个线程在减少盖伦的hp
        //同时又有多个线程在回复盖伦的hp
           
        //n个线程增加盖伦的hp
           
        int n = 10000;
   
        Thread[] addThreads = new Thread[n];
        Thread[] reduceThreads = new Thread[n];
           
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                    gareen.recover();
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            addThreads[i] = t;
               
        }
           
        //n个线程减少盖伦的hp
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                    gareen.hurt();
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            reduceThreads[i] = t;
        }
           
        //等待所有增加线程结束
        for (Thread t : addThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //等待所有减少线程结束
        for (Thread t : reduceThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
           
        //代码执行到这里，所有增加和减少线程都结束了
           
        //增加和减少线程的数量是一样的，每次都增加，减少1.
        //那么所有线程都结束后，盖伦的hp应该还是初始值
           
        //但是事实上观察到的是：
                   
        System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量变成了 %.0f%n", n,n,gareen.hp);
           
    }
        
}
  • 分析同步问题产生的原因
    1. 假设增加线程先进入，得到的hp是10000 
    2. 进行增加运算 
    3. 正在做增加运算的时候，还没有来得及修改hp的值，减少线程来了 
    4. 减少线程得到的hp的值也是10000 
    5. 减少线程进行减少运算 
    6. 增加线程运算结束，得到值10001，并把这个值赋予hp 
    7. 减少线程也运算结束，得到值9999，并把这个值赋予hp 
    hp，最后的值就是9999 
    虽然经历了两个线程各自增减了一次，本来期望还是原值10000，但是却得到了一个9999 
    这个时候的值9999是一个错误的值，在业务上又叫做脏数据


  • 解决思路
    总体解决思路是： 在增加线程访问hp期间，其他线程不可以访问hp 
    1. 增加线程获取到hp的值，并进行运算 
    2. 在运算期间，减少线程试图来获取hp的值，但是不被允许 
    3. 增加线程运算结束，并成功修改hp的值为10001 
    4. 减少线程，在增加线程做完后，才能访问hp的值，即10001 
    5. 减少线程运算，并得到新的值10000


  • synchronized 同步对象概念
    解决上述问题之前，先理解
    synchronized关键字的意义
    如下代码：
    Object someObject =new Object();
    synchronized (someObject){
    //此处的代码只有占有了someObject后才可以执行
    }
    synchronized表示当前线程，独占 对象 someObject
    当前线程独占 了对象someObject，如果有其他线程试图占有对象someObject，就会等待，直到当前线程释放对someObject的占用。
    someObject 又叫同步对象，所有的对象，都可以作为同步对象
    为了达到同步的效果，必须使用同一个同步对象


    释放同步对象的方式： synchronized 块自然结束，或者有异常抛出

    package multiplethread;
  
import java.text.SimpleDateFormat;
import java.util.Date;
   
public class TestThread {
     
    public static String now(){
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }
     
    public static void main(String[] args) {
        final Object someObject = new Object();
          
        Thread t1 = new Thread(){
            public void run(){
                try {
                    System.out.println( now()+" t1 线程已经运行");
                    System.out.println( now()+this.getName()+ " 试图占有对象：someObject");
                    synchronized (someObject) {
                          
                        System.out.println( now()+this.getName()+ " 占有对象：someObject");
                        Thread.sleep(5000);
                        System.out.println( now()+this.getName()+ " 释放对象：someObject");
                    }
                    System.out.println(now()+" t1 线程结束");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t1.setName(" t1");
        t1.start();
        Thread t2 = new Thread(){
  
            public void run(){
                try {
                    System.out.println( now()+" t2 线程已经运行");
                    System.out.println( now()+this.getName()+ " 试图占有对象：someObject");
                    synchronized (someObject) {
                        System.out.println( now()+this.getName()+ " 占有对象：someObject");
                        Thread.sleep(5000);
                        System.out.println( now()+this.getName()+ " 释放对象：someObject");
                    }
                    System.out.println(now()+" t2 线程结束");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        t2.setName(" t2");
        t2.start();
    }
       
}
  • 使用synchronized 解决同步问题
    所有需要修改hp的地方，有要建立在占有someObject的基础上。 
    而对象 someObject在同一时间，只能被一个线程占有。 间接地，导致同一时间，hp只能被一个线程修改。

    package multiplethread;
   
import java.awt.GradientPaint;
 
import charactor.Hero;
   
public class TestThread {
   
    public static void main(String[] args) {
 
        final Object someObject = new Object();
         
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 10000;
          
        int n = 10000;
  
        Thread[] addThreads = new Thread[n];
        Thread[] reduceThreads = new Thread[n];
          
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                     
                    //任何线程要修改hp的值，必须先占用someObject
                    synchronized (someObject) {
                        gareen.recover();
                    }
                     
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            addThreads[i] = t;
              
        }
          
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                    //任何线程要修改hp的值，必须先占用someObject
                    synchronized (someObject) {
                        gareen.hurt();
                    }
                     
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            reduceThreads[i] = t;
        }
          
        for (Thread t : addThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        for (Thread t : reduceThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
          
        System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量是 %.0f%n", n,n,gareen.hp);
          
    }
       
}
  • 使用hero对象作为同步对象
    既然任意对象都可以用来作为同步对象，而所有的线程访问的都是同一个hero对象，索性就使用gareen来作为同步对象 
    进一步的，对于Hero的hurt方法，加上： 
    synchronized (this) { 
    } 
    表示当期对象为同步对象，即也是gareen为同步对象
    package charactor;
  
public class Hero{
    public String name;
    public float hp;
     
    public int damage;
     
    //回血
    public void recover(){
        hp=hp+1;
    }
     
    //掉血
    public void hurt(){
        //使用this作为同步对象
        synchronized (this) {
            hp=hp-1;   
        }
    }
     
    public void attackHero(Hero h) {
        h.hp-=damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);
        if(h.isDead())
            System.out.println(h.name +"死了！");
    }
  
    public boolean isDead() {
        return 0>=hp?true:false;
    }
  
}
    package multiplethread;
   
import java.awt.GradientPaint;
 
import charactor.Hero;
   
public class TestThread {
   
    public static void main(String[] args) {
 
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 10000;
          
        int n = 10000;
  
        Thread[] addThreads = new Thread[n];
        Thread[] reduceThreads = new Thread[n];
          
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                     
                    //使用gareen作为synchronized
                    synchronized (gareen) {
                        gareen.recover();
                    }
                     
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            addThreads[i] = t;
              
        }
          
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                    //使用gareen作为synchronized
                    //在方法hurt中有synchronized(this)
                    gareen.hurt();
                     
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            reduceThreads[i] = t;
        }
          
        for (Thread t : addThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        for (Thread t : reduceThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
          
        System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量是 %.0f%n", n,n,gareen.hp);
          
    }
       
}
  • 在方法前，加上修饰符synchronized
    在recover前，直接加上synchronized ，其所对应的同步对象，就是this
    和hurt方法达到的效果是一样
    外部线程访问gareen的方法，就不需要额外使用synchronized 了
    package charactor;
  
public class Hero{
    public String name;
    public float hp;
     
    public int damage;
     
    //回血
    //直接在方法前加上修饰符synchronized
    //其所对应的同步对象，就是this
    //和hurt方法达到的效果一样
    public synchronized void recover(){
        hp=hp+1;
    }
     
    //掉血
    public void hurt(){
        //使用this作为同步对象
        synchronized (this) {
            hp=hp-1;   
        }
    }
     
    public void attackHero(Hero h) {
        h.hp-=damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n",name,h.name,h.name,h.hp);
        if(h.isDead())
            System.out.println(h.name +"死了！");
    }
  
    public boolean isDead() {
        return 0>=hp?true:false;
    }
  
}
    package multiplethread;
   
import java.awt.GradientPaint;
 
import charactor.Hero;
   
public class TestThread {
   
    public static void main(String[] args) {
 
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 10000;
          
        int n = 10000;
  
        Thread[] addThreads = new Thread[n];
        Thread[] reduceThreads = new Thread[n];
          
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                     
                    //recover自带synchronized
                    gareen.recover();
                     
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            addThreads[i] = t;
              
        }
          
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                    //hurt自带synchronized
                    gareen.hurt();
                     
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            reduceThreads[i] = t;
        }
          
        for (Thread t : addThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        for (Thread t : reduceThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
          
        System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量是 %.0f%n", n,n,gareen.hp);
          
    }
       
}
  • 线程安全的类
    如果一个类，其方法都是有synchronized修饰的，那么该类就叫做线程安全的类


    同一时间，只有一个线程能够进入 这种类的一个实例 的去修改数据，进而保证了这个实例中的数据的安全(不会同时被多线程修改而变成脏数据)


    比如StringBuffer和StringBuilder的区别
    StringBuffer的方法都是有synchronized修饰的，StringBuffer就叫做线程安全的类
    而StringBuilder就不是线程安全的类






litengbin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线程交互_多线程系列教材 （六）- Java 线程之间的交互 wait和notify
weixin_39878698的博客
02-26 44
//Hero类public class Hero {public String name ;public int hp ;public int damage ;public Hero(){};public Hero(String name,int hp,int damage){this.name = name ;this.hp = hp ; //这里我比较懒，所以用的int类型this....
多线程的同步问题
Whiteleaf3er的博客
09-11 296
多个线程同时修改统一数据造成错误的数据输出叫做多线程的同步问题 这是因为同时访问同一变量，当一个线程还未返回结果作为下一线程的参数时，下一线程已经开始，最后的结果也就是最后一个线程最后结束时变量最后改变的结果 synchronized表示当前线程，独占 对象 someObject 表示这个线程都占了此对象 其他线程要想进行就得等待此进程得结束也就是 synchronized 块自然结束 ...
Java自学-多线程 交互
我的博客
06-23 153
Java 线程之间的交互 wait和notify 线程之间有交互通知的需求，考虑如下情况： 有两个线程，处理同一个英雄。 一个加血，一个减血。 减血的线程，发现血量=1，就停止减血，直到加血的线程为英雄加了血，才可以继续减血 步骤 1 : 不好的解决方式 故意设计减血线程频率更高，盖伦的血量迟早会到达1 减血线程中使用while循环判断是否是1，如果是1就不停的循环,直到加血线程回复了血量 这是不...
java 线程交互_Java自学-多线程 交互
weixin_36259939的博客
02-25 136
Java 线程之间的交互 wait和notify线程之间有交互通知的需求，考虑如下情况：有两个线程，处理同一个英雄。一个加血，一个减血。减血的线程，发现血量=1，就停止减血，直到加血的线程为英雄加了血，才可以继续减血步骤 1 : 不好的解决方式故意设计减血线程频率更高，盖伦的血量迟早会到达1减血线程中使用while循环判断是否是1，如果是1就不停的循环,直到加血线程回复了血量这是不好的解决方式，因...
how2J学习之Java多线程
inf_zh
01-15 466
多线程即在同一时间，可以做多件事情。 创建多线程有3种方式，分别是继承线程类，实现Runnable接口，匿名类。 首先看看不使用多线程的情况： package charactor; import java.io.Serializable; public class Hero{ public String name; public float hp; p...
浅析Java多线程同步synchronized
08-27
本篇文章给大家详细分析了Java多线程同步synchronized的相关知识点，需要的读者们可以参考学习下。
Java多线程同步Synchronized深入解析
12-22
　1、在系统中对访类要使用多线程进行访问； 　2、在该类中有 类变量，或者是 在类的方法中有访问公共资源（如一个外部文件的读写）。 　同步锁锁定的内容是什么？ 　无论你将Synchronized加在方法前还是加在...
Java多线程synchronized同步方法详解
08-24
主要介绍了Java多线程synchronized同步方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
Java 多线程同步 锁机制与synchronized深入解析
09-05
从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间
多线程  同步
vino991的博客
03-18 144
多线程的同步问题指的是多个线程同时修改一个数据的时候，可能导致的问题 多线程的问题，又叫Concurrency问题 分析同步问题产生的原因 1. 假设增加线程先进入，得到的hp是10000 2. 进行增加运算 3. 正在做增加运算的时候，还没有来得及修改hp的值，减少线程来了 4. 减少线程得到的hp的值也是10000 5. 减少线程进行减少运算 6. 增加线程运算结束，得...
java多线程修改数据_java线程修改数据的问题
weixin_33503998的博客
02-19 625
//代码1publicclassCrawlUrlContainer{privateList>toCrawlList=newArrayList>();publicList>getToCrawlList(){returntoC...//代码1public class CrawlUrlContainer {private List> toCrawlList = new Array...
Java主线程等待所有子线程执行完毕再执行解决办法集
Andyの笔记
11-21 6025
Java主线程等待所有子线程执行完毕在执行，其实在我们的工作中经常的用到，比如说主线程要返回一个响应用户的值，但这个值得赋值过程是由过个子线程来完成的（模拟一个实际开发的情景），所以主线程必须等待子线程执行完毕，再响应用户；否则，响应用户的是一个无意义的值。 那么如何确保所有的子线程执行完毕了。一般的有如下方法： 1 让主线程等待，或着睡眠几分钟。用Thread.sleep()或者TimeUnit.SECONDS.sleep(5); 2 使用Thread的join()等待所有的子线程执行完毕，
Java 多线程（3）---- 线程的同步（上）
指点
03-17 901
前言 我们在前面两篇文章中分别看了一下 Java 线程的一些概念、用法和对于线程控制（开始、暂停、停止）等，并对其中的一些易错点进行了总结，如果你是对这些概念还是还不是太熟悉，建议先看一下前面的文章：Java 多线程（1）— 初识线程 和 Java 多线程（2） — 线程的控制。这篇文章我们来继续讨论 Java 多线程 — 线程的同步。 Java 内存模型 在开始介绍线程同步之前，我们必...
第二十三章 Java线程与操作系统关系
gonghaiyu的博客
11-29 639
Java线程与操作系统关系 线程是比进程更轻量级的调度执行单位，线程可以把一个进程的资源分配和执行调度分开，各个线程可以共享进程资源（内存地址、文件I/O等），又可以独立调度。并发不一定依赖于线程，PHP中是多进程并发。但Java并发大多数情况下与线程有关。线程是CPU调度和分配的基本单位，也就是说开辟线程需要系统内核来完成。 Java线程的实现方式 主流的操作系统都提供了线程实现，Java语言则提供了在不同硬件和操作系统平台下对线程操作的统一处理，每个已经执行start()且还未结束的java.lang.
java多线程实战( 多个线程 修改同一个变量)
热门推荐
hebixi的专栏
11-05 1万+
java多线程实战 介绍：
6-01 Java多线程编程
lduzhenlin的专栏
04-05 129
目录 一.线程的概念 二.创建线程 三.中断线程 四.线程常用方法 五.线程同步与交互 七.代码实现的同步和交互Lock 八.线程池 九.线程工具类 一.线程的概念 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。 比如java.exe进程中可以运行很多...
Java - 反射机制中，在静态方法上加synchronized，同步对象是什么？
sara_211的博客
03-26 1106
输出是最好的输入，做一个Java学习记录~ 在对象方法前，加上修饰符synchronized，同步对象是当前实例，也就是this啦 那么如果在类方法前，加上修饰符sunchronized，同步对象是什么呢？ 当synchronized修饰静态方法的时候，同步对象就是这个类的类对象。 代码验证如下： package reflection; public class TestReflec...
多线程实现加法（三种创建线程的方式）
terk1790的博客
07-04 966
文章目录三种创建线程的方法继承Thread类（没有返回值）实现Runable接口（没有返回值）实现Callable接口（有返回值）CountDownLatch 三种创建线程的方法 利用多线程去计算加法，主要有三步 分解任务为子任务 新建线程执行子任务（如何得到结果或保存结果） 得到子任务的结果，合并得到最终结果 创建线程主要有三种方法，前两种没有返回值，callable接口有返回值。 继承Thread类（没有返回值） //继承thread类，需要重写run方法 public class SumThrea
java线程同步synchronized
最新发布
07-27
Java中的线程同步是通过关键字synchronized来实现的。synchronized关键字可以应用在方法或代码块上，用于实现线程安全。当一个线程获取了某个对象的锁，其他试图获取该对象锁的线程将被阻塞，直到该线程释放锁。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值