线程同步&线程池

线程同步&线程池
线程同步

线程不同步会出现的问题：

• 当多个线程操作同一资源时，会出现重复操作和和操作不存在的资源的问题，为了规避这一问题就需要线程的同步操作来实现资源的共同使用。

线程同步：

• 当多个线程操作同一资源时，给操作该资源的代码加上一把锁，当有一个线程拿到这把锁后，其他线程都不能操作带锁的资源代码，直至拿到锁的线程释放锁。

线程同步实现的3种方式：

• 同步代码块
  synchornized(obj){
  //涉及操作同一资源的代码
  }
  注： 没有静态的同步代码块
  obj: 任意类型的对象，相当于一把锁，操作同一资源的而线程必须使用同一把锁。
  如何保证多个线程使用同一把锁？
  在设置线程任务，即定义线程对象时在成员变量的位置上声明一个对象，将声明的变量放在sychornized代码块中
  /**
  *模拟买票功能，开启多个线程，同时买一百张票
  /
  public class SaleTicket implements Runnable{
  /
  不同对象使用同一个变量
  */
  private static int ticket=100 ;

      /**
       *不同线程使用同一个锁对象
       */
      private Object obj = new Object();
      @Override
      public void run() {
          while(true) {
              /**
               * 使用synchornized(obj) {} 代码块
               */
              synchronized (obj) {
                  if (ticket > 0) {
                      try {
                          Thread.sleep(500);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      System.out.println(Thread.currentThread().getName() + "sale=====" + ticket);
                      ticket--;
                  }
              }
          }
      }
  }
  
  
  public class SaleTicketDemoTest {
      public static void main(String[] args) {
          SaleTicket sale = new SaleTicket();
          //开启3个线程操作同一对象，从而操作同一资源
          Thread th1 = new Thread(sale);
          Thread th2 = new Thread(sale);
          Thread th3 = new Thread(sale);
          th1.start();
          th2.start();
          th3.start();
      }
  }
  

• 同步方法
  public synchornied void 方法名(){
  //涉及操作同一资源的方法
  }
  同步方法的锁：
  同步方法的锁使用的是this对象，即new Thread(Xxx) 的Xxx对象
  package com.test.java;

  /**
   *模拟买票功能，开启多个线程，同时买一百张票
   */
  
  public class SaleTicket implements Runnable{
      /*
      不同对象使用同一个变量
       */
      private static int ticket=100 ;
  
      /**
       *不同线程使用同一个锁对象
       */
      private Object obj = new Object();
      @Override
      public void run() {
          while(true) {
                  saleTicket();
          }
      }
      /**
       * 定义个个同步方法 public snychonized void XXX(){}
       */
      public synchronized void saleTicket() {
          if (ticket > 0) {
              try {
                  Thread.sleep(500);
  
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName() + "sale=====" + ticket);
              ticket--;
          }
      }
  }
  

  静态的同步方法
  public static sychornized xxx(){
  //涉及操作共同资源的代码
  }
  静态同步方法的锁是类名.class对象
  package com.test.java;

  /**
   *模拟买票功能，开启多个线程，同时买一百张票
   */
  
  public class SaleTicket implements Runnable{
      /*
      不同对象使用同一个变量
       */
      private static int ticket=100 ;
  
      /**
       *不同线程使用同一个锁对象
       */
      private Object obj = new Object();
      @Override
      public void run() {
          while(true) {
                  saleTicket();
          }
  
  
      /**
       * 静态同步方法
       */
  
      public static synchronized void saleTicket() {
          if (ticket > 0) {
              try {
                  Thread.sleep(500);
  
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName() + "sale=====" + ticket);
              ticket--;
          }
      }
  }
  

• 锁机制
  Jdk1.5后在java.util.concurrent.locks

  lock的好处：解决了当共享资源的锁一直未被释放，其他线程无限等待的问题。
  当多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操 作。因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到
  Lock和synchornized的区别：

  1. Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这 个类可以实现同步访问；
     2. Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

  lock的特点：

  1. 采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话

线程池