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

package cn.tedu.thread;
/**
 * 本类用于改造售票案例,解决多线程编程安全问题
 * 需求:4个线程共同卖100张票
 * 问题1:出现了重卖现象:一张票卖给了多个人
 * 问题2:出现了超卖现象:出现了0张/-1张/-2张这样的现象
 * */
public class TestSaleTicketsV2 {
 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();
 }
}
/**2.多线程中出现数据不安全问题的前提:多线程程序 + 有共享数据(成员变量) +多条语句操作共享数据*/
/**3.同步锁:相当于给容易出现问题的代码加了一把锁,包裹了所有可能会出现问题的代码
 * 加锁范围:不能太大,也不能太小,太大,干啥都得排队,导致程序的效率太低,太小,没锁住,会有安全问题*/
//1.自定义售票类,通过实现Runnable接口的方式完成
class SaleTicketsV2 implements Runnable{
 //2.定义静态成员变量,用来保存票数
 static int tickets = 100;
 //9.2创建了一个唯一的"锁"对象,不论之后那个线程进同步代码块,使用的都是o对象,"唯一"很重要
 Object o = new Object();
 
 /**6.如果一个方法里的代码都被同步了,可以直接把方法修饰成同步方法,同步方法用的锁对象是this*/
 //3.添加未实现方法run()--写业务
 @Override
 //synchronized public void run() {//被synchronized修饰的方法是同步方法
 public void run() {//被synchronized修饰的方法是同步方法
  //4.1通过while(true)死循环的方式卖票,注意添加出口!!!
  while(true) {
   /**4.synchronized(锁对象){}--同步代码块:是指同一时间这一资源会被一个线程独享,大家使用的时候,都得排队,同步效果*/
   /**5.锁对象的要求:多线程之间必须使用同一把锁,同步代码块的方式,关于锁对象可以任意定义*/
   //9.出现了线程安全问题,所以需要加同步代码块
   //9.1这种写法不对,相当于每个线程进来一次new一个锁对象,并不是使用的同一把锁
      //synchronized (new Object()) {   
      //9.3 使用同步代码块,锁对象是o
   synchronized (o) {
    //4.2通过if结构判断卖票情况
    if(tickets > 0) {//还有票,继续售卖
     //8.手动添加休眠方法,创造延迟效果,注意可能会发生问题,需要由try-catch包裹
     try {
      Thread.sleep(10);//让线程休眠10ms
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     //4.3打印当前卖票的线程名以及票数
     System.out.println(Thread.currentThread().getName() + "=" + tickets--);
    }
    //4.4 没票了,退出循环,没的卖了
    if(tickets <= 0) break;
   }
  }
 }
} 

public class TestSaleTicketsV2 {
 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);//本方法的参数就是执行的业务,也就是实现类的目标对象
  }
 }

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();
   }
  }
 }
}