多线程 同步

多线程的同步问题指的是多个线程同时修改一个数据的时候，可能致使的问题
多线程的问题，又叫Concurrency 问题

演示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;
    }
}

package multiplethread;
import charactor.Hero;
public class TestThread3 {
    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
        int n = 10000;
        Thread[] addThreads = new Thread[n];
        Thread[] reduceThreads = new Thread[n];
         //n个线程增长盖伦的hp 
        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对象做为同步对象

package charactor;
  
public class Hero{
    public String name;
    public float hp;
    public int damage;
    //回血
    public void recover(){
	     synchronized (this) {
	        hp=hp+1;
        }
    }
    //掉血
    public void hurt(){
        //使用this做为同步对象
        synchronized (this) {
            hp=hp-1;   
        }
    }
}

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(){
                    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.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 synchronized  void hurt(){
        hp=hp-1;
    }

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就不是线程安全的类