线程锁

线程在执行的过程中，容易出现安全问题，除了线程死锁外，所谓的安全问题就是：

     对需要同步的变量进行多线程操作时，会使变量的判定发生问题,比如卖票的问题可能出现0票或者-1，-2的情况，

那么我们就需要一个锁来对需要同步的变量或者方法进行标记，指示：

     该变量或方法在某个时刻或时间段只能被一个线程所执行

//错误代码演示:
public class ThreadDemo implements Runnable {
     //创建线程的第一种方式：继承Thread类
     private int ticket =100;
     Object object = new Object();
     @Override
     public void run() {
          while(true) {
              if (ticket>0) {
                   try {
                        Thread.sleep(10);
                   } catch (Exception e) {}
               System.out.println(Thread.currentThread().getName()+"-----"+ticket--);
              }
          }
     }
}

//正确代码演示：
public class ThreadDemo implements Runnable {
     //创建线程的第一种方式：继承Thread类
     private int ticket =100;
     Object object = new Object();
     @Override
     public void run() {
          while(true) {
              synchronized (object) {
                   if (ticket>0) {
                        try {
                             Thread.sleep(10);
                        } catch (Exception e) {
                        }
                        System.out.println(Thread.currentThread().getName()+"-----"+ticket--);
                   }
              }
          }
     }
}

线程所使用的锁是有不同的，

在普通的方法或者同步代码块中：

     当方法是非静态的，锁指的是调用这个方法的对象本身，也就是this；

     当方法是静态的，锁指的是该方法所在类的字节码对象，也就是类名.class

 

演示同步代码块和同步函数的使用方法:

//同步代码块的使用：
public void run() {
          while(true) {
               //锁this指的是调用本方法的类实例对象
              synchronized (this) {
                   if (ticket>0) {
                        try {
                             Thread.sleep(10);
                             //线程休眠是为了看清同步的效果，有没有产生错误的票号
                        } catch (Exception e) {
                        }
                        System.out.println(Thread.currentThread().getName()+"-----"+ticket--);
                   }
              }
          }
     }

//同步函数的使用：
public class ThreadDemo implements Runnable {
     private int ticket =100;
     @Override
     public void run() {
          while(true) {
              synchMethod();
          }
     }
     public synchronized void synchMethod() {
          if (ticket>0) {
              try {
                   Thread.sleep(10);
                   //线程休眠是为了看清同步的效果，有没有产生错误的票号
              } catch (Exception e) {
              }
               System.out.println(Thread.currentThread().getName()+"-----"+ticket--);
          }
     }
}

//当同步的方法是静态的时候，锁使用的是本类的字节码对象：类名.class
public class ThreadDemo implements Runnable {
     //这时候静态方法使用的变量也要是静态的
     private static  int ticket =100;
     @Override
     public void run() {
          while(true) {
              synchMethod();
          }
     }
     public static synchronized void synchMethod() {
          if (ticket>0) {
              try {
                   Thread.sleep(10);
                   //线程休眠是为了看清同步的效果，有没有产生错误的票号
              } catch (Exception e) {
              }
               System.out.println(Thread.currentThread().getName()+"-----"+ticket--);
          }
     }
}