多线程的同步-sychronized

线程同步场景

---

 　　假设盖伦有10000基础血量，这个时候他在基地被别人虐泉水。这时候就会出现这种场景，有多个线程在打击盖伦，减少他的血量。于此同时，基地又有多个线程在给盖伦恢复血量。假设增加血量的线程数和攻击减少血量的线程数是一样的，并且每次改变的值都是1，那么最终盖伦血量应该为基数10000才对。但是，结果不是这个样子的！

　　示例代码 ：Hero

package com.thread;

public class Hero {
    public String name;
    public float hp;
    public int damage;
    //回血
    public void revoer() {
        hp = hp +1;
    }
    //掉血
    public void hurt() {
        hp = hp -1;
    }

    public void attackHero(Hero h) {
        try {
            //为了表示攻击需要时间   每次攻击暂停1秒
            Thread.sleep(1000);
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
        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;   //血量大于0  没死   isDead=false
    }
}

　　线程同步代码

package com.thread.thread9;

import com.thread.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
        //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.revoer();  //加血
                    try {
                        Thread.sleep(100);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            t.start();  //启动线程
            addThreads[i] = t;  //将单个线程放入线程数组中
        }

        //n个线程减少盖伦的hp    for循环内部都是用的局部变量
        for(int i=0; i<n; i++) {
            Thread t = new Thread() {
                public void run() {
                    gareen.hurt();
                    try {
                        Thread.sleep(100);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            t.start();   //启动每一个线程
            reduceThreads[i] = t; //将当个线程放入减少的线程组中
        }

        //等待所有增加线程结束
        for (Thread t: addThreads) {
            try{
                t.join();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //等待所有减少线程结束
        for(Thread t: reduceThreads) {
            try{
                t.join();
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
        }

        //代码执行到这里  所有增加减少线程都结束了
        //增加和减少线程的数量是一样的  每次都是增加 减少1
        //那么所有线程都结束后  盖伦的hp应该还是初始值
        //但是事实观察到的是

        //%d 代表整数参数
        //%n 换行
        //%.0f  float精度
        System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量变成了%.0f%n", n, n, gareen.hp);
    }
}

为什么？

---

　　理论上我们想要：数据10000+1=10001，然后10001-1=10000

　　增加线程的操作步骤有三步，取数据，加法，放回数据。减少线程的操作步骤也有三步，取数据，减法，放回数据。

　　由于线程的启动是很迅速的，而取数据，加法，放回数据这三步需要很长的时间，所以，可能会出现这种情况。

　　当增加线程刚刚在修改数据的时候，还没有提交数据。减少线程就启动线程了，并且拿到还没增加的10000，进行减一操作，然后再把改好的9999放回去，这样我们最终读到的数据就是9999。

　　最终读到的9999和理论10000数据不一致，根本原因是两个线程的争抢，一个线程读到了另一个线程还未提交的数据-脏数据。

 

解决方案-上锁

---

 　　给每个线程sychronized上锁，当t1线程执行的过程中就把t2线程挡在外面。在每次一个线程执行完成后，重新抢夺cpu资源进行单个线程执行。

线程内部上锁

---

　　记录下每行代码执行的时间。给每个线程上锁，看线程占用对象资源后的执行情况。

package com.thread.thread10;

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() {  //重写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) {
                    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) {   //线程t2占领了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) {
                    e.printStackTrace();
                }
            }
        };
        t2.setName(" t2");
        t2.start();
    }
}

　　t1和t2，由于线程启动的时间很短，如果运行程序多次，你会看到t1和t2是没有顺序的。最开始的时候，实际上是他们在抢占资源，谁抢到谁就去占坑位。由于加上了sychronized关键字，所以必须等锁内的最后一行代码，释放了对象，t2才能继续抢占。

 

synchronized使用方式

---

 　　分为三种。一是，在线程内部，run方法内的业务逻辑加上锁。二是，在业务方法内部进行加锁，如果有线程使用该方法，就会触发上锁机制。三是，在业务方法上增加锁，如果有线程使用该方法，就会触发上锁机制。

　　注意: 如果要保证当前线程不会被抢占资源，那么当前线程最好都加上锁，这样才能保证每个线程执行了自己内部的所有任务。

　　一是，在线程内部上锁，在线程同步代码基础上进行更改。实例线程的时候，内部重写run方法，方法内部业务逻辑加锁。

package com.thread.thread11;

import com.thread.Hero;

/**
 * 线程内部每个线程需要执行的方法 给它加上synchronized关键字  使用全局
 * object对象   保持全局唯一
 */

public class TestThread {
    public static void main(String[] args) {
        final Object someObject = new Object();   //声明一个公共的object对象
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 10000;

        System.out.printf("盖伦初始血量是 %.0f%n", gareen.hp);

        //多线成同步问题指的是多个线程同时修改一个数据的时候 导致的问题
        //假设盖伦有10000滴血   并且在基地里  同时又被多个英雄攻击
        //用java代码来表示  就是多个线程在减少盖伦的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() {
                    //在线程内部加血方法加锁
                    synchronized (someObject) {
                        gareen.revoer();  //加血
                    }
                    try {
                        Thread.sleep(100);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            t.start();  //启动线程
            addThreads[i] = t;  //将单个线程放入线程数组中
        }

        //n个线程减少盖伦的hp    for循环内部都是用的局部变量
        for(int i=0; i<n; i++) {
            Thread t = new Thread() {
                public void run() {
                    synchronized (someObject) {
                        gareen.hurt();
                    }
//                    gareen.hurt();
                    try {
                        Thread.sleep(100);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            t.start();   //启动每一个线程
            reduceThreads[i] = t; //将当个线程放入减少的线程组中
        }

        //等待所有增加线程结束
        for (Thread t: addThreads) {
            try{
                t.join();
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //等待所有减少线程结束
        for(Thread t: reduceThreads) {
            try{
                t.join();
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
        }

        //代码执行到这里  所有增加减少线程都结束了
        //增加和减少线程的数量是一样的  每次都是增加 减少1
        //那么所有线程都结束后  盖伦的hp应该还是初始值
        //但是事实观察到的是

        //%d 代表整数参数
        //%n 换行
        //%.0f  float精度
        System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量变成了%.0f%n", n, n, gareen.hp);

    }
}

　　二是，在业务方法内部添加锁。

package com.thread.thread12;

public class Hero {
    public String name;
    public float hp;

    public int damage;

    //回血
    public void revoer() {
        hp = hp +1;
    }
    //掉血
    public void hurt() {
        //使用this作为同步对象
        //哪一个调用这个方法 this就是指代的那一个对象
        synchronized (this) {
            hp = hp -1;
        }
    }

    public void attackHero(Hero h) {
        try {
            //为了表示攻击需要时间   每次攻击暂停1秒
            Thread.sleep(1000);
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
        h.hp -= damage; //血量在被攻击力一点点的减少
        //%s 字符串 %.0f 双精度数 可以带小数
        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;   //血量大于0  没死   isDead=false
    }
}

　　三是业务方法上添加锁。

package com.thread.thread13;

public class Hero {
    public String name;
    public float hp;

    public int damage;

    //回血
    public synchronized void revoer() {
        hp = hp +1;
    }
    //掉血
    public synchronized void hurt() {
        //使用this作为同步对象
        //哪一个调用这个方法 this就是指代的那一个对象
        hp = hp -1;
    }

    public void attackHero(Hero h) {
        try {
            //为了表示攻击需要时间   每次攻击暂停1秒
            Thread.sleep(1000);
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
        h.hp -= damage; //血量在被攻击力一点点的减少
        //%s 字符串 %.0f 双精度数 可以带小数
        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;   //血量大于0  没死   isDead=false
    }
}

线程安全类

---

　　如果一个类，其方法都是有synchronized修饰的，那么该类就叫做线程安全的类。

　　synchronized意义：同一时间，只有一个线程能够进入这种类的一个实例去修改数据，进而保证这个实例中的数据的安全（不会同时被多线程抢占修改而变成脏数据）

StringBuffer和StringBuilder对比

---

 　　StringBuffer源码，这个类在多个线程同时修改一个字符串的时候，不会发生字符串拼接异常，它会等待一个拼接成功后，基于上一个线程执行下一段拼接。线程安全

　　正因为线程安全需要同步，所以效率上比线程不安全的StringBuilder耗时要久，效率要慢。

 HashMap和Hashtable对比

---

 　　Hashtable方法具有synchronized修饰，线程安全。但是不可以放null值。

　　HashMap线程不安全，可以放null值

ArrayList和Vector对比 

---

 　　vector是线程安全的类，方法上加了synchronized关键字。

 

 线程不安全转成线程安全

---

 　　这里ArrayList集合创建的list1线程不安全，使用synchronizedList转换成了list2线程安全的对象

List<String> list1 = new ArrayList<>();
List<String> list2 = Collections.synchronizedList(list1);

　　synchronizedList在Collections中声明了方法，从图中我们可以看到方法内new了两个类SynchronizedRandomAccessList和SynchronizedList

　　根据源码可以看到，两个类最终都会到一个方法

　　下图是SynchronizedCollection的声明方法。所以说，list经过synchronizedList方法的转化，相当于在原来list的基础上，封装了一层，每个方法重写并且加了一把锁在上面。