Day17-API05-2-同步锁、线程安全问题解决方案、接口线程池优化线程

1.同步锁

 

**如何判断程序是否有线程安全问题？

答：在多线程程序中+有共享数据+多条语句操作共享数据

多线程安全问题的解决方案

**1.1加锁

1.加锁的位置：

容易出现线程安全问题的位置

2.加锁：注意加锁的范围

太大：整个程序都是同步的，都要排队，效率低了，失去多线程的效果

太小：要保护的资源锁不住

**1.2同步与异步：

1）同步：类似于排队的效果，一个接一个，同一时刻只能有一个线程占有资源，其他线程排队，

优点：线程是安全的

缺点：需要排队，效率变低

2）异步：不排队，多线程的效果，各个线程抢占资源

优点：抢占资源效率高

缺点：可能出现数据安全隐患

1.3 同步锁synchronized关键字

改造售票案例--解决售票时重卖与超卖的现象

解决方案：双重校验机制DoubleCheck

1）增加判断控制--有票时在卖票，会减少超卖的概率

2）使用同步代码块，主要强调同步，也就是同一资源只能被一个线程独享

3）synchronized(锁对象){可能发生安全问题的代码}

TIPS：同步代码块使用的锁对象必须唯一！！！

TIPS：使用继承方式时，锁对象是本类的字节码对象(子类名.class)

TIPS：使用接口实现方式时，锁对象不限（对象/字节码对象）【到成员变量下方位置创建对象，锁对象是创建对象的对象名】

练习1：继承方式多线程售票解决安全问题

package cn.tedu.tickets;

public class TestExtendsV2 {
    public static void main(String[] args) {
        //6.创建多线程对象
        TicketThreadV2 t1 =new TicketThreadV2();
        TicketThreadV2 t2 =new TicketThreadV2();
        TicketThreadV2 t3 =new TicketThreadV2();
        TicketThreadV2 t4 =new TicketThreadV2();
        //7.以多线程的方式启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
//1.自定义多线程业务类
class TicketThreadV2 extends Thread{

    //3.定义一个成员变量保存票数,此方式需要设置票数为静态，优先加载一次
    static int tickets = 100;
    //2.重写父类的run()方法
    @Override
    public void run() {
        //4.使用循环卖票
        while(true) {
            /*锁对象必须唯一*/
            //synchronized (new Object()){
            //错误，因为每个线程都会new一个object对象，锁对象不唯一
            /*双重校验二：使用同步代码块
            * synchronized(锁对象){容易发生数据安全问题的代码}
            * 在同步代码块中，同一时刻同一资源只能被一个线程独享，其他线程排队
            * 注意：锁对象必须唯一，如果不唯一，还会发生安全问题
            * 如果是继承的方式的话，锁对象一般使用本类的字节码对象(子类名.class)*/
            synchronized (TicketThreadV2.class) {
                try {
                    //5.人为休眠10毫秒，发生阻塞，会产生重卖和超卖现象
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                /*双重校验一：有票的时候再卖票，增加了一个判断*/
                if (tickets > 0) {
                    //4.1获取线程名和票数减一
                    System.out.println(getName() + "=" + tickets--);
                }
                //4.2设置出口，没票停止
                if (tickets <= 0) break;
            }
        }
    }
}

练习2：实现接口下多线程售票案例解决数据安全问题

package cn.tedu.tickets;
/*本类解决实现接口下多线程售票案例的数据安全问题*/
public class TestRunnableV2 {
    public static void main(String[] args) {
        //6.创建目标业务类对象target
        TicketsRunnable1 target = new TicketsRunnable1();
        //7.创建多个线程对象
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        //8.以多线程的方式启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
//1.自定义多线程售票业务
class TicketsRunnable1 implements Runnable{
    //3.定义一个成员变量保存票数,只创建一个接口对象，可不用加static
    int tickets = 100;
    /*实现接口的方式，不限制锁对象的类型，只需要保持锁对象的唯一
    * 亦为提取到成员位置创建对象即可，因为target对象只创建一次*/
    Object o = new Object();
    //2.添加未实现的方法，将业务写在run()方法中
    @Override
    public void run() {
        //4.循环售票
        while(true) {
            //10.双重校验二：同步代码块
            /*注意：锁对象必须唯一，下面这种方式不正确
            * 原因：每个线程执行run()时都会new一个锁对象*/
            //synchronized (new Object()) {
            synchronized (o){
                //5.主动让线程休眠10ms，出现阻塞状态
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //9.双重校验一：加判断
                if (tickets > 0) {
                    //4.1打印现在正在卖票的线程名+票数--
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                //4.2死循环需要设置出口！没票时停止
                if (tickets <= 0) break;
            }
        }
    }
}

其中

/*如果一个方法中的所有代码均需要被同步，那么可以用synchronized修饰
    *被synchronized关键字修饰的方法称为同步方法
    * 但同步方法不常用，使用同步代码块可以调用自己即可*/
    //synchronized public void run() {

1.4之前遇到过的同步例子

StringBuffer JDK1.0	加了synchronized ,性能相对较低(要排队,同步),安全性高
StringBuilder JDK1.5	去掉了synchronized,性能更高(不排队,异步),存在安全隐患

2.线程创建的其他方式

2.1线程池ExecutorService

1）线程池工具类：Executors

newFixedThreadPool(int nThreads)	最多n个线程的线程池
newCachedThreadPool()	足够多的线程,使任务不必等待
newSingleThreadExecutor()	只有一个线程的线程池

2）线程池：存放线程的池子，把新建线程/启动线程/关闭线程的任务都交给池来管理

3）创建线程池的工具类：Executors.newFixedThread

4）启动线程池中的线程：pool.execute(target目标业务对象)

TIPS:线程池会自动管理线程，线程池目前单机测试不关闭，需要手动关闭 

TIPS:线程池Executor是接口，可以和Runnable接口联用，线程池也需要一个同样的业务对象target

2.2练习：线程池创建线程售票

package cn.tedu.tickets;

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

/*本类解决实现接口下多线程售票案例的数据安全问题*/
public class TestRunnableV2 {
    public static void main(String[] args) {
        //6.创建目标业务类对象target
        TicketsRunnable1 target = new TicketsRunnable1();
        //7.创建多个线程对象
//        Thread t1 = new Thread(target);
//        Thread t2 = new Thread(target);
//        Thread t3 = new Thread(target);
//        Thread t4 = new Thread(target);
        //8.以多线程的方式启动线程
//        t1.start();
//        t2.start();
//        t3.start();
//        t4.start();
         //Executor是接口，可以和Runnable接口联用，不能和继承式线程联用
        /*11.线程池ExecutorService：用于存储线程的池子，把新建/启动/关闭线程都交给池来做
        * 12.Executors：用于创建线程池的工具类，
        * newFixedThreadPool()--创建一个指定线程数的线程池--可调节顺序大小的线程池*/
        //13.创建线程池对象，线程池容纳的线程数指定为5
        ExecutorService pool = Executors.newFixedThreadPool(5);
        for (int i = 1; i <6; i++) {
            /*14.executor()让线程池中的线程来执行任务，每次调用都会启动一个线程
            * 方法的参数是要执行的自定义业务，也就是目标对象target*/
            pool.execute(target);
        }
    }
}
//1.自定义多线程售票业务
class TicketsRunnable1 implements Runnable{
    //3.定义一个成员变量保存票数,只创建一个接口对象，可不用加static
    int tickets = 100;
    /*实现接口的方式，不限制锁对象的类型，只需要保持锁对象的唯一
    * 亦为提取到成员位置创建对象即可，因为target对象只创建一次*/
    Object o = new Object();
    //2.添加未实现的方法，将业务写在run()方法中
    @Override
    /*如果一个方法中的所有代码均需要被同步，那么可以用synchronized修饰
    *被synchronized关键字修饰的方法称为同步方法
    * 但同步方法不常用，使用同步代码块可以调用自己即可*/
    //synchronized public void run() {
    public void run() {
        //4.循环售票
        while(true) {
            //10.双重校验二：同步代码块
            /*注意：锁对象必须唯一，下面这种方式不正确
            * 原因：每个线程执行run()时都会new一个锁对象*/
            //synchronized (new Object()) {
            synchronized (o){
                //5.主动让线程休眠10ms，出现阻塞状态
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //9.双重校验一：加判断
                if (tickets > 0) {
                    //4.1打印现在正在卖票的线程名+票数--
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                //4.2死循环需要设置出口！没票时停止
                if (tickets <= 0) break;
            }
        }
    }
}

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.4synchronize锁和Lock锁的区别

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