25 同步锁-线程安全问题解决方案

1 同步锁
1.1 前言
经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象.
上节笔记点这里-进程与线程笔记

我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件:

在多线程程序中 + 有共享数据 + 多条语句操作共享数据
多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务)
所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题
那我们可以把有可能出现问题的代码都包裹起来，一次只让一个线程来执行

1.2 同步与异步
那怎么"把有可能出现问题的代码都包裹起来"呢?我们可以使用synchronized关键字来实现同步效果
也就是说,当多个对象操作共享数据时,可以使用同步锁解决线程安全问题,被锁住的代码就是同步的

接下来介绍下同步与异步的概念:
同步：体现了排队的效果，同一时刻只能有一个线程独占资源，其他没有权利的线程排队。
坏处就是效率会降低，不过保证了安全。
异步：体现了多线程抢占资源的效果，线程间互相不等待，互相抢占资源。
坏处就是有安全隐患,效率要高一些。

1.3 synchronized同步关键字
1.3.1 写法
synchronized (锁对象){
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
}

1.3.2 前提
同步效果的使用有两个前提:

前提1：同步需要两个或者两个以上的线程(单线程无需考虑多线程安全问题)
前提2：多个线程间必须使用同一个锁(我上锁后其他人也能看到这个锁,不然我的锁锁不住其他人,就没有了上锁的效果)
1.3.3 特点
synchronized同步关键字可以用来修饰方法,称为同步方法,使用的锁对象是this
synchronized同步关键字可以用来修饰代码块,称为同步代码块,使用的锁对象可以任意
同步的缺点是会降低程序的执行效率，但我们为了保证线程的安全,有些性能是必须要牺牲的
但是为了性能,加锁的范围需要控制好,比如我们不需要给整个商场加锁,试衣间加锁就可以了
为什么同步代码块的锁对象可以是任意的同一个对象,但是同步方法使用的是this呢?
因为同步代码块可以保证同一个时刻只有一个线程进入
但同步方法不可以保证同一时刻只能有一个线程调用,所以使用本类代指对象this来确保同步

1.4.1练习-改造售票案例
创建包: cn.tedu.tickets
创建类:TestRunnableV2.java

package cn.tedu.tickets;
/*需求:改造售票案例,解决多线程数据不安全的问题*/
public class TestRunnableV2 {
    public static void main(String[] args) {
        //5.创建目标业务对象
        TicketRunnable target = new TicketRunnable();
        //6.使用Thread类中的含参构造,将目标对象与线程对象做绑定
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        //7.以多线程的方式启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}
/*1.多线程中出现数据安全隐患的原因:
*多线程程序 + 有共享数据(成员变量) + 多条语句操作共享数据 */
/*2.同步锁:相当于给容易出现问题的代码加了一把锁,包裹了所有可能会出现安全隐患的代码
加锁之后,就有同步(排队)的效果,但是加锁的范围,需要考虑:
不能太大,太大,干啥都得排队,效率低,范围太小,太小,锁不住,还是会有安全隐患*/
//1.创建自定义多线程类
class TicketRunnable implements Runnable{
    //3.创建成员变量,用来保存票数,注意必须是静态的
    static int tickets = 100;
    //8.2创建一个唯一的锁对象
    /*5.不论之后是哪个线程进同步代码块,使用的都是唯一的锁对象,"唯一"很重要*/
    Object o = new Object();
    //2.添加接口中未实现的方法,把业务放在run()里
    @Override
    /*6.如果一个方法中的所有代码都需要同步,那这个方法可以设置成同步方法*/
    //synchronized public void run() {/*被sychronized关键字修饰的方法是同步方法*/
    public void run() {/*被sychronized关键字修饰的方法是同步方法*/
        while (true){
            //8.1使用同步代码块包裹可能会出现安全隐患的代码,锁对象类型任意
            /*3.同步代码块:sychronized(锁对象){会出现安全问题的代码}
             * 同步代码块中,同一时刻,同一资源,只能被一个线程独享*/
            /*4.这种写法不对,相当于每个线程进来都会new一个锁对象,线程间并不是使用同一把锁*/
            //synchronized (new Object()) {
            //8.3修改同步代码块的锁对象为成员变量o,注意,"唯一"很重要
            synchronized (o) {
                //3.获取当前正在卖票的线程名称,以及卖票
                if(tickets > 0){//还有票的情况下就卖票

                    try {
                        //让程序休眠后出现的两个问题:
                        //问题1.重卖:一张票卖给了多个人
                        //问题2.超卖:出现了票数为0甚至是负数的情况
                        Thread.sleep(10);//让程序休眠10ms
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                //4.设置死循环的出口
                if (tickets <= 0) break;
            }
        }
    }
}

1.4.2 练习-改造售票案例
创建包: cn.tedu.tickets
创建类:TestThreadV2.java

package cn.tedu.tickets;

/*需求:设计多线程编程模型,4个窗口共计售票100张*/
/*本类通过继承Thread类的方式实现多线程售票案例*/
public class TestThreadV2 {
    public static void main(String[] args) {
        //5.创建多个线程对象 Ctrl+D 复制当前行
        TicketThread t1 = new TicketThread();
        TicketThread t2 = new TicketThread();
        TicketThread t3 = new TicketThread();
        TicketThread t4 = new TicketThread();
        //6.以多线程的方式启动
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义线程售票业务类
class TicketThread extends Thread {
    //3.定义变量,用来保存票数
    //int tickets = 100;//不可以,会卖400张票
    //7.解决4个线程卖了400张票的BUG
    static int tickets = 100;//静态资源属于类资源,被全局所有对象共享,只有一份

    //2.把业务写在重写run()里
    @Override
    public void run() {
        //4.通过循环结构来一直卖票
        while (true) {
            synchronized (TicketThread.class) {
                if (tickets > 0) {
                    try {
                        //8.如果数据能够经受住sleep的考验,才能说明数据没有了安全隐患--人为制造问题
                        //问题1:产生了重卖:同一张票卖给了多个人
                        //问题2:产生了超卖:超出了规定票数,甚至卖出了0和-1这样的票数
                        Thread.sleep(10);//让程序休眠10ms
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + "=" + tickets--);
                }
                //做判断,如果没有票了,就退出死循环
                if (tickets <= 0) break;//注意,死循环一定要设置出口
            }
        }
    }
}

注意:如果是继承的方式的话,锁对象最好用"类名.class",否则创建自定义线程类多个对象时,无法保证锁的唯一

1.5 之前遇到过的同步例子
StringBuffer JDK1.0
加了synchronized ,性能相对较低(要排队,同步),安全性高
StringBuilder JDK1.5
去掉了synchronized,性能更高(不排队,异步),存在安全隐患

快速查找某个类的快捷键:Ctrl+Shift+T

2 线程创建的其他方式
2.1 ExecutorService/Executors
ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理

execute(Runnable任务对象) 把任务丢到线程池
Executors 辅助创建线程池的工具类

newFixedThreadPool(int nThreads) 最多n个线程的线程池
newCachedThreadPool() 足够多的线程,使任务不必等待
newSingleThreadExecutor() 只有一个线程的线程池
2.2 练习:线程的其他创建方式
创建包: cn.tedu.tickets
创建类: TestRunnableV2.java

public class TestRunnableV2 {
    public static void main(String[] args) {
        //5.创建接口实现类对象作为目标对象(目标对象就是要做的业务)
        SaleTicketsV2 target = new SaleTicketsV2();
        //6.将目标对象与Thread线程对象绑定
//        Thread t1 = new Thread(target);
//        Thread t2 = new Thread(target);
//        Thread t3 = new Thread(target);
//        Thread t4 = new Thread(target);
        //7.以多线程的方式启动线程--会将线程由新建状态变为就绪状态
        /**1.如果只创建了一个线程对象,是单线程场景,不会出现数据问题*/
//        t1.start();
//        t2.start();
//        t3.start();
//        t4.start();
        /**7.线程池ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理*/
        /**8.Executors用来辅助创建线程池对象,newFixedThreadPool()创建具有参数个数的线程数的线程池*/
        ExecutorService pool = Executors.newFixedThreadPool(5);
        for(int i = 0;i<5;i++) {
            /**9.excute()让线程池中的线程来执行任务,每次调用都会启动一个线程*/
            pool.execute(target);//本方法的参数就是执行的业务,也就是实现类的目标对象
        }
    }

3 拓展:线程锁
3.1 悲观锁和乐观锁
悲观锁：像它的名字一样，对于并发间操作产生的线程安全问题持悲观状态.
悲观锁认为竞争总是会发生，因此每次对某资源进行操作时，都会持有一个独占的锁,就像synchronized,不管三七二十一，直接上了锁就操作资源了。

乐观锁：还是像它的名字一样，对于并发间操作产生的线程安全问题持乐观状态.
乐观锁认为竞争不总是会发生，因此它不需要持有锁，将”比较-替换”这两个动作作为一个原子操作尝试去修改内存中的变量，如果失败则表示发生冲突，那么就应该有相应的重试逻辑。

3.2 两种常见的锁
synchronized 互斥锁（悲观锁，有罪假设）
采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。
每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。

ReentrantLock 排他锁（悲观锁，有罪假设）
ReentrantLock是排他锁，排他锁在同一时刻仅有一个线程可以进行访问，实际上独占锁是一种相对比较保守的锁策略，在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生，这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题，如果”读/读”操作能够以共享锁的方式进行，那会进一步提升性能。

ReentrantReadWriteLock 读写锁（乐观锁，无罪假设）
因此引入了ReentrantReadWriteLock，顾名思义，ReentrantReadWriteLock是Reentrant（可重入）Read（读）Write（写）Lock（锁），我们下面称它为读写锁。
读写锁内部又分为读锁和写锁，读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。
读锁和写锁分离从而提升程序性能，读写锁主要应用于读多写少的场景。

3.3 尝试用读写锁改造售票案例
package cn.tedu.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 本类用于改造售票案例,使用可重入读写锁
 * ReentrantReadWriteLock
 * */
public class TestSaleTicketsV3 {
    public static void main(String[] args) {
        SaleTicketsV3 target = new SaleTicketsV3();
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
class SaleTicketsV3 implements Runnable{
    static int tickets = 100;
    //1.定义可重入读写锁对象,静态保证全局唯一
    static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    @Override
    public void run() {
        while(true) {
            //2.在操作共享资源前上锁
            lock.writeLock().lock();
            try {
                if(tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                if(tickets <= 0) break;
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                //3.finally{}中释放锁,注意一定要手动释放,防止死锁,否则就独占报错了
                lock.writeLock().unlock();
            }
        }
    }
} 

3.4 两种方式的区别
需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁会自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内！
与互斥锁相比，读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程）从理论上讲，与互斥锁定相比，使用读-写锁允许的并发性增强将带来更大的性能提高。