Java线程安全
一个程序在运行起来的时候会转换成进程，通常含有多个线程。
通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。
比如显示生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。
当进程中有多个并发线程进入一个重要数据的代码块时，在修改数据的过程中，很有可能引发线程安全问题，从而造成数据异常。例如，正常逻辑下，同一个编号的火车票只能售出一次，却由于线程安全问题而被多次售出，从而引起实际业务异常。现在就以售票问题来演示线程安全的问题

在不对多线程数据进行保护的情况下会引发的状况

  1. public class ThreadUnSecurity {
  3.     static int tickets = 10;
  5.     class SellTickets implements Runnable{
  7.         @Override
  8.         public void run() {
  9.             // 未加同步时产生脏数据
  10.             while(tickets > 0) {
  12.                 System.out.println(Thread.currentThread().getName()+"--->售出第：  "+tickets+" 票");
  13.                 tickets--;
  15.                 try {
  16.                     Thread.sleep(1000);
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  21.             }
  23.             if (tickets <= 0) {
  25.                 System.out.println(Thread.currentThread().getName()+"--->售票结束！");
  26.             }
  27.         }
  28.     }
  31.     public static void main(String[] args) {
  34.         SellTickets sell = new ThreadUnSecurity().new SellTickets();
  36.         Thread thread1 = new Thread(sell, "1号窗口");
  37.         Thread thread2 = new Thread(sell, "2号窗口");
  38.         Thread thread3 = new Thread(sell, "3号窗口");
  39.         Thread thread4 = new Thread(sell, "4号窗口");
  41.         thread1.start();
  42.         thread2.start();
  43.         thread3.start();
  44.         thread4.start();
  47.     }
  48. }

上述代码运行的结果：

  1. 1号窗口--->售出第：  10 票
  2. 3号窗口--->售出第：  10 票
  3. 2号窗口--->售出第：  10 票
  4. 4号窗口--->售出第：  10 票
  5. 2号窗口--->售出第：  6 票
  6. 1号窗口--->售出第：  5 票
  7. 3号窗口--->售出第：  4 票
  8. 4号窗口--->售出第：  3 票
  9. 2号窗口--->售出第：  2 票
  10. 4号窗口--->售出第：  1 票
  11. 1号窗口--->售出第：  1 票
  12. 3号窗口--->售票结束！
  13. 2号窗口--->售票结束！
  14. 1号窗口--->售票结束！
  15. 4号窗口--->售票结束！

可以看出同一张票在不对票数进行保护时会出现同一张票会被出售多次！由于线程调度中的不确定性，在演示上述代码时，出现的运行结果会有不同。

第一种方式：同步代码块

  1. package com.bpan.spring.beans.thread;
  3. import com.sun.org.apache.regexp.internal.recompile;
  5. public class ThreadSynchronizedSecurity {
  7.     static int tickets = 10;
  9.     class SellTickets implements Runnable{
  11.         @Override
  12.         public void run() {
  13.             // 同步代码块
  14.             while(tickets > 0) {
  16.                 synchronized (this) {
  18. //                    System.out.println(this.getClass().getName().toString());
  20.                     if (tickets <= 0) {
  22.                         return;
  23.                     }
  25.                     System.out.println(Thread.currentThread().getName()+"--->售出第：  "+tickets+" 票");
  26.                     tickets--;
  28.                     try {
  29.                         Thread.sleep(100);
  30.                     } catch (InterruptedException e) {
  31.                         e.printStackTrace();
  32.                     }
  33.                 }
  35.                 if (tickets <= 0) {
  37.                     System.out.println(Thread.currentThread().getName()+"--->售票结束！");
  38.                 }
  39.             }
  40.         }
  41.     }
  44.     public static void main(String[] args) {
  47.         SellTickets sell = new ThreadSynchronizedSecurity().new SellTickets();
  49.         Thread thread1 = new Thread(sell, "1号窗口");
  50.         Thread thread2 = new Thread(sell, "2号窗口");
  51.         Thread thread3 = new Thread(sell, "3号窗口");
  52.         Thread thread4 = new Thread(sell, "4号窗口");
  54.         thread1.start();
  55.         thread2.start();
  56.         thread3.start();
  57.         thread4.start();
  60.     }
  63. }

输出结果读者可自行调试，不会出现同一张票被出售多次的情况。

第二种方式：同步方法

  1. package com.bpan.spring.beans.thread;
  3. public class ThreadSynchroniazedMethodSecurity {
  6.     static int tickets = 10;
  8.     class SellTickets implements Runnable{
  10.         @Override
  11.         public void run() {
  12.             //同步方法
  13.             while (tickets > 0) {
  15.                 synMethod();
  17.                 try {
  18.                     Thread.sleep(100);
  19.                 } catch (InterruptedException e) {
  20.                     // TODO Auto-generated catch block
  21.                     e.printStackTrace();
  22.                 }
  24.                 if (tickets<=0) {
  26.                     System.out.println(Thread.currentThread().getName()+"--->售票结束");
  27.                 }
  29.             }
  32.         }
  34.         synchronized void synMethod() {
  36.             synchronized (this) {
  37.                 if (tickets <=0) {
  39.                     return;
  40.                 }
  42.                 System.out.println(Thread.currentThread().getName()+"---->售出第 "+tickets+" 票 ");
  43.                 tickets-- ;
  44.             }
  46.         }
  48.     }
  49.     public static void main(String[] args) {
  52.         SellTickets sell = new ThreadSynchroniazedMethodSecurity().new SellTickets();
  54.         Thread thread1 = new Thread(sell, "1号窗口");
  55.         Thread thread2 = new Thread(sell, "2号窗口");
  56.         Thread thread3 = new Thread(sell, "3号窗口");
  57.         Thread thread4 = new Thread(sell, "4号窗口");
  59.         thread1.start();
  60.         thread2.start();
  61.         thread3.start();
  62.         thread4.start();
  64.     }
  66. }

可自行调试上述代码的运行结果。

第三种方式：Lock锁机制

通过创建Lock对象，采用lock()加锁，unlock()解锁，来保护指定的代码块

  1. package com.bpan.spring.beans.thread;
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  6. public class ThreadLockSecurity {
  8.     static int tickets = 10;
  10.     class SellTickets implements Runnable{
  12.         Lock lock = new ReentrantLock();
  14.         @Override
  15.         public void run() {
  16.             // Lock锁机制
  17.             while(tickets > 0) {
  19.                 try {
  20.                     lock.lock();
  22.                     if (tickets <= 0) {
  24.                         return;
  25.                     }
  27.                     System.out.println(Thread.currentThread().getName()+"--->售出第：  "+tickets+" 票");
  28.                     tickets--;
  29.                 } catch (Exception e1) {
  30.                     // TODO Auto-generated catch block
  31.                     e1.printStackTrace();
  32.                 }finally {
  34.                     lock.unlock();
  35.                     try {
  36.                         Thread.sleep(100);
  37.                     } catch (InterruptedException e) {
  38.                         e.printStackTrace();
  39.                     }
  40.                 }
  41.             }
  43.             if (tickets <= 0) {
  45.                 System.out.println(Thread.currentThread().getName()+"--->售票结束！");
  46.             }
  48.         }
  49.     }
  52.     public static void main(String[] args) {
  55.         SellTickets sell = new ThreadLockSecurity().new SellTickets();
  57.         Thread thread1 = new Thread(sell, "1号窗口");
  58.         Thread thread2 = new Thread(sell, "2号窗口");
  59.         Thread thread3 = new Thread(sell, "3号窗口");
  60.         Thread thread4 = new Thread(sell, "4号窗口");
  62.         thread1.start();
  63.         thread2.start();
  64.         thread3.start();
  65.         thread4.start();
  67.     }
  68. }

最后总结

由于synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否；而ReentrantLock是使用代码实现的，系统无法自动释放锁，需要在代码中的finally子句中显式释放锁lock.unlock()。
另外，在并发量比较小的情况下，使用synchronized是个不错的选择；但是在并发量比较高的情况下，其性能下降会很严重，此时ReentrantLock是个不错的方案。

补充

在使用synchronized 代码块时，可以与wait()、notify()、nitifyAll()一起使用，从而进一步实现线程的通信。
其中，wait()方法会释放占有的对象锁，当前线程进入等待池，释放cpu，而其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序；
线程的sleep()方法则表示，当前线程会休眠一段时间，休眠期间，会暂时释放cpu，但并不释放对象锁，也就是说，在休眠期间，其他线程依然无法进入被同步保护的代码内部，当前线程休眠结束时，会重新获得cpu执行权，从而执行被同步保护的代码。
wait()和sleep()最大的不同在于wait()会释放对象锁，而sleep()不会释放对象锁。
notify()方法会唤醒因为调用对象的wait()而处于等待状态的线程，从而使得该线程有机会获取对象锁。调用notify()后，当前线程并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，才会释放对象锁。JVM会在等待的线程中调度一个线程去获得对象锁，执行代码。
需要注意的是，wait()和notify()必须在synchronized代码块中调用。
notifyAll()是唤醒所有等待的线程。
下面是示例代码，

  1. package com.bpan.spring.beans.thread;
  3. public class ThreadDemo {
  5.     static final Object obj = new Object();
  7.     //第一个子线程
  8.     static class ThreadA implements Runnable{
  10.         @Override
  11.         public void run() {
  14.             int count = 10;
  15.             while(count > 0) {
  17.                 synchronized (ThreadDemo.obj) {
  19.                     System.out.println("A-----"+count);
  20.                     count--;
  22.                     synchronized (ThreadDemo.obj) {
  24.                         //notify()方法会唤醒因为调用对象的wait()而处于等待状态的线程，从而使得该线程有机会获取对象锁。
  25.                         //调用notify()后，当前线程并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，
  26.                         ThreadDemo.obj.notify();
  28.                         try {
  29.                             ThreadDemo.obj.wait();
  30.                         } catch (InterruptedException e) {
  31.                             // TODO Auto-generated catch block
  32.                             e.printStackTrace();
  33.                         }
  34.                     }
  35.                 }
  36.             }
  38.         }
  40.     }
  42.     static class ThreadB implements Runnable{
  45.         @Override
  46.         public void run() {
  48.             int count = 10;
  50.             while(count > 0) {
  52.                 synchronized (ThreadDemo.obj) {
  53.                     System.out.println("B-----"+count);
  54.                     count--;
  56.                     synchronized (ThreadDemo.obj) {
  58.                         //notify()方法会唤醒因为调用对象的wait()而处于等待状态的线程，从而使得该线程有机会获取对象锁。
  59.                         //调用notify()后，当前线程并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，
  60.                         ThreadDemo.obj.notify();
  62.                         try {
  63.                             ThreadDemo.obj.wait();
  64.                         } catch (InterruptedException e) {
  65.                             // TODO Auto-generated catch block
  66.                             e.printStackTrace();
  67.                         }
  68.                     }
  70.                 }
  72.             }
  74.         }
  76.     }
  78.     public static void main(String[] args) {
  79.         new Thread(new ThreadA()).start();
  80.         new Thread(new ThreadB()).start();
  81.     }
  82. }