Java基础（14）---- 线程同步

线程同步

卖票

需求，实现三个窗口卖票，直到票卖完为止，

• 线程类

public class SellTicket implements Runnable{

	private int tickets = 20;
	@Override
	public void run() {
		while(true){
			if(tickets > 0){
				System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
				tickets--;
			}
		}
		
	}
}

• 测试类

	@Test
	public void test1(){
		//创建SellTickets类的对象
		SellTicket st = new SellTicket();
		//创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
	}
/*
窗口2正在出售第20张票
窗口2正在出售第19张票
窗口2正在出售第18张票
窗口2正在出售第17张票
窗口2正在出售第16张票
窗口2正在出售第15张票
窗口2正在出售第14张票
窗口2正在出售第13张票
窗口2正在出售第12张票
窗口1正在出售第20张票
窗口3正在出售第20张票
窗口1正在出售第10张票
窗口2正在出售第11张票
窗口1正在出售第8张票
窗口1正在出售第6张票
窗口3正在出售第9张票
窗口1正在出售第5张票
窗口1正在出售第3张票
窗口1正在出售第2张票
窗口1正在出售第1张票
窗口2正在出售第7张票
窗口3正在出售第4张票
*/

但是通过代码实现，发现如果按照上面的内容去运行，

• 问题一：会出现一样的数据，即相同的票出现了多次

• 问题二：有可能会出现负数（我没有运行出来，因为逻辑问题）

  两个问题出现的原因都是线程执行的随机性导致的

• 那么如何解决上面的问题呢？

  • 通过同步代码块解决数据安全问题

同步代码

同步代码块

• 安全问题出现的条件

  • 是多线程环境

  • 有共享数据

  • 有多条语句操作共享数据

• 如何解决多线程安全问题呢?

  • 基本思想：让程序没有安全问题的环境

• 怎么实现呢?

  • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

  • Java提供了同步代码块的方式来解决

• 同步代码块格式：

  synchronized(任意对象) { 
  	多条语句操作共享数据的代码 
  }
  

  synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

• 同步的好处和弊端

  • 好处：解决了多线程的数据安全问题

  • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

• 代码演示

• 线程

  public class SellTicket implements Runnable{
  
  	private int tickets = 20;
  	private Object obj = new Object();
  	@Override
  	public void run() {
  		while(true){
  			//tickets = 100;
              //t1,t2,t3
              //假设t1抢到了CPU的执行权
              //假设t2抢到了CPU的执行权
              synchronized (obj) {
                  //t1进来后，就会把这段代码给锁起来
                  if (tickets > 0) {
                      try {
                          Thread.sleep(100);
                          //t1休息100毫秒
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      //窗口1正在出售第100张票
                      System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                      tickets--; //tickets = 99;
                  }
              }
              //t1出来了，这段代码的锁就被释放了
  		}
  		
  	}
  }
  

• 测试代码：这时候不能使用Junit测试，只能使用main方法进行测试，否则的话，结果出不来

  public class Test3 {
  	
  	public static void main(String[] args) {
  		//创建SellTickets类的对象
  		SellTicket st = new SellTicket();
  		//创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
  		Thread t1 = new Thread(st,"窗口1");
  		Thread t2 = new Thread(st,"窗口2");
  		Thread t3 = new Thread(st,"窗口3");
  		
  		//启动线程
  		t1.start();
  		t2.start();
  		t3.start();
  	}
  
  }
  /*
  窗口1正在出售第20张票
  窗口1正在出售第19张票
  窗口1正在出售第18张票
  窗口1正在出售第17张票
  窗口1正在出售第16张票
  窗口1正在出售第15张票
  窗口1正在出售第14张票
  窗口1正在出售第13张票
  窗口1正在出售第12张票
  窗口1正在出售第11张票
  窗口3正在出售第10张票
  窗口3正在出售第9张票
  窗口3正在出售第8张票
  窗口3正在出售第7张票
  窗口3正在出售第6张票
  窗口3正在出售第5张票
  窗口3正在出售第4张票
  窗口3正在出售第3张票
  窗口3正在出售第2张票
  窗口3正在出售第1张票
  */
  

同步方法

• 同步方法的格式

  同步方法：就是把synchronized关键字加到方法上

  修饰符 synchronized 返回值类型 方法名(方法参数) { 
  	方法体；
  }
  

  同步方法的锁对象是什么呢?

  this

• 静态同步方法

  同步静态方法：就是把synchronized关键字加到静态方法上

  修饰符 static synchronized 返回值类型 方法名(方法参数) { 
  	方法体；
  }
  

  同步静态方法的锁对象是什么呢?

  类名.class

• 代码演示:就线程类这一块不一样，其他都一模一样

  public class SellTicket implements Runnable{
  
  	private static int tickets = 20;
  	private Object obj = new Object();
  	@Override
  	public void run() {
  		while(true){
  			sellTicket();
  		}
  	}
  //  静态同步方法
      private static synchronized void sellTicket() {
          if (tickets > 0) {
              try {
                  Thread.sleep(100);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
              tickets--;
          }
      }
  }
  
  

线程安全的类

• StringBuffer

  • 线程安全，可变的字符序列

  • 从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步

• Vector

  • 从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector

• Hashtable

  • 该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值
  • 从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable

Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

• ReentrantLock构造方法

  方法名	说明
  ReentrantLock()	创建一个ReentrantLock的实例

• 加锁解锁方法

  方法名	说明
  void lock()	获得锁
  void unlock()	释放锁

• 代码演示

  public class SellTicket implements Runnable {
      private int tickets = 100;
      private Lock lock = new ReentrantLock();
  
      @Override
      public void run() {
          while (true) {
              try {
                  lock.lock();
                  if (tickets > 0) {
                      try {
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                      tickets--;
                  }
              } finally {
                  lock.unlock();
              }
          }
      }
  }