线程安全和同步问题

线程安全和同步问题：

使用线程同步解决线程安全问题：
当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的，否则就是不安全的。

1，解决线程安全问题的一种方案：使用同步代码块
格式：sychronized(锁对象)
{
可能出现的线程安全问题的代码（访问了共享数据的代码）
}

例如：

 Object obj = new Object();
      private int ticket = 100;

      @Override
      public void run() {
          while (true) {
              synchronized (obj) {
                  if (ticket > 0) {
                      //提高安全问题出现的频率
                      try {
                          Thread.sleep(20);
                      } catch (InterruptedException e) {
                          e.printStackTrace();

                          System.out.println(Thread.currentThread().getName() + "售出" + ticket--);
                      }
                  }
              }

          }
      }

2，同步代码块保证了线程的安全问题，但是进程在执行同步代码块的时候每次都要判断锁的状态，非常消耗资源，效率比较低。

3，第二种方案：同步方法来解决。同步方法的对象是当前创建的对象（this）
例如：

      private int ticket = 100;

      @Override
      public void run() {
          while (true) {
              payticket();
          }
      }

      public synchronized  void payticket()
      {
          if (ticket > 0) {
              //提高安全问题出现的频率
              try {
                  Thread.sleep(20);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
                  System.out.println(Thread.currentThread().getName() + "售出" + ticket--);
              }
          }

3，第三种方案：静态同步方法：锁对象是本类所在的所有对象:注意的是，静态方法只能访问静态变量。描述的对象为：(类.class)

举例：

      private static int ticket = 100;

      @Override
      public void run() {
          while (true) {
              payticketstatic();
          }
      }
      public  static synchronized  void payticketstatic()
      {
          if (ticket > 0) {
              //提高安全问题出现的频率
              try {
                  Thread.sleep(20);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
                  System.out.println(Thread.currentThread().getName() + "售出" + ticket--);
              }
          }

4，解决线程安全的方案四：lock锁;（上锁：lock() ）(释放锁 (unlock() ))，注意的是，这里要导入的类有两个
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

举例：

   //创建锁对象
      Lock l = new ReentrantLock();

      private int ticket = 100;

      @Override
      public void run() {
          while (true) {

              //上锁
              l.lock();
              if (ticket > 0) {
                  //提高安全问题出现的频率
                  try {
                      Thread.sleep(20);
                      System.out.println(Thread.currentThread().getName() + "售出" + ticket--);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  //这里加上finally，表示无论程序是否异常，都会释放锁，提高程序效率
                  finally {
                      //释放锁
                      l.unlock();
                  }

                  }

              }